Annotation of embedaddon/mpd/src/pptp.c, revision 1.1
1.1 ! misho 1:
! 2: /*
! 3: * pptp.c
! 4: *
! 5: * Written by Archie Cobbs <archie@freebsd.org>
! 6: * Copyright (c) 1998-1999 Whistle Communications, Inc. All rights reserved.
! 7: * See ``COPYRIGHT.whistle''
! 8: */
! 9:
! 10: #include "ppp.h"
! 11: #include "phys.h"
! 12: #include "mbuf.h"
! 13: #include "ngfunc.h"
! 14: #include "pptp.h"
! 15: #include "pptp_ctrl.h"
! 16: #include "log.h"
! 17: #include "util.h"
! 18:
! 19: #include <netgraph/ng_message.h>
! 20: #include <netgraph/ng_socket.h>
! 21: #include <netgraph/ng_ksocket.h>
! 22: #include <netgraph/ng_pptpgre.h>
! 23: #include <netgraph.h>
! 24:
! 25: /*
! 26: * DEFINITIONS
! 27: */
! 28:
! 29: #define PPTP_MRU PPTP_MTU
! 30:
! 31: #define PPTP_CALL_MIN_BPS 56000
! 32: #define PPTP_CALL_MAX_BPS 64000
! 33:
! 34: struct pptptun {
! 35: struct u_addr self_addr; /* Current self IP address */
! 36: struct u_addr peer_addr; /* Current peer IP address */
! 37: ng_ID_t node_id;
! 38: int refs;
! 39: };
! 40: typedef struct pptptun *PptpTun;
! 41:
! 42: struct pptpinfo {
! 43: struct {
! 44: struct u_addr self_addr; /* self IP address */
! 45: struct u_range peer_addr; /* Peer IP addresses allowed */
! 46: in_port_t self_port; /* self port */
! 47: in_port_t peer_port; /* Peer port required (or zero) */
! 48: struct optinfo options;
! 49: char callingnum[64]; /* PPTP phone number to use */
! 50: char callednum[64]; /* PPTP phone number to use */
! 51: char *fqdn_peer_addr; /* FQDN Peer address */
! 52: } conf;
! 53: void *listener; /* Listener pointer */
! 54: struct u_addr self_addr; /* Current self IP address */
! 55: struct u_addr peer_addr; /* Current peer IP address */
! 56: char peer_iface[IFNAMSIZ]; /* Peer iface */
! 57: u_char peer_mac_addr[6]; /* Peer MAC address */
! 58: in_port_t peer_port; /* Current peer port */
! 59: u_char originate; /* Call originated locally */
! 60: u_char outcall; /* Call is outgoing vs. incoming */
! 61: u_char sync; /* Call is sync vs. async */
! 62: u_int16_t cid; /* call id */
! 63: PptpTun tun;
! 64: struct pptpctrlinfo cinfo;
! 65: char callingnum[64]; /* PPTP phone number to use */
! 66: char callednum[64]; /* PPTP phone number to use */
! 67: };
! 68: typedef struct pptpinfo *PptpInfo;
! 69:
! 70: /* Set menu options */
! 71: enum {
! 72: SET_SELFADDR,
! 73: SET_PEERADDR,
! 74: SET_CALLINGNUM,
! 75: SET_CALLEDNUM,
! 76: SET_ENABLE,
! 77: SET_DISABLE
! 78: };
! 79:
! 80: /* Binary options */
! 81: enum {
! 82: PPTP_CONF_OUTCALL, /* when originating, calls are "outgoing" */
! 83: PPTP_CONF_DELAYED_ACK, /* enable delayed receive ack algorithm */
! 84: PPTP_CONF_ALWAYS_ACK, /* include ack with all outgoing data packets */
! 85: PPTP_CONF_RESOLVE_ONCE, /* Only once resolve peer_addr */
! 86: #if NGM_PPTPGRE_COOKIE >= 1082548365
! 87: PPTP_CONF_WINDOWING /* control (stupid) windowing algorithm */
! 88: #endif
! 89: };
! 90:
! 91: /*
! 92: * INTERNAL FUNCTIONS
! 93: */
! 94:
! 95: static int PptpTInit(void);
! 96: static void PptpTShutdown(void);
! 97: static int PptpInit(Link l);
! 98: static int PptpInst(Link l, Link lt);
! 99: static void PptpOpen(Link l);
! 100: static void PptpClose(Link l);
! 101: static void PptpShutdown(Link l);
! 102: static void PptpStat(Context ctx);
! 103: static int PptpOriginated(Link l);
! 104: static int PptpIsSync(Link l);
! 105: static int PptpSetAccm(Link l, u_int32_t xmit, u_int32_t recv);
! 106: static int PptpSetCallingNum(Link l, void *buf);
! 107: static int PptpSetCalledNum(Link l, void *buf);
! 108: static int PptpSelfName(Link l, void *buf, size_t buf_len);
! 109: static int PptpPeerName(Link l, void *buf, size_t buf_len);
! 110: static int PptpSelfAddr(Link l, void *buf, size_t buf_len);
! 111: static int PptpPeerAddr(Link l, void *buf, size_t buf_len);
! 112: static int PptpPeerPort(Link l, void *buf, size_t buf_len);
! 113: static int PptpPeerMacAddr(Link l, void *buf, size_t buf_len);
! 114: static int PptpPeerIface(Link l, void *buf, size_t buf_len);
! 115: static int PptpCallingNum(Link l, void *buf, size_t buf_len);
! 116: static int PptpCalledNum(Link l, void *buf, size_t buf_len);
! 117:
! 118: static int PptpOriginate(Link l);
! 119: static void PptpDoClose(Link l);
! 120: static void PptpUnhook(Link l);
! 121: static void PptpResult(void *cookie, const char *errmsg, int frameType);
! 122: static void PptpSetLinkInfo(void *cookie, u_int32_t sa, u_int32_t ra);
! 123: static void PptpCancel(void *cookie);
! 124: static int PptpHookUp(Link l);
! 125: static void PptpListenUpdate(Link l);
! 126:
! 127: static struct pptplinkinfo PptpIncoming(struct pptpctrlinfo *cinfo,
! 128: struct u_addr *self, struct u_addr *peer, in_port_t port, int bearType,
! 129: const char *callingNum,
! 130: const char *calledNum,
! 131: const char *subAddress);
! 132:
! 133: static struct pptplinkinfo PptpOutgoing(struct pptpctrlinfo *cinfo,
! 134: struct u_addr *self, struct u_addr *peer, in_port_t port, int bearType,
! 135: int frameType, int minBps, int maxBps,
! 136: const char *calledNum,
! 137: const char *subAddress);
! 138:
! 139: static struct pptplinkinfo PptpPeerCall(struct pptpctrlinfo *cinfo,
! 140: struct u_addr *self, struct u_addr *peer, in_port_t port, int incoming,
! 141: const char *callingNum,
! 142: const char *calledNum,
! 143: const char *subAddress);
! 144:
! 145: static int PptpSetCommand(Context ctx, int ac, char *av[], void *arg);
! 146: static int PptpTunEQ(struct ghash *g, const void *item1, const void *item2);
! 147: static u_int32_t PptpTunHash(struct ghash *g, const void *item);
! 148:
! 149:
! 150: /*
! 151: * GLOBAL VARIABLES
! 152: */
! 153:
! 154: const struct phystype gPptpPhysType = {
! 155: .name = "pptp",
! 156: .descr = "Point-to-Point Tunneling Protocol",
! 157: .mtu = PPTP_MTU,
! 158: .mru = PPTP_MRU,
! 159: .tmpl = 1,
! 160: .tinit = PptpTInit,
! 161: .tshutdown = PptpTShutdown,
! 162: .init = PptpInit,
! 163: .inst = PptpInst,
! 164: .open = PptpOpen,
! 165: .close = PptpClose,
! 166: .update = PptpListenUpdate,
! 167: .shutdown = PptpShutdown,
! 168: .showstat = PptpStat,
! 169: .originate = PptpOriginated,
! 170: .issync = PptpIsSync,
! 171: .setaccm = PptpSetAccm,
! 172: .setcallingnum = PptpSetCallingNum,
! 173: .setcallednum = PptpSetCalledNum,
! 174: .selfname = PptpSelfName,
! 175: .peername = PptpPeerName,
! 176: .selfaddr = PptpSelfAddr,
! 177: .peeraddr = PptpPeerAddr,
! 178: .peerport = PptpPeerPort,
! 179: .peermacaddr = PptpPeerMacAddr,
! 180: .peeriface = PptpPeerIface,
! 181: .callingnum = PptpCallingNum,
! 182: .callednum = PptpCalledNum,
! 183: };
! 184:
! 185: const struct cmdtab PptpSetCmds[] = {
! 186: { "self {ip} [{port}]", "Set local IP address",
! 187: PptpSetCommand, NULL, 2, (void *) SET_SELFADDR },
! 188: { "peer {ip} [{port}]", "Set remote IP address",
! 189: PptpSetCommand, NULL, 2, (void *) SET_PEERADDR },
! 190: { "callingnum {number}", "Set calling PPTP telephone number",
! 191: PptpSetCommand, NULL, 2, (void *) SET_CALLINGNUM },
! 192: { "callednum {number}", "Set called PPTP telephone number",
! 193: PptpSetCommand, NULL, 2, (void *) SET_CALLEDNUM },
! 194: { "enable [opt ...]", "Enable option",
! 195: PptpSetCommand, NULL, 2, (void *) SET_ENABLE },
! 196: { "disable [opt ...]", "Disable option",
! 197: PptpSetCommand, NULL, 2, (void *) SET_DISABLE },
! 198: { NULL },
! 199: };
! 200:
! 201: /*
! 202: * INTERNAL VARIABLES
! 203: */
! 204:
! 205: static struct confinfo gConfList[] = {
! 206: { 0, PPTP_CONF_OUTCALL, "outcall" },
! 207: { 0, PPTP_CONF_DELAYED_ACK, "delayed-ack" },
! 208: { 0, PPTP_CONF_ALWAYS_ACK, "always-ack" },
! 209: { 0, PPTP_CONF_RESOLVE_ONCE, "resolve-once" },
! 210: #if NGM_PPTPGRE_COOKIE >= 1082548365
! 211: { 0, PPTP_CONF_WINDOWING, "windowing" },
! 212: #endif
! 213: { 0, 0, NULL },
! 214: };
! 215:
! 216: struct ghash *gPptpTuns;
! 217:
! 218: /*
! 219: * PptpTInit()
! 220: */
! 221:
! 222: static int
! 223: PptpTInit(void)
! 224: {
! 225: if ((gPptpTuns = ghash_create(NULL, 0, 0, MB_PHYS, PptpTunHash, PptpTunEQ, NULL, NULL))
! 226: == NULL)
! 227: return(-1);
! 228: return (PptpCtrlInit(PptpIncoming, PptpOutgoing));
! 229: }
! 230:
! 231: /*
! 232: * PptpTShutdown()
! 233: */
! 234:
! 235: static void
! 236: PptpTShutdown(void)
! 237: {
! 238: Log(LG_PHYS2, ("PPTP: Total shutdown"));
! 239: ghash_destroy(&gPptpTuns);
! 240: }
! 241:
! 242: /*
! 243: * PptpInit()
! 244: */
! 245:
! 246: static int
! 247: PptpInit(Link l)
! 248: {
! 249: PptpInfo pptp;
! 250:
! 251: /* Initialize this link */
! 252: pptp = (PptpInfo) (l->info = Malloc(MB_PHYS, sizeof(*pptp)));
! 253:
! 254: pptp->conf.self_addr.family = AF_INET;
! 255: pptp->conf.fqdn_peer_addr = NULL;
! 256: Enable(&pptp->conf.options, PPTP_CONF_OUTCALL);
! 257: Enable(&pptp->conf.options, PPTP_CONF_DELAYED_ACK);
! 258: Enable(&pptp->conf.options, PPTP_CONF_RESOLVE_ONCE);
! 259:
! 260: return(0);
! 261: }
! 262:
! 263: /*
! 264: * PptpInst()
! 265: */
! 266:
! 267: static int
! 268: PptpInst(Link l, Link lt)
! 269: {
! 270: PptpInfo pptp;
! 271: PptpInfo const pptpt = (PptpInfo) lt->info;
! 272:
! 273: /* Initialize this link */
! 274: pptp = (PptpInfo) (l->info = Mdup(MB_PHYS, lt->info, sizeof(*pptp)));
! 275: if (pptpt->conf.fqdn_peer_addr != NULL)
! 276: pptp->conf.fqdn_peer_addr =
! 277: Mstrdup(MB_PHYS, pptpt->conf.fqdn_peer_addr);
! 278: pptp->listener = NULL;
! 279:
! 280: return(0);
! 281: }
! 282:
! 283: /*
! 284: * PptpOpen()
! 285: */
! 286:
! 287: static void
! 288: PptpOpen(Link l)
! 289: {
! 290: PptpInfo const pptp = (PptpInfo) l->info;
! 291: struct sockaddr_dl hwa;
! 292:
! 293: /* Check state */
! 294: switch (l->state) {
! 295: case PHYS_STATE_DOWN:
! 296: if (PptpOriginate(l) < 0) {
! 297: Log(LG_PHYS, ("[%s] PPTP call failed", l->name));
! 298: PhysDown(l, STR_ERROR, NULL);
! 299: return;
! 300: }
! 301: l->state = PHYS_STATE_CONNECTING;
! 302: break;
! 303:
! 304: case PHYS_STATE_CONNECTING:
! 305: if (pptp->originate) /* our call to peer is already in progress */
! 306: break;
! 307: if (pptp->outcall) {
! 308:
! 309: /* Hook up nodes */
! 310: Log(LG_PHYS, ("[%s] PPTP: attaching to peer's outgoing call", l->name));
! 311: if (PptpHookUp(l) < 0) {
! 312: PptpDoClose(l);
! 313: /* We should not set state=DOWN as PptpResult() will be called once more */
! 314: break;
! 315: }
! 316:
! 317: if (GetPeerEther(&pptp->peer_addr, &hwa)) {
! 318: if_indextoname(hwa.sdl_index, pptp->peer_iface);
! 319: memcpy(pptp->peer_mac_addr, LLADDR(&hwa), sizeof(pptp->peer_mac_addr));
! 320: };
! 321:
! 322: (*pptp->cinfo.answer)(pptp->cinfo.cookie,
! 323: PPTP_OCR_RESL_OK, 0, 0, 64000 /*XXX*/ );
! 324:
! 325: /* Report UP if there was no error. */
! 326: if (l->state == PHYS_STATE_CONNECTING) {
! 327: l->state = PHYS_STATE_UP;
! 328: PhysUp(l);
! 329: }
! 330: return;
! 331: }
! 332: return; /* wait for peer's incoming pptp call to complete */
! 333:
! 334: case PHYS_STATE_UP:
! 335: PhysUp(l);
! 336: return;
! 337:
! 338: default:
! 339: assert(0);
! 340: }
! 341: }
! 342:
! 343: /*
! 344: * PptpOriginate()
! 345: *
! 346: * Initiate an "incoming" or an "outgoing" call to the remote site
! 347: */
! 348:
! 349: static int
! 350: PptpOriginate(Link l)
! 351: {
! 352: PptpInfo const pptp = (PptpInfo) l->info;
! 353: struct pptplinkinfo linfo;
! 354: const u_short port = pptp->conf.peer_port ?
! 355: pptp->conf.peer_port : PPTP_PORT;
! 356:
! 357: pptp->originate = TRUE;
! 358: pptp->outcall = Enabled(&pptp->conf.options, PPTP_CONF_OUTCALL);
! 359: memset(&linfo, 0, sizeof(linfo));
! 360: linfo.cookie = l;
! 361: linfo.result = PptpResult;
! 362: linfo.setLinkInfo = PptpSetLinkInfo;
! 363: linfo.cancel = PptpCancel;
! 364: strlcpy(pptp->callingnum, pptp->conf.callingnum, sizeof(pptp->callingnum));
! 365: strlcpy(pptp->callednum, pptp->conf.callednum, sizeof(pptp->callednum));
! 366: if ((!Enabled(&pptp->conf.options, PPTP_CONF_RESOLVE_ONCE)) &&
! 367: (pptp->conf.fqdn_peer_addr != NULL)) {
! 368: struct u_range rng;
! 369: if (ParseRange(pptp->conf.fqdn_peer_addr, &rng, ALLOW_IPV4|ALLOW_IPV6))
! 370: pptp->conf.peer_addr = rng;
! 371: }
! 372: if (!pptp->outcall) {
! 373: int frameType = PPTP_FRAMECAP_SYNC;
! 374: if (l->rep && !RepIsSync(l))
! 375: frameType = PPTP_FRAMECAP_ASYNC;
! 376: PptpCtrlInCall(&pptp->cinfo, &linfo,
! 377: &pptp->conf.self_addr, &pptp->conf.peer_addr.addr, port,
! 378: PPTP_BEARCAP_ANY, frameType,
! 379: PPTP_CALL_MIN_BPS, PPTP_CALL_MAX_BPS,
! 380: pptp->callingnum, pptp->callednum, "");
! 381: } else {
! 382: PptpCtrlOutCall(&pptp->cinfo, &linfo,
! 383: &pptp->conf.self_addr, &pptp->conf.peer_addr.addr, port,
! 384: PPTP_BEARCAP_ANY, PPTP_FRAMECAP_ANY,
! 385: PPTP_CALL_MIN_BPS, PPTP_CALL_MAX_BPS,
! 386: pptp->callednum, "");
! 387: }
! 388: if (pptp->cinfo.cookie == NULL)
! 389: return(-1);
! 390: pptp->self_addr = pptp->conf.self_addr;
! 391: pptp->peer_addr = pptp->conf.peer_addr.addr;
! 392: pptp->peer_port = port;
! 393: return(0);
! 394: }
! 395:
! 396: /*
! 397: * PptpClose()
! 398: */
! 399:
! 400: static void
! 401: PptpClose(Link l)
! 402: {
! 403: PptpDoClose(l);
! 404: }
! 405:
! 406: /*
! 407: * PptpShutdown()
! 408: */
! 409:
! 410: static void
! 411: PptpShutdown(Link l)
! 412: {
! 413: PptpInfo const pptp = (PptpInfo) l->info;
! 414:
! 415:
! 416: if (pptp->conf.fqdn_peer_addr)
! 417: Freee(pptp->conf.fqdn_peer_addr);
! 418: if (pptp->listener) {
! 419: PptpCtrlUnListen(pptp->listener);
! 420: pptp->listener = NULL;
! 421: }
! 422: PptpUnhook(l);
! 423: Freee(l->info);
! 424: }
! 425:
! 426: /*
! 427: * PptpDoClose()
! 428: */
! 429:
! 430: static void
! 431: PptpDoClose(Link l)
! 432: {
! 433: PptpInfo const pptp = (PptpInfo) l->info;
! 434:
! 435: if (l->state != PHYS_STATE_DOWN) /* avoid double close */
! 436: (*pptp->cinfo.close)(pptp->cinfo.cookie, PPTP_CDN_RESL_ADMIN, 0, 0);
! 437: }
! 438:
! 439: /*
! 440: * PptpUnhook()
! 441: */
! 442:
! 443: static void
! 444: PptpUnhook(Link l)
! 445: {
! 446: PptpInfo const pptp = (PptpInfo) l->info;
! 447: char path[NG_PATHSIZ];
! 448: int csock = -1;
! 449:
! 450: if (pptp->tun == NULL)
! 451: return;
! 452:
! 453: /* Get a temporary netgraph socket node */
! 454: if (NgMkSockNode(NULL, &csock, NULL) == -1) {
! 455: Perror("PPTP: NgMkSockNode");
! 456: return;
! 457: }
! 458:
! 459: pptp->tun->refs--;
! 460: snprintf(path, sizeof(path), "[%lx]:", (u_long)pptp->tun->node_id);
! 461: if (pptp->tun->refs == 0) {
! 462: /* Disconnect session hook. */
! 463: NgFuncShutdownNode(csock, l->name, path);
! 464: ghash_remove(gPptpTuns, pptp->tun);
! 465: Freee(pptp->tun);
! 466: #ifdef NG_PPTPGRE_HOOK_SESSION_F
! 467: } else {
! 468: char hook[NG_HOOKSIZ];
! 469: snprintf(hook, sizeof(hook), NG_PPTPGRE_HOOK_SESSION_F, pptp->cid);
! 470: NgFuncDisconnect(csock, l->name, path, hook);
! 471: #endif
! 472: }
! 473:
! 474: close(csock);
! 475:
! 476: pptp->tun = NULL;
! 477: }
! 478:
! 479: /*
! 480: * PptpOriginated()
! 481: */
! 482:
! 483: static int
! 484: PptpOriginated(Link l)
! 485: {
! 486: PptpInfo const pptp = (PptpInfo) l->info;
! 487:
! 488: return(pptp->originate ? LINK_ORIGINATE_LOCAL : LINK_ORIGINATE_REMOTE);
! 489: }
! 490:
! 491: /*
! 492: * PptpIsSync()
! 493: */
! 494:
! 495: static int
! 496: PptpIsSync(Link l)
! 497: {
! 498: PptpInfo const pptp = (PptpInfo) l->info;
! 499:
! 500: return (pptp->sync);
! 501: }
! 502:
! 503: static int
! 504: PptpSetAccm(Link l, u_int32_t xmit, u_int32_t recv)
! 505: {
! 506: PptpInfo const pptp = (PptpInfo) l->info;
! 507:
! 508: if (!pptp->cinfo.close || !pptp->cinfo.cookie)
! 509: return (-1);
! 510:
! 511: (*pptp->cinfo.setLinkInfo)(pptp->cinfo.cookie, xmit, recv);
! 512: return (0);
! 513: }
! 514:
! 515: static int
! 516: PptpSetCallingNum(Link l, void *buf)
! 517: {
! 518: PptpInfo const pptp = (PptpInfo) l->info;
! 519:
! 520: strlcpy(pptp->conf.callingnum, buf, sizeof(pptp->conf.callingnum));
! 521: return(0);
! 522: }
! 523:
! 524: static int
! 525: PptpSetCalledNum(Link l, void *buf)
! 526: {
! 527: PptpInfo const pptp = (PptpInfo) l->info;
! 528:
! 529: strlcpy(pptp->conf.callednum, buf, sizeof(pptp->conf.callednum));
! 530: return(0);
! 531: }
! 532:
! 533: static int
! 534: PptpSelfName(Link l, void *buf, size_t buf_len)
! 535: {
! 536: PptpInfo const pptp = (PptpInfo) l->info;
! 537:
! 538: if (pptp->cinfo.cookie)
! 539: return(PptpCtrlGetSelfName(&pptp->cinfo, buf, buf_len));
! 540: ((char*)buf)[0]=0;
! 541: return (0);
! 542: }
! 543:
! 544: static int
! 545: PptpPeerName(Link l, void *buf, size_t buf_len)
! 546: {
! 547: PptpInfo const pptp = (PptpInfo) l->info;
! 548:
! 549: if (pptp->cinfo.cookie)
! 550: return(PptpCtrlGetPeerName(&pptp->cinfo, buf, buf_len));
! 551: ((char*)buf)[0]=0;
! 552: return (0);
! 553: }
! 554:
! 555: static int
! 556: PptpSelfAddr(Link l, void *buf, size_t buf_len)
! 557: {
! 558: PptpInfo const pptp = (PptpInfo) l->info;
! 559:
! 560: if (u_addrtoa(&pptp->self_addr, buf, buf_len))
! 561: return(0);
! 562: else
! 563: return(-1);
! 564: }
! 565:
! 566: static int
! 567: PptpPeerAddr(Link l, void *buf, size_t buf_len)
! 568: {
! 569: PptpInfo const pptp = (PptpInfo) l->info;
! 570:
! 571: if (u_addrtoa(&pptp->peer_addr, buf, buf_len))
! 572: return(0);
! 573: else
! 574: return(-1);
! 575: }
! 576:
! 577: static int
! 578: PptpPeerPort(Link l, void *buf, size_t buf_len)
! 579: {
! 580: PptpInfo const pptp = (PptpInfo) l->info;
! 581:
! 582: if (snprintf(buf, buf_len, "%d", pptp->peer_port))
! 583: return(0);
! 584: else
! 585: return(-1);
! 586: }
! 587:
! 588: static int
! 589: PptpPeerMacAddr(Link l, void *buf, size_t buf_len)
! 590: {
! 591: PptpInfo const pptp = (PptpInfo) l->info;
! 592:
! 593: if (pptp->peer_iface[0]) {
! 594: snprintf(buf, buf_len, "%02x:%02x:%02x:%02x:%02x:%02x",
! 595: pptp->peer_mac_addr[0], pptp->peer_mac_addr[1],
! 596: pptp->peer_mac_addr[2], pptp->peer_mac_addr[3],
! 597: pptp->peer_mac_addr[4], pptp->peer_mac_addr[5]);
! 598: return (0);
! 599: }
! 600: ((char*)buf)[0]=0;
! 601: return(0);
! 602: }
! 603:
! 604: static int
! 605: PptpPeerIface(Link l, void *buf, size_t buf_len)
! 606: {
! 607: PptpInfo const pptp = (PptpInfo) l->info;
! 608:
! 609: if (pptp->peer_iface[0]) {
! 610: strlcpy(buf, pptp->peer_iface, buf_len);
! 611: return (0);
! 612: }
! 613: ((char*)buf)[0]=0;
! 614: return(0);
! 615: }
! 616:
! 617: static int
! 618: PptpCallingNum(Link l, void *buf, size_t buf_len)
! 619: {
! 620: PptpInfo const pptp = (PptpInfo) l->info;
! 621:
! 622: strlcpy((char*)buf, pptp->callingnum, buf_len);
! 623: return(0);
! 624: }
! 625:
! 626: static int
! 627: PptpCalledNum(Link l, void *buf, size_t buf_len)
! 628: {
! 629: PptpInfo const pptp = (PptpInfo) l->info;
! 630:
! 631: strlcpy((char*)buf, pptp->callednum, buf_len);
! 632: return(0);
! 633: }
! 634:
! 635: /*
! 636: * PptpStat()
! 637: */
! 638:
! 639: void
! 640: PptpStat(Context ctx)
! 641: {
! 642: PptpInfo const pptp = (PptpInfo) ctx->lnk->info;
! 643: char buf[32];
! 644:
! 645: Printf("PPTP configuration:\r\n");
! 646: Printf("\tSelf addr : %s",
! 647: u_addrtoa(&pptp->conf.self_addr, buf, sizeof(buf)));
! 648: if (pptp->conf.self_port)
! 649: Printf(", port %u", pptp->conf.self_port);
! 650: Printf("\r\n");
! 651: Printf("\tPeer FQDN : %s\r\n", pptp->conf.fqdn_peer_addr);
! 652: Printf("\tPeer range : %s",
! 653: u_rangetoa(&pptp->conf.peer_addr, buf, sizeof(buf)));
! 654: if (pptp->conf.peer_port)
! 655: Printf(", port %u", pptp->conf.peer_port);
! 656: Printf("\r\n");
! 657: Printf("\tCalling number: %s\r\n", pptp->conf.callingnum);
! 658: Printf("\tCalled number: %s\r\n", pptp->conf.callednum);
! 659: Printf("PPTP options:\r\n");
! 660: OptStat(ctx, &pptp->conf.options, gConfList);
! 661: Printf("PPTP status:\r\n");
! 662: if (ctx->lnk->state != PHYS_STATE_DOWN) {
! 663: Printf("\tIncoming : %s\r\n", (pptp->originate?"NO":"YES"));
! 664: Printf("\tCurrent self : %s",
! 665: u_addrtoa(&pptp->self_addr, buf, sizeof(buf)));
! 666: PptpSelfName(ctx->lnk, buf, sizeof(buf));
! 667: Printf(" (%s)\r\n", buf);
! 668: Printf("\tCurrent peer : %s, port %u",
! 669: u_addrtoa(&pptp->peer_addr, buf, sizeof(buf)), pptp->peer_port);
! 670: PptpPeerName(ctx->lnk, buf, sizeof(buf));
! 671: Printf(" (%s)\r\n", buf);
! 672: if (pptp->peer_iface[0]) {
! 673: Printf("\tCurrent peer : %02x:%02x:%02x:%02x:%02x:%02x at %s\r\n",
! 674: pptp->peer_mac_addr[0], pptp->peer_mac_addr[1],
! 675: pptp->peer_mac_addr[2], pptp->peer_mac_addr[3],
! 676: pptp->peer_mac_addr[4], pptp->peer_mac_addr[5],
! 677: pptp->peer_iface);
! 678: }
! 679: Printf("\tFraming : %s\r\n", (pptp->sync?"Sync":"Async"));
! 680: Printf("\tCalling number: %s\r\n", pptp->callingnum);
! 681: Printf("\tCalled number: %s\r\n", pptp->callednum);
! 682: }
! 683: }
! 684:
! 685: /*
! 686: * PptpResult()
! 687: *
! 688: * The control code calls this function to report a PPTP link
! 689: * being connected, disconnected, or failing to connect.
! 690: */
! 691:
! 692: static void
! 693: PptpResult(void *cookie, const char *errmsg, int frameType)
! 694: {
! 695: PptpInfo pptp;
! 696: Link l;
! 697: struct sockaddr_dl hwa;
! 698:
! 699: /* It this fake call? */
! 700: if (!cookie)
! 701: return;
! 702:
! 703: l = (Link)cookie;
! 704: pptp = (PptpInfo) l->info;
! 705:
! 706: switch (l->state) {
! 707: case PHYS_STATE_CONNECTING:
! 708: if (!errmsg) {
! 709:
! 710: /* Hook up nodes */
! 711: Log(LG_PHYS, ("[%s] PPTP call successful", l->name));
! 712: if (PptpHookUp(l) < 0) {
! 713: PptpDoClose(l);
! 714: /* We should not set state=DOWN as PptpResult() will be called once more */
! 715: break;
! 716: }
! 717:
! 718: if (pptp->originate && !pptp->outcall)
! 719: (*pptp->cinfo.connected)(pptp->cinfo.cookie, 64000 /*XXX*/ );
! 720:
! 721: /* Report UP if there was no error. */
! 722: if (l->state == PHYS_STATE_CONNECTING) {
! 723: if (GetPeerEther(&pptp->peer_addr, &hwa)) {
! 724: if_indextoname(hwa.sdl_index, pptp->peer_iface);
! 725: memcpy(pptp->peer_mac_addr, LLADDR(&hwa), sizeof(pptp->peer_mac_addr));
! 726: };
! 727:
! 728: /* OK */
! 729: l->state = PHYS_STATE_UP;
! 730: pptp->sync = (frameType&PPTP_FRAMECAP_ASYNC)?0:1;
! 731: PhysUp(l);
! 732: }
! 733: } else {
! 734: Log(LG_PHYS, ("[%s] PPTP call failed", l->name));
! 735: PptpUnhook(l); /* For the (*connected)() error. */
! 736: l->state = PHYS_STATE_DOWN;
! 737: u_addrclear(&pptp->self_addr);
! 738: u_addrclear(&pptp->peer_addr);
! 739: pptp->peer_port = 0;
! 740: pptp->callingnum[0]=0;
! 741: pptp->callednum[0]=0;
! 742: pptp->peer_iface[0] = 0;
! 743: PhysDown(l, STR_CON_FAILED, errmsg);
! 744: }
! 745: break;
! 746: case PHYS_STATE_UP:
! 747: assert(errmsg);
! 748: Log(LG_PHYS, ("[%s] PPTP call terminated", l->name));
! 749: PptpUnhook(l);
! 750: l->state = PHYS_STATE_DOWN;
! 751: u_addrclear(&pptp->self_addr);
! 752: u_addrclear(&pptp->peer_addr);
! 753: pptp->peer_port = 0;
! 754: pptp->callingnum[0]=0;
! 755: pptp->callednum[0]=0;
! 756: pptp->peer_iface[0] = 0;
! 757: PhysDown(l, STR_DROPPED, NULL);
! 758: break;
! 759: case PHYS_STATE_DOWN:
! 760: return;
! 761: default:
! 762: assert(0);
! 763: }
! 764: }
! 765:
! 766: /*
! 767: * PptpSetLinkInfo()
! 768: *
! 769: * Received LinkInfo from peer;
! 770: */
! 771:
! 772: void
! 773: PptpSetLinkInfo(void *cookie, u_int32_t sa, u_int32_t ra)
! 774: {
! 775: Link l;
! 776:
! 777: /* It this fake call? */
! 778: if (!cookie)
! 779: return;
! 780:
! 781: l = (Link)cookie;
! 782:
! 783: if (l->rep != NULL)
! 784: RepSetAccm(l, sa, ra);
! 785: }
! 786:
! 787: static int
! 788: PptpTunEQ(struct ghash *g, const void *item1, const void *item2)
! 789: {
! 790: const struct pptptun *tun1 = item1;
! 791: const struct pptptun *tun2 = item2;
! 792: if (u_addrcompare(&tun1->self_addr, &tun2->self_addr) == 0 &&
! 793: u_addrcompare(&tun1->peer_addr, &tun2->peer_addr) == 0)
! 794: return (1);
! 795: return (0);
! 796: }
! 797:
! 798: static u_int32_t
! 799: PptpTunHash(struct ghash *g, const void *item)
! 800: {
! 801: const struct pptptun *tun = item;
! 802: return (u_addrtoid(&tun->self_addr) + u_addrtoid(&tun->peer_addr));
! 803: }
! 804:
! 805: /*
! 806: * PptpHookUp()
! 807: *
! 808: * Connect the PPTP/GRE node to the PPP node
! 809: */
! 810:
! 811: static int
! 812: PptpHookUp(Link l)
! 813: {
! 814: const PptpInfo pi = (PptpInfo)l->info;
! 815: char ksockpath[NG_PATHSIZ];
! 816: char pptppath[NG_PATHSIZ];
! 817: struct ngm_mkpeer mkp;
! 818: struct ng_pptpgre_conf gc;
! 819: struct sockaddr_storage self_addr, peer_addr;
! 820: struct u_addr u_self_addr, u_peer_addr;
! 821: union {
! 822: u_char buf[sizeof(struct ng_ksocket_sockopt) + sizeof(int)];
! 823: struct ng_ksocket_sockopt ksso;
! 824: } u;
! 825: struct ng_ksocket_sockopt *const ksso = &u.ksso;
! 826: int csock = -1;
! 827: char path[NG_PATHSIZ];
! 828: char hook[NG_HOOKSIZ];
! 829: PptpTun tun = NULL;
! 830:
! 831: /* Get session info */
! 832: memset(&gc, 0, sizeof(gc));
! 833: PptpCtrlGetSessionInfo(&pi->cinfo, &u_self_addr,
! 834: &u_peer_addr, &gc.cid, &gc.peerCid, &gc.recvWin, &gc.peerPpd);
! 835: pi->cid = gc.cid;
! 836:
! 837: u_addrtosockaddr(&u_self_addr, 0, &self_addr);
! 838: u_addrtosockaddr(&u_peer_addr, 0, &peer_addr);
! 839:
! 840: if (!PhysGetUpperHook(l, path, hook)) {
! 841: Log(LG_PHYS, ("[%s] PPTP: can't get upper hook", l->name));
! 842: return(-1);
! 843: }
! 844:
! 845: /* Get a temporary netgraph socket node */
! 846: if (NgMkSockNode(NULL, &csock, NULL) == -1) {
! 847: Perror("PPTP: NgMkSockNode");
! 848: return(-1);
! 849: }
! 850:
! 851: #ifdef NG_PPTPGRE_HOOK_SESSION_F
! 852: {
! 853: struct pptptun tmptun;
! 854: tmptun.self_addr = u_self_addr;
! 855: tmptun.peer_addr = u_peer_addr;
! 856: tun = ghash_get(gPptpTuns, &tmptun);
! 857: }
! 858: #endif
! 859:
! 860: snprintf(pptppath, sizeof(pptppath), "%s.%s", path, hook);
! 861: if (tun == NULL) {
! 862: tun = (PptpTun)Malloc(MB_PHYS, sizeof(*tun));
! 863: tun->self_addr = u_self_addr;
! 864: tun->peer_addr = u_peer_addr;
! 865: if (ghash_put(gPptpTuns, tun) == -1) {
! 866: Perror("[%s] PPTP: ghash_put", l->name);
! 867: Freee(tun);
! 868: close(csock);
! 869: return(-1);
! 870: }
! 871:
! 872: /* Attach PPTP/GRE node to PPP node */
! 873: strcpy(mkp.type, NG_PPTPGRE_NODE_TYPE);
! 874: strlcpy(mkp.ourhook, hook, sizeof(mkp.ourhook));
! 875: #ifdef NG_PPTPGRE_HOOK_SESSION_F
! 876: snprintf(mkp.peerhook, sizeof(mkp.peerhook), NG_PPTPGRE_HOOK_SESSION_F, pi->cid);
! 877: #else
! 878: strcpy(mkp.peerhook, NG_PPTPGRE_HOOK_UPPER);
! 879: #endif
! 880: if (NgSendMsg(csock, path, NGM_GENERIC_COOKIE,
! 881: NGM_MKPEER, &mkp, sizeof(mkp)) < 0) {
! 882: Perror("[%s] PPTP: can't attach %s node", l->name, NG_PPTPGRE_NODE_TYPE);
! 883: ghash_remove(gPptpTuns, tun);
! 884: Freee(tun);
! 885: close(csock);
! 886: return(-1);
! 887: }
! 888:
! 889: /* Get pptpgre node ID */
! 890: if ((tun->node_id = NgGetNodeID(csock, pptppath)) == 0) {
! 891: Perror("[%s] Cannot get %s node id", l->name, NG_PPTPGRE_NODE_TYPE);
! 892: ghash_remove(gPptpTuns, tun);
! 893: Freee(tun);
! 894: close(csock);
! 895: return(-1);
! 896: };
! 897: tun->refs++;
! 898: pi->tun = tun;
! 899:
! 900: /* Attach ksocket node to PPTP/GRE node */
! 901: strcpy(mkp.type, NG_KSOCKET_NODE_TYPE);
! 902: strcpy(mkp.ourhook, NG_PPTPGRE_HOOK_LOWER);
! 903: if (u_self_addr.family==AF_INET6) {
! 904: //ng_ksocket doesn't support inet6 name
! 905: snprintf(mkp.peerhook, sizeof(mkp.peerhook), "%d/%d/%d", PF_INET6, SOCK_RAW, IPPROTO_GRE);
! 906: } else {
! 907: snprintf(mkp.peerhook, sizeof(mkp.peerhook), "inet/raw/gre");
! 908: }
! 909: if (NgSendMsg(csock, pptppath, NGM_GENERIC_COOKIE,
! 910: NGM_MKPEER, &mkp, sizeof(mkp)) < 0) {
! 911: Perror("[%s] PPTP: can't attach %s node", l->name, NG_KSOCKET_NODE_TYPE);
! 912: close(csock);
! 913: return(-1);
! 914: }
! 915: snprintf(ksockpath, sizeof(ksockpath),
! 916: "%s.%s", pptppath, NG_PPTPGRE_HOOK_LOWER);
! 917:
! 918: /* increase recvspace to avoid packet loss due to very small GRE recv buffer. */
! 919: ksso->level=SOL_SOCKET;
! 920: ksso->name=SO_RCVBUF;
! 921: ((int *)(ksso->value))[0]=48*1024;
! 922: if (NgSendMsg(csock, ksockpath, NGM_KSOCKET_COOKIE,
! 923: NGM_KSOCKET_SETOPT, &u, sizeof(u)) < 0) {
! 924: Perror("[%s] PPTP: can't setsockopt %s node",
! 925: l->name, NG_KSOCKET_NODE_TYPE);
! 926: }
! 927:
! 928: /* Bind ksocket socket to local IP address */
! 929: if (NgSendMsg(csock, ksockpath, NGM_KSOCKET_COOKIE,
! 930: NGM_KSOCKET_BIND, &self_addr, self_addr.ss_len) < 0) {
! 931: Perror("[%s] PPTP: can't bind() %s node", l->name, NG_KSOCKET_NODE_TYPE);
! 932: close(csock);
! 933: return(-1);
! 934: }
! 935:
! 936: /* Connect ksocket socket to remote IP address */
! 937: if (NgSendMsg(csock, ksockpath, NGM_KSOCKET_COOKIE,
! 938: NGM_KSOCKET_CONNECT, &peer_addr, peer_addr.ss_len) < 0 &&
! 939: errno != EINPROGRESS) { /* happens in -current (weird) */
! 940: Perror("[%s] PPTP: can't connect() %s node",
! 941: l->name, NG_KSOCKET_NODE_TYPE);
! 942: close(csock);
! 943: return(-1);
! 944: }
! 945: #ifdef NG_PPTPGRE_HOOK_SESSION_F
! 946: } else {
! 947: struct ngm_connect cn;
! 948: snprintf(cn.path, sizeof(cn.path), "[%x]:", tun->node_id);
! 949: strlcpy(cn.ourhook, hook, sizeof(mkp.ourhook));
! 950: snprintf(cn.peerhook, sizeof(mkp.peerhook), NG_PPTPGRE_HOOK_SESSION_F, pi->cid);
! 951: if (NgSendMsg(csock, path, NGM_GENERIC_COOKIE,
! 952: NGM_CONNECT, &cn, sizeof(cn)) < 0) {
! 953: Perror("[%s] PPTP: can't connect to %s node",
! 954: l->name, NG_PPTPGRE_NODE_TYPE);
! 955: close(csock);
! 956: return(-1);
! 957: }
! 958: tun->refs++;
! 959: pi->tun = tun;
! 960: #endif
! 961: }
! 962:
! 963: /* Configure PPTP/GRE node */
! 964: gc.enabled = 1;
! 965: gc.enableDelayedAck = Enabled(&pi->conf.options, PPTP_CONF_DELAYED_ACK);
! 966: gc.enableAlwaysAck = Enabled(&pi->conf.options, PPTP_CONF_ALWAYS_ACK);
! 967: #if NGM_PPTPGRE_COOKIE >= 1082548365
! 968: gc.enableWindowing = Enabled(&pi->conf.options, PPTP_CONF_WINDOWING);
! 969: #endif
! 970:
! 971: if (NgSendMsg(csock, pptppath, NGM_PPTPGRE_COOKIE,
! 972: NGM_PPTPGRE_SET_CONFIG, &gc, sizeof(gc)) < 0) {
! 973: Perror("[%s] PPTP: can't config %s node", l->name, NG_PPTPGRE_NODE_TYPE);
! 974: close(csock);
! 975: return(-1);
! 976: }
! 977:
! 978: close(csock);
! 979:
! 980: return(0);
! 981: }
! 982:
! 983: /*
! 984: * PptpIncoming()
! 985: *
! 986: * The control code calls this function to report that some
! 987: * remote PPTP client has asked us if we will accept an incoming
! 988: * call relayed over PPTP.
! 989: */
! 990:
! 991: static struct pptplinkinfo
! 992: PptpIncoming(struct pptpctrlinfo *cinfo,
! 993: struct u_addr *self, struct u_addr *peer, in_port_t port, int bearType,
! 994: const char *callingNum,
! 995: const char *calledNum,
! 996: const char *subAddress)
! 997: {
! 998: return(PptpPeerCall(cinfo, self, peer, port, TRUE, callingNum, calledNum, subAddress));
! 999: }
! 1000:
! 1001: /*
! 1002: * PptpOutgoing()
! 1003: *
! 1004: * The control code calls this function to report that some
! 1005: * remote PPTP client has asked us if we will dial out to some
! 1006: * phone number. We don't actually do this, but some clients
! 1007: * initiate their connections as outgoing calls for some reason.
! 1008: */
! 1009:
! 1010: static struct pptplinkinfo
! 1011: PptpOutgoing(struct pptpctrlinfo *cinfo,
! 1012: struct u_addr *self, struct u_addr *peer, in_port_t port, int bearType,
! 1013: int frameType, int minBps, int maxBps,
! 1014: const char *calledNum, const char *subAddress)
! 1015: {
! 1016: return(PptpPeerCall(cinfo, self, peer, port, FALSE, "", calledNum, subAddress));
! 1017: }
! 1018:
! 1019: /*
! 1020: * PptpPeerCall()
! 1021: *
! 1022: * Peer has initiated a call (either incoming or outgoing; either
! 1023: * way it's the same to us). If we have an available link that may
! 1024: * accept calls from the peer's IP addresss and port, then say yes.
! 1025: */
! 1026:
! 1027: static struct pptplinkinfo
! 1028: PptpPeerCall(struct pptpctrlinfo *cinfo,
! 1029: struct u_addr *self, struct u_addr *peer, in_port_t port, int incoming,
! 1030: const char *callingNum,
! 1031: const char *calledNum,
! 1032: const char *subAddress)
! 1033: {
! 1034: struct pptplinkinfo linfo;
! 1035: Link l = NULL;
! 1036: PptpInfo pi = NULL;
! 1037: int k;
! 1038:
! 1039: memset(&linfo, 0, sizeof(linfo));
! 1040:
! 1041: linfo.cookie = NULL;
! 1042: linfo.result = PptpResult;
! 1043: linfo.setLinkInfo = PptpSetLinkInfo;
! 1044: linfo.cancel = PptpCancel;
! 1045:
! 1046: if (gShutdownInProgress) {
! 1047: Log(LG_PHYS, ("Shutdown sequence in progress, ignoring request."));
! 1048: return(linfo);
! 1049: }
! 1050:
! 1051: if (OVERLOAD()) {
! 1052: Log(LG_PHYS, ("Daemon overloaded, ignoring request."));
! 1053: return(linfo);
! 1054: }
! 1055:
! 1056: /* Find a suitable link; prefer the link best matching peer's IP address */
! 1057: for (k = 0; k < gNumLinks; k++) {
! 1058: Link l2;
! 1059: PptpInfo pi2;
! 1060:
! 1061: if (!gLinks[k] || gLinks[k]->type != &gPptpPhysType)
! 1062: continue;
! 1063:
! 1064: l2 = gLinks[k];
! 1065: pi2 = (PptpInfo)l2->info;
! 1066:
! 1067: /* See if link is feasible */
! 1068: if ((!PhysIsBusy(l2)) &&
! 1069: Enabled(&l2->conf.options, LINK_CONF_INCOMING) &&
! 1070: (u_addrempty(&pi2->conf.self_addr) || (u_addrcompare(&pi2->conf.self_addr, self) == 0)) &&
! 1071: IpAddrInRange(&pi2->conf.peer_addr, peer) &&
! 1072: (!pi2->conf.peer_port || pi2->conf.peer_port == port)) {
! 1073:
! 1074: /* Link is feasible; now see if it's preferable */
! 1075: if (!pi || pi2->conf.peer_addr.width > pi->conf.peer_addr.width) {
! 1076: l = l2;
! 1077: pi = pi2;
! 1078: if (u_rangehost(&pi->conf.peer_addr)) {
! 1079: break; /* Nothing could be better */
! 1080: }
! 1081: }
! 1082: }
! 1083: }
! 1084:
! 1085: if (l != NULL && l->tmpl)
! 1086: l = LinkInst(l, NULL, 0, 0);
! 1087:
! 1088: /* If no link is suitable, can't take the call */
! 1089: if (l == NULL) {
! 1090: Log(LG_PHYS, ("No free PPTP link with requested parameters "
! 1091: "was found"));
! 1092: return(linfo);
! 1093: }
! 1094: pi = (PptpInfo)l->info;
! 1095:
! 1096: Log(LG_PHYS, ("[%s] Accepting PPTP connection", l->name));
! 1097:
! 1098: /* Got one */
! 1099: linfo.cookie = l;
! 1100: l->state = PHYS_STATE_CONNECTING;
! 1101: pi->cinfo = *cinfo;
! 1102: pi->originate = FALSE;
! 1103: pi->outcall = !incoming;
! 1104: pi->sync = 1;
! 1105: pi->self_addr = *self;
! 1106: pi->peer_addr = *peer;
! 1107: pi->peer_port = port;
! 1108: strlcpy(pi->callingnum, callingNum, sizeof(pi->callingnum));
! 1109: strlcpy(pi->callednum, calledNum, sizeof(pi->callednum));
! 1110:
! 1111: PhysIncoming(l);
! 1112: return(linfo);
! 1113: }
! 1114:
! 1115: /*
! 1116: * PptpCancel()
! 1117: *
! 1118: * The control code calls this function to cancel a
! 1119: * local outgoing call in progress.
! 1120: */
! 1121:
! 1122: static void
! 1123: PptpCancel(void *cookie)
! 1124: {
! 1125: PptpInfo pi;
! 1126: Link l;
! 1127:
! 1128: /* It this fake call? */
! 1129: if (!cookie)
! 1130: return;
! 1131:
! 1132: l = (Link)cookie;
! 1133: pi = (PptpInfo) l->info;
! 1134:
! 1135: Log(LG_PHYS, ("[%s] PPTP call cancelled in state %s",
! 1136: l->name, gPhysStateNames[l->state]));
! 1137: if (l->state == PHYS_STATE_DOWN)
! 1138: return;
! 1139: l->state = PHYS_STATE_DOWN;
! 1140: u_addrclear(&pi->peer_addr);
! 1141: pi->peer_port = 0;
! 1142: pi->callingnum[0]=0;
! 1143: pi->callednum[0]=0;
! 1144: pi->peer_iface[0] = 0;
! 1145: PhysDown(l, STR_CON_FAILED0, NULL);
! 1146: }
! 1147:
! 1148: /*
! 1149: * PptpListenUpdate()
! 1150: */
! 1151:
! 1152: static void
! 1153: PptpListenUpdate(Link l)
! 1154: {
! 1155: PptpInfo pi = (PptpInfo) l->info;
! 1156:
! 1157: if (pi->listener == NULL) {
! 1158: if (Enabled(&l->conf.options, LINK_CONF_INCOMING)) {
! 1159: /* Set up listening for incoming connections */
! 1160: if ((pi->listener =
! 1161: PptpCtrlListen(&pi->conf.self_addr, pi->conf.self_port))
! 1162: == NULL) {
! 1163: Log(LG_ERR, ("PPTP: Error, can't listen for connection!"));
! 1164: }
! 1165: }
! 1166: } else {
! 1167: if (!Enabled(&l->conf.options, LINK_CONF_INCOMING)) {
! 1168: PptpCtrlUnListen(pi->listener);
! 1169: pi->listener = NULL;
! 1170: }
! 1171: }
! 1172: }
! 1173:
! 1174: /*
! 1175: * PptpSetCommand()
! 1176: */
! 1177:
! 1178: static int
! 1179: PptpSetCommand(Context ctx, int ac, char *av[], void *arg)
! 1180: {
! 1181: PptpInfo const pi = (PptpInfo) ctx->lnk->info;
! 1182: char **fqdn_peer_addr = &pi->conf.fqdn_peer_addr;
! 1183: struct u_range rng;
! 1184: int port;
! 1185:
! 1186: switch ((intptr_t)arg) {
! 1187: case SET_SELFADDR:
! 1188: case SET_PEERADDR:
! 1189: if ((ac == 1 || ac == 2) && (intptr_t)arg == SET_PEERADDR) {
! 1190: if (*fqdn_peer_addr)
! 1191: Freee(*fqdn_peer_addr);
! 1192: *fqdn_peer_addr = Mstrdup(MB_PHYS, av[0]);
! 1193: }
! 1194: if (ac < 1 || ac > 2 || !ParseRange(av[0], &rng, ALLOW_IPV4|ALLOW_IPV6))
! 1195: return(-1);
! 1196: if (ac > 1) {
! 1197: if ((port = atoi(av[1])) < 0 || port > 0xffff)
! 1198: return(-1);
! 1199: } else {
! 1200: port = 0;
! 1201: }
! 1202: if ((intptr_t)arg == SET_SELFADDR) {
! 1203: pi->conf.self_addr = rng.addr;
! 1204: pi->conf.self_port = port;
! 1205: } else {
! 1206: pi->conf.peer_addr = rng;
! 1207: pi->conf.peer_port = port;
! 1208: }
! 1209: break;
! 1210: case SET_CALLINGNUM:
! 1211: if (ac != 1)
! 1212: return(-1);
! 1213: strlcpy(pi->conf.callingnum, av[0], sizeof(pi->conf.callingnum));
! 1214: break;
! 1215: case SET_CALLEDNUM:
! 1216: if (ac != 1)
! 1217: return(-1);
! 1218: strlcpy(pi->conf.callednum, av[0], sizeof(pi->conf.callednum));
! 1219: break;
! 1220: case SET_ENABLE:
! 1221: EnableCommand(ac, av, &pi->conf.options, gConfList);
! 1222: PptpListenUpdate(ctx->lnk);
! 1223: break;
! 1224: case SET_DISABLE:
! 1225: DisableCommand(ac, av, &pi->conf.options, gConfList);
! 1226: PptpListenUpdate(ctx->lnk);
! 1227: break;
! 1228: default:
! 1229: assert(0);
! 1230: }
! 1231: return(0);
! 1232: }
! 1233:
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to pptp.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