![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to ppp_bundle.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / libpdel / ppp|
Return to ppp_bundle.c CVS log | Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / libpdel / ppp |
1.1 misho 1:
2: /*
3: * Copyright (c) 2001-2002 Packet Design, LLC.
4: * All rights reserved.
5: *
6: * Subject to the following obligations and disclaimer of warranty,
7: * use and redistribution of this software, in source or object code
8: * forms, with or without modifications are expressly permitted by
9: * Packet Design; provided, however, that:
10: *
11: * (i) Any and all reproductions of the source or object code
12: * must include the copyright notice above and the following
13: * disclaimer of warranties; and
14: * (ii) No rights are granted, in any manner or form, to use
15: * Packet Design trademarks, including the mark "PACKET DESIGN"
16: * on advertising, endorsements, or otherwise except as such
17: * appears in the above copyright notice or in the software.
18: *
19: * THIS SOFTWARE IS BEING PROVIDED BY PACKET DESIGN "AS IS", AND
20: * TO THE MAXIMUM EXTENT PERMITTED BY LAW, PACKET DESIGN MAKES NO
21: * REPRESENTATIONS OR WARRANTIES, EXPRESS OR IMPLIED, REGARDING
22: * THIS SOFTWARE, INCLUDING WITHOUT LIMITATION, ANY AND ALL IMPLIED
23: * WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE,
24: * OR NON-INFRINGEMENT. PACKET DESIGN DOES NOT WARRANT, GUARANTEE,
25: * OR MAKE ANY REPRESENTATIONS REGARDING THE USE OF, OR THE RESULTS
26: * OF THE USE OF THIS SOFTWARE IN TERMS OF ITS CORRECTNESS, ACCURACY,
27: * RELIABILITY OR OTHERWISE. IN NO EVENT SHALL PACKET DESIGN BE
28: * LIABLE FOR ANY DAMAGES RESULTING FROM OR ARISING OUT OF ANY USE
29: * OF THIS SOFTWARE, INCLUDING WITHOUT LIMITATION, ANY DIRECT,
30: * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, PUNITIVE, OR CONSEQUENTIAL
31: * DAMAGES, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, LOSS OF
32: * USE, DATA OR PROFITS, HOWEVER CAUSED AND UNDER ANY THEORY OF
33: * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
34: * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
35: * THE USE OF THIS SOFTWARE, EVEN IF PACKET DESIGN IS ADVISED OF
36: * THE POSSIBILITY OF SUCH DAMAGE.
37: *
38: * Author: Archie Cobbs <archie@freebsd.org>
39: */
40:
41: #include "ppp/ppp_defs.h"
42: #include "ppp/ppp_log.h"
43: #include "ppp/ppp_fsm_option.h"
44: #include "ppp/ppp_fsm.h"
45: #include "ppp/ppp_auth.h"
46: #include "ppp/ppp_node.h"
47: #include "ppp/ppp_engine.h"
48: #include "ppp/ppp_link.h"
49: #include "ppp/ppp_lcp.h"
50: #include "ppp/ppp_ipcp.h"
51: #include "ppp/ppp_ccp.h"
52: #include "ppp/ppp_bundle.h"
53: #include "ppp/ppp_channel.h"
54: #include "ppp/ppp_msoft.h"
55:
56: #include <netgraph/ng_mppc.h>
57:
58: #ifndef MPPE_56
59: #define MPPE_56 0x00000080
60: #define MPPE_56_UNSUPPORTED
61: #endif
62:
63: #define BUNDLE_MTYPE "ppp_bundle"
64:
65: /* Bundle structure */
66: struct ppp_bundle {
67: struct ppp_engine *engine; /* engine that owns me */
68: struct ppp_bundle_config conf; /* bundle configuration */
69: struct ppp_node *node; /* ng_ppp(4) node */
70: struct ppp_log *log; /* log */
71: struct ng_ppp_node_conf node_conf; /* ng_ppp(4) node config */
72: struct paction *action; /* configuration action */
73: struct ppp_fsm *lcp; /* lcp fsm (for bundle only) */
74: struct ppp_fsm *ipcp; /* ipcp fsm */
75: struct ppp_fsm *ccp; /* ccp fsm */
76: struct pevent_ctx *ev_ctx; /* event context */
77: pthread_mutex_t *mutex; /* mutex */
78: struct pevent *lcp_event; /* lcp fsm event */
79: struct pevent *ipcp_event; /* ipcp fsm event */
80: struct pevent *ccp_event; /* ccp fsm event */
81: struct pevent *config_timeout;/* timer for config operation */
82: void *cookie; /* client bundle cookie */
83: void *plumb_arg; /* client plumbing arg */
84: union ppp_auth_mppe mppe; /* mppe from first link auth */
85: enum ppp_auth_index mppe_auth; /* type of auth on first link */
86: u_char mppe_server; /* which side is mppe server */
87: u_char mppe_64[2][8]; /* 64 bit mppe keys */
88: u_char mppe_128[2][16];/* 128 bit mppe keys */
89: u_char multilink; /* multilink active */
90: u_char shutdown; /* bundle shutting down */
91: u_char ipcp_up; /* ipcp is up */
92: u_char ccp_up; /* ccp is up */
93: struct ppp_eid eid[2]; /* endpoint id */
94: u_int nlinks; /* number of links */
95: struct ppp_link *links[NG_PPP_MAX_LINKS]; /* links */
96: char authname[2][PPP_MAX_AUTHNAME]; /* authname's */
97: };
98:
99: /* Internal functions */
100: static int ppp_bundle_configure(struct ppp_bundle *bundle);
101: static void ppp_bundle_shutdown(struct ppp_bundle *bundle);
102: static void ppp_bundle_fsm_dead(struct ppp_bundle *bundle);
103:
104: static ppp_node_recv_t ppp_bundle_node_recv;
105:
106: /* Event handlers */
107: static pevent_handler_t ppp_bundle_lcp_event;
108: static pevent_handler_t ppp_bundle_ipcp_event;
109: static pevent_handler_t ppp_bundle_ccp_event;
110:
111: /* Internal variables */
112: static const u_char ppp_bundle_zero[16]; /* all zeros */
113:
114: /* Macro for logging */
115: #define LOG(sev, fmt, args...) PPP_LOG(bundle->log, sev, fmt , ## args)
116:
117: /***********************************************************************
118: PUBLIC FUNCTIONS
119: ***********************************************************************/
120:
121: /*
122: * Create a new bundle from a newly opened link.
123: *
124: * We 'steal' the link's ng_ppp(4) node for the bundle's use.
125: * We assume the link's device is already connected as link #0.
126: *
127: * The "log" is destroyed when the bundle is destroyed.
128: */
129: struct ppp_bundle *
130: ppp_bundle_create(struct ppp_engine *engine,
131: struct ppp_link *link, struct ppp_node *node)
132: {
133: struct ppp_lcp_req lcp_req;
134: struct ppp_bundle *bundle;
135: int i;
136:
137: /* Create bundle */
138: if ((bundle = MALLOC(BUNDLE_MTYPE, sizeof(*bundle))) == NULL)
139: return (NULL);
140: memset(bundle, 0, sizeof(*bundle));
141: bundle->engine = engine;
142: bundle->ev_ctx = ppp_engine_get_ev_ctx(engine);
143: bundle->mutex = ppp_engine_get_mutex(engine);
144: bundle->node = node;
145: bundle->links[0] = link;
146: bundle->nlinks = 1;
147:
148: /* Make bundle known to engine */
149: if (ppp_engine_add_bundle(bundle->engine, bundle) == -1)
150: goto fail;
151:
152: /* Get link's negotiated LCP config and inherit from it */
153: ppp_link_get_lcp_req(link, &lcp_req);
154: for (i = 0; i < 2; i++) {
155: strlcpy(bundle->authname[i], ppp_link_get_authname(link, i),
156: sizeof(bundle->authname[i]));
157: bundle->eid[i] = lcp_req.eid[i];
158: }
159: bundle->multilink = lcp_req.multilink[PPP_SELF];
160: bundle->mppe_server = !ppp_link_get_origination(link);
161: bundle->mppe_auth = lcp_req.auth[bundle->mppe_server];
162: ppp_link_get_mppe(link, bundle->mppe_server, &bundle->mppe);
163:
164: /* Initialize ng_ppp(4) node configuration, enabling the first link */
165: if (ppp_node_get_config(bundle->node, &bundle->node_conf) == -1)
166: goto fail;
167: bundle->node_conf.links[0].enableLink = 1;
168: bundle->node_conf.bund.mrru = lcp_req.mrru[PPP_PEER];
169: bundle->node_conf.bund.enableMultilink = bundle->multilink;
170: bundle->node_conf.bund.xmitShortSeq = lcp_req.shortseq[PPP_PEER];
171: bundle->node_conf.bund.recvShortSeq = lcp_req.shortseq[PPP_SELF];
172:
173: /* Update ng_ppp(4) node configuration */
174: if (ppp_node_set_config(bundle->node, &bundle->node_conf) == -1)
175: goto fail;
176:
177: /* Acquire bundle configuration */
178: if (ppp_bundle_configure(bundle) == -1) {
179: ppp_log_put(ppp_link_get_log(link), LOG_ERR,
180: "%s: %m", "error configuring bundle");
181: goto fail;
182: }
183:
184: /* Receive all node bypass packets */
185: ppp_node_set_recv(node, ppp_bundle_node_recv, bundle);
186:
187: /* Done */
188: return (bundle);
189:
190: fail:
191: /* Clean up after failure */
192: paction_cancel(&bundle->action);
193: pevent_unregister(&bundle->lcp_event);
194: ppp_fsm_destroy(&bundle->lcp);
195: ppp_engine_del_bundle(bundle->engine, bundle);
196: FREE(BUNDLE_MTYPE, bundle);
197: return (NULL);
198: }
199:
200: /*
201: * Close a bundle.
202: */
203: void
204: ppp_bundle_close(struct ppp_bundle *bundle)
205: {
206: int i;
207:
208: if (bundle->ipcp != NULL)
209: ppp_fsm_input(bundle->ipcp, FSM_INPUT_CLOSE);
210: if (bundle->ccp != NULL)
211: ppp_fsm_input(bundle->ipcp, FSM_INPUT_CLOSE);
212: for (i = 0; i < bundle->nlinks; i++)
213: ppp_link_close(bundle->links[i]);
214: }
215:
216: /*
217: * Destroy a bundle.
218: */
219: void
220: ppp_bundle_destroy(struct ppp_bundle **bundlep)
221: {
222: struct ppp_bundle *const bundle = *bundlep;
223:
224: /* Avoid recursion */
225: if (bundle == NULL)
226: return;
227: *bundlep = NULL;
228: if (bundle->shutdown)
229: return;
230: bundle->shutdown = 1;
231:
232: /* XXX disable traffic on node first? */
233:
234: /* Unplumb bundle and release IP address */
235: if (bundle->plumb_arg != NULL) {
236: ppp_engine_bundle_unplumb(bundle->engine,
237: bundle->plumb_arg, bundle);
238: }
239: if (bundle->conf.ip[PPP_PEER].s_addr != 0) {
240: ppp_engine_release_ip(bundle->engine,
241: bundle, bundle->conf.ip[PPP_PEER]);
242: }
243:
244: /* Destroy all links */
245: while (bundle->nlinks > 0) {
246: struct ppp_link *link = bundle->links[0];
247:
248: ppp_link_destroy(&link);
249: }
250:
251: /* Destroy bundle */
252: paction_cancel(&bundle->action);
253: ppp_engine_del_bundle(bundle->engine, bundle);
254: pevent_unregister(&bundle->config_timeout);
255: pevent_unregister(&bundle->lcp_event);
256: pevent_unregister(&bundle->ipcp_event);
257: pevent_unregister(&bundle->ccp_event);
258: ppp_fsm_destroy(&bundle->lcp);
259: ppp_fsm_destroy(&bundle->ipcp);
260: ppp_fsm_destroy(&bundle->ccp);
261: ppp_node_destroy(&bundle->node);
262: ppp_log_close(&bundle->log);
263: FREE(BUNDLE_MTYPE, bundle);
264: }
265:
266: const char *
267: ppp_bundle_get_authname(struct ppp_bundle *bundle, int dir)
268: {
269: dir &= 1;
270: return (bundle->authname[dir]);
271: }
272:
273: void
274: ppp_bundle_get_eid(struct ppp_bundle *bundle, int dir, struct ppp_eid *eid)
275: {
276: dir &= 1;
277: *eid = bundle->eid[dir];
278: }
279:
280: int
281: ppp_bundle_get_multilink(struct ppp_bundle *bundle)
282: {
283: return (bundle->multilink);
284: }
285:
286: int
287: ppp_bundle_get_links(struct ppp_bundle *bundle, struct ppp_link **list, int max)
288: {
289: int num;
290: int i;
291:
292: num = MIN(bundle->nlinks, max);
293: for (i = 0; i < num; i++)
294: list[i] = bundle->links[i];
295: return (num);
296: }
297:
298: int
299: ppp_bundle_get_ipcp(struct ppp_bundle *bundle,
300: struct ppp_ipcp_req *ipcp, int *is_up)
301: {
302: if (bundle->ipcp == NULL) {
303: errno = ENXIO;
304: return (-1);
305: }
306: if (ipcp != NULL)
307: ppp_ipcp_get_req(bundle->ipcp, ipcp);
308: if (is_up != NULL)
309: *is_up = (ppp_fsm_get_state(bundle->ipcp) == FSM_STATE_OPENED);
310: return (0);
311: }
312:
313: int
314: ppp_bundle_get_ccp(struct ppp_bundle *bundle,
315: struct ppp_ccp_req *ccp, int *is_up)
316: {
317: if (bundle->ccp == NULL) {
318: errno = ENXIO;
319: return (-1);
320: }
321: if (ccp != NULL)
322: ppp_ccp_get_req(bundle->ccp, ccp);
323: if (is_up != NULL)
324: *is_up = (ppp_fsm_get_state(bundle->ccp) == FSM_STATE_OPENED);
325: return (0);
326: }
327:
328: void *
329: ppp_bundle_get_cookie(struct ppp_bundle *bundle)
330: {
331: return (bundle->cookie);
332: }
333:
334: /*
335: * Join a new link into a bundle that already has one or more links.
336: */
337: int
338: ppp_bundle_join(struct ppp_bundle *bundle, struct ppp_link *link,
339: struct ppp_node *node, u_int16_t *link_num)
340: {
341: struct ppp_channel *const device = ppp_link_get_device(link);
342: struct ng_ppp_node_conf bconf;
343: const char *path;
344: const char *hook;
345:
346: /* Sanity check */
347: if (!bundle->multilink) {
348: LOG(LOG_ERR, "multilink disabled on this bundle");
349: errno = EINVAL;
350: return (-1);
351: }
352: if (bundle->nlinks == NG_PPP_MAX_LINKS) {
353: LOG(LOG_ERR, "too many links in this bundle");
354: errno = ENOSPC;
355: return (-1);
356: }
357:
358: /* Disconnect device from link's node */
359: if (ppp_node_disconnect(bundle->node, 0) == -1) {
360: LOG(LOG_ERR, "can't disconnect link device: %m");
361: return (-1);
362: }
363:
364: /* Connect link's device to our node */
365: if ((path = ppp_channel_get_node(device)) == NULL
366: || (hook = ppp_channel_get_hook(device)) == NULL) {
367: LOG(LOG_ERR, "link's channel is not a device");
368: return (-1);
369: }
370: if (ppp_node_connect(bundle->node, bundle->nlinks, path, hook) == -1) {
371: LOG(LOG_ERR, "%s: %m", "connecting device to node");
372: return (-1);
373: }
374:
375: /* Copy over link's configuration from link node to bundle node */
376: if (ppp_node_get_config(node, &bconf) == -1) {
377: LOG(LOG_ERR, "can't get link's node configuration: %m");
378: return (-1);
379: }
380: bundle->node_conf.links[bundle->nlinks] = bconf.links[0];
381: bundle->node_conf.links[bundle->nlinks].enableLink = 1;
382:
383: /* Update node configuration */
384: if (ppp_node_set_config(bundle->node, &bundle->node_conf) == -1)
385: goto fail;
386:
387: /* Done */
388: *link_num = bundle->nlinks;
389: bundle->links[bundle->nlinks++] = link;
390: return (0);
391:
392: fail:
393: /* Clean up after failure */
394: bundle->node_conf.links[bundle->nlinks].enableLink = 0;
395: (void)ppp_node_set_config(bundle->node, &bundle->node_conf);
396: return (-1);
397: }
398:
399: /*
400: * Remove a link from a bundle.
401: */
402: void
403: ppp_bundle_unjoin(struct ppp_bundle **bundlep, struct ppp_link *link)
404: {
405: struct ppp_bundle *bundle = *bundlep;
406: int link_num;
407:
408: /* Get bundle */
409: if (bundle == NULL)
410: return;
411: *bundlep = NULL;
412:
413: /* Find link; do nothing if not found */
414: for (link_num = 0; link_num < bundle->nlinks
415: && bundle->links[link_num] != link; link_num++);
416: if (link_num == bundle->nlinks) {
417: LOG(LOG_ERR, "link %p not found in bundle", link);
418: return;
419: }
420:
421: /* Disable traffic on link */
422: bundle->node_conf.links[link_num].enableLink = 0;
423: if (ppp_node_set_config(bundle->node, &bundle->node_conf) == -1)
424: LOG(LOG_ERR, "can't disable link: %m");
425:
426: /* Disconnect link's device from bundle's node */
427: if (ppp_node_disconnect(bundle->node, link_num) == -1)
428: LOG(LOG_ERR, "can't disconnect link device: %m");
429:
430: /* Remove link from bundle */
431: memmove(&bundle->links[link_num], &bundle->links[link_num + 1],
432: (--bundle->nlinks - link_num) * sizeof(*bundle->links));
433:
434: /* If no links remain, remove bundle */
435: if (bundle->nlinks == 0)
436: ppp_bundle_destroy(&bundle);
437: }
438:
439: /*
440: * Handle protocol rejection by peer.
441: */
442: void
443: ppp_bundle_protorej(struct ppp_bundle *bundle, u_int16_t proto)
444: {
445: switch (proto) {
446: case PPP_PROTO_LCP: /* these are required */
447: case PPP_PROTO_MP:
448: case PPP_PROTO_IPCP:
449: case PPP_PROTO_IP:
450: case PPP_PROTO_VJCOMP:
451: case PPP_PROTO_VJUNCOMP:
452: case PPP_PROTO_COMPD:
453: ppp_bundle_shutdown(bundle);
454: break;
455: case PPP_PROTO_CCP: /* this one is maybe optional */
456: if (bundle->conf.mppe_reqd)
457: ppp_bundle_shutdown(bundle);
458: else {
459: pevent_unregister(&bundle->ccp_event);
460: ppp_fsm_destroy(&bundle->ccp);
461: }
462: return;
463: default: /* others we don't care */
464: break;
465: }
466: }
467:
468: /*
469: * Write to ng_ppp(4) node "bypass" hook.
470: */
471: int
472: ppp_bundle_write(struct ppp_bundle *bundle, u_int link_num,
473: u_int16_t proto, const void *data, size_t len)
474: {
475: return (ppp_node_write(bundle->node, link_num, proto, data, len));
476: }
477:
478: /***********************************************************************
479: BUNDLE CONFIGURATION
480: ***********************************************************************/
481:
482: #define BCONFIG_MTYPE "ppp_bundle.config"
483: #define CONFIG_TIMEOUT 20 /* 20 seconds */
484:
485: /* Configuration state */
486: struct ppp_bundle_config_state {
487: struct ppp_engine *engine;
488: struct ppp_bundle *bundle;
489: struct ppp_link *link;
490: struct ppp_bundle_config config;
491: void *cookie;
492: };
493:
494: static pevent_handler_t ppp_bundle_config_timeout;
495:
496: static paction_handler_t ppp_bundle_configure_main;
497: static paction_finish_t ppp_bundle_configure_finish;
498:
499: /*
500: * Initiate action to configure bundle.
501: */
502: static int
503: ppp_bundle_configure(struct ppp_bundle *bundle)
504: {
505: struct ppp_bundle_config_state *state;
506:
507: /* Initialize state */
508: if ((state = MALLOC(BCONFIG_MTYPE, sizeof(*state))) == NULL)
509: return (-1);
510: memset(state, 0, sizeof(*state));
511: state->engine = bundle->engine;
512: state->bundle = bundle;
513: state->link = bundle->links[0];
514:
515: /* Set a timeout for ppp_engine_bundle_config() to return */
516: if (pevent_register(bundle->ev_ctx, &bundle->config_timeout, 0,
517: bundle->mutex, ppp_bundle_config_timeout, bundle, PEVENT_TIME,
518: CONFIG_TIMEOUT * 1000) == -1) {
519: LOG(LOG_ERR, "%s: %m", "pevent_register");
520: goto fail;
521: }
522:
523: /* Get the configuration in a separate thread */
524: if (paction_start(&bundle->action, bundle->mutex,
525: ppp_bundle_configure_main, ppp_bundle_configure_finish,
526: state) == -1) {
527: LOG(LOG_ERR, "%s: %m", "paction_start");
528: goto fail;
529: }
530:
531: /* Done */
532: return (0);
533:
534: fail:
535: /* Clean up */
536: paction_cancel(&bundle->action);
537: pevent_unregister(&bundle->config_timeout);
538: FREE(BCONFIG_MTYPE, state);
539: return (-1);
540: }
541:
542: /*
543: * Configure bundle main routine.
544: *
545: * This is called from a separate thread.
546: */
547: static void
548: ppp_bundle_configure_main(void *arg)
549: {
550: struct ppp_bundle_config_state *const state = arg;
551:
552: /* Get configuration for the new bundle */
553: state->cookie = ppp_engine_bundle_config(state->engine,
554: state->link, &state->config);
555:
556: /* Disable 56-bit MPPE if not supported */
557: #ifdef MPPE_56_UNSUPPORTED
558: state->config.mppe_56 = 0;
559: #endif
560: }
561:
562: /*
563: * Configure bundle finish routine.
564: *
565: * This is called from a separate thread.
566: */
567: static void
568: ppp_bundle_configure_finish(void *arg, int was_canceled)
569: {
570: struct ppp_bundle_config_state *const state = arg;
571: struct ppp_bundle *bundle = state->bundle;
572: struct ppp_fsm_instance *inst = NULL;
573: struct ppp_ipcp_config ipcp_config;
574: int i;
575:
576: /* Canceled? */
577: if (was_canceled)
578: goto done;
579:
580: /* Cancel config timer */
581: pevent_unregister(&bundle->config_timeout);
582:
583: /* Check result */
584: if (state->cookie == NULL) {
585: ppp_log_put(ppp_link_get_log(bundle->links[0]),
586: LOG_ERR, "failed to configure new bundle");
587: goto fail;
588: }
589:
590: /* Copy config info to bundle */
591: bundle->conf = state->config;
592: bundle->cookie = state->cookie;
593: bundle->conf.logname[sizeof(bundle->conf.logname) - 1] = '\0';
594:
595: /* Create log */
596: if ((bundle->log = ppp_log_prefix(ppp_engine_get_log(bundle->engine),
597: "%s: ", *bundle->conf.logname != '\0' ? bundle->conf.logname :
598: ppp_link_get_authname(bundle->links[0], PPP_PEER))) == NULL) {
599: ppp_log_put(ppp_link_get_log(bundle->links[0]),
600: LOG_ERR, "failed to create bundle log: %m");
601: goto fail;
602: }
603:
604: /* Create LCP FSM */
605: if ((inst = ppp_lcp_create(NULL)) == NULL) {
606: LOG(LOG_ERR, "failed to create LCP: %m");
607: goto fail;
608: }
609: if ((bundle->lcp = ppp_fsm_create(bundle->ev_ctx,
610: bundle->mutex, inst, bundle->log)) == NULL) {
611: LOG(LOG_ERR, "failed to create LCP: %m");
612: goto fail;
613: }
614: inst = NULL;
615:
616: /* Listen for LCP events */
617: if (pevent_register(bundle->ev_ctx, &bundle->lcp_event,
618: PEVENT_RECURRING, bundle->mutex, ppp_bundle_lcp_event, bundle,
619: PEVENT_MESG_PORT, ppp_fsm_get_outport(bundle->lcp)) == -1) {
620: LOG(LOG_ERR, "%s: %m", "adding read event for lcp");
621: goto fail;
622: }
623:
624: /* Create IPCP FSM */
625: memset(&ipcp_config, 0, sizeof(ipcp_config));
626: if (bundle->conf.dns_servers[0].s_addr != 0) {
627: ipcp_config.dns[0] = bundle->conf.dns_servers[0];
628: ipcp_config.dns[1] = bundle->conf.dns_servers[1];
629: ipcp_config.do_dns[PPP_PEER] = 1;
630: }
631: if (bundle->conf.nbns_servers[0].s_addr != 0) {
632: ipcp_config.nbns[0] = bundle->conf.nbns_servers[0];
633: ipcp_config.nbns[1] = bundle->conf.nbns_servers[1];
634: ipcp_config.do_nbns[PPP_PEER] = 1;
635: }
636: for (i = 0; i < 2; i++) {
637: ipcp_config.ip[i] = bundle->conf.ip[i];
638: ipcp_config.mask[i].s_addr
639: = (ipcp_config.ip[i].s_addr == 0) ? 0 : 0xffffffff;
640: }
641: if ((inst = ppp_ipcp_create(&ipcp_config, bundle->node)) == NULL) {
642: LOG(LOG_ERR, "failed to create IPCP: %m");
643: goto fail;
644: }
645: if ((bundle->ipcp = ppp_fsm_create(bundle->ev_ctx,
646: bundle->mutex, inst, bundle->log)) == NULL) {
647: LOG(LOG_ERR, "failed to create IPCP: %m");
648: goto fail;
649: }
650: inst = NULL;
651:
652: /* Listen for IPCP events */
653: if (pevent_register(bundle->ev_ctx, &bundle->ipcp_event,
654: PEVENT_RECURRING, bundle->mutex, ppp_bundle_ipcp_event, bundle,
655: PEVENT_MESG_PORT, ppp_fsm_get_outport(bundle->ipcp)) == -1) {
656: LOG(LOG_ERR, "%s: %m", "adding ipcp event");
657: goto fail;
658: }
659:
660: /* Start IPCP */
661: ppp_fsm_input(bundle->ipcp, FSM_INPUT_UP);
662: ppp_fsm_input(bundle->ipcp, FSM_INPUT_OPEN);
663:
664: /* Create CCP FSM (if MPPE enabled) */
665: if (bundle->conf.mppe_40
666: || bundle->conf.mppe_56
667: || bundle->conf.mppe_128) {
668: struct ppp_ccp_config ccp_config;
669: int i;
670:
671: /* Create CCP config */
672: memset(&ccp_config, 0, sizeof(ccp_config));
673: for (i = 0; i < 2; i++) {
674: if (bundle->conf.mppe_40)
675: ccp_config.mppe40[i] = 1;
676: if (bundle->conf.mppe_56)
677: ccp_config.mppe56[i] = 1;
678: if (bundle->conf.mppe_128)
679: ccp_config.mppe128[i] = 1;
680: if (bundle->conf.mppe_stateless)
681: ccp_config.mppe_stateless[i] = 1;
682: }
683:
684: /* Derive the MPPE keys we'll need */
685: switch (bundle->mppe_auth) {
686: case PPP_AUTH_CHAP_MSV1:
687: for (i = 0; i < 2; i++) {
688: memcpy(&bundle->mppe_64[i],
689: bundle->mppe.msv1.key_64,
690: sizeof(bundle->mppe_64[i]));
691: memcpy(&bundle->mppe_128[i],
692: bundle->mppe.msv1.key_128,
693: sizeof(bundle->mppe_128[i]));
694: }
695: break;
696: case PPP_AUTH_CHAP_MSV2:
697: for (i = 0; i < 2; i++) {
698: memcpy(&bundle->mppe_64[i],
699: bundle->mppe.msv2.keys[!i
700: ^ bundle->mppe_server],
701: sizeof(bundle->mppe_64[i]));
702: memcpy(&bundle->mppe_128[i],
703: bundle->mppe.msv2.keys[!i
704: ^ bundle->mppe_server],
705: sizeof(bundle->mppe_128[i]));
706: }
707: break;
708: default:
709: if (bundle->conf.mppe_reqd) {
710: LOG(LOG_ERR, "MPPE %s but MS-CHAP was not"
711: " used for authentication", "required");
712: goto fail;
713: } else {
714: LOG(LOG_WARNING, "MPPE %s but MS-CHAP was not"
715: " used for authentication", "requested");
716: goto done;
717: }
718: break;
719: }
720:
721: /* Create CCP instance */
722: if ((inst = ppp_ccp_create(&ccp_config,
723: bundle->node)) == NULL) {
724: LOG(LOG_ERR, "failed to create CCP: %m");
725: goto fail;
726: }
727: if ((bundle->ccp = ppp_fsm_create(bundle->ev_ctx,
728: bundle->mutex, inst, bundle->log)) == NULL) {
729: LOG(LOG_ERR, "failed to create CCP: %m");
730: goto fail;
731: }
732: inst = NULL;
733:
734: /* Listen for CCP events */
735: if (pevent_register(bundle->ev_ctx, &bundle->ccp_event,
736: PEVENT_RECURRING, bundle->mutex, ppp_bundle_ccp_event,
737: bundle, PEVENT_MESG_PORT, ppp_fsm_get_outport(bundle->ccp))
738: == -1) {
739: LOG(LOG_ERR, "%s: %m", "adding ccp event");
740: goto fail;
741: }
742:
743: /* Start CCP */
744: ppp_fsm_input(bundle->ccp, FSM_INPUT_UP);
745: ppp_fsm_input(bundle->ccp, FSM_INPUT_OPEN);
746: }
747:
748: done:
749: /* Done */
750: FREE(BCONFIG_MTYPE, state);
751: return;
752:
753: fail:
754: /* Clean up after failure */
755: if (inst != NULL)
756: (*inst->type->destroy)(inst);
757: ppp_bundle_destroy(&bundle);
758: FREE(BCONFIG_MTYPE, state);
759: }
760:
761: /*
762: * Handle a timeout trying to configure the bundle.
763: */
764: static void
765: ppp_bundle_config_timeout(void *arg)
766: {
767: struct ppp_bundle *bundle = arg;
768:
769: LOG(LOG_ERR, "timed out configuring new bundle");
770: paction_cancel(&bundle->action);
771: ppp_bundle_destroy(&bundle);
772: }
773:
774: /***********************************************************************
775: PPP NODE OUTPUT HANDLER
776: ***********************************************************************/
777:
778: /*
779: * Handle data received from the node's bypass hook.
780: */
781: static void
782: ppp_bundle_node_recv(void *arg, u_int link_num,
783: u_int16_t proto, u_char *data, size_t len)
784: {
785: struct ppp_bundle *const bundle = arg;
786:
787: /* Check for link-specific packets */
788: if (PPP_PROTO_LINK_LAYER(proto) && link_num != NG_PPP_BUNDLE_LINKNUM) {
789: if (link_num >= bundle->nlinks)
790: return;
791: ppp_link_recv_bypass(bundle->links[link_num], proto, data, len);
792: return;
793: }
794:
795: /* Handle packet at the bundle level */
796: switch (proto) {
797: case PPP_PROTO_IPCP:
798: if (bundle->ipcp != NULL)
799: ppp_fsm_input(bundle->ipcp, FSM_INPUT_DATA, data, len);
800: break;
801: case PPP_PROTO_CCP:
802: if (bundle->ccp != NULL)
803: ppp_fsm_input(bundle->ccp, FSM_INPUT_DATA, data, len);
804: else if (bundle->action == NULL) /* got config already */
805: goto proto_reject;
806: break;
807: case PPP_PROTO_MP:
808: case PPP_PROTO_IP:
809: case PPP_PROTO_VJCOMP:
810: case PPP_PROTO_VJUNCOMP:
811: case PPP_PROTO_COMPD:
812: break;
813: default:
814: goto proto_reject;
815: }
816: return;
817:
818: proto_reject:
819: /* Send a protocol reject */
820: if (bundle->lcp != NULL) {
821: ppp_fsm_input(bundle->lcp,
822: FSM_INPUT_XMIT_PROTOREJ, proto, data, len);
823: }
824: }
825:
826: /***********************************************************************
827: LCP EVENT HANDLER
828: ***********************************************************************/
829:
830: static void
831: ppp_bundle_lcp_event(void *arg)
832: {
833: struct ppp_bundle *const bundle = arg;
834: struct mesg_port *const outport = ppp_fsm_get_outport(bundle->lcp);
835: struct ppp_fsm_output *output;
836:
837: /* Read and handle all FSM events */
838: while ((output = mesg_port_get(outport, 0)) != NULL) {
839:
840: /* Check it out */
841: switch (output->type) {
842: case FSM_OUTPUT_DATA: /* probably an echo reply */
843: ppp_node_write(bundle->node, NG_PPP_BUNDLE_LINKNUM,
844: PPP_PROTO_LCP, output->u.data.data,
845: output->u.data.length);
846: break;
847: case FSM_OUTPUT_PROTOREJ:
848: {
849: LOG(LOG_NOTICE, "peer rejected protocol 0x%04x",
850: output->u.proto);
851: ppp_bundle_protorej(bundle, output->u.proto);
852: break;
853: }
854: case FSM_OUTPUT_OPEN:
855: case FSM_OUTPUT_CLOSE:
856: case FSM_OUTPUT_UP:
857: case FSM_OUTPUT_DOWN:
858: case FSM_OUTPUT_DEAD:
859: LOG(LOG_NOTICE, "unexpected LCP output: %s",
860: ppp_fsm_output_str(output));
861: break;
862: }
863:
864: /* Free output */
865: ppp_fsm_free_output(output);
866: }
867: }
868:
869: /***********************************************************************
870: IPCP EVENT HANDLER
871: ***********************************************************************/
872:
873: static void
874: ppp_bundle_ipcp_event(void *arg)
875: {
876: struct ppp_bundle *const bundle = arg;
877: struct mesg_port *const outport = ppp_fsm_get_outport(bundle->ipcp);
878: struct ppp_fsm_output *output;
879:
880: /* Read and handle all FSM events */
881: while ((output = mesg_port_get(outport, 0)) != NULL) {
882:
883: /* Check it out */
884: switch (output->type) {
885: case FSM_OUTPUT_OPEN:
886: case FSM_OUTPUT_CLOSE:
887: break;
888: case FSM_OUTPUT_UP:
889: {
890: static const char *chooks[][2] = {
891: { NG_PPP_HOOK_VJC_IP, NG_VJC_HOOK_IP },
892: { NG_PPP_HOOK_VJC_COMP, NG_VJC_HOOK_VJCOMP },
893: { NG_PPP_HOOK_VJC_UNCOMP, NG_VJC_HOOK_VJUNCOMP },
894: { NG_PPP_HOOK_VJC_VJIP, NG_VJC_HOOK_VJIP },
895: };
896: struct ng_ppp_node_conf conf;
897: struct ngm_vjc_config vjc;
898: struct ppp_ipcp_req req;
899: struct ngm_mkpeer mkpeer;
900: char buf[16];
901: u_int mtu;
902: int i;
903:
904: /* Remember IPCP is up */
905: bundle->ipcp_up = 1;
906:
907: /* Get negotiated parameters */
908: ppp_ipcp_get_req(bundle->ipcp, &req);
909: strlcpy(buf, inet_ntoa(req.ip[PPP_SELF]), sizeof(buf));
910: LOG(LOG_INFO, "IPCP successfully configured: "
911: "%s -> %s", buf, inet_ntoa(req.ip[PPP_PEER]));
912:
913: /* Get ppp node config */
914: if (ppp_node_get_config(bundle->node, &conf) == -1) {
915: LOG(LOG_ERR, "can't get ppp node config: %m");
916: ppp_fsm_input(bundle->ipcp, FSM_INPUT_CLOSE);
917: break;
918: }
919:
920: /* Configure IP traffic */
921: conf.bund.enableIP =
922: !bundle->conf.mppe_reqd || bundle->ccp_up;
923: conf.bund.enableVJCompression = 0;
924: conf.bund.enableVJDecompression = 0;
925:
926: /* Skip VJC config if not negotiated */
927: if (!req.vjc[PPP_SELF].enabled
928: && !req.vjc[PPP_PEER].enabled)
929: goto no_vjc;
930:
931: /* Attach vjc node to ppp node */
932: (void)ppp_node_send_msg(bundle->node,
933: chooks[0][0], NGM_GENERIC_COOKIE,
934: NGM_SHUTDOWN, NULL, 0);
935: memset(&mkpeer, 0, sizeof(mkpeer));
936: strlcpy(mkpeer.type,
937: NG_VJC_NODE_TYPE, sizeof(mkpeer.type));
938: strlcpy(mkpeer.ourhook,
939: chooks[0][0], sizeof(mkpeer.ourhook));
940: strlcpy(mkpeer.peerhook,
941: chooks[0][1], sizeof(mkpeer.peerhook));
942: if (ppp_node_send_msg(bundle->node, NULL,
943: NGM_GENERIC_COOKIE, NGM_MKPEER, &mkpeer,
944: sizeof(mkpeer)) == -1) {
945: LOG(LOG_ERR, "can't attach VJC node: %m");
946: ppp_fsm_input(bundle->ipcp, FSM_INPUT_CLOSE);
947: break;
948: }
949: for (i = 1; i < sizeof(chooks) / sizeof(*chooks); i++) {
950: struct ngm_connect connect;
951:
952: memset(&connect, 0, sizeof(connect));
953: strlcpy(connect.path,
954: NG_PPP_HOOK_VJC_IP, sizeof(connect.path));
955: strlcpy(connect.ourhook,
956: chooks[i][0], sizeof(connect.ourhook));
957: strlcpy(connect.peerhook,
958: chooks[i][1], sizeof(connect.peerhook));
959: if (ppp_node_send_msg(bundle->node, NULL,
960: NGM_GENERIC_COOKIE, NGM_CONNECT, &connect,
961: sizeof(connect)) == -1) {
962: LOG(LOG_ERR,
963: "can't connect VJC node: %m");
964: ppp_fsm_input(bundle->ipcp,
965: FSM_INPUT_CLOSE);
966: break;
967: }
968: }
969: if (i < sizeof(chooks) / sizeof(*chooks)) /* failed */
970: break;
971:
972: /* Configure VJ compression node */
973: memset(&vjc, 0, sizeof(vjc));
974: vjc.enableComp = req.vjc[PPP_PEER].enabled;
975: vjc.enableDecomp = req.vjc[PPP_SELF].enabled;
976: vjc.maxChannel = req.vjc[PPP_PEER].maxchan;
977: vjc.compressCID = req.vjc[PPP_PEER].compcid;
978: if (ppp_node_send_msg(bundle->node, NG_PPP_HOOK_VJC_IP,
979: NGM_VJC_COOKIE, NGM_VJC_SET_CONFIG,
980: &vjc, sizeof(vjc)) == -1) {
981: LOG(LOG_ERR, "error configuring VJC node: %m");
982: ppp_fsm_input(bundle->ipcp, FSM_INPUT_CLOSE);
983: break;
984: }
985:
986: /* Configure ppp node to enable VJ (de)compression */
987: conf.bund.enableVJCompression
988: = req.vjc[PPP_PEER].enabled;
989: conf.bund.enableVJDecompression
990: = req.vjc[PPP_SELF].enabled;
991:
992: no_vjc:
993: /*
994: * Determine the MTU for the interface
995: *
996: * XXX if/when compression is added, we must account
997: * XXX for any possible payload expansion here as well
998: */
999: mtu = bundle->multilink ? bundle->node_conf.bund.mrru
1000: : bundle->node_conf.links[0].mru;
1001: if (bundle->conf.mppe_40
1002: || bundle->conf.mppe_56
1003: || bundle->conf.mppe_128)
1004: mtu -= 4; /* allow for mppe header */
1005:
1006: /* Plumb the 'top' side of the node */
1007: if ((bundle->plumb_arg =
1008: ppp_engine_bundle_plumb(bundle->engine, bundle,
1009: ppp_node_get_path(bundle->node), NG_PPP_HOOK_INET,
1010: req.ip, req.dns, req.nbns, mtu)) == NULL) {
1011: LOG(LOG_ERR, "error plumbing ppp node: %m");
1012: ppp_fsm_input(bundle->ipcp, FSM_INPUT_CLOSE);
1013: break;
1014: }
1015:
1016: /* Update ppp node configuration */
1017: if (ppp_node_set_config(bundle->node, &conf) == -1) {
1018: LOG(LOG_ERR, "error configuring ppp node: %m");
1019: ppp_fsm_input(bundle->ipcp, FSM_INPUT_CLOSE);
1020: break;
1021: }
1022: break;
1023: }
1024: case FSM_OUTPUT_DOWN:
1025: {
1026: struct ng_ppp_node_conf conf;
1027: void *parg;
1028:
1029: /* Remember IPCP is down */
1030: bundle->ipcp_up = 0;
1031:
1032: /* Get ppp node config */
1033: if (ppp_node_get_config(bundle->node, &conf) == -1) {
1034: LOG(LOG_ERR, "can't get ppp node config: %m");
1035: ppp_fsm_input(bundle->ipcp, FSM_INPUT_CLOSE);
1036: break;
1037: }
1038:
1039: /* Disable IP and VJC packets */
1040: conf.bund.enableIP = 0;
1041: conf.bund.enableVJCompression = 0;
1042: conf.bund.enableVJDecompression = 0;
1043:
1044: /* Update ppp node configuration */
1045: if (ppp_node_set_config(bundle->node, &conf) == -1) {
1046: LOG(LOG_ERR, "error configuring ppp node: %m");
1047: ppp_fsm_input(bundle->ipcp, FSM_INPUT_CLOSE);
1048: break;
1049: }
1050:
1051: /* Clobber VJC node (if any) */
1052: (void)ppp_node_send_msg(bundle->node,
1053: NG_PPP_HOOK_VJC_IP, NGM_GENERIC_COOKIE,
1054: NGM_SHUTDOWN, NULL, 0);
1055:
1056: /* Disconnect the 'top' side of the node */
1057: if ((parg = bundle->plumb_arg) != NULL) {
1058: bundle->plumb_arg = NULL;
1059: ppp_engine_bundle_unplumb(bundle->engine,
1060: parg, bundle);
1061: }
1062: break;
1063: }
1064: case FSM_OUTPUT_DATA:
1065: ppp_node_write(bundle->node, NG_PPP_BUNDLE_LINKNUM,
1066: PPP_PROTO_IPCP, output->u.data.data,
1067: output->u.data.length);
1068: break;
1069: case FSM_OUTPUT_PROTOREJ:
1070: LOG(LOG_NOTICE, "unexpected IPCP output: %s",
1071: ppp_fsm_output_str(output));
1072: break;
1073: case FSM_OUTPUT_DEAD:
1074: LOG(LOG_INFO, "IPCP is dead: %s",
1075: ppp_fsm_reason_str(output));
1076: ppp_fsm_destroy(&bundle->ipcp);
1077: ppp_bundle_fsm_dead(bundle);
1078: ppp_fsm_free_output(output);
1079: return;
1080: }
1081:
1082: /* Free output */
1083: ppp_fsm_free_output(output);
1084: }
1085: }
1086:
1087: /***********************************************************************
1088: CCP EVENT HANDLER
1089: ***********************************************************************/
1090:
1091: static void
1092: ppp_bundle_ccp_event(void *arg)
1093: {
1094: struct ppp_bundle *const bundle = arg;
1095: struct mesg_port *const outport = ppp_fsm_get_outport(bundle->ccp);
1096: struct ppp_fsm_output *output;
1097:
1098: /* Read and handle all FSM events */
1099: while ((output = mesg_port_get(outport, 0)) != NULL) {
1100:
1101: /* Check it out */
1102: switch (output->type) {
1103: case FSM_OUTPUT_OPEN:
1104: case FSM_OUTPUT_CLOSE:
1105: break;
1106: case FSM_OUTPUT_UP:
1107: {
1108: struct ng_ppp_node_conf conf;
1109: struct ngm_connect connect;
1110: struct ngm_mkpeer mkpeer;
1111: struct ppp_ccp_req req;
1112: char buf[2][64];
1113: int i;
1114:
1115: /* Remember CCP is up */
1116: bundle->ccp_up = 1;
1117:
1118: /* Some peers don't know 56 bit and will ack it too */
1119: for (i = 0; i < 2; i++) {
1120: if (req.mppe56[i]
1121: && (req.mppe40[i] || req.mppe128[i]))
1122: req.mppe56[i] = 0;
1123: }
1124:
1125: /* Get negotiated parameters */
1126: ppp_ccp_get_req(bundle->ccp, &req);
1127: for (i = 0; i < 2; i++) {
1128: strlcpy(buf[i], "MPPC", sizeof(buf[i]));
1129: if (req.mppc[i]) {
1130: strlcat(buf[i], " compression",
1131: sizeof(buf[i]));
1132: }
1133: if (req.mppe40[i]) {
1134: strlcat(buf[i], " 40 bit encryption",
1135: sizeof(buf[i]));
1136: } else if (req.mppe56[i]) {
1137: strlcat(buf[i], " 56 bit encryption",
1138: sizeof(buf[i]));
1139: } else if (req.mppe128[i]) {
1140: strlcat(buf[i], " 128 bit encryption",
1141: sizeof(buf[i]));
1142: }
1143: if (req.mppe_stateless[i]) {
1144: strlcat(buf[i], ", stateless",
1145: sizeof(buf[i]));
1146: }
1147: }
1148: LOG(LOG_INFO, "CCP successfully configured: "
1149: "Recv: %s; Xmit: %s", buf[PPP_SELF], buf[PPP_PEER]);
1150:
1151: /* Get ppp node config */
1152: if (ppp_node_get_config(bundle->node, &conf) == -1) {
1153: LOG(LOG_ERR, "can't get ppp node config: %m");
1154: ppp_fsm_input(bundle->ccp, FSM_INPUT_CLOSE);
1155: break;
1156: }
1157:
1158: /* Enable IP traffic now */
1159: if (bundle->ipcp_up)
1160: conf.bund.enableIP = 1;
1161:
1162: /* Configure ppp node to enable MPPC (de)compression */
1163: conf.bund.enableCompression = req.mppc[PPP_PEER]
1164: || req.mppe40[PPP_PEER]
1165: || req.mppe56[PPP_PEER]
1166: || req.mppe128[PPP_PEER];
1167: conf.bund.enableDecompression = req.mppc[PPP_SELF]
1168: || req.mppe40[PPP_SELF]
1169: || req.mppe56[PPP_SELF]
1170: || req.mppe128[PPP_SELF];
1171:
1172: /* Attach mppc node to ppp node */
1173: (void)ppp_node_send_msg(bundle->node,
1174: NG_PPP_HOOK_COMPRESS, NGM_GENERIC_COOKIE,
1175: NGM_SHUTDOWN, NULL, 0);
1176: memset(&mkpeer, 0, sizeof(mkpeer));
1177: strlcpy(mkpeer.type,
1178: NG_MPPC_NODE_TYPE, sizeof(mkpeer.type));
1179: strlcpy(mkpeer.ourhook,
1180: NG_PPP_HOOK_COMPRESS, sizeof(mkpeer.ourhook));
1181: strlcpy(mkpeer.peerhook,
1182: NG_MPPC_HOOK_COMP, sizeof(mkpeer.peerhook));
1183: if (ppp_node_send_msg(bundle->node, NULL,
1184: NGM_GENERIC_COOKIE, NGM_MKPEER, &mkpeer,
1185: sizeof(mkpeer)) == -1) {
1186: LOG(LOG_ERR, "can't attach MPPC node: %m");
1187: ppp_fsm_input(bundle->ccp, FSM_INPUT_CLOSE);
1188: break;
1189: }
1190: memset(&connect, 0, sizeof(connect));
1191: strlcpy(connect.path,
1192: NG_PPP_HOOK_COMPRESS, sizeof(connect.path));
1193: strlcpy(connect.ourhook,
1194: NG_PPP_HOOK_DECOMPRESS, sizeof(connect.ourhook));
1195: strlcpy(connect.peerhook,
1196: NG_MPPC_HOOK_DECOMP, sizeof(connect.peerhook));
1197: if (ppp_node_send_msg(bundle->node, NULL,
1198: NGM_GENERIC_COOKIE, NGM_CONNECT, &connect,
1199: sizeof(connect)) == -1) {
1200: LOG(LOG_ERR, "can't connect MPPC node: %m");
1201: ppp_fsm_input(bundle->ccp, FSM_INPUT_CLOSE);
1202: break;
1203: }
1204:
1205: /* Verify we have the MPPE keys that we need */
1206: for (i = 0; i < 2; i++) {
1207: if (((req.mppe40[i] || req.mppe56[i])
1208: && memcmp(&bundle->mppe_64[i],
1209: ppp_bundle_zero, 8) == 0)
1210: || (req.mppe128[i]
1211: && memcmp(&bundle->mppe_128[i],
1212: ppp_bundle_zero, 16) == 0)) {
1213: LOG(LOG_ERR, "can't do MPPE encryption:"
1214: " no keys were provided by the"
1215: " authentication process");
1216: ppp_fsm_input(bundle->ccp,
1217: FSM_INPUT_CLOSE);
1218: break;
1219: }
1220: }
1221: if (i < 2)
1222: break;
1223:
1224: /* Configure MPPC node in both directions */
1225: for (i = 0; i < 2; i++) {
1226: struct ng_mppc_config mppc;
1227:
1228: memset(&mppc, 0, sizeof(mppc));
1229: mppc.enable = req.mppc[i] || req.mppe40[i]
1230: || req.mppe56[i] || req.mppe128[i];
1231: if (req.mppc[i])
1232: mppc.bits |= MPPC_BIT;
1233: if (req.mppe40[i] || req.mppe56[i]) {
1234: mppc.bits |= req.mppe40[i] ?
1235: MPPE_40 : MPPE_56;
1236: memcpy(mppc.startkey,
1237: &bundle->mppe_64[i],
1238: sizeof(bundle->mppe_64[i]));
1239: } else if (req.mppe128[i]) {
1240: mppc.bits |= MPPE_128;
1241: memcpy(mppc.startkey,
1242: &bundle->mppe_128[i],
1243: sizeof(bundle->mppe_128[i]));
1244: }
1245: if (req.mppe_stateless[i])
1246: mppc.bits |= MPPE_STATELESS;
1247: if (ppp_node_send_msg(bundle->node,
1248: NG_PPP_HOOK_COMPRESS, NGM_MPPC_COOKIE,
1249: (i == PPP_SELF) ? NGM_MPPC_CONFIG_DECOMP
1250: : NGM_MPPC_CONFIG_COMP,
1251: &mppc, sizeof(mppc)) == -1) {
1252: LOG(LOG_ERR,
1253: "error configuring MPPC node: %m");
1254: ppp_fsm_input(bundle->ccp,
1255: FSM_INPUT_CLOSE);
1256: break;
1257: }
1258: }
1259:
1260: /* Update ppp node configuration */
1261: if (ppp_node_set_config(bundle->node, &conf) == -1) {
1262: LOG(LOG_ERR, "error configuring ppp node: %m");
1263: ppp_fsm_input(bundle->ccp, FSM_INPUT_CLOSE);
1264: break;
1265: }
1266: break;
1267: }
1268: case FSM_OUTPUT_DOWN:
1269: {
1270: struct ng_ppp_node_conf conf;
1271:
1272: /* Remember CCP is down */
1273: bundle->ccp_up = 0;
1274:
1275: /* Get ppp node config */
1276: if (ppp_node_get_config(bundle->node, &conf) == -1) {
1277: LOG(LOG_ERR, "can't get ppp node config: %m");
1278: ppp_fsm_input(bundle->ccp, FSM_INPUT_CLOSE);
1279: break;
1280: }
1281:
1282: /* Disable IP traffic if encryption is required */
1283: if (bundle->conf.mppe_reqd)
1284: conf.bund.enableIP = 0;
1285:
1286: /* Disable compression */
1287: conf.bund.enableCompression = 0;
1288: conf.bund.enableDecompression = 0;
1289:
1290: /* Update ppp node configuration */
1291: if (ppp_node_set_config(bundle->node, &conf) == -1) {
1292: LOG(LOG_ERR, "error configuring ppp node: %m");
1293: ppp_fsm_input(bundle->ccp, FSM_INPUT_CLOSE);
1294: break;
1295: }
1296:
1297: /* Clobber MPPC node */
1298: (void)ppp_node_send_msg(bundle->node,
1299: NG_PPP_HOOK_COMPRESS, NGM_GENERIC_COOKIE,
1300: NGM_SHUTDOWN, NULL, 0);
1301: break;
1302: }
1303: case FSM_OUTPUT_DATA:
1304: ppp_node_write(bundle->node, NG_PPP_BUNDLE_LINKNUM,
1305: PPP_PROTO_CCP, output->u.data.data,
1306: output->u.data.length);
1307: break;
1308: case FSM_OUTPUT_PROTOREJ:
1309: LOG(LOG_NOTICE, "unexpected CCP output: %s",
1310: ppp_fsm_output_str(output));
1311: break;
1312: case FSM_OUTPUT_DEAD:
1313: LOG(LOG_INFO, "CCP is dead: %s",
1314: ppp_fsm_reason_str(output));
1315: ppp_fsm_destroy(&bundle->ccp);
1316: ppp_bundle_fsm_dead(bundle);
1317: ppp_fsm_free_output(output);
1318: return;
1319: }
1320:
1321: /* Free output */
1322: ppp_fsm_free_output(output);
1323: }
1324: }
1325:
1326: /***********************************************************************
1327: INTERNAL FUNCTIONS
1328: ***********************************************************************/
1329:
1330: /*
1331: * One of our network control protocols has died.
1332: * If this is fatal, then shutdown the bundle.
1333: */
1334: static void
1335: ppp_bundle_fsm_dead(struct ppp_bundle *bundle)
1336: {
1337: if (bundle->ipcp == NULL) {
1338: ppp_bundle_shutdown(bundle);
1339: return;
1340: }
1341: if (bundle->conf.mppe_reqd && bundle->ccp == NULL) {
1342: LOG(LOG_ERR, "MPPE is required but CCP negotiation failed");
1343: ppp_bundle_shutdown(bundle);
1344: }
1345: }
1346:
1347: /*
1348: * Shutdown the bundle.
1349: */
1350: static void
1351: ppp_bundle_shutdown(struct ppp_bundle *bundle)
1352: {
1353: int i;
1354:
1355: if (bundle->ipcp != NULL)
1356: ppp_fsm_input(bundle->ipcp, FSM_INPUT_CLOSE);
1357: if (bundle->ccp != NULL)
1358: ppp_fsm_input(bundle->ccp, FSM_INPUT_CLOSE);
1359: for (i = 0; i < bundle->nlinks; i++)
1360: ppp_link_close(bundle->links[i]);
1361: }
1362: