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