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