![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to lcp.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|
Return to lcp.c CVS log | Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / mpd / src |
1.1 misho 1:
2: /*
3: * lcp.c
4: *
5: * Written by Toshiharu OHNO <tony-o@iij.ad.jp>
6: * Copyright (c) 1993, Internet Initiative Japan, Inc. All rights reserved.
7: * See ``COPYRIGHT.iij''
8: *
9: * Rewritten by Archie Cobbs <archie@freebsd.org>
10: * Copyright (c) 1995-1999 Whistle Communications, Inc. All rights reserved.
11: * See ``COPYRIGHT.whistle''
12: */
13:
14: #include "ppp.h"
15: #include "lcp.h"
16: #include "fsm.h"
17: #include "mp.h"
18: #include "phys.h"
19: #include "link.h"
20: #include "msg.h"
21: #include "util.h"
22:
23: /*
24: * DEFINITIONS
25: */
26:
27: #define LCP_ECHO_INTERVAL 5 /* Enable keep alive by default */
28: #define LCP_ECHO_TIMEOUT 40
29:
30: #define LCP_KNOWN_CODES ( (1 << CODE_CONFIGREQ) \
31: | (1 << CODE_CONFIGACK) \
32: | (1 << CODE_CONFIGNAK) \
33: | (1 << CODE_CONFIGREJ) \
34: | (1 << CODE_TERMREQ) \
35: | (1 << CODE_TERMACK) \
36: | (1 << CODE_CODEREJ) \
37: | (1 << CODE_PROTOREJ) \
38: | (1 << CODE_ECHOREQ) \
39: | (1 << CODE_ECHOREP) \
40: | (1 << CODE_DISCREQ) \
41: | (1 << CODE_IDENT) \
42: | (1 << CODE_TIMEREM) )
43:
44: #define LCP_PEER_REJECTED(p,x) ((p)->peer_reject & (1<<x))
45: #define LCP_PEER_REJ(p,x) do{(p)->peer_reject |= (1<<(x));}while(0)
46: #define LCP_PEER_UNREJ(p,x) do{(p)->peer_reject &= ~(1<<(x));}while(0)
47:
48: /*
49: * INTERNAL FUNCTIONS
50: */
51:
52: static void LcpConfigure(Fsm fp);
53: static void LcpNewState(Fsm fp, enum fsm_state old, enum fsm_state new);
54: static void LcpNewPhase(Link l, enum lcp_phase new);
55:
56: static u_char *LcpBuildConfigReq(Fsm fp, u_char *cp);
57: static void LcpDecodeConfig(Fsm fp, FsmOption list, int num, int mode);
58: static void LcpLayerDown(Fsm fp);
59: static void LcpLayerStart(Fsm fp);
60: static void LcpLayerFinish(Fsm fp);
61: static int LcpRecvProtoRej(Fsm fp, int proto, Mbuf bp);
62: static void LcpFailure(Fsm fp, enum fsmfail reason);
63: static const struct fsmoption *LcpAuthProtoNak(ushort proto, u_char alg);
64: static short LcpFindAuthProto(ushort proto, u_char alg);
65: static void LcpRecvIdent(Fsm fp, Mbuf bp);
66: static void LcpStopActivity(Link l);
67:
68: /*
69: * INTERNAL VARIABLES
70: */
71:
72: static const struct fsmoptinfo gLcpConfOpts[] = {
73: { "VENDOR", TY_VENDOR, 4, 255, TRUE },
74: { "MRU", TY_MRU, 2, 2, TRUE },
75: { "ACCMAP", TY_ACCMAP, 4, 4, TRUE },
76: { "AUTHPROTO", TY_AUTHPROTO, 2, 255, TRUE },
77: { "QUALPROTO", TY_QUALPROTO, 0, 0, FALSE },
78: { "MAGICNUM", TY_MAGICNUM, 4, 4, TRUE },
79: { "RESERVED", TY_RESERVED, 0, 0, FALSE }, /* DEPRECATED */
80: { "PROTOCOMP", TY_PROTOCOMP, 0, 0, TRUE },
81: { "ACFCOMP", TY_ACFCOMP, 0, 0, TRUE },
82: { "FCSALT", TY_FCSALT, 0, 0, FALSE },
83: { "SDP", TY_SDP, 0, 0, FALSE },
84: { "NUMMODE", TY_NUMMODE, 0, 0, FALSE },
85: { "MULTILINK", TY_MULTILINK, 0, 0, FALSE }, /* DEPRECATED */
86: { "CALLBACK", TY_CALLBACK, 1, 255, TRUE },
87: { "CONNECTTIME", TY_CONNECTTIME, 0, 0, FALSE }, /* DEPRECATED */
88: { "COMPFRAME", TY_COMPFRAME, 0, 0, FALSE }, /* DEPRECATED */
89: { "NDS", TY_NDS, 0, 0, FALSE }, /* DEPRECATED */
90: { "MP MRRU", TY_MRRU, 2, 2, TRUE },
91: { "MP SHORTSEQ", TY_SHORTSEQNUM, 0, 0, TRUE },
92: { "ENDPOINTDISC", TY_ENDPOINTDISC, 1, 255, TRUE },
93: { "PROPRIETARY", TY_PROPRIETARY, 0, 0, FALSE },
94: { "DCEIDENTIFIER", TY_DCEIDENTIFIER, 0, 0, FALSE },
95: { "MULTILINKPLUS", TY_MULTILINKPLUS, 0, 0, FALSE },
96: { "BACP", TY_BACP, 0, 0, FALSE },
97: { "LCPAUTHOPT", TY_LCPAUTHOPT, 0, 0, FALSE },
98: { "COBS", TY_COBS, 0, 0, FALSE },
99: { "PREFIXELISION", TY_PREFIXELISION, 0, 0, FALSE },
100: { "MULTILINKHEADERFMT", TY_MULTILINKHEADERFMT, 0, 0, FALSE },
101: { "INTERNAT", TY_INTERNAT, 0, 0, FALSE },
102: { "SDATALINKSONET", TY_SDATALINKSONET, 0, 0, FALSE },
103: { NULL }
104: };
105:
106: static struct fsmtype gLcpFsmType = {
107: "LCP", /* Name of protocol */
108: PROTO_LCP, /* Protocol Number */
109: LCP_KNOWN_CODES,
110: TRUE,
111: LG_LCP, LG_LCP2,
112: LcpNewState,
113: NULL,
114: LcpLayerDown,
115: LcpLayerStart,
116: LcpLayerFinish,
117: LcpBuildConfigReq,
118: LcpDecodeConfig,
119: LcpConfigure,
120: NULL,
121: NULL,
122: NULL,
123: NULL,
124: LcpRecvProtoRej,
125: LcpFailure,
126: NULL,
127: NULL,
128: LcpRecvIdent,
129: };
130:
131: /* List of possible Authentication Protocols */
132: static struct lcpauthproto gLcpAuthProtos[] = {
133: {
134: PROTO_PAP,
135: 0,
136: LINK_CONF_PAP,
137: },
138: {
139: PROTO_CHAP,
140: CHAP_ALG_MD5,
141: LINK_CONF_CHAPMD5
142: },
143: {
144: PROTO_CHAP,
145: CHAP_ALG_MSOFT,
146: LINK_CONF_CHAPMSv1
147: },
148: {
149: PROTO_CHAP,
150: CHAP_ALG_MSOFTv2,
151: LINK_CONF_CHAPMSv2
152: },
153: {
154: PROTO_EAP,
155: 0,
156: LINK_CONF_EAP
157: }
158:
159: };
160:
161: static const char *PhaseNames[] = {
162: "DEAD",
163: "ESTABLISH",
164: "AUTHENTICATE",
165: "NETWORK",
166: "TERMINATE",
167: };
168:
169: /*
170: * LcpInit()
171: */
172:
173: void
174: LcpInit(Link l)
175: {
176: LcpState const lcp = &l->lcp;
177:
178: memset(lcp, 0, sizeof(*lcp));
179: FsmInit(&lcp->fsm, &gLcpFsmType, l);
180: lcp->fsm.conf.echo_int = LCP_ECHO_INTERVAL;
181: lcp->fsm.conf.echo_max = LCP_ECHO_TIMEOUT;
182: lcp->phase = PHASE_DEAD;
183:
184: AuthInit(l);
185: }
186:
187: /*
188: * LcpInst()
189: */
190:
191: void
192: LcpInst(Link l, Link lt)
193: {
194: LcpState const lcp = &l->lcp;
195:
196: memcpy(lcp, <->lcp, sizeof(*lcp));
197: FsmInst(&lcp->fsm, <->lcp.fsm, l);
198: AuthInst(&lcp->auth, <->lcp.auth);
199: }
200:
201: /*
202: * LcpShutdown()
203: */
204:
205: void
206: LcpShutdown(Link l)
207: {
208: AuthShutdown(l);
209: }
210:
211: /*
212: * LcpConfigure()
213: */
214:
215: static void
216: LcpConfigure(Fsm fp)
217: {
218: Link l = (Link)fp->arg;
219: LcpState const lcp = &l->lcp;
220: short i;
221:
222: /* FSM stuff */
223: lcp->fsm.conf.passive = Enabled(&l->conf.options, LINK_CONF_PASSIVE);
224: lcp->fsm.conf.check_magic =
225: Enabled(&l->conf.options, LINK_CONF_CHECK_MAGIC);
226: lcp->peer_reject = 0;
227:
228: /* Initialize normal LCP stuff */
229: lcp->peer_mru = l->conf.mtu;
230: lcp->want_mru = l->conf.mru;
231: if (l->type && (lcp->want_mru > l->type->mru))
232: lcp->want_mru = l->type->mru;
233: lcp->peer_accmap = 0xffffffff;
234: lcp->want_accmap = l->conf.accmap;
235: lcp->peer_acfcomp = FALSE;
236: lcp->want_acfcomp = Enabled(&l->conf.options, LINK_CONF_ACFCOMP);
237: lcp->peer_protocomp = FALSE;
238: lcp->want_protocomp = Enabled(&l->conf.options, LINK_CONF_PROTOCOMP);
239: lcp->peer_magic = 0;
240: lcp->want_magic = Enabled(&l->conf.options,
241: LINK_CONF_MAGICNUM) ? GenerateMagic() : 0;
242: if (l->originate == LINK_ORIGINATE_LOCAL)
243: lcp->want_callback = Enabled(&l->conf.options, LINK_CONF_CALLBACK);
244: else
245: lcp->want_callback = FALSE;
246:
247: /* Authentication stuff */
248: lcp->peer_auth = 0;
249: lcp->want_auth = 0;
250: lcp->peer_alg = 0;
251: lcp->want_alg = 0;
252: lcp->peer_ident[0] = 0;
253:
254: memset(lcp->want_protos, 0, sizeof(lcp->want_protos));
255: /* fill my list of possible auth-protos, most to least secure */
256: /* prefer MS-CHAP to others to get encryption keys */
257: lcp->want_protos[0] = &gLcpAuthProtos[LINK_CONF_CHAPMSv2];
258: lcp->want_protos[1] = &gLcpAuthProtos[LINK_CONF_CHAPMSv1];
259: lcp->want_protos[2] = &gLcpAuthProtos[LINK_CONF_CHAPMD5];
260: lcp->want_protos[3] = &gLcpAuthProtos[LINK_CONF_PAP];
261: lcp->want_protos[4] = &gLcpAuthProtos[LINK_CONF_EAP];
262:
263: /* Use the same list for the MODE_REQ */
264: memcpy(lcp->peer_protos, lcp->want_protos, sizeof(lcp->peer_protos));
265:
266: for (i = 0; i < LCP_NUM_AUTH_PROTOS; i++) {
267: if (Enabled(&l->conf.options, lcp->want_protos[i]->conf) && lcp->want_auth == 0) {
268: lcp->want_auth = lcp->want_protos[i]->proto;
269: lcp->want_alg = lcp->want_protos[i]->alg;
270: /* avoid re-requesting this proto, if it was nak'd by the peer */
271: lcp->want_protos[i] = NULL;
272: } else if (!Enabled(&l->conf.options, lcp->want_protos[i]->conf)) {
273: /* don't request disabled Protos */
274: lcp->want_protos[i] = NULL;
275: }
276:
277: /* remove all denied protos */
278: if (!Acceptable(&l->conf.options, lcp->peer_protos[i]->conf))
279: lcp->peer_protos[i] = NULL;
280: }
281:
282: /* Multi-link stuff */
283: lcp->peer_mrru = 0;
284: lcp->peer_shortseq = FALSE;
285: if (Enabled(&l->conf.options, LINK_CONF_MULTILINK)) {
286: lcp->want_mrru = l->conf.mrru;
287: lcp->want_shortseq = Enabled(&l->conf.options, LINK_CONF_SHORTSEQ);
288: } else {
289: lcp->want_mrru = 0;
290: lcp->want_shortseq = FALSE;
291: }
292:
293: /* Peer discriminator */
294: lcp->peer_discrim.class = DISCRIM_CLASS_NULL;
295: lcp->peer_discrim.len = 0;
296: }
297:
298: /*
299: * LcpNewState()
300: *
301: * Keep track of phase shifts
302: */
303:
304: static void
305: LcpNewState(Fsm fp, enum fsm_state old, enum fsm_state new)
306: {
307: Link l = (Link)fp->arg;
308:
309: switch (old) {
310: case ST_INITIAL: /* DEAD */
311: case ST_STARTING:
312: switch (new) {
313: case ST_INITIAL:
314: /* fall through */
315: case ST_STARTING:
316: break;
317: default:
318: LcpNewPhase(l, PHASE_ESTABLISH);
319: break;
320: }
321: break;
322:
323: case ST_CLOSED: /* ESTABLISH */
324: case ST_STOPPED:
325: switch (new) {
326: case ST_INITIAL:
327: case ST_STARTING:
328: LcpNewPhase(l, PHASE_DEAD);
329: break;
330: default:
331: break;
332: }
333: break;
334:
335: case ST_CLOSING: /* TERMINATE */
336: case ST_STOPPING:
337: switch (new) {
338: case ST_INITIAL:
339: case ST_STARTING:
340: LcpNewPhase(l, PHASE_DEAD);
341: break;
342: case ST_CLOSED:
343: case ST_STOPPED:
344: LcpNewPhase(l, PHASE_ESTABLISH);
345: break;
346: default:
347: break;
348: }
349: break;
350:
351: case ST_REQSENT: /* ESTABLISH */
352: case ST_ACKRCVD:
353: case ST_ACKSENT:
354: switch (new) {
355: case ST_INITIAL:
356: case ST_STARTING:
357: LcpNewPhase(l, PHASE_DEAD);
358: break;
359: case ST_CLOSING:
360: case ST_STOPPING:
361: LcpNewPhase(l, PHASE_TERMINATE);
362: break;
363: case ST_OPENED:
364: LcpNewPhase(l, PHASE_AUTHENTICATE);
365: break;
366: default:
367: break;
368: }
369: break;
370:
371: case ST_OPENED: /* AUTHENTICATE, NETWORK */
372: switch (new) {
373: case ST_STARTING:
374: LcpNewPhase(l, PHASE_DEAD);
375: break;
376: case ST_REQSENT:
377: case ST_ACKSENT:
378: LcpNewPhase(l, PHASE_ESTABLISH);
379: break;
380: case ST_CLOSING:
381: case ST_STOPPING:
382: LcpNewPhase(l, PHASE_TERMINATE);
383: break;
384: default:
385: assert(0);
386: }
387: break;
388:
389: default:
390: assert(0);
391: }
392:
393: LinkShutdownCheck(l, new);
394: }
395:
396: /*
397: * LcpNewPhase()
398: */
399:
400: static void
401: LcpNewPhase(Link l, enum lcp_phase new)
402: {
403: LcpState const lcp = &l->lcp;
404: enum lcp_phase old = lcp->phase;
405:
406: /* Logit */
407: Log(LG_LCP2, ("[%s] %s: phase shift %s --> %s",
408: Pref(&lcp->fsm), Fsm(&lcp->fsm), PhaseNames[old], PhaseNames[new]));
409:
410: /* Sanity check transition (The picture on RFC 1661 p. 6 is incomplete) */
411: switch (old) {
412: case PHASE_DEAD:
413: assert(new == PHASE_ESTABLISH);
414: break;
415: case PHASE_ESTABLISH:
416: assert(new == PHASE_DEAD
417: || new == PHASE_TERMINATE
418: || new == PHASE_AUTHENTICATE);
419: break;
420: case PHASE_AUTHENTICATE:
421: assert(new == PHASE_TERMINATE
422: || new == PHASE_ESTABLISH
423: || new == PHASE_NETWORK
424: || new == PHASE_DEAD);
425: break;
426: case PHASE_NETWORK:
427: assert(new == PHASE_TERMINATE
428: || new == PHASE_ESTABLISH
429: || new == PHASE_DEAD);
430: break;
431: case PHASE_TERMINATE:
432: assert(new == PHASE_ESTABLISH
433: || new == PHASE_DEAD);
434: break;
435: default:
436: assert(0);
437: }
438:
439: /* Change phase now */
440: lcp->phase = new;
441:
442: /* Do whatever for leaving old phase */
443: switch (old) {
444: case PHASE_AUTHENTICATE:
445: if (new != PHASE_NETWORK)
446: AuthCleanup(l);
447: break;
448:
449: case PHASE_NETWORK:
450: if (l->joined_bund)
451: BundLeave(l);
452: AuthCleanup(l);
453: break;
454:
455: default:
456: break;
457: }
458:
459: /* Do whatever for entering new phase */
460: switch (new) {
461: case PHASE_ESTABLISH:
462: break;
463:
464: case PHASE_AUTHENTICATE:
465: if (!PhysIsSync(l))
466: PhysSetAccm(l, lcp->peer_accmap, lcp->want_accmap);
467: AuthStart(l);
468: break;
469:
470: case PHASE_NETWORK:
471: /* Send ident string, if configured */
472: if (l->conf.ident != NULL)
473: FsmSendIdent(&lcp->fsm, l->conf.ident);
474:
475: /* Send Time-Remaining if known */
476: if (Enabled(&l->conf.options, LINK_CONF_TIMEREMAIN) &&
477: lcp->auth.params.session_timeout != 0)
478: FsmSendTimeRemaining(&lcp->fsm, lcp->auth.params.session_timeout);
479:
480: /* Join my bundle */
481: if (!BundJoin(l)) {
482: Log(LG_LINK|LG_BUND,
483: ("[%s] link did not validate in bundle",
484: l->name));
485: RecordLinkUpDownReason(NULL, l,
486: 0, STR_PROTO_ERR, "%s", STR_MULTI_FAIL);
487: FsmFailure(&l->lcp.fsm, FAIL_NEGOT_FAILURE);
488: } else {
489: /* If link connection complete, reset redial counter */
490: l->num_redial = 0;
491: }
492: break;
493:
494: case PHASE_TERMINATE:
495: break;
496:
497: case PHASE_DEAD:
498: break;
499:
500: default:
501: assert(0);
502: }
503: }
504:
505: /*
506: * LcpAuthResult()
507: */
508:
509: void
510: LcpAuthResult(Link l, int success)
511: {
512: Log(LG_AUTH|LG_LCP, ("[%s] %s: authorization %s",
513: Pref(&l->lcp.fsm), Fsm(&l->lcp.fsm), success ? "successful" : "failed"));
514: if (success) {
515: if (l->lcp.phase != PHASE_NETWORK)
516: LcpNewPhase(l, PHASE_NETWORK);
517: } else {
518: RecordLinkUpDownReason(NULL, l, 0, STR_LOGIN_FAIL,
519: "%s", STR_PPP_AUTH_FAILURE);
520: FsmFailure(&l->lcp.fsm, FAIL_NEGOT_FAILURE);
521: }
522: }
523:
524: /*
525: * LcpStat()
526: */
527:
528: int
529: LcpStat(Context ctx, int ac, char *av[], void *arg)
530: {
531: Link const l = ctx->lnk;
532: LcpState const lcp = &l->lcp;
533: char buf[64];
534:
535: Printf("%s [%s]\r\n", lcp->fsm.type->name, FsmStateName(lcp->fsm.state));
536:
537: Printf("Self:\r\n");
538: Printf( "\tMRU : %d bytes\r\n"
539: "\tMAGIC : 0x%08x\r\n"
540: "\tACCMAP : 0x%08x\r\n"
541: "\tACFCOMP : %s\r\n"
542: "\tPROTOCOMP: %s\r\n"
543: "\tAUTHTYPE : %s\r\n",
544: (int) lcp->want_mru,
545: (int) lcp->want_magic,
546: (int) lcp->want_accmap,
547: lcp->want_acfcomp ? "Yes" : "No",
548: lcp->want_protocomp ? "Yes" : "No",
549: (lcp->want_auth)?ProtoName(lcp->want_auth):"none");
550:
551: if (lcp->want_mrru) {
552: Printf( "\tMRRU : %d bytes\r\n", (int) lcp->want_mrru);
553: Printf( "\tSHORTSEQ : %s\r\n", lcp->want_shortseq ? "Yes" : "No");
554: Printf( "\tENDPOINTDISC: %s\r\n", MpDiscrimText(&self_discrim, buf, sizeof(buf)));
555: }
556: if (l->conf.ident)
557: Printf( "\tIDENT : %s\r\n", l->conf.ident);
558:
559: Printf("Peer:\r\n");
560: Printf( "\tMRU : %d bytes\r\n"
561: "\tMAGIC : 0x%08x\r\n"
562: "\tACCMAP : 0x%08x\r\n"
563: "\tACFCOMP : %s\r\n"
564: "\tPROTOCOMP: %s\r\n"
565: "\tAUTHTYPE : %s\r\n",
566: (int) lcp->peer_mru,
567: (int) lcp->peer_magic,
568: (int) lcp->peer_accmap,
569: lcp->peer_acfcomp ? "Yes" : "No",
570: lcp->peer_protocomp ? "Yes" : "No",
571: (lcp->peer_auth)?ProtoName(lcp->peer_auth):"none");
572:
573: if (lcp->peer_mrru) {
574: Printf( "\tMRRU : %d bytes\r\n", (int) lcp->peer_mrru);
575: Printf( "\tSHORTSEQ : %s\r\n", lcp->peer_shortseq ? "Yes" : "No");
576: Printf( "\tENDPOINTDISC: %s\r\n", MpDiscrimText(&lcp->peer_discrim, buf, sizeof(buf)));
577: }
578: if (lcp->peer_ident[0])
579: Printf( "\tIDENT : %s\r\n", lcp->peer_ident);
580:
581: return(0);
582: }
583:
584: /*
585: * LcpBuildConfigReq()
586: */
587:
588: static u_char *
589: LcpBuildConfigReq(Fsm fp, u_char *cp)
590: {
591: Link l = (Link)fp->arg;
592: LcpState const lcp = &l->lcp;
593:
594: /* Standard stuff */
595: if (lcp->want_acfcomp && !LCP_PEER_REJECTED(lcp, TY_ACFCOMP))
596: cp = FsmConfValue(cp, TY_ACFCOMP, 0, NULL);
597: if (lcp->want_protocomp && !LCP_PEER_REJECTED(lcp, TY_PROTOCOMP))
598: cp = FsmConfValue(cp, TY_PROTOCOMP, 0, NULL);
599: if ((!PhysIsSync(l)) && (!LCP_PEER_REJECTED(lcp, TY_ACCMAP)))
600: cp = FsmConfValue(cp, TY_ACCMAP, -4, &lcp->want_accmap);
601: if (!LCP_PEER_REJECTED(lcp, TY_MRU))
602: cp = FsmConfValue(cp, TY_MRU, -2, &lcp->want_mru);
603: if (lcp->want_magic && !LCP_PEER_REJECTED(lcp, TY_MAGICNUM))
604: cp = FsmConfValue(cp, TY_MAGICNUM, -4, &lcp->want_magic);
605: if (lcp->want_callback && !LCP_PEER_REJECTED(lcp, TY_CALLBACK)) {
606: struct {
607: u_char op;
608: u_char data[0];
609: } s_callback;
610:
611: s_callback.op = 0;
612: cp = FsmConfValue(cp, TY_CALLBACK, 1, &s_callback);
613: }
614:
615: /* Authorization stuff */
616: switch (lcp->want_auth) {
617: case PROTO_PAP:
618: case PROTO_EAP:
619: cp = FsmConfValue(cp, TY_AUTHPROTO, -2, &lcp->want_auth);
620: break;
621: case PROTO_CHAP: {
622: struct {
623: u_short want_auth;
624: u_char alg;
625: } s_mdx;
626:
627: s_mdx.want_auth = htons(PROTO_CHAP);
628: s_mdx.alg = lcp->want_alg;
629: cp = FsmConfValue(cp, TY_AUTHPROTO, 3, &s_mdx);
630: }
631: break;
632: }
633:
634: /* Multi-link stuff */
635: if (Enabled(&l->conf.options, LINK_CONF_MULTILINK)
636: && !LCP_PEER_REJECTED(lcp, TY_MRRU)) {
637: cp = FsmConfValue(cp, TY_MRRU, -2, &lcp->want_mrru);
638: if (lcp->want_shortseq && !LCP_PEER_REJECTED(lcp, TY_SHORTSEQNUM))
639: cp = FsmConfValue(cp, TY_SHORTSEQNUM, 0, NULL);
640: if (!LCP_PEER_REJECTED(lcp, TY_ENDPOINTDISC))
641: cp = FsmConfValue(cp, TY_ENDPOINTDISC, 1 + self_discrim.len, &self_discrim.class);
642: }
643:
644: /* Done */
645: return(cp);
646: }
647:
648: static void
649: LcpLayerStart(Fsm fp)
650: {
651: Link l = (Link)fp->arg;
652:
653: LinkNgInit(l);
654: if (!TimerStarted(&l->openTimer))
655: PhysOpen(l);
656: }
657:
658: static void
659: LcpStopActivity(Link l)
660: {
661: AuthStop(l);
662: }
663:
664: static void
665: LcpLayerFinish(Fsm fp)
666: {
667: Link l = (Link)fp->arg;
668:
669: LcpStopActivity(l);
670: if (!l->rep) {
671: PhysClose(l);
672: LinkNgShutdown(l);
673: }
674: }
675:
676: /*
677: * LcpLayerDown()
678: */
679:
680: static void
681: LcpLayerDown(Fsm fp)
682: {
683: Link l = (Link)fp->arg;
684: LcpStopActivity(l);
685: }
686:
687: void LcpOpen(Link l)
688: {
689: FsmOpen(&l->lcp.fsm);
690: }
691:
692: void LcpClose(Link l)
693: {
694: FsmClose(&l->lcp.fsm);
695: }
696:
697: void LcpUp(Link l)
698: {
699: FsmUp(&l->lcp.fsm);
700: }
701:
702: void LcpDown(Link l)
703: {
704: FsmDown(&l->lcp.fsm);
705: }
706:
707: /*
708: * LcpRecvProtoRej()
709: */
710:
711: static int
712: LcpRecvProtoRej(Fsm fp, int proto, Mbuf bp)
713: {
714: Link l = (Link)fp->arg;
715: int fatal = FALSE;
716: Fsm rej = NULL;
717:
718: /* Which protocol? */
719: switch (proto) {
720: case PROTO_CCP:
721: case PROTO_COMPD:
722: rej = l->bund ? &l->bund->ccp.fsm : NULL;
723: break;
724: case PROTO_ECP:
725: case PROTO_CRYPT:
726: rej = l->bund ? &l->bund->ecp.fsm : NULL;
727: break;
728: case PROTO_IPCP:
729: rej = l->bund ? &l->bund->ipcp.fsm : NULL;
730: break;
731: case PROTO_IPV6CP:
732: rej = l->bund ? &l->bund->ipv6cp.fsm : NULL;
733: break;
734: default:
735: break;
736: }
737:
738: /* Turn off whatever protocol got rejected */
739: if (rej)
740: FsmFailure(rej, FAIL_WAS_PROTREJ);
741: return(fatal);
742: }
743:
744: /*
745: * LcpRecvIdent()
746: */
747:
748: static void
749: LcpRecvIdent(Fsm fp, Mbuf bp)
750: {
751: Link l = (Link)fp->arg;
752: int len, clen;
753:
754: if (bp == NULL)
755: return;
756:
757: if (l->lcp.peer_ident[0] != 0)
758: strlcat(l->lcp.peer_ident, " ", sizeof(l->lcp.peer_ident));
759:
760: len = strlen(l->lcp.peer_ident);
761: clen = sizeof(l->lcp.peer_ident) - len - 1;
762: if (clen > MBLEN(bp))
763: clen = MBLEN(bp);
764: memcpy(l->lcp.peer_ident + len, (char *) MBDATAU(bp), clen);
765: l->lcp.peer_ident[len + clen] = 0;
766: }
767:
768: /*
769: * LcpFailure()
770: */
771:
772: static void
773: LcpFailure(Fsm fp, enum fsmfail reason)
774: {
775: Link l = (Link)fp->arg;
776: char buf[100];
777:
778: snprintf(buf, sizeof(buf), STR_LCP_FAILED, FsmFailureStr(reason));
779: RecordLinkUpDownReason(NULL, l, 0, reason == FAIL_ECHO_TIMEOUT ?
780: STR_ECHO_TIMEOUT : STR_PROTO_ERR, "%s", buf);
781: }
782:
783: /*
784: * LcpDecodeConfig()
785: */
786:
787: static void
788: LcpDecodeConfig(Fsm fp, FsmOption list, int num, int mode)
789: {
790: Link l = (Link)fp->arg;
791: LcpState const lcp = &l->lcp;
792: int k;
793:
794: /* If we have got request, forget the previous values */
795: if (mode == MODE_REQ) {
796: lcp->peer_mru = l->conf.mtu;
797: lcp->peer_accmap = 0xffffffff;
798: lcp->peer_acfcomp = FALSE;
799: lcp->peer_protocomp = FALSE;
800: lcp->peer_magic = 0;
801: lcp->peer_auth = 0;
802: lcp->peer_alg = 0;
803: lcp->peer_mrru = 0;
804: lcp->peer_shortseq = FALSE;
805: }
806:
807: /* Decode each config option */
808: for (k = 0; k < num; k++) {
809: FsmOption const opt = &list[k];
810: FsmOptInfo const oi = FsmFindOptInfo(gLcpConfOpts, opt->type);
811:
812: /* Check option */
813: if (!oi) {
814: Log(LG_LCP, ("[%s] UNKNOWN[%d] len=%d", l->name, opt->type, opt->len));
815: if (mode == MODE_REQ)
816: FsmRej(fp, opt);
817: continue;
818: }
819: if (!oi->supported) {
820: Log(LG_LCP, ("[%s] %s", l->name, oi->name));
821: if (mode == MODE_REQ) {
822: Log(LG_LCP, ("[%s] Not supported", l->name));
823: FsmRej(fp, opt);
824: }
825: continue;
826: }
827: if (opt->len < oi->minLen + 2 || opt->len > oi->maxLen + 2) {
828: Log(LG_LCP, ("[%s] %s", l->name, oi->name));
829: if (mode == MODE_REQ) {
830: Log(LG_LCP, ("[%s] Bogus length=%d", l->name, opt->len));
831: FsmRej(fp, opt);
832: }
833: continue;
834: }
835:
836: /* Do whatever */
837: switch (opt->type) {
838: case TY_MRU: /* link MRU */
839: {
840: u_int16_t mru;
841:
842: memcpy(&mru, opt->data, 2);
843: mru = ntohs(mru);
844: Log(LG_LCP, ("[%s] %s %d", l->name, oi->name, mru));
845: switch (mode) {
846: case MODE_REQ:
847: if (mru < LCP_MIN_MRU) {
848: mru = htons(LCP_MIN_MRU);
849: memcpy(opt->data, &mru, 2);
850: FsmNak(fp, opt);
851: break;
852: }
853: if (mru < lcp->peer_mru)
854: lcp->peer_mru = mru;
855: FsmAck(fp, opt);
856: break;
857: case MODE_NAK:
858: /* Windows 2000 PPPoE bug workaround */
859: if (mru == lcp->want_mru) {
860: LCP_PEER_REJ(lcp, opt->type);
861: break;
862: }
863: if (mru >= LCP_MIN_MRU
864: && (mru <= l->type->mru || mru < lcp->want_mru))
865: lcp->want_mru = mru;
866: break;
867: case MODE_REJ:
868: LCP_PEER_REJ(lcp, opt->type);
869: break;
870: }
871: }
872: break;
873:
874: case TY_ACCMAP: /* async control character escape map */
875: {
876: u_int32_t accm;
877:
878: memcpy(&accm, opt->data, 4);
879: accm = ntohl(accm);
880: Log(LG_LCP, ("[%s] %s 0x%08x", l->name, oi->name, accm));
881: switch (mode) {
882: case MODE_REQ:
883: lcp->peer_accmap = accm;
884: FsmAck(fp, opt);
885: break;
886: case MODE_NAK:
887: lcp->want_accmap = accm;
888: break;
889: case MODE_REJ:
890: LCP_PEER_REJ(lcp, opt->type);
891: break;
892: }
893: }
894: break;
895:
896: case TY_AUTHPROTO: /* authentication protocol */
897: {
898: u_int16_t proto;
899: int bogus = 0, i, protoPos = -1;
900: LcpAuthProto authProto = NULL;
901:
902: memcpy(&proto, opt->data, 2);
903: proto = ntohs(proto);
904:
905: /* Display it */
906: switch (proto) {
907: case PROTO_CHAP:
908: if (opt->len >= 5) {
909: char buf[20];
910: const char *ts;
911:
912: switch (opt->data[2]) {
913: case CHAP_ALG_MD5:
914: ts = "MD5";
915: break;
916: case CHAP_ALG_MSOFT:
917: ts = "MSOFT";
918: break;
919: case CHAP_ALG_MSOFTv2:
920: ts = "MSOFTv2";
921: break;
922: default:
923: snprintf(buf, sizeof(buf), "0x%02x", opt->data[2]);
924: ts = buf;
925: break;
926: }
927: Log(LG_LCP, ("[%s] %s %s %s", l->name, oi->name, ProtoName(proto), ts));
928: break;
929: }
930: break;
931: default:
932: Log(LG_LCP, ("[%s] %s %s", l->name, oi->name, ProtoName(proto)));
933: break;
934: }
935:
936: /* Sanity check */
937: switch (proto) {
938: case PROTO_PAP:
939: if (opt->len != 4) {
940: Log(LG_LCP, ("[%s] Bad len=%d", l->name, opt->len));
941: bogus = 1;
942: }
943: break;
944: case PROTO_CHAP:
945: if (opt->len != 5) {
946: Log(LG_LCP, ("[%s] Bad len=%d", l->name, opt->len));
947: bogus = 1;
948: }
949: break;
950: }
951: if (!bogus) {
952: protoPos = LcpFindAuthProto(proto, proto == PROTO_CHAP ? opt->data[2] : 0);
953: authProto = (protoPos == -1) ? NULL : &gLcpAuthProtos[protoPos];
954: }
955:
956: /* Deal with it */
957: switch (mode) {
958: case MODE_REQ:
959:
960: /* let us check, whether the requested auth-proto is acceptable */
961: if ((authProto != NULL) && Acceptable(&l->conf.options, authProto->conf)) {
962: lcp->peer_auth = proto;
963: if (proto == PROTO_CHAP)
964: lcp->peer_alg = opt->data[2];
965: FsmAck(fp, opt);
966: break;
967: }
968:
969: /* search an acceptable proto */
970: for(i = 0; i < LCP_NUM_AUTH_PROTOS; i++) {
971: if (lcp->peer_protos[i] != NULL) {
972: FsmNak(fp, LcpAuthProtoNak(lcp->peer_protos[i]->proto, lcp->peer_protos[i]->alg));
973: break;
974: }
975: }
976:
977: /* no other acceptable auth-proto found */
978: if (i == LCP_NUM_AUTH_PROTOS)
979: FsmRej(fp, opt);
980: break;
981:
982: case MODE_NAK:
983: /* this should never happen */
984: if (authProto == NULL)
985: break;
986:
987: /* let us check, whether the requested auth-proto is enabled */
988: if (Enabled(&l->conf.options, authProto->conf)) {
989: lcp->want_auth = proto;
990: if (proto == PROTO_CHAP)
991: lcp->want_alg = opt->data[2];
992: break;
993: }
994:
995: /* Remove the disabled proto from my list */
996: lcp->want_protos[protoPos] = NULL;
997:
998: /* Search the next enabled proto */
999: for(i = 0; i < LCP_NUM_AUTH_PROTOS; i++) {
1000: if (lcp->want_protos[i] != NULL) {
1001: lcp->want_auth = lcp->want_protos[i]->proto;
1002: lcp->want_alg = lcp->want_protos[i]->alg;
1003: break;
1004: }
1005: }
1006: break;
1007:
1008: case MODE_REJ:
1009: LCP_PEER_REJ(lcp, opt->type);
1010: if (l->originate == LINK_ORIGINATE_LOCAL
1011: && Enabled(&l->conf.options, LINK_CONF_NO_ORIG_AUTH)) {
1012: lcp->want_auth = 0;
1013: }
1014: break;
1015: }
1016: }
1017: break;
1018:
1019: case TY_MRRU: /* multi-link MRRU */
1020: {
1021: u_int16_t mrru;
1022:
1023: memcpy(&mrru, opt->data, 2);
1024: mrru = ntohs(mrru);
1025: Log(LG_LCP, ("[%s] %s %d", l->name, oi->name, mrru));
1026: switch (mode) {
1027: case MODE_REQ:
1028: if (!Enabled(&l->conf.options, LINK_CONF_MULTILINK)) {
1029: FsmRej(fp, opt);
1030: break;
1031: }
1032: if (mrru < MP_MIN_MRRU) {
1033: mrru = htons(MP_MIN_MRRU);
1034: memcpy(opt->data, &mrru, 2);
1035: FsmNak(fp, opt);
1036: break;
1037: }
1038: lcp->peer_mrru = mrru;
1039: FsmAck(fp, opt);
1040: break;
1041: case MODE_NAK:
1042: {
1043: /* Let the peer to change it's mind. */
1044: if (LCP_PEER_REJECTED(lcp, opt->type)) {
1045: LCP_PEER_UNREJ(lcp, opt->type);
1046: if (Enabled(&l->conf.options, LINK_CONF_MULTILINK))
1047: lcp->want_mrru = l->conf.mrru;
1048: }
1049: /* Make sure we don't violate any rules by changing MRRU now */
1050: if (mrru > lcp->want_mrru) /* too big */
1051: break;
1052: if (mrru < MP_MIN_MRRU) /* too small; clip */
1053: mrru = MP_MIN_MRRU;
1054:
1055: /* Update our links */
1056: lcp->want_mrru = mrru;
1057: }
1058: break;
1059: case MODE_REJ:
1060: lcp->want_mrru = 0;
1061: LCP_PEER_REJ(lcp, opt->type);
1062: break;
1063: }
1064: }
1065: break;
1066:
1067: case TY_SHORTSEQNUM: /* multi-link short sequence numbers */
1068: Log(LG_LCP, ("[%s] %s", l->name, oi->name));
1069: switch (mode) {
1070: case MODE_REQ:
1071: if (!Enabled(&l->conf.options, LINK_CONF_MULTILINK) ||
1072: !Acceptable(&l->conf.options, LINK_CONF_SHORTSEQ)) {
1073: FsmRej(fp, opt);
1074: break;
1075: }
1076: lcp->peer_shortseq = TRUE;
1077: FsmAck(fp, opt);
1078: break;
1079: case MODE_NAK:
1080: /* Let the peer to change it's mind. */
1081: if (LCP_PEER_REJECTED(lcp, opt->type)) {
1082: LCP_PEER_UNREJ(lcp, opt->type);
1083: if (Enabled(&l->conf.options, LINK_CONF_MULTILINK))
1084: lcp->want_shortseq = Enabled(&l->conf.options, LINK_CONF_SHORTSEQ);
1085: }
1086: break;
1087: case MODE_REJ:
1088: lcp->want_shortseq = FALSE;
1089: LCP_PEER_REJ(lcp, opt->type);
1090: break;
1091: }
1092: break;
1093:
1094: case TY_ENDPOINTDISC: /* multi-link endpoint discriminator */
1095: {
1096: struct discrim dis;
1097: char buf[64];
1098:
1099: if (opt->len < 3 || opt->len > sizeof(dis.bytes)) {
1100: Log(LG_LCP, ("[%s] %s bad len=%d", l->name, oi->name, opt->len));
1101: if (mode == MODE_REQ)
1102: FsmRej(fp, opt);
1103: break;
1104: }
1105: memcpy(&dis.class, opt->data, opt->len - 2);
1106: dis.len = opt->len - 3;
1107: Log(LG_LCP, ("[%s] %s %s", l->name, oi->name, MpDiscrimText(&dis, buf, sizeof(buf))));
1108: switch (mode) {
1109: case MODE_REQ:
1110: lcp->peer_discrim = dis;
1111: FsmAck(fp, opt);
1112: break;
1113: case MODE_NAK:
1114: /* Let the peer to change it's mind. */
1115: LCP_PEER_UNREJ(lcp, opt->type);
1116: break;
1117: case MODE_REJ:
1118: LCP_PEER_REJ(lcp, opt->type);
1119: break;
1120: }
1121: }
1122: break;
1123:
1124: case TY_MAGICNUM: /* magic number */
1125: {
1126: u_int32_t magic;
1127:
1128: memcpy(&magic, opt->data, 4);
1129: magic = ntohl(magic);
1130: Log(LG_LCP, ("[%s] %s %08x", l->name, oi->name, magic));
1131: switch (mode) {
1132: case MODE_REQ:
1133: if (lcp->want_magic) {
1134: if (magic == lcp->want_magic) {
1135: Log(LG_LCP, ("[%s] Same magic! Detected loopback condition", l->name));
1136: magic = htonl(~magic);
1137: memcpy(opt->data, &magic, 4);
1138: FsmNak(fp, opt);
1139: break;
1140: }
1141: lcp->peer_magic = magic;
1142: FsmAck(fp, opt);
1143: break;
1144: }
1145: FsmRej(fp, opt);
1146: break;
1147: case MODE_NAK:
1148: lcp->want_magic = GenerateMagic();
1149: break;
1150: case MODE_REJ:
1151: lcp->want_magic = 0;
1152: LCP_PEER_REJ(lcp, opt->type);
1153: break;
1154: }
1155: }
1156: break;
1157:
1158: case TY_PROTOCOMP: /* Protocol field compression */
1159: Log(LG_LCP, ("[%s] %s", l->name, oi->name));
1160: switch (mode) {
1161: case MODE_REQ:
1162: if (Acceptable(&l->conf.options, LINK_CONF_PROTOCOMP)) {
1163: lcp->peer_protocomp = TRUE;
1164: FsmAck(fp, opt);
1165: break;
1166: }
1167: FsmRej(fp, opt);
1168: break;
1169: case MODE_NAK: /* a NAK here doesn't make sense */
1170: case MODE_REJ:
1171: lcp->want_protocomp = FALSE;
1172: LCP_PEER_REJ(lcp, opt->type);
1173: break;
1174: }
1175: break;
1176:
1177: case TY_ACFCOMP: /* Address field compression */
1178: Log(LG_LCP, ("[%s] %s", l->name, oi->name));
1179: switch (mode) {
1180: case MODE_REQ:
1181: if (Acceptable(&l->conf.options, LINK_CONF_ACFCOMP)) {
1182: lcp->peer_acfcomp = TRUE;
1183: FsmAck(fp, opt);
1184: break;
1185: }
1186: FsmRej(fp, opt);
1187: break;
1188: case MODE_NAK: /* a NAK here doesn't make sense */
1189: case MODE_REJ:
1190: lcp->want_acfcomp = FALSE;
1191: LCP_PEER_REJ(lcp, opt->type);
1192: break;
1193: }
1194: break;
1195:
1196: case TY_CALLBACK: /* Callback */
1197: Log(LG_LCP, ("[%s] %s %d", l->name, oi->name, opt->data[0]));
1198: switch (mode) {
1199: case MODE_REQ: /* we only support peer calling us back */
1200: FsmRej(fp, opt);
1201: break;
1202: case MODE_NAK: /* we only know one way to do it */
1203: /* fall through */
1204: case MODE_REJ:
1205: lcp->want_callback = FALSE;
1206: LCP_PEER_REJ(lcp, opt->type);
1207: break;
1208: }
1209: break;
1210:
1211: case TY_VENDOR:
1212: {
1213: Log(LG_LCP, ("[%s] %s %02x%02x%02x:%d", l->name, oi->name,
1214: opt->data[0], opt->data[1], opt->data[2], opt->data[3]));
1215: switch (mode) {
1216: case MODE_REQ:
1217: FsmRej(fp, opt);
1218: break;
1219: case MODE_NAK:
1220: /* fall through */
1221: case MODE_REJ:
1222: LCP_PEER_REJ(lcp, opt->type);
1223: break;
1224: }
1225: break;
1226: }
1227: break;
1228:
1229: default:
1230: assert(0);
1231: }
1232: }
1233: }
1234:
1235: /*
1236: * LcpInput()
1237: */
1238:
1239: void
1240: LcpInput(Link l, Mbuf bp)
1241: {
1242: FsmInput(&l->lcp.fsm, bp);
1243: }
1244:
1245: static const struct fsmoption *
1246: LcpAuthProtoNak(ushort proto, u_char alg)
1247: {
1248: static const u_char chapmd5cf[] =
1249: { PROTO_CHAP >> 8, PROTO_CHAP & 0xff, CHAP_ALG_MD5 };
1250: static const struct fsmoption chapmd5Nak =
1251: { TY_AUTHPROTO, 2 + sizeof(chapmd5cf), (u_char *) chapmd5cf };
1252:
1253: static const u_char chapmsv1cf[] =
1254: { PROTO_CHAP >> 8, PROTO_CHAP & 0xff, CHAP_ALG_MSOFT };
1255: static const struct fsmoption chapmsv1Nak =
1256: { TY_AUTHPROTO, 2 + sizeof(chapmsv1cf), (u_char *) chapmsv1cf };
1257:
1258: static const u_char chapmsv2cf[] =
1259: { PROTO_CHAP >> 8, PROTO_CHAP & 0xff, CHAP_ALG_MSOFTv2 };
1260: static const struct fsmoption chapmsv2Nak =
1261: { TY_AUTHPROTO, 2 + sizeof(chapmsv2cf), (u_char *) chapmsv2cf };
1262:
1263: static const u_char papcf[] =
1264: { PROTO_PAP >> 8, PROTO_PAP & 0xff };
1265: static const struct fsmoption papNak =
1266: { TY_AUTHPROTO, 2 + sizeof(papcf), (u_char *) papcf };
1267:
1268: static const u_char eapcf[] =
1269: { PROTO_EAP >> 8, PROTO_EAP & 0xff };
1270: static const struct fsmoption eapNak =
1271: { TY_AUTHPROTO, 2 + sizeof(eapcf), (u_char *) eapcf };
1272:
1273: if (proto == PROTO_PAP) {
1274: return &papNak;
1275: } else if (proto == PROTO_EAP) {
1276: return &eapNak;
1277: } else {
1278: switch (alg) {
1279: case CHAP_ALG_MSOFTv2:
1280: return &chapmsv2Nak;
1281:
1282: case CHAP_ALG_MSOFT:
1283: return &chapmsv1Nak;
1284:
1285: case CHAP_ALG_MD5:
1286: return &chapmd5Nak;
1287:
1288: default:
1289: return NULL;
1290: }
1291: }
1292:
1293: }
1294:
1295: /*
1296: * LcpFindAuthProto()
1297: *
1298: */
1299: static short
1300: LcpFindAuthProto(ushort proto, u_char alg)
1301: {
1302: int i;
1303:
1304: for(i = 0; i < LCP_NUM_AUTH_PROTOS; i++) {
1305: if (gLcpAuthProtos[i].proto == proto && gLcpAuthProtos[i].alg == alg) {
1306: return i;
1307: }
1308: }
1309:
1310: return -1;
1311:
1312: }