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