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