/*
* Copyright (c) 2001-2002 Packet Design, LLC.
* All rights reserved.
*
* Subject to the following obligations and disclaimer of warranty,
* use and redistribution of this software, in source or object code
* forms, with or without modifications are expressly permitted by
* Packet Design; provided, however, that:
*
* (i) Any and all reproductions of the source or object code
* must include the copyright notice above and the following
* disclaimer of warranties; and
* (ii) No rights are granted, in any manner or form, to use
* Packet Design trademarks, including the mark "PACKET DESIGN"
* on advertising, endorsements, or otherwise except as such
* appears in the above copyright notice or in the software.
*
* THIS SOFTWARE IS BEING PROVIDED BY PACKET DESIGN "AS IS", AND
* TO THE MAXIMUM EXTENT PERMITTED BY LAW, PACKET DESIGN MAKES NO
* REPRESENTATIONS OR WARRANTIES, EXPRESS OR IMPLIED, REGARDING
* THIS SOFTWARE, INCLUDING WITHOUT LIMITATION, ANY AND ALL IMPLIED
* WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE,
* OR NON-INFRINGEMENT. PACKET DESIGN DOES NOT WARRANT, GUARANTEE,
* OR MAKE ANY REPRESENTATIONS REGARDING THE USE OF, OR THE RESULTS
* OF THE USE OF THIS SOFTWARE IN TERMS OF ITS CORRECTNESS, ACCURACY,
* RELIABILITY OR OTHERWISE. IN NO EVENT SHALL PACKET DESIGN BE
* LIABLE FOR ANY DAMAGES RESULTING FROM OR ARISING OUT OF ANY USE
* OF THIS SOFTWARE, INCLUDING WITHOUT LIMITATION, ANY DIRECT,
* INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, PUNITIVE, OR CONSEQUENTIAL
* DAMAGES, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, LOSS OF
* USE, DATA OR PROFITS, HOWEVER CAUSED AND UNDER ANY THEORY OF
* LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
* THE USE OF THIS SOFTWARE, EVEN IF PACKET DESIGN IS ADVISED OF
* THE POSSIBILITY OF SUCH DAMAGE.
*
* Author: Archie Cobbs <archie@freebsd.org>
*/
#include "ppp/ppp_defs.h"
#include "ppp/ppp_log.h"
#include "ppp/ppp_fsm_option.h"
#include "ppp/ppp_fsm.h"
#include "ppp/ppp_auth.h"
#include "ppp/ppp_node.h"
#include "ppp/ppp_ccp.h"
#include <netgraph/ng_mppc.h>
#ifndef MPPE_56
#define MPPE_56 0x00000080
#undef MPPE_BITS
#define MPPE_BITS 0x000000e0
#endif
/*
* CCP FSM
*
* XXX This is hard coded to only support MPPC/MPPE compression.
* XXX It should be generalized to support multiple PPP compression types.
*/
#define MPPC_SUPPORTED (MPPC_BIT | MPPE_BITS | MPPE_STATELESS)
/* Memory type */
#define CCP_MTYPE "ccp"
/* CCP compression types */
enum ccp_type {
CCP_OPT_OUI =0, /* oui */
CCP_OPT_PRED1 =1, /* predictor type 1 */
CCP_OPT_PRED2 =2, /* predictor type 2 */
CCP_OPT_PUDDLE =3, /* puddle jumper */
CCP_OPT_HWPPC =16, /* hewlett-packard ppc */
CCP_OPT_STAC =17, /* stac electronics lzs */
CCP_OPT_MPPC =18, /* microsoft mppc/mppe */
CCP_OPT_GAND =19, /* gandalf fza */
CCP_OPT_V42BIS =20, /* v.42bis compression */
CCP_OPT_BSD =21, /* bsd lzw compress */
CCP_OPT_DEFLATE =24, /* gzip "deflate" compression */
};
/* Supported and required FSM codes */
#define CCP_SUPPORTED_CODES \
(1 << FSM_CODE_CONFIGREQ) \
| (1 << FSM_CODE_CONFIGACK) \
| (1 << FSM_CODE_CONFIGNAK) \
| (1 << FSM_CODE_CONFIGREJ) \
| (1 << FSM_CODE_TERMREQ) \
| (1 << FSM_CODE_TERMACK) \
| (1 << FSM_CODE_CODEREJ) \
| (1 << FSM_CODE_RESETREQ) \
| (1 << FSM_CODE_RESETACK)
#define CCP_REQUIRED_CODES \
(1 << FSM_CODE_CONFIGREQ) \
| (1 << FSM_CODE_CONFIGACK) \
| (1 << FSM_CODE_CONFIGNAK) \
| (1 << FSM_CODE_CONFIGREJ) \
| (1 << FSM_CODE_TERMREQ) \
| (1 << FSM_CODE_TERMACK) \
| (1 << FSM_CODE_CODEREJ) \
| (1 << FSM_CODE_RESETREQ) \
| (1 << FSM_CODE_RESETACK)
/* FSM options descriptors */
static opt_pr_t ppp_cpp_pr_mppc;
static const struct ppp_fsm_optdesc ccp_opt_desc[] = {
{ "OUI", CCP_OPT_OUI, 0, 255, 0, NULL },
{ "Predictor-1",CCP_OPT_PRED1, 0, 255, 0, NULL },
{ "Predictor-2",CCP_OPT_PRED2, 0, 255, 0, NULL },
{ "Puddle", CCP_OPT_PUDDLE, 0, 255, 0, NULL },
{ "HWPPC", CCP_OPT_HWPPC, 0, 255, 0, NULL },
{ "Stac", CCP_OPT_STAC, 0, 255, 0, NULL },
{ "MPPC/MPPE", CCP_OPT_MPPC, 4, 4, 1, ppp_cpp_pr_mppc },
{ "Gandalf", CCP_OPT_GAND, 0, 255, 0, NULL },
{ "v.42bis", CCP_OPT_V42BIS, 0, 255, 0, NULL },
{ "BSD-LZW", CCP_OPT_BSD, 0, 255, 0, NULL },
{ "Deflate", CCP_OPT_DEFLATE,0, 255, 0, NULL },
{ NULL, 0, 0, 0, 0, NULL }
};
/* FSM type for CCP */
static ppp_fsm_type_destroy_t ppp_ccp_destroy;
static ppp_fsm_type_build_conf_req_t ppp_ccp_build_conf_req;
static ppp_fsm_type_recv_conf_req_t ppp_ccp_recv_conf_req;
static ppp_fsm_type_recv_conf_rej_t ppp_ccp_recv_conf_rej;
static ppp_fsm_type_recv_conf_nak_t ppp_ccp_recv_conf_nak;
static ppp_fsm_type_recv_reset_req_t ppp_ccp_recv_reset_req;
static ppp_fsm_type_recv_reset_ack_t ppp_ccp_recv_reset_ack;
const struct ppp_fsm_type ppp_fsm_ccp = {
"CCP",
PPP_PROTO_CCP,
CCP_SUPPORTED_CODES,
CCP_REQUIRED_CODES,
ccp_opt_desc,
NULL,
ppp_ccp_destroy,
ppp_ccp_build_conf_req,
ppp_ccp_recv_conf_req,
ppp_ccp_recv_conf_rej,
ppp_ccp_recv_conf_nak,
NULL,
ppp_ccp_recv_reset_req,
ppp_ccp_recv_reset_ack,
NULL
};
/* CCP instance state */
struct ccp {
struct ppp_fsm_instance *inst; /* backpointer to instance */
struct ppp_ccp_config conf; /* initial config */
struct ppp_ccp_req req; /* current request state */
struct ppp_node *node; /* ng_ppp(4) node */
};
/* Internal functions */
static ppp_node_recvmsg_t ppp_ccp_send_reset_req;
/***********************************************************************
PUBLIC FUNCTIONS
***********************************************************************/
struct ppp_fsm_instance *
ppp_ccp_create(struct ppp_ccp_config *conf, struct ppp_node *node)
{
struct ppp_fsm_instance *inst;
struct ppp_ccp_req *req;
struct ccp *ccp = NULL;
/* Construct instance object */
if ((inst = MALLOC(CCP_MTYPE, sizeof(*inst))) == NULL)
return (NULL);
memset(inst, 0, sizeof(*inst));
inst->type = &ppp_fsm_ccp;
/* Attach private data */
if ((ccp = MALLOC(CCP_MTYPE, sizeof(*ccp))) == NULL)
goto fail;
memset(ccp, 0, sizeof(*ccp));
ccp->conf = *conf;
ccp->node = node;
ccp->inst = inst;
inst->arg = ccp;
/* Initialize local request state */
req = &ccp->req;
req->mppc[PPP_SELF] = conf->mppc[PPP_SELF];
req->mppe40[PPP_SELF] = conf->mppe40[PPP_SELF];
req->mppe56[PPP_SELF] = conf->mppe56[PPP_SELF];
req->mppe128[PPP_SELF] = conf->mppe128[PPP_SELF];
req->mppe_stateless[PPP_SELF] = conf->mppe_stateless[PPP_SELF];
/* Register handler for reset-req control message from ng_mppc(4) */
if (ppp_node_set_recvmsg(ccp->node, NGM_MPPC_COOKIE,
NGM_MPPC_RESETREQ, ppp_ccp_send_reset_req, ccp) == -1)
goto fail;
/* Done */
return (inst);
fail:
/* Clean up after failure */
if (ccp != NULL)
FREE(CCP_MTYPE, ccp);
FREE(CCP_MTYPE, inst);
return (NULL);
}
/*
* Get CCP request state.
*/
void
ppp_ccp_get_req(struct ppp_fsm *fsm, struct ppp_ccp_req *req)
{
struct ppp_fsm_instance *const inst = ppp_fsm_get_instance(fsm);
struct ccp *const ccp = inst->arg;
assert(inst->type == &ppp_fsm_ccp);
memcpy(req, &ccp->req, sizeof(*req));
}
/***********************************************************************
FSM CALLBACKS
***********************************************************************/
static void
ppp_ccp_destroy(struct ppp_fsm_instance *inst)
{
struct ccp *const ccp = inst->arg;
ppp_node_set_recvmsg(ccp->node,
NGM_MPPC_COOKIE, NGM_MPPC_RESETREQ, NULL, NULL);
FREE(CCP_MTYPE, ccp);
FREE(CCP_MTYPE, inst);
}
static int
ppp_ccp_build_conf_req(struct ppp_fsm_instance *fsm,
struct ppp_fsm_options *opts)
{
struct ccp *const ccp = (struct ccp *)fsm->arg;
struct ppp_ccp_req *const req = &ccp->req;
u_int32_t mppo = 0;
/* Add MPPC/MPPE requested config options */
if (req->mppc[PPP_SELF])
mppo |= MPPC_BIT;
if (req->mppe40[PPP_SELF])
mppo |= MPPE_40;
if (req->mppe56[PPP_SELF])
mppo |= MPPE_56;
if (req->mppe128[PPP_SELF])
mppo |= MPPE_128;
if (req->mppe_stateless[PPP_SELF])
mppo |= MPPE_STATELESS;
/* If no options left to try, don't ask for anything */
if ((mppo & (MPPC_BIT | MPPE_BITS)) == 0) {
errno = EINVAL;
return (-1);
}
/* Add option */
mppo = htonl(mppo);
if (ppp_fsm_option_add(opts, CCP_OPT_MPPC, 4, &mppo) == -1)
return (-1);
/* Done */
return (0);
}
static int
ppp_ccp_recv_conf_req(struct ppp_fsm_instance *fsm,
struct ppp_fsm_options *crq, struct ppp_fsm_options *nak,
struct ppp_fsm_options *rej)
{
struct ccp *const ccp = (struct ccp *)fsm->arg;
struct ppp_ccp_config *const conf = &ccp->conf;
struct ppp_ccp_req *const req = &ccp->req;
int i;
/* Initialize peer's request state */
req->mppc[PPP_PEER] = 0;
req->mppe40[PPP_PEER] = 0;
req->mppe56[PPP_PEER] = 0;
req->mppe128[PPP_PEER] = 0;
req->mppe_stateless[PPP_PEER] = 0;
/* Process options */
for (i = 0; i < crq->num; i++) {
const struct ppp_fsm_option *const opt = &crq->opts[i];
switch (opt->type) {
case CCP_OPT_MPPC:
{
u_int32_t obits;
u_int32_t bits;
/* Get requested bits */
memcpy(&obits, opt->data, 4);
obits = ntohl(obits);
bits = obits;
/* Filter out bits we can't handle */
bits &= MPPC_SUPPORTED;
if ((bits & MPPC_BIT) != 0 && !conf->mppc[PPP_PEER])
bits &= ~MPPC_BIT;
if ((bits & MPPE_40) != 0 && !conf->mppe40[PPP_PEER])
bits &= ~MPPE_40;
if ((bits & MPPE_56) != 0 && !conf->mppe56[PPP_PEER])
bits &= ~MPPE_56;
if ((bits & MPPE_128) != 0 && !conf->mppe128[PPP_PEER])
bits &= ~MPPE_128;
if ((bits & MPPE_STATELESS) != 0
&& !conf->mppe_stateless[PPP_PEER])
bits &= ~MPPE_STATELESS;
/*
* It doesn't really make sense to do MPPE encryption
* in only one direction. Also, Win95/98 PPTP can't
* handle uni-directional encryption. So if the remote
* side doesn't request encryption, try to prompt it.
* This is broken wrt. normal PPP negotiation: typical
* Microsoft.
*/
if ((bits & MPPE_BITS) == 0) {
if (req->mppe40[PPP_SELF])
bits |= MPPE_40;
if (req->mppe56[PPP_SELF])
bits |= MPPE_56;
if (req->mppe128[PPP_SELF])
bits |= MPPE_128;
}
/* Make sure we're not left with no options */
if ((bits & MPPE_BITS) == 0) {
if (ccp->conf.mppe40[PPP_SELF])
bits |= MPPE_40;
if (ccp->conf.mppe56[PPP_SELF])
bits |= MPPE_56;
if (ccp->conf.mppe128[PPP_SELF])
bits |= MPPE_128;
}
/* Now choose the strongest encryption available */
if ((bits & MPPE_128) != 0)
bits &= ~(MPPE_56|MPPE_40);
else if ((bits & MPPE_56) != 0)
bits &= ~(MPPE_128|MPPE_40);
else if ((bits & MPPE_40) != 0)
bits &= ~(MPPE_128|MPPE_56);
/* Send back a nak if there were any changes */
if (bits != obits) {
bits = htonl(bits);
if (ppp_fsm_option_add(nak,
opt->type, 4, &bits) == -1)
return (-1);
break;
}
/* Peer's request is accepted */
req->mppc[PPP_PEER] = (bits & MPPC_BIT) != 0;
req->mppe40[PPP_PEER] = (bits & MPPE_40) != 0;
req->mppe56[PPP_PEER] = (bits & MPPE_56) != 0;
req->mppe128[PPP_PEER] = (bits & MPPE_128) != 0;
req->mppe_stateless[PPP_PEER]
= (bits & MPPE_STATELESS) != 0;
break;
}
default:
goto reject;
}
/* OK */
continue;
reject:
/* Reject this requested option */
if (ppp_fsm_option_add(rej,
opt->type, opt->len, opt->data) == -1)
return (-1);
}
/* If there were no options, shut down */
if (crq->num == 0) {
errno = EINVAL;
return (-1);
}
/* Done */
return (0);
}
static int
ppp_ccp_recv_conf_rej(struct ppp_fsm_instance *fsm,
struct ppp_fsm_options *rej)
{
int i;
for (i = 0; i < rej->num; i++) {
const struct ppp_fsm_option *const opt = &rej->opts[i];
switch (opt->type) {
case CCP_OPT_MPPC:
errno = EINVAL;
return (-1);
default:
break;
}
}
/* Done */
return (0);
}
static int
ppp_ccp_recv_conf_nak(struct ppp_fsm_instance *fsm,
struct ppp_fsm_options *nak)
{
struct ccp *const ccp = (struct ccp *)fsm->arg;
struct ppp_ccp_req *const req = &ccp->req;
int i;
for (i = 0; i < nak->num; i++) {
const struct ppp_fsm_option *const opt = &nak->opts[i];
switch (opt->type) {
case CCP_OPT_MPPC:
{
u_int32_t bits;
memcpy(&bits, opt->data, 4);
bits = ntohl(bits);
/* Mask away bits the client didn't like */
if ((bits & MPPC_BIT) == 0)
req->mppc[PPP_SELF] = 0;
if ((bits & MPPE_40) == 0)
req->mppe40[PPP_SELF] = 0;
if ((bits & MPPE_56) == 0)
req->mppe56[PPP_SELF] = 0;
if ((bits & MPPE_128) == 0)
req->mppe128[PPP_SELF] = 0;
if ((bits & MPPE_STATELESS) == 0)
req->mppe_stateless[PPP_SELF] = 0;
/* Make sure we're not left with no options */
if ((bits & MPPE_BITS) == 0) {
if (ccp->conf.mppe40[PPP_SELF])
bits |= MPPE_40;
if (ccp->conf.mppe56[PPP_SELF])
bits |= MPPE_56;
if (ccp->conf.mppe128[PPP_SELF])
bits |= MPPE_128;
}
break;
}
default:
break;
}
}
/* Done */
return (0);
}
/*
* Receive a Reset-Req from peer. Relay request to the ng_mppc(4) node.
*/
static void
ppp_ccp_recv_reset_req(struct ppp_fsm_instance *fsm,
const u_char *data, u_int len)
{
struct ccp *const ccp = (struct ccp *)fsm->arg;
ppp_node_send_msg(ccp->node, NG_PPP_HOOK_COMPRESS,
NGM_MPPC_COOKIE, NGM_MPPC_RESETREQ, NULL, 0);
}
/*
* Receive a Reset-Ack.
*/
static void
ppp_ccp_recv_reset_ack(struct ppp_fsm_instance *fsm,
const u_char *data, u_int len)
{
return; /* not used by MPPC/MPPE, just ignore it */
}
/***********************************************************************
INTERNAL FUNCTIONS
***********************************************************************/
static void
ppp_ccp_send_reset_req(void *arg, struct ng_mesg *msg)
{
struct ccp *const ccp = arg;
struct ppp_fsm *const fsm = ccp->inst->fsm;
ppp_fsm_send_reset_req(fsm, NULL, 0);
}
static void
ppp_cpp_pr_mppc(const struct ppp_fsm_optdesc *desc,
const struct ppp_fsm_option *opt, char *buf, size_t bmax)
{
static const struct {
u_int32_t bit;
const char *name;
} mppe_bits[] = {
{ MPPC_BIT, "MPPC" },
{ MPPE_BITS, "MPPE" },
{ MPPE_40, "40 bit" },
{ MPPE_56, "56 bit" },
{ MPPE_128, "128 bit" },
{ MPPE_STATELESS, "stateless" },
{ 0 }
};
u_int32_t mppo;
int first;
int i;
if (opt->len < 4) {
snprintf(buf, bmax, "<truncated>");
return;
}
memcpy(&mppo, opt->data, 4);
mppo = ntohl(mppo);
*buf = '\0';
for (first = 1, i = 0; mppe_bits[i].bit != 0; i++) {
if ((mppo & mppe_bits[i].bit) != 0) {
snprintf(buf + strlen(buf), bmax - strlen(buf),
"%s%s", first ? "" : ", ", mppe_bits[i].name);
first = 0;
}
}
}
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to ppp_ccp.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / libpdel / ppp