2 * Copyright (c) 1996 - 2001 Brian Somers <brian@Awfulhak.org>
3 * based on work by Toshiharu OHNO <tony-o@iij.ad.jp>
4 * Internet Initiative Japan, Inc (IIJ)
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
10 * 1. Redistributions of source code must retain the above copyright
11 * notice, this list of conditions and the following disclaimer.
12 * 2. Redistributions in binary form must reproduce the above copyright
13 * notice, this list of conditions and the following disclaimer in the
14 * documentation and/or other materials provided with the distribution.
16 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
17 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
18 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
19 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
20 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
21 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
22 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
23 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
24 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
25 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
31 #include <sys/param.h>
32 #include <netinet/in.h>
33 #include <netinet/in_systm.h>
34 #include <netinet/ip.h>
35 #include <sys/socket.h>
54 #include "throughput.h"
56 #include "descriptor.h"
65 #include "slcompress.h"
82 /* for received LQRs */
84 struct fsm_opt_hdr hdr;
85 u_short proto; /* Quality protocol */
86 u_int32_t period; /* Reporting interval */
89 static int LcpLayerUp(struct fsm *);
90 static void LcpLayerDown(struct fsm *);
91 static void LcpLayerStart(struct fsm *);
92 static void LcpLayerFinish(struct fsm *);
93 static void LcpInitRestartCounter(struct fsm *, int);
94 static void LcpSendConfigReq(struct fsm *);
95 static void LcpSentTerminateReq(struct fsm *);
96 static void LcpSendTerminateAck(struct fsm *, u_char);
97 static void LcpDecodeConfig(struct fsm *, u_char *, u_char *, int,
100 static struct fsm_callbacks lcp_Callbacks = {
105 LcpInitRestartCounter,
110 fsm_NullRecvResetReq,
114 static const char * const lcp_TimerNames[] =
115 {"LCP restart", "LCP openmode", "LCP stopped"};
120 static const char * const cftypes[] = {
121 /* Check out the latest ``Assigned numbers'' rfc (1700) */
123 "MRU", /* 1: Maximum-Receive-Unit */
124 "ACCMAP", /* 2: Async-Control-Character-Map */
125 "AUTHPROTO", /* 3: Authentication-Protocol */
126 "QUALPROTO", /* 4: Quality-Protocol */
127 "MAGICNUM", /* 5: Magic-Number */
128 "RESERVED", /* 6: RESERVED */
129 "PROTOCOMP", /* 7: Protocol-Field-Compression */
130 "ACFCOMP", /* 8: Address-and-Control-Field-Compression */
131 "FCSALT", /* 9: FCS-Alternatives */
132 "SDP", /* 10: Self-Describing-Pad */
133 "NUMMODE", /* 11: Numbered-Mode */
134 "MULTIPROC", /* 12: Multi-Link-Procedure */
135 "CALLBACK", /* 13: Callback */
136 "CONTIME", /* 14: Connect-Time */
137 "COMPFRAME", /* 15: Compound-Frames */
138 "NDE", /* 16: Nominal-Data-Encapsulation */
139 "MRRU", /* 17: Multilink-MRRU */
140 "SHORTSEQ", /* 18: Multilink-Short-Sequence-Number-Header */
141 "ENDDISC", /* 19: Multilink-Endpoint-Discriminator */
142 "PROPRIETRY", /* 20: Proprietary */
143 "DCEID", /* 21: DCE-Identifier */
144 "MULTIPP", /* 22: Multi-Link-Plus-Procedure */
145 "LDBACP", /* 23: Link Discriminator for BACP */
148 if (proto < 0 || proto > sizeof cftypes / sizeof *cftypes ||
149 cftypes[proto] == NULL)
150 return HexStr(proto, NULL, 0);
152 return cftypes[proto];
156 lcp_ReportStatus(struct cmdargs const *arg)
161 l = command_ChooseLink(arg);
164 prompt_Printf(arg->prompt, "%s: %s [%s]\n", l->name, lcp->fsm.name,
165 State2Nam(lcp->fsm.state));
166 prompt_Printf(arg->prompt,
167 " his side: MRU %d, ACCMAP %08lx, PROTOCOMP %s, ACFCOMP %s,\n"
168 " MAGIC %08lx, MRRU %u, SHORTSEQ %s, REJECT %04x\n",
169 lcp->his_mru, (u_long)lcp->his_accmap,
170 lcp->his_protocomp ? "on" : "off",
171 lcp->his_acfcomp ? "on" : "off",
172 (u_long)lcp->his_magic, lcp->his_mrru,
173 lcp->his_shortseq ? "on" : "off", lcp->his_reject);
174 prompt_Printf(arg->prompt,
175 " my side: MRU %d, ACCMAP %08lx, PROTOCOMP %s, ACFCOMP %s,\n"
176 " MAGIC %08lx, MRRU %u, SHORTSEQ %s, REJECT %04x\n",
177 lcp->want_mru, (u_long)lcp->want_accmap,
178 lcp->want_protocomp ? "on" : "off",
179 lcp->want_acfcomp ? "on" : "off",
180 (u_long)lcp->want_magic, lcp->want_mrru,
181 lcp->want_shortseq ? "on" : "off", lcp->my_reject);
184 prompt_Printf(arg->prompt, "\n Defaults: MRU = %d (max %d), ",
185 lcp->cfg.mru, lcp->cfg.max_mru);
187 prompt_Printf(arg->prompt, "\n Defaults: MRU = any (max %d), ",
190 prompt_Printf(arg->prompt, "MTU = %d (max %d), ",
191 lcp->cfg.mtu, lcp->cfg.max_mtu);
193 prompt_Printf(arg->prompt, "MTU = any (max %d), ", lcp->cfg.max_mtu);
194 prompt_Printf(arg->prompt, "ACCMAP = %08lx\n", (u_long)lcp->cfg.accmap);
195 prompt_Printf(arg->prompt, " LQR period = %us, ",
197 prompt_Printf(arg->prompt, "Open Mode = %s",
198 lcp->cfg.openmode == OPEN_PASSIVE ? "passive" : "active");
199 if (lcp->cfg.openmode > 0)
200 prompt_Printf(arg->prompt, " (delay %ds)", lcp->cfg.openmode);
201 prompt_Printf(arg->prompt, "\n FSM retry = %us, max %u Config"
202 " REQ%s, %u Term REQ%s\n", lcp->cfg.fsm.timeout,
203 lcp->cfg.fsm.maxreq, lcp->cfg.fsm.maxreq == 1 ? "" : "s",
204 lcp->cfg.fsm.maxtrm, lcp->cfg.fsm.maxtrm == 1 ? "" : "s");
205 prompt_Printf(arg->prompt, " Ident: %s\n", lcp->cfg.ident);
206 prompt_Printf(arg->prompt, "\n Negotiation:\n");
207 prompt_Printf(arg->prompt, " ACFCOMP = %s\n",
208 command_ShowNegval(lcp->cfg.acfcomp));
209 prompt_Printf(arg->prompt, " CHAP = %s\n",
210 command_ShowNegval(lcp->cfg.chap05));
212 prompt_Printf(arg->prompt, " CHAP80 = %s\n",
213 command_ShowNegval(lcp->cfg.chap80nt));
214 prompt_Printf(arg->prompt, " LANMan = %s\n",
215 command_ShowNegval(lcp->cfg.chap80lm));
216 prompt_Printf(arg->prompt, " CHAP81 = %s\n",
217 command_ShowNegval(lcp->cfg.chap81));
219 prompt_Printf(arg->prompt, " LQR = %s\n",
220 command_ShowNegval(lcp->cfg.lqr));
221 prompt_Printf(arg->prompt, " PAP = %s\n",
222 command_ShowNegval(lcp->cfg.pap));
223 prompt_Printf(arg->prompt, " PROTOCOMP = %s\n",
224 command_ShowNegval(lcp->cfg.protocomp));
232 /* Generate random number which will be used as magic number */
238 lcp_SetupCallbacks(struct lcp *lcp)
240 lcp->fsm.fn = &lcp_Callbacks;
241 lcp->fsm.FsmTimer.name = lcp_TimerNames[0];
242 lcp->fsm.OpenTimer.name = lcp_TimerNames[1];
243 lcp->fsm.StoppedTimer.name = lcp_TimerNames[2];
247 lcp_Init(struct lcp *lcp, struct bundle *bundle, struct link *l,
248 const struct fsm_parent *parent)
250 /* Initialise ourselves */
251 int mincode = parent ? 1 : LCP_MINMPCODE;
253 fsm_Init(&lcp->fsm, "LCP", PROTO_LCP, mincode, LCP_MAXCODE, LogLCP,
254 bundle, l, parent, &lcp_Callbacks, lcp_TimerNames);
257 lcp->cfg.max_mru = MAX_MRU;
259 lcp->cfg.max_mtu = MAX_MTU;
261 lcp->cfg.openmode = 1;
262 lcp->cfg.lqrperiod = DEF_LQRPERIOD;
263 lcp->cfg.fsm.timeout = DEF_FSMRETRY;
264 lcp->cfg.fsm.maxreq = DEF_FSMTRIES;
265 lcp->cfg.fsm.maxtrm = DEF_FSMTRIES;
267 lcp->cfg.acfcomp = NEG_ENABLED|NEG_ACCEPTED;
268 lcp->cfg.chap05 = NEG_ACCEPTED;
270 lcp->cfg.chap80nt = NEG_ACCEPTED;
271 lcp->cfg.chap80lm = 0;
272 lcp->cfg.chap81 = NEG_ACCEPTED;
274 lcp->cfg.lqr = NEG_ACCEPTED;
275 lcp->cfg.pap = NEG_ACCEPTED;
276 lcp->cfg.protocomp = NEG_ENABLED|NEG_ACCEPTED;
277 *lcp->cfg.ident = '\0';
279 lcp_Setup(lcp, lcp->cfg.openmode);
283 lcp_Setup(struct lcp *lcp, int openmode)
285 struct physical *p = link2physical(lcp->fsm.link);
287 lcp->fsm.open_mode = openmode;
289 lcp->his_mru = DEF_MRU;
292 lcp->his_lqrperiod = 0;
293 lcp->his_acfcomp = 0;
295 lcp->his_authtype = 0;
296 lcp->his_callback.opmask = 0;
297 lcp->his_shortseq = 0;
300 if ((lcp->want_mru = lcp->cfg.mru) == 0)
301 lcp->want_mru = DEF_MRU;
302 lcp->want_mrru = lcp->fsm.bundle->ncp.mp.cfg.mrru;
303 lcp->want_shortseq = IsEnabled(lcp->fsm.bundle->ncp.mp.cfg.shortseq) ? 1 : 0;
304 lcp->want_acfcomp = IsEnabled(lcp->cfg.acfcomp) ? 1 : 0;
306 if (lcp->fsm.parent) {
307 lcp->his_accmap = 0xffffffff;
308 lcp->want_accmap = lcp->cfg.accmap;
309 lcp->his_protocomp = 0;
310 lcp->want_protocomp = IsEnabled(lcp->cfg.protocomp) ? 1 : 0;
311 lcp->want_magic = GenerateMagic();
313 if (IsEnabled(lcp->cfg.chap05)) {
314 lcp->want_auth = PROTO_CHAP;
315 lcp->want_authtype = 0x05;
317 } else if (IsEnabled(lcp->cfg.chap80nt) ||
318 IsEnabled(lcp->cfg.chap80lm)) {
319 lcp->want_auth = PROTO_CHAP;
320 lcp->want_authtype = 0x80;
321 } else if (IsEnabled(lcp->cfg.chap81)) {
322 lcp->want_auth = PROTO_CHAP;
323 lcp->want_authtype = 0x81;
325 } else if (IsEnabled(lcp->cfg.pap)) {
326 lcp->want_auth = PROTO_PAP;
327 lcp->want_authtype = 0;
330 lcp->want_authtype = 0;
333 if (p->type != PHYS_DIRECT)
334 memcpy(&lcp->want_callback, &p->dl->cfg.callback,
335 sizeof(struct callback));
337 lcp->want_callback.opmask = 0;
338 lcp->want_lqrperiod = IsEnabled(lcp->cfg.lqr) ?
339 lcp->cfg.lqrperiod * 100 : 0;
341 lcp->his_accmap = lcp->want_accmap = 0;
342 lcp->his_protocomp = lcp->want_protocomp = 1;
345 lcp->want_authtype = 0;
346 lcp->want_callback.opmask = 0;
347 lcp->want_lqrperiod = 0;
350 lcp->his_reject = lcp->my_reject = 0;
351 lcp->auth_iwait = lcp->auth_ineed = 0;
352 lcp->LcpFailedMagic = 0;
356 LcpInitRestartCounter(struct fsm *fp, int what)
358 /* Set fsm timer load */
359 struct lcp *lcp = fsm2lcp(fp);
361 fp->FsmTimer.load = lcp->cfg.fsm.timeout * SECTICKS;
364 fp->restart = lcp->cfg.fsm.maxreq;
367 fp->restart = lcp->cfg.fsm.maxtrm;
376 LcpSendConfigReq(struct fsm *fp)
378 /* Send config REQ please */
379 struct physical *p = link2physical(fp->link);
380 struct lcp *lcp = fsm2lcp(fp);
388 log_Printf(LogERROR, "%s: LcpSendConfigReq: Not a physical link !\n",
393 o = (struct fsm_opt *)buff;
394 if (!physical_IsSync(p)) {
395 if (lcp->want_acfcomp && !REJECTED(lcp, TY_ACFCOMP))
396 INC_FSM_OPT(TY_ACFCOMP, 2, o);
398 if (lcp->want_protocomp && !REJECTED(lcp, TY_PROTOCOMP))
399 INC_FSM_OPT(TY_PROTOCOMP, 2, o);
401 if (!REJECTED(lcp, TY_ACCMAP)) {
402 ua_htonl(&lcp->want_accmap, o->data);
403 INC_FSM_OPT(TY_ACCMAP, 6, o);
407 maxmru = p ? physical_DeviceMTU(p) : 0;
408 if (lcp->cfg.max_mru && (!maxmru || maxmru > lcp->cfg.max_mru))
409 maxmru = lcp->cfg.max_mru;
410 if (maxmru && lcp->want_mru > maxmru) {
411 log_Printf(LogWARN, "%s: Reducing configured MRU from %u to %u\n",
412 fp->link->name, lcp->want_mru, maxmru);
413 lcp->want_mru = maxmru;
415 if (!REJECTED(lcp, TY_MRU)) {
416 ua_htons(&lcp->want_mru, o->data);
417 INC_FSM_OPT(TY_MRU, 4, o);
420 if (lcp->want_magic && !REJECTED(lcp, TY_MAGICNUM)) {
421 ua_htonl(&lcp->want_magic, o->data);
422 INC_FSM_OPT(TY_MAGICNUM, 6, o);
425 if (lcp->want_lqrperiod && !REJECTED(lcp, TY_QUALPROTO)) {
427 ua_htons(&proto, o->data);
428 ua_htonl(&lcp->want_lqrperiod, o->data + 2);
429 INC_FSM_OPT(TY_QUALPROTO, 8, o);
432 switch (lcp->want_auth) {
435 ua_htons(&proto, o->data);
436 INC_FSM_OPT(TY_AUTHPROTO, 4, o);
441 ua_htons(&proto, o->data);
442 o->data[2] = lcp->want_authtype;
443 INC_FSM_OPT(TY_AUTHPROTO, 5, o);
447 if (!REJECTED(lcp, TY_CALLBACK)) {
448 if (lcp->want_callback.opmask & CALLBACK_BIT(CALLBACK_AUTH)) {
449 *o->data = CALLBACK_AUTH;
450 INC_FSM_OPT(TY_CALLBACK, 3, o);
451 } else if (lcp->want_callback.opmask & CALLBACK_BIT(CALLBACK_CBCP)) {
452 *o->data = CALLBACK_CBCP;
453 INC_FSM_OPT(TY_CALLBACK, 3, o);
454 } else if (lcp->want_callback.opmask & CALLBACK_BIT(CALLBACK_E164)) {
455 int sz = strlen(lcp->want_callback.msg);
457 if (sz > sizeof o->data - 1) {
458 sz = sizeof o->data - 1;
459 log_Printf(LogWARN, "Truncating E164 data to %d octets (oops!)\n", sz);
461 *o->data = CALLBACK_E164;
462 memcpy(o->data + 1, lcp->want_callback.msg, sz);
463 INC_FSM_OPT(TY_CALLBACK, sz + 3, o);
467 if (lcp->want_mrru && !REJECTED(lcp, TY_MRRU)) {
468 ua_htons(&lcp->want_mrru, o->data);
469 INC_FSM_OPT(TY_MRRU, 4, o);
471 if (lcp->want_shortseq && !REJECTED(lcp, TY_SHORTSEQ))
472 INC_FSM_OPT(TY_SHORTSEQ, 2, o);
475 mp = &lcp->fsm.bundle->ncp.mp;
476 if (mp->cfg.enddisc.class != 0 && IsEnabled(mp->cfg.negenddisc) &&
477 !REJECTED(lcp, TY_ENDDISC)) {
478 *o->data = mp->cfg.enddisc.class;
479 memcpy(o->data+1, mp->cfg.enddisc.address, mp->cfg.enddisc.len);
480 INC_FSM_OPT(TY_ENDDISC, mp->cfg.enddisc.len + 3, o);
483 fsm_Output(fp, CODE_CONFIGREQ, fp->reqid, buff, (u_char *)o - buff,
488 lcp_SendProtoRej(struct lcp *lcp, u_char *option, int count)
490 /* Don't understand `option' */
491 fsm_Output(&lcp->fsm, CODE_PROTOREJ, lcp->fsm.reqid, option, count,
496 lcp_SendIdentification(struct lcp *lcp)
498 static u_char id; /* Use a private id */
499 u_char msg[DEF_MRU - 3];
503 if (*lcp->cfg.ident == '\0')
506 argv[0] = lcp->cfg.ident;
509 command_Expand(exp, 1, argv, lcp->fsm.bundle, 1, getpid());
511 ua_htonl(&lcp->want_magic, msg);
512 strncpy(msg + 4, exp[0], sizeof msg - 5);
513 msg[sizeof msg - 1] = '\0';
515 fsm_Output(&lcp->fsm, CODE_IDENT, id++, msg, 4 + strlen(msg + 4), MB_LCPOUT);
516 log_Printf(LogLCP, " MAGICNUM %08x\n", lcp->want_magic);
517 log_Printf(LogLCP, " TEXT %s\n", msg + 4);
519 command_Free(1, exp);
524 lcp_RecvIdentification(struct lcp *lcp, char *data)
526 log_Printf(LogLCP, " MAGICNUM %08x\n", lcp->his_magic);
527 log_Printf(LogLCP, " TEXT %s\n", data);
531 LcpSentTerminateReq(struct fsm *fp)
533 /* Term REQ just sent by FSM */
537 LcpSendTerminateAck(struct fsm *fp, u_char id)
539 /* Send Term ACK please */
540 struct physical *p = link2physical(fp->link);
542 if (p && p->dl->state == DATALINK_CBCP)
543 cbcp_ReceiveTerminateReq(p);
545 fsm_Output(fp, CODE_TERMACK, id, NULL, 0, MB_LCPOUT);
549 LcpLayerStart(struct fsm *fp)
551 /* We're about to start up ! */
552 struct lcp *lcp = fsm2lcp(fp);
554 log_Printf(LogLCP, "%s: LayerStart\n", fp->link->name);
555 lcp->LcpFailedMagic = 0;
556 fp->more.reqs = fp->more.naks = fp->more.rejs = lcp->cfg.fsm.maxreq * 3;
561 LcpLayerFinish(struct fsm *fp)
564 log_Printf(LogLCP, "%s: LayerFinish\n", fp->link->name);
568 LcpLayerUp(struct fsm *fp)
571 struct physical *p = link2physical(fp->link);
572 struct lcp *lcp = fsm2lcp(fp);
574 log_Printf(LogLCP, "%s: LayerUp\n", fp->link->name);
575 physical_SetAsyncParams(p, lcp->want_accmap, lcp->his_accmap);
577 hdlc_StartTimer(&p->hdlc);
578 fp->more.reqs = fp->more.naks = fp->more.rejs = lcp->cfg.fsm.maxreq * 3;
580 lcp_SendIdentification(lcp);
586 LcpLayerDown(struct fsm *fp)
588 /* About to come down */
589 struct physical *p = link2physical(fp->link);
591 log_Printf(LogLCP, "%s: LayerDown\n", fp->link->name);
592 hdlc_StopTimer(&p->hdlc);
594 lcp_Setup(fsm2lcp(fp), 0);
598 E164ok(struct callback *cb, char *req, int sz)
600 char list[sizeof cb->msg], *next;
603 if (!strcmp(cb->msg, "*"))
606 strncpy(list, cb->msg, sizeof list - 1);
607 list[sizeof list - 1] = '\0';
608 for (next = strtok(list, ","); next; next = strtok(NULL, ",")) {
610 if (sz == len && !memcmp(list, req, sz))
617 lcp_auth_nak(struct lcp *lcp, struct fsm_decode *dec)
621 nak.hdr.id = TY_AUTHPROTO;
623 if (IsAccepted(lcp->cfg.pap)) {
625 nak.data[0] = (unsigned char)(PROTO_PAP >> 8);
626 nak.data[1] = (unsigned char)PROTO_PAP;
632 nak.data[0] = (unsigned char)(PROTO_CHAP >> 8);
633 nak.data[1] = (unsigned char)PROTO_CHAP;
635 if (IsAccepted(lcp->cfg.chap05)) {
639 } else if (IsAccepted(lcp->cfg.chap80nt) ||
640 IsAccepted(lcp->cfg.chap80lm)) {
643 } else if (IsAccepted(lcp->cfg.chap81)) {
655 LcpDecodeConfig(struct fsm *fp, u_char *cp, u_char *end, int mode_type,
656 struct fsm_decode *dec)
658 /* Deal with incoming PROTO_LCP */
659 struct lcp *lcp = fsm2lcp(fp);
660 int sz, pos, op, callback_req, chap_type;
661 u_int32_t magic, accmap;
662 u_short mru, phmtu, maxmtu, maxmru, wantmtu, wantmru, proto;
664 char request[20], desc[22];
666 struct physical *p = link2physical(fp->link);
667 struct fsm_opt *opt, nak;
669 sz = op = callback_req = 0;
671 while (end - cp >= sizeof(opt->hdr)) {
672 if ((opt = fsm_readopt(&cp)) == NULL)
675 snprintf(request, sizeof request, " %s[%d]", protoname(opt->hdr.id),
678 switch (opt->hdr.id) {
680 mp = &lcp->fsm.bundle->ncp.mp;
681 ua_ntohs(opt->data, &mru);
682 log_Printf(LogLCP, "%s %u\n", request, mru);
687 if (REJECTED(lcp, TY_MRRU))
688 /* Ignore his previous reject so that we REQ next time */
689 lcp->his_reject &= ~(1 << opt->hdr.id);
692 /* Push him down to MAX_MRU */
693 lcp->his_mrru = MAX_MRU;
694 nak.hdr.id = TY_MRRU;
696 ua_htons(&lcp->his_mrru, nak.data);
698 } else if (mru < MIN_MRU) {
699 /* Push him up to MIN_MRU */
700 lcp->his_mrru = MIN_MRU;
701 nak.hdr.id = TY_MRRU;
703 ua_htons(&lcp->his_mrru, nak.data);
712 lcp->my_reject |= (1 << opt->hdr.id);
717 if (REJECTED(lcp, TY_MRRU))
718 /* Must have changed his mind ! */
719 lcp->his_reject &= ~(1 << opt->hdr.id);
722 lcp->want_mrru = MAX_MRU;
723 else if (mru < MIN_MRU)
724 lcp->want_mrru = MIN_MRU;
726 lcp->want_mrru = mru;
728 /* else we honour our config and don't send the suggested REQ */
731 lcp->his_reject |= (1 << opt->hdr.id);
732 lcp->want_mrru = 0; /* Ah well, no multilink :-( */
739 ua_ntohs(opt->data, &mru);
740 log_Printf(LogLCP, "%s %d\n", request, mru);
744 maxmtu = p ? physical_DeviceMTU(p) : 0;
745 if (lcp->cfg.max_mtu && (!maxmtu || maxmtu > lcp->cfg.max_mtu))
746 maxmtu = lcp->cfg.max_mtu;
747 wantmtu = lcp->cfg.mtu;
748 if (maxmtu && wantmtu > maxmtu) {
749 log_Printf(LogWARN, "%s: Reducing configured MTU from %u to %u\n",
750 fp->link->name, wantmtu, maxmtu);
754 if (maxmtu && mru > maxmtu) {
755 lcp->his_mru = maxmtu;
758 ua_htons(&lcp->his_mru, nak.data);
760 } else if (wantmtu && mru < wantmtu) {
761 /* Push him up to MTU or MIN_MRU */
762 lcp->his_mru = wantmtu;
765 ua_htons(&lcp->his_mru, nak.data);
773 maxmru = p ? physical_DeviceMTU(p) : 0;
774 if (lcp->cfg.max_mru && (!maxmru || maxmru > lcp->cfg.max_mru))
775 maxmru = lcp->cfg.max_mru;
776 wantmru = lcp->cfg.mru > maxmru ? maxmru : lcp->cfg.mru;
778 if (wantmru && mru > wantmru)
779 lcp->want_mru = wantmru;
780 else if (mru > maxmru)
781 lcp->want_mru = maxmru;
782 else if (mru < MIN_MRU)
783 lcp->want_mru = MIN_MRU;
788 lcp->his_reject |= (1 << opt->hdr.id);
794 ua_ntohl(opt->data, &accmap);
795 log_Printf(LogLCP, "%s 0x%08lx\n", request, (u_long)accmap);
799 lcp->his_accmap = accmap;
803 lcp->want_accmap = accmap;
806 lcp->his_reject |= (1 << opt->hdr.id);
812 ua_ntohs(opt->data, &proto);
813 chap_type = opt->hdr.len == 5 ? opt->data[2] : 0;
815 log_Printf(LogLCP, "%s 0x%04x (%s)\n", request, proto,
816 Auth2Nam(proto, chap_type));
822 if (opt->hdr.len == 4 && IsAccepted(lcp->cfg.pap)) {
823 lcp->his_auth = proto;
824 lcp->his_authtype = 0;
826 } else if (!lcp_auth_nak(lcp, dec)) {
827 lcp->my_reject |= (1 << opt->hdr.id);
833 if ((chap_type == 0x05 && IsAccepted(lcp->cfg.chap05))
835 || (chap_type == 0x80 && (IsAccepted(lcp->cfg.chap80nt) ||
836 (IsAccepted(lcp->cfg.chap80lm))))
837 || (chap_type == 0x81 && IsAccepted(lcp->cfg.chap81))
840 lcp->his_auth = proto;
841 lcp->his_authtype = chap_type;
845 if (chap_type == 0x80) {
846 log_Printf(LogWARN, "CHAP 0x80 not available without DES\n");
847 } else if (chap_type == 0x81) {
848 log_Printf(LogWARN, "CHAP 0x81 not available without DES\n");
851 if (chap_type != 0x05)
852 log_Printf(LogWARN, "%s not supported\n",
853 Auth2Nam(PROTO_CHAP, chap_type));
855 if (!lcp_auth_nak(lcp, dec)) {
856 lcp->my_reject |= (1 << opt->hdr.id);
863 log_Printf(LogLCP, "%s 0x%04x - not recognised\n",
865 if (!lcp_auth_nak(lcp, dec)) {
866 lcp->my_reject |= (1 << opt->hdr.id);
876 if (IsEnabled(lcp->cfg.pap)) {
877 lcp->want_auth = PROTO_PAP;
878 lcp->want_authtype = 0;
880 log_Printf(LogLCP, "Peer will only send PAP (not enabled)\n");
881 lcp->his_reject |= (1 << opt->hdr.id);
885 if (chap_type == 0x05 && IsEnabled(lcp->cfg.chap05)) {
886 lcp->want_auth = PROTO_CHAP;
887 lcp->want_authtype = 0x05;
889 } else if (chap_type == 0x80 && (IsEnabled(lcp->cfg.chap80nt) ||
890 IsEnabled(lcp->cfg.chap80lm))) {
891 lcp->want_auth = PROTO_CHAP;
892 lcp->want_authtype = 0x80;
893 } else if (chap_type == 0x81 && IsEnabled(lcp->cfg.chap81)) {
894 lcp->want_auth = PROTO_CHAP;
895 lcp->want_authtype = 0x81;
899 if (chap_type == 0x80) {
900 log_Printf(LogLCP, "Peer will only send MSCHAP (not available"
902 } else if (chap_type == 0x81) {
903 log_Printf(LogLCP, "Peer will only send MSCHAPV2 (not available"
907 log_Printf(LogLCP, "Peer will only send %s (not %s)\n",
908 Auth2Nam(PROTO_CHAP, chap_type),
910 (chap_type == 0x80 || chap_type == 0x81) ? "configured" :
913 lcp->his_reject |= (1 << opt->hdr.id);
917 /* We've been NAK'd with something we don't understand :-( */
918 lcp->his_reject |= (1 << opt->hdr.id);
924 lcp->his_reject |= (1 << opt->hdr.id);
930 req = (struct lqrreq *)opt;
931 log_Printf(LogLCP, "%s proto %x, interval %lums\n",
932 request, ntohs(req->proto), (u_long)ntohl(req->period) * 10);
935 if (ntohs(req->proto) != PROTO_LQR || !IsAccepted(lcp->cfg.lqr)) {
937 lcp->my_reject |= (1 << opt->hdr.id);
939 lcp->his_lqrperiod = ntohl(req->period);
940 if (lcp->his_lqrperiod < MIN_LQRPERIOD * 100)
941 lcp->his_lqrperiod = MIN_LQRPERIOD * 100;
942 req->period = htonl(lcp->his_lqrperiod);
947 lcp->want_lqrperiod = ntohl(req->period);
950 lcp->his_reject |= (1 << opt->hdr.id);
956 ua_ntohl(opt->data, &magic);
957 log_Printf(LogLCP, "%s 0x%08lx\n", request, (u_long)magic);
961 if (lcp->want_magic) {
962 /* Validate magic number */
963 if (magic == lcp->want_magic) {
966 log_Printf(LogLCP, "Magic is same (%08lx) - %d times\n",
967 (u_long)magic, ++lcp->LcpFailedMagic);
968 lcp->want_magic = GenerateMagic();
970 ualarm(TICKUNIT * (4 + 4 * lcp->LcpFailedMagic), 0);
971 sigemptyset(&emptyset);
972 sigsuspend(&emptyset);
974 lcp->his_magic = magic;
975 lcp->LcpFailedMagic = 0;
979 lcp->my_reject |= (1 << opt->hdr.id);
984 log_Printf(LogLCP, " Magic 0x%08lx is NAKed!\n", (u_long)magic);
985 lcp->want_magic = GenerateMagic();
988 log_Printf(LogLCP, " Magic 0x%08x is REJected!\n", magic);
990 lcp->his_reject |= (1 << opt->hdr.id);
996 log_Printf(LogLCP, "%s\n", request);
1000 if (IsAccepted(lcp->cfg.protocomp)) {
1001 lcp->his_protocomp = 1;
1005 /* MorningStar before v1.3 needs NAK */
1009 lcp->my_reject |= (1 << opt->hdr.id);
1015 lcp->want_protocomp = 0;
1016 lcp->his_reject |= (1 << opt->hdr.id);
1022 log_Printf(LogLCP, "%s\n", request);
1023 switch (mode_type) {
1025 if (IsAccepted(lcp->cfg.acfcomp)) {
1026 lcp->his_acfcomp = 1;
1030 /* MorningStar before v1.3 needs NAK */
1034 lcp->my_reject |= (1 << opt->hdr.id);
1040 lcp->want_acfcomp = 0;
1041 lcp->his_reject |= (1 << opt->hdr.id);
1047 log_Printf(LogLCP, "%s\n", request);
1048 switch (mode_type) {
1057 if (opt->hdr.len == 2)
1060 op = (int)opt->data[0];
1061 sz = opt->hdr.len - 3;
1064 log_Printf(LogLCP, "%s Auth\n", request);
1066 case CALLBACK_DIALSTRING:
1067 log_Printf(LogLCP, "%s Dialstring %.*s\n", request, sz,
1070 case CALLBACK_LOCATION:
1071 log_Printf(LogLCP, "%s Location %.*s\n", request, sz, opt->data + 1);
1074 log_Printf(LogLCP, "%s E.164 (%.*s)\n", request, sz, opt->data + 1);
1077 log_Printf(LogLCP, "%s Name %.*s\n", request, sz, opt->data + 1);
1080 log_Printf(LogLCP, "%s CBCP\n", request);
1083 log_Printf(LogLCP, "%s ???\n", request);
1087 switch (mode_type) {
1090 if (p->type != PHYS_DIRECT) {
1092 lcp->my_reject |= (1 << opt->hdr.id);
1094 nak.hdr.id = opt->hdr.id;
1096 if ((p->dl->cfg.callback.opmask & CALLBACK_BIT(op)) &&
1097 (op != CALLBACK_AUTH || p->link.lcp.want_auth) &&
1098 (op != CALLBACK_E164 ||
1099 E164ok(&p->dl->cfg.callback, opt->data + 1, sz))) {
1100 lcp->his_callback.opmask = CALLBACK_BIT(op);
1101 if (sz > sizeof lcp->his_callback.msg - 1) {
1102 sz = sizeof lcp->his_callback.msg - 1;
1103 log_Printf(LogWARN, "Truncating option arg to %d octets\n", sz);
1105 memcpy(lcp->his_callback.msg, opt->data + 1, sz);
1106 lcp->his_callback.msg[sz] = '\0';
1108 } else if ((p->dl->cfg.callback.opmask & CALLBACK_BIT(CALLBACK_AUTH)) &&
1109 p->link.lcp.auth_ineed) {
1110 nak.data[0] = CALLBACK_AUTH;
1112 } else if (p->dl->cfg.callback.opmask & CALLBACK_BIT(CALLBACK_CBCP)) {
1113 nak.data[0] = CALLBACK_CBCP;
1115 } else if (p->dl->cfg.callback.opmask & CALLBACK_BIT(CALLBACK_E164)) {
1116 nak.data[0] = CALLBACK_E164;
1118 } else if (p->dl->cfg.callback.opmask & CALLBACK_BIT(CALLBACK_AUTH)) {
1119 log_Printf(LogWARN, "Cannot insist on auth callback without"
1120 " PAP or CHAP enabled !\n");
1124 lcp->my_reject |= (1 << opt->hdr.id);
1129 /* We don't do what he NAKs with, we do things in our preferred order */
1130 if (lcp->want_callback.opmask & CALLBACK_BIT(CALLBACK_AUTH))
1131 lcp->want_callback.opmask &= ~CALLBACK_BIT(CALLBACK_AUTH);
1132 else if (lcp->want_callback.opmask & CALLBACK_BIT(CALLBACK_CBCP))
1133 lcp->want_callback.opmask &= ~CALLBACK_BIT(CALLBACK_CBCP);
1134 else if (lcp->want_callback.opmask & CALLBACK_BIT(CALLBACK_E164))
1135 lcp->want_callback.opmask &= ~CALLBACK_BIT(CALLBACK_E164);
1136 if (lcp->want_callback.opmask == CALLBACK_BIT(CALLBACK_NONE)) {
1137 log_Printf(LogPHASE, "Peer NAKd all callbacks, trying none\n");
1138 lcp->want_callback.opmask = 0;
1139 } else if (!lcp->want_callback.opmask) {
1140 log_Printf(LogPHASE, "Peer NAKd last configured callback\n");
1141 fsm_Close(&lcp->fsm);
1145 if (lcp->want_callback.opmask & CALLBACK_BIT(CALLBACK_NONE)) {
1146 lcp->his_reject |= (1 << opt->hdr.id);
1147 lcp->want_callback.opmask = 0;
1149 log_Printf(LogPHASE, "Peer rejected *required* callback\n");
1150 fsm_Close(&lcp->fsm);
1157 mp = &lcp->fsm.bundle->ncp.mp;
1158 log_Printf(LogLCP, "%s\n", request);
1160 switch (mode_type) {
1162 if (lcp->want_mrru && IsAccepted(mp->cfg.shortseq)) {
1163 lcp->his_shortseq = 1;
1167 lcp->my_reject |= (1 << opt->hdr.id);
1172 * He's trying to get us to ask for short sequence numbers.
1173 * We ignore the NAK and honour our configuration file instead.
1177 lcp->his_reject |= (1 << opt->hdr.id);
1178 lcp->want_shortseq = 0; /* For when we hit MP */
1184 mp = &lcp->fsm.bundle->ncp.mp;
1185 log_Printf(LogLCP, "%s %s\n", request,
1186 mp_Enddisc(opt->data[0], opt->data + 1, opt->hdr.len - 3));
1187 switch (mode_type) {
1190 log_Printf(LogLCP, " ENDDISC rejected - not a physical link\n");
1192 lcp->my_reject |= (1 << opt->hdr.id);
1193 } else if (!IsAccepted(mp->cfg.negenddisc)) {
1194 lcp->my_reject |= (1 << opt->hdr.id);
1196 } else if (opt->hdr.len - 3 < sizeof p->dl->peer.enddisc.address &&
1197 opt->data[0] <= MAX_ENDDISC_CLASS) {
1198 p->dl->peer.enddisc.class = opt->data[0];
1199 p->dl->peer.enddisc.len = opt->hdr.len - 3;
1200 memcpy(p->dl->peer.enddisc.address, opt->data + 1, opt->hdr.len - 3);
1201 p->dl->peer.enddisc.address[opt->hdr.len - 3] = '\0';
1202 /* XXX: If mp->active, compare and NAK with mp->peer ? */
1205 if (opt->data[0] > MAX_ENDDISC_CLASS)
1206 log_Printf(LogLCP, " ENDDISC rejected - unrecognised class %d\n",
1209 log_Printf(LogLCP, " ENDDISC rejected - local max length is %ld\n",
1210 (long)(sizeof p->dl->peer.enddisc.address - 1));
1212 lcp->my_reject |= (1 << opt->hdr.id);
1216 case MODE_NAK: /* Treat this as a REJ, we don't vary our disc (yet) */
1218 lcp->his_reject |= (1 << opt->hdr.id);
1224 sz = (sizeof desc - 2) / 2;
1225 if (sz > opt->hdr.len - 2)
1226 sz = opt->hdr.len - 2;
1228 desc[0] = sz ? ' ' : '\0';
1229 for (pos = 0; sz--; pos++)
1230 sprintf(desc+(pos<<1)+1, "%02x", opt->data[pos]);
1232 log_Printf(LogLCP, "%s%s\n", request, desc);
1234 if (mode_type == MODE_REQ) {
1236 lcp->my_reject |= (1 << opt->hdr.id);
1242 if (mode_type != MODE_NOP) {
1243 if (mode_type == MODE_REQ && p && p->type == PHYS_DIRECT &&
1244 p->dl->cfg.callback.opmask && !callback_req &&
1245 !(p->dl->cfg.callback.opmask & CALLBACK_BIT(CALLBACK_NONE))) {
1246 /* We *REQUIRE* that the peer requests callback */
1247 nak.hdr.id = TY_CALLBACK;
1249 if ((p->dl->cfg.callback.opmask & CALLBACK_BIT(CALLBACK_AUTH)) &&
1250 p->link.lcp.want_auth)
1251 nak.data[0] = CALLBACK_AUTH;
1252 else if (p->dl->cfg.callback.opmask & CALLBACK_BIT(CALLBACK_CBCP))
1253 nak.data[0] = CALLBACK_CBCP;
1254 else if (p->dl->cfg.callback.opmask & CALLBACK_BIT(CALLBACK_E164))
1255 nak.data[0] = CALLBACK_E164;
1257 log_Printf(LogWARN, "Cannot insist on auth callback without"
1258 " PAP or CHAP enabled !\n");
1259 nak.hdr.len = 2; /* XXX: Silly ! */
1263 if (mode_type == MODE_REQ && !lcp->mru_req) {
1265 phmtu = p ? physical_DeviceMTU(p) : 0;
1266 if (phmtu && mru > phmtu)
1268 if (mru > lcp->cfg.max_mtu)
1269 mru = lcp->cfg.max_mtu;
1270 if (mru < DEF_MRU) {
1271 /* Don't let the peer use the default MRU */
1272 lcp->his_mru = lcp->cfg.mtu && lcp->cfg.mtu < mru ? lcp->cfg.mtu : mru;
1273 nak.hdr.id = TY_MRU;
1275 ua_htons(&lcp->his_mru, nak.data);
1277 lcp->mru_req = 1; /* Don't keep NAK'ing this */
1280 fsm_opt_normalise(dec);
1284 extern struct mbuf *
1285 lcp_Input(struct bundle *bundle, struct link *l, struct mbuf *bp)
1287 /* Got PROTO_LCP from link */
1288 m_settype(bp, MB_LCPIN);
1289 fsm_Input(&l->lcp.fsm, bp);