2 * Copyright (c) 2001 Brian Somers <brian@Awfulhak.org>
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
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.
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
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>
52 #include "throughput.h"
53 #include "slcompress.h"
60 #include "descriptor.h"
82 static u_short default_urgent_tcp_ports
[] = {
92 #define NDEFTCPPORTS \
93 (sizeof default_urgent_tcp_ports / sizeof default_urgent_tcp_ports[0])
96 ncp_Init(struct ncp
*ncp
, struct bundle
*bundle
)
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;
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
));
110 ncp
->cfg
.urgent
.tos
= 1;
112 ncp
->cfg
.urgent
.udp
.nports
= ncp
->cfg
.urgent
.udp
.maxports
= 0;
113 ncp
->cfg
.urgent
.udp
.port
= NULL
;
115 mp_Init(&ncp
->mp
, bundle
);
117 /* Send over the first physical link by default */
118 ipcp_Init(&ncp
->ipcp
, bundle
, &bundle
->links
->physical
->link
,
121 ipv6cp_Init(&ncp
->ipv6cp
, bundle
, &bundle
->links
->physical
->link
,
127 ncp_Destroy(struct ncp
*ncp
)
129 ipcp_Destroy(&ncp
->ipcp
);
131 ipv6cp_Destroy(&ncp
->ipv6cp
);
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
;
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
;
147 ncp_fsmStart(struct ncp
*ncp
,
149 struct bundle
*bundle __unused
151 struct bundle
*bundle
158 if (Enabled(bundle
, OPT_IPCP
)) {
160 fsm_Up(&ncp
->ipcp
.fsm
);
161 fsm_Open(&ncp
->ipcp
.fsm
);
166 if (Enabled(bundle
, OPT_IPV6CP
)) {
167 fsm_Up(&ncp
->ipv6cp
.fsm
);
168 fsm_Open(&ncp
->ipv6cp
.fsm
);
177 ncp_IfaceAddrAdded(struct ncp
*ncp
, const struct iface_addr
*addr
)
179 switch (ncprange_family(&addr
->ifa
)) {
181 ipcp_IfaceAddrAdded(&ncp
->ipcp
, addr
);
185 ipv6cp_IfaceAddrAdded(&ncp
->ipv6cp
, addr
);
192 ncp_IfaceAddrDeleted(struct ncp
*ncp
, const struct iface_addr
*addr
)
194 if (ncprange_family(&addr
->ifa
) == AF_INET
)
195 ipcp_IfaceAddrDeleted(&ncp
->ipcp
, addr
);
199 ncp_SetLink(struct ncp
*ncp
, struct link
*l
)
201 ipcp_SetLink(&ncp
->ipcp
, l
);
203 ipv6cp_SetLink(&ncp
->ipv6cp
, l
);
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.
212 ncp_Enqueue(struct ncp
*ncp
, int af
, unsigned pri
, char *ptr
, int count
)
215 struct ipv6cp
*ipv6cp
= &ncp
->ipv6cp
;
217 struct ipcp
*ipcp
= &ncp
->ipcp
;
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().
229 if (pri
>= IPCP_QUEUES(ipcp
)) {
230 log_Printf(LogERROR
, "Can't store in ip queue %u\n", pri
);
234 bp
= m_get(count
+ 6, MB_IPOUT
);
237 memcpy(MBUF_CTOP(bp
), ptr
, count
);
238 m_enqueue(ipcp
->Queue
+ pri
, bp
);
243 if (pri
>= IPV6CP_QUEUES(ipcp
)) {
244 log_Printf(LogERROR
, "Can't store in ipv6 queue %u\n", pri
);
248 bp
= m_get(count
+ 6, MB_IPOUT
);
251 memcpy(MBUF_CTOP(bp
), ptr
, count
);
252 m_enqueue(ipv6cp
->Queue
+ pri
, bp
);
257 log_Printf(LogERROR
, "Can't enqueue protocol family %d\n", af
);
262 * How many packets are queued to go out ?
265 ncp_QueueLen(struct ncp
*ncp
)
269 result
= ipcp_QueueLen(&ncp
->ipcp
);
271 result
+= ipv6cp_QueueLen(&ncp
->ipv6cp
);
273 result
+= mp_QueueLen(&ncp
->mp
); /* Usually empty */
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.
284 ncp_DeleteQueues(struct ncp
*ncp
)
287 struct ipv6cp
*ipv6cp
= &ncp
->ipv6cp
;
289 struct ipcp
*ipcp
= &ncp
->ipcp
;
290 struct mp
*mp
= &ncp
->mp
;
293 for (q
= ipcp
->Queue
; q
< ipcp
->Queue
+ IPCP_QUEUES(ipcp
); q
++)
295 m_freem(m_dequeue(q
));
298 for (q
= ipv6cp
->Queue
; q
< ipv6cp
->Queue
+ IPV6CP_QUEUES(ipv6cp
); q
++)
300 m_freem(m_dequeue(q
));
303 link_DeleteQueue(&mp
->link
); /* Usually empty anyway */
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
313 ncp_FillPhysicalQueues(struct ncp
*ncp
, struct bundle
*bundle
)
317 if (bundle
->ncp
.mp
.active
)
318 total
= mp_FillPhysicalQueues(bundle
);
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
);
332 return total
+ ncp_QueueLen(&bundle
->ncp
);
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.
340 ncp_PushPacket(struct ncp
*ncp __unused
,
348 struct bundle
*bundle
= l
->lcp
.fsm
.bundle
;
352 if (*af
== AF_INET
) {
353 if ((res
= ipcp_PushPacket(&bundle
->ncp
.ipcp
, l
)))
356 res
= ipv6cp_PushPacket(&bundle
->ncp
.ipv6cp
, l
);
358 if ((res
= ipv6cp_PushPacket(&bundle
->ncp
.ipv6cp
, l
)))
361 res
= ipcp_PushPacket(&bundle
->ncp
.ipcp
, l
);
364 res
= ipcp_PushPacket(&bundle
->ncp
.ipcp
, l
);
371 ncp_IsUrgentPort(struct port_range
*range
, u_short src
, u_short dst
)
375 for (f
= 0; f
< range
->nports
; f
++)
376 if (range
->port
[f
] == src
|| range
->port
[f
] == dst
)
383 ncp_AddUrgentPort(struct port_range
*range
, u_short port
)
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",
395 range
->maxports
-= 10;
398 range
->port
= newport
;
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
);
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
;
413 if (p
== range
->nports
)
414 range
->port
[range
->nports
++] = port
;
418 ncp_RemoveUrgentPort(struct port_range
*range
, u_short port
)
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
));
431 if (p
== range
->nports
)
432 log_Printf(LogWARN
, "%u: Port not set to urgent\n", port
);
436 ncp_ClearUrgentPorts(struct port_range
*range
)
442 ncp_Show(struct cmdargs
const *arg
)
444 struct ncp
*ncp
= &arg
->bundle
->ncp
;
448 prompt_Printf(arg
->prompt
, "Next queued AF: %s\n",
449 ncp
->afq
== AF_INET6
? "inet6" : "inet");
453 prompt_Printf(arg
->prompt
, "\n");
454 route_ShowSticky(arg
->prompt
, ncp
->route
, "Sticky routes", 1);
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
);
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
);
467 prompt_Printf(arg
->prompt
, "unspecified\n");
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");
474 for (p
= 0; p
< ncp
->cfg
.urgent
.tcp
.nports
; p
++) {
476 prompt_Printf(arg
->prompt
, ", ");
477 prompt_Printf(arg
->prompt
, "%u", ncp
->cfg
.urgent
.tcp
.port
[p
]);
480 prompt_Printf(arg
->prompt
, "\n UDP: ");
481 if (ncp
->cfg
.urgent
.udp
.nports
== 0)
482 prompt_Printf(arg
->prompt
, "none");
484 for (p
= 0; p
< ncp
->cfg
.urgent
.udp
.nports
; p
++) {
486 prompt_Printf(arg
->prompt
, ", ");
487 prompt_Printf(arg
->prompt
, "%u", ncp
->cfg
.urgent
.udp
.port
[p
]);
489 prompt_Printf(arg
->prompt
, "\n TOS: %s\n\n",
490 ncp
->cfg
.urgent
.tos
? "yes" : "no");
496 ncp_LayersOpen(struct ncp
*ncp
)
500 n
= !!(ncp
->ipcp
.fsm
.state
== ST_OPENED
);
502 n
+= !!(ncp
->ipv6cp
.fsm
.state
== ST_OPENED
);
509 ncp_LayersUnfinished(struct ncp
*ncp
)
513 if (ncp
->ipcp
.fsm
.state
> ST_CLOSED
||
514 ncp
->ipcp
.fsm
.state
== ST_STARTING
)
518 if (ncp
->ipv6cp
.fsm
.state
> ST_CLOSED
||
519 ncp
->ipv6cp
.fsm
.state
== ST_STARTING
)
527 ncp_Close(struct ncp
*ncp
)
529 if (ncp
->ipcp
.fsm
.state
> ST_CLOSED
||
530 ncp
->ipcp
.fsm
.state
== ST_STARTING
)
531 fsm_Close(&ncp
->ipcp
.fsm
);
534 if (ncp
->ipv6cp
.fsm
.state
> ST_CLOSED
||
535 ncp
->ipv6cp
.fsm
.state
== ST_STARTING
)
536 fsm_Close(&ncp
->ipv6cp
.fsm
);
541 ncp2initial(struct ncp
*ncp
)
543 fsm2initial(&ncp
->ipcp
.fsm
);
545 fsm2initial(&ncp
->ipv6cp
.fsm
);