1/*
2 * PPP Link Control Protocol (LCP) Module
3 *
4 * Written by Toshiharu OHNO (tony-o@iij.ad.jp)
5 *
6 * Copyright (C) 1993, Internet Initiative Japan, Inc. All rights reserverd.
7 *
8 * Redistribution and use in source and binary forms are permitted
9 * provided that the above copyright notice and this paragraph are
10 * duplicated in all such forms and that any documentation,
11 * advertising materials, and other materials related to such
12 * distribution and use acknowledge that the software was developed
13 * by the Internet Initiative Japan, Inc. The name of the
14 * IIJ may not be used to endorse or promote products derived
15 * from this software without specific prior written permission.
16 * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
17 * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
18 * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
19 *
20 * $FreeBSD: head/usr.sbin/ppp/lcp.c 55146 1999-12-27 11:54:57Z brian $
21 *
22 */
23
24#include <sys/param.h>
25#include <netinet/in.h>
26#include <netinet/in_systm.h>
27#include <netinet/ip.h>
28#include <sys/un.h>
29
30#include <signal.h>
31#include <stdio.h>
32#include <stdlib.h>
33#include <string.h>
34#include <termios.h>
35#include <unistd.h>
36
37#include "layer.h"
38#include "ua.h"
39#include "defs.h"
40#include "command.h"
41#include "mbuf.h"
42#include "log.h"
43#include "timer.h"
44#include "fsm.h"
45#include "iplist.h"
46#include "lcp.h"
47#include "throughput.h"
48#include "proto.h"
49#include "descriptor.h"
50#include "lqr.h"
51#include "hdlc.h"
52#include "ccp.h"
53#include "async.h"
54#include "link.h"
55#include "physical.h"
56#include "prompt.h"
57#include "slcompress.h"
58#include "ipcp.h"
59#include "filter.h"
60#include "mp.h"
61#include "chat.h"
62#include "auth.h"
63#include "chap.h"
64#include "cbcp.h"
65#include "datalink.h"
66#ifndef NORADIUS
67#include "radius.h"
68#endif
69#include "bundle.h"
70
71/* for received LQRs */
72struct lqrreq {
73 u_char type;
74 u_char length;
75 u_short proto; /* Quality protocol */
76 u_int32_t period; /* Reporting interval */
77};
78
79static int LcpLayerUp(struct fsm *);
80static void LcpLayerDown(struct fsm *);
81static void LcpLayerStart(struct fsm *);
82static void LcpLayerFinish(struct fsm *);
83static void LcpInitRestartCounter(struct fsm *, int);
84static void LcpSendConfigReq(struct fsm *);
85static void LcpSentTerminateReq(struct fsm *);
86static void LcpSendTerminateAck(struct fsm *, u_char);
87static void LcpDecodeConfig(struct fsm *, u_char *, int, int,
88 struct fsm_decode *);
89
90static struct fsm_callbacks lcp_Callbacks = {
91 LcpLayerUp,
92 LcpLayerDown,
93 LcpLayerStart,
94 LcpLayerFinish,
95 LcpInitRestartCounter,
96 LcpSendConfigReq,
97 LcpSentTerminateReq,
98 LcpSendTerminateAck,
99 LcpDecodeConfig,
100 fsm_NullRecvResetReq,
101 fsm_NullRecvResetAck
102};
103
104static const char * const lcp_TimerNames[] =
105 {"LCP restart", "LCP openmode", "LCP stopped"};
106
107static const char * const cftypes[] = {
108 /* Check out the latest ``Assigned numbers'' rfc (rfc1700.txt) */
109 "???",
110 "MRU", /* 1: Maximum-Receive-Unit */
111 "ACCMAP", /* 2: Async-Control-Character-Map */
112 "AUTHPROTO", /* 3: Authentication-Protocol */
113 "QUALPROTO", /* 4: Quality-Protocol */
114 "MAGICNUM", /* 5: Magic-Number */
115 "RESERVED", /* 6: RESERVED */
116 "PROTOCOMP", /* 7: Protocol-Field-Compression */
117 "ACFCOMP", /* 8: Address-and-Control-Field-Compression */
118 "FCSALT", /* 9: FCS-Alternatives */
119 "SDP", /* 10: Self-Describing-Pad */
120 "NUMMODE", /* 11: Numbered-Mode */
121 "MULTIPROC", /* 12: Multi-Link-Procedure */
122 "CALLBACK", /* 13: Callback */
123 "CONTIME", /* 14: Connect-Time */
124 "COMPFRAME", /* 15: Compound-Frames */
125 "NDE", /* 16: Nominal-Data-Encapsulation */
126 "MRRU", /* 17: Multilink-MRRU */
127 "SHORTSEQ", /* 18: Multilink-Short-Sequence-Number-Header */
128 "ENDDISC", /* 19: Multilink-Endpoint-Discriminator */
129 "PROPRIETRY", /* 20: Proprietary */
130 "DCEID", /* 21: DCE-Identifier */
131 "MULTIPP", /* 22: Multi-Link-Plus-Procedure */
132 "LDBACP", /* 23: Link Discriminator for BACP */
133};
134
135#define NCFTYPES (sizeof cftypes/sizeof cftypes[0])
136
137int
138lcp_ReportStatus(struct cmdargs const *arg)
139{
140 struct link *l;
141 struct lcp *lcp;
142
143 l = command_ChooseLink(arg);
144 lcp = &l->lcp;
145
146 prompt_Printf(arg->prompt, "%s: %s [%s]\n", l->name, lcp->fsm.name,
147 State2Nam(lcp->fsm.state));
148 prompt_Printf(arg->prompt,
149 " his side: MRU %d, ACCMAP %08lx, PROTOCOMP %s, ACFCOMP %s,\n"
150 " MAGIC %08lx, MRRU %u, SHORTSEQ %s, REJECT %04x\n",
151 lcp->his_mru, (u_long)lcp->his_accmap,
152 lcp->his_protocomp ? "on" : "off",
153 lcp->his_acfcomp ? "on" : "off",
154 (u_long)lcp->his_magic, lcp->his_mrru,
155 lcp->his_shortseq ? "on" : "off", lcp->his_reject);
156 prompt_Printf(arg->prompt,
157 " my side: MRU %d, ACCMAP %08lx, PROTOCOMP %s, ACFCOMP %s,\n"
158 " MAGIC %08lx, MRRU %u, SHORTSEQ %s, REJECT %04x\n",
159 lcp->want_mru, (u_long)lcp->want_accmap,
160 lcp->want_protocomp ? "on" : "off",
161 lcp->want_acfcomp ? "on" : "off",
162 (u_long)lcp->want_magic, lcp->want_mrru,
163 lcp->want_shortseq ? "on" : "off", lcp->my_reject);
164
165 prompt_Printf(arg->prompt, "\n Defaults: MRU = %d, ", lcp->cfg.mru);
166 prompt_Printf(arg->prompt, "ACCMAP = %08lx\n", (u_long)lcp->cfg.accmap);
167 prompt_Printf(arg->prompt, " LQR period = %us, ",
168 lcp->cfg.lqrperiod);
169 prompt_Printf(arg->prompt, "Open Mode = %s",
170 lcp->cfg.openmode == OPEN_PASSIVE ? "passive" : "active");
171 if (lcp->cfg.openmode > 0)
172 prompt_Printf(arg->prompt, " (delay %ds)", lcp->cfg.openmode);
173 prompt_Printf(arg->prompt, "\n FSM retry = %us, max %u Config"
174 " REQ%s, %u Term REQ%s\n", lcp->cfg.fsm.timeout,
175 lcp->cfg.fsm.maxreq, lcp->cfg.fsm.maxreq == 1 ? "" : "s",
176 lcp->cfg.fsm.maxtrm, lcp->cfg.fsm.maxtrm == 1 ? "" : "s");
177 prompt_Printf(arg->prompt, "\n Negotiation:\n");
178 prompt_Printf(arg->prompt, " ACFCOMP = %s\n",
179 command_ShowNegval(lcp->cfg.acfcomp));
180 prompt_Printf(arg->prompt, " CHAP = %s\n",
181 command_ShowNegval(lcp->cfg.chap05));
182#ifdef HAVE_DES
183 prompt_Printf(arg->prompt, " MSCHAP = %s\n",
184 command_ShowNegval(lcp->cfg.chap80nt));
185 prompt_Printf(arg->prompt, " LANMan = %s\n",
186 command_ShowNegval(lcp->cfg.chap80lm));
187#endif
188 prompt_Printf(arg->prompt, " LQR = %s\n",
189 command_ShowNegval(lcp->cfg.lqr));
190 prompt_Printf(arg->prompt, " PAP = %s\n",
191 command_ShowNegval(lcp->cfg.pap));
192 prompt_Printf(arg->prompt, " PROTOCOMP = %s\n",
193 command_ShowNegval(lcp->cfg.protocomp));
194
195 return 0;
196}
197
198static u_int32_t
199GenerateMagic(void)
200{
201 /* Generate random number which will be used as magic number */
202 randinit();
203 return random();
204}
205
206void
207lcp_SetupCallbacks(struct lcp *lcp)
208{
209 lcp->fsm.fn = &lcp_Callbacks;
210 lcp->fsm.FsmTimer.name = lcp_TimerNames[0];
211 lcp->fsm.OpenTimer.name = lcp_TimerNames[1];
212 lcp->fsm.StoppedTimer.name = lcp_TimerNames[2];
213}
214
215void
216lcp_Init(struct lcp *lcp, struct bundle *bundle, struct link *l,
217 const struct fsm_parent *parent)
218{
219 /* Initialise ourselves */
220 int mincode = parent ? 1 : LCP_MINMPCODE;
221
222 fsm_Init(&lcp->fsm, "LCP", PROTO_LCP, mincode, LCP_MAXCODE, LogLCP,
223 bundle, l, parent, &lcp_Callbacks, lcp_TimerNames);
224
225 lcp->cfg.mru = DEF_MRU;
226 lcp->cfg.accmap = 0;
227 lcp->cfg.openmode = 1;
228 lcp->cfg.lqrperiod = DEF_LQRPERIOD;
229 lcp->cfg.fsm.timeout = DEF_FSMRETRY;
230 lcp->cfg.fsm.maxreq = DEF_FSMTRIES;
231 lcp->cfg.fsm.maxtrm = DEF_FSMTRIES;
232
233 lcp->cfg.acfcomp = NEG_ENABLED|NEG_ACCEPTED;
234 lcp->cfg.chap05 = NEG_ACCEPTED;
235#ifdef HAVE_DES
236 lcp->cfg.chap80nt = NEG_ACCEPTED;
237 lcp->cfg.chap80lm = NEG_ACCEPTED;
238#endif
239 lcp->cfg.lqr = NEG_ACCEPTED;
240 lcp->cfg.pap = NEG_ACCEPTED;
241 lcp->cfg.protocomp = NEG_ENABLED|NEG_ACCEPTED;
242
243 lcp_Setup(lcp, lcp->cfg.openmode);
244}
245
246void
247lcp_Setup(struct lcp *lcp, int openmode)
248{
249 lcp->fsm.open_mode = openmode;
250
251 lcp->his_mru = lcp->fsm.bundle->cfg.mtu;
252 if (!lcp->his_mru || lcp->his_mru > DEF_MRU)
253 lcp->his_mru = DEF_MRU;
254 lcp->his_mrru = 0;
255 lcp->his_magic = 0;
256 lcp->his_lqrperiod = 0;
257 lcp->his_acfcomp = 0;
258 lcp->his_auth = 0;
259 lcp->his_authtype = 0;
260 lcp->his_callback.opmask = 0;
261 lcp->his_shortseq = 0;
262
263 lcp->want_mru = lcp->cfg.mru;
264 lcp->want_mrru = lcp->fsm.bundle->ncp.mp.cfg.mrru;
265 lcp->want_shortseq = IsEnabled(lcp->fsm.bundle->ncp.mp.cfg.shortseq) ? 1 : 0;
266 lcp->want_acfcomp = IsEnabled(lcp->cfg.acfcomp) ? 1 : 0;
267
268 if (lcp->fsm.parent) {
269 struct physical *p = link2physical(lcp->fsm.link);
270
271 lcp->his_accmap = 0xffffffff;
272 lcp->want_accmap = lcp->cfg.accmap;
273 lcp->his_protocomp = 0;
274 lcp->want_protocomp = IsEnabled(lcp->cfg.protocomp) ? 1 : 0;
275 lcp->want_magic = GenerateMagic();
276
277 if (IsEnabled(lcp->cfg.chap05)) {
278 lcp->want_auth = PROTO_CHAP;
279 lcp->want_authtype = 0x05;
280#ifdef HAVE_DES
281 } else if (IsEnabled(lcp->cfg.chap80nt) ||
282 IsEnabled(lcp->cfg.chap80lm)) {
283 lcp->want_auth = PROTO_CHAP;
284 lcp->want_authtype = 0x80;
285#endif
286 } else if (IsEnabled(lcp->cfg.pap)) {
287 lcp->want_auth = PROTO_PAP;
288 lcp->want_authtype = 0;
289 } else {
290 lcp->want_auth = 0;
291 lcp->want_authtype = 0;
292 }
293
294 if (p->type != PHYS_DIRECT)
295 memcpy(&lcp->want_callback, &p->dl->cfg.callback, sizeof(struct callback));
296 else
297 lcp->want_callback.opmask = 0;
298 lcp->want_lqrperiod = IsEnabled(lcp->cfg.lqr) ?
299 lcp->cfg.lqrperiod * 100 : 0;
300 } else {
301 lcp->his_accmap = lcp->want_accmap = 0;
302 lcp->his_protocomp = lcp->want_protocomp = 1;
303 lcp->want_magic = 0;
304 lcp->want_auth = 0;
305 lcp->want_authtype = 0;
306 lcp->want_callback.opmask = 0;
307 lcp->want_lqrperiod = 0;
308 }
309
310 lcp->his_reject = lcp->my_reject = 0;
311 lcp->auth_iwait = lcp->auth_ineed = 0;
312 lcp->LcpFailedMagic = 0;
313}
314
315static void
316LcpInitRestartCounter(struct fsm *fp, int what)
317{
318 /* Set fsm timer load */
319 struct lcp *lcp = fsm2lcp(fp);
320
321 fp->FsmTimer.load = lcp->cfg.fsm.timeout * SECTICKS;
322 switch (what) {
323 case FSM_REQ_TIMER:
324 fp->restart = lcp->cfg.fsm.maxreq;
325 break;
326 case FSM_TRM_TIMER:
327 fp->restart = lcp->cfg.fsm.maxtrm;
328 break;
329 default:
330 fp->restart = 1;
331 break;
332 }
333}
334
335static void
336LcpSendConfigReq(struct fsm *fp)
337{
338 /* Send config REQ please */
339 struct physical *p = link2physical(fp->link);
340 struct lcp *lcp = fsm2lcp(fp);
341 u_char buff[200];
342 struct lcp_opt *o;
343 struct mp *mp;
344 u_int16_t proto;
345
346 if (!p) {
347 log_Printf(LogERROR, "%s: LcpSendConfigReq: Not a physical link !\n",
348 fp->link->name);
349 return;
350 }
351
352 o = (struct lcp_opt *)buff;
353 if (!physical_IsSync(p)) {
354 if (lcp->want_acfcomp && !REJECTED(lcp, TY_ACFCOMP))
355 INC_LCP_OPT(TY_ACFCOMP, 2, o);
356
357 if (lcp->want_protocomp && !REJECTED(lcp, TY_PROTOCOMP))
358 INC_LCP_OPT(TY_PROTOCOMP, 2, o);
359
360 if (!REJECTED(lcp, TY_ACCMAP)) {
361 ua_htonl(&lcp->want_accmap, o->data);
362 INC_LCP_OPT(TY_ACCMAP, 6, o);
363 }
364 }
365
366 if (!REJECTED(lcp, TY_MRU)) {
367 ua_htons(&lcp->want_mru, o->data);
368 INC_LCP_OPT(TY_MRU, 4, o);
369 }
370
371 if (lcp->want_magic && !REJECTED(lcp, TY_MAGICNUM)) {
372 ua_htonl(&lcp->want_magic, o->data);
373 INC_LCP_OPT(TY_MAGICNUM, 6, o);
374 }
375
376 if (lcp->want_lqrperiod && !REJECTED(lcp, TY_QUALPROTO)) {
377 proto = PROTO_LQR;
378 ua_htons(&proto, o->data);
379 ua_htonl(&lcp->want_lqrperiod, o->data + 2);
380 INC_LCP_OPT(TY_QUALPROTO, 8, o);
381 }
382
383 switch (lcp->want_auth) {
384 case PROTO_PAP:
385 proto = PROTO_PAP;
386 ua_htons(&proto, o->data);
387 INC_LCP_OPT(TY_AUTHPROTO, 4, o);
388 break;
389
390 case PROTO_CHAP:
391 proto = PROTO_CHAP;
392 ua_htons(&proto, o->data);
393 o->data[2] = lcp->want_authtype;
394 INC_LCP_OPT(TY_AUTHPROTO, 5, o);
395 break;
396 }
397
398 if (!REJECTED(lcp, TY_CALLBACK)) {
399 if (lcp->want_callback.opmask & CALLBACK_BIT(CALLBACK_AUTH)) {
400 *o->data = CALLBACK_AUTH;
401 INC_LCP_OPT(TY_CALLBACK, 3, o);
402 } else if (lcp->want_callback.opmask & CALLBACK_BIT(CALLBACK_CBCP)) {
403 *o->data = CALLBACK_CBCP;
404 INC_LCP_OPT(TY_CALLBACK, 3, o);
405 } else if (lcp->want_callback.opmask & CALLBACK_BIT(CALLBACK_E164)) {
406 int sz = strlen(lcp->want_callback.msg);
407
408 if (sz > sizeof o->data - 1) {
409 sz = sizeof o->data - 1;
410 log_Printf(LogWARN, "Truncating E164 data to %d octets (oops!)\n", sz);
411 }
412 *o->data = CALLBACK_E164;
413 memcpy(o->data + 1, lcp->want_callback.msg, sz);
414 INC_LCP_OPT(TY_CALLBACK, sz + 3, o);
415 }
416 }
417
418 if (lcp->want_mrru && !REJECTED(lcp, TY_MRRU)) {
419 ua_htons(&lcp->want_mrru, o->data);
420 INC_LCP_OPT(TY_MRRU, 4, o);
421
422 if (lcp->want_shortseq && !REJECTED(lcp, TY_SHORTSEQ))
423 INC_LCP_OPT(TY_SHORTSEQ, 2, o);
424 }
425
426 mp = &lcp->fsm.bundle->ncp.mp;
427 if (mp->cfg.enddisc.class != 0 && IsEnabled(mp->cfg.negenddisc) &&
428 !REJECTED(lcp, TY_ENDDISC)) {
429 *o->data = mp->cfg.enddisc.class;
430 memcpy(o->data+1, mp->cfg.enddisc.address, mp->cfg.enddisc.len);
431 INC_LCP_OPT(TY_ENDDISC, mp->cfg.enddisc.len + 3, o);
432 }
433
434 fsm_Output(fp, CODE_CONFIGREQ, fp->reqid, buff, (u_char *)o - buff,
435 MB_LCPOUT);
436}
437
438void
439lcp_SendProtoRej(struct lcp *lcp, u_char *option, int count)
440{
441 /* Don't understand `option' */
442 fsm_Output(&lcp->fsm, CODE_PROTOREJ, lcp->fsm.reqid, option, count,
443 MB_LCPOUT);
444}
445
446static void
447LcpSentTerminateReq(struct fsm *fp)
448{
449 /* Term REQ just sent by FSM */
450}
451
452static void
453LcpSendTerminateAck(struct fsm *fp, u_char id)
454{
455 /* Send Term ACK please */
456 struct physical *p = link2physical(fp->link);
457
458 if (p && p->dl->state == DATALINK_CBCP)
459 cbcp_ReceiveTerminateReq(p);
460
461 fsm_Output(fp, CODE_TERMACK, id, NULL, 0, MB_LCPOUT);
462}
463
464static void
465LcpLayerStart(struct fsm *fp)
466{
467 /* We're about to start up ! */
468 struct lcp *lcp = fsm2lcp(fp);
469
470 log_Printf(LogLCP, "%s: LayerStart\n", fp->link->name);
471 lcp->LcpFailedMagic = 0;
472 fp->more.reqs = fp->more.naks = fp->more.rejs = lcp->cfg.fsm.maxreq * 3;
473}
474
475static void
476LcpLayerFinish(struct fsm *fp)
477{
478 /* We're now down */
479 log_Printf(LogLCP, "%s: LayerFinish\n", fp->link->name);
480}
481
482static int
483LcpLayerUp(struct fsm *fp)
484{
485 /* We're now up */
486 struct physical *p = link2physical(fp->link);
487 struct lcp *lcp = fsm2lcp(fp);
488
489 log_Printf(LogLCP, "%s: LayerUp\n", fp->link->name);
490 async_SetLinkParams(&p->async, lcp);
491 lqr_Start(lcp);
492 hdlc_StartTimer(&p->hdlc);
493 fp->more.reqs = fp->more.naks = fp->more.rejs = lcp->cfg.fsm.maxreq * 3;
494
495 return 1;
496}
497
498static void
499LcpLayerDown(struct fsm *fp)
500{
501 /* About to come down */
502 struct physical *p = link2physical(fp->link);
503
504 log_Printf(LogLCP, "%s: LayerDown\n", fp->link->name);
505 hdlc_StopTimer(&p->hdlc);
506 lqr_StopTimer(p);
507 lcp_Setup(fsm2lcp(fp), 0);
508}
509
510static int
511E164ok(struct callback *cb, char *req, int sz)
512{
513 char list[sizeof cb->msg], *next;
514 int len;
515
516 if (!strcmp(cb->msg, "*"))
517 return 1;
518
519 strncpy(list, cb->msg, sizeof list - 1);
520 list[sizeof list - 1] = '\0';
521 for (next = strtok(list, ","); next; next = strtok(NULL, ",")) {
522 len = strlen(next);
523 if (sz == len && !memcmp(list, req, sz))
524 return 1;
525 }
526 return 0;
527}
528
529static void
530LcpDecodeConfig(struct fsm *fp, u_char *cp, int plen, int mode_type,
531 struct fsm_decode *dec)
532{
533 /* Deal with incoming PROTO_LCP */
534 struct lcp *lcp = fsm2lcp(fp);
535 int type, length, sz, pos, op, callback_req;
536 u_int32_t magic, accmap;
537 u_short mtu, mru, proto;
538 struct lqrreq *req;
539 char request[20], desc[22];
540 struct mp *mp;
541 struct physical *p = link2physical(fp->link);
542
543 sz = op = callback_req = 0;
544
545 while (plen >= sizeof(struct fsmconfig)) {
546 type = *cp;
547 length = cp[1];
548
549 if (type < 0 || type >= NCFTYPES)
550 snprintf(request, sizeof request, " <%d>[%d]", type, length);
551 else
552 snprintf(request, sizeof request, " %s[%d]", cftypes[type], length);
553
554 if (length < 2) {
555 log_Printf(LogLCP, "%s:%s: Bad LCP length\n", fp->link->name, request);
556 break;
557 }
558
559 switch (type) {
560 case TY_MRRU:
561 mp = &lcp->fsm.bundle->ncp.mp;
562 ua_ntohs(cp + 2, &mru);
563 log_Printf(LogLCP, "%s %u\n", request, mru);
564
565 switch (mode_type) {
566 case MODE_REQ:
567 if (mp->cfg.mrru) {
568 if (REJECTED(lcp, TY_MRRU))
569 /* Ignore his previous reject so that we REQ next time */
570 lcp->his_reject &= ~(1 << type);
571
572 mtu = lcp->fsm.bundle->cfg.mtu;
573 if (mru < MIN_MRU || mru < mtu) {
574 /* Push him up to MTU or MIN_MRU */
575 lcp->his_mrru = mru < mtu ? mtu : MIN_MRU;
576 memcpy(dec->nakend, cp, 2);
577 ua_htons(&lcp->his_mrru, dec->nakend + 2);
578 dec->nakend += 4;
579 } else {
580 lcp->his_mrru = mtu ? mtu : mru;
581 memcpy(dec->ackend, cp, 4);
582 dec->ackend += 4;
583 }
584 break;
585 } else
586 goto reqreject;
587 break;
588 case MODE_NAK:
589 if (mp->cfg.mrru) {
590 if (REJECTED(lcp, TY_MRRU))
591 /* Must have changed his mind ! */
592 lcp->his_reject &= ~(1 << type);
593
594 if (mru > MAX_MRU)
595 lcp->want_mrru = MAX_MRU;
596 else if (mru < MIN_MRU)
597 lcp->want_mrru = MIN_MRU;
598 else
599 lcp->want_mrru = mru;
600 }
601 /* else we honour our config and don't send the suggested REQ */
602 break;
603 case MODE_REJ:
604 lcp->his_reject |= (1 << type);
605 lcp->want_mrru = 0; /* Ah well, no multilink :-( */
606 break;
607 }
608 break;
609
610 case TY_MRU:
611 ua_ntohs(cp + 2, &mru);
612 log_Printf(LogLCP, "%s %d\n", request, mru);
613
614 switch (mode_type) {
615 case MODE_REQ:
616 mtu = lcp->fsm.bundle->cfg.mtu;
617 if (mru < MIN_MRU || (!lcp->want_mrru && mru < mtu)) {
618 /* Push him up to MTU or MIN_MRU */
619 lcp->his_mru = mru < mtu ? mtu : MIN_MRU;
620 memcpy(dec->nakend, cp, 2);
621 ua_htons(&lcp->his_mru, dec->nakend + 2);
622 dec->nakend += 4;
623 } else {
624 lcp->his_mru = mtu ? mtu : mru;
625 memcpy(dec->ackend, cp, 4);
626 dec->ackend += 4;
627 }
628 break;
629 case MODE_NAK:
630 if (mru > MAX_MRU)
631 lcp->want_mru = MAX_MRU;
632 else if (mru < MIN_MRU)
633 lcp->want_mru = MIN_MRU;
634 else
635 lcp->want_mru = mru;
636 break;
637 case MODE_REJ:
638 lcp->his_reject |= (1 << type);
639 break;
640 }
641 break;
642
643 case TY_ACCMAP:
644 ua_ntohl(cp + 2, &accmap);
645 log_Printf(LogLCP, "%s 0x%08lx\n", request, (u_long)accmap);
646
647 switch (mode_type) {
648 case MODE_REQ:
649 lcp->his_accmap = accmap;
650 memcpy(dec->ackend, cp, 6);
651 dec->ackend += 6;
652 break;
653 case MODE_NAK:
654 lcp->want_accmap = accmap;
655 break;
656 case MODE_REJ:
657 lcp->his_reject |= (1 << type);
658 break;
659 }
660 break;
661
662 case TY_AUTHPROTO:
663 ua_ntohs(cp + 2, &proto);
664 log_Printf(LogLCP, "%s 0x%04x (%s)\n", request, proto,
665 Auth2Nam(proto, length > 4 ? cp[4] : 0));
666
667 switch (mode_type) {
668 case MODE_REQ:
669 switch (proto) {
670 case PROTO_PAP:
671 if (length != 4) {
672 log_Printf(LogLCP, " Bad length!\n");
673 goto reqreject;
674 }
675 if (IsAccepted(lcp->cfg.pap)) {
676 lcp->his_auth = proto;
677 lcp->his_authtype = 0;
678 memcpy(dec->ackend, cp, length);
679 dec->ackend += length;
680 } else if (IsAccepted(lcp->cfg.chap05)) {
681 *dec->nakend++ = *cp;
682 *dec->nakend++ = 5;
683 *dec->nakend++ = (unsigned char) (PROTO_CHAP >> 8);
684 *dec->nakend++ = (unsigned char) PROTO_CHAP;
685 *dec->nakend++ = 0x05;
686#ifdef HAVE_DES
687 } else if (IsAccepted(lcp->cfg.chap80nt) ||
688 IsAccepted(lcp->cfg.chap80lm)) {
689 *dec->nakend++ = *cp;
690 *dec->nakend++ = 5;
691 *dec->nakend++ = (unsigned char) (PROTO_CHAP >> 8);
692 *dec->nakend++ = (unsigned char) PROTO_CHAP;
693 *dec->nakend++ = 0x80;
694#endif
695 } else
696 goto reqreject;
697 break;
698
699 case PROTO_CHAP:
700 if (length != 5) {
701 log_Printf(LogLCP, " Bad length!\n");
702 goto reqreject;
703 }
704 if ((cp[4] == 0x05 && IsAccepted(lcp->cfg.chap05))
705#ifdef HAVE_DES
706 || (cp[4] == 0x80 && (IsAccepted(lcp->cfg.chap80nt) ||
707 (IsAccepted(lcp->cfg.chap80lm))))
708#endif
709 ) {
710 lcp->his_auth = proto;
711 lcp->his_authtype = cp[4];
712 memcpy(dec->ackend, cp, length);
713 dec->ackend += length;
714 } else {
715#ifndef HAVE_DES
716 if (cp[4] == 0x80)
717 log_Printf(LogWARN, "CHAP 0x80 not available without DES\n");
718 else
719#endif
720 if (cp[4] != 0x05)
721 log_Printf(LogWARN, "%s not supported\n",
722 Auth2Nam(PROTO_CHAP, cp[4]));
723
724 if (IsAccepted(lcp->cfg.chap05)) {
725 *dec->nakend++ = *cp;
726 *dec->nakend++ = 5;
727 *dec->nakend++ = (unsigned char) (PROTO_CHAP >> 8);
728 *dec->nakend++ = (unsigned char) PROTO_CHAP;
729 *dec->nakend++ = 0x05;
730#ifdef HAVE_DES
731 } else if (IsAccepted(lcp->cfg.chap80nt) ||
732 IsAccepted(lcp->cfg.chap80lm)) {
733 *dec->nakend++ = *cp;
734 *dec->nakend++ = 5;
735 *dec->nakend++ = (unsigned char) (PROTO_CHAP >> 8);
736 *dec->nakend++ = (unsigned char) PROTO_CHAP;
737 *dec->nakend++ = 0x80;
738#endif
739 } else if (IsAccepted(lcp->cfg.pap)) {
740 *dec->nakend++ = *cp;
741 *dec->nakend++ = 4;
742 *dec->nakend++ = (unsigned char) (PROTO_PAP >> 8);
743 *dec->nakend++ = (unsigned char) PROTO_PAP;
744 } else
745 goto reqreject;
746 }
747 break;
748
749 default:
750 log_Printf(LogLCP, "%s 0x%04x - not recognised, NAK\n",
751 request, proto);
752 memcpy(dec->nakend, cp, length);
753 dec->nakend += length;
754 break;
755 }
756 break;
757 case MODE_NAK:
758 switch (proto) {
759 case PROTO_PAP:
760 if (IsEnabled(lcp->cfg.pap)) {
761 lcp->want_auth = PROTO_PAP;
762 lcp->want_authtype = 0;
763 } else {
764 log_Printf(LogLCP, "Peer will only send PAP (not enabled)\n");
765 lcp->his_reject |= (1 << type);
766 }
767 break;
768 case PROTO_CHAP:
769 if (cp[4] == 0x05 && IsEnabled(lcp->cfg.chap05)) {
770 lcp->want_auth = PROTO_CHAP;
771 lcp->want_authtype = 0x05;
772#ifdef HAVE_DES
773 } else if (cp[4] == 0x80 && (IsEnabled(lcp->cfg.chap80nt) ||
774 IsEnabled(lcp->cfg.chap80lm))) {
775 lcp->want_auth = PROTO_CHAP;
776 lcp->want_authtype = 0x80;
777#endif
778 } else {
779#ifndef HAVE_DES
780 if (cp[4] == 0x80)
781 log_Printf(LogLCP, "Peer will only send MSCHAP (not available"
782 " without DES)\n");
783 else
784#endif
785 log_Printf(LogLCP, "Peer will only send %s (not %s)\n",
786 Auth2Nam(PROTO_CHAP, cp[4]),
787#ifdef HAVE_DES
788 cp[4] == 0x80 ? "configured" :
789#endif
790 "supported");
791 lcp->his_reject |= (1 << type);
792 }
793 break;
794 default:
795 /* We've been NAK'd with something we don't understand :-( */
796 lcp->his_reject |= (1 << type);
797 break;
798 }
799 break;
800 case MODE_REJ:
801 lcp->his_reject |= (1 << type);
802 break;
803 }
804 break;
805
806 case TY_QUALPROTO:
807 req = (struct lqrreq *)cp;
808 log_Printf(LogLCP, "%s proto %x, interval %lums\n",
809 request, ntohs(req->proto), (u_long)ntohl(req->period) * 10);
810 switch (mode_type) {
811 case MODE_REQ:
812 if (ntohs(req->proto) != PROTO_LQR || !IsAccepted(lcp->cfg.lqr))
813 goto reqreject;
814 else {
815 lcp->his_lqrperiod = ntohl(req->period);
816 if (lcp->his_lqrperiod < MIN_LQRPERIOD * 100)
817 lcp->his_lqrperiod = MIN_LQRPERIOD * 100;
818 req->period = htonl(lcp->his_lqrperiod);
819 memcpy(dec->ackend, cp, length);
820 dec->ackend += length;
821 }
822 break;
823 case MODE_NAK:
824 break;
825 case MODE_REJ:
826 lcp->his_reject |= (1 << type);
827 break;
828 }
829 break;
830
831 case TY_MAGICNUM:
832 ua_ntohl(cp + 2, &magic);
833 log_Printf(LogLCP, "%s 0x%08lx\n", request, (u_long)magic);
834
835 switch (mode_type) {
836 case MODE_REQ:
837 if (lcp->want_magic) {
838 /* Validate magic number */
839 if (magic == lcp->want_magic) {
840 log_Printf(LogLCP, "Magic is same (%08lx) - %d times\n",
841 (u_long)magic, ++lcp->LcpFailedMagic);
842 lcp->want_magic = GenerateMagic();
843 memcpy(dec->nakend, cp, 6);
844 dec->nakend += 6;
845 ualarm(TICKUNIT * (4 + 4 * lcp->LcpFailedMagic), 0);
846 sigpause(0);
847 } else {
848 lcp->his_magic = magic;
849 memcpy(dec->ackend, cp, length);
850 dec->ackend += length;
851 lcp->LcpFailedMagic = 0;
852 }
853 } else {
854 goto reqreject;
855 }
856 break;
857 case MODE_NAK:
858 log_Printf(LogLCP, " Magic 0x%08lx is NAKed!\n", (u_long)magic);
859 lcp->want_magic = GenerateMagic();
860 break;
861 case MODE_REJ:
862 log_Printf(LogLCP, " Magic 0x%08x is REJected!\n", magic);
863 lcp->want_magic = 0;
864 lcp->his_reject |= (1 << type);
865 break;
866 }
867 break;
868
869 case TY_PROTOCOMP:
870 log_Printf(LogLCP, "%s\n", request);
871
872 switch (mode_type) {
873 case MODE_REQ:
874 if (IsAccepted(lcp->cfg.protocomp)) {
875 lcp->his_protocomp = 1;
876 memcpy(dec->ackend, cp, 2);
877 dec->ackend += 2;
878 } else {
879#ifdef OLDMST
880 /* MorningStar before v1.3 needs NAK */
881 memcpy(dec->nakend, cp, 2);
882 dec->nakend += 2;
883#else
884 goto reqreject;
885#endif
886 }
887 break;
888 case MODE_NAK:
889 case MODE_REJ:
890 lcp->want_protocomp = 0;
891 lcp->his_reject |= (1 << type);
892 break;
893 }
894 break;
895
896 case TY_ACFCOMP:
897 log_Printf(LogLCP, "%s\n", request);
898 switch (mode_type) {
899 case MODE_REQ:
900 if (IsAccepted(lcp->cfg.acfcomp)) {
901 lcp->his_acfcomp = 1;
902 memcpy(dec->ackend, cp, 2);
903 dec->ackend += 2;
904 } else {
905#ifdef OLDMST
906 /* MorningStar before v1.3 needs NAK */
907 memcpy(dec->nakend, cp, 2);
908 dec->nakend += 2;
909#else
910 goto reqreject;
911#endif
912 }
913 break;
914 case MODE_NAK:
915 case MODE_REJ:
916 lcp->want_acfcomp = 0;
917 lcp->his_reject |= (1 << type);
918 break;
919 }
920 break;
921
922 case TY_SDP:
923 log_Printf(LogLCP, "%s\n", request);
924 switch (mode_type) {
925 case MODE_REQ:
926 case MODE_NAK:
927 case MODE_REJ:
928 break;
929 }
930 break;
931
932 case TY_CALLBACK:
933 if (length == 2)
934 op = CALLBACK_NONE;
935 else
936 op = (int)cp[2];
937 sz = length - 3;
938 switch (op) {
939 case CALLBACK_AUTH:
940 log_Printf(LogLCP, "%s Auth\n", request);
941 break;
942 case CALLBACK_DIALSTRING:
943 log_Printf(LogLCP, "%s Dialstring %.*s\n", request, sz, cp + 3);
944 break;
945 case CALLBACK_LOCATION:
946 log_Printf(LogLCP, "%s Location %.*s\n", request, sz, cp + 3);
947 break;
948 case CALLBACK_E164:
949 log_Printf(LogLCP, "%s E.164 (%.*s)\n", request, sz, cp + 3);
950 break;
951 case CALLBACK_NAME:
952 log_Printf(LogLCP, "%s Name %.*s\n", request, sz, cp + 3);
953 break;
954 case CALLBACK_CBCP:
955 log_Printf(LogLCP, "%s CBCP\n", request);
956 break;
957 default:
958 log_Printf(LogLCP, "%s ???\n", request);
959 break;
960 }
961
962 switch (mode_type) {
963 case MODE_REQ:
964 callback_req = 1;
965 if (p->type != PHYS_DIRECT)
966 goto reqreject;
967 if ((p->dl->cfg.callback.opmask & CALLBACK_BIT(op)) &&
968 (op != CALLBACK_AUTH || p->link.lcp.auth_ineed) &&
969 (op != CALLBACK_E164 ||
970 E164ok(&p->dl->cfg.callback, cp + 3, sz))) {
971 lcp->his_callback.opmask = CALLBACK_BIT(op);
972 if (sz > sizeof lcp->his_callback.msg - 1) {
973 sz = sizeof lcp->his_callback.msg - 1;
974 log_Printf(LogWARN, "Truncating option arg to %d octets\n", sz);
975 }
976 memcpy(lcp->his_callback.msg, cp + 3, sz);
977 lcp->his_callback.msg[sz] = '\0';
978 memcpy(dec->ackend, cp, sz + 3);
979 dec->ackend += sz + 3;
980 } else if ((p->dl->cfg.callback.opmask & CALLBACK_BIT(CALLBACK_AUTH)) &&
981 p->link.lcp.auth_ineed) {
982 *dec->nakend++ = *cp;
983 *dec->nakend++ = 3;
984 *dec->nakend++ = CALLBACK_AUTH;
985 } else if (p->dl->cfg.callback.opmask & CALLBACK_BIT(CALLBACK_CBCP)) {
986 *dec->nakend++ = *cp;
987 *dec->nakend++ = 3;
988 *dec->nakend++ = CALLBACK_CBCP;
989 } else if (p->dl->cfg.callback.opmask & CALLBACK_BIT(CALLBACK_E164)) {
990 *dec->nakend++ = *cp;
991 *dec->nakend++ = 3;
992 *dec->nakend++ = CALLBACK_E164;
993 } else if (p->dl->cfg.callback.opmask & CALLBACK_BIT(CALLBACK_AUTH)) {
994 log_Printf(LogWARN, "Cannot insist on auth callback without"
995 " PAP or CHAP enabled !\n");
996 *dec->nakend++ = *cp;
997 *dec->nakend++ = 2;
998 } else
999 goto reqreject;
1000 break;
1001 case MODE_NAK:
1002 /* We don't do what he NAKs with, we do things in our preferred order */
1003 if (lcp->want_callback.opmask & CALLBACK_BIT(CALLBACK_AUTH))
1004 lcp->want_callback.opmask &= ~CALLBACK_BIT(CALLBACK_AUTH);
1005 else if (lcp->want_callback.opmask & CALLBACK_BIT(CALLBACK_CBCP))
1006 lcp->want_callback.opmask &= ~CALLBACK_BIT(CALLBACK_CBCP);
1007 else if (lcp->want_callback.opmask & CALLBACK_BIT(CALLBACK_E164))
1008 lcp->want_callback.opmask &= ~CALLBACK_BIT(CALLBACK_E164);
1009 if (lcp->want_callback.opmask == CALLBACK_BIT(CALLBACK_NONE)) {
1010 log_Printf(LogPHASE, "Peer NAKd all callbacks, trying none\n");
1011 lcp->want_callback.opmask = 0;
1012 } else if (!lcp->want_callback.opmask) {
1013 log_Printf(LogPHASE, "Peer NAKd last configured callback\n");
1014 fsm_Close(&lcp->fsm);
1015 }
1016 break;
1017 case MODE_REJ:
1018 if (lcp->want_callback.opmask & CALLBACK_BIT(CALLBACK_NONE)) {
1019 lcp->his_reject |= (1 << type);
1020 lcp->want_callback.opmask = 0;
1021 } else {
1022 log_Printf(LogPHASE, "Peer rejected *required* callback\n");
1023 fsm_Close(&lcp->fsm);
1024 }
1025 break;
1026 }
1027 break;
1028
1029 case TY_SHORTSEQ:
1030 mp = &lcp->fsm.bundle->ncp.mp;
1031 log_Printf(LogLCP, "%s\n", request);
1032
1033 switch (mode_type) {
1034 case MODE_REQ:
1035 if (lcp->want_mrru && IsAccepted(mp->cfg.shortseq)) {
1036 lcp->his_shortseq = 1;
1037 memcpy(dec->ackend, cp, length);
1038 dec->ackend += length;
1039 } else
1040 goto reqreject;
1041 break;
1042 case MODE_NAK:
1043 /*
1044 * He's trying to get us to ask for short sequence numbers.
1045 * We ignore the NAK and honour our configuration file instead.
1046 */
1047 break;
1048 case MODE_REJ:
1049 lcp->his_reject |= (1 << type);
1050 lcp->want_shortseq = 0; /* For when we hit MP */
1051 break;
1052 }
1053 break;
1054
1055 case TY_ENDDISC:
1056 mp = &lcp->fsm.bundle->ncp.mp;
1057 log_Printf(LogLCP, "%s %s\n", request,
1058 mp_Enddisc(cp[2], cp + 3, length - 3));
1059 switch (mode_type) {
1060 case MODE_REQ:
1061 if (!p) {
1062 log_Printf(LogLCP, " ENDDISC rejected - not a physical link\n");
1063 goto reqreject;
1064 } else if (!IsAccepted(mp->cfg.negenddisc))
1065 goto reqreject;
1066 else if (length-3 < sizeof p->dl->peer.enddisc.address &&
1067 cp[2] <= MAX_ENDDISC_CLASS) {
1068 p->dl->peer.enddisc.class = cp[2];
1069 p->dl->peer.enddisc.len = length-3;
1070 memcpy(p->dl->peer.enddisc.address, cp + 3, length - 3);
1071 p->dl->peer.enddisc.address[length - 3] = '\0';
1072 /* XXX: If mp->active, compare and NAK with mp->peer ? */
1073 memcpy(dec->ackend, cp, length);
1074 dec->ackend += length;
1075 } else {
1076 if (cp[2] > MAX_ENDDISC_CLASS)
1077 log_Printf(LogLCP, " ENDDISC rejected - unrecognised class %d\n",
1078 cp[2]);
1079 else
1080 log_Printf(LogLCP, " ENDDISC rejected - local max length is %ld\n",
1081 (long)(sizeof p->dl->peer.enddisc.address - 1));
1082 goto reqreject;
1083 }
1084 break;
1085
1086 case MODE_NAK: /* Treat this as a REJ, we don't vary our disc (yet) */
1087 case MODE_REJ:
1088 lcp->his_reject |= (1 << type);
1089 break;
1090 }
1091 break;
1092
1093 default:
1094 sz = (sizeof desc - 2) / 2;
1095 if (sz > length - 2)
1096 sz = length - 2;
1097 pos = 0;
1098 desc[0] = sz ? ' ' : '\0';
1099 for (pos = 0; sz--; pos++)
1100 sprintf(desc+(pos<<1)+1, "%02x", cp[pos+2]);
1101
1102 log_Printf(LogLCP, "%s%s\n", request, desc);
1103
1104 if (mode_type == MODE_REQ) {
1105reqreject:
1106 if (length > sizeof dec->rej - (dec->rejend - dec->rej)) {
1107 length = sizeof dec->rej - (dec->rejend - dec->rej);
1108 log_Printf(LogLCP, "Can't REJ length %d - trunating to %d\n",
1109 cp[1], length);
1110 }
1111 memcpy(dec->rejend, cp, length);
1112 dec->rejend += length;
1113 lcp->my_reject |= (1 << type);
1114 if (length != cp[1])
1115 length = 0; /* force our way out of the loop */
1116 }
1117 break;
1118 }
1119 plen -= length;
1120 cp += length;
1121 }
1122
1123 if (mode_type != MODE_NOP) {
1124 if (mode_type == MODE_REQ && p && p->type == PHYS_DIRECT &&
1125 p->dl->cfg.callback.opmask && !callback_req &&
1126 !(p->dl->cfg.callback.opmask & CALLBACK_BIT(CALLBACK_NONE))) {
1127 /* We *REQUIRE* that the peer requests callback */
1128 *dec->nakend++ = TY_CALLBACK;
1129 *dec->nakend++ = 3;
1130 if ((p->dl->cfg.callback.opmask & CALLBACK_BIT(CALLBACK_AUTH)) &&
1131 p->link.lcp.auth_ineed)
1132 *dec->nakend++ = CALLBACK_AUTH;
1133 else if (p->dl->cfg.callback.opmask & CALLBACK_BIT(CALLBACK_CBCP))
1134 *dec->nakend++ = CALLBACK_CBCP;
1135 else if (p->dl->cfg.callback.opmask & CALLBACK_BIT(CALLBACK_E164))
1136 *dec->nakend++ = CALLBACK_E164;
1137 else {
1138 log_Printf(LogWARN, "Cannot insist on auth callback without"
1139 " PAP or CHAP enabled !\n");
1140 dec->nakend[-1] = 2; /* XXX: Silly ! */
1141 }
1142 }
1143 if (dec->rejend != dec->rej) {
1144 /* rejects are preferred */
1145 dec->ackend = dec->ack;
1146 dec->nakend = dec->nak;
1147 } else if (dec->nakend != dec->nak)
1148 /* then NAKs */
1149 dec->ackend = dec->ack;
1150 }
1151}
1152
1153extern struct mbuf *
1154lcp_Input(struct bundle *bundle, struct link *l, struct mbuf *bp)
1155{
1156 /* Got PROTO_LCP from link */
1157 m_settype(bp, MB_LCPIN);
1158 fsm_Input(&l->lcp.fsm, bp);
1159 return NULL;
1160}
2 * PPP Link Control Protocol (LCP) Module
3 *
4 * Written by Toshiharu OHNO (tony-o@iij.ad.jp)
5 *
6 * Copyright (C) 1993, Internet Initiative Japan, Inc. All rights reserverd.
7 *
8 * Redistribution and use in source and binary forms are permitted
9 * provided that the above copyright notice and this paragraph are
10 * duplicated in all such forms and that any documentation,
11 * advertising materials, and other materials related to such
12 * distribution and use acknowledge that the software was developed
13 * by the Internet Initiative Japan, Inc. The name of the
14 * IIJ may not be used to endorse or promote products derived
15 * from this software without specific prior written permission.
16 * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
17 * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
18 * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
19 *
20 * $FreeBSD: head/usr.sbin/ppp/lcp.c 55146 1999-12-27 11:54:57Z brian $
21 *
22 */
23
24#include <sys/param.h>
25#include <netinet/in.h>
26#include <netinet/in_systm.h>
27#include <netinet/ip.h>
28#include <sys/un.h>
29
30#include <signal.h>
31#include <stdio.h>
32#include <stdlib.h>
33#include <string.h>
34#include <termios.h>
35#include <unistd.h>
36
37#include "layer.h"
38#include "ua.h"
39#include "defs.h"
40#include "command.h"
41#include "mbuf.h"
42#include "log.h"
43#include "timer.h"
44#include "fsm.h"
45#include "iplist.h"
46#include "lcp.h"
47#include "throughput.h"
48#include "proto.h"
49#include "descriptor.h"
50#include "lqr.h"
51#include "hdlc.h"
52#include "ccp.h"
53#include "async.h"
54#include "link.h"
55#include "physical.h"
56#include "prompt.h"
57#include "slcompress.h"
58#include "ipcp.h"
59#include "filter.h"
60#include "mp.h"
61#include "chat.h"
62#include "auth.h"
63#include "chap.h"
64#include "cbcp.h"
65#include "datalink.h"
66#ifndef NORADIUS
67#include "radius.h"
68#endif
69#include "bundle.h"
70
71/* for received LQRs */
72struct lqrreq {
73 u_char type;
74 u_char length;
75 u_short proto; /* Quality protocol */
76 u_int32_t period; /* Reporting interval */
77};
78
79static int LcpLayerUp(struct fsm *);
80static void LcpLayerDown(struct fsm *);
81static void LcpLayerStart(struct fsm *);
82static void LcpLayerFinish(struct fsm *);
83static void LcpInitRestartCounter(struct fsm *, int);
84static void LcpSendConfigReq(struct fsm *);
85static void LcpSentTerminateReq(struct fsm *);
86static void LcpSendTerminateAck(struct fsm *, u_char);
87static void LcpDecodeConfig(struct fsm *, u_char *, int, int,
88 struct fsm_decode *);
89
90static struct fsm_callbacks lcp_Callbacks = {
91 LcpLayerUp,
92 LcpLayerDown,
93 LcpLayerStart,
94 LcpLayerFinish,
95 LcpInitRestartCounter,
96 LcpSendConfigReq,
97 LcpSentTerminateReq,
98 LcpSendTerminateAck,
99 LcpDecodeConfig,
100 fsm_NullRecvResetReq,
101 fsm_NullRecvResetAck
102};
103
104static const char * const lcp_TimerNames[] =
105 {"LCP restart", "LCP openmode", "LCP stopped"};
106
107static const char * const cftypes[] = {
108 /* Check out the latest ``Assigned numbers'' rfc (rfc1700.txt) */
109 "???",
110 "MRU", /* 1: Maximum-Receive-Unit */
111 "ACCMAP", /* 2: Async-Control-Character-Map */
112 "AUTHPROTO", /* 3: Authentication-Protocol */
113 "QUALPROTO", /* 4: Quality-Protocol */
114 "MAGICNUM", /* 5: Magic-Number */
115 "RESERVED", /* 6: RESERVED */
116 "PROTOCOMP", /* 7: Protocol-Field-Compression */
117 "ACFCOMP", /* 8: Address-and-Control-Field-Compression */
118 "FCSALT", /* 9: FCS-Alternatives */
119 "SDP", /* 10: Self-Describing-Pad */
120 "NUMMODE", /* 11: Numbered-Mode */
121 "MULTIPROC", /* 12: Multi-Link-Procedure */
122 "CALLBACK", /* 13: Callback */
123 "CONTIME", /* 14: Connect-Time */
124 "COMPFRAME", /* 15: Compound-Frames */
125 "NDE", /* 16: Nominal-Data-Encapsulation */
126 "MRRU", /* 17: Multilink-MRRU */
127 "SHORTSEQ", /* 18: Multilink-Short-Sequence-Number-Header */
128 "ENDDISC", /* 19: Multilink-Endpoint-Discriminator */
129 "PROPRIETRY", /* 20: Proprietary */
130 "DCEID", /* 21: DCE-Identifier */
131 "MULTIPP", /* 22: Multi-Link-Plus-Procedure */
132 "LDBACP", /* 23: Link Discriminator for BACP */
133};
134
135#define NCFTYPES (sizeof cftypes/sizeof cftypes[0])
136
137int
138lcp_ReportStatus(struct cmdargs const *arg)
139{
140 struct link *l;
141 struct lcp *lcp;
142
143 l = command_ChooseLink(arg);
144 lcp = &l->lcp;
145
146 prompt_Printf(arg->prompt, "%s: %s [%s]\n", l->name, lcp->fsm.name,
147 State2Nam(lcp->fsm.state));
148 prompt_Printf(arg->prompt,
149 " his side: MRU %d, ACCMAP %08lx, PROTOCOMP %s, ACFCOMP %s,\n"
150 " MAGIC %08lx, MRRU %u, SHORTSEQ %s, REJECT %04x\n",
151 lcp->his_mru, (u_long)lcp->his_accmap,
152 lcp->his_protocomp ? "on" : "off",
153 lcp->his_acfcomp ? "on" : "off",
154 (u_long)lcp->his_magic, lcp->his_mrru,
155 lcp->his_shortseq ? "on" : "off", lcp->his_reject);
156 prompt_Printf(arg->prompt,
157 " my side: MRU %d, ACCMAP %08lx, PROTOCOMP %s, ACFCOMP %s,\n"
158 " MAGIC %08lx, MRRU %u, SHORTSEQ %s, REJECT %04x\n",
159 lcp->want_mru, (u_long)lcp->want_accmap,
160 lcp->want_protocomp ? "on" : "off",
161 lcp->want_acfcomp ? "on" : "off",
162 (u_long)lcp->want_magic, lcp->want_mrru,
163 lcp->want_shortseq ? "on" : "off", lcp->my_reject);
164
165 prompt_Printf(arg->prompt, "\n Defaults: MRU = %d, ", lcp->cfg.mru);
166 prompt_Printf(arg->prompt, "ACCMAP = %08lx\n", (u_long)lcp->cfg.accmap);
167 prompt_Printf(arg->prompt, " LQR period = %us, ",
168 lcp->cfg.lqrperiod);
169 prompt_Printf(arg->prompt, "Open Mode = %s",
170 lcp->cfg.openmode == OPEN_PASSIVE ? "passive" : "active");
171 if (lcp->cfg.openmode > 0)
172 prompt_Printf(arg->prompt, " (delay %ds)", lcp->cfg.openmode);
173 prompt_Printf(arg->prompt, "\n FSM retry = %us, max %u Config"
174 " REQ%s, %u Term REQ%s\n", lcp->cfg.fsm.timeout,
175 lcp->cfg.fsm.maxreq, lcp->cfg.fsm.maxreq == 1 ? "" : "s",
176 lcp->cfg.fsm.maxtrm, lcp->cfg.fsm.maxtrm == 1 ? "" : "s");
177 prompt_Printf(arg->prompt, "\n Negotiation:\n");
178 prompt_Printf(arg->prompt, " ACFCOMP = %s\n",
179 command_ShowNegval(lcp->cfg.acfcomp));
180 prompt_Printf(arg->prompt, " CHAP = %s\n",
181 command_ShowNegval(lcp->cfg.chap05));
182#ifdef HAVE_DES
183 prompt_Printf(arg->prompt, " MSCHAP = %s\n",
184 command_ShowNegval(lcp->cfg.chap80nt));
185 prompt_Printf(arg->prompt, " LANMan = %s\n",
186 command_ShowNegval(lcp->cfg.chap80lm));
187#endif
188 prompt_Printf(arg->prompt, " LQR = %s\n",
189 command_ShowNegval(lcp->cfg.lqr));
190 prompt_Printf(arg->prompt, " PAP = %s\n",
191 command_ShowNegval(lcp->cfg.pap));
192 prompt_Printf(arg->prompt, " PROTOCOMP = %s\n",
193 command_ShowNegval(lcp->cfg.protocomp));
194
195 return 0;
196}
197
198static u_int32_t
199GenerateMagic(void)
200{
201 /* Generate random number which will be used as magic number */
202 randinit();
203 return random();
204}
205
206void
207lcp_SetupCallbacks(struct lcp *lcp)
208{
209 lcp->fsm.fn = &lcp_Callbacks;
210 lcp->fsm.FsmTimer.name = lcp_TimerNames[0];
211 lcp->fsm.OpenTimer.name = lcp_TimerNames[1];
212 lcp->fsm.StoppedTimer.name = lcp_TimerNames[2];
213}
214
215void
216lcp_Init(struct lcp *lcp, struct bundle *bundle, struct link *l,
217 const struct fsm_parent *parent)
218{
219 /* Initialise ourselves */
220 int mincode = parent ? 1 : LCP_MINMPCODE;
221
222 fsm_Init(&lcp->fsm, "LCP", PROTO_LCP, mincode, LCP_MAXCODE, LogLCP,
223 bundle, l, parent, &lcp_Callbacks, lcp_TimerNames);
224
225 lcp->cfg.mru = DEF_MRU;
226 lcp->cfg.accmap = 0;
227 lcp->cfg.openmode = 1;
228 lcp->cfg.lqrperiod = DEF_LQRPERIOD;
229 lcp->cfg.fsm.timeout = DEF_FSMRETRY;
230 lcp->cfg.fsm.maxreq = DEF_FSMTRIES;
231 lcp->cfg.fsm.maxtrm = DEF_FSMTRIES;
232
233 lcp->cfg.acfcomp = NEG_ENABLED|NEG_ACCEPTED;
234 lcp->cfg.chap05 = NEG_ACCEPTED;
235#ifdef HAVE_DES
236 lcp->cfg.chap80nt = NEG_ACCEPTED;
237 lcp->cfg.chap80lm = NEG_ACCEPTED;
238#endif
239 lcp->cfg.lqr = NEG_ACCEPTED;
240 lcp->cfg.pap = NEG_ACCEPTED;
241 lcp->cfg.protocomp = NEG_ENABLED|NEG_ACCEPTED;
242
243 lcp_Setup(lcp, lcp->cfg.openmode);
244}
245
246void
247lcp_Setup(struct lcp *lcp, int openmode)
248{
249 lcp->fsm.open_mode = openmode;
250
251 lcp->his_mru = lcp->fsm.bundle->cfg.mtu;
252 if (!lcp->his_mru || lcp->his_mru > DEF_MRU)
253 lcp->his_mru = DEF_MRU;
254 lcp->his_mrru = 0;
255 lcp->his_magic = 0;
256 lcp->his_lqrperiod = 0;
257 lcp->his_acfcomp = 0;
258 lcp->his_auth = 0;
259 lcp->his_authtype = 0;
260 lcp->his_callback.opmask = 0;
261 lcp->his_shortseq = 0;
262
263 lcp->want_mru = lcp->cfg.mru;
264 lcp->want_mrru = lcp->fsm.bundle->ncp.mp.cfg.mrru;
265 lcp->want_shortseq = IsEnabled(lcp->fsm.bundle->ncp.mp.cfg.shortseq) ? 1 : 0;
266 lcp->want_acfcomp = IsEnabled(lcp->cfg.acfcomp) ? 1 : 0;
267
268 if (lcp->fsm.parent) {
269 struct physical *p = link2physical(lcp->fsm.link);
270
271 lcp->his_accmap = 0xffffffff;
272 lcp->want_accmap = lcp->cfg.accmap;
273 lcp->his_protocomp = 0;
274 lcp->want_protocomp = IsEnabled(lcp->cfg.protocomp) ? 1 : 0;
275 lcp->want_magic = GenerateMagic();
276
277 if (IsEnabled(lcp->cfg.chap05)) {
278 lcp->want_auth = PROTO_CHAP;
279 lcp->want_authtype = 0x05;
280#ifdef HAVE_DES
281 } else if (IsEnabled(lcp->cfg.chap80nt) ||
282 IsEnabled(lcp->cfg.chap80lm)) {
283 lcp->want_auth = PROTO_CHAP;
284 lcp->want_authtype = 0x80;
285#endif
286 } else if (IsEnabled(lcp->cfg.pap)) {
287 lcp->want_auth = PROTO_PAP;
288 lcp->want_authtype = 0;
289 } else {
290 lcp->want_auth = 0;
291 lcp->want_authtype = 0;
292 }
293
294 if (p->type != PHYS_DIRECT)
295 memcpy(&lcp->want_callback, &p->dl->cfg.callback, sizeof(struct callback));
296 else
297 lcp->want_callback.opmask = 0;
298 lcp->want_lqrperiod = IsEnabled(lcp->cfg.lqr) ?
299 lcp->cfg.lqrperiod * 100 : 0;
300 } else {
301 lcp->his_accmap = lcp->want_accmap = 0;
302 lcp->his_protocomp = lcp->want_protocomp = 1;
303 lcp->want_magic = 0;
304 lcp->want_auth = 0;
305 lcp->want_authtype = 0;
306 lcp->want_callback.opmask = 0;
307 lcp->want_lqrperiod = 0;
308 }
309
310 lcp->his_reject = lcp->my_reject = 0;
311 lcp->auth_iwait = lcp->auth_ineed = 0;
312 lcp->LcpFailedMagic = 0;
313}
314
315static void
316LcpInitRestartCounter(struct fsm *fp, int what)
317{
318 /* Set fsm timer load */
319 struct lcp *lcp = fsm2lcp(fp);
320
321 fp->FsmTimer.load = lcp->cfg.fsm.timeout * SECTICKS;
322 switch (what) {
323 case FSM_REQ_TIMER:
324 fp->restart = lcp->cfg.fsm.maxreq;
325 break;
326 case FSM_TRM_TIMER:
327 fp->restart = lcp->cfg.fsm.maxtrm;
328 break;
329 default:
330 fp->restart = 1;
331 break;
332 }
333}
334
335static void
336LcpSendConfigReq(struct fsm *fp)
337{
338 /* Send config REQ please */
339 struct physical *p = link2physical(fp->link);
340 struct lcp *lcp = fsm2lcp(fp);
341 u_char buff[200];
342 struct lcp_opt *o;
343 struct mp *mp;
344 u_int16_t proto;
345
346 if (!p) {
347 log_Printf(LogERROR, "%s: LcpSendConfigReq: Not a physical link !\n",
348 fp->link->name);
349 return;
350 }
351
352 o = (struct lcp_opt *)buff;
353 if (!physical_IsSync(p)) {
354 if (lcp->want_acfcomp && !REJECTED(lcp, TY_ACFCOMP))
355 INC_LCP_OPT(TY_ACFCOMP, 2, o);
356
357 if (lcp->want_protocomp && !REJECTED(lcp, TY_PROTOCOMP))
358 INC_LCP_OPT(TY_PROTOCOMP, 2, o);
359
360 if (!REJECTED(lcp, TY_ACCMAP)) {
361 ua_htonl(&lcp->want_accmap, o->data);
362 INC_LCP_OPT(TY_ACCMAP, 6, o);
363 }
364 }
365
366 if (!REJECTED(lcp, TY_MRU)) {
367 ua_htons(&lcp->want_mru, o->data);
368 INC_LCP_OPT(TY_MRU, 4, o);
369 }
370
371 if (lcp->want_magic && !REJECTED(lcp, TY_MAGICNUM)) {
372 ua_htonl(&lcp->want_magic, o->data);
373 INC_LCP_OPT(TY_MAGICNUM, 6, o);
374 }
375
376 if (lcp->want_lqrperiod && !REJECTED(lcp, TY_QUALPROTO)) {
377 proto = PROTO_LQR;
378 ua_htons(&proto, o->data);
379 ua_htonl(&lcp->want_lqrperiod, o->data + 2);
380 INC_LCP_OPT(TY_QUALPROTO, 8, o);
381 }
382
383 switch (lcp->want_auth) {
384 case PROTO_PAP:
385 proto = PROTO_PAP;
386 ua_htons(&proto, o->data);
387 INC_LCP_OPT(TY_AUTHPROTO, 4, o);
388 break;
389
390 case PROTO_CHAP:
391 proto = PROTO_CHAP;
392 ua_htons(&proto, o->data);
393 o->data[2] = lcp->want_authtype;
394 INC_LCP_OPT(TY_AUTHPROTO, 5, o);
395 break;
396 }
397
398 if (!REJECTED(lcp, TY_CALLBACK)) {
399 if (lcp->want_callback.opmask & CALLBACK_BIT(CALLBACK_AUTH)) {
400 *o->data = CALLBACK_AUTH;
401 INC_LCP_OPT(TY_CALLBACK, 3, o);
402 } else if (lcp->want_callback.opmask & CALLBACK_BIT(CALLBACK_CBCP)) {
403 *o->data = CALLBACK_CBCP;
404 INC_LCP_OPT(TY_CALLBACK, 3, o);
405 } else if (lcp->want_callback.opmask & CALLBACK_BIT(CALLBACK_E164)) {
406 int sz = strlen(lcp->want_callback.msg);
407
408 if (sz > sizeof o->data - 1) {
409 sz = sizeof o->data - 1;
410 log_Printf(LogWARN, "Truncating E164 data to %d octets (oops!)\n", sz);
411 }
412 *o->data = CALLBACK_E164;
413 memcpy(o->data + 1, lcp->want_callback.msg, sz);
414 INC_LCP_OPT(TY_CALLBACK, sz + 3, o);
415 }
416 }
417
418 if (lcp->want_mrru && !REJECTED(lcp, TY_MRRU)) {
419 ua_htons(&lcp->want_mrru, o->data);
420 INC_LCP_OPT(TY_MRRU, 4, o);
421
422 if (lcp->want_shortseq && !REJECTED(lcp, TY_SHORTSEQ))
423 INC_LCP_OPT(TY_SHORTSEQ, 2, o);
424 }
425
426 mp = &lcp->fsm.bundle->ncp.mp;
427 if (mp->cfg.enddisc.class != 0 && IsEnabled(mp->cfg.negenddisc) &&
428 !REJECTED(lcp, TY_ENDDISC)) {
429 *o->data = mp->cfg.enddisc.class;
430 memcpy(o->data+1, mp->cfg.enddisc.address, mp->cfg.enddisc.len);
431 INC_LCP_OPT(TY_ENDDISC, mp->cfg.enddisc.len + 3, o);
432 }
433
434 fsm_Output(fp, CODE_CONFIGREQ, fp->reqid, buff, (u_char *)o - buff,
435 MB_LCPOUT);
436}
437
438void
439lcp_SendProtoRej(struct lcp *lcp, u_char *option, int count)
440{
441 /* Don't understand `option' */
442 fsm_Output(&lcp->fsm, CODE_PROTOREJ, lcp->fsm.reqid, option, count,
443 MB_LCPOUT);
444}
445
446static void
447LcpSentTerminateReq(struct fsm *fp)
448{
449 /* Term REQ just sent by FSM */
450}
451
452static void
453LcpSendTerminateAck(struct fsm *fp, u_char id)
454{
455 /* Send Term ACK please */
456 struct physical *p = link2physical(fp->link);
457
458 if (p && p->dl->state == DATALINK_CBCP)
459 cbcp_ReceiveTerminateReq(p);
460
461 fsm_Output(fp, CODE_TERMACK, id, NULL, 0, MB_LCPOUT);
462}
463
464static void
465LcpLayerStart(struct fsm *fp)
466{
467 /* We're about to start up ! */
468 struct lcp *lcp = fsm2lcp(fp);
469
470 log_Printf(LogLCP, "%s: LayerStart\n", fp->link->name);
471 lcp->LcpFailedMagic = 0;
472 fp->more.reqs = fp->more.naks = fp->more.rejs = lcp->cfg.fsm.maxreq * 3;
473}
474
475static void
476LcpLayerFinish(struct fsm *fp)
477{
478 /* We're now down */
479 log_Printf(LogLCP, "%s: LayerFinish\n", fp->link->name);
480}
481
482static int
483LcpLayerUp(struct fsm *fp)
484{
485 /* We're now up */
486 struct physical *p = link2physical(fp->link);
487 struct lcp *lcp = fsm2lcp(fp);
488
489 log_Printf(LogLCP, "%s: LayerUp\n", fp->link->name);
490 async_SetLinkParams(&p->async, lcp);
491 lqr_Start(lcp);
492 hdlc_StartTimer(&p->hdlc);
493 fp->more.reqs = fp->more.naks = fp->more.rejs = lcp->cfg.fsm.maxreq * 3;
494
495 return 1;
496}
497
498static void
499LcpLayerDown(struct fsm *fp)
500{
501 /* About to come down */
502 struct physical *p = link2physical(fp->link);
503
504 log_Printf(LogLCP, "%s: LayerDown\n", fp->link->name);
505 hdlc_StopTimer(&p->hdlc);
506 lqr_StopTimer(p);
507 lcp_Setup(fsm2lcp(fp), 0);
508}
509
510static int
511E164ok(struct callback *cb, char *req, int sz)
512{
513 char list[sizeof cb->msg], *next;
514 int len;
515
516 if (!strcmp(cb->msg, "*"))
517 return 1;
518
519 strncpy(list, cb->msg, sizeof list - 1);
520 list[sizeof list - 1] = '\0';
521 for (next = strtok(list, ","); next; next = strtok(NULL, ",")) {
522 len = strlen(next);
523 if (sz == len && !memcmp(list, req, sz))
524 return 1;
525 }
526 return 0;
527}
528
529static void
530LcpDecodeConfig(struct fsm *fp, u_char *cp, int plen, int mode_type,
531 struct fsm_decode *dec)
532{
533 /* Deal with incoming PROTO_LCP */
534 struct lcp *lcp = fsm2lcp(fp);
535 int type, length, sz, pos, op, callback_req;
536 u_int32_t magic, accmap;
537 u_short mtu, mru, proto;
538 struct lqrreq *req;
539 char request[20], desc[22];
540 struct mp *mp;
541 struct physical *p = link2physical(fp->link);
542
543 sz = op = callback_req = 0;
544
545 while (plen >= sizeof(struct fsmconfig)) {
546 type = *cp;
547 length = cp[1];
548
549 if (type < 0 || type >= NCFTYPES)
550 snprintf(request, sizeof request, " <%d>[%d]", type, length);
551 else
552 snprintf(request, sizeof request, " %s[%d]", cftypes[type], length);
553
554 if (length < 2) {
555 log_Printf(LogLCP, "%s:%s: Bad LCP length\n", fp->link->name, request);
556 break;
557 }
558
559 switch (type) {
560 case TY_MRRU:
561 mp = &lcp->fsm.bundle->ncp.mp;
562 ua_ntohs(cp + 2, &mru);
563 log_Printf(LogLCP, "%s %u\n", request, mru);
564
565 switch (mode_type) {
566 case MODE_REQ:
567 if (mp->cfg.mrru) {
568 if (REJECTED(lcp, TY_MRRU))
569 /* Ignore his previous reject so that we REQ next time */
570 lcp->his_reject &= ~(1 << type);
571
572 mtu = lcp->fsm.bundle->cfg.mtu;
573 if (mru < MIN_MRU || mru < mtu) {
574 /* Push him up to MTU or MIN_MRU */
575 lcp->his_mrru = mru < mtu ? mtu : MIN_MRU;
576 memcpy(dec->nakend, cp, 2);
577 ua_htons(&lcp->his_mrru, dec->nakend + 2);
578 dec->nakend += 4;
579 } else {
580 lcp->his_mrru = mtu ? mtu : mru;
581 memcpy(dec->ackend, cp, 4);
582 dec->ackend += 4;
583 }
584 break;
585 } else
586 goto reqreject;
587 break;
588 case MODE_NAK:
589 if (mp->cfg.mrru) {
590 if (REJECTED(lcp, TY_MRRU))
591 /* Must have changed his mind ! */
592 lcp->his_reject &= ~(1 << type);
593
594 if (mru > MAX_MRU)
595 lcp->want_mrru = MAX_MRU;
596 else if (mru < MIN_MRU)
597 lcp->want_mrru = MIN_MRU;
598 else
599 lcp->want_mrru = mru;
600 }
601 /* else we honour our config and don't send the suggested REQ */
602 break;
603 case MODE_REJ:
604 lcp->his_reject |= (1 << type);
605 lcp->want_mrru = 0; /* Ah well, no multilink :-( */
606 break;
607 }
608 break;
609
610 case TY_MRU:
611 ua_ntohs(cp + 2, &mru);
612 log_Printf(LogLCP, "%s %d\n", request, mru);
613
614 switch (mode_type) {
615 case MODE_REQ:
616 mtu = lcp->fsm.bundle->cfg.mtu;
617 if (mru < MIN_MRU || (!lcp->want_mrru && mru < mtu)) {
618 /* Push him up to MTU or MIN_MRU */
619 lcp->his_mru = mru < mtu ? mtu : MIN_MRU;
620 memcpy(dec->nakend, cp, 2);
621 ua_htons(&lcp->his_mru, dec->nakend + 2);
622 dec->nakend += 4;
623 } else {
624 lcp->his_mru = mtu ? mtu : mru;
625 memcpy(dec->ackend, cp, 4);
626 dec->ackend += 4;
627 }
628 break;
629 case MODE_NAK:
630 if (mru > MAX_MRU)
631 lcp->want_mru = MAX_MRU;
632 else if (mru < MIN_MRU)
633 lcp->want_mru = MIN_MRU;
634 else
635 lcp->want_mru = mru;
636 break;
637 case MODE_REJ:
638 lcp->his_reject |= (1 << type);
639 break;
640 }
641 break;
642
643 case TY_ACCMAP:
644 ua_ntohl(cp + 2, &accmap);
645 log_Printf(LogLCP, "%s 0x%08lx\n", request, (u_long)accmap);
646
647 switch (mode_type) {
648 case MODE_REQ:
649 lcp->his_accmap = accmap;
650 memcpy(dec->ackend, cp, 6);
651 dec->ackend += 6;
652 break;
653 case MODE_NAK:
654 lcp->want_accmap = accmap;
655 break;
656 case MODE_REJ:
657 lcp->his_reject |= (1 << type);
658 break;
659 }
660 break;
661
662 case TY_AUTHPROTO:
663 ua_ntohs(cp + 2, &proto);
664 log_Printf(LogLCP, "%s 0x%04x (%s)\n", request, proto,
665 Auth2Nam(proto, length > 4 ? cp[4] : 0));
666
667 switch (mode_type) {
668 case MODE_REQ:
669 switch (proto) {
670 case PROTO_PAP:
671 if (length != 4) {
672 log_Printf(LogLCP, " Bad length!\n");
673 goto reqreject;
674 }
675 if (IsAccepted(lcp->cfg.pap)) {
676 lcp->his_auth = proto;
677 lcp->his_authtype = 0;
678 memcpy(dec->ackend, cp, length);
679 dec->ackend += length;
680 } else if (IsAccepted(lcp->cfg.chap05)) {
681 *dec->nakend++ = *cp;
682 *dec->nakend++ = 5;
683 *dec->nakend++ = (unsigned char) (PROTO_CHAP >> 8);
684 *dec->nakend++ = (unsigned char) PROTO_CHAP;
685 *dec->nakend++ = 0x05;
686#ifdef HAVE_DES
687 } else if (IsAccepted(lcp->cfg.chap80nt) ||
688 IsAccepted(lcp->cfg.chap80lm)) {
689 *dec->nakend++ = *cp;
690 *dec->nakend++ = 5;
691 *dec->nakend++ = (unsigned char) (PROTO_CHAP >> 8);
692 *dec->nakend++ = (unsigned char) PROTO_CHAP;
693 *dec->nakend++ = 0x80;
694#endif
695 } else
696 goto reqreject;
697 break;
698
699 case PROTO_CHAP:
700 if (length != 5) {
701 log_Printf(LogLCP, " Bad length!\n");
702 goto reqreject;
703 }
704 if ((cp[4] == 0x05 && IsAccepted(lcp->cfg.chap05))
705#ifdef HAVE_DES
706 || (cp[4] == 0x80 && (IsAccepted(lcp->cfg.chap80nt) ||
707 (IsAccepted(lcp->cfg.chap80lm))))
708#endif
709 ) {
710 lcp->his_auth = proto;
711 lcp->his_authtype = cp[4];
712 memcpy(dec->ackend, cp, length);
713 dec->ackend += length;
714 } else {
715#ifndef HAVE_DES
716 if (cp[4] == 0x80)
717 log_Printf(LogWARN, "CHAP 0x80 not available without DES\n");
718 else
719#endif
720 if (cp[4] != 0x05)
721 log_Printf(LogWARN, "%s not supported\n",
722 Auth2Nam(PROTO_CHAP, cp[4]));
723
724 if (IsAccepted(lcp->cfg.chap05)) {
725 *dec->nakend++ = *cp;
726 *dec->nakend++ = 5;
727 *dec->nakend++ = (unsigned char) (PROTO_CHAP >> 8);
728 *dec->nakend++ = (unsigned char) PROTO_CHAP;
729 *dec->nakend++ = 0x05;
730#ifdef HAVE_DES
731 } else if (IsAccepted(lcp->cfg.chap80nt) ||
732 IsAccepted(lcp->cfg.chap80lm)) {
733 *dec->nakend++ = *cp;
734 *dec->nakend++ = 5;
735 *dec->nakend++ = (unsigned char) (PROTO_CHAP >> 8);
736 *dec->nakend++ = (unsigned char) PROTO_CHAP;
737 *dec->nakend++ = 0x80;
738#endif
739 } else if (IsAccepted(lcp->cfg.pap)) {
740 *dec->nakend++ = *cp;
741 *dec->nakend++ = 4;
742 *dec->nakend++ = (unsigned char) (PROTO_PAP >> 8);
743 *dec->nakend++ = (unsigned char) PROTO_PAP;
744 } else
745 goto reqreject;
746 }
747 break;
748
749 default:
750 log_Printf(LogLCP, "%s 0x%04x - not recognised, NAK\n",
751 request, proto);
752 memcpy(dec->nakend, cp, length);
753 dec->nakend += length;
754 break;
755 }
756 break;
757 case MODE_NAK:
758 switch (proto) {
759 case PROTO_PAP:
760 if (IsEnabled(lcp->cfg.pap)) {
761 lcp->want_auth = PROTO_PAP;
762 lcp->want_authtype = 0;
763 } else {
764 log_Printf(LogLCP, "Peer will only send PAP (not enabled)\n");
765 lcp->his_reject |= (1 << type);
766 }
767 break;
768 case PROTO_CHAP:
769 if (cp[4] == 0x05 && IsEnabled(lcp->cfg.chap05)) {
770 lcp->want_auth = PROTO_CHAP;
771 lcp->want_authtype = 0x05;
772#ifdef HAVE_DES
773 } else if (cp[4] == 0x80 && (IsEnabled(lcp->cfg.chap80nt) ||
774 IsEnabled(lcp->cfg.chap80lm))) {
775 lcp->want_auth = PROTO_CHAP;
776 lcp->want_authtype = 0x80;
777#endif
778 } else {
779#ifndef HAVE_DES
780 if (cp[4] == 0x80)
781 log_Printf(LogLCP, "Peer will only send MSCHAP (not available"
782 " without DES)\n");
783 else
784#endif
785 log_Printf(LogLCP, "Peer will only send %s (not %s)\n",
786 Auth2Nam(PROTO_CHAP, cp[4]),
787#ifdef HAVE_DES
788 cp[4] == 0x80 ? "configured" :
789#endif
790 "supported");
791 lcp->his_reject |= (1 << type);
792 }
793 break;
794 default:
795 /* We've been NAK'd with something we don't understand :-( */
796 lcp->his_reject |= (1 << type);
797 break;
798 }
799 break;
800 case MODE_REJ:
801 lcp->his_reject |= (1 << type);
802 break;
803 }
804 break;
805
806 case TY_QUALPROTO:
807 req = (struct lqrreq *)cp;
808 log_Printf(LogLCP, "%s proto %x, interval %lums\n",
809 request, ntohs(req->proto), (u_long)ntohl(req->period) * 10);
810 switch (mode_type) {
811 case MODE_REQ:
812 if (ntohs(req->proto) != PROTO_LQR || !IsAccepted(lcp->cfg.lqr))
813 goto reqreject;
814 else {
815 lcp->his_lqrperiod = ntohl(req->period);
816 if (lcp->his_lqrperiod < MIN_LQRPERIOD * 100)
817 lcp->his_lqrperiod = MIN_LQRPERIOD * 100;
818 req->period = htonl(lcp->his_lqrperiod);
819 memcpy(dec->ackend, cp, length);
820 dec->ackend += length;
821 }
822 break;
823 case MODE_NAK:
824 break;
825 case MODE_REJ:
826 lcp->his_reject |= (1 << type);
827 break;
828 }
829 break;
830
831 case TY_MAGICNUM:
832 ua_ntohl(cp + 2, &magic);
833 log_Printf(LogLCP, "%s 0x%08lx\n", request, (u_long)magic);
834
835 switch (mode_type) {
836 case MODE_REQ:
837 if (lcp->want_magic) {
838 /* Validate magic number */
839 if (magic == lcp->want_magic) {
840 log_Printf(LogLCP, "Magic is same (%08lx) - %d times\n",
841 (u_long)magic, ++lcp->LcpFailedMagic);
842 lcp->want_magic = GenerateMagic();
843 memcpy(dec->nakend, cp, 6);
844 dec->nakend += 6;
845 ualarm(TICKUNIT * (4 + 4 * lcp->LcpFailedMagic), 0);
846 sigpause(0);
847 } else {
848 lcp->his_magic = magic;
849 memcpy(dec->ackend, cp, length);
850 dec->ackend += length;
851 lcp->LcpFailedMagic = 0;
852 }
853 } else {
854 goto reqreject;
855 }
856 break;
857 case MODE_NAK:
858 log_Printf(LogLCP, " Magic 0x%08lx is NAKed!\n", (u_long)magic);
859 lcp->want_magic = GenerateMagic();
860 break;
861 case MODE_REJ:
862 log_Printf(LogLCP, " Magic 0x%08x is REJected!\n", magic);
863 lcp->want_magic = 0;
864 lcp->his_reject |= (1 << type);
865 break;
866 }
867 break;
868
869 case TY_PROTOCOMP:
870 log_Printf(LogLCP, "%s\n", request);
871
872 switch (mode_type) {
873 case MODE_REQ:
874 if (IsAccepted(lcp->cfg.protocomp)) {
875 lcp->his_protocomp = 1;
876 memcpy(dec->ackend, cp, 2);
877 dec->ackend += 2;
878 } else {
879#ifdef OLDMST
880 /* MorningStar before v1.3 needs NAK */
881 memcpy(dec->nakend, cp, 2);
882 dec->nakend += 2;
883#else
884 goto reqreject;
885#endif
886 }
887 break;
888 case MODE_NAK:
889 case MODE_REJ:
890 lcp->want_protocomp = 0;
891 lcp->his_reject |= (1 << type);
892 break;
893 }
894 break;
895
896 case TY_ACFCOMP:
897 log_Printf(LogLCP, "%s\n", request);
898 switch (mode_type) {
899 case MODE_REQ:
900 if (IsAccepted(lcp->cfg.acfcomp)) {
901 lcp->his_acfcomp = 1;
902 memcpy(dec->ackend, cp, 2);
903 dec->ackend += 2;
904 } else {
905#ifdef OLDMST
906 /* MorningStar before v1.3 needs NAK */
907 memcpy(dec->nakend, cp, 2);
908 dec->nakend += 2;
909#else
910 goto reqreject;
911#endif
912 }
913 break;
914 case MODE_NAK:
915 case MODE_REJ:
916 lcp->want_acfcomp = 0;
917 lcp->his_reject |= (1 << type);
918 break;
919 }
920 break;
921
922 case TY_SDP:
923 log_Printf(LogLCP, "%s\n", request);
924 switch (mode_type) {
925 case MODE_REQ:
926 case MODE_NAK:
927 case MODE_REJ:
928 break;
929 }
930 break;
931
932 case TY_CALLBACK:
933 if (length == 2)
934 op = CALLBACK_NONE;
935 else
936 op = (int)cp[2];
937 sz = length - 3;
938 switch (op) {
939 case CALLBACK_AUTH:
940 log_Printf(LogLCP, "%s Auth\n", request);
941 break;
942 case CALLBACK_DIALSTRING:
943 log_Printf(LogLCP, "%s Dialstring %.*s\n", request, sz, cp + 3);
944 break;
945 case CALLBACK_LOCATION:
946 log_Printf(LogLCP, "%s Location %.*s\n", request, sz, cp + 3);
947 break;
948 case CALLBACK_E164:
949 log_Printf(LogLCP, "%s E.164 (%.*s)\n", request, sz, cp + 3);
950 break;
951 case CALLBACK_NAME:
952 log_Printf(LogLCP, "%s Name %.*s\n", request, sz, cp + 3);
953 break;
954 case CALLBACK_CBCP:
955 log_Printf(LogLCP, "%s CBCP\n", request);
956 break;
957 default:
958 log_Printf(LogLCP, "%s ???\n", request);
959 break;
960 }
961
962 switch (mode_type) {
963 case MODE_REQ:
964 callback_req = 1;
965 if (p->type != PHYS_DIRECT)
966 goto reqreject;
967 if ((p->dl->cfg.callback.opmask & CALLBACK_BIT(op)) &&
968 (op != CALLBACK_AUTH || p->link.lcp.auth_ineed) &&
969 (op != CALLBACK_E164 ||
970 E164ok(&p->dl->cfg.callback, cp + 3, sz))) {
971 lcp->his_callback.opmask = CALLBACK_BIT(op);
972 if (sz > sizeof lcp->his_callback.msg - 1) {
973 sz = sizeof lcp->his_callback.msg - 1;
974 log_Printf(LogWARN, "Truncating option arg to %d octets\n", sz);
975 }
976 memcpy(lcp->his_callback.msg, cp + 3, sz);
977 lcp->his_callback.msg[sz] = '\0';
978 memcpy(dec->ackend, cp, sz + 3);
979 dec->ackend += sz + 3;
980 } else if ((p->dl->cfg.callback.opmask & CALLBACK_BIT(CALLBACK_AUTH)) &&
981 p->link.lcp.auth_ineed) {
982 *dec->nakend++ = *cp;
983 *dec->nakend++ = 3;
984 *dec->nakend++ = CALLBACK_AUTH;
985 } else if (p->dl->cfg.callback.opmask & CALLBACK_BIT(CALLBACK_CBCP)) {
986 *dec->nakend++ = *cp;
987 *dec->nakend++ = 3;
988 *dec->nakend++ = CALLBACK_CBCP;
989 } else if (p->dl->cfg.callback.opmask & CALLBACK_BIT(CALLBACK_E164)) {
990 *dec->nakend++ = *cp;
991 *dec->nakend++ = 3;
992 *dec->nakend++ = CALLBACK_E164;
993 } else if (p->dl->cfg.callback.opmask & CALLBACK_BIT(CALLBACK_AUTH)) {
994 log_Printf(LogWARN, "Cannot insist on auth callback without"
995 " PAP or CHAP enabled !\n");
996 *dec->nakend++ = *cp;
997 *dec->nakend++ = 2;
998 } else
999 goto reqreject;
1000 break;
1001 case MODE_NAK:
1002 /* We don't do what he NAKs with, we do things in our preferred order */
1003 if (lcp->want_callback.opmask & CALLBACK_BIT(CALLBACK_AUTH))
1004 lcp->want_callback.opmask &= ~CALLBACK_BIT(CALLBACK_AUTH);
1005 else if (lcp->want_callback.opmask & CALLBACK_BIT(CALLBACK_CBCP))
1006 lcp->want_callback.opmask &= ~CALLBACK_BIT(CALLBACK_CBCP);
1007 else if (lcp->want_callback.opmask & CALLBACK_BIT(CALLBACK_E164))
1008 lcp->want_callback.opmask &= ~CALLBACK_BIT(CALLBACK_E164);
1009 if (lcp->want_callback.opmask == CALLBACK_BIT(CALLBACK_NONE)) {
1010 log_Printf(LogPHASE, "Peer NAKd all callbacks, trying none\n");
1011 lcp->want_callback.opmask = 0;
1012 } else if (!lcp->want_callback.opmask) {
1013 log_Printf(LogPHASE, "Peer NAKd last configured callback\n");
1014 fsm_Close(&lcp->fsm);
1015 }
1016 break;
1017 case MODE_REJ:
1018 if (lcp->want_callback.opmask & CALLBACK_BIT(CALLBACK_NONE)) {
1019 lcp->his_reject |= (1 << type);
1020 lcp->want_callback.opmask = 0;
1021 } else {
1022 log_Printf(LogPHASE, "Peer rejected *required* callback\n");
1023 fsm_Close(&lcp->fsm);
1024 }
1025 break;
1026 }
1027 break;
1028
1029 case TY_SHORTSEQ:
1030 mp = &lcp->fsm.bundle->ncp.mp;
1031 log_Printf(LogLCP, "%s\n", request);
1032
1033 switch (mode_type) {
1034 case MODE_REQ:
1035 if (lcp->want_mrru && IsAccepted(mp->cfg.shortseq)) {
1036 lcp->his_shortseq = 1;
1037 memcpy(dec->ackend, cp, length);
1038 dec->ackend += length;
1039 } else
1040 goto reqreject;
1041 break;
1042 case MODE_NAK:
1043 /*
1044 * He's trying to get us to ask for short sequence numbers.
1045 * We ignore the NAK and honour our configuration file instead.
1046 */
1047 break;
1048 case MODE_REJ:
1049 lcp->his_reject |= (1 << type);
1050 lcp->want_shortseq = 0; /* For when we hit MP */
1051 break;
1052 }
1053 break;
1054
1055 case TY_ENDDISC:
1056 mp = &lcp->fsm.bundle->ncp.mp;
1057 log_Printf(LogLCP, "%s %s\n", request,
1058 mp_Enddisc(cp[2], cp + 3, length - 3));
1059 switch (mode_type) {
1060 case MODE_REQ:
1061 if (!p) {
1062 log_Printf(LogLCP, " ENDDISC rejected - not a physical link\n");
1063 goto reqreject;
1064 } else if (!IsAccepted(mp->cfg.negenddisc))
1065 goto reqreject;
1066 else if (length-3 < sizeof p->dl->peer.enddisc.address &&
1067 cp[2] <= MAX_ENDDISC_CLASS) {
1068 p->dl->peer.enddisc.class = cp[2];
1069 p->dl->peer.enddisc.len = length-3;
1070 memcpy(p->dl->peer.enddisc.address, cp + 3, length - 3);
1071 p->dl->peer.enddisc.address[length - 3] = '\0';
1072 /* XXX: If mp->active, compare and NAK with mp->peer ? */
1073 memcpy(dec->ackend, cp, length);
1074 dec->ackend += length;
1075 } else {
1076 if (cp[2] > MAX_ENDDISC_CLASS)
1077 log_Printf(LogLCP, " ENDDISC rejected - unrecognised class %d\n",
1078 cp[2]);
1079 else
1080 log_Printf(LogLCP, " ENDDISC rejected - local max length is %ld\n",
1081 (long)(sizeof p->dl->peer.enddisc.address - 1));
1082 goto reqreject;
1083 }
1084 break;
1085
1086 case MODE_NAK: /* Treat this as a REJ, we don't vary our disc (yet) */
1087 case MODE_REJ:
1088 lcp->his_reject |= (1 << type);
1089 break;
1090 }
1091 break;
1092
1093 default:
1094 sz = (sizeof desc - 2) / 2;
1095 if (sz > length - 2)
1096 sz = length - 2;
1097 pos = 0;
1098 desc[0] = sz ? ' ' : '\0';
1099 for (pos = 0; sz--; pos++)
1100 sprintf(desc+(pos<<1)+1, "%02x", cp[pos+2]);
1101
1102 log_Printf(LogLCP, "%s%s\n", request, desc);
1103
1104 if (mode_type == MODE_REQ) {
1105reqreject:
1106 if (length > sizeof dec->rej - (dec->rejend - dec->rej)) {
1107 length = sizeof dec->rej - (dec->rejend - dec->rej);
1108 log_Printf(LogLCP, "Can't REJ length %d - trunating to %d\n",
1109 cp[1], length);
1110 }
1111 memcpy(dec->rejend, cp, length);
1112 dec->rejend += length;
1113 lcp->my_reject |= (1 << type);
1114 if (length != cp[1])
1115 length = 0; /* force our way out of the loop */
1116 }
1117 break;
1118 }
1119 plen -= length;
1120 cp += length;
1121 }
1122
1123 if (mode_type != MODE_NOP) {
1124 if (mode_type == MODE_REQ && p && p->type == PHYS_DIRECT &&
1125 p->dl->cfg.callback.opmask && !callback_req &&
1126 !(p->dl->cfg.callback.opmask & CALLBACK_BIT(CALLBACK_NONE))) {
1127 /* We *REQUIRE* that the peer requests callback */
1128 *dec->nakend++ = TY_CALLBACK;
1129 *dec->nakend++ = 3;
1130 if ((p->dl->cfg.callback.opmask & CALLBACK_BIT(CALLBACK_AUTH)) &&
1131 p->link.lcp.auth_ineed)
1132 *dec->nakend++ = CALLBACK_AUTH;
1133 else if (p->dl->cfg.callback.opmask & CALLBACK_BIT(CALLBACK_CBCP))
1134 *dec->nakend++ = CALLBACK_CBCP;
1135 else if (p->dl->cfg.callback.opmask & CALLBACK_BIT(CALLBACK_E164))
1136 *dec->nakend++ = CALLBACK_E164;
1137 else {
1138 log_Printf(LogWARN, "Cannot insist on auth callback without"
1139 " PAP or CHAP enabled !\n");
1140 dec->nakend[-1] = 2; /* XXX: Silly ! */
1141 }
1142 }
1143 if (dec->rejend != dec->rej) {
1144 /* rejects are preferred */
1145 dec->ackend = dec->ack;
1146 dec->nakend = dec->nak;
1147 } else if (dec->nakend != dec->nak)
1148 /* then NAKs */
1149 dec->ackend = dec->ack;
1150 }
1151}
1152
1153extern struct mbuf *
1154lcp_Input(struct bundle *bundle, struct link *l, struct mbuf *bp)
1155{
1156 /* Got PROTO_LCP from link */
1157 m_settype(bp, MB_LCPIN);
1158 fsm_Input(&l->lcp.fsm, bp);
1159 return NULL;
1160}