1 /*- 2 * Copyright (c) 2001 Brian Somers <brian@Awfulhak.org> 3 * All rights reserved. 4 * 5 * Redistribution and use in source and binary forms, with or without 6 * modification, are permitted provided that the following conditions 7 * are met: 8 * 1. Redistributions of source code must retain the above copyright 9 * notice, this list of conditions and the following disclaimer. 10 * 2. Redistributions in binary form must reproduce the above copyright 11 * notice, this list of conditions and the following disclaimer in the 12 * documentation and/or other materials provided with the distribution. 13 * 14 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 15 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 16 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 17 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 18 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 19 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 20 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 21 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 22 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 23 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 24 * SUCH DAMAGE. 25 * 26 * $FreeBSD: src/usr.sbin/ppp/ncp.c,v 1.5.2.1 2002/09/01 02:12:29 brian Exp $ 27 * $DragonFly: src/usr.sbin/ppp/ncp.c,v 1.2 2003/06/17 04:30:00 dillon Exp $ 28 */ 29 30 #include <sys/param.h> 31 #include <netinet/in_systm.h> 32 #include <netinet/in.h> 33 #include <netinet/ip.h> 34 #include <sys/socket.h> 35 #include <net/route.h> 36 #include <sys/un.h> 37 38 #include <errno.h> 39 #include <resolv.h> 40 #include <stdarg.h> 41 #include <stdlib.h> 42 #include <string.h> 43 #include <termios.h> 44 45 #include "layer.h" 46 #include "defs.h" 47 #include "command.h" 48 #include "mbuf.h" 49 #include "log.h" 50 #include "timer.h" 51 #include "fsm.h" 52 #include "iplist.h" 53 #include "throughput.h" 54 #include "slcompress.h" 55 #include "lqr.h" 56 #include "hdlc.h" 57 #include "lcp.h" 58 #include "ncpaddr.h" 59 #include "ipcp.h" 60 #include "filter.h" 61 #include "descriptor.h" 62 #include "async.h" 63 #include "ccp.h" 64 #include "link.h" 65 #include "physical.h" 66 #include "mp.h" 67 #ifndef NORADIUS 68 #include "radius.h" 69 #endif 70 #include "ipv6cp.h" 71 #include "ncp.h" 72 #include "bundle.h" 73 #include "prompt.h" 74 #include "route.h" 75 #include "iface.h" 76 #include "chat.h" 77 #include "auth.h" 78 #include "chap.h" 79 #include "cbcp.h" 80 #include "datalink.h" 81 82 83 static u_short default_urgent_tcp_ports[] = { 84 21, /* ftp */ 85 22, /* ssh */ 86 23, /* telnet */ 87 513, /* login */ 88 514, /* shell */ 89 543, /* klogin */ 90 544 /* kshell */ 91 }; 92 93 static u_short default_urgent_udp_ports[] = { }; 94 95 #define NDEFTCPPORTS \ 96 (sizeof default_urgent_tcp_ports / sizeof default_urgent_tcp_ports[0]) 97 #define NDEFUDPPORTS \ 98 (sizeof default_urgent_udp_ports / sizeof default_urgent_udp_ports[0]) 99 100 void 101 ncp_Init(struct ncp *ncp, struct bundle *bundle) 102 { 103 ncp->afq = AF_INET; 104 ncp->route = NULL; 105 106 ncp->cfg.urgent.tcp.nports = ncp->cfg.urgent.tcp.maxports = NDEFTCPPORTS; 107 ncp->cfg.urgent.tcp.port = (u_short *)malloc(NDEFTCPPORTS * sizeof(u_short)); 108 memcpy(ncp->cfg.urgent.tcp.port, default_urgent_tcp_ports, 109 NDEFTCPPORTS * sizeof(u_short)); 110 ncp->cfg.urgent.tos = 1; 111 112 ncp->cfg.urgent.udp.nports = ncp->cfg.urgent.udp.maxports = NDEFUDPPORTS; 113 ncp->cfg.urgent.udp.port = (u_short *)malloc(NDEFUDPPORTS * sizeof(u_short)); 114 memcpy(ncp->cfg.urgent.udp.port, default_urgent_udp_ports, 115 NDEFUDPPORTS * sizeof(u_short)); 116 117 118 mp_Init(&ncp->mp, bundle); 119 120 /* Send over the first physical link by default */ 121 ipcp_Init(&ncp->ipcp, bundle, &bundle->links->physical->link, 122 &bundle->fsm); 123 #ifndef NOINET6 124 ipv6cp_Init(&ncp->ipv6cp, bundle, &bundle->links->physical->link, 125 &bundle->fsm); 126 #endif 127 } 128 129 void 130 ncp_Destroy(struct ncp *ncp) 131 { 132 ipcp_Destroy(&ncp->ipcp); 133 #ifndef NOINET6 134 ipv6cp_Destroy(&ncp->ipv6cp); 135 #endif 136 137 if (ncp->cfg.urgent.tcp.maxports) { 138 ncp->cfg.urgent.tcp.nports = ncp->cfg.urgent.tcp.maxports = 0; 139 free(ncp->cfg.urgent.tcp.port); 140 ncp->cfg.urgent.tcp.port = NULL; 141 } 142 if (ncp->cfg.urgent.udp.maxports) { 143 ncp->cfg.urgent.udp.nports = ncp->cfg.urgent.udp.maxports = 0; 144 free(ncp->cfg.urgent.udp.port); 145 ncp->cfg.urgent.udp.port = NULL; 146 } 147 } 148 149 int 150 ncp_fsmStart(struct ncp *ncp, struct bundle *bundle) 151 { 152 int res = 0; 153 154 #ifndef NOINET6 155 if (Enabled(bundle, OPT_IPCP)) { 156 #endif 157 fsm_Up(&ncp->ipcp.fsm); 158 fsm_Open(&ncp->ipcp.fsm); 159 res++; 160 #ifndef NOINET6 161 } 162 163 if (Enabled(bundle, OPT_IPV6CP)) { 164 fsm_Up(&ncp->ipv6cp.fsm); 165 fsm_Open(&ncp->ipv6cp.fsm); 166 res++; 167 } 168 #endif 169 170 return res; 171 } 172 173 void 174 ncp_IfaceAddrAdded(struct ncp *ncp, const struct iface_addr *addr) 175 { 176 switch (ncprange_family(&addr->ifa)) { 177 case AF_INET: 178 ipcp_IfaceAddrAdded(&ncp->ipcp, addr); 179 break; 180 #ifndef NOINET6 181 case AF_INET6: 182 ipv6cp_IfaceAddrAdded(&ncp->ipv6cp, addr); 183 break; 184 #endif 185 } 186 } 187 188 void 189 ncp_IfaceAddrDeleted(struct ncp *ncp, const struct iface_addr *addr) 190 { 191 if (ncprange_family(&addr->ifa) == AF_INET) 192 ipcp_IfaceAddrDeleted(&ncp->ipcp, addr); 193 } 194 195 void 196 ncp_SetLink(struct ncp *ncp, struct link *l) 197 { 198 ipcp_SetLink(&ncp->ipcp, l); 199 #ifndef NOINET6 200 ipv6cp_SetLink(&ncp->ipv6cp, l); 201 #endif 202 } 203 204 /* 205 * Enqueue a packet of the given address family. Nothing will make it 206 * down to the physical link level 'till ncp_FillPhysicalQueues() is used. 207 */ 208 void 209 ncp_Enqueue(struct ncp *ncp, int af, int pri, char *ptr, int count) 210 { 211 #ifndef NOINET6 212 struct ipv6cp *ipv6cp = &ncp->ipv6cp; 213 #endif 214 struct ipcp *ipcp = &ncp->ipcp; 215 struct mbuf *bp; 216 217 /* 218 * We allocate an extra 6 bytes, four at the front and two at the end. 219 * This is an optimisation so that we need to do less work in 220 * m_prepend() in acf_LayerPush() and proto_LayerPush() and 221 * appending in hdlc_LayerPush(). 222 */ 223 224 switch (af) { 225 case AF_INET: 226 if (pri < 0 || pri >= IPCP_QUEUES(ipcp)) { 227 log_Printf(LogERROR, "Can't store in ip queue %d\n", pri); 228 break; 229 } 230 231 bp = m_get(count + 6, MB_IPOUT); 232 bp->m_offset += 4; 233 bp->m_len -= 6; 234 memcpy(MBUF_CTOP(bp), ptr, count); 235 m_enqueue(ipcp->Queue + pri, bp); 236 break; 237 238 #ifndef NOINET6 239 case AF_INET6: 240 if (pri < 0 || pri >= IPV6CP_QUEUES(ipcp)) { 241 log_Printf(LogERROR, "Can't store in ipv6 queue %d\n", pri); 242 break; 243 } 244 245 bp = m_get(count + 6, MB_IPOUT); 246 bp->m_offset += 4; 247 bp->m_len -= 6; 248 memcpy(MBUF_CTOP(bp), ptr, count); 249 m_enqueue(ipv6cp->Queue + pri, bp); 250 break; 251 #endif 252 253 default: 254 log_Printf(LogERROR, "Can't enqueue protocol family %d\n", af); 255 } 256 } 257 258 /* 259 * How many packets are queued to go out ? 260 */ 261 size_t 262 ncp_QueueLen(struct ncp *ncp) 263 { 264 size_t result; 265 266 result = ipcp_QueueLen(&ncp->ipcp); 267 #ifndef NOINET6 268 result += ipv6cp_QueueLen(&ncp->ipv6cp); 269 #endif 270 result += mp_QueueLen(&ncp->mp); /* Usually empty */ 271 272 return result; 273 } 274 275 /* 276 * Ditch all queued packets. This is usually done after our choked timer 277 * has fired - which happens because we couldn't send any traffic over 278 * any links for some time. 279 */ 280 void 281 ncp_DeleteQueues(struct ncp *ncp) 282 { 283 #ifndef NOINET6 284 struct ipv6cp *ipv6cp = &ncp->ipv6cp; 285 #endif 286 struct ipcp *ipcp = &ncp->ipcp; 287 struct mp *mp = &ncp->mp; 288 struct mqueue *q; 289 290 for (q = ipcp->Queue; q < ipcp->Queue + IPCP_QUEUES(ipcp); q++) 291 while (q->top) 292 m_freem(m_dequeue(q)); 293 294 #ifndef NOINET6 295 for (q = ipv6cp->Queue; q < ipv6cp->Queue + IPV6CP_QUEUES(ipv6cp); q++) 296 while (q->top) 297 m_freem(m_dequeue(q)); 298 #endif 299 300 link_DeleteQueue(&mp->link); /* Usually empty anyway */ 301 } 302 303 /* 304 * Arrange that each of our links has at least one packet. We keep the 305 * number of packets queued at the link level to a minimum so that the 306 * loss of a link in multi-link mode results in the minimum number of 307 * dropped packets. 308 */ 309 size_t 310 ncp_FillPhysicalQueues(struct ncp *ncp, struct bundle *bundle) 311 { 312 size_t total; 313 314 if (bundle->ncp.mp.active) 315 total = mp_FillPhysicalQueues(bundle); 316 else { 317 struct datalink *dl; 318 size_t add; 319 320 for (total = 0, dl = bundle->links; dl; dl = dl->next) 321 if (dl->state == DATALINK_OPEN) { 322 add = link_QueueLen(&dl->physical->link); 323 if (add == 0 && dl->physical->out == NULL) 324 add = ncp_PushPacket(ncp, &ncp->afq, &dl->physical->link); 325 total += add; 326 } 327 } 328 329 return total + ncp_QueueLen(&bundle->ncp); 330 } 331 332 /* 333 * Push a packet into the given link. ``af'' is used as a persistent record 334 * of what is to be pushed next, coming either from mp->out or ncp->afq. 335 */ 336 int 337 ncp_PushPacket(struct ncp *ncp, int *af, struct link *l) 338 { 339 struct bundle *bundle = l->lcp.fsm.bundle; 340 int res; 341 342 #ifndef NOINET6 343 if (*af == AF_INET) { 344 if ((res = ipcp_PushPacket(&bundle->ncp.ipcp, l))) 345 *af = AF_INET6; 346 else 347 res = ipv6cp_PushPacket(&bundle->ncp.ipv6cp, l); 348 } else { 349 if ((res = ipv6cp_PushPacket(&bundle->ncp.ipv6cp, l))) 350 *af = AF_INET; 351 else 352 res = ipcp_PushPacket(&bundle->ncp.ipcp, l); 353 } 354 #else 355 res = ipcp_PushPacket(&bundle->ncp.ipcp, l); 356 #endif 357 358 return res; 359 } 360 361 int 362 ncp_IsUrgentPort(struct port_range *range, u_short src, u_short dst) 363 { 364 int f; 365 366 for (f = 0; f < range->nports; f++) 367 if (range->port[f] == src || range->port[f] == dst) 368 return 1; 369 370 return 0; 371 } 372 373 void 374 ncp_AddUrgentPort(struct port_range *range, u_short port) 375 { 376 u_short *newport; 377 int p; 378 379 if (range->nports == range->maxports) { 380 range->maxports += 10; 381 newport = (u_short *)realloc(range->port, 382 range->maxports * sizeof(u_short)); 383 if (newport == NULL) { 384 log_Printf(LogERROR, "ncp_AddUrgentPort: realloc: %s\n", 385 strerror(errno)); 386 range->maxports -= 10; 387 return; 388 } 389 range->port = newport; 390 } 391 392 for (p = 0; p < range->nports; p++) 393 if (range->port[p] == port) { 394 log_Printf(LogWARN, "%u: Port already set to urgent\n", port); 395 break; 396 } else if (range->port[p] > port) { 397 memmove(range->port + p + 1, range->port + p, 398 (range->nports - p) * sizeof(u_short)); 399 range->port[p] = port; 400 range->nports++; 401 break; 402 } 403 404 if (p == range->nports) 405 range->port[range->nports++] = port; 406 } 407 408 void 409 ncp_RemoveUrgentPort(struct port_range *range, u_short port) 410 { 411 int p; 412 413 for (p = 0; p < range->nports; p++) 414 if (range->port[p] == port) { 415 if (p != range->nports - 1) 416 memmove(range->port + p, range->port + p + 1, 417 (range->nports - p - 1) * sizeof(u_short)); 418 range->nports--; 419 return; 420 } 421 422 if (p == range->nports) 423 log_Printf(LogWARN, "%u: Port not set to urgent\n", port); 424 } 425 426 void 427 ncp_ClearUrgentPorts(struct port_range *range) 428 { 429 range->nports = 0; 430 } 431 432 int 433 ncp_Show(struct cmdargs const *arg) 434 { 435 struct ncp *ncp = &arg->bundle->ncp; 436 int p; 437 438 #ifndef NOINET6 439 prompt_Printf(arg->prompt, "Next queued AF: %s\n", 440 ncp->afq == AF_INET6 ? "inet6" : "inet"); 441 #endif 442 443 if (ncp->route) { 444 prompt_Printf(arg->prompt, "\n"); 445 route_ShowSticky(arg->prompt, ncp->route, "Sticky routes", 1); 446 } 447 448 prompt_Printf(arg->prompt, "\nDefaults:\n"); 449 prompt_Printf(arg->prompt, " sendpipe: "); 450 if (ncp->cfg.sendpipe > 0) 451 prompt_Printf(arg->prompt, "%-20ld\n", ncp->cfg.sendpipe); 452 else 453 prompt_Printf(arg->prompt, "unspecified\n"); 454 prompt_Printf(arg->prompt, " recvpipe: "); 455 if (ncp->cfg.recvpipe > 0) 456 prompt_Printf(arg->prompt, "%ld\n", ncp->cfg.recvpipe); 457 else 458 prompt_Printf(arg->prompt, "unspecified\n"); 459 460 prompt_Printf(arg->prompt, "\n Urgent ports\n"); 461 prompt_Printf(arg->prompt, " TCP: "); 462 if (ncp->cfg.urgent.tcp.nports == 0) 463 prompt_Printf(arg->prompt, "none"); 464 else 465 for (p = 0; p < ncp->cfg.urgent.tcp.nports; p++) { 466 if (p) 467 prompt_Printf(arg->prompt, ", "); 468 prompt_Printf(arg->prompt, "%u", ncp->cfg.urgent.tcp.port[p]); 469 } 470 471 prompt_Printf(arg->prompt, "\n UDP: "); 472 if (ncp->cfg.urgent.udp.nports == 0) 473 prompt_Printf(arg->prompt, "none"); 474 else 475 for (p = 0; p < ncp->cfg.urgent.udp.nports; p++) { 476 if (p) 477 prompt_Printf(arg->prompt, ", "); 478 prompt_Printf(arg->prompt, "%u", ncp->cfg.urgent.udp.port[p]); 479 } 480 prompt_Printf(arg->prompt, "\n TOS: %s\n\n", 481 ncp->cfg.urgent.tos ? "yes" : "no"); 482 483 return 0; 484 } 485 486 int 487 ncp_LayersOpen(struct ncp *ncp) 488 { 489 int n; 490 491 n = !!(ncp->ipcp.fsm.state == ST_OPENED); 492 #ifndef NOINET6 493 n += !!(ncp->ipv6cp.fsm.state == ST_OPENED); 494 #endif 495 496 return n; 497 } 498 499 int 500 ncp_LayersUnfinished(struct ncp *ncp) 501 { 502 int n = 0; 503 504 if (ncp->ipcp.fsm.state > ST_CLOSED || 505 ncp->ipcp.fsm.state == ST_STARTING) 506 n++; 507 508 #ifndef NOINET6 509 if (ncp->ipv6cp.fsm.state > ST_CLOSED || 510 ncp->ipv6cp.fsm.state == ST_STARTING) 511 n++; 512 #endif 513 514 return n; 515 } 516 517 void 518 ncp_Close(struct ncp *ncp) 519 { 520 if (ncp->ipcp.fsm.state > ST_CLOSED || 521 ncp->ipcp.fsm.state == ST_STARTING) 522 fsm_Close(&ncp->ipcp.fsm); 523 524 #ifndef NOINET6 525 if (ncp->ipv6cp.fsm.state > ST_CLOSED || 526 ncp->ipv6cp.fsm.state == ST_STARTING) 527 fsm_Close(&ncp->ipv6cp.fsm); 528 #endif 529 } 530 531 void 532 ncp2initial(struct ncp *ncp) 533 { 534 fsm2initial(&ncp->ipcp.fsm); 535 #ifndef NOINET6 536 fsm2initial(&ncp->ipv6cp.fsm); 537 #endif 538 } 539