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