Annotation of embedaddon/mpd/src/l2tp.c, revision 1.1.1.1
1.1 misho 1:
2: /*
3: * l2tp.c
4: *
5: * Written by Alexander Motin <mav@FreeBSD.org>
6: */
7:
8: #include "ppp.h"
9: #include "phys.h"
10: #include "mbuf.h"
11: #include "ngfunc.h"
12: #include "l2tp.h"
13: #include "l2tp_avp.h"
14: #include "l2tp_ctrl.h"
15: #include "log.h"
16: #include "util.h"
17:
18: #include <sys/types.h>
19: #ifdef NOLIBPDEL
20: #include "contrib/libpdel/util/ghash.h"
21: #else
22: #include <pdel/util/ghash.h>
23: #endif
24:
25: #include <netgraph/ng_message.h>
26: #include <netgraph/ng_socket.h>
27: #include <netgraph/ng_ksocket.h>
28: #include <netgraph/ng_l2tp.h>
29: #include <netgraph.h>
30:
31: /*
32: * DEFINITIONS
33: */
34:
35: #define L2TP_MTU 1600
36: #define L2TP_MRU L2TP_MTU
37:
38: #define L2TP_PORT 1701
39:
40: #define L2TP_CALL_MIN_BPS 56000
41: #define L2TP_CALL_MAX_BPS 64000
42:
43: struct l2tp_server {
44: struct u_addr self_addr; /* self IP address */
45: in_port_t self_port; /* self port */
46: int refs;
47: int sock; /* server listen socket */
48: EventRef event; /* listen for data messages */
49: };
50:
51: struct l2tp_tun {
52: struct u_addr self_addr; /* self IP address */
53: struct u_addr peer_addr; /* peer IP address */
54: char peer_iface[IFNAMSIZ]; /* Peer iface */
55: u_char peer_mac_addr[6]; /* Peer MAC address */
56: in_port_t self_port; /* self port */
57: in_port_t peer_port; /* peer port */
58: u_char connected; /* control connection is connected */
59: u_char alive; /* control connection is not dying */
60: u_int active_sessions;/* number of calls in this sunnels */
61: struct ppp_l2tp_ctrl *ctrl; /* control connection for this tunnel */
62: };
63:
64: struct l2tpinfo {
65: struct {
66: struct u_addr self_addr; /* self IP address */
67: struct u_range peer_addr; /* Peer IP addresses allowed */
68: in_port_t self_port; /* self port */
69: in_port_t peer_port; /* Peer port required (or zero) */
70: struct optinfo options;
71: char callingnum[64]; /* L2TP phone number to use */
72: char callednum[64]; /* L2TP phone number to use */
73: char hostname[MAXHOSTNAMELEN]; /* L2TP local hostname */
74: char secret[64]; /* L2TP tunnel secret */
75: char *fqdn_peer_addr; /* FQDN Peer address */
76: } conf;
77: u_char opened; /* L2TP opened by phys */
78: u_char incoming; /* Call is incoming vs. outgoing */
79: u_char outcall; /* incall or outcall */
80: u_char sync; /* sync or async call */
81: struct l2tp_server *server; /* server associated with link */
82: struct l2tp_tun *tun; /* tunnel associated with link */
83: struct ppp_l2tp_sess *sess; /* current session for this link */
84: char callingnum[64]; /* current L2TP phone number */
85: char callednum[64]; /* current L2TP phone number */
86: };
87: typedef struct l2tpinfo *L2tpInfo;
88:
89: /* Set menu options */
90: enum {
91: SET_SELFADDR,
92: SET_PEERADDR,
93: SET_CALLINGNUM,
94: SET_CALLEDNUM,
95: SET_HOSTNAME,
96: SET_SECRET,
97: SET_ENABLE,
98: SET_DISABLE
99: };
100:
101: /* Binary options */
102: enum {
103: L2TP_CONF_OUTCALL, /* when originating, calls are "outgoing" */
104: L2TP_CONF_HIDDEN, /* enable AVP hidding */
105: L2TP_CONF_LENGTH, /* enable Length field in data packets */
106: L2TP_CONF_DATASEQ, /* enable sequence fields in data packets */
107: L2TP_CONF_RESOLVE_ONCE /* Only once resolve peer_addr */
108: };
109:
110: /*
111: * INTERNAL FUNCTIONS
112: */
113:
114: static int L2tpTInit(void);
115: static void L2tpTShutdown(void);
116: static int L2tpInit(Link l);
117: static int L2tpInst(Link l, Link lt);
118: static void L2tpOpen(Link l);
119: static void L2tpClose(Link l);
120: static void L2tpShutdown(Link l);
121: static void L2tpStat(Context ctx);
122: static int L2tpOriginated(Link l);
123: static int L2tpIsSync(Link l);
124: static int L2tpSetAccm(Link l, u_int32_t xmit, u_int32_t recv);
125: static int L2tpSelfName(Link l, void *buf, size_t buf_len);
126: static int L2tpPeerName(Link l, void *buf, size_t buf_len);
127: static int L2tpSelfAddr(Link l, void *buf, size_t buf_len);
128: static int L2tpPeerAddr(Link l, void *buf, size_t buf_len);
129: static int L2tpPeerPort(Link l, void *buf, size_t buf_len);
130: static int L2tpPeerMacAddr(Link l, void *buf, size_t buf_len);
131: static int L2tpPeerIface(Link l, void *buf, size_t buf_len);
132: static int L2tpCallingNum(Link l, void *buf, size_t buf_len);
133: static int L2tpCalledNum(Link l, void *buf, size_t buf_len);
134: static int L2tpSetCallingNum(Link l, void *buf);
135: static int L2tpSetCalledNum(Link l, void *buf);
136:
137: static void L2tpHookUp(Link l);
138: static void L2tpUnhook(Link l);
139:
140: static void L2tpNodeUpdate(Link l);
141: static int L2tpListen(Link l);
142: static void L2tpUnListen(Link l);
143: static int L2tpSetCommand(Context ctx, int ac, char *av[], void *arg);
144:
145: /* L2TP control callbacks */
146: static ppp_l2tp_ctrl_connected_t ppp_l2tp_ctrl_connected_cb;
147: static ppp_l2tp_ctrl_terminated_t ppp_l2tp_ctrl_terminated_cb;
148: static ppp_l2tp_ctrl_destroyed_t ppp_l2tp_ctrl_destroyed_cb;
149: static ppp_l2tp_initiated_t ppp_l2tp_initiated_cb;
150: static ppp_l2tp_connected_t ppp_l2tp_connected_cb;
151: static ppp_l2tp_terminated_t ppp_l2tp_terminated_cb;
152: static ppp_l2tp_set_link_info_t ppp_l2tp_set_link_info_cb;
153:
154: static const struct ppp_l2tp_ctrl_cb ppp_l2tp_server_ctrl_cb = {
155: ppp_l2tp_ctrl_connected_cb,
156: ppp_l2tp_ctrl_terminated_cb,
157: ppp_l2tp_ctrl_destroyed_cb,
158: ppp_l2tp_initiated_cb,
159: ppp_l2tp_connected_cb,
160: ppp_l2tp_terminated_cb,
161: ppp_l2tp_set_link_info_cb,
162: NULL,
163: };
164:
165: /*
166: * GLOBAL VARIABLES
167: */
168:
169: const struct phystype gL2tpPhysType = {
170: .name = "l2tp",
171: .descr = "Layer Two Tunneling Protocol",
172: .mtu = L2TP_MTU,
173: .mru = L2TP_MRU,
174: .tmpl = 1,
175: .tinit = L2tpTInit,
176: .tshutdown = L2tpTShutdown,
177: .init = L2tpInit,
178: .inst = L2tpInst,
179: .open = L2tpOpen,
180: .close = L2tpClose,
181: .update = L2tpNodeUpdate,
182: .shutdown = L2tpShutdown,
183: .showstat = L2tpStat,
184: .originate = L2tpOriginated,
185: .issync = L2tpIsSync,
186: .setaccm = L2tpSetAccm,
187: .setcallingnum = L2tpSetCallingNum,
188: .setcallednum = L2tpSetCalledNum,
189: .selfname = L2tpSelfName,
190: .peername = L2tpPeerName,
191: .selfaddr = L2tpSelfAddr,
192: .peeraddr = L2tpPeerAddr,
193: .peerport = L2tpPeerPort,
194: .peermacaddr = L2tpPeerMacAddr,
195: .peeriface = L2tpPeerIface,
196: .callingnum = L2tpCallingNum,
197: .callednum = L2tpCalledNum,
198: };
199:
200: const struct cmdtab L2tpSetCmds[] = {
201: { "self {ip} [{port}]", "Set local IP address",
202: L2tpSetCommand, NULL, 2, (void *) SET_SELFADDR },
203: { "peer {ip} [{port}]", "Set remote IP address",
204: L2tpSetCommand, NULL, 2, (void *) SET_PEERADDR },
205: { "callingnum {number}", "Set calling L2TP telephone number",
206: L2tpSetCommand, NULL, 2, (void *) SET_CALLINGNUM },
207: { "callednum {number}", "Set called L2TP telephone number",
208: L2tpSetCommand, NULL, 2, (void *) SET_CALLEDNUM },
209: { "hostname {name}", "Set L2TP local hostname",
210: L2tpSetCommand, NULL, 2, (void *) SET_HOSTNAME },
211: { "secret {sec}", "Set L2TP tunnel secret",
212: L2tpSetCommand, NULL, 2, (void *) SET_SECRET },
213: { "enable [opt ...]", "Enable option",
214: L2tpSetCommand, NULL, 2, (void *) SET_ENABLE },
215: { "disable [opt ...]", "Disable option",
216: L2tpSetCommand, NULL, 2, (void *) SET_DISABLE },
217: { NULL },
218: };
219:
220: /*
221: * INTERNAL VARIABLES
222: */
223:
224: static struct confinfo gConfList[] = {
225: { 0, L2TP_CONF_OUTCALL, "outcall" },
226: { 0, L2TP_CONF_HIDDEN, "hidden" },
227: { 0, L2TP_CONF_LENGTH, "length" },
228: { 0, L2TP_CONF_DATASEQ, "dataseq" },
229: { 0, L2TP_CONF_RESOLVE_ONCE, "resolve-once" },
230: { 0, 0, NULL },
231: };
232:
233: int L2tpListenUpdateSheduled = 0;
234: struct pppTimer L2tpListenUpdateTimer;
235:
236: struct ghash *gL2tpServers;
237: struct ghash *gL2tpTuns;
238: int one = 1;
239:
240: /*
241: * L2tpTInit()
242: */
243:
244: static int
245: L2tpTInit(void)
246: {
247: if ((gL2tpServers = ghash_create(NULL, 0, 0, MB_PHYS, NULL, NULL, NULL, NULL))
248: == NULL)
249: return(-1);
250: if ((gL2tpTuns = ghash_create(NULL, 0, 0, MB_PHYS, NULL, NULL, NULL, NULL))
251: == NULL)
252: return(-1);
253: return(0);
254: }
255:
256: /*
257: * L2tpTShutdown()
258: */
259:
260: static void
261: L2tpTShutdown(void)
262: {
263: struct ghash_walk walk;
264: struct l2tp_tun *tun;
265:
266: Log(LG_PHYS2, ("L2TP: Total shutdown"));
267: ghash_walk_init(gL2tpTuns, &walk);
268: while ((tun = ghash_walk_next(gL2tpTuns, &walk)) != NULL) {
269: if (tun->ctrl) {
270: if (tun->alive)
271: ppp_l2tp_ctrl_shutdown(tun->ctrl,
272: L2TP_RESULT_SHUTDOWN, 0, NULL);
273: ppp_l2tp_ctrl_destroy(&tun->ctrl);
274: }
275: }
276: ghash_destroy(&gL2tpServers);
277: ghash_destroy(&gL2tpTuns);
278: }
279:
280: /*
281: * L2tpInit()
282: */
283:
284: static int
285: L2tpInit(Link l)
286: {
287: L2tpInfo l2tp;
288:
289: /* Initialize this link */
290: l2tp = (L2tpInfo) (l->info = Malloc(MB_PHYS, sizeof(*l2tp)));
291:
292: u_addrclear(&l2tp->conf.self_addr);
293: l2tp->conf.self_addr.family = AF_INET;
294: l2tp->conf.self_port = 0;
295: u_rangeclear(&l2tp->conf.peer_addr);
296: l2tp->conf.peer_addr.addr.family = AF_INET;
297: l2tp->conf.peer_addr.width = 0;
298: l2tp->conf.peer_port = 0;
299: l2tp->conf.fqdn_peer_addr = NULL;
300:
301: Enable(&l2tp->conf.options, L2TP_CONF_DATASEQ);
302: Enable(&l2tp->conf.options, L2TP_CONF_RESOLVE_ONCE);
303:
304: return(0);
305: }
306:
307: /*
308: * L2tpInst()
309: */
310:
311: static int
312: L2tpInst(Link l, Link lt)
313: {
314: L2tpInfo pi;
315: L2tpInfo const pit = (L2tpInfo) lt->info;
316:
317: /* Initialize this link */
318: pi = (L2tpInfo) (l->info = Mdup(MB_PHYS, lt->info, sizeof(*pit)));
319: if (pit->conf.fqdn_peer_addr != NULL)
320: pi->conf.fqdn_peer_addr =
321: Mstrdup(MB_PHYS, pit->conf.fqdn_peer_addr);
322: if (pi->server)
323: pi->server->refs++;
324:
325: return(0);
326: }
327:
328: /*
329: * L2tpOpen()
330: */
331:
332: static void
333: L2tpOpen(Link l)
334: {
335: L2tpInfo const pi = (L2tpInfo) l->info;
336:
337: struct l2tp_tun *tun = NULL;
338: struct ppp_l2tp_sess *sess;
339: struct ppp_l2tp_avp_list *avps = NULL;
340: union {
341: u_char buf[sizeof(struct ng_ksocket_sockopt) + sizeof(int)];
342: struct ng_ksocket_sockopt sockopt;
343: } sockopt_buf;
344: struct ng_ksocket_sockopt *const sockopt = &sockopt_buf.sockopt;
345: union {
346: u_char buf[sizeof(struct ng_mesg) + sizeof(struct sockaddr_storage)];
347: struct ng_mesg reply;
348: } ugetsas;
349: struct sockaddr_storage *const getsas = (struct sockaddr_storage *)(void *)ugetsas.reply.data;
350: struct ngm_mkpeer mkpeer;
351: struct sockaddr_storage sas;
352: char hook[NG_HOOKSIZ];
353: char namebuf[64];
354: char buf[32], buf2[32];
355: char hostname[MAXHOSTNAMELEN];
356: ng_ID_t node_id;
357: int csock = -1;
358: int dsock = -1;
359: struct ghash_walk walk;
360: u_int32_t cap;
361: u_int16_t win;
362:
363: pi->opened=1;
364:
365: if (pi->incoming == 1) {
366: Log(LG_PHYS2, ("[%s] L2tpOpen() on incoming call", l->name));
367: if (l->state==PHYS_STATE_READY) {
368: l->state = PHYS_STATE_UP;
369: if (pi->outcall) {
370: pi->sync = 1;
371: if (l->rep) {
372: uint32_t fr;
373: avps = ppp_l2tp_avp_list_create();
374: if (RepIsSync(l)) {
375: fr = htonl(L2TP_FRAMING_SYNC);
376: } else {
377: fr = htonl(L2TP_FRAMING_ASYNC);
378: pi->sync = 0;
379: }
380: if (ppp_l2tp_avp_list_append(avps, 1, 0, AVP_FRAMING_TYPE,
381: &fr, sizeof(fr)) == -1) {
382: Perror("[%s] ppp_l2tp_avp_list_append",
383: l->name);
384: }
385: } else {
386: avps = NULL;
387: }
388: Log(LG_PHYS, ("[%s] L2TP: Call #%u connected", l->name,
389: ppp_l2tp_sess_get_serial(pi->sess)));
390: ppp_l2tp_connected(pi->sess, avps);
391: if (avps)
392: ppp_l2tp_avp_list_destroy(&avps);
393: }
394: L2tpHookUp(l);
395: PhysUp(l);
396: }
397: return;
398: }
399:
400: /* Sanity check. */
401: if (l->state != PHYS_STATE_DOWN) {
402: Log(LG_PHYS, ("[%s] L2TP: allready active", l->name));
403: return;
404: };
405:
406: l->state = PHYS_STATE_CONNECTING;
407: strlcpy(pi->callingnum, pi->conf.callingnum, sizeof(pi->callingnum));
408: strlcpy(pi->callednum, pi->conf.callednum, sizeof(pi->callednum));
409:
410: if ((!Enabled(&pi->conf.options, L2TP_CONF_RESOLVE_ONCE)) &&
411: (pi->conf.fqdn_peer_addr != NULL)) {
412: struct u_range rng;
413: if (ParseRange(pi->conf.fqdn_peer_addr, &rng, ALLOW_IPV4|ALLOW_IPV6))
414: pi->conf.peer_addr = rng;
415: }
416:
417: ghash_walk_init(gL2tpTuns, &walk);
418: while ((tun = ghash_walk_next(gL2tpTuns, &walk)) != NULL) {
419: if (tun->ctrl && tun->alive && tun->active_sessions < gL2TPtunlimit &&
420: (IpAddrInRange(&pi->conf.peer_addr, &tun->peer_addr)) &&
421: (u_addrempty(&pi->conf.self_addr) || u_addrempty(&tun->self_addr) ||
422: u_addrcompare(&pi->conf.self_addr, &tun->self_addr) == 0) &&
423: (pi->conf.peer_port == 0 || pi->conf.peer_port == tun->peer_port)) {
424: pi->tun = tun;
425: tun->active_sessions++;
426: if (tun->connected) { /* if tun is connected then just initiate */
427:
428: /* Create number AVPs */
429: avps = ppp_l2tp_avp_list_create();
430: if (pi->conf.callingnum[0]) {
431: if (ppp_l2tp_avp_list_append(avps, 1, 0, AVP_CALLING_NUMBER,
432: pi->conf.callingnum, strlen(pi->conf.callingnum)) == -1) {
433: Perror("[%s] ppp_l2tp_avp_list_append", l->name);
434: }
435: }
436: if (pi->conf.callednum[0]) {
437: if (ppp_l2tp_avp_list_append(avps, 1, 0, AVP_CALLED_NUMBER,
438: pi->conf.callednum, strlen(pi->conf.callednum)) == -1) {
439: Perror("[%s] ppp_l2tp_avp_list_append", l->name);
440: }
441: }
442: if ((sess = ppp_l2tp_initiate(tun->ctrl,
443: Enabled(&pi->conf.options, L2TP_CONF_OUTCALL)?1:0,
444: Enabled(&pi->conf.options, L2TP_CONF_LENGTH)?1:0,
445: Enabled(&pi->conf.options, L2TP_CONF_DATASEQ)?1:0,
446: avps)) == NULL) {
447: Perror("[%s] ppp_l2tp_initiate", l->name);
448: ppp_l2tp_avp_list_destroy(&avps);
449: pi->sess = NULL;
450: pi->tun = NULL;
451: tun->active_sessions--;
452: l->state = PHYS_STATE_DOWN;
453: PhysDown(l, STR_ERROR, NULL);
454: return;
455: };
456: ppp_l2tp_avp_list_destroy(&avps);
457: pi->sess = sess;
458: pi->outcall = Enabled(&pi->conf.options, L2TP_CONF_OUTCALL);
459: Log(LG_PHYS, ("[%s] L2TP: %s call #%u via control connection %p initiated",
460: l->name, (pi->outcall?"Outgoing":"Incoming"),
461: ppp_l2tp_sess_get_serial(sess), tun->ctrl));
462: ppp_l2tp_sess_set_cookie(sess, l);
463: if (!pi->outcall) {
464: pi->sync = 1;
465: if (l->rep) {
466: uint32_t fr;
467: avps = ppp_l2tp_avp_list_create();
468: if (RepIsSync(l)) {
469: fr = htonl(L2TP_FRAMING_SYNC);
470: } else {
471: fr = htonl(L2TP_FRAMING_ASYNC);
472: pi->sync = 0;
473: }
474: if (ppp_l2tp_avp_list_append(avps, 1, 0, AVP_FRAMING_TYPE,
475: &fr, sizeof(fr)) == -1) {
476: Perror("[%s] ppp_l2tp_avp_list_append",
477: l->name);
478: }
479: } else {
480: avps = NULL;
481: }
482: ppp_l2tp_connected(pi->sess, avps);
483: if (avps)
484: ppp_l2tp_avp_list_destroy(&avps);
485: }
486: } /* Else wait while it will be connected */
487: return;
488: }
489: }
490:
491: /* There is no tun which we need. Create a new one. */
492: tun = Malloc(MB_PHYS, sizeof(*tun));
493: memset(tun, 0, sizeof(*tun));
494: u_addrcopy(&pi->conf.peer_addr.addr, &tun->peer_addr);
495: tun->peer_port = pi->conf.peer_port?pi->conf.peer_port:L2TP_PORT;
496: u_addrcopy(&pi->conf.self_addr, &tun->self_addr);
497: tun->self_port = pi->conf.self_port;
498: tun->alive = 1;
499: tun->connected = 0;
500:
501: /* Create vendor name AVP */
502: avps = ppp_l2tp_avp_list_create();
503:
504: if (pi->conf.hostname[0] != 0) {
505: strlcpy(hostname, pi->conf.hostname, sizeof(hostname));
506: } else {
507: (void)gethostname(hostname, sizeof(hostname) - 1);
508: hostname[sizeof(hostname) - 1] = '\0';
509: }
510: cap = htonl(L2TP_BEARER_DIGITAL|L2TP_BEARER_ANALOG);
511: win = htons(8); /* XXX: this value is empirical. */
512: if ((ppp_l2tp_avp_list_append(avps, 1, 0, AVP_HOST_NAME,
513: hostname, strlen(hostname)) == -1) ||
514: (ppp_l2tp_avp_list_append(avps, 1, 0, AVP_VENDOR_NAME,
515: MPD_VENDOR, strlen(MPD_VENDOR)) == -1) ||
516: (ppp_l2tp_avp_list_append(avps, 1, 0, AVP_BEARER_CAPABILITIES,
517: &cap, sizeof(cap)) == -1) ||
518: (ppp_l2tp_avp_list_append(avps, 1, 0, AVP_RECEIVE_WINDOW_SIZE,
519: &win, sizeof(win)) == -1)) {
520: Perror("L2TP: ppp_l2tp_avp_list_append");
521: goto fail;
522: }
523:
524: /* Create a new control connection */
525: if ((tun->ctrl = ppp_l2tp_ctrl_create(gPeventCtx, &gGiantMutex,
526: &ppp_l2tp_server_ctrl_cb, u_addrtoid(&tun->peer_addr),
527: &node_id, hook, avps,
528: pi->conf.secret, strlen(pi->conf.secret),
529: Enabled(&pi->conf.options, L2TP_CONF_HIDDEN))) == NULL) {
530: Perror("[%s] ppp_l2tp_ctrl_create", l->name);
531: goto fail;
532: }
533: ppp_l2tp_ctrl_set_cookie(tun->ctrl, tun);
534:
535: Log(LG_PHYS, ("L2TP: Initiating control connection %p %s %u <-> %s %u",
536: tun->ctrl, u_addrtoa(&tun->self_addr,buf,sizeof(buf)), tun->self_port,
537: u_addrtoa(&tun->peer_addr,buf2,sizeof(buf2)), tun->peer_port));
538:
539: /* Get a temporary netgraph socket node */
540: if (NgMkSockNode(NULL, &csock, &dsock) == -1) {
541: Perror("[%s] NgMkSockNode", l->name);
542: goto fail;
543: }
544:
545: /* Attach a new UDP socket to "lower" hook */
546: snprintf(namebuf, sizeof(namebuf), "[%lx]:", (u_long)node_id);
547: memset(&mkpeer, 0, sizeof(mkpeer));
548: strlcpy(mkpeer.type, NG_KSOCKET_NODE_TYPE, sizeof(mkpeer.type));
549: strlcpy(mkpeer.ourhook, hook, sizeof(mkpeer.ourhook));
550: if (tun->peer_addr.family==AF_INET6) {
551: snprintf(mkpeer.peerhook, sizeof(mkpeer.peerhook), "%d/%d/%d", PF_INET6, SOCK_DGRAM, IPPROTO_UDP);
552: } else {
553: snprintf(mkpeer.peerhook, sizeof(mkpeer.peerhook), "inet/dgram/udp");
554: }
555: if (NgSendMsg(csock, namebuf, NGM_GENERIC_COOKIE,
556: NGM_MKPEER, &mkpeer, sizeof(mkpeer)) == -1) {
557: Perror("[%s] mkpeer", l->name);
558: goto fail;
559: }
560:
561: /* Point name at ksocket node */
562: strlcat(namebuf, hook, sizeof(namebuf));
563:
564: /* Make UDP port reusable */
565: memset(&sockopt_buf, 0, sizeof(sockopt_buf));
566: sockopt->level = SOL_SOCKET;
567: sockopt->name = SO_REUSEADDR;
568: memcpy(sockopt->value, &one, sizeof(int));
569: if (NgSendMsg(csock, namebuf, NGM_KSOCKET_COOKIE,
570: NGM_KSOCKET_SETOPT, sockopt, sizeof(sockopt_buf)) == -1) {
571: Perror("[%s] setsockopt", l->name);
572: goto fail;
573: }
574: sockopt->name = SO_REUSEPORT;
575: if (NgSendMsg(csock, namebuf, NGM_KSOCKET_COOKIE,
576: NGM_KSOCKET_SETOPT, sockopt, sizeof(sockopt_buf)) == -1) {
577: Perror("[%s] setsockopt", l->name);
578: goto fail;
579: }
580:
581: if (!u_addrempty(&tun->self_addr)) {
582: /* Bind socket to a new port */
583: u_addrtosockaddr(&tun->self_addr,tun->self_port,&sas);
584: if (NgSendMsg(csock, namebuf, NGM_KSOCKET_COOKIE,
585: NGM_KSOCKET_BIND, &sas, sas.ss_len) == -1) {
586: Perror("[%s] bind", l->name);
587: goto fail;
588: }
589: }
590: /* Connect socket to remote peer's IP and port */
591: u_addrtosockaddr(&tun->peer_addr,tun->peer_port,&sas);
592: if (NgSendMsg(csock, namebuf, NGM_KSOCKET_COOKIE,
593: NGM_KSOCKET_CONNECT, &sas, sas.ss_len) == -1
594: && errno != EINPROGRESS) {
595: Perror("[%s] connect", l->name);
596: goto fail;
597: }
598:
599: if (NgSendMsg(csock, namebuf, NGM_KSOCKET_COOKIE,
600: NGM_KSOCKET_GETNAME, NULL, 0) == -1) {
601: Perror("[%s] getname send", l->name);
602: } else
603: if (NgRecvMsg(csock, &ugetsas.reply, sizeof(ugetsas), NULL) == -1) {
604: Perror("[%s] getname recv", l->name);
605: } else {
606: sockaddrtou_addr(getsas,&tun->self_addr,&tun->self_port);
607: }
608:
609: /* Add peer to our hash table */
610: if (ghash_put(gL2tpTuns, tun) == -1) {
611: Perror("[%s] ghash_put", l->name);
612: goto fail;
613: }
614: pi->tun = tun;
615: tun->active_sessions++;
616: Log(LG_PHYS2, ("L2TP: Control connection %p %s %u <-> %s %u initiated",
617: tun->ctrl, u_addrtoa(&tun->self_addr,buf,sizeof(buf)), tun->self_port,
618: u_addrtoa(&tun->peer_addr,buf2,sizeof(buf2)), tun->peer_port));
619: ppp_l2tp_ctrl_initiate(tun->ctrl);
620:
621: /* Clean up and return */
622: ppp_l2tp_avp_list_destroy(&avps);
623: (void)close(csock);
624: (void)close(dsock);
625: return;
626:
627: fail:
628: /* Clean up after failure */
629: if (csock != -1)
630: (void)close(csock);
631: if (dsock != -1)
632: (void)close(dsock);
633: if (tun != NULL) {
634: ppp_l2tp_ctrl_destroy(&tun->ctrl);
635: Freee(tun);
636: }
637: l->state = PHYS_STATE_DOWN;
638: PhysDown(l, STR_ERROR, NULL);
639: }
640:
641: /*
642: * L2tpClose()
643: */
644:
645: static void
646: L2tpClose(Link l)
647: {
648: L2tpInfo const pi = (L2tpInfo) l->info;
649:
650: pi->opened = 0;
651: pi->incoming = 0;
652: pi->outcall = 0;
653: if (l->state == PHYS_STATE_DOWN)
654: return;
655: L2tpUnhook(l);
656: if (pi->sess) {
657: Log(LG_PHYS, ("[%s] L2TP: Call #%u terminated locally", l->name,
658: ppp_l2tp_sess_get_serial(pi->sess)));
659: ppp_l2tp_terminate(pi->sess, L2TP_RESULT_ADMIN, 0, NULL);
660: pi->sess = NULL;
661: }
662: if (pi->tun)
663: pi->tun->active_sessions--;
664: pi->tun = NULL;
665: pi->callingnum[0]=0;
666: pi->callednum[0]=0;
667: l->state = PHYS_STATE_DOWN;
668: PhysDown(l, STR_MANUALLY, NULL);
669: }
670:
671: /*
672: * L2tpShutdown()
673: */
674:
675: static void
676: L2tpShutdown(Link l)
677: {
678: L2tpInfo const pi = (L2tpInfo) l->info;
679:
680: if (pi->conf.fqdn_peer_addr)
681: Freee(pi->conf.fqdn_peer_addr);
682:
683: L2tpUnListen(l);
684: Freee(l->info);
685: }
686:
687: /*
688: * L2tpUnhook()
689: */
690:
691: static void
692: L2tpUnhook(Link l)
693: {
694: int csock = -1;
695: L2tpInfo const pi = (L2tpInfo) l->info;
696: const char *hook;
697: ng_ID_t node_id;
698: char path[NG_PATHSIZ];
699:
700: if (pi->sess) { /* avoid double close */
701:
702: /* Get this link's node and hook */
703: ppp_l2tp_sess_get_hook(pi->sess, &node_id, &hook);
704:
705: if (node_id != 0) {
706:
707: /* Get a temporary netgraph socket node */
708: if (NgMkSockNode(NULL, &csock, NULL) == -1) {
709: Perror("L2TP: NgMkSockNode");
710: return;
711: }
712:
713: /* Disconnect session hook. */
714: snprintf(path, sizeof(path), "[%lx]:", (u_long)node_id);
715: NgFuncDisconnect(csock, l->name, path, hook);
716:
717: close(csock);
718: }
719: }
720: }
721:
722: /*
723: * L2tpOriginated()
724: */
725:
726: static int
727: L2tpOriginated(Link l)
728: {
729: L2tpInfo const l2tp = (L2tpInfo) l->info;
730:
731: return(l2tp->incoming ? LINK_ORIGINATE_REMOTE : LINK_ORIGINATE_LOCAL);
732: }
733:
734: /*
735: * L2tpIsSync()
736: */
737:
738: static int
739: L2tpIsSync(Link l)
740: {
741: L2tpInfo const l2tp = (L2tpInfo) l->info;
742:
743: return (l2tp->sync);
744: }
745:
746: static int
747: L2tpSetAccm(Link l, u_int32_t xmit, u_int32_t recv)
748: {
749: L2tpInfo const l2tp = (L2tpInfo) l->info;
750:
751: if (!l2tp->sess)
752: return (-1);
753:
754: return (ppp_l2tp_set_link_info(l2tp->sess, xmit, recv));
755: }
756:
757: static int
758: L2tpSetCallingNum(Link l, void *buf)
759: {
760: L2tpInfo const l2tp = (L2tpInfo) l->info;
761:
762: strlcpy(l2tp->conf.callingnum, buf, sizeof(l2tp->conf.callingnum));
763: return(0);
764: }
765:
766: static int
767: L2tpSetCalledNum(Link l, void *buf)
768: {
769: L2tpInfo const l2tp = (L2tpInfo) l->info;
770:
771: strlcpy(l2tp->conf.callednum, buf, sizeof(l2tp->conf.callednum));
772: return(0);
773: }
774:
775: static int
776: L2tpSelfName(Link l, void *buf, size_t buf_len)
777: {
778: L2tpInfo const l2tp = (L2tpInfo) l->info;
779:
780: if (l2tp->tun && l2tp->tun->ctrl)
781: return (ppp_l2tp_ctrl_get_self_name(l2tp->tun->ctrl, buf, buf_len));
782: ((char*)buf)[0]=0;
783: return (0);
784: }
785:
786: static int
787: L2tpPeerName(Link l, void *buf, size_t buf_len)
788: {
789: L2tpInfo const l2tp = (L2tpInfo) l->info;
790:
791: if (l2tp->tun && l2tp->tun->ctrl)
792: return (ppp_l2tp_ctrl_get_peer_name(l2tp->tun->ctrl, buf, buf_len));
793: ((char*)buf)[0]=0;
794: return (0);
795: }
796:
797: static int
798: L2tpSelfAddr(Link l, void *buf, size_t buf_len)
799: {
800: L2tpInfo const l2tp = (L2tpInfo) l->info;
801:
802: if (l2tp->tun && !u_addrempty(&l2tp->tun->self_addr)) {
803: if (u_addrtoa(&l2tp->tun->self_addr, buf, buf_len))
804: return (0);
805: else {
806: ((char*)buf)[0]=0;
807: return (-1);
808: }
809: }
810: ((char*)buf)[0]=0;
811: return (0);
812: }
813:
814: static int
815: L2tpPeerAddr(Link l, void *buf, size_t buf_len)
816: {
817: L2tpInfo const l2tp = (L2tpInfo) l->info;
818:
819: if (l2tp->tun) {
820: if (u_addrtoa(&l2tp->tun->peer_addr, buf, buf_len))
821: return(0);
822: else {
823: ((char*)buf)[0]=0;
824: return(-1);
825: }
826: }
827: ((char*)buf)[0]=0;
828: return(0);
829: }
830:
831: static int
832: L2tpPeerPort(Link l, void *buf, size_t buf_len)
833: {
834: L2tpInfo const l2tp = (L2tpInfo) l->info;
835:
836: if (l2tp->tun) {
837: if (snprintf(buf, buf_len, "%d", l2tp->tun->peer_port))
838: return(0);
839: else {
840: ((char*)buf)[0]=0;
841: return(-1);
842: }
843: }
844: ((char*)buf)[0]=0;
845: return(0);
846: }
847:
848: static int
849: L2tpPeerMacAddr(Link l, void *buf, size_t buf_len)
850: {
851: L2tpInfo const l2tp = (L2tpInfo) l->info;
852:
853: if (l2tp->tun && l2tp->tun->peer_iface[0]) {
854: snprintf(buf, buf_len, "%02x:%02x:%02x:%02x:%02x:%02x",
855: l2tp->tun->peer_mac_addr[0], l2tp->tun->peer_mac_addr[1],
856: l2tp->tun->peer_mac_addr[2], l2tp->tun->peer_mac_addr[3],
857: l2tp->tun->peer_mac_addr[4], l2tp->tun->peer_mac_addr[5]);
858: return (0);
859: }
860: ((char*)buf)[0]=0;
861: return(0);
862: }
863:
864: static int
865: L2tpPeerIface(Link l, void *buf, size_t buf_len)
866: {
867: L2tpInfo const l2tp = (L2tpInfo) l->info;
868:
869: if (l2tp->tun && l2tp->tun->peer_iface[0]) {
870: strlcpy(buf, l2tp->tun->peer_iface, buf_len);
871: return (0);
872: }
873: ((char*)buf)[0]=0;
874: return(0);
875: }
876:
877: static int
878: L2tpCallingNum(Link l, void *buf, size_t buf_len)
879: {
880: L2tpInfo const l2tp = (L2tpInfo) l->info;
881:
882: strlcpy((char*)buf, l2tp->callingnum, buf_len);
883: return(0);
884: }
885:
886: static int
887: L2tpCalledNum(Link l, void *buf, size_t buf_len)
888: {
889: L2tpInfo const l2tp = (L2tpInfo) l->info;
890:
891: strlcpy((char*)buf, l2tp->callednum, buf_len);
892: return(0);
893: }
894:
895: /*
896: * L2tpStat()
897: */
898:
899: void
900: L2tpStat(Context ctx)
901: {
902: L2tpInfo const l2tp = (L2tpInfo) ctx->lnk->info;
903: char buf[32];
904:
905: Printf("L2TP configuration:\r\n");
906: Printf("\tSelf addr : %s, port %u",
907: u_addrtoa(&l2tp->conf.self_addr, buf, sizeof(buf)), l2tp->conf.self_port);
908: Printf("\r\n");
909: Printf("\tPeer FQDN : %s\r\n", l2tp->conf.fqdn_peer_addr);
910: Printf("\tPeer range : %s",
911: u_rangetoa(&l2tp->conf.peer_addr, buf, sizeof(buf)));
912: if (l2tp->conf.peer_port)
913: Printf(", port %u", l2tp->conf.peer_port);
914: Printf("\r\n");
915: Printf("\tHostname : %s\r\n", l2tp->conf.hostname);
916: Printf("\tSecret : %s\r\n", (l2tp->conf.callingnum[0])?"******":"");
917: Printf("\tCalling number: %s\r\n", l2tp->conf.callingnum);
918: Printf("\tCalled number: %s\r\n", l2tp->conf.callednum);
919: Printf("L2TP options:\r\n");
920: OptStat(ctx, &l2tp->conf.options, gConfList);
921: Printf("L2TP status:\r\n");
922: if (ctx->lnk->state != PHYS_STATE_DOWN) {
923: Printf("\tIncoming : %s\r\n", (l2tp->incoming?"YES":"NO"));
924: if (l2tp->tun) {
925: Printf("\tCurrent self : %s, port %u",
926: u_addrtoa(&l2tp->tun->self_addr, buf, sizeof(buf)), l2tp->tun->self_port);
927: L2tpSelfName(ctx->lnk, buf, sizeof(buf));
928: Printf(" (%s)\r\n", buf);
929: Printf("\tCurrent peer : %s, port %u",
930: u_addrtoa(&l2tp->tun->peer_addr, buf, sizeof(buf)), l2tp->tun->peer_port);
931: L2tpPeerName(ctx->lnk, buf, sizeof(buf));
932: Printf(" (%s)\r\n", buf);
933: if (l2tp->tun->peer_iface[0]) {
934: Printf("\tCurrent peer : %02x:%02x:%02x:%02x:%02x:%02x at %s\r\n",
935: l2tp->tun->peer_mac_addr[0], l2tp->tun->peer_mac_addr[1],
936: l2tp->tun->peer_mac_addr[2], l2tp->tun->peer_mac_addr[3],
937: l2tp->tun->peer_mac_addr[4], l2tp->tun->peer_mac_addr[5],
938: l2tp->tun->peer_iface);
939: }
940:
941: Printf("\tFraming : %s\r\n", (l2tp->sync?"Sync":"Async"));
942: }
943: Printf("\tCalling number: %s\r\n", l2tp->callingnum);
944: Printf("\tCalled number: %s\r\n", l2tp->callednum);
945: }
946: }
947:
948: /*
949: * This is called when a control connection gets opened.
950: */
951: static void
952: ppp_l2tp_ctrl_connected_cb(struct ppp_l2tp_ctrl *ctrl)
953: {
954: struct l2tp_tun *tun = ppp_l2tp_ctrl_get_cookie(ctrl);
955: struct ppp_l2tp_sess *sess;
956: struct ppp_l2tp_avp_list *avps = NULL;
957: struct sockaddr_dl hwa;
958: char buf[32], buf2[32];
959: int k;
960:
961: Log(LG_PHYS, ("L2TP: Control connection %p %s %u <-> %s %u connected",
962: ctrl, u_addrtoa(&tun->self_addr,buf,sizeof(buf)), tun->self_port,
963: u_addrtoa(&tun->peer_addr,buf2,sizeof(buf2)), tun->peer_port));
964:
965: if (GetPeerEther(&tun->peer_addr, &hwa)) {
966: if_indextoname(hwa.sdl_index, tun->peer_iface);
967: memcpy(tun->peer_mac_addr, LLADDR(&hwa), sizeof(tun->peer_mac_addr));
968: };
969:
970: /* Examine all L2TP links. */
971: for (k = 0; k < gNumLinks; k++) {
972: Link l;
973: L2tpInfo pi;
974:
975: if (!gLinks[k] || gLinks[k]->type != &gL2tpPhysType)
976: continue;
977:
978: l = gLinks[k];
979: pi = (L2tpInfo)l->info;
980:
981: if (pi->tun != tun)
982: continue;
983:
984: tun->connected = 1;
985: /* Create number AVPs */
986: avps = ppp_l2tp_avp_list_create();
987: if (pi->conf.callingnum[0]) {
988: if (ppp_l2tp_avp_list_append(avps, 1, 0, AVP_CALLING_NUMBER,
989: pi->conf.callingnum, strlen(pi->conf.callingnum)) == -1) {
990: Perror("[%s] ppp_l2tp_avp_list_append", l->name);
991: }
992: }
993: if (pi->conf.callednum[0]) {
994: if (ppp_l2tp_avp_list_append(avps, 1, 0, AVP_CALLED_NUMBER,
995: pi->conf.callednum, strlen(pi->conf.callednum)) == -1) {
996: Perror("[%s] ppp_l2tp_avp_list_append", l->name);
997: }
998: }
999: if ((sess = ppp_l2tp_initiate(tun->ctrl,
1000: Enabled(&pi->conf.options, L2TP_CONF_OUTCALL)?1:0,
1001: Enabled(&pi->conf.options, L2TP_CONF_LENGTH)?1:0,
1002: Enabled(&pi->conf.options, L2TP_CONF_DATASEQ)?1:0,
1003: avps)) == NULL) {
1004: Perror("ppp_l2tp_initiate");
1005: pi->sess = NULL;
1006: pi->tun = NULL;
1007: tun->active_sessions--;
1008: l->state = PHYS_STATE_DOWN;
1009: PhysDown(l, STR_ERROR, NULL);
1010: continue;
1011: };
1012: ppp_l2tp_avp_list_destroy(&avps);
1013: pi->sess = sess;
1014: pi->outcall = Enabled(&pi->conf.options, L2TP_CONF_OUTCALL);
1015: Log(LG_PHYS, ("[%s] L2TP: %s call #%u via control connection %p initiated",
1016: l->name, (pi->outcall?"Outgoing":"Incoming"),
1017: ppp_l2tp_sess_get_serial(sess), tun->ctrl));
1018: ppp_l2tp_sess_set_cookie(sess, l);
1019: if (!pi->outcall) {
1020: pi->sync = 1;
1021: if (l->rep) {
1022: uint32_t fr;
1023: avps = ppp_l2tp_avp_list_create();
1024: if (RepIsSync(l)) {
1025: fr = htonl(L2TP_FRAMING_SYNC);
1026: } else {
1027: fr = htonl(L2TP_FRAMING_ASYNC);
1028: pi->sync = 0;
1029: }
1030: if (ppp_l2tp_avp_list_append(avps, 1, 0, AVP_FRAMING_TYPE,
1031: &fr, sizeof(fr)) == -1) {
1032: Perror("[%s] ppp_l2tp_avp_list_append", l->name);
1033: }
1034: } else {
1035: avps = NULL;
1036: }
1037: ppp_l2tp_connected(pi->sess, avps);
1038: if (avps)
1039: ppp_l2tp_avp_list_destroy(&avps);
1040: }
1041: };
1042: }
1043:
1044: /*
1045: * This is called when a control connection is terminated for any reason
1046: * other than a call ppp_l2tp_ctrl_destroy().
1047: */
1048: static void
1049: ppp_l2tp_ctrl_terminated_cb(struct ppp_l2tp_ctrl *ctrl,
1050: u_int16_t result, u_int16_t error, const char *errmsg)
1051: {
1052: struct l2tp_tun *tun = ppp_l2tp_ctrl_get_cookie(ctrl);
1053: int k;
1054:
1055: Log(LG_PHYS, ("L2TP: Control connection %p terminated: %d (%s)",
1056: ctrl, error, errmsg));
1057:
1058: /* Examine all L2TP links. */
1059: for (k = 0; k < gNumLinks; k++) {
1060: Link l;
1061: L2tpInfo pi;
1062:
1063: if (!gLinks[k] || gLinks[k]->type != &gL2tpPhysType)
1064: continue;
1065:
1066: l = gLinks[k];
1067: pi = (L2tpInfo)l->info;
1068:
1069: if (pi->tun != tun)
1070: continue;
1071:
1072: l->state = PHYS_STATE_DOWN;
1073: L2tpUnhook(l);
1074: pi->sess = NULL;
1075: pi->tun = NULL;
1076: tun->active_sessions--;
1077: pi->callingnum[0]=0;
1078: pi->callednum[0]=0;
1079: PhysDown(l, STR_DROPPED, NULL);
1080: };
1081:
1082: tun->alive = 0;
1083: }
1084:
1085: /*
1086: * This is called before control connection is destroyed for any reason
1087: * other than a call ppp_l2tp_ctrl_destroy().
1088: */
1089: static void
1090: ppp_l2tp_ctrl_destroyed_cb(struct ppp_l2tp_ctrl *ctrl)
1091: {
1092: struct l2tp_tun *tun = ppp_l2tp_ctrl_get_cookie(ctrl);
1093:
1094: Log(LG_PHYS, ("L2TP: Control connection %p destroyed", ctrl));
1095:
1096: ghash_remove(gL2tpTuns, tun);
1097: Freee(tun);
1098: }
1099:
1100: /*
1101: * This callback is used to report the peer's initiating a new incoming
1102: * or outgoing call.
1103: */
1104: static void
1105: ppp_l2tp_initiated_cb(struct ppp_l2tp_ctrl *ctrl,
1106: struct ppp_l2tp_sess *sess, int out,
1107: const struct ppp_l2tp_avp_list *avps,
1108: u_char *include_length, u_char *enable_dseq)
1109: {
1110: struct l2tp_tun *const tun = ppp_l2tp_ctrl_get_cookie(ctrl);
1111: struct ppp_l2tp_avp_ptrs *ptrs = NULL;
1112: Link l = NULL;
1113: L2tpInfo pi = NULL;
1114: int k;
1115:
1116: /* Convert AVP's to friendly form */
1117: if ((ptrs = ppp_l2tp_avp_list2ptrs(avps)) == NULL) {
1118: Perror("L2TP: error decoding AVP list");
1119: ppp_l2tp_terminate(sess, L2TP_RESULT_ERROR,
1120: L2TP_ERROR_GENERIC, strerror(errno));
1121: return;
1122: }
1123:
1124: Log(LG_PHYS, ("L2TP: %s call #%u via connection %p received",
1125: (out?"Outgoing":"Incoming"),
1126: ppp_l2tp_sess_get_serial(sess), ctrl));
1127:
1128: if (gShutdownInProgress) {
1129: Log(LG_PHYS, ("Shutdown sequence in progress, ignoring request."));
1130: goto failed;
1131: }
1132:
1133: if (OVERLOAD()) {
1134: Log(LG_PHYS, ("Daemon overloaded, ignoring request."));
1135: goto failed;
1136: }
1137:
1138: /* Examine all L2TP links. */
1139: for (k = 0; k < gNumLinks; k++) {
1140: Link l2;
1141: L2tpInfo pi2;
1142:
1143: if (!gLinks[k] || gLinks[k]->type != &gL2tpPhysType)
1144: continue;
1145:
1146: l2 = gLinks[k];
1147: pi2 = (L2tpInfo)l2->info;
1148:
1149: if ((!PhysIsBusy(l2)) &&
1150: Enabled(&l2->conf.options, LINK_CONF_INCOMING) &&
1151: ((u_addrempty(&pi2->conf.self_addr)) || (u_addrcompare(&pi2->conf.self_addr, &tun->self_addr) == 0)) &&
1152: (pi2->conf.self_port == 0 || pi2->conf.self_port == tun->self_port) &&
1153: (IpAddrInRange(&pi2->conf.peer_addr, &tun->peer_addr)) &&
1154: (pi2->conf.peer_port == 0 || pi2->conf.peer_port == tun->peer_port)) {
1155:
1156: if (pi == NULL || pi2->conf.peer_addr.width > pi->conf.peer_addr.width) {
1157: l = l2;
1158: pi = pi2;
1159: if (u_rangehost(&pi->conf.peer_addr)) {
1160: break; /* Nothing could be better */
1161: }
1162: }
1163: }
1164: }
1165: if (l != NULL && l->tmpl)
1166: l = LinkInst(l, NULL, 0, 0);
1167:
1168: if (l != NULL) {
1169: pi = (L2tpInfo)l->info;
1170: Log(LG_PHYS, ("[%s] L2TP: %s call #%u via control connection %p accepted",
1171: l->name, (out?"Outgoing":"Incoming"),
1172: ppp_l2tp_sess_get_serial(sess), ctrl));
1173:
1174: if (out)
1175: l->state = PHYS_STATE_READY;
1176: else
1177: l->state = PHYS_STATE_CONNECTING;
1178: pi->incoming = 1;
1179: pi->outcall = out;
1180: pi->tun = tun;
1181: tun->active_sessions++;
1182: pi->sess = sess;
1183: if (ptrs->callingnum && ptrs->callingnum->number)
1184: strlcpy(pi->callingnum, ptrs->callingnum->number, sizeof(pi->callingnum));
1185: if (ptrs->callednum && ptrs->callednum->number)
1186: strlcpy(pi->callednum, ptrs->callednum->number, sizeof(pi->callednum));
1187:
1188: *include_length = (Enabled(&pi->conf.options, L2TP_CONF_LENGTH)?1:0);
1189: *enable_dseq = (Enabled(&pi->conf.options, L2TP_CONF_DATASEQ)?1:0);
1190:
1191: PhysIncoming(l);
1192:
1193: ppp_l2tp_sess_set_cookie(sess, l);
1194: ppp_l2tp_avp_ptrs_destroy(&ptrs);
1195: return;
1196: }
1197: Log(LG_PHYS, ("L2TP: No free link with requested parameters "
1198: "was found"));
1199: failed:
1200: ppp_l2tp_terminate(sess, L2TP_RESULT_AVAIL_TEMP, 0, NULL);
1201: ppp_l2tp_avp_ptrs_destroy(&ptrs);
1202: }
1203:
1204: /*
1205: * This callback is used to report successful connection of a remotely
1206: * initiated incoming call (see ppp_l2tp_initiated_t) or a locally initiated
1207: * outgoing call (see ppp_l2tp_initiate()).
1208: */
1209: static void
1210: ppp_l2tp_connected_cb(struct ppp_l2tp_sess *sess,
1211: const struct ppp_l2tp_avp_list *avps)
1212: {
1213: Link l;
1214: L2tpInfo pi;
1215: struct ppp_l2tp_avp_ptrs *ptrs = NULL;
1216:
1217: l = ppp_l2tp_sess_get_cookie(sess);
1218: pi = (L2tpInfo)l->info;
1219:
1220: Log(LG_PHYS, ("[%s] L2TP: Call #%u connected", l->name,
1221: ppp_l2tp_sess_get_serial(sess)));
1222:
1223: if ((pi->incoming != pi->outcall) && avps != NULL) {
1224: /* Convert AVP's to friendly form */
1225: if ((ptrs = ppp_l2tp_avp_list2ptrs(avps)) == NULL) {
1226: Perror("L2TP: error decoding AVP list");
1227: } else {
1228: if (ptrs->framing && ptrs->framing->sync) {
1229: pi->sync = 1;
1230: } else {
1231: pi->sync = 0;
1232: }
1233: ppp_l2tp_avp_ptrs_destroy(&ptrs);
1234: }
1235: }
1236:
1237: if (pi->opened) {
1238: l->state = PHYS_STATE_UP;
1239: L2tpHookUp(l);
1240: PhysUp(l);
1241: } else {
1242: l->state = PHYS_STATE_READY;
1243: }
1244: }
1245:
1246: /*
1247: * This callback is called when any call, whether successfully connected
1248: * or not, is terminated for any reason other than explict termination
1249: * from the link side (via a call to either ppp_l2tp_terminate() or
1250: * ppp_l2tp_ctrl_destroy()).
1251: */
1252: static void
1253: ppp_l2tp_terminated_cb(struct ppp_l2tp_sess *sess,
1254: u_int16_t result, u_int16_t error, const char *errmsg)
1255: {
1256: char buf[128];
1257: Link l;
1258: L2tpInfo pi;
1259:
1260: l = ppp_l2tp_sess_get_cookie(sess);
1261: pi = (L2tpInfo) l->info;
1262:
1263: /* Control side is notifying us session is down */
1264: snprintf(buf, sizeof(buf), "result=%u error=%u errmsg=\"%s\"",
1265: result, error, (errmsg != NULL) ? errmsg : "");
1266: Log(LG_PHYS, ("[%s] L2TP: call #%u terminated: %s", l->name,
1267: ppp_l2tp_sess_get_serial(sess), buf));
1268:
1269: l->state = PHYS_STATE_DOWN;
1270: L2tpUnhook(l);
1271: pi->sess = NULL;
1272: if (pi->tun)
1273: pi->tun->active_sessions--;
1274: pi->tun = NULL;
1275: pi->callingnum[0]=0;
1276: pi->callednum[0]=0;
1277: PhysDown(l, STR_DROPPED, NULL);
1278: }
1279:
1280: /*
1281: * This callback called on receiving link info from peer.
1282: */
1283: void
1284: ppp_l2tp_set_link_info_cb(struct ppp_l2tp_sess *sess,
1285: u_int32_t xmit, u_int32_t recv)
1286: {
1287: Link l = ppp_l2tp_sess_get_cookie(sess);
1288:
1289: if (l->rep != NULL) {
1290: RepSetAccm(l, xmit, recv);
1291: }
1292: }
1293:
1294: /*
1295: * Connect L2TP and link hooks.
1296: */
1297:
1298: static void
1299: L2tpHookUp(Link l)
1300: {
1301: int csock = -1;
1302: L2tpInfo pi = (L2tpInfo)l->info;
1303: const char *hook;
1304: ng_ID_t node_id;
1305: char path[NG_PATHSIZ];
1306: struct ngm_connect cn;
1307:
1308: /* Get a temporary netgraph socket node */
1309: if (NgMkSockNode(NULL, &csock, NULL) == -1) {
1310: Perror("L2TP: NgMkSockNode");
1311: goto fail;
1312: }
1313:
1314: /* Get this link's node and hook */
1315: ppp_l2tp_sess_get_hook(pi->sess, &node_id, &hook);
1316:
1317: /* Initialize cn */
1318: memset(&cn, 0, sizeof(cn));
1319:
1320: /* Connect our ng_ppp(4) node link hook and ng_l2tp(4) node. */
1321: if (!PhysGetUpperHook(l, cn.path, cn.peerhook)) {
1322: Log(LG_PHYS, ("[%s] L2TP: can't get upper hook", l->name));
1323: goto fail;
1324: }
1325: snprintf(path, sizeof(path), "[%lx]:", (u_long)node_id);
1326: strlcpy(cn.ourhook, hook, sizeof(cn.ourhook));
1327: if (NgSendMsg(csock, path, NGM_GENERIC_COOKIE, NGM_CONNECT,
1328: &cn, sizeof(cn)) < 0) {
1329: Perror("[%s] L2TP: can't connect \"%s\"->\"%s\" and \"%s\"->\"%s\"",
1330: l->name, path, cn.ourhook, cn.path, cn.peerhook);
1331: goto fail;
1332: }
1333: ppp_l2tp_sess_hooked(pi->sess);
1334: close(csock);
1335: return;
1336:
1337: fail:
1338: /* Clean up after failure */
1339: ppp_l2tp_terminate(pi->sess, L2TP_RESULT_ERROR,
1340: L2TP_ERROR_GENERIC, strerror(errno));
1341: pi->sess = NULL;
1342: if (csock != -1)
1343: (void)close(csock);
1344: }
1345:
1346: /*
1347: * Read an incoming packet that might be a new L2TP connection.
1348: */
1349:
1350: static void
1351: L2tpServerEvent(int type, void *arg)
1352: {
1353: struct l2tp_server *const s = arg;
1354: L2tpInfo pi = NULL;
1355: struct ppp_l2tp_avp_list *avps = NULL;
1356: struct l2tp_tun *tun = NULL;
1357: union {
1358: u_char buf[sizeof(struct ng_ksocket_sockopt) + sizeof(int)];
1359: struct ng_ksocket_sockopt sockopt;
1360: } sockopt_buf;
1361: struct ng_ksocket_sockopt *const sockopt = &sockopt_buf.sockopt;
1362: struct ngm_connect connect;
1363: struct ngm_rmhook rmhook;
1364: struct ngm_mkpeer mkpeer;
1365: struct sockaddr_storage peer_sas;
1366: struct sockaddr_storage sas;
1367: const size_t bufsize = 8192;
1368: u_int16_t *buf = NULL;
1369: char hook[NG_HOOKSIZ];
1370: char hostname[MAXHOSTNAMELEN];
1371: socklen_t sas_len;
1372: char namebuf[64];
1373: char buf1[32], buf2[32];
1374: ng_ID_t node_id;
1375: int csock = -1;
1376: int dsock = -1;
1377: int len;
1378: u_int32_t cap;
1379: u_int16_t win;
1380: int k;
1381:
1382: /* Allocate buffer */
1383: buf = Malloc(MB_PHYS, bufsize);
1384:
1385: /* Read packet */
1386: sas_len = sizeof(peer_sas);
1387: if ((len = recvfrom(s->sock, buf, bufsize, 0,
1388: (struct sockaddr *)&peer_sas, &sas_len)) == -1) {
1389: Perror("L2TP: recvfrom");
1390: goto fail;
1391: }
1392:
1393: /* Drop it if it's not an initial L2TP packet */
1394: if (len < 12)
1395: goto fail;
1396: if ((ntohs(buf[0]) & 0xcb0f) != 0xc802 || ntohs(buf[1]) < 12
1397: || buf[2] != 0 || buf[3] != 0 || buf[4] != 0 || buf[5] != 0)
1398: goto fail;
1399:
1400: /* Create a new tun */
1401: tun = Malloc(MB_PHYS, sizeof(*tun));
1402: sockaddrtou_addr(&peer_sas,&tun->peer_addr,&tun->peer_port);
1403: u_addrcopy(&s->self_addr, &tun->self_addr);
1404: tun->self_port = s->self_port;
1405: tun->alive = 1;
1406:
1407: Log(LG_PHYS, ("Incoming L2TP packet from %s %d",
1408: u_addrtoa(&tun->peer_addr, namebuf, sizeof(namebuf)), tun->peer_port));
1409:
1410: /* Examine all L2TP links to get best possible fit tunnel parameters. */
1411: for (k = 0; k < gNumLinks; k++) {
1412: Link l2;
1413: L2tpInfo pi2;
1414:
1415: if (!gLinks[k] || gLinks[k]->type != &gL2tpPhysType)
1416: continue;
1417:
1418: l2 = gLinks[k];
1419: pi2 = (L2tpInfo)l2->info;
1420:
1421: /* Simplified comparation as it is not a final one. */
1422: if ((!PhysIsBusy(l2)) &&
1423: (pi2->server == s) &&
1424: (IpAddrInRange(&pi2->conf.peer_addr, &tun->peer_addr)) &&
1425: (pi2->conf.peer_port == 0 || pi2->conf.peer_port == tun->peer_port)) {
1426:
1427: if (pi == NULL || pi2->conf.peer_addr.width > pi->conf.peer_addr.width) {
1428: pi = pi2;
1429: if (u_rangehost(&pi->conf.peer_addr)) {
1430: break; /* Nothing could be better */
1431: }
1432: }
1433: }
1434: }
1435: if (pi == NULL) {
1436: Log(LG_PHYS, ("L2TP: No link with requested parameters "
1437: "was found"));
1438: goto fail;
1439: }
1440:
1441: /* Create vendor name AVP */
1442: avps = ppp_l2tp_avp_list_create();
1443:
1444: if (pi->conf.hostname[0] != 0) {
1445: strlcpy(hostname, pi->conf.hostname, sizeof(hostname));
1446: } else {
1447: (void)gethostname(hostname, sizeof(hostname) - 1);
1448: hostname[sizeof(hostname) - 1] = '\0';
1449: }
1450: cap = htonl(L2TP_BEARER_DIGITAL|L2TP_BEARER_ANALOG);
1451: win = htons(8); /* XXX: this value is empirical. */
1452: if ((ppp_l2tp_avp_list_append(avps, 1, 0, AVP_HOST_NAME,
1453: hostname, strlen(hostname)) == -1) ||
1454: (ppp_l2tp_avp_list_append(avps, 1, 0, AVP_VENDOR_NAME,
1455: MPD_VENDOR, strlen(MPD_VENDOR)) == -1) ||
1456: (ppp_l2tp_avp_list_append(avps, 1, 0, AVP_BEARER_CAPABILITIES,
1457: &cap, sizeof(cap)) == -1) ||
1458: (ppp_l2tp_avp_list_append(avps, 1, 0, AVP_RECEIVE_WINDOW_SIZE,
1459: &win, sizeof(win)) == -1)) {
1460: Perror("L2TP: ppp_l2tp_avp_list_append");
1461: goto fail;
1462: }
1463:
1464: /* Create a new control connection */
1465: if ((tun->ctrl = ppp_l2tp_ctrl_create(gPeventCtx, &gGiantMutex,
1466: &ppp_l2tp_server_ctrl_cb, u_addrtoid(&tun->peer_addr),
1467: &node_id, hook, avps,
1468: pi->conf.secret, strlen(pi->conf.secret),
1469: Enabled(&pi->conf.options, L2TP_CONF_HIDDEN))) == NULL) {
1470: Perror("L2TP: ppp_l2tp_ctrl_create");
1471: goto fail;
1472: }
1473: ppp_l2tp_ctrl_set_cookie(tun->ctrl, tun);
1474:
1475: /* Get a temporary netgraph socket node */
1476: if (NgMkSockNode(NULL, &csock, &dsock) == -1) {
1477: Perror("L2TP: NgMkSockNode");
1478: goto fail;
1479: }
1480:
1481: /* Connect to l2tp netgraph node "lower" hook */
1482: snprintf(namebuf, sizeof(namebuf), "[%lx]:", (u_long)node_id);
1483: memset(&connect, 0, sizeof(connect));
1484: strlcpy(connect.path, namebuf, sizeof(connect.path));
1485: strlcpy(connect.ourhook, hook, sizeof(connect.ourhook));
1486: strlcpy(connect.peerhook, hook, sizeof(connect.peerhook));
1487: if (NgSendMsg(csock, ".:", NGM_GENERIC_COOKIE,
1488: NGM_CONNECT, &connect, sizeof(connect)) == -1) {
1489: Perror("L2TP: connect");
1490: goto fail;
1491: }
1492:
1493: /* Write the received packet to the node */
1494: if (NgSendData(dsock, hook, (u_char *)buf, len) == -1) {
1495: Perror("L2TP: NgSendData");
1496: goto fail;
1497: }
1498:
1499: /* Disconnect from netgraph node "lower" hook */
1500: memset(&rmhook, 0, sizeof(rmhook));
1501: strlcpy(rmhook.ourhook, hook, sizeof(rmhook.ourhook));
1502: if (NgSendMsg(csock, ".:", NGM_GENERIC_COOKIE,
1503: NGM_RMHOOK, &rmhook, sizeof(rmhook)) == -1) {
1504: Perror("L2TP: rmhook");
1505: goto fail;
1506: }
1507:
1508: /* Attach a new UDP socket to "lower" hook */
1509: memset(&mkpeer, 0, sizeof(mkpeer));
1510: strlcpy(mkpeer.type, NG_KSOCKET_NODE_TYPE, sizeof(mkpeer.type));
1511: strlcpy(mkpeer.ourhook, hook, sizeof(mkpeer.ourhook));
1512: if (s->self_addr.family==AF_INET6) {
1513: snprintf(mkpeer.peerhook, sizeof(mkpeer.peerhook), "%d/%d/%d", PF_INET6, SOCK_DGRAM, IPPROTO_UDP);
1514: } else {
1515: snprintf(mkpeer.peerhook, sizeof(mkpeer.peerhook), "inet/dgram/udp");
1516: }
1517: if (NgSendMsg(csock, namebuf, NGM_GENERIC_COOKIE,
1518: NGM_MKPEER, &mkpeer, sizeof(mkpeer)) == -1) {
1519: Perror("L2TP: mkpeer");
1520: goto fail;
1521: }
1522:
1523: /* Point name at ksocket node */
1524: strlcat(namebuf, hook, sizeof(namebuf));
1525:
1526: /* Make UDP port reusable */
1527: memset(&sockopt_buf, 0, sizeof(sockopt_buf));
1528: sockopt->level = SOL_SOCKET;
1529: sockopt->name = SO_REUSEADDR;
1530: memcpy(sockopt->value, &one, sizeof(int));
1531: if (NgSendMsg(csock, namebuf, NGM_KSOCKET_COOKIE,
1532: NGM_KSOCKET_SETOPT, sockopt, sizeof(sockopt_buf)) == -1) {
1533: Perror("L2TP: setsockopt");
1534: goto fail;
1535: }
1536: sockopt->name = SO_REUSEPORT;
1537: if (NgSendMsg(csock, namebuf, NGM_KSOCKET_COOKIE,
1538: NGM_KSOCKET_SETOPT, sockopt, sizeof(sockopt_buf)) == -1) {
1539: Perror("L2TP: setsockopt");
1540: goto fail;
1541: }
1542:
1543: /* Bind socket to a new port */
1544: u_addrtosockaddr(&s->self_addr,s->self_port,&sas);
1545: if (NgSendMsg(csock, namebuf, NGM_KSOCKET_COOKIE,
1546: NGM_KSOCKET_BIND, &sas, sas.ss_len) == -1) {
1547: Perror("L2TP: bind");
1548: goto fail;
1549: }
1550:
1551: /* Connect socket to remote peer's IP and port */
1552: if (NgSendMsg(csock, namebuf, NGM_KSOCKET_COOKIE,
1553: NGM_KSOCKET_CONNECT, &peer_sas, peer_sas.ss_len) == -1
1554: && errno != EINPROGRESS) {
1555: Perror("L2TP: connect");
1556: goto fail;
1557: }
1558:
1559: /* Add peer to our hash table */
1560: if (ghash_put(gL2tpTuns, tun) == -1) {
1561: Perror("L2TP: ghash_put");
1562: goto fail;
1563: }
1564:
1565: Log(LG_PHYS2, ("L2TP: Control connection %p %s %u <-> %s %u accepted",
1566: tun->ctrl, u_addrtoa(&tun->self_addr,buf1,sizeof(buf1)), tun->self_port,
1567: u_addrtoa(&tun->peer_addr,buf2,sizeof(buf2)), tun->peer_port));
1568:
1569: /* Clean up and return */
1570: ppp_l2tp_avp_list_destroy(&avps);
1571: (void)close(csock);
1572: (void)close(dsock);
1573: Freee(buf);
1574: return;
1575:
1576: fail:
1577: /* Clean up after failure */
1578: if (csock != -1)
1579: (void)close(csock);
1580: if (dsock != -1)
1581: (void)close(dsock);
1582: if (tun != NULL) {
1583: ppp_l2tp_ctrl_destroy(&tun->ctrl);
1584: Freee(tun);
1585: }
1586: ppp_l2tp_avp_list_destroy(&avps);
1587: Freee(buf);
1588: }
1589:
1590:
1591: /*
1592: * L2tpListen()
1593: */
1594:
1595: static int
1596: L2tpListen(Link l)
1597: {
1598: L2tpInfo p = (L2tpInfo)l->info;
1599: struct l2tp_server *s;
1600: struct sockaddr_storage sa;
1601: char buf[48];
1602: struct ghash_walk walk;
1603:
1604: if (p->server)
1605: return(1);
1606:
1607: ghash_walk_init(gL2tpServers, &walk);
1608: while ((s = ghash_walk_next(gL2tpServers, &walk)) != NULL) {
1609: if ((u_addrcompare(&s->self_addr, &p->conf.self_addr) == 0) &&
1610: s->self_port == (p->conf.self_port?p->conf.self_port:L2TP_PORT)) {
1611: s->refs++;
1612: p->server = s;
1613: return(1);
1614: }
1615: }
1616:
1617: s = Malloc(MB_PHYS, sizeof(struct l2tp_server));
1618: s->refs = 1;
1619: u_addrcopy(&p->conf.self_addr, &s->self_addr);
1620: s->self_port = p->conf.self_port?p->conf.self_port:L2TP_PORT;
1621:
1622: /* Setup UDP socket that listens for new connections */
1623: if (s->self_addr.family==AF_INET6) {
1624: s->sock = socket(PF_INET6, SOCK_DGRAM, IPPROTO_UDP);
1625: } else {
1626: s->sock = socket(PF_INET, SOCK_DGRAM, IPPROTO_UDP);
1627: }
1628: if (s->sock == -1) {
1629: Perror("L2TP: socket");
1630: goto fail;
1631: }
1632: if (setsockopt(s->sock, SOL_SOCKET,
1633: SO_REUSEADDR, &one, sizeof(one)) == -1) {
1634: Perror("L2TP: setsockopt");
1635: goto fail;
1636: }
1637: if (setsockopt(s->sock, SOL_SOCKET,
1638: SO_REUSEPORT, &one, sizeof(one)) == -1) {
1639: Perror("L2TP: setsockopt");
1640: goto fail;
1641: }
1642: u_addrtosockaddr(&s->self_addr, s->self_port, &sa);
1643: if (bind(s->sock, (struct sockaddr *)&sa, sa.ss_len) == -1) {
1644: Perror("L2TP: bind");
1645: goto fail;
1646: }
1647:
1648: EventRegister(&s->event, EVENT_READ, s->sock,
1649: EVENT_RECURRING, L2tpServerEvent, s);
1650:
1651: Log(LG_PHYS, ("L2TP: waiting for connection on %s %u",
1652: u_addrtoa(&s->self_addr, buf, sizeof(buf)), s->self_port));
1653:
1654: p->server = s;
1655: ghash_put(gL2tpServers, s);
1656: return (1);
1657: fail:
1658: if (s->sock)
1659: close(s->sock);
1660: Freee(s);
1661: return (0);
1662: }
1663:
1664: /*
1665: * L2tpUnListen()
1666: */
1667:
1668: static void
1669: L2tpUnListen(Link l)
1670: {
1671: L2tpInfo p = (L2tpInfo)l->info;
1672: struct l2tp_server *s = p->server;
1673: char buf[48];
1674:
1675: if (!s)
1676: return;
1677:
1678: s->refs--;
1679: if (s->refs == 0) {
1680: Log(LG_PHYS, ("L2TP: stop waiting for connection on %s %u",
1681: u_addrtoa(&s->self_addr, buf, sizeof(buf)), s->self_port));
1682:
1683: ghash_remove(gL2tpServers, s);
1684: EventUnRegister(&s->event);
1685: if (s->sock)
1686: close(s->sock);
1687: Freee(s);
1688: p->server = NULL;
1689: }
1690: return;
1691: }
1692:
1693: /*
1694: * L2tpNodeUpdate()
1695: */
1696:
1697: static void
1698: L2tpNodeUpdate(Link l)
1699: {
1700: L2tpInfo const pi = (L2tpInfo) l->info;
1701: if (!pi->server) {
1702: if (Enabled(&l->conf.options, LINK_CONF_INCOMING))
1703: L2tpListen(l);
1704: } else {
1705: if (!Enabled(&l->conf.options, LINK_CONF_INCOMING))
1706: L2tpUnListen(l);
1707: }
1708: }
1709:
1710: /*
1711: * L2tpSetCommand()
1712: */
1713:
1714: static int
1715: L2tpSetCommand(Context ctx, int ac, char *av[], void *arg)
1716: {
1717: L2tpInfo const l2tp = (L2tpInfo) ctx->lnk->info;
1718: char **fqdn_peer_addr = &l2tp->conf.fqdn_peer_addr;
1719: struct u_range rng;
1720: int port;
1721:
1722: switch ((intptr_t)arg) {
1723: case SET_SELFADDR:
1724: case SET_PEERADDR:
1725: if ((ac == 1 || ac == 2) && (intptr_t)arg == SET_PEERADDR) {
1726: if (*fqdn_peer_addr)
1727: Freee(*fqdn_peer_addr);
1728: *fqdn_peer_addr = Mstrdup(MB_PHYS, av[0]);
1729: }
1730: if (ac < 1 || ac > 2 || !ParseRange(av[0], &rng, ALLOW_IPV4|ALLOW_IPV6))
1731: return(-1);
1732: if (ac > 1) {
1733: if ((port = atoi(av[1])) < 0 || port > 0xffff)
1734: return(-1);
1735: } else {
1736: port = 0;
1737: }
1738: if ((intptr_t)arg == SET_SELFADDR) {
1739: l2tp->conf.self_addr = rng.addr;
1740: l2tp->conf.self_port = port;
1741: if (l2tp->server) {
1742: L2tpUnListen(ctx->lnk);
1743: L2tpListen(ctx->lnk);
1744: }
1745: } else {
1746: l2tp->conf.peer_addr = rng;
1747: l2tp->conf.peer_port = port;
1748: }
1749: break;
1750: case SET_CALLINGNUM:
1751: if (ac != 1)
1752: return(-1);
1753: strlcpy(l2tp->conf.callingnum, av[0], sizeof(l2tp->conf.callingnum));
1754: break;
1755: case SET_CALLEDNUM:
1756: if (ac != 1)
1757: return(-1);
1758: strlcpy(l2tp->conf.callednum, av[0], sizeof(l2tp->conf.callednum));
1759: break;
1760: case SET_HOSTNAME:
1761: if (ac != 1)
1762: return(-1);
1763: strlcpy(l2tp->conf.hostname, av[0], sizeof(l2tp->conf.hostname));
1764: break;
1765: case SET_SECRET:
1766: if (ac != 1)
1767: return(-1);
1768: strlcpy(l2tp->conf.secret, av[0], sizeof(l2tp->conf.secret));
1769: break;
1770: case SET_ENABLE:
1771: EnableCommand(ac, av, &l2tp->conf.options, gConfList);
1772: break;
1773: case SET_DISABLE:
1774: DisableCommand(ac, av, &l2tp->conf.options, gConfList);
1775: break;
1776: default:
1777: assert(0);
1778: }
1779: return(0);
1780: }
1781:
1782: /*
1783: * L2tpsStat()
1784: */
1785:
1786: int
1787: L2tpsStat(Context ctx, int ac, char *av[], void *arg)
1788: {
1789: struct l2tp_tun *tun;
1790: struct ghash_walk walk;
1791: char buf1[64], buf2[64], buf3[64];
1792:
1793: Printf("Active L2TP tunnels:\r\n");
1794: ghash_walk_init(gL2tpTuns, &walk);
1795: while ((tun = ghash_walk_next(gL2tpTuns, &walk)) != NULL) {
1796:
1797: u_addrtoa(&tun->self_addr, buf1, sizeof(buf1));
1798: u_addrtoa(&tun->peer_addr, buf2, sizeof(buf2));
1799: ppp_l2tp_ctrl_stats(tun->ctrl, buf3, sizeof(buf3));
1800: Printf("%p\t %s %d <=> %s %d\t%s %d calls\r\n",
1801: tun->ctrl, buf1, tun->self_port, buf2, tun->peer_port,
1802: buf3, tun->active_sessions);
1803: }
1804:
1805: return 0;
1806: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to l2tp.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