usr.sbin/ppp/ncp.c

   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 }