Annotation of embedaddon/mpd/src/ipcp.c, revision 1.1
1.1 ! misho 1:
! 2: /*
! 3: * ipcp.c
! 4: *
! 5: * Written by Toshiharu OHNO <tony-o@iij.ad.jp>
! 6: * Copyright (c) 1993, Internet Initiative Japan, Inc. All rights reserved.
! 7: * See ``COPYRIGHT.iij''
! 8: *
! 9: * Rewritten by Archie Cobbs <archie@freebsd.org>
! 10: * Copyright (c) 1995-1999 Whistle Communications, Inc. All rights reserved.
! 11: * See ``COPYRIGHT.whistle''
! 12: */
! 13:
! 14: #include "ppp.h"
! 15: #include "ipcp.h"
! 16: #include "fsm.h"
! 17: #include "ip.h"
! 18: #include "iface.h"
! 19: #include "msg.h"
! 20: #include "ngfunc.h"
! 21: #include "ippool.h"
! 22: #include "util.h"
! 23:
! 24: #include <netgraph.h>
! 25: #include <sys/mbuf.h>
! 26: #ifdef USE_NG_VJC
! 27: #include <net/slcompress.h>
! 28: #include <netgraph/ng_vjc.h>
! 29: #endif
! 30:
! 31: /*
! 32: * DEFINITIONS
! 33: */
! 34:
! 35: #define IPCP_KNOWN_CODES ( (1 << CODE_CONFIGREQ) \
! 36: | (1 << CODE_CONFIGACK) \
! 37: | (1 << CODE_CONFIGNAK) \
! 38: | (1 << CODE_CONFIGREJ) \
! 39: | (1 << CODE_TERMREQ) \
! 40: | (1 << CODE_TERMACK) \
! 41: | (1 << CODE_CODEREJ) )
! 42:
! 43: #define TY_IPADDRS 1
! 44: #define TY_COMPPROTO 2
! 45: #define TY_IPADDR 3
! 46: #define TY_PRIMARYDNS 129
! 47: #define TY_PRIMARYNBNS 130
! 48: #define TY_SECONDARYDNS 131
! 49: #define TY_SECONDARYNBNS 132
! 50:
! 51: /* Keep sync with above */
! 52: #define o2b(x) (((x)<128)?(x):(x)-128+3)
! 53:
! 54: #define IPCP_REJECTED(p,x) ((p)->peer_reject & (1<<o2b(x)))
! 55: #define IPCP_PEER_REJ(p,x) do{(p)->peer_reject |= (1<<o2b(x));}while(0)
! 56:
! 57: #ifdef USE_NG_VJC
! 58: #define IPCP_VJCOMP_MIN_MAXCHAN (NG_VJC_MIN_CHANNELS - 1)
! 59: #define IPCP_VJCOMP_MAX_MAXCHAN (NG_VJC_MAX_CHANNELS - 1)
! 60: #define IPCP_VJCOMP_DEFAULT_MAXCHAN IPCP_VJCOMP_MAX_MAXCHAN
! 61: #endif
! 62:
! 63: /* Set menu options */
! 64: enum {
! 65: SET_RANGES,
! 66: SET_ENABLE,
! 67: SET_DNS,
! 68: SET_NBNS,
! 69: SET_DISABLE,
! 70: SET_ACCEPT,
! 71: SET_DENY,
! 72: SET_YES,
! 73: SET_NO
! 74: };
! 75:
! 76: /*
! 77: * INTERNAL FUNCTIONS
! 78: */
! 79:
! 80: static void IpcpConfigure(Fsm fp);
! 81: static void IpcpUnConfigure(Fsm fp);
! 82:
! 83: static u_char *IpcpBuildConfigReq(Fsm fp, u_char *cp);
! 84: static void IpcpDecodeConfig(Fsm fp, FsmOption list, int num, int mode);
! 85: static void IpcpLayerStart(Fsm fp);
! 86: static void IpcpLayerFinish(Fsm fp);
! 87: static void IpcpLayerUp(Fsm fp);
! 88: static void IpcpLayerDown(Fsm fp);
! 89: static void IpcpFailure(Fsm fp, enum fsmfail reason);
! 90:
! 91: #ifdef USE_NG_VJC
! 92: static int IpcpNgInitVJ(Bund b);
! 93: static void IpcpNgShutdownVJ(Bund b);
! 94: #endif
! 95:
! 96: static int IpcpSetCommand(Context ctx, int ac, char *av[], void *arg);
! 97:
! 98: /*
! 99: * GLOBAL VARIABLES
! 100: */
! 101:
! 102: const struct cmdtab IpcpSetCmds[] = {
! 103: { "ranges {self}[/{width}]|ippool {pool} {peer}[/{width}]|ippool {pool}", "Allowed IP address ranges",
! 104: IpcpSetCommand, NULL, 2, (void *) SET_RANGES },
! 105: { "enable [opt ...]", "Enable option",
! 106: IpcpSetCommand, NULL, 2, (void *) SET_ENABLE},
! 107: { "dns primary [secondary]", "Set peer DNS servers",
! 108: IpcpSetCommand, NULL, 2, (void *) SET_DNS},
! 109: { "nbns primary [secondary]", "Set peer NBNS servers",
! 110: IpcpSetCommand, NULL, 2, (void *) SET_NBNS},
! 111: { "disable [opt ...]", "Disable option",
! 112: IpcpSetCommand, NULL, 2, (void *) SET_DISABLE},
! 113: { "accept [opt ...]", "Accept option",
! 114: IpcpSetCommand, NULL, 2, (void *) SET_ACCEPT},
! 115: { "deny [opt ...]", "Deny option",
! 116: IpcpSetCommand, NULL, 2, (void *) SET_DENY},
! 117: { "yes [opt ...]", "Enable and accept option",
! 118: IpcpSetCommand, NULL, 2, (void *) SET_YES},
! 119: { "no [opt ...]", "Disable and deny option",
! 120: IpcpSetCommand, NULL, 2, (void *) SET_NO},
! 121: { NULL },
! 122: };
! 123:
! 124: /*
! 125: * INTERNAL VARIABLES
! 126: */
! 127:
! 128: static const struct fsmoptinfo gIpcpConfOpts[] = {
! 129: { "IPADDRS", TY_IPADDRS, 8, 8, FALSE },
! 130: #ifdef USE_NG_VJC
! 131: { "COMPPROTO", TY_COMPPROTO, 4, 4, TRUE },
! 132: #endif
! 133: { "IPADDR", TY_IPADDR, 4, 4, TRUE },
! 134: { "PRIDNS", TY_PRIMARYDNS, 4, 4, TRUE },
! 135: { "PRINBNS", TY_PRIMARYNBNS, 4, 4, TRUE },
! 136: { "SECDNS", TY_SECONDARYDNS, 4, 4, TRUE },
! 137: { "SECNBNS", TY_SECONDARYNBNS, 4, 4, TRUE },
! 138: { NULL }
! 139: };
! 140:
! 141: static const struct confinfo gConfList[] = {
! 142: #ifdef USE_NG_VJC
! 143: { 1, IPCP_CONF_VJCOMP, "vjcomp" },
! 144: #endif
! 145: { 0, IPCP_CONF_REQPRIDNS, "req-pri-dns" },
! 146: { 0, IPCP_CONF_REQSECDNS, "req-sec-dns" },
! 147: { 0, IPCP_CONF_REQPRINBNS, "req-pri-nbns" },
! 148: { 0, IPCP_CONF_REQSECNBNS, "req-sec-nbns" },
! 149: { 0, IPCP_CONF_PRETENDIP, "pretend-ip" },
! 150: { 0, 0, NULL },
! 151: };
! 152:
! 153: static const struct fsmtype gIpcpFsmType = {
! 154: "IPCP",
! 155: PROTO_IPCP,
! 156: IPCP_KNOWN_CODES,
! 157: FALSE,
! 158: LG_IPCP, LG_IPCP2,
! 159: NULL,
! 160: IpcpLayerUp,
! 161: IpcpLayerDown,
! 162: IpcpLayerStart,
! 163: IpcpLayerFinish,
! 164: IpcpBuildConfigReq,
! 165: IpcpDecodeConfig,
! 166: IpcpConfigure,
! 167: IpcpUnConfigure,
! 168: NULL,
! 169: NULL,
! 170: NULL,
! 171: NULL,
! 172: IpcpFailure,
! 173: NULL,
! 174: NULL,
! 175: NULL,
! 176: };
! 177:
! 178: /*
! 179: * IpcpStat()
! 180: */
! 181:
! 182: int
! 183: IpcpStat(Context ctx, int ac, char *av[], void *arg)
! 184: {
! 185: #ifdef USE_NG_VJC
! 186: char path[NG_PATHSIZ];
! 187: #endif
! 188: IpcpState const ipcp = &ctx->bund->ipcp;
! 189: Fsm fp = &ipcp->fsm;
! 190: #ifdef USE_NG_VJC
! 191: union {
! 192: u_char buf[sizeof(struct ng_mesg) + sizeof(struct slcompress)];
! 193: struct ng_mesg reply;
! 194: } u;
! 195: struct slcompress *const sls = (struct slcompress *)(void *)u.reply.data;
! 196: #endif
! 197: char buf[48];
! 198:
! 199: Printf("[%s] %s [%s]\r\n", Pref(fp), Fsm(fp), FsmStateName(fp->state));
! 200: Printf("Allowed IP address ranges:\r\n");
! 201: if (ipcp->conf.self_ippool[0]) {
! 202: Printf("\tPeer: ippool %s\r\n",
! 203: ipcp->conf.self_ippool);
! 204: } else {
! 205: Printf("\tSelf: %s\r\n",
! 206: u_rangetoa(&ipcp->conf.self_allow,buf,sizeof(buf)));
! 207: }
! 208: if (ipcp->conf.ippool[0]) {
! 209: Printf("\tPeer: ippool %s\r\n",
! 210: ipcp->conf.ippool);
! 211: } else {
! 212: Printf("\tPeer: %s\r\n",
! 213: u_rangetoa(&ipcp->conf.peer_allow,buf,sizeof(buf)));
! 214: }
! 215: Printf("IPCP Options:\r\n");
! 216: OptStat(ctx, &ipcp->conf.options, gConfList);
! 217: Printf("Current addressing:\r\n");
! 218: Printf("\tSelf: %s\r\n", inet_ntoa(ipcp->want_addr));
! 219: Printf("\tPeer: %s\r\n", inet_ntoa(ipcp->peer_addr));
! 220: #ifdef USE_NG_VJC
! 221: Printf("Compression:\r\n");
! 222: Printf("\tSelf: ");
! 223: if (ipcp->want_comp.proto != 0)
! 224: Printf("%s, %d compression channels, CID %scompressible\r\n",
! 225: ProtoName(ntohs(ipcp->want_comp.proto)),
! 226: ipcp->want_comp.maxchan + 1, ipcp->want_comp.compcid ? "" : "not ");
! 227: else
! 228: Printf("None\r\n");
! 229: Printf("\tPeer: ");
! 230: if (ipcp->peer_comp.proto != 0)
! 231: Printf("%s, %d compression channels, CID %scompressible\n",
! 232: ProtoName(ntohs(ipcp->peer_comp.proto)),
! 233: ipcp->peer_comp.maxchan + 1, ipcp->peer_comp.compcid ? "" : "not ");
! 234: else
! 235: Printf("None\r\n");
! 236: #endif /* USE_NG_VJC */
! 237: Printf("Server info we give to peer:\r\n");
! 238: Printf("DNS servers : %15s", inet_ntoa(ipcp->conf.peer_dns[0]));
! 239: Printf(" %15s\r\n", inet_ntoa(ipcp->conf.peer_dns[1]));
! 240: Printf("NBNS servers: %15s", inet_ntoa(ipcp->conf.peer_nbns[0]));
! 241: Printf(" %15s\r\n", inet_ntoa(ipcp->conf.peer_nbns[1]));
! 242: Printf("Server info peer gave to us:\r\n");
! 243: Printf("DNS servers : %15s", inet_ntoa(ipcp->want_dns[0]));
! 244: Printf(" %15s\r\n", inet_ntoa(ipcp->want_dns[1]));
! 245: Printf("NBNS servers: %15s", inet_ntoa(ipcp->want_nbns[0]));
! 246: Printf(" %15s\r\n", inet_ntoa(ipcp->want_nbns[1]));
! 247:
! 248: #ifdef USE_NG_VJC
! 249: /* Get VJC state */
! 250: snprintf(path, sizeof(path), "mpd%d-%s:%s", gPid, ctx->bund->name, NG_PPP_HOOK_VJC_IP);
! 251: if (NgFuncSendQuery(path, NGM_VJC_COOKIE, NGM_VJC_GET_STATE,
! 252: NULL, 0, &u.reply, sizeof(u), NULL) < 0)
! 253: return(0);
! 254:
! 255: Printf("VJ Compression:\r\n");
! 256: Printf("\tOut comp : %d\r\n", sls->sls_compressed);
! 257: Printf("\tOut total: %d\r\n", sls->sls_packets);
! 258: Printf("\tMissed : %d\r\n", sls->sls_misses);
! 259: Printf("\tSearched : %d\r\n", sls->sls_searches);
! 260: Printf("\tIn comp : %d\r\n", sls->sls_compressedin);
! 261: Printf("\tIn uncomp: %d\r\n", sls->sls_uncompressedin);
! 262: Printf("\tIn error : %d\r\n", sls->sls_errorin);
! 263: Printf("\tIn tossed: %d\r\n", sls->sls_tossed);
! 264: #endif /* USE_NG_VJC */
! 265: return(0);
! 266: }
! 267:
! 268: /*
! 269: * IpcpInit()
! 270: */
! 271:
! 272: void
! 273: IpcpInit(Bund b)
! 274: {
! 275: IpcpState const ipcp = &b->ipcp;
! 276:
! 277: /* Init state machine */
! 278: memset(ipcp, 0, sizeof(*ipcp));
! 279: FsmInit(&ipcp->fsm, &gIpcpFsmType, b);
! 280:
! 281: /* Come up with a default IP address for my side of the link */
! 282: u_rangeclear(&ipcp->conf.self_allow);
! 283: GetAnyIpAddress(&ipcp->conf.self_allow.addr, NULL);
! 284:
! 285: #ifdef USE_NG_VJC
! 286: /* Default we want VJ comp */
! 287: Enable(&ipcp->conf.options, IPCP_CONF_VJCOMP);
! 288: Accept(&ipcp->conf.options, IPCP_CONF_VJCOMP);
! 289: #endif
! 290: }
! 291:
! 292: /*
! 293: * IpcpInst()
! 294: */
! 295:
! 296: void
! 297: IpcpInst(Bund b, Bund bt)
! 298: {
! 299: IpcpState const ipcp = &b->ipcp;
! 300:
! 301: /* Init state machine */
! 302: memcpy(ipcp, &bt->ipcp, sizeof(*ipcp));
! 303: FsmInst(&ipcp->fsm, &bt->ipcp.fsm, b);
! 304: }
! 305:
! 306: /*
! 307: * IpcpConfigure()
! 308: */
! 309:
! 310: static void
! 311: IpcpConfigure(Fsm fp)
! 312: {
! 313: Bund b = (Bund)fp->arg;
! 314: IpcpState const ipcp = &b->ipcp;
! 315: char buf[48];
! 316:
! 317: /* FSM stuff */
! 318: ipcp->peer_reject = 0;
! 319:
! 320: /* Get allowed IP addresses from config and/or from current bundle */
! 321: if (ipcp->conf.self_ippool[0]) {
! 322: if (IPPoolGet(ipcp->conf.self_ippool, &ipcp->self_allow.addr)) {
! 323: Log(LG_IPCP, ("[%s] IPCP: Can't get IP from pool \"%s\" for self",
! 324: b->name, ipcp->conf.self_ippool));
! 325: } else {
! 326: Log(LG_IPCP, ("[%s] IPCP: Got IP %s from pool \"%s\" for self",
! 327: b->name,
! 328: u_addrtoa(&ipcp->self_allow.addr, buf, sizeof(buf)),
! 329: ipcp->conf.self_ippool));
! 330: ipcp->self_allow.width = 32;
! 331: ipcp->self_ippool_used = 1;
! 332: }
! 333: } else
! 334: ipcp->self_allow = ipcp->conf.self_allow;
! 335:
! 336: if ((b->params.range_valid) && (!u_rangeempty(&b->params.range)))
! 337: ipcp->peer_allow = b->params.range;
! 338: else if (b->params.ippool[0]) {
! 339: /* Get IP from pool if needed */
! 340: if (IPPoolGet(b->params.ippool, &ipcp->peer_allow.addr)) {
! 341: Log(LG_IPCP, ("[%s] IPCP: Can't get IP from pool \"%s\" for peer",
! 342: b->name, b->params.ippool));
! 343: } else {
! 344: Log(LG_IPCP, ("[%s] IPCP: Got IP %s from pool \"%s\" for peer",
! 345: b->name,
! 346: u_addrtoa(&ipcp->peer_allow.addr, buf, sizeof(buf)),
! 347: b->params.ippool));
! 348: ipcp->peer_allow.width = 32;
! 349: b->params.ippool_used = 1;
! 350: }
! 351: } else if (ipcp->conf.ippool[0]) {
! 352: if (IPPoolGet(ipcp->conf.ippool, &ipcp->peer_allow.addr)) {
! 353: Log(LG_IPCP, ("[%s] IPCP: Can't get IP from pool \"%s\"",
! 354: b->name, ipcp->conf.ippool));
! 355: } else {
! 356: Log(LG_IPCP, ("[%s] IPCP: Got IP %s from pool \"%s\" for peer",
! 357: b->name,
! 358: u_addrtoa(&ipcp->peer_allow.addr, buf, sizeof(buf)),
! 359: ipcp->conf.ippool));
! 360: ipcp->peer_allow.width = 32;
! 361: ipcp->ippool_used = 1;
! 362: }
! 363: } else
! 364: ipcp->peer_allow = ipcp->conf.peer_allow;
! 365:
! 366: /* Initially request addresses as specified by config */
! 367: u_addrtoin_addr(&ipcp->self_allow.addr, &ipcp->want_addr);
! 368: u_addrtoin_addr(&ipcp->peer_allow.addr, &ipcp->peer_addr);
! 369:
! 370: #ifdef USE_NG_VJC
! 371: /* Van Jacobson compression */
! 372: ipcp->peer_comp.proto = 0;
! 373: ipcp->peer_comp.maxchan = IPCP_VJCOMP_DEFAULT_MAXCHAN;
! 374: ipcp->peer_comp.compcid = 0;
! 375:
! 376: ipcp->want_comp.proto =
! 377: (b->params.vjc_enable || Enabled(&ipcp->conf.options, IPCP_CONF_VJCOMP)) ?
! 378: htons(PROTO_VJCOMP) : 0;
! 379: ipcp->want_comp.maxchan = IPCP_VJCOMP_MAX_MAXCHAN;
! 380:
! 381: /* If any of our links are unable to give receive error indications, we must
! 382: tell the peer not to compress the slot-id in VJCOMP packets (cf. RFC1144).
! 383: To be on the safe side, we always say this. */
! 384: ipcp->want_comp.compcid = 0;
! 385: #endif
! 386:
! 387: /* DNS and NBNS servers */
! 388: memset(&ipcp->want_dns, 0, sizeof(ipcp->want_dns));
! 389: memset(&ipcp->want_nbns, 0, sizeof(ipcp->want_nbns));
! 390: }
! 391:
! 392: /*
! 393: * IpcpUnConfigure()
! 394: */
! 395:
! 396: static void
! 397: IpcpUnConfigure(Fsm fp)
! 398: {
! 399: Bund b = (Bund)fp->arg;
! 400: IpcpState const ipcp = &b->ipcp;
! 401:
! 402: if (ipcp->self_ippool_used) {
! 403: struct u_addr ip;
! 404: in_addrtou_addr(&ipcp->want_addr, &ip);
! 405: IPPoolFree(ipcp->conf.self_ippool, &ip);
! 406: ipcp->self_ippool_used = 0;
! 407: }
! 408: if (b->params.ippool_used) {
! 409: struct u_addr ip;
! 410: in_addrtou_addr(&ipcp->peer_addr, &ip);
! 411: IPPoolFree(b->params.ippool, &ip);
! 412: b->params.ippool_used = 0;
! 413: } else if (ipcp->ippool_used) {
! 414: struct u_addr ip;
! 415: in_addrtou_addr(&ipcp->peer_addr, &ip);
! 416: IPPoolFree(ipcp->conf.ippool, &ip);
! 417: ipcp->ippool_used = 0;
! 418: }
! 419: }
! 420:
! 421: /*
! 422: * IpcpBuildConfigReq()
! 423: */
! 424:
! 425: static u_char *
! 426: IpcpBuildConfigReq(Fsm fp, u_char *cp)
! 427: {
! 428: Bund b = (Bund)fp->arg;
! 429: IpcpState const ipcp = &b->ipcp;
! 430:
! 431: /* Put in my desired IP address */
! 432: if (!IPCP_REJECTED(ipcp, TY_IPADDR) || ipcp->want_addr.s_addr == 0)
! 433: cp = FsmConfValue(cp, TY_IPADDR, 4, &ipcp->want_addr.s_addr);
! 434:
! 435: #ifdef USE_NG_VJC
! 436: /* Put in my requested compression protocol */
! 437: if (ipcp->want_comp.proto != 0 && !IPCP_REJECTED(ipcp, TY_COMPPROTO))
! 438: cp = FsmConfValue(cp, TY_COMPPROTO, 4, &ipcp->want_comp);
! 439: #endif
! 440:
! 441: /* Request peer's DNS and NBNS servers */
! 442: {
! 443: const int sopts[2][2] = { { IPCP_CONF_REQPRIDNS, IPCP_CONF_REQSECDNS },
! 444: { IPCP_CONF_REQPRINBNS, IPCP_CONF_REQSECNBNS }};
! 445: const int nopts[2][2] = { { TY_PRIMARYDNS, TY_SECONDARYDNS },
! 446: { TY_PRIMARYNBNS, TY_SECONDARYNBNS } };
! 447: struct in_addr *vals[2] = { ipcp->want_dns, ipcp->want_nbns };
! 448: int sopt, pri;
! 449:
! 450: for (sopt = 0; sopt < 2; sopt++) {
! 451: for (pri = 0; pri < 2; pri++) {
! 452: const int opt = nopts[sopt][pri];
! 453:
! 454: /* Add option if we desire it and it hasn't been rejected */
! 455: if (Enabled(&ipcp->conf.options, sopts[sopt][pri])
! 456: && !IPCP_REJECTED(ipcp, opt)) {
! 457: cp = FsmConfValue(cp, opt, 4, &vals[sopt][pri]);
! 458: }
! 459: }
! 460: }
! 461: }
! 462:
! 463: /* Done */
! 464:
! 465: return(cp);
! 466: }
! 467:
! 468: /*
! 469: * IpcpLayerStart()
! 470: *
! 471: * Tell the lower layer (the bundle) that we need it
! 472: */
! 473:
! 474: static void
! 475: IpcpLayerStart(Fsm fp)
! 476: {
! 477: BundNcpsStart((Bund)(fp->arg), NCP_IPCP);
! 478: }
! 479:
! 480: /*
! 481: * IpcpLayerFinish()
! 482: *
! 483: * Tell the lower layer (the bundle) that we no longer need it
! 484: */
! 485:
! 486: static void
! 487: IpcpLayerFinish(Fsm fp)
! 488: {
! 489: BundNcpsFinish((Bund)(fp->arg), NCP_IPCP);
! 490: }
! 491:
! 492: /*
! 493: * IpcpLayerUp()
! 494: *
! 495: * Called when IPCP has reached the OPEN state
! 496: */
! 497:
! 498: static void
! 499: IpcpLayerUp(Fsm fp)
! 500: {
! 501: Bund b = (Bund)fp->arg;
! 502: IpcpState const ipcp = &b->ipcp;
! 503: char ipbuf[20];
! 504: #ifdef USE_NG_VJC
! 505: char path[NG_PATHSIZ];
! 506: struct ngm_vjc_config vjc;
! 507: #endif
! 508: struct u_addr tmp;
! 509:
! 510: /* Determine actual address we'll use for ourselves */
! 511: in_addrtou_addr(&ipcp->want_addr, &tmp);
! 512: if (!IpAddrInRange(&ipcp->self_allow, &tmp)) {
! 513: Log(LG_IPCP, ("[%s] Note: ignoring negotiated %s IP %s,",
! 514: b->name, "self", inet_ntoa(ipcp->want_addr)));
! 515: u_addrtoin_addr(&ipcp->self_allow.addr, &ipcp->want_addr);
! 516: Log(LG_IPCP, ("[%s] using %s instead.",
! 517: b->name, inet_ntoa(ipcp->want_addr)));
! 518: }
! 519:
! 520: /* Determine actual address we'll use for peer */
! 521: in_addrtou_addr(&ipcp->peer_addr, &tmp);
! 522: if (!IpAddrInRange(&ipcp->peer_allow, &tmp)
! 523: && !u_addrempty(&ipcp->peer_allow.addr)) {
! 524: Log(LG_IPCP, ("[%s] Note: ignoring negotiated %s IP %s,",
! 525: b->name, "peer", inet_ntoa(ipcp->peer_addr)));
! 526: u_addrtoin_addr(&ipcp->peer_allow.addr, &ipcp->peer_addr);
! 527: Log(LG_IPCP, ("[%s] using %s instead.",
! 528: b->name, inet_ntoa(ipcp->peer_addr)));
! 529: }
! 530:
! 531: /* Report */
! 532: strlcpy(ipbuf, inet_ntoa(ipcp->peer_addr), sizeof(ipbuf));
! 533: Log(LG_IPCP, ("[%s] %s -> %s", b->name, inet_ntoa(ipcp->want_addr), ipbuf));
! 534:
! 535: #ifdef USE_NG_VJC
! 536: memset(&vjc, 0, sizeof(vjc));
! 537: if (ntohs(ipcp->peer_comp.proto) == PROTO_VJCOMP ||
! 538: ntohs(ipcp->want_comp.proto) == PROTO_VJCOMP) {
! 539:
! 540: IpcpNgInitVJ(b);
! 541:
! 542: /* Configure VJ compression node */
! 543: vjc.enableComp = ntohs(ipcp->peer_comp.proto) == PROTO_VJCOMP;
! 544: vjc.enableDecomp = ntohs(ipcp->want_comp.proto) == PROTO_VJCOMP;
! 545: vjc.maxChannel = ipcp->peer_comp.maxchan;
! 546: vjc.compressCID = ipcp->peer_comp.compcid;
! 547: snprintf(path, sizeof(path), "[%x]:%s", b->nodeID, NG_PPP_HOOK_VJC_IP);
! 548: if (NgSendMsg(gLinksCsock, path,
! 549: NGM_VJC_COOKIE, NGM_VJC_SET_CONFIG, &vjc, sizeof(vjc)) < 0) {
! 550: Perror("[%s] can't config %s node", b->name, NG_VJC_NODE_TYPE);
! 551: }
! 552: }
! 553: #endif /* USE_NG_VJC */
! 554:
! 555: /* Enable IP packets in the PPP node */
! 556: b->pppConfig.bund.enableIP = 1;
! 557: #ifdef USE_NG_VJC
! 558: b->pppConfig.bund.enableVJCompression = vjc.enableComp;
! 559: b->pppConfig.bund.enableVJDecompression = vjc.enableDecomp;
! 560: #endif
! 561: NgFuncSetConfig(b);
! 562:
! 563: BundNcpsJoin(b, NCP_IPCP);
! 564: }
! 565:
! 566: /*
! 567: * IpcpLayerDown()
! 568: *
! 569: * Called when IPCP leaves the OPEN state
! 570: */
! 571:
! 572: static void
! 573: IpcpLayerDown(Fsm fp)
! 574: {
! 575: Bund b = (Bund)fp->arg;
! 576: #ifdef USE_NG_VJC
! 577: IpcpState const ipcp = &b->ipcp;
! 578: #endif
! 579:
! 580: BundNcpsLeave(b, NCP_IPCP);
! 581:
! 582: /* Turn off IP packets */
! 583: b->pppConfig.bund.enableIP = 0;
! 584: #ifdef USE_NG_VJC
! 585: b->pppConfig.bund.enableVJCompression = 0;
! 586: b->pppConfig.bund.enableVJDecompression = 0;
! 587: #endif
! 588: NgFuncSetConfig(b);
! 589:
! 590: #ifdef USE_NG_VJC
! 591: if (ntohs(ipcp->peer_comp.proto) == PROTO_VJCOMP ||
! 592: ntohs(ipcp->want_comp.proto) == PROTO_VJCOMP) {
! 593: IpcpNgShutdownVJ(b);
! 594: }
! 595: #endif /* USE_NG_VJC */
! 596: }
! 597:
! 598: /*
! 599: * IpcpUp()
! 600: */
! 601:
! 602: void
! 603: IpcpUp(Bund b)
! 604: {
! 605: FsmUp(&b->ipcp.fsm);
! 606: }
! 607:
! 608: /*
! 609: * IpcpDown()
! 610: */
! 611:
! 612: void
! 613: IpcpDown(Bund b)
! 614: {
! 615: FsmDown(&b->ipcp.fsm);
! 616: }
! 617:
! 618: /*
! 619: * IpcpOpen()
! 620: */
! 621:
! 622: void
! 623: IpcpOpen(Bund b)
! 624: {
! 625: FsmOpen(&b->ipcp.fsm);
! 626: }
! 627:
! 628: /*
! 629: * IpcpClose()
! 630: */
! 631:
! 632: void
! 633: IpcpClose(Bund b)
! 634: {
! 635: FsmClose(&b->ipcp.fsm);
! 636: }
! 637:
! 638: /*
! 639: * IpcpOpenCmd()
! 640: */
! 641:
! 642: int
! 643: IpcpOpenCmd(Context ctx)
! 644: {
! 645: if (ctx->bund->tmpl)
! 646: Error("impossible to open template");
! 647: FsmOpen(&ctx->bund->ipcp.fsm);
! 648: return (0);
! 649: }
! 650:
! 651: /*
! 652: * IpcpCloseCmd()
! 653: */
! 654:
! 655: int
! 656: IpcpCloseCmd(Context ctx)
! 657: {
! 658: if (ctx->bund->tmpl)
! 659: Error("impossible to close template");
! 660: FsmClose(&ctx->bund->ipcp.fsm);
! 661: return (0);
! 662: }
! 663:
! 664: /*
! 665: * IpcpFailure()
! 666: */
! 667:
! 668: static void
! 669: IpcpFailure(Fsm fp, enum fsmfail reason)
! 670: {
! 671: Bund b = (Bund)fp->arg;
! 672: RecordLinkUpDownReason(b, NULL, 0, STR_PROTO_ERR, STR_IPCP_FAILED, FsmFailureStr(reason));
! 673: }
! 674:
! 675: /*
! 676: * IpcpDecodeConfig()
! 677: */
! 678:
! 679: static void
! 680: IpcpDecodeConfig(Fsm fp, FsmOption list, int num, int mode)
! 681: {
! 682: Bund b = (Bund)fp->arg;
! 683: IpcpState const ipcp = &b->ipcp;
! 684: struct in_addr *wantip, *peerip;
! 685: int k;
! 686:
! 687: /* Decode each config option */
! 688: for (k = 0; k < num; k++) {
! 689: FsmOption const opt = &list[k];
! 690: FsmOptInfo const oi = FsmFindOptInfo(gIpcpConfOpts, opt->type);
! 691:
! 692: if (!oi) {
! 693: Log(LG_IPCP, ("[%s] UNKNOWN[%d] len=%d", b->name, opt->type, opt->len));
! 694: if (mode == MODE_REQ)
! 695: FsmRej(fp, opt);
! 696: continue;
! 697: }
! 698: if (!oi->supported) {
! 699: Log(LG_IPCP, ("[%s] %s", b->name, oi->name));
! 700: if (mode == MODE_REQ) {
! 701: Log(LG_IPCP, ("[%s] Not supported", b->name));
! 702: FsmRej(fp, opt);
! 703: }
! 704: continue;
! 705: }
! 706: if (opt->len < oi->minLen + 2 || opt->len > oi->maxLen + 2) {
! 707: Log(LG_IPCP, ("[%s] %s", b->name, oi->name));
! 708: if (mode == MODE_REQ) {
! 709: Log(LG_IPCP, ("[%s] bogus len=%d", b->name, opt->len));
! 710: FsmRej(fp, opt);
! 711: }
! 712: continue;
! 713: }
! 714: switch (opt->type) {
! 715: case TY_IPADDR:
! 716: {
! 717: struct in_addr ip;
! 718: struct u_addr tmp;
! 719:
! 720: memcpy(&ip, opt->data, 4);
! 721: in_addrtou_addr(&ip, &tmp);
! 722: Log(LG_IPCP, ("[%s] %s %s", b->name, oi->name, inet_ntoa(ip)));
! 723: switch (mode) {
! 724: case MODE_REQ:
! 725: if (!IpAddrInRange(&ipcp->peer_allow, &tmp) || !ip.s_addr) {
! 726: if (ipcp->peer_addr.s_addr == 0)
! 727: Log(LG_IPCP, ("[%s] no IP address available for peer!", b->name));
! 728: if (Enabled(&ipcp->conf.options, IPCP_CONF_PRETENDIP)) {
! 729: Log(LG_IPCP, ("[%s] pretending that %s is OK, will ignore",
! 730: b->name, inet_ntoa(ip)));
! 731: ipcp->peer_addr = ip;
! 732: FsmAck(fp, opt);
! 733: break;
! 734: }
! 735: memcpy(opt->data, &ipcp->peer_addr, 4);
! 736: Log(LG_IPCP, ("[%s] NAKing with %s", b->name, inet_ntoa(ipcp->peer_addr)));
! 737: FsmNak(fp, opt);
! 738: break;
! 739: }
! 740: Log(LG_IPCP, ("[%s] %s is OK", b->name, inet_ntoa(ip)));
! 741: ipcp->peer_addr = ip;
! 742: FsmAck(fp, opt);
! 743: break;
! 744: case MODE_NAK:
! 745: {
! 746: if (IpAddrInRange(&ipcp->self_allow, &tmp)) {
! 747: Log(LG_IPCP, ("[%s] %s is OK", b->name, inet_ntoa(ip)));
! 748: ipcp->want_addr = ip;
! 749: } else if (Enabled(&ipcp->conf.options, IPCP_CONF_PRETENDIP)) {
! 750: Log(LG_IPCP, ("[%s] pretending that %s is OK, will ignore",
! 751: b->name, inet_ntoa(ip)));
! 752: ipcp->want_addr = ip;
! 753: } else
! 754: Log(LG_IPCP, ("[%s] %s is unacceptable", b->name, inet_ntoa(ip)));
! 755: }
! 756: break;
! 757: case MODE_REJ:
! 758: IPCP_PEER_REJ(ipcp, opt->type);
! 759: if (ipcp->want_addr.s_addr == 0)
! 760: Log(LG_IPCP, ("[%s] Problem: I need an IP address!", b->name));
! 761: break;
! 762: }
! 763: }
! 764: break;
! 765:
! 766: #ifdef USE_NG_VJC
! 767: case TY_COMPPROTO:
! 768: {
! 769: struct ipcpvjcomp vj;
! 770:
! 771: memcpy(&vj, opt->data, sizeof(vj));
! 772: Log(LG_IPCP, ("[%s] %s %s, %d comp. channels, %s comp-cid",
! 773: b->name, oi->name, ProtoName(ntohs(vj.proto)),
! 774: vj.maxchan + 1, vj.compcid ? "allow" : "no"));
! 775: switch (mode) {
! 776: case MODE_REQ:
! 777: if (!Acceptable(&ipcp->conf.options, IPCP_CONF_VJCOMP) &&
! 778: !b->params.vjc_enable) {
! 779: FsmRej(fp, opt);
! 780: break;
! 781: }
! 782: if (ntohs(vj.proto) == PROTO_VJCOMP
! 783: && vj.maxchan <= IPCP_VJCOMP_MAX_MAXCHAN
! 784: && vj.maxchan >= IPCP_VJCOMP_MIN_MAXCHAN) {
! 785: ipcp->peer_comp = vj;
! 786: FsmAck(fp, opt);
! 787: break;
! 788: }
! 789: vj.proto = htons(PROTO_VJCOMP);
! 790: vj.maxchan = IPCP_VJCOMP_MAX_MAXCHAN;
! 791: vj.compcid = 0;
! 792: memcpy(opt->data, &vj, sizeof(vj));
! 793: FsmNak(fp, opt);
! 794: break;
! 795: case MODE_NAK:
! 796: if (ntohs(vj.proto) != PROTO_VJCOMP) {
! 797: Log(LG_IPCP, ("[%s] Can't accept proto 0x%04x",
! 798: b->name, (u_short) ntohs(vj.proto)));
! 799: break;
! 800: }
! 801: if (vj.maxchan != ipcp->want_comp.maxchan) {
! 802: if (vj.maxchan <= IPCP_VJCOMP_MAX_MAXCHAN
! 803: && vj.maxchan >= IPCP_VJCOMP_MIN_MAXCHAN) {
! 804: Log(LG_IPCP, ("[%s] Adjusting # compression channels", b->name));
! 805: ipcp->want_comp.maxchan = vj.maxchan;
! 806: } else {
! 807: Log(LG_IPCP, ("[%s] Can't handle %d maxchan", b->name, vj.maxchan));
! 808: }
! 809: }
! 810: if (vj.compcid) {
! 811: Log(LG_IPCP, ("[%s] Can't accept comp-cid", b->name));
! 812: break;
! 813: }
! 814: break;
! 815: case MODE_REJ:
! 816: IPCP_PEER_REJ(ipcp, opt->type);
! 817: ipcp->want_comp.proto = 0;
! 818: break;
! 819: }
! 820: }
! 821: break;
! 822: #endif /* USE_NG_VJC */
! 823:
! 824: case TY_PRIMARYDNS:
! 825: if (b->params.peer_dns[0].s_addr != 0)
! 826: peerip = &b->params.peer_dns[0];
! 827: else
! 828: peerip = &ipcp->conf.peer_dns[0];
! 829: wantip = &ipcp->want_dns[0];
! 830: goto doDnsNbns;
! 831: case TY_PRIMARYNBNS:
! 832: if (b->params.peer_nbns[0].s_addr != 0)
! 833: peerip = &b->params.peer_nbns[0];
! 834: else
! 835: peerip = &ipcp->conf.peer_nbns[0];
! 836: wantip = &ipcp->want_nbns[0];
! 837: goto doDnsNbns;
! 838: case TY_SECONDARYDNS:
! 839: if (b->params.peer_dns[1].s_addr != 0)
! 840: peerip = &b->params.peer_dns[1];
! 841: else
! 842: peerip = &ipcp->conf.peer_dns[1];
! 843: wantip = &ipcp->want_dns[1];
! 844: goto doDnsNbns;
! 845: case TY_SECONDARYNBNS:
! 846: if (b->params.peer_nbns[1].s_addr != 0)
! 847: peerip = &b->params.peer_nbns[1];
! 848: else
! 849: peerip = &ipcp->conf.peer_nbns[1];
! 850: wantip = &ipcp->want_nbns[1];
! 851: doDnsNbns:
! 852: {
! 853: struct in_addr hisip;
! 854:
! 855: memcpy(&hisip, opt->data, 4);
! 856: Log(LG_IPCP, ("[%s] %s %s", b->name, oi->name, inet_ntoa(hisip)));
! 857: switch (mode) {
! 858: case MODE_REQ:
! 859: if (hisip.s_addr == 0) { /* he's asking for one */
! 860: if (peerip->s_addr == 0) { /* we don't got one */
! 861: FsmRej(fp, opt);
! 862: break;
! 863: }
! 864: Log(LG_IPCP, ("[%s] NAKing with %s", b->name, inet_ntoa(*peerip)));
! 865: memcpy(opt->data, peerip, sizeof(*peerip));
! 866: FsmNak(fp, opt); /* we got one for him */
! 867: break;
! 868: }
! 869: FsmAck(fp, opt); /* he knows what he wants */
! 870: break;
! 871: case MODE_NAK: /* we asked for his server, he's telling us */
! 872: *wantip = hisip;
! 873: break;
! 874: case MODE_REJ: /* we asked for his server, he's ignorant */
! 875: IPCP_PEER_REJ(ipcp, opt->type);
! 876: break;
! 877: }
! 878: }
! 879: break;
! 880:
! 881: default:
! 882: assert(0);
! 883: }
! 884: }
! 885: }
! 886:
! 887: /*
! 888: * IpcpInput()
! 889: *
! 890: * Deal with an incoming IPCP packet
! 891: */
! 892:
! 893: void
! 894: IpcpInput(Bund b, Mbuf bp)
! 895: {
! 896: FsmInput(&b->ipcp.fsm, bp);
! 897: }
! 898:
! 899: #ifdef USE_NG_VJC
! 900: static int
! 901: IpcpNgInitVJ(Bund b)
! 902: {
! 903: struct ngm_mkpeer mp;
! 904: struct ngm_connect cn;
! 905: char path[NG_PATHSIZ];
! 906: struct ngm_name nm;
! 907:
! 908: /* Add a VJ compression node */
! 909: snprintf(path, sizeof(path), "[%x]:", b->nodeID);
! 910: strcpy(mp.type, NG_VJC_NODE_TYPE);
! 911: strcpy(mp.ourhook, NG_PPP_HOOK_VJC_IP);
! 912: strcpy(mp.peerhook, NG_VJC_HOOK_IP);
! 913: if (NgSendMsg(gLinksCsock, path,
! 914: NGM_GENERIC_COOKIE, NGM_MKPEER, &mp, sizeof(mp)) < 0) {
! 915: Perror("[%s] can't create %s node at \"%s\"->\"%s\"",
! 916: b->name, NG_VJC_NODE_TYPE, path, mp.ourhook);
! 917: goto fail;
! 918: }
! 919:
! 920: /* Give it a name */
! 921: strlcat(path, NG_PPP_HOOK_VJC_IP, sizeof(path));
! 922: snprintf(nm.name, sizeof(nm.name), "mpd%d-%s-vjc", gPid, b->name);
! 923: if (NgSendMsg(gLinksCsock, path,
! 924: NGM_GENERIC_COOKIE, NGM_NAME, &nm, sizeof(nm)) < 0) {
! 925: Perror("[%s] can't name %s node", b->name, NG_VJC_NODE_TYPE);
! 926: goto fail;
! 927: }
! 928:
! 929: /* Connect the other three hooks between the ppp and vjc nodes */
! 930: snprintf(path, sizeof(path), "[%x]:", b->nodeID);
! 931: strcpy(cn.path, NG_PPP_HOOK_VJC_IP);
! 932: strcpy(cn.ourhook, NG_PPP_HOOK_VJC_COMP);
! 933: strcpy(cn.peerhook, NG_VJC_HOOK_VJCOMP);
! 934: if (NgSendMsg(gLinksCsock, path,
! 935: NGM_GENERIC_COOKIE, NGM_CONNECT, &cn, sizeof(cn)) < 0) {
! 936: Perror("[%s] can't connect \"%s\"->\"%s\" and \"%s\"->\"%s\"",
! 937: b->name, path, cn.ourhook, cn.path, cn.peerhook);
! 938: goto fail;
! 939: }
! 940: strcpy(cn.ourhook, NG_PPP_HOOK_VJC_UNCOMP);
! 941: strcpy(cn.peerhook, NG_VJC_HOOK_VJUNCOMP);
! 942: if (NgSendMsg(gLinksCsock, path,
! 943: NGM_GENERIC_COOKIE, NGM_CONNECT, &cn, sizeof(cn)) < 0) {
! 944: Perror("[%s] can't connect \"%s\"->\"%s\" and \"%s\"->\"%s\"",
! 945: b->name, path, cn.ourhook, cn.path, cn.peerhook);
! 946: goto fail;
! 947: }
! 948: strcpy(cn.ourhook, NG_PPP_HOOK_VJC_VJIP);
! 949: strcpy(cn.peerhook, NG_VJC_HOOK_VJIP);
! 950: if (NgSendMsg(gLinksCsock, path,
! 951: NGM_GENERIC_COOKIE, NGM_CONNECT, &cn, sizeof(cn)) < 0) {
! 952: Perror("[%s] can't connect \"%s\"->\"%s\" and \"%s\"->\"%s\"",
! 953: b->name, path, cn.ourhook, cn.path, cn.peerhook);
! 954: goto fail;
! 955: }
! 956:
! 957: return 0;
! 958: fail:
! 959: return -1;
! 960: }
! 961:
! 962: static void
! 963: IpcpNgShutdownVJ(Bund b)
! 964: {
! 965: char path[NG_PATHSIZ];
! 966:
! 967: snprintf(path, sizeof(path), "[%x]:%s", b->nodeID, NG_PPP_HOOK_VJC_IP);
! 968: NgFuncShutdownNode(gLinksCsock, b->name, path);
! 969: }
! 970: #endif /* USE_NG_VJC */
! 971:
! 972: /*
! 973: * IpcpSetCommand()
! 974: */
! 975:
! 976: static int
! 977: IpcpSetCommand(Context ctx, int ac, char *av[], void *arg)
! 978: {
! 979: IpcpState const ipcp = &ctx->bund->ipcp;
! 980: struct in_addr *ips;
! 981:
! 982: if (ac == 0)
! 983: return(-1);
! 984: switch ((intptr_t)arg) {
! 985: case SET_RANGES:
! 986: {
! 987: struct u_range self_new_allow;
! 988: struct u_range peer_new_allow;
! 989: int pos = 0, self_new_pool = -1, peer_new_pool = -1;
! 990:
! 991: /* Parse args */
! 992: if (ac < 2)
! 993: return (-1);
! 994: if (strcmp(av[pos], "ippool") == 0) {
! 995: self_new_pool = pos+1;
! 996: pos+=2;
! 997: } else {
! 998: if (!ParseRange(av[pos], &self_new_allow, ALLOW_IPV4))
! 999: return(-1);
! 1000: pos++;
! 1001: }
! 1002: if (pos >= ac)
! 1003: return (-1);
! 1004: if (strcmp(av[pos], "ippool") == 0) {
! 1005: if ((pos + 1) >= ac)
! 1006: return (-1);
! 1007: peer_new_pool = pos+1;
! 1008: pos+=2;
! 1009: } else {
! 1010: if (!ParseRange(av[pos], &peer_new_allow, ALLOW_IPV4))
! 1011: return(-1);
! 1012: pos++;
! 1013: }
! 1014: if (pos != ac)
! 1015: return (-1);
! 1016:
! 1017: if (self_new_pool >= 0)
! 1018: strlcpy(ipcp->conf.self_ippool, av[self_new_pool], sizeof(ipcp->conf.self_ippool));
! 1019: else
! 1020: ipcp->conf.self_ippool[0] = 0;
! 1021: if (peer_new_pool >= 0)
! 1022: strlcpy(ipcp->conf.ippool, av[peer_new_pool], sizeof(ipcp->conf.ippool));
! 1023: else
! 1024: ipcp->conf.ippool[0] = 0;
! 1025: ipcp->conf.self_allow = self_new_allow;
! 1026: ipcp->conf.peer_allow = peer_new_allow;
! 1027:
! 1028: }
! 1029: break;
! 1030:
! 1031: case SET_DNS:
! 1032: ips = ipcp->conf.peer_dns;
! 1033: goto getPrimSec;
! 1034: break;
! 1035: case SET_NBNS:
! 1036: ips = ipcp->conf.peer_nbns;
! 1037: getPrimSec:
! 1038: if (!inet_aton(av[0], &ips[0]))
! 1039: Error("invalid IP address: \'%s\'", av[0]);
! 1040: ips[1].s_addr = 0;
! 1041: if (ac > 1 && !inet_aton(av[1], &ips[1]))
! 1042: Error("invalid IP address: \'%s\'", av[1]);
! 1043: break;
! 1044:
! 1045: case SET_ACCEPT:
! 1046: AcceptCommand(ac, av, &ipcp->conf.options, gConfList);
! 1047: break;
! 1048:
! 1049: case SET_DENY:
! 1050: DenyCommand(ac, av, &ipcp->conf.options, gConfList);
! 1051: break;
! 1052:
! 1053: case SET_ENABLE:
! 1054: EnableCommand(ac, av, &ipcp->conf.options, gConfList);
! 1055: break;
! 1056:
! 1057: case SET_DISABLE:
! 1058: DisableCommand(ac, av, &ipcp->conf.options, gConfList);
! 1059: break;
! 1060:
! 1061: case SET_YES:
! 1062: YesCommand(ac, av, &ipcp->conf.options, gConfList);
! 1063: break;
! 1064:
! 1065: case SET_NO:
! 1066: NoCommand(ac, av, &ipcp->conf.options, gConfList);
! 1067: break;
! 1068:
! 1069: default:
! 1070: assert(0);
! 1071: }
! 1072: return(0);
! 1073: }
! 1074:
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to ipcp.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / mpd / src