xref: /freebsd/sys/netgraph/ng_ppp.c (revision ccb07cc3db7d605e3fcb072f6c6a24249b46ffc3)
14cf49a43SJulian Elischer /*
24cf49a43SJulian Elischer  * ng_ppp.c
3c398230bSWarner Losh  */
4c398230bSWarner Losh 
5c398230bSWarner Losh /*-
6a9b3dca5SArchie Cobbs  * Copyright (c) 1996-2000 Whistle Communications, Inc.
74cf49a43SJulian Elischer  * All rights reserved.
84cf49a43SJulian Elischer  *
94cf49a43SJulian Elischer  * Subject to the following obligations and disclaimer of warranty, use and
104cf49a43SJulian Elischer  * redistribution of this software, in source or object code forms, with or
114cf49a43SJulian Elischer  * without modifications are expressly permitted by Whistle Communications;
124cf49a43SJulian Elischer  * provided, however, that:
134cf49a43SJulian Elischer  * 1. Any and all reproductions of the source or object code must include the
144cf49a43SJulian Elischer  *    copyright notice above and the following disclaimer of warranties; and
154cf49a43SJulian Elischer  * 2. No rights are granted, in any manner or form, to use Whistle
164cf49a43SJulian Elischer  *    Communications, Inc. trademarks, including the mark "WHISTLE
174cf49a43SJulian Elischer  *    COMMUNICATIONS" on advertising, endorsements, or otherwise except as
184cf49a43SJulian Elischer  *    such appears in the above copyright notice or in the software.
194cf49a43SJulian Elischer  *
204cf49a43SJulian Elischer  * THIS SOFTWARE IS BEING PROVIDED BY WHISTLE COMMUNICATIONS "AS IS", AND
214cf49a43SJulian Elischer  * TO THE MAXIMUM EXTENT PERMITTED BY LAW, WHISTLE COMMUNICATIONS MAKES NO
224cf49a43SJulian Elischer  * REPRESENTATIONS OR WARRANTIES, EXPRESS OR IMPLIED, REGARDING THIS SOFTWARE,
234cf49a43SJulian Elischer  * INCLUDING WITHOUT LIMITATION, ANY AND ALL IMPLIED WARRANTIES OF
244cf49a43SJulian Elischer  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, OR NON-INFRINGEMENT.
254cf49a43SJulian Elischer  * WHISTLE COMMUNICATIONS DOES NOT WARRANT, GUARANTEE, OR MAKE ANY
264cf49a43SJulian Elischer  * REPRESENTATIONS REGARDING THE USE OF, OR THE RESULTS OF THE USE OF THIS
274cf49a43SJulian Elischer  * SOFTWARE IN TERMS OF ITS CORRECTNESS, ACCURACY, RELIABILITY OR OTHERWISE.
284cf49a43SJulian Elischer  * IN NO EVENT SHALL WHISTLE COMMUNICATIONS BE LIABLE FOR ANY DAMAGES
294cf49a43SJulian Elischer  * RESULTING FROM OR ARISING OUT OF ANY USE OF THIS SOFTWARE, INCLUDING
304cf49a43SJulian Elischer  * WITHOUT LIMITATION, ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY,
314cf49a43SJulian Elischer  * PUNITIVE, OR CONSEQUENTIAL DAMAGES, PROCUREMENT OF SUBSTITUTE GOODS OR
324cf49a43SJulian Elischer  * SERVICES, LOSS OF USE, DATA OR PROFITS, HOWEVER CAUSED AND UNDER ANY
334cf49a43SJulian Elischer  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
344cf49a43SJulian Elischer  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
354cf49a43SJulian Elischer  * THIS SOFTWARE, EVEN IF WHISTLE COMMUNICATIONS IS ADVISED OF THE POSSIBILITY
364cf49a43SJulian Elischer  * OF SUCH DAMAGE.
374cf49a43SJulian Elischer  *
386f16db81SArchie Cobbs  * Author: Archie Cobbs <archie@freebsd.org>
394cf49a43SJulian Elischer  *
404cf49a43SJulian Elischer  * $FreeBSD$
4174f5c6aaSJulian Elischer  * $Whistle: ng_ppp.c,v 1.24 1999/11/01 09:24:52 julian Exp $
424cf49a43SJulian Elischer  */
434cf49a43SJulian Elischer 
444cf49a43SJulian Elischer /*
453949bee8SArchie Cobbs  * PPP node type.
464cf49a43SJulian Elischer  */
474cf49a43SJulian Elischer 
484cf49a43SJulian Elischer #include <sys/param.h>
494cf49a43SJulian Elischer #include <sys/systm.h>
504cf49a43SJulian Elischer #include <sys/kernel.h>
51104a9b7eSAlexander Kabaev #include <sys/limits.h>
52a9b3dca5SArchie Cobbs #include <sys/time.h>
534cf49a43SJulian Elischer #include <sys/mbuf.h>
544cf49a43SJulian Elischer #include <sys/malloc.h>
554cf49a43SJulian Elischer #include <sys/errno.h>
565b664c7cSPoul-Henning Kamp #include <sys/ctype.h>
574cf49a43SJulian Elischer 
584cf49a43SJulian Elischer #include <netgraph/ng_message.h>
594cf49a43SJulian Elischer #include <netgraph/netgraph.h>
60f8307e12SArchie Cobbs #include <netgraph/ng_parse.h>
614cf49a43SJulian Elischer #include <netgraph/ng_ppp.h>
623949bee8SArchie Cobbs #include <netgraph/ng_vjc.h>
634cf49a43SJulian Elischer 
649c8c302fSJulian Elischer #ifdef NG_SEPARATE_MALLOC
659c8c302fSJulian Elischer MALLOC_DEFINE(M_NETGRAPH_PPP, "netgraph_ppp", "netgraph ppp node");
669c8c302fSJulian Elischer #else
679c8c302fSJulian Elischer #define M_NETGRAPH_PPP M_NETGRAPH
689c8c302fSJulian Elischer #endif
699c8c302fSJulian Elischer 
704cf49a43SJulian Elischer #define PROT_VALID(p)		(((p) & 0x0101) == 0x0001)
712b70adcbSArchie Cobbs #define PROT_COMPRESSABLE(p)	(((p) & 0xff00) == 0x0000)
724cf49a43SJulian Elischer 
733949bee8SArchie Cobbs /* Some PPP protocol numbers we're interested in */
743949bee8SArchie Cobbs #define PROT_APPLETALK		0x0029
753949bee8SArchie Cobbs #define PROT_COMPD		0x00fd
763949bee8SArchie Cobbs #define PROT_CRYPTD		0x0053
773949bee8SArchie Cobbs #define PROT_IP			0x0021
78a9b3dca5SArchie Cobbs #define PROT_IPV6		0x0057
792b70adcbSArchie Cobbs #define PROT_IPX		0x002b
80d690a6e7SArchie Cobbs #define PROT_LCP		0xc021
813949bee8SArchie Cobbs #define PROT_MP			0x003d
823949bee8SArchie Cobbs #define PROT_VJCOMP		0x002d
833949bee8SArchie Cobbs #define PROT_VJUNCOMP		0x002f
843949bee8SArchie Cobbs 
853949bee8SArchie Cobbs /* Multilink PPP definitions */
863949bee8SArchie Cobbs #define MP_MIN_MRRU		1500		/* per RFC 1990 */
873949bee8SArchie Cobbs #define MP_INITIAL_SEQ		0		/* per RFC 1990 */
883949bee8SArchie Cobbs #define MP_MIN_LINK_MRU		32
893949bee8SArchie Cobbs 
903949bee8SArchie Cobbs #define MP_SHORT_SEQ_MASK	0x00000fff	/* short seq # mask */
913949bee8SArchie Cobbs #define MP_SHORT_SEQ_HIBIT	0x00000800	/* short seq # high bit */
923949bee8SArchie Cobbs #define MP_SHORT_FIRST_FLAG	0x00008000	/* first fragment in frame */
933949bee8SArchie Cobbs #define MP_SHORT_LAST_FLAG	0x00004000	/* last fragment in frame */
943949bee8SArchie Cobbs 
953949bee8SArchie Cobbs #define MP_LONG_SEQ_MASK	0x00ffffff	/* long seq # mask */
963949bee8SArchie Cobbs #define MP_LONG_SEQ_HIBIT	0x00800000	/* long seq # high bit */
973949bee8SArchie Cobbs #define MP_LONG_FIRST_FLAG	0x80000000	/* first fragment in frame */
983949bee8SArchie Cobbs #define MP_LONG_LAST_FLAG	0x40000000	/* last fragment in frame */
993949bee8SArchie Cobbs 
1006f16db81SArchie Cobbs #define MP_NOSEQ		0x7fffffff	/* impossible sequence number */
1013949bee8SArchie Cobbs 
1023949bee8SArchie Cobbs /* Sign extension of MP sequence numbers */
1033949bee8SArchie Cobbs #define MP_SHORT_EXTEND(s)	(((s) & MP_SHORT_SEQ_HIBIT) ?		\
1046f16db81SArchie Cobbs 				    ((s) | ~MP_SHORT_SEQ_MASK)		\
1056f16db81SArchie Cobbs 				    : ((s) & MP_SHORT_SEQ_MASK))
1063949bee8SArchie Cobbs #define MP_LONG_EXTEND(s)	(((s) & MP_LONG_SEQ_HIBIT) ?		\
1076f16db81SArchie Cobbs 				    ((s) | ~MP_LONG_SEQ_MASK)		\
1086f16db81SArchie Cobbs 				    : ((s) & MP_LONG_SEQ_MASK))
1093949bee8SArchie Cobbs 
1106f16db81SArchie Cobbs /* Comparision of MP sequence numbers. Note: all sequence numbers
1116f16db81SArchie Cobbs    except priv->xseq are stored with the sign bit extended. */
1126f16db81SArchie Cobbs #define MP_SHORT_SEQ_DIFF(x,y)	MP_SHORT_EXTEND((x) - (y))
1136f16db81SArchie Cobbs #define MP_LONG_SEQ_DIFF(x,y)	MP_LONG_EXTEND((x) - (y))
1143949bee8SArchie Cobbs 
1156f16db81SArchie Cobbs #define MP_RECV_SEQ_DIFF(priv,x,y)					\
1166f16db81SArchie Cobbs 				((priv)->conf.recvShortSeq ?		\
1173949bee8SArchie Cobbs 				    MP_SHORT_SEQ_DIFF((x), (y)) :	\
1183949bee8SArchie Cobbs 				    MP_LONG_SEQ_DIFF((x), (y)))
1193949bee8SArchie Cobbs 
1206f16db81SArchie Cobbs /* Increment receive sequence number */
1216f16db81SArchie Cobbs #define MP_NEXT_RECV_SEQ(priv,seq)					\
122b5a60ddbSArchie Cobbs 				((priv)->conf.recvShortSeq ?		\
123b5a60ddbSArchie Cobbs 				    MP_SHORT_EXTEND((seq) + 1) :	\
124b5a60ddbSArchie Cobbs 				    MP_LONG_EXTEND((seq) + 1))
125a9b3dca5SArchie Cobbs 
126a9b3dca5SArchie Cobbs /* Don't fragment transmitted packets smaller than this */
127a9b3dca5SArchie Cobbs #define MP_MIN_FRAG_LEN		6
128a9b3dca5SArchie Cobbs 
129a9b3dca5SArchie Cobbs /* Maximum fragment reasssembly queue length */
130a9b3dca5SArchie Cobbs #define MP_MAX_QUEUE_LEN	128
131a9b3dca5SArchie Cobbs 
132a9b3dca5SArchie Cobbs /* Fragment queue scanner period */
133a9b3dca5SArchie Cobbs #define MP_FRAGTIMER_INTERVAL	(hz/2)
134a9b3dca5SArchie Cobbs 
1353949bee8SArchie Cobbs /* We store incoming fragments this way */
1363949bee8SArchie Cobbs struct ng_ppp_frag {
137a9b3dca5SArchie Cobbs 	int				seq;		/* fragment seq# */
138a9b3dca5SArchie Cobbs 	u_char				first;		/* First in packet? */
139a9b3dca5SArchie Cobbs 	u_char				last;		/* Last in packet? */
140a9b3dca5SArchie Cobbs 	struct timeval			timestamp;	/* time of reception */
141a9b3dca5SArchie Cobbs 	struct mbuf			*data;		/* Fragment data */
1425f90cac7SKirk McKusick 	TAILQ_ENTRY(ng_ppp_frag)	f_qent;		/* Fragment queue */
1433949bee8SArchie Cobbs };
1443949bee8SArchie Cobbs 
1453949bee8SArchie Cobbs /* We use integer indicies to refer to the non-link hooks */
1463949bee8SArchie Cobbs static const char *const ng_ppp_hook_names[] = {
1473949bee8SArchie Cobbs 	NG_PPP_HOOK_ATALK,
1483949bee8SArchie Cobbs #define HOOK_INDEX_ATALK		0
1493949bee8SArchie Cobbs 	NG_PPP_HOOK_BYPASS,
1503949bee8SArchie Cobbs #define HOOK_INDEX_BYPASS		1
1513949bee8SArchie Cobbs 	NG_PPP_HOOK_COMPRESS,
1523949bee8SArchie Cobbs #define HOOK_INDEX_COMPRESS		2
1533949bee8SArchie Cobbs 	NG_PPP_HOOK_ENCRYPT,
1543949bee8SArchie Cobbs #define HOOK_INDEX_ENCRYPT		3
1553949bee8SArchie Cobbs 	NG_PPP_HOOK_DECOMPRESS,
1563949bee8SArchie Cobbs #define HOOK_INDEX_DECOMPRESS		4
1573949bee8SArchie Cobbs 	NG_PPP_HOOK_DECRYPT,
1583949bee8SArchie Cobbs #define HOOK_INDEX_DECRYPT		5
1593949bee8SArchie Cobbs 	NG_PPP_HOOK_INET,
1603949bee8SArchie Cobbs #define HOOK_INDEX_INET			6
1613949bee8SArchie Cobbs 	NG_PPP_HOOK_IPX,
1623949bee8SArchie Cobbs #define HOOK_INDEX_IPX			7
1633949bee8SArchie Cobbs 	NG_PPP_HOOK_VJC_COMP,
1643949bee8SArchie Cobbs #define HOOK_INDEX_VJC_COMP		8
1653949bee8SArchie Cobbs 	NG_PPP_HOOK_VJC_IP,
1663949bee8SArchie Cobbs #define HOOK_INDEX_VJC_IP		9
1673949bee8SArchie Cobbs 	NG_PPP_HOOK_VJC_UNCOMP,
1683949bee8SArchie Cobbs #define HOOK_INDEX_VJC_UNCOMP		10
1693949bee8SArchie Cobbs 	NG_PPP_HOOK_VJC_VJIP,
1703949bee8SArchie Cobbs #define HOOK_INDEX_VJC_VJIP		11
171a9b3dca5SArchie Cobbs 	NG_PPP_HOOK_IPV6,
172a9b3dca5SArchie Cobbs #define HOOK_INDEX_IPV6			12
1733949bee8SArchie Cobbs 	NULL
174a9b3dca5SArchie Cobbs #define HOOK_INDEX_MAX			13
1753949bee8SArchie Cobbs };
1763949bee8SArchie Cobbs 
1773949bee8SArchie Cobbs /* We store index numbers in the hook private pointer. The HOOK_INDEX()
1783949bee8SArchie Cobbs    for a hook is either the index (above) for normal hooks, or the ones
17930400f03SJulian Elischer    complement of the link number for link hooks.
18030400f03SJulian Elischer XXX Not any more.. (what a hack)
1813949bee8SArchie Cobbs #define HOOK_INDEX(hook)	(*((int16_t *) &(hook)->private))
18230400f03SJulian Elischer */
1834cf49a43SJulian Elischer 
184a9b3dca5SArchie Cobbs /* Per-link private information */
185a9b3dca5SArchie Cobbs struct ng_ppp_link {
186a9b3dca5SArchie Cobbs 	struct ng_ppp_link_conf	conf;		/* link configuration */
187a9b3dca5SArchie Cobbs 	hook_p			hook;		/* connection to link data */
1886f16db81SArchie Cobbs 	int32_t			seq;		/* highest rec'd seq# - MSEQ */
18949728ffcSBjoern A. Zeeb 	u_int32_t		latency;	/* calculated link latency */
190a9b3dca5SArchie Cobbs 	struct timeval		lastWrite;	/* time of last write */
191a9b3dca5SArchie Cobbs 	int			bytesInQueue;	/* bytes in the output queue */
192a9b3dca5SArchie Cobbs 	struct ng_ppp_link_stat	stats;		/* Link stats */
193a9b3dca5SArchie Cobbs };
194a9b3dca5SArchie Cobbs 
195a9b3dca5SArchie Cobbs /* Total per-node private information */
19662838faeSArchie Cobbs struct ng_ppp_private {
197a9b3dca5SArchie Cobbs 	struct ng_ppp_bund_conf	conf;			/* bundle config */
198a9b3dca5SArchie Cobbs 	struct ng_ppp_link_stat	bundleStats;		/* bundle stats */
199a9b3dca5SArchie Cobbs 	struct ng_ppp_link	links[NG_PPP_MAX_LINKS];/* per-link info */
2006f16db81SArchie Cobbs 	int32_t			xseq;			/* next out MP seq # */
2016f16db81SArchie Cobbs 	int32_t			mseq;			/* min links[i].seq */
202a9b3dca5SArchie Cobbs 	u_char			vjCompHooked;		/* VJ comp hooked up? */
203a9b3dca5SArchie Cobbs 	u_char			allLinksEqual;		/* all xmit the same? */
204a9b3dca5SArchie Cobbs 	u_int			numActiveLinks;		/* how many links up */
205a9b3dca5SArchie Cobbs 	int			activeLinks[NG_PPP_MAX_LINKS];	/* indicies */
2063949bee8SArchie Cobbs 	u_int			lastLink;		/* for round robin */
207a9b3dca5SArchie Cobbs 	hook_p			hooks[HOOK_INDEX_MAX];	/* non-link hooks */
2085f90cac7SKirk McKusick 	TAILQ_HEAD(ng_ppp_fraglist, ng_ppp_frag)	/* fragment queue */
209a9b3dca5SArchie Cobbs 				frags;
210a9b3dca5SArchie Cobbs 	int			qlen;			/* fraq queue length */
2119d952bd3SGleb Smirnoff 	struct callout		fragTimer;		/* fraq queue check */
2124cf49a43SJulian Elischer };
21362838faeSArchie Cobbs typedef struct ng_ppp_private *priv_p;
2144cf49a43SJulian Elischer 
2154cf49a43SJulian Elischer /* Netgraph node methods */
21674f5c6aaSJulian Elischer static ng_constructor_t	ng_ppp_constructor;
21774f5c6aaSJulian Elischer static ng_rcvmsg_t	ng_ppp_rcvmsg;
218069154d5SJulian Elischer static ng_shutdown_t	ng_ppp_shutdown;
21974f5c6aaSJulian Elischer static ng_newhook_t	ng_ppp_newhook;
22074f5c6aaSJulian Elischer static ng_rcvdata_t	ng_ppp_rcvdata;
22174f5c6aaSJulian Elischer static ng_disconnect_t	ng_ppp_disconnect;
2224cf49a43SJulian Elischer 
2233949bee8SArchie Cobbs /* Helper functions */
224e149c4e2SArchie Cobbs static int	ng_ppp_input(node_p node, int bypass,
225ccb07cc3SGleb Smirnoff 			int linkNum, item_p item, int index);
226d690a6e7SArchie Cobbs static int	ng_ppp_output(node_p node, int bypass, int proto,
227069154d5SJulian Elischer 			int linkNum, item_p item);
228069154d5SJulian Elischer static int	ng_ppp_mp_input(node_p node, int linkNum, item_p item);
229a9b3dca5SArchie Cobbs static int	ng_ppp_check_packet(node_p node);
2303ca24c28SJulian Elischer static void	ng_ppp_get_packet(node_p node, struct mbuf **mp);
231a9b3dca5SArchie Cobbs static int	ng_ppp_frag_process(node_p node);
232a9b3dca5SArchie Cobbs static int	ng_ppp_frag_trim(node_p node);
2339d952bd3SGleb Smirnoff static void	ng_ppp_frag_timeout(node_p node, hook_p hook, void *arg1,
2349d952bd3SGleb Smirnoff 			int arg2);
235a9b3dca5SArchie Cobbs static void	ng_ppp_frag_checkstale(node_p node);
236a9b3dca5SArchie Cobbs static void	ng_ppp_frag_reset(node_p node);
2373ca24c28SJulian Elischer static int	ng_ppp_mp_output(node_p node, struct mbuf *m);
2383949bee8SArchie Cobbs static void	ng_ppp_mp_strategy(node_p node, int len, int *distrib);
2398250de83SGleb Smirnoff static int	ng_ppp_intcmp(void *latency, const void *v1, const void *v2);
2403949bee8SArchie Cobbs static struct	mbuf *ng_ppp_addproto(struct mbuf *m, int proto, int compOK);
241d690a6e7SArchie Cobbs static struct	mbuf *ng_ppp_prepend(struct mbuf *m, const void *buf, int len);
2423949bee8SArchie Cobbs static int	ng_ppp_config_valid(node_p node,
243a9b3dca5SArchie Cobbs 			const struct ng_ppp_node_conf *newConf);
2443949bee8SArchie Cobbs static void	ng_ppp_update(node_p node, int newConf);
245a9b3dca5SArchie Cobbs static void	ng_ppp_start_frag_timer(node_p node);
246a9b3dca5SArchie Cobbs static void	ng_ppp_stop_frag_timer(node_p node);
2474cf49a43SJulian Elischer 
2486f16db81SArchie Cobbs /* Parse type for struct ng_ppp_mp_state_type */
2496f16db81SArchie Cobbs static const struct ng_parse_fixedarray_info ng_ppp_rseq_array_info = {
2506f16db81SArchie Cobbs 	&ng_parse_hint32_type,
2516f16db81SArchie Cobbs 	NG_PPP_MAX_LINKS
2526f16db81SArchie Cobbs };
2536f16db81SArchie Cobbs static const struct ng_parse_type ng_ppp_rseq_array_type = {
2546f16db81SArchie Cobbs 	&ng_parse_fixedarray_type,
2556f16db81SArchie Cobbs 	&ng_ppp_rseq_array_info,
2566f16db81SArchie Cobbs };
257f0184ff8SArchie Cobbs static const struct ng_parse_struct_field ng_ppp_mp_state_type_fields[]
2586f16db81SArchie Cobbs 	= NG_PPP_MP_STATE_TYPE_INFO(&ng_ppp_rseq_array_type);
2596f16db81SArchie Cobbs static const struct ng_parse_type ng_ppp_mp_state_type = {
2606f16db81SArchie Cobbs 	&ng_parse_struct_type,
261f0184ff8SArchie Cobbs 	&ng_ppp_mp_state_type_fields
2626f16db81SArchie Cobbs };
2636f16db81SArchie Cobbs 
264a9b3dca5SArchie Cobbs /* Parse type for struct ng_ppp_link_conf */
265f0184ff8SArchie Cobbs static const struct ng_parse_struct_field ng_ppp_link_type_fields[]
266f0184ff8SArchie Cobbs 	= NG_PPP_LINK_TYPE_INFO;
267f8307e12SArchie Cobbs static const struct ng_parse_type ng_ppp_link_type = {
268f8307e12SArchie Cobbs 	&ng_parse_struct_type,
269f0184ff8SArchie Cobbs 	&ng_ppp_link_type_fields
270f8307e12SArchie Cobbs };
271f8307e12SArchie Cobbs 
272a9b3dca5SArchie Cobbs /* Parse type for struct ng_ppp_bund_conf */
273f0184ff8SArchie Cobbs static const struct ng_parse_struct_field ng_ppp_bund_type_fields[]
274f0184ff8SArchie Cobbs 	= NG_PPP_BUND_TYPE_INFO;
275a9b3dca5SArchie Cobbs static const struct ng_parse_type ng_ppp_bund_type = {
276a9b3dca5SArchie Cobbs 	&ng_parse_struct_type,
277f0184ff8SArchie Cobbs 	&ng_ppp_bund_type_fields
278a9b3dca5SArchie Cobbs };
279a9b3dca5SArchie Cobbs 
280a9b3dca5SArchie Cobbs /* Parse type for struct ng_ppp_node_conf */
2816f16db81SArchie Cobbs static const struct ng_parse_fixedarray_info ng_ppp_array_info = {
282f8307e12SArchie Cobbs 	&ng_ppp_link_type,
283f8307e12SArchie Cobbs 	NG_PPP_MAX_LINKS
284f8307e12SArchie Cobbs };
285f8307e12SArchie Cobbs static const struct ng_parse_type ng_ppp_link_array_type = {
286f8307e12SArchie Cobbs 	&ng_parse_fixedarray_type,
287f8307e12SArchie Cobbs 	&ng_ppp_array_info,
288f8307e12SArchie Cobbs };
289f0184ff8SArchie Cobbs static const struct ng_parse_struct_field ng_ppp_conf_type_fields[]
290a9b3dca5SArchie Cobbs 	= NG_PPP_CONFIG_TYPE_INFO(&ng_ppp_bund_type, &ng_ppp_link_array_type);
291a9b3dca5SArchie Cobbs static const struct ng_parse_type ng_ppp_conf_type = {
292f8307e12SArchie Cobbs 	&ng_parse_struct_type,
293f0184ff8SArchie Cobbs 	&ng_ppp_conf_type_fields
294f8307e12SArchie Cobbs };
295f8307e12SArchie Cobbs 
296f8307e12SArchie Cobbs /* Parse type for struct ng_ppp_link_stat */
297f0184ff8SArchie Cobbs static const struct ng_parse_struct_field ng_ppp_stats_type_fields[]
298f0184ff8SArchie Cobbs 	= NG_PPP_STATS_TYPE_INFO;
299f8307e12SArchie Cobbs static const struct ng_parse_type ng_ppp_stats_type = {
300f8307e12SArchie Cobbs 	&ng_parse_struct_type,
301f0184ff8SArchie Cobbs 	&ng_ppp_stats_type_fields
302f8307e12SArchie Cobbs };
303f8307e12SArchie Cobbs 
304f8307e12SArchie Cobbs /* List of commands and how to convert arguments to/from ASCII */
305f8307e12SArchie Cobbs static const struct ng_cmdlist ng_ppp_cmds[] = {
306f8307e12SArchie Cobbs 	{
307f8307e12SArchie Cobbs 	  NGM_PPP_COOKIE,
308f8307e12SArchie Cobbs 	  NGM_PPP_SET_CONFIG,
309f8307e12SArchie Cobbs 	  "setconfig",
310a9b3dca5SArchie Cobbs 	  &ng_ppp_conf_type,
311f8307e12SArchie Cobbs 	  NULL
312f8307e12SArchie Cobbs 	},
313f8307e12SArchie Cobbs 	{
314f8307e12SArchie Cobbs 	  NGM_PPP_COOKIE,
315f8307e12SArchie Cobbs 	  NGM_PPP_GET_CONFIG,
316f8307e12SArchie Cobbs 	  "getconfig",
317f8307e12SArchie Cobbs 	  NULL,
318a9b3dca5SArchie Cobbs 	  &ng_ppp_conf_type
319f8307e12SArchie Cobbs 	},
320f8307e12SArchie Cobbs 	{
321f8307e12SArchie Cobbs 	  NGM_PPP_COOKIE,
3226f16db81SArchie Cobbs 	  NGM_PPP_GET_MP_STATE,
3236f16db81SArchie Cobbs 	  "getmpstate",
3246f16db81SArchie Cobbs 	  NULL,
3256f16db81SArchie Cobbs 	  &ng_ppp_mp_state_type
3266f16db81SArchie Cobbs 	},
3276f16db81SArchie Cobbs 	{
3286f16db81SArchie Cobbs 	  NGM_PPP_COOKIE,
329f8307e12SArchie Cobbs 	  NGM_PPP_GET_LINK_STATS,
330f8307e12SArchie Cobbs 	  "getstats",
331f8307e12SArchie Cobbs 	  &ng_parse_int16_type,
332f8307e12SArchie Cobbs 	  &ng_ppp_stats_type
333f8307e12SArchie Cobbs 	},
334f8307e12SArchie Cobbs 	{
335f8307e12SArchie Cobbs 	  NGM_PPP_COOKIE,
336f8307e12SArchie Cobbs 	  NGM_PPP_CLR_LINK_STATS,
337f8307e12SArchie Cobbs 	  "clrstats",
338f8307e12SArchie Cobbs 	  &ng_parse_int16_type,
339f8307e12SArchie Cobbs 	  NULL
340f8307e12SArchie Cobbs 	},
341f8307e12SArchie Cobbs 	{
342f8307e12SArchie Cobbs 	  NGM_PPP_COOKIE,
343f8307e12SArchie Cobbs 	  NGM_PPP_GETCLR_LINK_STATS,
344f8307e12SArchie Cobbs 	  "getclrstats",
345f8307e12SArchie Cobbs 	  &ng_parse_int16_type,
346f8307e12SArchie Cobbs 	  &ng_ppp_stats_type
347f8307e12SArchie Cobbs 	},
348f8307e12SArchie Cobbs 	{ 0 }
349f8307e12SArchie Cobbs };
350f8307e12SArchie Cobbs 
3514cf49a43SJulian Elischer /* Node type descriptor */
3523949bee8SArchie Cobbs static struct ng_type ng_ppp_typestruct = {
353f8aae777SJulian Elischer 	.version =	NG_ABI_VERSION,
354f8aae777SJulian Elischer 	.name =		NG_PPP_NODE_TYPE,
355f8aae777SJulian Elischer 	.constructor =	ng_ppp_constructor,
356f8aae777SJulian Elischer 	.rcvmsg =	ng_ppp_rcvmsg,
357f8aae777SJulian Elischer 	.shutdown =	ng_ppp_shutdown,
358f8aae777SJulian Elischer 	.newhook =	ng_ppp_newhook,
359f8aae777SJulian Elischer 	.rcvdata =	ng_ppp_rcvdata,
360f8aae777SJulian Elischer 	.disconnect =	ng_ppp_disconnect,
361f8aae777SJulian Elischer 	.cmdlist =	ng_ppp_cmds,
3624cf49a43SJulian Elischer };
3633949bee8SArchie Cobbs NETGRAPH_INIT(ppp, &ng_ppp_typestruct);
3644cf49a43SJulian Elischer 
365d690a6e7SArchie Cobbs /* Address and control field header */
366d690a6e7SArchie Cobbs static const u_char ng_ppp_acf[2] = { 0xff, 0x03 };
367d690a6e7SArchie Cobbs 
368a9b3dca5SArchie Cobbs /* Maximum time we'll let a complete incoming packet sit in the queue */
369a9b3dca5SArchie Cobbs static const struct timeval ng_ppp_max_staleness = { 2, 0 };	/* 2 seconds */
370a9b3dca5SArchie Cobbs 
3714cf49a43SJulian Elischer #define ERROUT(x)	do { error = (x); goto done; } while (0)
3724cf49a43SJulian Elischer 
3734cf49a43SJulian Elischer /************************************************************************
3744cf49a43SJulian Elischer 			NETGRAPH NODE STUFF
3754cf49a43SJulian Elischer  ************************************************************************/
3764cf49a43SJulian Elischer 
3774cf49a43SJulian Elischer /*
3783949bee8SArchie Cobbs  * Node type constructor
3794cf49a43SJulian Elischer  */
3804cf49a43SJulian Elischer static int
381069154d5SJulian Elischer ng_ppp_constructor(node_p node)
3824cf49a43SJulian Elischer {
3834cf49a43SJulian Elischer 	priv_p priv;
384069154d5SJulian Elischer 	int i;
3854cf49a43SJulian Elischer 
3864cf49a43SJulian Elischer 	/* Allocate private structure */
3879c8c302fSJulian Elischer 	MALLOC(priv, priv_p, sizeof(*priv), M_NETGRAPH_PPP, M_NOWAIT | M_ZERO);
3884cf49a43SJulian Elischer 	if (priv == NULL)
3894cf49a43SJulian Elischer 		return (ENOMEM);
3904cf49a43SJulian Elischer 
39130400f03SJulian Elischer 	NG_NODE_SET_PRIVATE(node, priv);
3924cf49a43SJulian Elischer 
3933949bee8SArchie Cobbs 	/* Initialize state */
3945f90cac7SKirk McKusick 	TAILQ_INIT(&priv->frags);
395a9b3dca5SArchie Cobbs 	for (i = 0; i < NG_PPP_MAX_LINKS; i++)
396a9b3dca5SArchie Cobbs 		priv->links[i].seq = MP_NOSEQ;
3979d952bd3SGleb Smirnoff 	ng_callout_init(&priv->fragTimer);
3983949bee8SArchie Cobbs 
3994cf49a43SJulian Elischer 	/* Done */
4004cf49a43SJulian Elischer 	return (0);
4014cf49a43SJulian Elischer }
4024cf49a43SJulian Elischer 
4034cf49a43SJulian Elischer /*
4044cf49a43SJulian Elischer  * Give our OK for a hook to be added
4054cf49a43SJulian Elischer  */
4064cf49a43SJulian Elischer static int
4074cf49a43SJulian Elischer ng_ppp_newhook(node_p node, hook_p hook, const char *name)
4084cf49a43SJulian Elischer {
40930400f03SJulian Elischer 	const priv_p priv = NG_NODE_PRIVATE(node);
4103949bee8SArchie Cobbs 	int linkNum = -1;
4113949bee8SArchie Cobbs 	hook_p *hookPtr = NULL;
4123949bee8SArchie Cobbs 	int hookIndex = -1;
4134cf49a43SJulian Elischer 
4143949bee8SArchie Cobbs 	/* Figure out which hook it is */
4153949bee8SArchie Cobbs 	if (strncmp(name, NG_PPP_HOOK_LINK_PREFIX,	/* a link hook? */
4163949bee8SArchie Cobbs 	    strlen(NG_PPP_HOOK_LINK_PREFIX)) == 0) {
41725792ef3SArchie Cobbs 		const char *cp;
41825792ef3SArchie Cobbs 		char *eptr;
4193949bee8SArchie Cobbs 
4202b70adcbSArchie Cobbs 		cp = name + strlen(NG_PPP_HOOK_LINK_PREFIX);
4212b70adcbSArchie Cobbs 		if (!isdigit(*cp) || (cp[0] == '0' && cp[1] != '\0'))
4224cf49a43SJulian Elischer 			return (EINVAL);
4232b70adcbSArchie Cobbs 		linkNum = (int)strtoul(cp, &eptr, 10);
4242b70adcbSArchie Cobbs 		if (*eptr != '\0' || linkNum < 0 || linkNum >= NG_PPP_MAX_LINKS)
4253949bee8SArchie Cobbs 			return (EINVAL);
426a9b3dca5SArchie Cobbs 		hookPtr = &priv->links[linkNum].hook;
4273949bee8SArchie Cobbs 		hookIndex = ~linkNum;
4283949bee8SArchie Cobbs 	} else {				/* must be a non-link hook */
4293949bee8SArchie Cobbs 		int i;
4304cf49a43SJulian Elischer 
4313949bee8SArchie Cobbs 		for (i = 0; ng_ppp_hook_names[i] != NULL; i++) {
4323949bee8SArchie Cobbs 			if (strcmp(name, ng_ppp_hook_names[i]) == 0) {
4333949bee8SArchie Cobbs 				hookPtr = &priv->hooks[i];
4343949bee8SArchie Cobbs 				hookIndex = i;
4353949bee8SArchie Cobbs 				break;
4363949bee8SArchie Cobbs 			}
4373949bee8SArchie Cobbs 		}
4383949bee8SArchie Cobbs 		if (ng_ppp_hook_names[i] == NULL)
4393949bee8SArchie Cobbs 			return (EINVAL);	/* no such hook */
4403949bee8SArchie Cobbs 	}
4413949bee8SArchie Cobbs 
4423949bee8SArchie Cobbs 	/* See if hook is already connected */
4433949bee8SArchie Cobbs 	if (*hookPtr != NULL)
4444cf49a43SJulian Elischer 		return (EISCONN);
4454cf49a43SJulian Elischer 
4463949bee8SArchie Cobbs 	/* Disallow more than one link unless multilink is enabled */
447a9b3dca5SArchie Cobbs 	if (linkNum != -1 && priv->links[linkNum].conf.enableLink
4483949bee8SArchie Cobbs 	    && !priv->conf.enableMultilink && priv->numActiveLinks >= 1)
4493949bee8SArchie Cobbs 		return (ENODEV);
4504cf49a43SJulian Elischer 
4514cf49a43SJulian Elischer 	/* OK */
4523949bee8SArchie Cobbs 	*hookPtr = hook;
4538214d60eSJohn Baldwin 	NG_HOOK_SET_PRIVATE(hook, (void *)(intptr_t)hookIndex);
4543949bee8SArchie Cobbs 	ng_ppp_update(node, 0);
4554cf49a43SJulian Elischer 	return (0);
4564cf49a43SJulian Elischer }
4574cf49a43SJulian Elischer 
4584cf49a43SJulian Elischer /*
4594cf49a43SJulian Elischer  * Receive a control message
4604cf49a43SJulian Elischer  */
4614cf49a43SJulian Elischer static int
462069154d5SJulian Elischer ng_ppp_rcvmsg(node_p node, item_p item, hook_p lasthook)
4634cf49a43SJulian Elischer {
46430400f03SJulian Elischer 	const priv_p priv = NG_NODE_PRIVATE(node);
4654cf49a43SJulian Elischer 	struct ng_mesg *resp = NULL;
4664cf49a43SJulian Elischer 	int error = 0;
467069154d5SJulian Elischer 	struct ng_mesg *msg;
4684cf49a43SJulian Elischer 
469069154d5SJulian Elischer 	NGI_GET_MSG(item, msg);
4704cf49a43SJulian Elischer 	switch (msg->header.typecookie) {
4714cf49a43SJulian Elischer 	case NGM_PPP_COOKIE:
4724cf49a43SJulian Elischer 		switch (msg->header.cmd) {
4733949bee8SArchie Cobbs 		case NGM_PPP_SET_CONFIG:
4743949bee8SArchie Cobbs 		    {
475a9b3dca5SArchie Cobbs 			struct ng_ppp_node_conf *const conf =
476a9b3dca5SArchie Cobbs 			    (struct ng_ppp_node_conf *)msg->data;
477a9b3dca5SArchie Cobbs 			int i;
4783949bee8SArchie Cobbs 
4793949bee8SArchie Cobbs 			/* Check for invalid or illegal config */
480a9b3dca5SArchie Cobbs 			if (msg->header.arglen != sizeof(*conf))
4814cf49a43SJulian Elischer 				ERROUT(EINVAL);
482a9b3dca5SArchie Cobbs 			if (!ng_ppp_config_valid(node, conf))
4833949bee8SArchie Cobbs 				ERROUT(EINVAL);
484a9b3dca5SArchie Cobbs 
485a9b3dca5SArchie Cobbs 			/* Copy config */
486a9b3dca5SArchie Cobbs 			priv->conf = conf->bund;
487a9b3dca5SArchie Cobbs 			for (i = 0; i < NG_PPP_MAX_LINKS; i++)
488a9b3dca5SArchie Cobbs 				priv->links[i].conf = conf->links[i];
4893949bee8SArchie Cobbs 			ng_ppp_update(node, 1);
4904cf49a43SJulian Elischer 			break;
4913949bee8SArchie Cobbs 		    }
4923949bee8SArchie Cobbs 		case NGM_PPP_GET_CONFIG:
493a9b3dca5SArchie Cobbs 		    {
494a9b3dca5SArchie Cobbs 			struct ng_ppp_node_conf *conf;
495a9b3dca5SArchie Cobbs 			int i;
496a9b3dca5SArchie Cobbs 
497a9b3dca5SArchie Cobbs 			NG_MKRESPONSE(resp, msg, sizeof(*conf), M_NOWAIT);
4984cf49a43SJulian Elischer 			if (resp == NULL)
4994cf49a43SJulian Elischer 				ERROUT(ENOMEM);
500a9b3dca5SArchie Cobbs 			conf = (struct ng_ppp_node_conf *)resp->data;
501a9b3dca5SArchie Cobbs 			conf->bund = priv->conf;
502a9b3dca5SArchie Cobbs 			for (i = 0; i < NG_PPP_MAX_LINKS; i++)
503a9b3dca5SArchie Cobbs 				conf->links[i] = priv->links[i].conf;
5044cf49a43SJulian Elischer 			break;
505a9b3dca5SArchie Cobbs 		    }
5066f16db81SArchie Cobbs 		case NGM_PPP_GET_MP_STATE:
5076f16db81SArchie Cobbs 		    {
5086f16db81SArchie Cobbs 			struct ng_ppp_mp_state *info;
5096f16db81SArchie Cobbs 			int i;
5106f16db81SArchie Cobbs 
5116f16db81SArchie Cobbs 			NG_MKRESPONSE(resp, msg, sizeof(*info), M_NOWAIT);
5126f16db81SArchie Cobbs 			if (resp == NULL)
5136f16db81SArchie Cobbs 				ERROUT(ENOMEM);
5146f16db81SArchie Cobbs 			info = (struct ng_ppp_mp_state *)resp->data;
5156f16db81SArchie Cobbs 			bzero(info, sizeof(*info));
5166f16db81SArchie Cobbs 			for (i = 0; i < NG_PPP_MAX_LINKS; i++) {
5176f16db81SArchie Cobbs 				if (priv->links[i].seq != MP_NOSEQ)
5186f16db81SArchie Cobbs 					info->rseq[i] = priv->links[i].seq;
5196f16db81SArchie Cobbs 			}
5206f16db81SArchie Cobbs 			info->mseq = priv->mseq;
5216f16db81SArchie Cobbs 			info->xseq = priv->xseq;
5226f16db81SArchie Cobbs 			break;
5236f16db81SArchie Cobbs 		    }
5243949bee8SArchie Cobbs 		case NGM_PPP_GET_LINK_STATS:
5253949bee8SArchie Cobbs 		case NGM_PPP_CLR_LINK_STATS:
526e149c4e2SArchie Cobbs 		case NGM_PPP_GETCLR_LINK_STATS:
5273949bee8SArchie Cobbs 		    {
5283949bee8SArchie Cobbs 			struct ng_ppp_link_stat *stats;
5293949bee8SArchie Cobbs 			u_int16_t linkNum;
5303949bee8SArchie Cobbs 
5313949bee8SArchie Cobbs 			if (msg->header.arglen != sizeof(u_int16_t))
5323949bee8SArchie Cobbs 				ERROUT(EINVAL);
5333949bee8SArchie Cobbs 			linkNum = *((u_int16_t *) msg->data);
5343949bee8SArchie Cobbs 			if (linkNum >= NG_PPP_MAX_LINKS
5353949bee8SArchie Cobbs 			    && linkNum != NG_PPP_BUNDLE_LINKNUM)
5363949bee8SArchie Cobbs 				ERROUT(EINVAL);
5373949bee8SArchie Cobbs 			stats = (linkNum == NG_PPP_BUNDLE_LINKNUM) ?
538a9b3dca5SArchie Cobbs 			    &priv->bundleStats : &priv->links[linkNum].stats;
539e149c4e2SArchie Cobbs 			if (msg->header.cmd != NGM_PPP_CLR_LINK_STATS) {
5403949bee8SArchie Cobbs 				NG_MKRESPONSE(resp, msg,
5413949bee8SArchie Cobbs 				    sizeof(struct ng_ppp_link_stat), M_NOWAIT);
5423949bee8SArchie Cobbs 				if (resp == NULL)
5433949bee8SArchie Cobbs 					ERROUT(ENOMEM);
5443949bee8SArchie Cobbs 				bcopy(stats, resp->data, sizeof(*stats));
545e149c4e2SArchie Cobbs 			}
546e149c4e2SArchie Cobbs 			if (msg->header.cmd != NGM_PPP_GET_LINK_STATS)
5473949bee8SArchie Cobbs 				bzero(stats, sizeof(*stats));
5484cf49a43SJulian Elischer 			break;
5493949bee8SArchie Cobbs 		    }
5504cf49a43SJulian Elischer 		default:
5514cf49a43SJulian Elischer 			error = EINVAL;
5524cf49a43SJulian Elischer 			break;
5534cf49a43SJulian Elischer 		}
5544cf49a43SJulian Elischer 		break;
5553949bee8SArchie Cobbs 	case NGM_VJC_COOKIE:
5563949bee8SArchie Cobbs 	    {
557069154d5SJulian Elischer 		/*
558069154d5SJulian Elischer 		 * Forward it to the vjc node. leave the
559069154d5SJulian Elischer 		 * old return address alone.
56030400f03SJulian Elischer 		 * If we have no hook, let NG_RESPOND_MSG
56130400f03SJulian Elischer 		 * clean up any remaining resources.
56230400f03SJulian Elischer 		 * Because we have no resp, the item will be freed
56330400f03SJulian Elischer 		 * along with anything it references. Don't
56430400f03SJulian Elischer 		 * let msg be freed twice.
565069154d5SJulian Elischer 		 */
566069154d5SJulian Elischer 		NGI_MSG(item) = msg;	/* put it back in the item */
56730400f03SJulian Elischer 		msg = NULL;
56830400f03SJulian Elischer 		if ((lasthook = priv->links[HOOK_INDEX_VJC_IP].hook)) {
56930400f03SJulian Elischer 			NG_FWD_ITEM_HOOK(error, item, lasthook);
570069154d5SJulian Elischer 		}
571069154d5SJulian Elischer 		return (error);
5723949bee8SArchie Cobbs 	    }
5734cf49a43SJulian Elischer 	default:
5744cf49a43SJulian Elischer 		error = EINVAL;
5754cf49a43SJulian Elischer 		break;
5764cf49a43SJulian Elischer 	}
5774cf49a43SJulian Elischer done:
578069154d5SJulian Elischer 	NG_RESPOND_MSG(error, node, item, resp);
579069154d5SJulian Elischer 	NG_FREE_MSG(msg);
5804cf49a43SJulian Elischer 	return (error);
5814cf49a43SJulian Elischer }
5824cf49a43SJulian Elischer 
5834cf49a43SJulian Elischer /*
5844cf49a43SJulian Elischer  * Receive data on a hook
5854cf49a43SJulian Elischer  */
5864cf49a43SJulian Elischer static int
587069154d5SJulian Elischer ng_ppp_rcvdata(hook_p hook, item_p item)
5884cf49a43SJulian Elischer {
58930400f03SJulian Elischer 	const node_p node = NG_HOOK_NODE(hook);
59030400f03SJulian Elischer 	const priv_p priv = NG_NODE_PRIVATE(node);
5918214d60eSJohn Baldwin 	const int index = (intptr_t)NG_HOOK_PRIVATE(hook);
5923949bee8SArchie Cobbs 	u_int16_t linkNum = NG_PPP_BUNDLE_LINKNUM;
5933949bee8SArchie Cobbs 	hook_p outHook = NULL;
5943949bee8SArchie Cobbs 	int proto = 0, error;
595069154d5SJulian Elischer 	struct mbuf *m;
5964cf49a43SJulian Elischer 
597069154d5SJulian Elischer 	NGI_GET_M(item, m);
5983949bee8SArchie Cobbs 	/* Did it come from a link hook? */
5993949bee8SArchie Cobbs 	if (index < 0) {
600a9b3dca5SArchie Cobbs 		struct ng_ppp_link *link;
6014cf49a43SJulian Elischer 
602e149c4e2SArchie Cobbs 		/* Convert index into a link number */
6033949bee8SArchie Cobbs 		linkNum = (u_int16_t)~index;
6043949bee8SArchie Cobbs 		KASSERT(linkNum < NG_PPP_MAX_LINKS,
6056e551fb6SDavid E. O'Brien 		    ("%s: bogus index 0x%x", __func__, index));
606a9b3dca5SArchie Cobbs 		link = &priv->links[linkNum];
6073949bee8SArchie Cobbs 
6083949bee8SArchie Cobbs 		/* Stats */
609a9b3dca5SArchie Cobbs 		link->stats.recvFrames++;
610a9b3dca5SArchie Cobbs 		link->stats.recvOctets += m->m_pkthdr.len;
6113949bee8SArchie Cobbs 
612d690a6e7SArchie Cobbs 		/* Strip address and control fields, if present */
613d690a6e7SArchie Cobbs 		if (m->m_pkthdr.len >= 2) {
614d690a6e7SArchie Cobbs 			if (m->m_len < 2 && (m = m_pullup(m, 2)) == NULL) {
615069154d5SJulian Elischer 				NG_FREE_ITEM(item);
616d690a6e7SArchie Cobbs 				return (ENOBUFS);
617d690a6e7SArchie Cobbs 			}
618d690a6e7SArchie Cobbs 			if (bcmp(mtod(m, u_char *), &ng_ppp_acf, 2) == 0)
619d690a6e7SArchie Cobbs 				m_adj(m, 2);
620d690a6e7SArchie Cobbs 		}
621d690a6e7SArchie Cobbs 
622e149c4e2SArchie Cobbs 		/* Dispatch incoming frame (if not enabled, to bypass) */
623069154d5SJulian Elischer 		NGI_M(item) = m; 	/* put changed m back in item */
624e149c4e2SArchie Cobbs 		return ng_ppp_input(node,
625ccb07cc3SGleb Smirnoff 		    !link->conf.enableLink, linkNum, item, index);
6263949bee8SArchie Cobbs 	}
6273949bee8SArchie Cobbs 
6283949bee8SArchie Cobbs 	/* Get protocol & check if data allowed from this hook */
629069154d5SJulian Elischer 	NGI_M(item) = m; 	/* put possibly changed m back in item */
6303949bee8SArchie Cobbs 	switch (index) {
6313949bee8SArchie Cobbs 
632e149c4e2SArchie Cobbs 	/* Outgoing data */
6333949bee8SArchie Cobbs 	case HOOK_INDEX_ATALK:
6343949bee8SArchie Cobbs 		if (!priv->conf.enableAtalk) {
635069154d5SJulian Elischer 			NG_FREE_ITEM(item);
6363949bee8SArchie Cobbs 			return (ENXIO);
6373949bee8SArchie Cobbs 		}
6383949bee8SArchie Cobbs 		proto = PROT_APPLETALK;
6393949bee8SArchie Cobbs 		break;
6403949bee8SArchie Cobbs 	case HOOK_INDEX_IPX:
6413949bee8SArchie Cobbs 		if (!priv->conf.enableIPX) {
642069154d5SJulian Elischer 			NG_FREE_ITEM(item);
6433949bee8SArchie Cobbs 			return (ENXIO);
6443949bee8SArchie Cobbs 		}
6453949bee8SArchie Cobbs 		proto = PROT_IPX;
6463949bee8SArchie Cobbs 		break;
647a9b3dca5SArchie Cobbs 	case HOOK_INDEX_IPV6:
648a9b3dca5SArchie Cobbs 		if (!priv->conf.enableIPv6) {
649069154d5SJulian Elischer 			NG_FREE_ITEM(item);
650a9b3dca5SArchie Cobbs 			return (ENXIO);
651a9b3dca5SArchie Cobbs 		}
652a9b3dca5SArchie Cobbs 		proto = PROT_IPV6;
653a9b3dca5SArchie Cobbs 		break;
6543949bee8SArchie Cobbs 	case HOOK_INDEX_INET:
6553949bee8SArchie Cobbs 	case HOOK_INDEX_VJC_VJIP:
6563949bee8SArchie Cobbs 		if (!priv->conf.enableIP) {
657069154d5SJulian Elischer 			NG_FREE_ITEM(item);
6583949bee8SArchie Cobbs 			return (ENXIO);
6593949bee8SArchie Cobbs 		}
6603949bee8SArchie Cobbs 		proto = PROT_IP;
6613949bee8SArchie Cobbs 		break;
6623949bee8SArchie Cobbs 	case HOOK_INDEX_VJC_COMP:
6633949bee8SArchie Cobbs 		if (!priv->conf.enableVJCompression) {
664069154d5SJulian Elischer 			NG_FREE_ITEM(item);
6653949bee8SArchie Cobbs 			return (ENXIO);
6663949bee8SArchie Cobbs 		}
6673949bee8SArchie Cobbs 		proto = PROT_VJCOMP;
6683949bee8SArchie Cobbs 		break;
6693949bee8SArchie Cobbs 	case HOOK_INDEX_VJC_UNCOMP:
6703949bee8SArchie Cobbs 		if (!priv->conf.enableVJCompression) {
671069154d5SJulian Elischer 			NG_FREE_ITEM(item);
6723949bee8SArchie Cobbs 			return (ENXIO);
6733949bee8SArchie Cobbs 		}
6743949bee8SArchie Cobbs 		proto = PROT_VJUNCOMP;
6753949bee8SArchie Cobbs 		break;
6763949bee8SArchie Cobbs 	case HOOK_INDEX_COMPRESS:
677ccb07cc3SGleb Smirnoff 		switch (priv->conf.enableCompression) {
678ccb07cc3SGleb Smirnoff 		case NG_PPP_COMPRESS_FULL:
679ccb07cc3SGleb Smirnoff 			/*
680ccb07cc3SGleb Smirnoff 			 * In full compression mode sending of uncompressed
681ccb07cc3SGleb Smirnoff 			 * frames is permitted, so compressor must prepend
682ccb07cc3SGleb Smirnoff 			 * actual protocol number.
683ccb07cc3SGleb Smirnoff 	    		 */
684ccb07cc3SGleb Smirnoff 			if (m->m_pkthdr.len < 2) {
685ccb07cc3SGleb Smirnoff 				NG_FREE_ITEM(item);
686ccb07cc3SGleb Smirnoff 				return (EINVAL);
687ccb07cc3SGleb Smirnoff 			}
688ccb07cc3SGleb Smirnoff 			if (m->m_len < 2 && (m = m_pullup(m, 2)) == NULL) {
689ccb07cc3SGleb Smirnoff 				NGI_M(item) = NULL; /* don't free twice */
690ccb07cc3SGleb Smirnoff 				NG_FREE_ITEM(item);
691ccb07cc3SGleb Smirnoff 				return (ENOBUFS);
692ccb07cc3SGleb Smirnoff 			}
693ccb07cc3SGleb Smirnoff 			NGI_M(item) = m; /* m may have changed */
694ccb07cc3SGleb Smirnoff 			proto = ntohs(mtod(m, uint16_t *)[0]);
695ccb07cc3SGleb Smirnoff 			m_adj(m, 2);
696ccb07cc3SGleb Smirnoff 			break;
697ccb07cc3SGleb Smirnoff 
698ccb07cc3SGleb Smirnoff 		case NG_PPP_COMPRESS_SIMPLE:
699ccb07cc3SGleb Smirnoff 			proto = PROT_COMPD;
700ccb07cc3SGleb Smirnoff 			break;
701ccb07cc3SGleb Smirnoff 
702ccb07cc3SGleb Smirnoff 		case NG_PPP_COMPRESS_NONE:
703069154d5SJulian Elischer 			NG_FREE_ITEM(item);
7043949bee8SArchie Cobbs 			return (ENXIO);
7053949bee8SArchie Cobbs 		}
7063949bee8SArchie Cobbs 		break;
7073949bee8SArchie Cobbs 	case HOOK_INDEX_ENCRYPT:
7083949bee8SArchie Cobbs 		if (!priv->conf.enableEncryption) {
709069154d5SJulian Elischer 			NG_FREE_ITEM(item);
7103949bee8SArchie Cobbs 			return (ENXIO);
7113949bee8SArchie Cobbs 		}
7123949bee8SArchie Cobbs 		proto = PROT_CRYPTD;
7133949bee8SArchie Cobbs 		break;
7143949bee8SArchie Cobbs 	case HOOK_INDEX_BYPASS:
7153949bee8SArchie Cobbs 		if (m->m_pkthdr.len < 4) {
716069154d5SJulian Elischer 			NG_FREE_ITEM(item);
7173949bee8SArchie Cobbs 			return (EINVAL);
7183949bee8SArchie Cobbs 		}
7193949bee8SArchie Cobbs 		if (m->m_len < 4 && (m = m_pullup(m, 4)) == NULL) {
720069154d5SJulian Elischer 			NGI_M(item) = NULL; /* don't free twice */
721069154d5SJulian Elischer 			NG_FREE_ITEM(item);
7223949bee8SArchie Cobbs 			return (ENOBUFS);
7233949bee8SArchie Cobbs 		}
724069154d5SJulian Elischer 		NGI_M(item) = m; /* m may have changed */
7253949bee8SArchie Cobbs 		linkNum = ntohs(mtod(m, u_int16_t *)[0]);
7263949bee8SArchie Cobbs 		proto = ntohs(mtod(m, u_int16_t *)[1]);
7273949bee8SArchie Cobbs 		m_adj(m, 4);
7283949bee8SArchie Cobbs 		if (linkNum >= NG_PPP_MAX_LINKS
7294c641908SArchie Cobbs 		    && linkNum != NG_PPP_BUNDLE_LINKNUM) {
730069154d5SJulian Elischer 			NG_FREE_ITEM(item);
7313949bee8SArchie Cobbs 			return (EINVAL);
7324c641908SArchie Cobbs 		}
7333949bee8SArchie Cobbs 		break;
7343949bee8SArchie Cobbs 
735e149c4e2SArchie Cobbs 	/* Incoming data */
7363949bee8SArchie Cobbs 	case HOOK_INDEX_VJC_IP:
737e149c4e2SArchie Cobbs 		if (!priv->conf.enableIP || !priv->conf.enableVJDecompression) {
738069154d5SJulian Elischer 			NG_FREE_ITEM(item);
7393949bee8SArchie Cobbs 			return (ENXIO);
7403949bee8SArchie Cobbs 		}
7413949bee8SArchie Cobbs 		break;
7423949bee8SArchie Cobbs 	case HOOK_INDEX_DECOMPRESS:
7433949bee8SArchie Cobbs 		if (!priv->conf.enableDecompression) {
744069154d5SJulian Elischer 			NG_FREE_ITEM(item);
7453949bee8SArchie Cobbs 			return (ENXIO);
7463949bee8SArchie Cobbs 		}
7473949bee8SArchie Cobbs 		break;
7483949bee8SArchie Cobbs 	case HOOK_INDEX_DECRYPT:
7493949bee8SArchie Cobbs 		if (!priv->conf.enableDecryption) {
750069154d5SJulian Elischer 			NG_FREE_ITEM(item);
7513949bee8SArchie Cobbs 			return (ENXIO);
7523949bee8SArchie Cobbs 		}
7533949bee8SArchie Cobbs 		break;
7543949bee8SArchie Cobbs 	default:
7556e551fb6SDavid E. O'Brien 		panic("%s: bogus index 0x%x", __func__, index);
7563949bee8SArchie Cobbs 	}
7573949bee8SArchie Cobbs 
7583949bee8SArchie Cobbs 	/* Now figure out what to do with the frame */
7593949bee8SArchie Cobbs 	switch (index) {
760e149c4e2SArchie Cobbs 
761e149c4e2SArchie Cobbs 	/* Outgoing data */
7623949bee8SArchie Cobbs 	case HOOK_INDEX_INET:
7633949bee8SArchie Cobbs 		if (priv->conf.enableVJCompression && priv->vjCompHooked) {
7643949bee8SArchie Cobbs 			outHook = priv->hooks[HOOK_INDEX_VJC_IP];
7653949bee8SArchie Cobbs 			break;
7663949bee8SArchie Cobbs 		}
7673949bee8SArchie Cobbs 		/* FALLTHROUGH */
7683949bee8SArchie Cobbs 	case HOOK_INDEX_ATALK:
769a9b3dca5SArchie Cobbs 	case HOOK_INDEX_IPV6:
7703949bee8SArchie Cobbs 	case HOOK_INDEX_IPX:
7713949bee8SArchie Cobbs 	case HOOK_INDEX_VJC_COMP:
7723949bee8SArchie Cobbs 	case HOOK_INDEX_VJC_UNCOMP:
7733949bee8SArchie Cobbs 	case HOOK_INDEX_VJC_VJIP:
7743949bee8SArchie Cobbs 		if (priv->conf.enableCompression
7753949bee8SArchie Cobbs 		    && priv->hooks[HOOK_INDEX_COMPRESS] != NULL) {
7762adb8d6aSArchie Cobbs 			if ((m = ng_ppp_addproto(m, proto, 0)) == NULL) {
777069154d5SJulian Elischer 				NGI_M(item) = NULL;
778069154d5SJulian Elischer 				NG_FREE_ITEM(item);
7793949bee8SArchie Cobbs 				return (ENOBUFS);
7803949bee8SArchie Cobbs 			}
781069154d5SJulian Elischer 			NGI_M(item) = m; /* m may have changed */
7823949bee8SArchie Cobbs 			outHook = priv->hooks[HOOK_INDEX_COMPRESS];
7833949bee8SArchie Cobbs 			break;
7843949bee8SArchie Cobbs 		}
7853949bee8SArchie Cobbs 		/* FALLTHROUGH */
7863949bee8SArchie Cobbs 	case HOOK_INDEX_COMPRESS:
7873949bee8SArchie Cobbs 		if (priv->conf.enableEncryption
7883949bee8SArchie Cobbs 		    && priv->hooks[HOOK_INDEX_ENCRYPT] != NULL) {
7893949bee8SArchie Cobbs 			if ((m = ng_ppp_addproto(m, proto, 1)) == NULL) {
790069154d5SJulian Elischer 				NGI_M(item) = NULL;
791069154d5SJulian Elischer 				NG_FREE_ITEM(item);
7923949bee8SArchie Cobbs 				return (ENOBUFS);
7933949bee8SArchie Cobbs 			}
794069154d5SJulian Elischer 			NGI_M(item) = m; /* m may have changed */
7953949bee8SArchie Cobbs 			outHook = priv->hooks[HOOK_INDEX_ENCRYPT];
7963949bee8SArchie Cobbs 			break;
7973949bee8SArchie Cobbs 		}
7983949bee8SArchie Cobbs 		/* FALLTHROUGH */
7993949bee8SArchie Cobbs 	case HOOK_INDEX_ENCRYPT:
800069154d5SJulian Elischer 		return ng_ppp_output(node, 0, proto, NG_PPP_BUNDLE_LINKNUM, item);
8013949bee8SArchie Cobbs 
8020e11d0f3SArchie Cobbs 	case HOOK_INDEX_BYPASS:
803069154d5SJulian Elischer 		return ng_ppp_output(node, 1, proto, linkNum, item);
8040e11d0f3SArchie Cobbs 
8053949bee8SArchie Cobbs 	/* Incoming data */
8063949bee8SArchie Cobbs 	case HOOK_INDEX_DECRYPT:
8073949bee8SArchie Cobbs 	case HOOK_INDEX_DECOMPRESS:
808ccb07cc3SGleb Smirnoff 		return ng_ppp_input(node, 0, NG_PPP_BUNDLE_LINKNUM, item, index);
809e149c4e2SArchie Cobbs 
8103949bee8SArchie Cobbs 	case HOOK_INDEX_VJC_IP:
811e149c4e2SArchie Cobbs 		outHook = priv->hooks[HOOK_INDEX_INET];
812e149c4e2SArchie Cobbs 		break;
8133949bee8SArchie Cobbs 	}
8143949bee8SArchie Cobbs 
8153949bee8SArchie Cobbs 	/* Send packet out hook */
81630400f03SJulian Elischer 	NG_FWD_ITEM_HOOK(error, item, outHook);
8174cf49a43SJulian Elischer 	return (error);
8184cf49a43SJulian Elischer }
8194cf49a43SJulian Elischer 
8204cf49a43SJulian Elischer /*
8214cf49a43SJulian Elischer  * Destroy node
8224cf49a43SJulian Elischer  */
8234cf49a43SJulian Elischer static int
824069154d5SJulian Elischer ng_ppp_shutdown(node_p node)
8254cf49a43SJulian Elischer {
82630400f03SJulian Elischer 	const priv_p priv = NG_NODE_PRIVATE(node);
8274cf49a43SJulian Elischer 
828a9b3dca5SArchie Cobbs 	/* Stop fragment queue timer */
829a9b3dca5SArchie Cobbs 	ng_ppp_stop_frag_timer(node);
830a9b3dca5SArchie Cobbs 
8314cf49a43SJulian Elischer 	/* Take down netgraph node */
832a9b3dca5SArchie Cobbs 	ng_ppp_frag_reset(node);
8334cf49a43SJulian Elischer 	bzero(priv, sizeof(*priv));
8349c8c302fSJulian Elischer 	FREE(priv, M_NETGRAPH_PPP);
83530400f03SJulian Elischer 	NG_NODE_SET_PRIVATE(node, NULL);
83630400f03SJulian Elischer 	NG_NODE_UNREF(node);		/* let the node escape */
8374cf49a43SJulian Elischer 	return (0);
8384cf49a43SJulian Elischer }
8394cf49a43SJulian Elischer 
8404cf49a43SJulian Elischer /*
8414cf49a43SJulian Elischer  * Hook disconnection
8424cf49a43SJulian Elischer  */
8434cf49a43SJulian Elischer static int
8444cf49a43SJulian Elischer ng_ppp_disconnect(hook_p hook)
8454cf49a43SJulian Elischer {
84630400f03SJulian Elischer 	const node_p node = NG_HOOK_NODE(hook);
84730400f03SJulian Elischer 	const priv_p priv = NG_NODE_PRIVATE(node);
8488214d60eSJohn Baldwin 	const int index = (intptr_t)NG_HOOK_PRIVATE(hook);
84962838faeSArchie Cobbs 
85062838faeSArchie Cobbs 	/* Zero out hook pointer */
85162838faeSArchie Cobbs 	if (index < 0)
852a9b3dca5SArchie Cobbs 		priv->links[~index].hook = NULL;
85362838faeSArchie Cobbs 	else
85462838faeSArchie Cobbs 		priv->hooks[index] = NULL;
85562838faeSArchie Cobbs 
85662838faeSArchie Cobbs 	/* Update derived info (or go away if no hooks left) */
85730400f03SJulian Elischer 	if (NG_NODE_NUMHOOKS(node) > 0) {
85862838faeSArchie Cobbs 		ng_ppp_update(node, 0);
859069154d5SJulian Elischer 	} else {
86030400f03SJulian Elischer 		if (NG_NODE_IS_VALID(node)) {
861069154d5SJulian Elischer 			ng_rmnode_self(node);
862069154d5SJulian Elischer 		}
863069154d5SJulian Elischer 	}
8644cf49a43SJulian Elischer 	return (0);
8654cf49a43SJulian Elischer }
8664cf49a43SJulian Elischer 
8674cf49a43SJulian Elischer /************************************************************************
8684cf49a43SJulian Elischer 			HELPER STUFF
8694cf49a43SJulian Elischer  ************************************************************************/
8704cf49a43SJulian Elischer 
8714cf49a43SJulian Elischer /*
8723949bee8SArchie Cobbs  * Handle an incoming frame.  Extract the PPP protocol number
8733949bee8SArchie Cobbs  * and dispatch accordingly.
8744cf49a43SJulian Elischer  */
8754cf49a43SJulian Elischer static int
876ccb07cc3SGleb Smirnoff ng_ppp_input(node_p node, int bypass, int linkNum, item_p item, int index)
8774cf49a43SJulian Elischer {
87830400f03SJulian Elischer 	const priv_p priv = NG_NODE_PRIVATE(node);
8793949bee8SArchie Cobbs 	hook_p outHook = NULL;
8803949bee8SArchie Cobbs 	int proto, error;
881069154d5SJulian Elischer 	struct mbuf *m;
8824cf49a43SJulian Elischer 
883069154d5SJulian Elischer 
884069154d5SJulian Elischer 	NGI_GET_M(item, m);
8853949bee8SArchie Cobbs 	/* Extract protocol number */
8863949bee8SArchie Cobbs 	for (proto = 0; !PROT_VALID(proto) && m->m_pkthdr.len > 0; ) {
8873949bee8SArchie Cobbs 		if (m->m_len < 1 && (m = m_pullup(m, 1)) == NULL) {
888069154d5SJulian Elischer 			NG_FREE_ITEM(item);
8893949bee8SArchie Cobbs 			return (ENOBUFS);
8904cf49a43SJulian Elischer 		}
8913949bee8SArchie Cobbs 		proto = (proto << 8) + *mtod(m, u_char *);
8923949bee8SArchie Cobbs 		m_adj(m, 1);
8933949bee8SArchie Cobbs 	}
8943949bee8SArchie Cobbs 	if (!PROT_VALID(proto)) {
8953949bee8SArchie Cobbs 		if (linkNum == NG_PPP_BUNDLE_LINKNUM)
8963949bee8SArchie Cobbs 			priv->bundleStats.badProtos++;
8973949bee8SArchie Cobbs 		else
898a9b3dca5SArchie Cobbs 			priv->links[linkNum].stats.badProtos++;
899069154d5SJulian Elischer 		NG_FREE_ITEM(item);
900069154d5SJulian Elischer 		NG_FREE_M(m);
9013949bee8SArchie Cobbs 		return (EINVAL);
9023949bee8SArchie Cobbs 	}
9033949bee8SArchie Cobbs 
904e149c4e2SArchie Cobbs 	/* Bypass frame? */
905e149c4e2SArchie Cobbs 	if (bypass)
906e149c4e2SArchie Cobbs 		goto bypass;
907e149c4e2SArchie Cobbs 
908ccb07cc3SGleb Smirnoff 	/*
909ccb07cc3SGleb Smirnoff 	 * In full decompression mode we should pass any packet
910ccb07cc3SGleb Smirnoff 	 * to decompressor for dictionary update.
911ccb07cc3SGleb Smirnoff 	 */
912ccb07cc3SGleb Smirnoff 	if ((priv->conf.enableDecompression == NG_PPP_DECOMPRESS_FULL) &&
913ccb07cc3SGleb Smirnoff 	    (index < 0 || index == HOOK_INDEX_DECRYPT)) {
914ccb07cc3SGleb Smirnoff 
915ccb07cc3SGleb Smirnoff 		/* Check protocol */
916ccb07cc3SGleb Smirnoff 		switch (proto) {
917ccb07cc3SGleb Smirnoff 		case PROT_CRYPTD:
918ccb07cc3SGleb Smirnoff 			if (priv->conf.enableDecryption)
919ccb07cc3SGleb Smirnoff 				outHook = priv->hooks[HOOK_INDEX_DECRYPT];
920ccb07cc3SGleb Smirnoff 			break;
921ccb07cc3SGleb Smirnoff 		case PROT_MP:
922ccb07cc3SGleb Smirnoff 			if (priv->conf.enableMultilink &&
923ccb07cc3SGleb Smirnoff 			    linkNum != NG_PPP_BUNDLE_LINKNUM) {
924ccb07cc3SGleb Smirnoff 				NGI_M(item) = m;
925ccb07cc3SGleb Smirnoff 				return ng_ppp_mp_input(node, linkNum, item);
926ccb07cc3SGleb Smirnoff 			}
927ccb07cc3SGleb Smirnoff 			break;
928ccb07cc3SGleb Smirnoff 		case PROT_COMPD:
929ccb07cc3SGleb Smirnoff 		case PROT_VJCOMP:
930ccb07cc3SGleb Smirnoff 		case PROT_VJUNCOMP:
931ccb07cc3SGleb Smirnoff 		case PROT_APPLETALK:
932ccb07cc3SGleb Smirnoff 		case PROT_IPX:
933ccb07cc3SGleb Smirnoff 		case PROT_IP:
934ccb07cc3SGleb Smirnoff 		case PROT_IPV6:
935ccb07cc3SGleb Smirnoff 			if ((m = ng_ppp_addproto(m, proto, 0)) == NULL) {
936ccb07cc3SGleb Smirnoff 				NG_FREE_ITEM(item);
937ccb07cc3SGleb Smirnoff 				return (ENOBUFS);
938ccb07cc3SGleb Smirnoff 			}
939ccb07cc3SGleb Smirnoff 			outHook = priv->hooks[HOOK_INDEX_DECOMPRESS];
940ccb07cc3SGleb Smirnoff 			break;
941ccb07cc3SGleb Smirnoff 		}
942ccb07cc3SGleb Smirnoff 	} else {
943ccb07cc3SGleb Smirnoff 
9443949bee8SArchie Cobbs 		/* Check protocol */
9453949bee8SArchie Cobbs 		switch (proto) {
9463949bee8SArchie Cobbs 		case PROT_COMPD:
9473949bee8SArchie Cobbs 			if (priv->conf.enableDecompression)
9483949bee8SArchie Cobbs 				outHook = priv->hooks[HOOK_INDEX_DECOMPRESS];
9493949bee8SArchie Cobbs 			break;
9503949bee8SArchie Cobbs 		case PROT_CRYPTD:
9513949bee8SArchie Cobbs 			if (priv->conf.enableDecryption)
9523949bee8SArchie Cobbs 				outHook = priv->hooks[HOOK_INDEX_DECRYPT];
9533949bee8SArchie Cobbs 			break;
9543949bee8SArchie Cobbs 		case PROT_VJCOMP:
955ccb07cc3SGleb Smirnoff 			if (priv->conf.enableVJDecompression &&
956ccb07cc3SGleb Smirnoff 			    priv->vjCompHooked)
9573949bee8SArchie Cobbs 				outHook = priv->hooks[HOOK_INDEX_VJC_COMP];
9583949bee8SArchie Cobbs 			break;
9593949bee8SArchie Cobbs 		case PROT_VJUNCOMP:
960ccb07cc3SGleb Smirnoff 			if (priv->conf.enableVJDecompression &&
961ccb07cc3SGleb Smirnoff 			    priv->vjCompHooked)
9623949bee8SArchie Cobbs 				outHook = priv->hooks[HOOK_INDEX_VJC_UNCOMP];
9633949bee8SArchie Cobbs 			break;
9643949bee8SArchie Cobbs 		case PROT_MP:
965ccb07cc3SGleb Smirnoff 			if (priv->conf.enableMultilink &&
966ccb07cc3SGleb Smirnoff 			    linkNum != NG_PPP_BUNDLE_LINKNUM) {
967ed283669SJulian Elischer 				NGI_M(item) = m;
968069154d5SJulian Elischer 				return ng_ppp_mp_input(node, linkNum, item);
969ed283669SJulian Elischer 			}
9703949bee8SArchie Cobbs 			break;
9713949bee8SArchie Cobbs 		case PROT_APPLETALK:
9723949bee8SArchie Cobbs 			if (priv->conf.enableAtalk)
9733949bee8SArchie Cobbs 				outHook = priv->hooks[HOOK_INDEX_ATALK];
9743949bee8SArchie Cobbs 			break;
9753949bee8SArchie Cobbs 		case PROT_IPX:
9763949bee8SArchie Cobbs 			if (priv->conf.enableIPX)
9773949bee8SArchie Cobbs 				outHook = priv->hooks[HOOK_INDEX_IPX];
9783949bee8SArchie Cobbs 			break;
9793949bee8SArchie Cobbs 		case PROT_IP:
9803949bee8SArchie Cobbs 			if (priv->conf.enableIP)
9813949bee8SArchie Cobbs 				outHook = priv->hooks[HOOK_INDEX_INET];
9823949bee8SArchie Cobbs 			break;
983a9b3dca5SArchie Cobbs 		case PROT_IPV6:
984a9b3dca5SArchie Cobbs 			if (priv->conf.enableIPv6)
985a9b3dca5SArchie Cobbs 				outHook = priv->hooks[HOOK_INDEX_IPV6];
986a9b3dca5SArchie Cobbs 			break;
9873949bee8SArchie Cobbs 		}
988ccb07cc3SGleb Smirnoff 	}
9893949bee8SArchie Cobbs 
990e149c4e2SArchie Cobbs bypass:
9914c641908SArchie Cobbs 	/* For unknown/inactive protocols, forward out the bypass hook */
9923949bee8SArchie Cobbs 	if (outHook == NULL) {
993d690a6e7SArchie Cobbs 		u_int16_t hdr[2];
994d690a6e7SArchie Cobbs 
995d690a6e7SArchie Cobbs 		hdr[0] = htons(linkNum);
996d690a6e7SArchie Cobbs 		hdr[1] = htons((u_int16_t)proto);
9974c641908SArchie Cobbs 		if ((m = ng_ppp_prepend(m, &hdr, 4)) == NULL) {
998069154d5SJulian Elischer 			NG_FREE_ITEM(item);
9993949bee8SArchie Cobbs 			return (ENOBUFS);
10004c641908SArchie Cobbs 		}
10013949bee8SArchie Cobbs 		outHook = priv->hooks[HOOK_INDEX_BYPASS];
10023949bee8SArchie Cobbs 	}
10033949bee8SArchie Cobbs 
10043949bee8SArchie Cobbs 	/* Forward frame */
1005069154d5SJulian Elischer 	NG_FWD_NEW_DATA(error, item, outHook, m);
10063949bee8SArchie Cobbs 	return (error);
10074cf49a43SJulian Elischer }
10084cf49a43SJulian Elischer 
10094cf49a43SJulian Elischer /*
1010931c828aSArchie Cobbs  * Deliver a frame out a link, either a real one or NG_PPP_BUNDLE_LINKNUM.
10110e11d0f3SArchie Cobbs  * If the link is not enabled then ENXIO is returned, unless "bypass" is != 0.
1012931c828aSArchie Cobbs  *
1013931c828aSArchie Cobbs  * If the frame is too big for the particular link, return EMSGSIZE.
10144cf49a43SJulian Elischer  */
10153949bee8SArchie Cobbs static int
1016d690a6e7SArchie Cobbs ng_ppp_output(node_p node, int bypass,
1017069154d5SJulian Elischer 	int proto, int linkNum, item_p item)
10184cf49a43SJulian Elischer {
101930400f03SJulian Elischer 	const priv_p priv = NG_NODE_PRIVATE(node);
1020a9b3dca5SArchie Cobbs 	struct ng_ppp_link *link;
1021e149c4e2SArchie Cobbs 	int len, error;
1022069154d5SJulian Elischer 	struct mbuf *m;
1023931c828aSArchie Cobbs 	u_int16_t mru;
10244cf49a43SJulian Elischer 
1025931c828aSArchie Cobbs 	/* Extract mbuf */
1026931c828aSArchie Cobbs 	NGI_GET_M(item, m);
1027931c828aSArchie Cobbs 
1028d690a6e7SArchie Cobbs 	/* If not doing MP, map bundle virtual link to (the only) link */
1029d690a6e7SArchie Cobbs 	if (linkNum == NG_PPP_BUNDLE_LINKNUM && !priv->conf.enableMultilink)
10303949bee8SArchie Cobbs 		linkNum = priv->activeLinks[0];
10313949bee8SArchie Cobbs 
1032a9b3dca5SArchie Cobbs 	/* Get link pointer (optimization) */
1033a9b3dca5SArchie Cobbs 	link = (linkNum != NG_PPP_BUNDLE_LINKNUM) ?
1034a9b3dca5SArchie Cobbs 	    &priv->links[linkNum] : NULL;
1035a9b3dca5SArchie Cobbs 
1036d690a6e7SArchie Cobbs 	/* Check link status (if real) */
10370e11d0f3SArchie Cobbs 	if (linkNum != NG_PPP_BUNDLE_LINKNUM) {
1038a9b3dca5SArchie Cobbs 		if (!bypass && !link->conf.enableLink) {
1039069154d5SJulian Elischer 			NG_FREE_M(m);
1040069154d5SJulian Elischer 			NG_FREE_ITEM(item);
10413949bee8SArchie Cobbs 			return (ENXIO);
10424c641908SArchie Cobbs 		}
1043a9b3dca5SArchie Cobbs 		if (link->hook == NULL) {
1044069154d5SJulian Elischer 			NG_FREE_M(m);
1045069154d5SJulian Elischer 			NG_FREE_ITEM(item);
10463949bee8SArchie Cobbs 			return (ENETDOWN);
10473949bee8SArchie Cobbs 		}
10480e11d0f3SArchie Cobbs 	}
10493949bee8SArchie Cobbs 
1050931c828aSArchie Cobbs 	/* Check peer's MRU for this link */
1051931c828aSArchie Cobbs 	mru = (link != NULL) ? link->conf.mru : priv->conf.mrru;
1052931c828aSArchie Cobbs 	if (mru != 0 && m->m_pkthdr.len > mru) {
1053931c828aSArchie Cobbs 		NG_FREE_M(m);
1054931c828aSArchie Cobbs 		NG_FREE_ITEM(item);
1055931c828aSArchie Cobbs 		return (EMSGSIZE);
1056931c828aSArchie Cobbs 	}
1057931c828aSArchie Cobbs 
1058d690a6e7SArchie Cobbs 	/* Prepend protocol number, possibly compressed */
1059d690a6e7SArchie Cobbs 	if ((m = ng_ppp_addproto(m, proto,
1060d690a6e7SArchie Cobbs 	    linkNum == NG_PPP_BUNDLE_LINKNUM
1061a9b3dca5SArchie Cobbs 	      || link->conf.enableProtoComp)) == NULL) {
1062069154d5SJulian Elischer 		NG_FREE_ITEM(item);
1063d690a6e7SArchie Cobbs 		return (ENOBUFS);
1064d690a6e7SArchie Cobbs 	}
1065d690a6e7SArchie Cobbs 
1066d690a6e7SArchie Cobbs 	/* Special handling for the MP virtual link */
1067069154d5SJulian Elischer 	if (linkNum == NG_PPP_BUNDLE_LINKNUM) {
10683ca24c28SJulian Elischer 		/* discard the queue item */
1069069154d5SJulian Elischer 		NG_FREE_ITEM(item);
10703ca24c28SJulian Elischer 		return ng_ppp_mp_output(node, m);
1071069154d5SJulian Elischer 	}
1072d690a6e7SArchie Cobbs 
1073d690a6e7SArchie Cobbs 	/* Prepend address and control field (unless compressed) */
1074a9b3dca5SArchie Cobbs 	if (proto == PROT_LCP || !link->conf.enableACFComp) {
1075d690a6e7SArchie Cobbs 		if ((m = ng_ppp_prepend(m, &ng_ppp_acf, 2)) == NULL) {
1076069154d5SJulian Elischer 			NG_FREE_ITEM(item);
1077d690a6e7SArchie Cobbs 			return (ENOBUFS);
1078d690a6e7SArchie Cobbs 		}
1079d690a6e7SArchie Cobbs 	}
1080d690a6e7SArchie Cobbs 
10813949bee8SArchie Cobbs 	/* Deliver frame */
1082e149c4e2SArchie Cobbs 	len = m->m_pkthdr.len;
1083069154d5SJulian Elischer 	NG_FWD_NEW_DATA(error, item,  link->hook, m);
1084fb1fc8abSArchie Cobbs 
1085fb1fc8abSArchie Cobbs 	/* Update stats and 'bytes in queue' counter */
1086fb1fc8abSArchie Cobbs 	if (error == 0) {
1087a9b3dca5SArchie Cobbs 		link->stats.xmitFrames++;
1088a9b3dca5SArchie Cobbs 		link->stats.xmitOctets += len;
1089a9b3dca5SArchie Cobbs 		link->bytesInQueue += len;
1090a9b3dca5SArchie Cobbs 		getmicrouptime(&link->lastWrite);
1091fb1fc8abSArchie Cobbs 	}
10923949bee8SArchie Cobbs 	return error;
10933949bee8SArchie Cobbs }
10943949bee8SArchie Cobbs 
10953949bee8SArchie Cobbs /*
10963949bee8SArchie Cobbs  * Handle an incoming multi-link fragment
1097a9b3dca5SArchie Cobbs  *
1098a9b3dca5SArchie Cobbs  * The fragment reassembly algorithm is somewhat complex. This is mainly
1099a9b3dca5SArchie Cobbs  * because we are required not to reorder the reconstructed packets, yet
1100a9b3dca5SArchie Cobbs  * fragments are only guaranteed to arrive in order on a per-link basis.
1101a9b3dca5SArchie Cobbs  * In other words, when we have a complete packet ready, but the previous
1102a9b3dca5SArchie Cobbs  * packet is still incomplete, we have to decide between delivering the
1103a9b3dca5SArchie Cobbs  * complete packet and throwing away the incomplete one, or waiting to
1104a9b3dca5SArchie Cobbs  * see if the remainder of the incomplete one arrives, at which time we
1105a9b3dca5SArchie Cobbs  * can deliver both packets, in order.
1106a9b3dca5SArchie Cobbs  *
1107a9b3dca5SArchie Cobbs  * This problem is exacerbated by "sequence number slew", which is when
1108a9b3dca5SArchie Cobbs  * the sequence numbers coming in from different links are far apart from
1109a9b3dca5SArchie Cobbs  * each other. In particular, certain unnamed equipment (*cough* Ascend)
1110a9b3dca5SArchie Cobbs  * has been seen to generate sequence number slew of up to 10 on an ISDN
1111a9b3dca5SArchie Cobbs  * 2B-channel MP link. There is nothing invalid about sequence number slew
1112a9b3dca5SArchie Cobbs  * but it makes the reasssembly process have to work harder.
1113a9b3dca5SArchie Cobbs  *
1114a9b3dca5SArchie Cobbs  * However, the peer is required to transmit fragments in order on each
1115a9b3dca5SArchie Cobbs  * link. That means if we define MSEQ as the minimum over all links of
1116a9b3dca5SArchie Cobbs  * the highest sequence number received on that link, then we can always
1117a9b3dca5SArchie Cobbs  * give up any hope of receiving a fragment with sequence number < MSEQ in
1118a9b3dca5SArchie Cobbs  * the future (all of this using 'wraparound' sequence number space).
1119a9b3dca5SArchie Cobbs  * Therefore we can always immediately throw away incomplete packets
1120a9b3dca5SArchie Cobbs  * missing fragments with sequence numbers < MSEQ.
1121a9b3dca5SArchie Cobbs  *
1122a9b3dca5SArchie Cobbs  * Here is an overview of our algorithm:
1123a9b3dca5SArchie Cobbs  *
1124a9b3dca5SArchie Cobbs  *    o Received fragments are inserted into a queue, for which we
1125a9b3dca5SArchie Cobbs  *	maintain these invariants between calls to this function:
1126a9b3dca5SArchie Cobbs  *
1127a9b3dca5SArchie Cobbs  *	- Fragments are ordered in the queue by sequence number
1128a9b3dca5SArchie Cobbs  *	- If a complete packet is at the head of the queue, then
1129a9b3dca5SArchie Cobbs  *	  the first fragment in the packet has seq# > MSEQ + 1
1130a9b3dca5SArchie Cobbs  *	  (otherwise, we could deliver it immediately)
1131a9b3dca5SArchie Cobbs  *	- If any fragments have seq# < MSEQ, then they are necessarily
1132a9b3dca5SArchie Cobbs  *	  part of a packet whose missing seq#'s are all > MSEQ (otherwise,
1133a9b3dca5SArchie Cobbs  *	  we can throw them away because they'll never be completed)
1134a9b3dca5SArchie Cobbs  *	- The queue contains at most MP_MAX_QUEUE_LEN fragments
1135a9b3dca5SArchie Cobbs  *
1136a9b3dca5SArchie Cobbs  *    o We have a periodic timer that checks the queue for the first
1137a9b3dca5SArchie Cobbs  *	complete packet that has been sitting in the queue "too long".
1138a9b3dca5SArchie Cobbs  *	When one is detected, all previous (incomplete) fragments are
1139a9b3dca5SArchie Cobbs  *	discarded, their missing fragments are declared lost and MSEQ
1140a9b3dca5SArchie Cobbs  *	is increased.
1141a9b3dca5SArchie Cobbs  *
1142a9b3dca5SArchie Cobbs  *    o If we recieve a fragment with seq# < MSEQ, we throw it away
1143a9b3dca5SArchie Cobbs  *	because we've already delcared it lost.
1144a9b3dca5SArchie Cobbs  *
1145a9b3dca5SArchie Cobbs  * This assumes linkNum != NG_PPP_BUNDLE_LINKNUM.
11463949bee8SArchie Cobbs  */
11473949bee8SArchie Cobbs static int
1148069154d5SJulian Elischer ng_ppp_mp_input(node_p node, int linkNum, item_p item)
11493949bee8SArchie Cobbs {
115030400f03SJulian Elischer 	const priv_p priv = NG_NODE_PRIVATE(node);
1151a9b3dca5SArchie Cobbs 	struct ng_ppp_link *const link = &priv->links[linkNum];
11523949bee8SArchie Cobbs 	struct ng_ppp_frag frag0, *frag = &frag0;
1153a9b3dca5SArchie Cobbs 	struct ng_ppp_frag *qent;
1154a9b3dca5SArchie Cobbs 	int i, diff, inserted;
1155069154d5SJulian Elischer 	struct mbuf *m;
11563949bee8SArchie Cobbs 
1157069154d5SJulian Elischer 	NGI_GET_M(item, m);
1158069154d5SJulian Elischer 	NG_FREE_ITEM(item);
1159b4c44c30SArchie Cobbs 	/* Stats */
1160b4c44c30SArchie Cobbs 	priv->bundleStats.recvFrames++;
1161b4c44c30SArchie Cobbs 	priv->bundleStats.recvOctets += m->m_pkthdr.len;
1162b4c44c30SArchie Cobbs 
11633949bee8SArchie Cobbs 	/* Extract fragment information from MP header */
11643949bee8SArchie Cobbs 	if (priv->conf.recvShortSeq) {
11653949bee8SArchie Cobbs 		u_int16_t shdr;
11663949bee8SArchie Cobbs 
11673949bee8SArchie Cobbs 		if (m->m_pkthdr.len < 2) {
1168a9b3dca5SArchie Cobbs 			link->stats.runts++;
1169069154d5SJulian Elischer 			NG_FREE_M(m);
11703949bee8SArchie Cobbs 			return (EINVAL);
11713949bee8SArchie Cobbs 		}
11723ca24c28SJulian Elischer 		if (m->m_len < 2 && (m = m_pullup(m, 2)) == NULL)
11733949bee8SArchie Cobbs 			return (ENOBUFS);
11743ca24c28SJulian Elischer 
11753949bee8SArchie Cobbs 		shdr = ntohs(*mtod(m, u_int16_t *));
11766f16db81SArchie Cobbs 		frag->seq = MP_SHORT_EXTEND(shdr);
11773949bee8SArchie Cobbs 		frag->first = (shdr & MP_SHORT_FIRST_FLAG) != 0;
11783949bee8SArchie Cobbs 		frag->last = (shdr & MP_SHORT_LAST_FLAG) != 0;
1179a9b3dca5SArchie Cobbs 		diff = MP_SHORT_SEQ_DIFF(frag->seq, priv->mseq);
11803949bee8SArchie Cobbs 		m_adj(m, 2);
11813949bee8SArchie Cobbs 	} else {
11823949bee8SArchie Cobbs 		u_int32_t lhdr;
11833949bee8SArchie Cobbs 
11843949bee8SArchie Cobbs 		if (m->m_pkthdr.len < 4) {
1185a9b3dca5SArchie Cobbs 			link->stats.runts++;
1186069154d5SJulian Elischer 			NG_FREE_M(m);
11873949bee8SArchie Cobbs 			return (EINVAL);
11883949bee8SArchie Cobbs 		}
11893ca24c28SJulian Elischer 		if (m->m_len < 4 && (m = m_pullup(m, 4)) == NULL)
11903949bee8SArchie Cobbs 			return (ENOBUFS);
11913ca24c28SJulian Elischer 
11923949bee8SArchie Cobbs 		lhdr = ntohl(*mtod(m, u_int32_t *));
11936f16db81SArchie Cobbs 		frag->seq = MP_LONG_EXTEND(lhdr);
11943949bee8SArchie Cobbs 		frag->first = (lhdr & MP_LONG_FIRST_FLAG) != 0;
11953949bee8SArchie Cobbs 		frag->last = (lhdr & MP_LONG_LAST_FLAG) != 0;
1196a9b3dca5SArchie Cobbs 		diff = MP_LONG_SEQ_DIFF(frag->seq, priv->mseq);
11973949bee8SArchie Cobbs 		m_adj(m, 4);
11983949bee8SArchie Cobbs 	}
11993949bee8SArchie Cobbs 	frag->data = m;
1200a9b3dca5SArchie Cobbs 	getmicrouptime(&frag->timestamp);
12013949bee8SArchie Cobbs 
1202a9b3dca5SArchie Cobbs 	/* If sequence number is < MSEQ, we've already declared this
1203a9b3dca5SArchie Cobbs 	   fragment as lost, so we have no choice now but to drop it */
1204a9b3dca5SArchie Cobbs 	if (diff < 0) {
1205a9b3dca5SArchie Cobbs 		link->stats.dropFragments++;
1206069154d5SJulian Elischer 		NG_FREE_M(m);
1207a9b3dca5SArchie Cobbs 		return (0);
1208a9b3dca5SArchie Cobbs 	}
12093949bee8SArchie Cobbs 
1210a9b3dca5SArchie Cobbs 	/* Update highest received sequence number on this link and MSEQ */
1211a9b3dca5SArchie Cobbs 	priv->mseq = link->seq = frag->seq;
1212a9b3dca5SArchie Cobbs 	for (i = 0; i < priv->numActiveLinks; i++) {
1213a9b3dca5SArchie Cobbs 		struct ng_ppp_link *const alink =
1214a9b3dca5SArchie Cobbs 		    &priv->links[priv->activeLinks[i]];
1215a9b3dca5SArchie Cobbs 
12166f16db81SArchie Cobbs 		if (MP_RECV_SEQ_DIFF(priv, alink->seq, priv->mseq) < 0)
1217a9b3dca5SArchie Cobbs 			priv->mseq = alink->seq;
1218a9b3dca5SArchie Cobbs 	}
12193949bee8SArchie Cobbs 
12203949bee8SArchie Cobbs 	/* Allocate a new frag struct for the queue */
12219c8c302fSJulian Elischer 	MALLOC(frag, struct ng_ppp_frag *, sizeof(*frag), M_NETGRAPH_PPP, M_NOWAIT);
12223949bee8SArchie Cobbs 	if (frag == NULL) {
1223069154d5SJulian Elischer 		NG_FREE_M(m);
1224a9b3dca5SArchie Cobbs 		ng_ppp_frag_process(node);
12253949bee8SArchie Cobbs 		return (ENOMEM);
12263949bee8SArchie Cobbs 	}
12273949bee8SArchie Cobbs 	*frag = frag0;
12283949bee8SArchie Cobbs 
1229a9b3dca5SArchie Cobbs 	/* Add fragment to queue, which is sorted by sequence number */
12301e7a9f72SArchie Cobbs 	inserted = 0;
12315f90cac7SKirk McKusick 	TAILQ_FOREACH_REVERSE(qent, &priv->frags, ng_ppp_fraglist, f_qent) {
12326f16db81SArchie Cobbs 		diff = MP_RECV_SEQ_DIFF(priv, frag->seq, qent->seq);
12333949bee8SArchie Cobbs 		if (diff > 0) {
12345f90cac7SKirk McKusick 			TAILQ_INSERT_AFTER(&priv->frags, qent, frag, f_qent);
12351e7a9f72SArchie Cobbs 			inserted = 1;
12363949bee8SArchie Cobbs 			break;
12373949bee8SArchie Cobbs 		} else if (diff == 0) {	     /* should never happen! */
1238a9b3dca5SArchie Cobbs 			link->stats.dupFragments++;
1239069154d5SJulian Elischer 			NG_FREE_M(frag->data);
12409c8c302fSJulian Elischer 			FREE(frag, M_NETGRAPH_PPP);
12413949bee8SArchie Cobbs 			return (EINVAL);
12423949bee8SArchie Cobbs 		}
12433949bee8SArchie Cobbs 	}
12441e7a9f72SArchie Cobbs 	if (!inserted)
12455f90cac7SKirk McKusick 		TAILQ_INSERT_HEAD(&priv->frags, frag, f_qent);
1246a9b3dca5SArchie Cobbs 	priv->qlen++;
12473949bee8SArchie Cobbs 
1248a9b3dca5SArchie Cobbs 	/* Process the queue */
1249a9b3dca5SArchie Cobbs 	return ng_ppp_frag_process(node);
12503949bee8SArchie Cobbs }
12511e7a9f72SArchie Cobbs 
1252a9b3dca5SArchie Cobbs /*
1253a9b3dca5SArchie Cobbs  * Examine our list of fragments, and determine if there is a
1254a9b3dca5SArchie Cobbs  * complete and deliverable packet at the head of the list.
1255a9b3dca5SArchie Cobbs  * Return 1 if so, zero otherwise.
1256a9b3dca5SArchie Cobbs  */
1257a9b3dca5SArchie Cobbs static int
1258a9b3dca5SArchie Cobbs ng_ppp_check_packet(node_p node)
1259a9b3dca5SArchie Cobbs {
126030400f03SJulian Elischer 	const priv_p priv = NG_NODE_PRIVATE(node);
1261a9b3dca5SArchie Cobbs 	struct ng_ppp_frag *qent, *qnext;
12623949bee8SArchie Cobbs 
1263a9b3dca5SArchie Cobbs 	/* Check for empty queue */
12645f90cac7SKirk McKusick 	if (TAILQ_EMPTY(&priv->frags))
1265a9b3dca5SArchie Cobbs 		return (0);
1266a9b3dca5SArchie Cobbs 
1267a9b3dca5SArchie Cobbs 	/* Check first fragment is the start of a deliverable packet */
12685f90cac7SKirk McKusick 	qent = TAILQ_FIRST(&priv->frags);
12696f16db81SArchie Cobbs 	if (!qent->first || MP_RECV_SEQ_DIFF(priv, qent->seq, priv->mseq) > 1)
1270a9b3dca5SArchie Cobbs 		return (0);
1271a9b3dca5SArchie Cobbs 
1272a9b3dca5SArchie Cobbs 	/* Check that all the fragments are there */
1273a9b3dca5SArchie Cobbs 	while (!qent->last) {
12745f90cac7SKirk McKusick 		qnext = TAILQ_NEXT(qent, f_qent);
12755f90cac7SKirk McKusick 		if (qnext == NULL)	/* end of queue */
1276a9b3dca5SArchie Cobbs 			return (0);
12776f16db81SArchie Cobbs 		if (qnext->seq != MP_NEXT_RECV_SEQ(priv, qent->seq))
1278a9b3dca5SArchie Cobbs 			return (0);
1279a9b3dca5SArchie Cobbs 		qent = qnext;
1280a9b3dca5SArchie Cobbs 	}
1281a9b3dca5SArchie Cobbs 
1282a9b3dca5SArchie Cobbs 	/* Got one */
1283a9b3dca5SArchie Cobbs 	return (1);
1284a9b3dca5SArchie Cobbs }
1285a9b3dca5SArchie Cobbs 
1286a9b3dca5SArchie Cobbs /*
1287a9b3dca5SArchie Cobbs  * Pull a completed packet off the head of the incoming fragment queue.
1288a9b3dca5SArchie Cobbs  * This assumes there is a completed packet there to pull off.
1289a9b3dca5SArchie Cobbs  */
1290a9b3dca5SArchie Cobbs static void
12913ca24c28SJulian Elischer ng_ppp_get_packet(node_p node, struct mbuf **mp)
1292a9b3dca5SArchie Cobbs {
129330400f03SJulian Elischer 	const priv_p priv = NG_NODE_PRIVATE(node);
1294a9b3dca5SArchie Cobbs 	struct ng_ppp_frag *qent, *qnext;
1295a9b3dca5SArchie Cobbs 	struct mbuf *m = NULL, *tail;
1296a9b3dca5SArchie Cobbs 
12975f90cac7SKirk McKusick 	qent = TAILQ_FIRST(&priv->frags);
12985f90cac7SKirk McKusick 	KASSERT(!TAILQ_EMPTY(&priv->frags) && qent->first,
12996e551fb6SDavid E. O'Brien 	    ("%s: no packet", __func__));
1300a9b3dca5SArchie Cobbs 	for (tail = NULL; qent != NULL; qent = qnext) {
13015f90cac7SKirk McKusick 		qnext = TAILQ_NEXT(qent, f_qent);
13025f90cac7SKirk McKusick 		KASSERT(!TAILQ_EMPTY(&priv->frags),
13036e551fb6SDavid E. O'Brien 		    ("%s: empty q", __func__));
13045f90cac7SKirk McKusick 		TAILQ_REMOVE(&priv->frags, qent, f_qent);
13053ca24c28SJulian Elischer 		if (tail == NULL)
13063949bee8SArchie Cobbs 			tail = m = qent->data;
13073ca24c28SJulian Elischer 		else {
13083949bee8SArchie Cobbs 			m->m_pkthdr.len += qent->data->m_pkthdr.len;
13093949bee8SArchie Cobbs 			tail->m_next = qent->data;
13103949bee8SArchie Cobbs 		}
13113949bee8SArchie Cobbs 		while (tail->m_next != NULL)
13123949bee8SArchie Cobbs 			tail = tail->m_next;
1313a9b3dca5SArchie Cobbs 		if (qent->last)
13143949bee8SArchie Cobbs 			qnext = NULL;
13159c8c302fSJulian Elischer 		FREE(qent, M_NETGRAPH_PPP);
1316a9b3dca5SArchie Cobbs 		priv->qlen--;
1317a9b3dca5SArchie Cobbs 	}
1318a9b3dca5SArchie Cobbs 	*mp = m;
13193949bee8SArchie Cobbs }
13203949bee8SArchie Cobbs 
1321a9b3dca5SArchie Cobbs /*
1322a9b3dca5SArchie Cobbs  * Trim fragments from the queue whose packets can never be completed.
1323a9b3dca5SArchie Cobbs  * This assumes a complete packet is NOT at the beginning of the queue.
1324a9b3dca5SArchie Cobbs  * Returns 1 if fragments were removed, zero otherwise.
1325a9b3dca5SArchie Cobbs  */
1326a9b3dca5SArchie Cobbs static int
1327a9b3dca5SArchie Cobbs ng_ppp_frag_trim(node_p node)
1328a9b3dca5SArchie Cobbs {
132930400f03SJulian Elischer 	const priv_p priv = NG_NODE_PRIVATE(node);
1330a9b3dca5SArchie Cobbs 	struct ng_ppp_frag *qent, *qnext = NULL;
1331a9b3dca5SArchie Cobbs 	int removed = 0;
1332a9b3dca5SArchie Cobbs 
1333a9b3dca5SArchie Cobbs 	/* Scan for "dead" fragments and remove them */
1334a9b3dca5SArchie Cobbs 	while (1) {
1335a9b3dca5SArchie Cobbs 		int dead = 0;
1336a9b3dca5SArchie Cobbs 
1337a9b3dca5SArchie Cobbs 		/* If queue is empty, we're done */
13385f90cac7SKirk McKusick 		if (TAILQ_EMPTY(&priv->frags))
13393949bee8SArchie Cobbs 			break;
1340a9b3dca5SArchie Cobbs 
1341a9b3dca5SArchie Cobbs 		/* Determine whether first fragment can ever be completed */
13425f90cac7SKirk McKusick 		TAILQ_FOREACH(qent, &priv->frags, f_qent) {
13436f16db81SArchie Cobbs 			if (MP_RECV_SEQ_DIFF(priv, qent->seq, priv->mseq) >= 0)
1344a9b3dca5SArchie Cobbs 				break;
13455f90cac7SKirk McKusick 			qnext = TAILQ_NEXT(qent, f_qent);
13465f90cac7SKirk McKusick 			KASSERT(qnext != NULL,
13476e551fb6SDavid E. O'Brien 			    ("%s: last frag < MSEQ?", __func__));
13486f16db81SArchie Cobbs 			if (qnext->seq != MP_NEXT_RECV_SEQ(priv, qent->seq)
1349a9b3dca5SArchie Cobbs 			    || qent->last || qnext->first) {
1350a9b3dca5SArchie Cobbs 				dead = 1;
1351a9b3dca5SArchie Cobbs 				break;
1352a9b3dca5SArchie Cobbs 			}
1353a9b3dca5SArchie Cobbs 		}
1354a9b3dca5SArchie Cobbs 		if (!dead)
1355a9b3dca5SArchie Cobbs 			break;
1356a9b3dca5SArchie Cobbs 
1357a9b3dca5SArchie Cobbs 		/* Remove fragment and all others in the same packet */
13585f90cac7SKirk McKusick 		while ((qent = TAILQ_FIRST(&priv->frags)) != qnext) {
13595f90cac7SKirk McKusick 			KASSERT(!TAILQ_EMPTY(&priv->frags),
13606e551fb6SDavid E. O'Brien 			    ("%s: empty q", __func__));
1361a9b3dca5SArchie Cobbs 			priv->bundleStats.dropFragments++;
13625f90cac7SKirk McKusick 			TAILQ_REMOVE(&priv->frags, qent, f_qent);
1363069154d5SJulian Elischer 			NG_FREE_M(qent->data);
13649c8c302fSJulian Elischer 			FREE(qent, M_NETGRAPH_PPP);
1365a9b3dca5SArchie Cobbs 			priv->qlen--;
1366a9b3dca5SArchie Cobbs 			removed = 1;
1367a9b3dca5SArchie Cobbs 		}
1368a9b3dca5SArchie Cobbs 	}
1369a9b3dca5SArchie Cobbs 	return (removed);
13703949bee8SArchie Cobbs }
13713949bee8SArchie Cobbs 
1372a9b3dca5SArchie Cobbs /*
1373a9b3dca5SArchie Cobbs  * Run the queue, restoring the queue invariants
1374a9b3dca5SArchie Cobbs  */
1375a9b3dca5SArchie Cobbs static int
1376a9b3dca5SArchie Cobbs ng_ppp_frag_process(node_p node)
1377a9b3dca5SArchie Cobbs {
137830400f03SJulian Elischer 	const priv_p priv = NG_NODE_PRIVATE(node);
1379a9b3dca5SArchie Cobbs 	struct mbuf *m;
1380069154d5SJulian Elischer 	item_p item;
1381a9b3dca5SArchie Cobbs 
1382a9b3dca5SArchie Cobbs 	/* Deliver any deliverable packets */
1383a9b3dca5SArchie Cobbs 	while (ng_ppp_check_packet(node)) {
13843ca24c28SJulian Elischer 		ng_ppp_get_packet(node, &m);
1385d0784b47SGleb Smirnoff 		if ((item = ng_package_data(m, NG_NOFLAGS)) != NULL)
1386ccb07cc3SGleb Smirnoff 			ng_ppp_input(node, 0, NG_PPP_BUNDLE_LINKNUM, item,
1387ccb07cc3SGleb Smirnoff 			    ~((int)NG_PPP_BUNDLE_LINKNUM));
1388a9b3dca5SArchie Cobbs 	}
1389a9b3dca5SArchie Cobbs 
1390a9b3dca5SArchie Cobbs 	/* Delete dead fragments and try again */
1391a9b3dca5SArchie Cobbs 	if (ng_ppp_frag_trim(node)) {
1392a9b3dca5SArchie Cobbs 		while (ng_ppp_check_packet(node)) {
13933ca24c28SJulian Elischer 			ng_ppp_get_packet(node, &m);
1394d0784b47SGleb Smirnoff 			if ((item = ng_package_data(m, NG_NOFLAGS)) != NULL)
1395d0784b47SGleb Smirnoff 				ng_ppp_input(node, 0, NG_PPP_BUNDLE_LINKNUM,
1396ccb07cc3SGleb Smirnoff 				    item, ~((int)NG_PPP_BUNDLE_LINKNUM));
1397a9b3dca5SArchie Cobbs 		}
1398a9b3dca5SArchie Cobbs 	}
1399a9b3dca5SArchie Cobbs 
1400a9b3dca5SArchie Cobbs 	/* Check for stale fragments while we're here */
1401a9b3dca5SArchie Cobbs 	ng_ppp_frag_checkstale(node);
1402a9b3dca5SArchie Cobbs 
1403a9b3dca5SArchie Cobbs 	/* Check queue length */
1404a9b3dca5SArchie Cobbs 	if (priv->qlen > MP_MAX_QUEUE_LEN) {
1405a9b3dca5SArchie Cobbs 		struct ng_ppp_frag *qent;
1406a9b3dca5SArchie Cobbs 		int i;
1407a9b3dca5SArchie Cobbs 
1408a9b3dca5SArchie Cobbs 		/* Get oldest fragment */
14095f90cac7SKirk McKusick 		KASSERT(!TAILQ_EMPTY(&priv->frags),
14106e551fb6SDavid E. O'Brien 		    ("%s: empty q", __func__));
14115f90cac7SKirk McKusick 		qent = TAILQ_FIRST(&priv->frags);
1412a9b3dca5SArchie Cobbs 
1413a9b3dca5SArchie Cobbs 		/* Bump MSEQ if necessary */
14146f16db81SArchie Cobbs 		if (MP_RECV_SEQ_DIFF(priv, priv->mseq, qent->seq) < 0) {
1415a9b3dca5SArchie Cobbs 			priv->mseq = qent->seq;
1416a9b3dca5SArchie Cobbs 			for (i = 0; i < priv->numActiveLinks; i++) {
1417a9b3dca5SArchie Cobbs 				struct ng_ppp_link *const alink =
1418a9b3dca5SArchie Cobbs 				    &priv->links[priv->activeLinks[i]];
1419a9b3dca5SArchie Cobbs 
14206f16db81SArchie Cobbs 				if (MP_RECV_SEQ_DIFF(priv,
1421a9b3dca5SArchie Cobbs 				    alink->seq, priv->mseq) < 0)
1422a9b3dca5SArchie Cobbs 					alink->seq = priv->mseq;
1423a9b3dca5SArchie Cobbs 			}
1424a9b3dca5SArchie Cobbs 		}
1425a9b3dca5SArchie Cobbs 
1426a9b3dca5SArchie Cobbs 		/* Drop it */
1427a9b3dca5SArchie Cobbs 		priv->bundleStats.dropFragments++;
14285f90cac7SKirk McKusick 		TAILQ_REMOVE(&priv->frags, qent, f_qent);
1429069154d5SJulian Elischer 		NG_FREE_M(qent->data);
14309c8c302fSJulian Elischer 		FREE(qent, M_NETGRAPH_PPP);
1431a9b3dca5SArchie Cobbs 		priv->qlen--;
1432a9b3dca5SArchie Cobbs 
1433a9b3dca5SArchie Cobbs 		/* Process queue again */
1434a9b3dca5SArchie Cobbs 		return ng_ppp_frag_process(node);
1435a9b3dca5SArchie Cobbs 	}
1436a9b3dca5SArchie Cobbs 
1437a9b3dca5SArchie Cobbs 	/* Done */
1438a9b3dca5SArchie Cobbs 	return (0);
1439a9b3dca5SArchie Cobbs }
1440a9b3dca5SArchie Cobbs 
1441a9b3dca5SArchie Cobbs /*
1442a9b3dca5SArchie Cobbs  * Check for 'stale' completed packets that need to be delivered
1443a9b3dca5SArchie Cobbs  *
1444a9b3dca5SArchie Cobbs  * If a link goes down or has a temporary failure, MSEQ can get
1445a9b3dca5SArchie Cobbs  * "stuck", because no new incoming fragments appear on that link.
1446a9b3dca5SArchie Cobbs  * This can cause completed packets to never get delivered if
1447a9b3dca5SArchie Cobbs  * their sequence numbers are all > MSEQ + 1.
1448a9b3dca5SArchie Cobbs  *
1449a9b3dca5SArchie Cobbs  * This routine checks how long all of the completed packets have
1450a9b3dca5SArchie Cobbs  * been sitting in the queue, and if too long, removes fragments
1451a9b3dca5SArchie Cobbs  * from the queue and increments MSEQ to allow them to be delivered.
1452a9b3dca5SArchie Cobbs  */
1453a9b3dca5SArchie Cobbs static void
1454a9b3dca5SArchie Cobbs ng_ppp_frag_checkstale(node_p node)
1455a9b3dca5SArchie Cobbs {
145630400f03SJulian Elischer 	const priv_p priv = NG_NODE_PRIVATE(node);
1457a9b3dca5SArchie Cobbs 	struct ng_ppp_frag *qent, *beg, *end;
1458a9b3dca5SArchie Cobbs 	struct timeval now, age;
1459a9b3dca5SArchie Cobbs 	struct mbuf *m;
1460a9b3dca5SArchie Cobbs 	int i, seq;
1461069154d5SJulian Elischer 	item_p item;
14622b2a8188SArchie Cobbs 	int endseq;
1463a9b3dca5SArchie Cobbs 
1464a9b3dca5SArchie Cobbs 	now.tv_sec = 0;			/* uninitialized state */
1465a9b3dca5SArchie Cobbs 	while (1) {
1466a9b3dca5SArchie Cobbs 
1467a9b3dca5SArchie Cobbs 		/* If queue is empty, we're done */
14685f90cac7SKirk McKusick 		if (TAILQ_EMPTY(&priv->frags))
1469a9b3dca5SArchie Cobbs 			break;
1470a9b3dca5SArchie Cobbs 
1471a9b3dca5SArchie Cobbs 		/* Find the first complete packet in the queue */
1472a9b3dca5SArchie Cobbs 		beg = end = NULL;
14735f90cac7SKirk McKusick 		seq = TAILQ_FIRST(&priv->frags)->seq;
14745f90cac7SKirk McKusick 		TAILQ_FOREACH(qent, &priv->frags, f_qent) {
1475a9b3dca5SArchie Cobbs 			if (qent->first)
1476a9b3dca5SArchie Cobbs 				beg = qent;
1477a9b3dca5SArchie Cobbs 			else if (qent->seq != seq)
1478a9b3dca5SArchie Cobbs 				beg = NULL;
1479a9b3dca5SArchie Cobbs 			if (beg != NULL && qent->last) {
1480a9b3dca5SArchie Cobbs 				end = qent;
1481a9b3dca5SArchie Cobbs 				break;
1482a9b3dca5SArchie Cobbs 			}
14836f16db81SArchie Cobbs 			seq = MP_NEXT_RECV_SEQ(priv, seq);
1484a9b3dca5SArchie Cobbs 		}
1485a9b3dca5SArchie Cobbs 
1486a9b3dca5SArchie Cobbs 		/* If none found, exit */
1487a9b3dca5SArchie Cobbs 		if (end == NULL)
1488a9b3dca5SArchie Cobbs 			break;
1489a9b3dca5SArchie Cobbs 
1490a9b3dca5SArchie Cobbs 		/* Get current time (we assume we've been up for >= 1 second) */
1491a9b3dca5SArchie Cobbs 		if (now.tv_sec == 0)
1492a9b3dca5SArchie Cobbs 			getmicrouptime(&now);
1493a9b3dca5SArchie Cobbs 
1494a9b3dca5SArchie Cobbs 		/* Check if packet has been queued too long */
1495a9b3dca5SArchie Cobbs 		age = now;
1496a9b3dca5SArchie Cobbs 		timevalsub(&age, &beg->timestamp);
1497a9b3dca5SArchie Cobbs 		if (timevalcmp(&age, &ng_ppp_max_staleness, < ))
1498a9b3dca5SArchie Cobbs 			break;
1499a9b3dca5SArchie Cobbs 
1500a9b3dca5SArchie Cobbs 		/* Throw away junk fragments in front of the completed packet */
15015f90cac7SKirk McKusick 		while ((qent = TAILQ_FIRST(&priv->frags)) != beg) {
15025f90cac7SKirk McKusick 			KASSERT(!TAILQ_EMPTY(&priv->frags),
15036e551fb6SDavid E. O'Brien 			    ("%s: empty q", __func__));
1504a9b3dca5SArchie Cobbs 			priv->bundleStats.dropFragments++;
15055f90cac7SKirk McKusick 			TAILQ_REMOVE(&priv->frags, qent, f_qent);
1506069154d5SJulian Elischer 			NG_FREE_M(qent->data);
15079c8c302fSJulian Elischer 			FREE(qent, M_NETGRAPH_PPP);
1508a9b3dca5SArchie Cobbs 			priv->qlen--;
1509a9b3dca5SArchie Cobbs 		}
1510a9b3dca5SArchie Cobbs 
1511a9b3dca5SArchie Cobbs 		/* Extract completed packet */
15122b2a8188SArchie Cobbs 		endseq = end->seq;
15133ca24c28SJulian Elischer 		ng_ppp_get_packet(node, &m);
1514a9b3dca5SArchie Cobbs 
1515a9b3dca5SArchie Cobbs 		/* Bump MSEQ if necessary */
15162b2a8188SArchie Cobbs 		if (MP_RECV_SEQ_DIFF(priv, priv->mseq, endseq) < 0) {
15172b2a8188SArchie Cobbs 			priv->mseq = endseq;
1518a9b3dca5SArchie Cobbs 			for (i = 0; i < priv->numActiveLinks; i++) {
1519a9b3dca5SArchie Cobbs 				struct ng_ppp_link *const alink =
1520a9b3dca5SArchie Cobbs 				    &priv->links[priv->activeLinks[i]];
1521a9b3dca5SArchie Cobbs 
15226f16db81SArchie Cobbs 				if (MP_RECV_SEQ_DIFF(priv,
1523a9b3dca5SArchie Cobbs 				    alink->seq, priv->mseq) < 0)
1524a9b3dca5SArchie Cobbs 					alink->seq = priv->mseq;
1525a9b3dca5SArchie Cobbs 			}
1526a9b3dca5SArchie Cobbs 		}
1527a9b3dca5SArchie Cobbs 
1528a9b3dca5SArchie Cobbs 		/* Deliver packet */
152974eafa88SGleb Smirnoff 		if ((item = ng_package_data(m, NG_NOFLAGS)) != NULL)
1530ccb07cc3SGleb Smirnoff 			ng_ppp_input(node, 0, NG_PPP_BUNDLE_LINKNUM, item,
1531ccb07cc3SGleb Smirnoff 			    ~((int)NG_PPP_BUNDLE_LINKNUM));
1532a9b3dca5SArchie Cobbs 	}
1533a9b3dca5SArchie Cobbs }
1534a9b3dca5SArchie Cobbs 
1535a9b3dca5SArchie Cobbs /*
1536a9b3dca5SArchie Cobbs  * Periodically call ng_ppp_frag_checkstale()
1537a9b3dca5SArchie Cobbs  */
1538a9b3dca5SArchie Cobbs static void
15399d952bd3SGleb Smirnoff ng_ppp_frag_timeout(node_p node, hook_p hook, void *arg1, int arg2)
1540a9b3dca5SArchie Cobbs {
15419d952bd3SGleb Smirnoff 	/* XXX: is this needed? */
15429d952bd3SGleb Smirnoff 	if (NG_NODE_NOT_VALID(node))
1543a9b3dca5SArchie Cobbs 		return;
1544a9b3dca5SArchie Cobbs 
1545a9b3dca5SArchie Cobbs 	/* Scan the fragment queue */
1546a9b3dca5SArchie Cobbs 	ng_ppp_frag_checkstale(node);
15479d952bd3SGleb Smirnoff 
15489d952bd3SGleb Smirnoff 	/* Start timer again */
15499d952bd3SGleb Smirnoff 	ng_ppp_start_frag_timer(node);
15503949bee8SArchie Cobbs }
15513949bee8SArchie Cobbs 
15523949bee8SArchie Cobbs /*
15533949bee8SArchie Cobbs  * Deliver a frame out on the bundle, i.e., figure out how to fragment
15543949bee8SArchie Cobbs  * the frame across the individual PPP links and do so.
15553949bee8SArchie Cobbs  */
15563949bee8SArchie Cobbs static int
15573ca24c28SJulian Elischer ng_ppp_mp_output(node_p node, struct mbuf *m)
15583949bee8SArchie Cobbs {
155930400f03SJulian Elischer 	const priv_p priv = NG_NODE_PRIVATE(node);
1560931c828aSArchie Cobbs 	const int hdr_len = priv->conf.xmitShortSeq ? 2 : 4;
15613949bee8SArchie Cobbs 	int distrib[NG_PPP_MAX_LINKS];
15623949bee8SArchie Cobbs 	int firstFragment;
15633949bee8SArchie Cobbs 	int activeLinkNum;
1564069154d5SJulian Elischer 	item_p item;
15653949bee8SArchie Cobbs 
15663949bee8SArchie Cobbs 	/* At least one link must be active */
15673949bee8SArchie Cobbs 	if (priv->numActiveLinks == 0) {
1568069154d5SJulian Elischer 		NG_FREE_M(m);
15693949bee8SArchie Cobbs 		return (ENETDOWN);
15703949bee8SArchie Cobbs 	}
15713949bee8SArchie Cobbs 
15723949bee8SArchie Cobbs 	/* Round-robin strategy */
15733949bee8SArchie Cobbs 	if (priv->conf.enableRoundRobin || m->m_pkthdr.len < MP_MIN_FRAG_LEN) {
15743949bee8SArchie Cobbs 		activeLinkNum = priv->lastLink++ % priv->numActiveLinks;
15753949bee8SArchie Cobbs 		bzero(&distrib, priv->numActiveLinks * sizeof(distrib[0]));
15763949bee8SArchie Cobbs 		distrib[activeLinkNum] = m->m_pkthdr.len;
15773949bee8SArchie Cobbs 		goto deliver;
15783949bee8SArchie Cobbs 	}
15793949bee8SArchie Cobbs 
15803949bee8SArchie Cobbs 	/* Strategy when all links are equivalent (optimize the common case) */
15813949bee8SArchie Cobbs 	if (priv->allLinksEqual) {
15823949bee8SArchie Cobbs 		const int fraction = m->m_pkthdr.len / priv->numActiveLinks;
15833949bee8SArchie Cobbs 		int i, remain;
15843949bee8SArchie Cobbs 
15853949bee8SArchie Cobbs 		for (i = 0; i < priv->numActiveLinks; i++)
15863949bee8SArchie Cobbs 			distrib[priv->lastLink++ % priv->numActiveLinks]
15873949bee8SArchie Cobbs 			    = fraction;
15883949bee8SArchie Cobbs 		remain = m->m_pkthdr.len - (fraction * priv->numActiveLinks);
15893949bee8SArchie Cobbs 		while (remain > 0) {
15903949bee8SArchie Cobbs 			distrib[priv->lastLink++ % priv->numActiveLinks]++;
15913949bee8SArchie Cobbs 			remain--;
15923949bee8SArchie Cobbs 		}
15933949bee8SArchie Cobbs 		goto deliver;
15943949bee8SArchie Cobbs 	}
15953949bee8SArchie Cobbs 
15963949bee8SArchie Cobbs 	/* Strategy when all links are not equivalent */
15973949bee8SArchie Cobbs 	ng_ppp_mp_strategy(node, m->m_pkthdr.len, distrib);
15983949bee8SArchie Cobbs 
15993949bee8SArchie Cobbs deliver:
16003949bee8SArchie Cobbs 	/* Update stats */
16013949bee8SArchie Cobbs 	priv->bundleStats.xmitFrames++;
16023949bee8SArchie Cobbs 	priv->bundleStats.xmitOctets += m->m_pkthdr.len;
16033949bee8SArchie Cobbs 
16043949bee8SArchie Cobbs 	/* Send alloted portions of frame out on the link(s) */
16053949bee8SArchie Cobbs 	for (firstFragment = 1, activeLinkNum = priv->numActiveLinks - 1;
16063949bee8SArchie Cobbs 	    activeLinkNum >= 0; activeLinkNum--) {
16073949bee8SArchie Cobbs 		const int linkNum = priv->activeLinks[activeLinkNum];
1608a9b3dca5SArchie Cobbs 		struct ng_ppp_link *const link = &priv->links[linkNum];
16093949bee8SArchie Cobbs 
16103949bee8SArchie Cobbs 		/* Deliver fragment(s) out the next link */
16113949bee8SArchie Cobbs 		for ( ; distrib[activeLinkNum] > 0; firstFragment = 0) {
16123949bee8SArchie Cobbs 			int len, lastFragment, error;
16133949bee8SArchie Cobbs 			struct mbuf *m2;
16143949bee8SArchie Cobbs 
16153949bee8SArchie Cobbs 			/* Calculate fragment length; don't exceed link MTU */
16163949bee8SArchie Cobbs 			len = distrib[activeLinkNum];
1617931c828aSArchie Cobbs 			if (len > link->conf.mru - hdr_len)
1618931c828aSArchie Cobbs 				len = link->conf.mru - hdr_len;
16193949bee8SArchie Cobbs 			distrib[activeLinkNum] -= len;
16203949bee8SArchie Cobbs 			lastFragment = (len == m->m_pkthdr.len);
16213949bee8SArchie Cobbs 
16223949bee8SArchie Cobbs 			/* Split off next fragment as "m2" */
16233949bee8SArchie Cobbs 			m2 = m;
16243949bee8SArchie Cobbs 			if (!lastFragment) {
1625a163d034SWarner Losh 				struct mbuf *n = m_split(m, len, M_DONTWAIT);
16263949bee8SArchie Cobbs 
16273949bee8SArchie Cobbs 				if (n == NULL) {
1628069154d5SJulian Elischer 					NG_FREE_M(m);
16293949bee8SArchie Cobbs 					return (ENOMEM);
16303949bee8SArchie Cobbs 				}
16313949bee8SArchie Cobbs 				m = n;
16323949bee8SArchie Cobbs 			}
16333949bee8SArchie Cobbs 
16343949bee8SArchie Cobbs 			/* Prepend MP header */
16353949bee8SArchie Cobbs 			if (priv->conf.xmitShortSeq) {
16363949bee8SArchie Cobbs 				u_int16_t shdr;
16373949bee8SArchie Cobbs 
1638a9b3dca5SArchie Cobbs 				shdr = priv->xseq;
1639a9b3dca5SArchie Cobbs 				priv->xseq =
16406f16db81SArchie Cobbs 				    (priv->xseq + 1) & MP_SHORT_SEQ_MASK;
16413949bee8SArchie Cobbs 				if (firstFragment)
16423949bee8SArchie Cobbs 					shdr |= MP_SHORT_FIRST_FLAG;
16433949bee8SArchie Cobbs 				if (lastFragment)
16443949bee8SArchie Cobbs 					shdr |= MP_SHORT_LAST_FLAG;
1645d690a6e7SArchie Cobbs 				shdr = htons(shdr);
1646d690a6e7SArchie Cobbs 				m2 = ng_ppp_prepend(m2, &shdr, 2);
16473949bee8SArchie Cobbs 			} else {
16483949bee8SArchie Cobbs 				u_int32_t lhdr;
16493949bee8SArchie Cobbs 
1650a9b3dca5SArchie Cobbs 				lhdr = priv->xseq;
1651a9b3dca5SArchie Cobbs 				priv->xseq =
16526f16db81SArchie Cobbs 				    (priv->xseq + 1) & MP_LONG_SEQ_MASK;
16533949bee8SArchie Cobbs 				if (firstFragment)
16543949bee8SArchie Cobbs 					lhdr |= MP_LONG_FIRST_FLAG;
16553949bee8SArchie Cobbs 				if (lastFragment)
16563949bee8SArchie Cobbs 					lhdr |= MP_LONG_LAST_FLAG;
1657d690a6e7SArchie Cobbs 				lhdr = htonl(lhdr);
1658d690a6e7SArchie Cobbs 				m2 = ng_ppp_prepend(m2, &lhdr, 4);
16593949bee8SArchie Cobbs 			}
16603949bee8SArchie Cobbs 			if (m2 == NULL) {
16613949bee8SArchie Cobbs 				if (!lastFragment)
16623949bee8SArchie Cobbs 					m_freem(m);
16633949bee8SArchie Cobbs 				return (ENOBUFS);
16643949bee8SArchie Cobbs 			}
16653949bee8SArchie Cobbs 
16663949bee8SArchie Cobbs 			/* Send fragment */
1667d0784b47SGleb Smirnoff 			if ((item = ng_package_data(m2, NG_NOFLAGS)) != NULL) {
1668d0784b47SGleb Smirnoff 				error = ng_ppp_output(node, 0, PROT_MP,
1669d0784b47SGleb Smirnoff 				    linkNum, item);
16703949bee8SArchie Cobbs 				if (error != 0) {
16713ca24c28SJulian Elischer 					if (!lastFragment)
1672069154d5SJulian Elischer 						NG_FREE_M(m);
16733949bee8SArchie Cobbs 					return (error);
16743949bee8SArchie Cobbs 				}
16753949bee8SArchie Cobbs 			}
16763949bee8SArchie Cobbs 		}
1677d0784b47SGleb Smirnoff 	}
16783949bee8SArchie Cobbs 
16793949bee8SArchie Cobbs 	/* Done */
16803949bee8SArchie Cobbs 	return (0);
16813949bee8SArchie Cobbs }
16823949bee8SArchie Cobbs 
16833949bee8SArchie Cobbs /*
16843949bee8SArchie Cobbs  * Computing the optimal fragmentation
16853949bee8SArchie Cobbs  * -----------------------------------
16863949bee8SArchie Cobbs  *
16873949bee8SArchie Cobbs  * This routine tries to compute the optimal fragmentation pattern based
16883949bee8SArchie Cobbs  * on each link's latency, bandwidth, and calculated additional latency.
16893949bee8SArchie Cobbs  * The latter quantity is the additional latency caused by previously
16903949bee8SArchie Cobbs  * written data that has not been transmitted yet.
16913949bee8SArchie Cobbs  *
16923949bee8SArchie Cobbs  * This algorithm is only useful when not all of the links have the
16933949bee8SArchie Cobbs  * same latency and bandwidth values.
16943949bee8SArchie Cobbs  *
16953949bee8SArchie Cobbs  * The essential idea is to make the last bit of each fragment of the
16963949bee8SArchie Cobbs  * frame arrive at the opposite end at the exact same time. This greedy
16973949bee8SArchie Cobbs  * algorithm is optimal, in that no other scheduling could result in any
16983949bee8SArchie Cobbs  * packet arriving any sooner unless packets are delivered out of order.
16993949bee8SArchie Cobbs  *
17003949bee8SArchie Cobbs  * Suppose link i has bandwidth b_i (in tens of bytes per milisecond) and
17013949bee8SArchie Cobbs  * latency l_i (in miliseconds). Consider the function function f_i(t)
17023949bee8SArchie Cobbs  * which is equal to the number of bytes that will have arrived at
17033949bee8SArchie Cobbs  * the peer after t miliseconds if we start writing continuously at
17043949bee8SArchie Cobbs  * time t = 0. Then f_i(t) = b_i * (t - l_i) = ((b_i * t) - (l_i * b_i).
17053949bee8SArchie Cobbs  * That is, f_i(t) is a line with slope b_i and y-intersect -(l_i * b_i).
17063949bee8SArchie Cobbs  * Note that the y-intersect is always <= zero because latency can't be
17073949bee8SArchie Cobbs  * negative.  Note also that really the function is f_i(t) except when
17083949bee8SArchie Cobbs  * f_i(t) is negative, in which case the function is zero.  To take
17093949bee8SArchie Cobbs  * care of this, let Q_i(t) = { if (f_i(t) > 0) return 1; else return 0; }.
17103949bee8SArchie Cobbs  * So the actual number of bytes that will have arrived at the peer after
17113949bee8SArchie Cobbs  * t miliseconds is f_i(t) * Q_i(t).
17123949bee8SArchie Cobbs  *
17133949bee8SArchie Cobbs  * At any given time, each link has some additional latency a_i >= 0
17143949bee8SArchie Cobbs  * due to previously written fragment(s) which are still in the queue.
17153949bee8SArchie Cobbs  * This value is easily computed from the time since last transmission,
17163949bee8SArchie Cobbs  * the previous latency value, the number of bytes written, and the
17173949bee8SArchie Cobbs  * link's bandwidth.
17183949bee8SArchie Cobbs  *
17193949bee8SArchie Cobbs  * Assume that l_i includes any a_i already, and that the links are
17203949bee8SArchie Cobbs  * sorted by latency, so that l_i <= l_{i+1}.
17213949bee8SArchie Cobbs  *
17223949bee8SArchie Cobbs  * Let N be the total number of bytes in the current frame we are sending.
17233949bee8SArchie Cobbs  *
17243949bee8SArchie Cobbs  * Suppose we were to start writing bytes at time t = 0 on all links
17253949bee8SArchie Cobbs  * simultaneously, which is the most we can possibly do.  Then let
17263949bee8SArchie Cobbs  * F(t) be equal to the total number of bytes received by the peer
17273949bee8SArchie Cobbs  * after t miliseconds. Then F(t) = Sum_i (f_i(t) * Q_i(t)).
17283949bee8SArchie Cobbs  *
17293949bee8SArchie Cobbs  * Our goal is simply this: fragment the frame across the links such
17303949bee8SArchie Cobbs  * that the peer is able to reconstruct the completed frame as soon as
17313949bee8SArchie Cobbs  * possible, i.e., at the least possible value of t. Call this value t_0.
17323949bee8SArchie Cobbs  *
17333949bee8SArchie Cobbs  * Then it follows that F(t_0) = N. Our strategy is first to find the value
17343949bee8SArchie Cobbs  * of t_0, and then deduce how many bytes to write to each link.
17353949bee8SArchie Cobbs  *
17363949bee8SArchie Cobbs  * Rewriting F(t_0):
17373949bee8SArchie Cobbs  *
17383949bee8SArchie Cobbs  *   t_0 = ( N + Sum_i ( l_i * b_i * Q_i(t_0) ) ) / Sum_i ( b_i * Q_i(t_0) )
17393949bee8SArchie Cobbs  *
17403949bee8SArchie Cobbs  * Now, we note that Q_i(t) is constant for l_i <= t <= l_{i+1}. t_0 will
17413949bee8SArchie Cobbs  * lie in one of these ranges.  To find it, we just need to find the i such
17423949bee8SArchie Cobbs  * that F(l_i) <= N <= F(l_{i+1}).  Then we compute all the constant values
17433949bee8SArchie Cobbs  * for Q_i() in this range, plug in the remaining values, solving for t_0.
17443949bee8SArchie Cobbs  *
17453949bee8SArchie Cobbs  * Once t_0 is known, then the number of bytes to send on link i is
17463949bee8SArchie Cobbs  * just f_i(t_0) * Q_i(t_0).
17473949bee8SArchie Cobbs  *
17483949bee8SArchie Cobbs  * In other words, we start allocating bytes to the links one at a time.
17493949bee8SArchie Cobbs  * We keep adding links until the frame is completely sent.  Some links
17503949bee8SArchie Cobbs  * may not get any bytes because their latency is too high.
17513949bee8SArchie Cobbs  *
17523949bee8SArchie Cobbs  * Is all this work really worth the trouble?  Depends on the situation.
17533949bee8SArchie Cobbs  * The bigger the ratio of computer speed to link speed, and the more
17543949bee8SArchie Cobbs  * important total bundle latency is (e.g., for interactive response time),
17553949bee8SArchie Cobbs  * the more it's worth it.  There is however the cost of calling this
17563949bee8SArchie Cobbs  * function for every frame.  The running time is O(n^2) where n is the
17573949bee8SArchie Cobbs  * number of links that receive a non-zero number of bytes.
17583949bee8SArchie Cobbs  *
17593949bee8SArchie Cobbs  * Since latency is measured in miliseconds, the "resolution" of this
17603949bee8SArchie Cobbs  * algorithm is one milisecond.
17613949bee8SArchie Cobbs  *
17623949bee8SArchie Cobbs  * To avoid this algorithm altogether, configure all links to have the
17633949bee8SArchie Cobbs  * same latency and bandwidth.
17643949bee8SArchie Cobbs  */
17653949bee8SArchie Cobbs static void
17663949bee8SArchie Cobbs ng_ppp_mp_strategy(node_p node, int len, int *distrib)
17673949bee8SArchie Cobbs {
176830400f03SJulian Elischer 	const priv_p priv = NG_NODE_PRIVATE(node);
17693949bee8SArchie Cobbs 	int latency[NG_PPP_MAX_LINKS];
17703949bee8SArchie Cobbs 	int sortByLatency[NG_PPP_MAX_LINKS];
1771a9b3dca5SArchie Cobbs 	int activeLinkNum;
17723949bee8SArchie Cobbs 	int t0, total, topSum, botSum;
17733949bee8SArchie Cobbs 	struct timeval now;
17743949bee8SArchie Cobbs 	int i, numFragments;
17753949bee8SArchie Cobbs 
17763949bee8SArchie Cobbs 	/* If only one link, this gets real easy */
17773949bee8SArchie Cobbs 	if (priv->numActiveLinks == 1) {
17783949bee8SArchie Cobbs 		distrib[0] = len;
17793949bee8SArchie Cobbs 		return;
17803949bee8SArchie Cobbs 	}
17813949bee8SArchie Cobbs 
17823949bee8SArchie Cobbs 	/* Get current time */
1783a9b3dca5SArchie Cobbs 	getmicrouptime(&now);
17843949bee8SArchie Cobbs 
17853949bee8SArchie Cobbs 	/* Compute latencies for each link at this point in time */
17863949bee8SArchie Cobbs 	for (activeLinkNum = 0;
17873949bee8SArchie Cobbs 	    activeLinkNum < priv->numActiveLinks; activeLinkNum++) {
1788a9b3dca5SArchie Cobbs 		struct ng_ppp_link *alink;
17893949bee8SArchie Cobbs 		struct timeval diff;
17903949bee8SArchie Cobbs 		int xmitBytes;
17913949bee8SArchie Cobbs 
17923949bee8SArchie Cobbs 		/* Start with base latency value */
1793a9b3dca5SArchie Cobbs 		alink = &priv->links[priv->activeLinks[activeLinkNum]];
179449728ffcSBjoern A. Zeeb 		latency[activeLinkNum] = alink->latency;
17953949bee8SArchie Cobbs 		sortByLatency[activeLinkNum] = activeLinkNum;	/* see below */
17963949bee8SArchie Cobbs 
17973949bee8SArchie Cobbs 		/* Any additional latency? */
1798a9b3dca5SArchie Cobbs 		if (alink->bytesInQueue == 0)
17993949bee8SArchie Cobbs 			continue;
18003949bee8SArchie Cobbs 
18013949bee8SArchie Cobbs 		/* Compute time delta since last write */
18023949bee8SArchie Cobbs 		diff = now;
1803a9b3dca5SArchie Cobbs 		timevalsub(&diff, &alink->lastWrite);
18043949bee8SArchie Cobbs 		if (now.tv_sec < 0 || diff.tv_sec >= 10) {	/* sanity */
1805a9b3dca5SArchie Cobbs 			alink->bytesInQueue = 0;
18063949bee8SArchie Cobbs 			continue;
18073949bee8SArchie Cobbs 		}
18083949bee8SArchie Cobbs 
18093949bee8SArchie Cobbs 		/* How many bytes could have transmitted since last write? */
1810a9b3dca5SArchie Cobbs 		xmitBytes = (alink->conf.bandwidth * diff.tv_sec)
1811a9b3dca5SArchie Cobbs 		    + (alink->conf.bandwidth * (diff.tv_usec / 1000)) / 100;
1812a9b3dca5SArchie Cobbs 		alink->bytesInQueue -= xmitBytes;
1813a9b3dca5SArchie Cobbs 		if (alink->bytesInQueue < 0)
1814a9b3dca5SArchie Cobbs 			alink->bytesInQueue = 0;
18153949bee8SArchie Cobbs 		else
18163949bee8SArchie Cobbs 			latency[activeLinkNum] +=
1817a9b3dca5SArchie Cobbs 			    (100 * alink->bytesInQueue) / alink->conf.bandwidth;
18183949bee8SArchie Cobbs 	}
18193949bee8SArchie Cobbs 
1820a9b3dca5SArchie Cobbs 	/* Sort active links by latency */
18218250de83SGleb Smirnoff 	qsort_r(sortByLatency,
18228250de83SGleb Smirnoff 	    priv->numActiveLinks, sizeof(*sortByLatency), latency, ng_ppp_intcmp);
18233949bee8SArchie Cobbs 
18243949bee8SArchie Cobbs 	/* Find the interval we need (add links in sortByLatency[] order) */
18253949bee8SArchie Cobbs 	for (numFragments = 1;
18263949bee8SArchie Cobbs 	    numFragments < priv->numActiveLinks; numFragments++) {
18273949bee8SArchie Cobbs 		for (total = i = 0; i < numFragments; i++) {
18283949bee8SArchie Cobbs 			int flowTime;
18293949bee8SArchie Cobbs 
18303949bee8SArchie Cobbs 			flowTime = latency[sortByLatency[numFragments]]
18313949bee8SArchie Cobbs 			    - latency[sortByLatency[i]];
1832a9b3dca5SArchie Cobbs 			total += ((flowTime * priv->links[
1833a9b3dca5SArchie Cobbs 			    priv->activeLinks[sortByLatency[i]]].conf.bandwidth)
18343949bee8SArchie Cobbs 			    	+ 99) / 100;
18353949bee8SArchie Cobbs 		}
18363949bee8SArchie Cobbs 		if (total >= len)
18373949bee8SArchie Cobbs 			break;
18383949bee8SArchie Cobbs 	}
18393949bee8SArchie Cobbs 
18403949bee8SArchie Cobbs 	/* Solve for t_0 in that interval */
18413949bee8SArchie Cobbs 	for (topSum = botSum = i = 0; i < numFragments; i++) {
1842a9b3dca5SArchie Cobbs 		int bw = priv->links[
1843a9b3dca5SArchie Cobbs 		    priv->activeLinks[sortByLatency[i]]].conf.bandwidth;
18443949bee8SArchie Cobbs 
18453949bee8SArchie Cobbs 		topSum += latency[sortByLatency[i]] * bw;	/* / 100 */
18463949bee8SArchie Cobbs 		botSum += bw;					/* / 100 */
18473949bee8SArchie Cobbs 	}
18483949bee8SArchie Cobbs 	t0 = ((len * 100) + topSum + botSum / 2) / botSum;
18493949bee8SArchie Cobbs 
18503949bee8SArchie Cobbs 	/* Compute f_i(t_0) all i */
18513949bee8SArchie Cobbs 	bzero(distrib, priv->numActiveLinks * sizeof(*distrib));
18523949bee8SArchie Cobbs 	for (total = i = 0; i < numFragments; i++) {
1853a9b3dca5SArchie Cobbs 		int bw = priv->links[
1854a9b3dca5SArchie Cobbs 		    priv->activeLinks[sortByLatency[i]]].conf.bandwidth;
18553949bee8SArchie Cobbs 
18563949bee8SArchie Cobbs 		distrib[sortByLatency[i]] =
18573949bee8SArchie Cobbs 		    (bw * (t0 - latency[sortByLatency[i]]) + 50) / 100;
18583949bee8SArchie Cobbs 		total += distrib[sortByLatency[i]];
18593949bee8SArchie Cobbs 	}
18603949bee8SArchie Cobbs 
1861fb1fc8abSArchie Cobbs 	/* Deal with any rounding error */
1862fb1fc8abSArchie Cobbs 	if (total < len) {
1863a9b3dca5SArchie Cobbs 		struct ng_ppp_link *fastLink =
1864a9b3dca5SArchie Cobbs 		    &priv->links[priv->activeLinks[sortByLatency[0]]];
18653949bee8SArchie Cobbs 		int fast = 0;
18663949bee8SArchie Cobbs 
1867fb1fc8abSArchie Cobbs 		/* Find the fastest link */
18683949bee8SArchie Cobbs 		for (i = 1; i < numFragments; i++) {
1869a9b3dca5SArchie Cobbs 			struct ng_ppp_link *const link =
1870a9b3dca5SArchie Cobbs 			    &priv->links[priv->activeLinks[sortByLatency[i]]];
1871a9b3dca5SArchie Cobbs 
1872a9b3dca5SArchie Cobbs 			if (link->conf.bandwidth > fastLink->conf.bandwidth) {
18733949bee8SArchie Cobbs 				fast = i;
1874a9b3dca5SArchie Cobbs 				fastLink = link;
1875a9b3dca5SArchie Cobbs 			}
18763949bee8SArchie Cobbs 		}
18773949bee8SArchie Cobbs 		distrib[sortByLatency[fast]] += len - total;
1878fb1fc8abSArchie Cobbs 	} else while (total > len) {
1879a9b3dca5SArchie Cobbs 		struct ng_ppp_link *slowLink =
1880a9b3dca5SArchie Cobbs 		    &priv->links[priv->activeLinks[sortByLatency[0]]];
1881fb1fc8abSArchie Cobbs 		int delta, slow = 0;
18823949bee8SArchie Cobbs 
1883fb1fc8abSArchie Cobbs 		/* Find the slowest link that still has bytes to remove */
1884fb1fc8abSArchie Cobbs 		for (i = 1; i < numFragments; i++) {
1885a9b3dca5SArchie Cobbs 			struct ng_ppp_link *const link =
1886a9b3dca5SArchie Cobbs 			    &priv->links[priv->activeLinks[sortByLatency[i]]];
1887a9b3dca5SArchie Cobbs 
1888fb1fc8abSArchie Cobbs 			if (distrib[sortByLatency[slow]] == 0
1889fb1fc8abSArchie Cobbs 			  || (distrib[sortByLatency[i]] > 0
1890a9b3dca5SArchie Cobbs 			    && link->conf.bandwidth <
1891a9b3dca5SArchie Cobbs 			      slowLink->conf.bandwidth)) {
1892fb1fc8abSArchie Cobbs 				slow = i;
1893a9b3dca5SArchie Cobbs 				slowLink = link;
1894a9b3dca5SArchie Cobbs 			}
1895fb1fc8abSArchie Cobbs 		}
1896fb1fc8abSArchie Cobbs 		delta = total - len;
1897fb1fc8abSArchie Cobbs 		if (delta > distrib[sortByLatency[slow]])
1898fb1fc8abSArchie Cobbs 			delta = distrib[sortByLatency[slow]];
1899fb1fc8abSArchie Cobbs 		distrib[sortByLatency[slow]] -= delta;
1900fb1fc8abSArchie Cobbs 		total -= delta;
19013949bee8SArchie Cobbs 	}
19023949bee8SArchie Cobbs }
19033949bee8SArchie Cobbs 
19043949bee8SArchie Cobbs /*
19053949bee8SArchie Cobbs  * Compare two integers
19063949bee8SArchie Cobbs  */
19073949bee8SArchie Cobbs static int
19088250de83SGleb Smirnoff ng_ppp_intcmp(void *latency, const void *v1, const void *v2)
19093949bee8SArchie Cobbs {
19103949bee8SArchie Cobbs 	const int index1 = *((const int *) v1);
19113949bee8SArchie Cobbs 	const int index2 = *((const int *) v2);
19123949bee8SArchie Cobbs 
19138250de83SGleb Smirnoff 	return ((int *)latency)[index1] - ((int *)latency)[index2];
19143949bee8SArchie Cobbs }
19153949bee8SArchie Cobbs 
19163949bee8SArchie Cobbs /*
19173949bee8SArchie Cobbs  * Prepend a possibly compressed PPP protocol number in front of a frame
19183949bee8SArchie Cobbs  */
19193949bee8SArchie Cobbs static struct mbuf *
19203949bee8SArchie Cobbs ng_ppp_addproto(struct mbuf *m, int proto, int compOK)
19213949bee8SArchie Cobbs {
1922d690a6e7SArchie Cobbs 	if (compOK && PROT_COMPRESSABLE(proto)) {
1923d690a6e7SArchie Cobbs 		u_char pbyte = (u_char)proto;
19243949bee8SArchie Cobbs 
1925d690a6e7SArchie Cobbs 		return ng_ppp_prepend(m, &pbyte, 1);
1926d690a6e7SArchie Cobbs 	} else {
1927d690a6e7SArchie Cobbs 		u_int16_t pword = htons((u_int16_t)proto);
1928d690a6e7SArchie Cobbs 
1929d690a6e7SArchie Cobbs 		return ng_ppp_prepend(m, &pword, 2);
1930d690a6e7SArchie Cobbs 	}
1931d690a6e7SArchie Cobbs }
1932d690a6e7SArchie Cobbs 
1933d690a6e7SArchie Cobbs /*
1934d690a6e7SArchie Cobbs  * Prepend some bytes to an mbuf
1935d690a6e7SArchie Cobbs  */
1936d690a6e7SArchie Cobbs static struct mbuf *
1937d690a6e7SArchie Cobbs ng_ppp_prepend(struct mbuf *m, const void *buf, int len)
1938d690a6e7SArchie Cobbs {
1939a163d034SWarner Losh 	M_PREPEND(m, len, M_DONTWAIT);
1940d690a6e7SArchie Cobbs 	if (m == NULL || (m->m_len < len && (m = m_pullup(m, len)) == NULL))
19414cf49a43SJulian Elischer 		return (NULL);
1942d690a6e7SArchie Cobbs 	bcopy(buf, mtod(m, u_char *), len);
19433949bee8SArchie Cobbs 	return (m);
19443949bee8SArchie Cobbs }
19453949bee8SArchie Cobbs 
19463949bee8SArchie Cobbs /*
19473949bee8SArchie Cobbs  * Update private information that is derived from other private information
19483949bee8SArchie Cobbs  */
19493949bee8SArchie Cobbs static void
19503949bee8SArchie Cobbs ng_ppp_update(node_p node, int newConf)
19513949bee8SArchie Cobbs {
195230400f03SJulian Elischer 	const priv_p priv = NG_NODE_PRIVATE(node);
19533949bee8SArchie Cobbs 	int i;
19543949bee8SArchie Cobbs 
19553949bee8SArchie Cobbs 	/* Update active status for VJ Compression */
19563949bee8SArchie Cobbs 	priv->vjCompHooked = priv->hooks[HOOK_INDEX_VJC_IP] != NULL
19573949bee8SArchie Cobbs 	    && priv->hooks[HOOK_INDEX_VJC_COMP] != NULL
19583949bee8SArchie Cobbs 	    && priv->hooks[HOOK_INDEX_VJC_UNCOMP] != NULL
19593949bee8SArchie Cobbs 	    && priv->hooks[HOOK_INDEX_VJC_VJIP] != NULL;
19603949bee8SArchie Cobbs 
19613949bee8SArchie Cobbs 	/* Increase latency for each link an amount equal to one MP header */
19623949bee8SArchie Cobbs 	if (newConf) {
19633949bee8SArchie Cobbs 		for (i = 0; i < NG_PPP_MAX_LINKS; i++) {
19643949bee8SArchie Cobbs 			int hdrBytes;
19653949bee8SArchie Cobbs 
1966a9b3dca5SArchie Cobbs 			hdrBytes = (priv->links[i].conf.enableACFComp ? 0 : 2)
1967a9b3dca5SArchie Cobbs 			    + (priv->links[i].conf.enableProtoComp ? 1 : 2)
19683949bee8SArchie Cobbs 			    + (priv->conf.xmitShortSeq ? 2 : 4);
196949728ffcSBjoern A. Zeeb 			priv->links[i].latency =
197049728ffcSBjoern A. Zeeb 			    priv->links[i].conf.latency +
1971a9b3dca5SArchie Cobbs 			    ((hdrBytes * priv->links[i].conf.bandwidth) + 50)
19723949bee8SArchie Cobbs 				/ 100;
19733949bee8SArchie Cobbs 		}
19743949bee8SArchie Cobbs 	}
19753949bee8SArchie Cobbs 
19763949bee8SArchie Cobbs 	/* Update list of active links */
19773949bee8SArchie Cobbs 	bzero(&priv->activeLinks, sizeof(priv->activeLinks));
19783949bee8SArchie Cobbs 	priv->numActiveLinks = 0;
19793949bee8SArchie Cobbs 	priv->allLinksEqual = 1;
19803949bee8SArchie Cobbs 	for (i = 0; i < NG_PPP_MAX_LINKS; i++) {
1981a9b3dca5SArchie Cobbs 		struct ng_ppp_link *const link = &priv->links[i];
19820e11d0f3SArchie Cobbs 
1983a9b3dca5SArchie Cobbs 		/* Is link active? */
1984a9b3dca5SArchie Cobbs 		if (link->conf.enableLink && link->hook != NULL) {
1985a9b3dca5SArchie Cobbs 			struct ng_ppp_link *link0;
1986a9b3dca5SArchie Cobbs 
1987a9b3dca5SArchie Cobbs 			/* Add link to list of active links */
19883949bee8SArchie Cobbs 			priv->activeLinks[priv->numActiveLinks++] = i;
1989a9b3dca5SArchie Cobbs 			link0 = &priv->links[priv->activeLinks[0]];
1990a9b3dca5SArchie Cobbs 
1991a9b3dca5SArchie Cobbs 			/* Determine if all links are still equal */
199249728ffcSBjoern A. Zeeb 			if (link->latency != link0->latency
1993a9b3dca5SArchie Cobbs 			  || link->conf.bandwidth != link0->conf.bandwidth)
19943949bee8SArchie Cobbs 				priv->allLinksEqual = 0;
1995a9b3dca5SArchie Cobbs 
1996a9b3dca5SArchie Cobbs 			/* Initialize rec'd sequence number */
1997a9b3dca5SArchie Cobbs 			if (link->seq == MP_NOSEQ) {
1998a9b3dca5SArchie Cobbs 				link->seq = (link == link0) ?
1999a9b3dca5SArchie Cobbs 				    MP_INITIAL_SEQ : link0->seq;
20003949bee8SArchie Cobbs 			}
2001a9b3dca5SArchie Cobbs 		} else
2002a9b3dca5SArchie Cobbs 			link->seq = MP_NOSEQ;
20033949bee8SArchie Cobbs 	}
20043949bee8SArchie Cobbs 
2005a9b3dca5SArchie Cobbs 	/* Update MP state as multi-link is active or not */
2006a9b3dca5SArchie Cobbs 	if (priv->conf.enableMultilink && priv->numActiveLinks > 0)
2007a9b3dca5SArchie Cobbs 		ng_ppp_start_frag_timer(node);
2008a9b3dca5SArchie Cobbs 	else {
2009a9b3dca5SArchie Cobbs 		ng_ppp_stop_frag_timer(node);
2010a9b3dca5SArchie Cobbs 		ng_ppp_frag_reset(node);
2011a9b3dca5SArchie Cobbs 		priv->xseq = MP_INITIAL_SEQ;
2012a9b3dca5SArchie Cobbs 		priv->mseq = MP_INITIAL_SEQ;
2013a9b3dca5SArchie Cobbs 		for (i = 0; i < NG_PPP_MAX_LINKS; i++) {
2014a9b3dca5SArchie Cobbs 			struct ng_ppp_link *const link = &priv->links[i];
2015a9b3dca5SArchie Cobbs 
2016a9b3dca5SArchie Cobbs 			bzero(&link->lastWrite, sizeof(link->lastWrite));
2017a9b3dca5SArchie Cobbs 			link->bytesInQueue = 0;
2018a9b3dca5SArchie Cobbs 			link->seq = MP_NOSEQ;
2019a9b3dca5SArchie Cobbs 		}
20203949bee8SArchie Cobbs 	}
20213949bee8SArchie Cobbs }
20223949bee8SArchie Cobbs 
20233949bee8SArchie Cobbs /*
20243949bee8SArchie Cobbs  * Determine if a new configuration would represent a valid change
20253949bee8SArchie Cobbs  * from the current configuration and link activity status.
20263949bee8SArchie Cobbs  */
20273949bee8SArchie Cobbs static int
2028a9b3dca5SArchie Cobbs ng_ppp_config_valid(node_p node, const struct ng_ppp_node_conf *newConf)
20293949bee8SArchie Cobbs {
203030400f03SJulian Elischer 	const priv_p priv = NG_NODE_PRIVATE(node);
20313949bee8SArchie Cobbs 	int i, newNumLinksActive;
20323949bee8SArchie Cobbs 
20333949bee8SArchie Cobbs 	/* Check per-link config and count how many links would be active */
20343949bee8SArchie Cobbs 	for (newNumLinksActive = i = 0; i < NG_PPP_MAX_LINKS; i++) {
2035a9b3dca5SArchie Cobbs 		if (newConf->links[i].enableLink && priv->links[i].hook != NULL)
2036e149c4e2SArchie Cobbs 			newNumLinksActive++;
2037e149c4e2SArchie Cobbs 		if (!newConf->links[i].enableLink)
2038e149c4e2SArchie Cobbs 			continue;
20393949bee8SArchie Cobbs 		if (newConf->links[i].mru < MP_MIN_LINK_MRU)
20403949bee8SArchie Cobbs 			return (0);
20413949bee8SArchie Cobbs 		if (newConf->links[i].bandwidth == 0)
20423949bee8SArchie Cobbs 			return (0);
20433949bee8SArchie Cobbs 		if (newConf->links[i].bandwidth > NG_PPP_MAX_BANDWIDTH)
20443949bee8SArchie Cobbs 			return (0);
20453949bee8SArchie Cobbs 		if (newConf->links[i].latency > NG_PPP_MAX_LATENCY)
20463949bee8SArchie Cobbs 			return (0);
20473949bee8SArchie Cobbs 	}
20483949bee8SArchie Cobbs 
20493949bee8SArchie Cobbs 	/* Check bundle parameters */
2050a9b3dca5SArchie Cobbs 	if (newConf->bund.enableMultilink && newConf->bund.mrru < MP_MIN_MRRU)
20513949bee8SArchie Cobbs 		return (0);
20523949bee8SArchie Cobbs 
20533949bee8SArchie Cobbs 	/* Disallow changes to multi-link configuration while MP is active */
20543949bee8SArchie Cobbs 	if (priv->numActiveLinks > 0 && newNumLinksActive > 0) {
2055a9b3dca5SArchie Cobbs 		if (!priv->conf.enableMultilink
2056a9b3dca5SArchie Cobbs 				!= !newConf->bund.enableMultilink
2057a9b3dca5SArchie Cobbs 		    || !priv->conf.xmitShortSeq != !newConf->bund.xmitShortSeq
2058a9b3dca5SArchie Cobbs 		    || !priv->conf.recvShortSeq != !newConf->bund.recvShortSeq)
20593949bee8SArchie Cobbs 			return (0);
20603949bee8SArchie Cobbs 	}
20613949bee8SArchie Cobbs 
2062e149c4e2SArchie Cobbs 	/* At most one link can be active unless multi-link is enabled */
2063a9b3dca5SArchie Cobbs 	if (!newConf->bund.enableMultilink && newNumLinksActive > 1)
2064e149c4e2SArchie Cobbs 		return (0);
2065e149c4e2SArchie Cobbs 
2066e149c4e2SArchie Cobbs 	/* Configuration change would be valid */
20673949bee8SArchie Cobbs 	return (1);
20683949bee8SArchie Cobbs }
20693949bee8SArchie Cobbs 
20703949bee8SArchie Cobbs /*
20713949bee8SArchie Cobbs  * Free all entries in the fragment queue
20723949bee8SArchie Cobbs  */
20733949bee8SArchie Cobbs static void
2074a9b3dca5SArchie Cobbs ng_ppp_frag_reset(node_p node)
20753949bee8SArchie Cobbs {
207630400f03SJulian Elischer 	const priv_p priv = NG_NODE_PRIVATE(node);
20771e7a9f72SArchie Cobbs 	struct ng_ppp_frag *qent, *qnext;
20783949bee8SArchie Cobbs 
20795f90cac7SKirk McKusick 	for (qent = TAILQ_FIRST(&priv->frags); qent; qent = qnext) {
20805f90cac7SKirk McKusick 		qnext = TAILQ_NEXT(qent, f_qent);
2081069154d5SJulian Elischer 		NG_FREE_M(qent->data);
20829c8c302fSJulian Elischer 		FREE(qent, M_NETGRAPH_PPP);
20833949bee8SArchie Cobbs 	}
20845f90cac7SKirk McKusick 	TAILQ_INIT(&priv->frags);
2085a9b3dca5SArchie Cobbs 	priv->qlen = 0;
2086a9b3dca5SArchie Cobbs }
2087a9b3dca5SArchie Cobbs 
2088a9b3dca5SArchie Cobbs /*
2089a9b3dca5SArchie Cobbs  * Start fragment queue timer
2090a9b3dca5SArchie Cobbs  */
2091a9b3dca5SArchie Cobbs static void
2092a9b3dca5SArchie Cobbs ng_ppp_start_frag_timer(node_p node)
2093a9b3dca5SArchie Cobbs {
209430400f03SJulian Elischer 	const priv_p priv = NG_NODE_PRIVATE(node);
2095a9b3dca5SArchie Cobbs 
2096dc2f4d7fSGleb Smirnoff 	if (!(callout_pending(&priv->fragTimer)))
20979d952bd3SGleb Smirnoff 		ng_callout(&priv->fragTimer, node, NULL, MP_FRAGTIMER_INTERVAL,
20989d952bd3SGleb Smirnoff 		    ng_ppp_frag_timeout, NULL, 0);
2099a9b3dca5SArchie Cobbs }
2100a9b3dca5SArchie Cobbs 
2101a9b3dca5SArchie Cobbs /*
2102a9b3dca5SArchie Cobbs  * Stop fragment queue timer
2103a9b3dca5SArchie Cobbs  */
2104a9b3dca5SArchie Cobbs static void
2105a9b3dca5SArchie Cobbs ng_ppp_stop_frag_timer(node_p node)
2106a9b3dca5SArchie Cobbs {
210730400f03SJulian Elischer 	const priv_p priv = NG_NODE_PRIVATE(node);
2108a9b3dca5SArchie Cobbs 
2109dc2f4d7fSGleb Smirnoff 	if (callout_pending(&priv->fragTimer))
21109d952bd3SGleb Smirnoff 		ng_uncallout(&priv->fragTimer, node);
2111a9b3dca5SArchie Cobbs }
2112