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