Revamped and more useful PPP node type, supporting multi-link PPP directly.

This is one piece of the grand unified PPP daemon concept, whereby using
netgraph nodes enables PPP data to be handled completely in kernel land,
while leaving negotiation/control to be handled by a single user land
daemon, no matter what the link type(s).

This is a safety checkin only; it compiles, but is utterly untested.

Concept reviewed by:	julian, brian

1 files changed, 1153 insertions, 155 deletions

diff --git a/sys/netgraph/ng_ppp.c b/sys/netgraph/ng_ppp.c
index 3377a80..9dd2752 100644
--- a/sys/netgraph/ng_ppp.c
+++ b/sys/netgraph/ng_ppp.c
@@ -41,9 +41,7 @@
  */
 
 /*
- * This node does PPP protocol multiplexing based on PPP protocol
- * ID numbers. This node does not add address and control fields,
- * as that is considered a ``device layer'' issue.
+ * PPP node type.
  */
 
 #include <sys/param.h>
@@ -59,30 +57,127 @@
 #include <netgraph/ng_message.h>
 #include <netgraph/netgraph.h>
 #include <netgraph/ng_ppp.h>
-
-/* Protocol stuff */
-#define PROT_DOWNLINK		0xffff
-#define PROT_BYPASS		0x0000
+#include <netgraph/ng_vjc.h>
 
 #define PROT_VALID(p)		(((p) & 0x0101) == 0x0001)
-#define PROT_COMPRESSIBLE(p)	(((p) & 0xFF00) == 0x0000)
+#define PROT_COMPRESSIBLE(p)	(((p) & 0xff00) == 0x0000)
+
+/* Some PPP protocol numbers we're interested in */
+#define PROT_APPLETALK		0x0029
+#define PROT_COMPD		0x00fd
+#define PROT_CRYPTD		0x0053
+#define PROT_IP			0x0021
+#define PROT_IPX		0x002B
+#define PROT_MP			0x003d
+#define PROT_VJCOMP		0x002d
+#define PROT_VJUNCOMP		0x002f
+
+/* Multilink PPP definitions */
+#define MP_MIN_MRRU		1500		/* per RFC 1990 */
+#define MP_INITIAL_SEQ		0		/* per RFC 1990 */
+#define MP_MIN_LINK_MRU		32
+
+#define MP_MAX_SEQ_LINGER	64		/* max frags we will hold */
+#define MP_INSANE_SEQ_JUMP	128		/* a sequence # jump too far */
+#define MP_MIN_FRAG_LEN		6		/* don't frag smaller frames */
+
+#define MP_SHORT_SEQ_MASK	0x00000fff	/* short seq # mask */
+#define MP_SHORT_SEQ_HIBIT	0x00000800	/* short seq # high bit */
+#define MP_SHORT_FIRST_FLAG	0x00008000	/* first fragment in frame */
+#define MP_SHORT_LAST_FLAG	0x00004000	/* last fragment in frame */
 
-/* Extract protocol from hook private pointer */
-#define HOOK_PROTO(hook)	(*((u_int16_t *) &hook->private))
+#define MP_LONG_SEQ_MASK	0x00ffffff	/* long seq # mask */
+#define MP_LONG_SEQ_HIBIT	0x00800000	/* long seq # high bit */
+#define MP_LONG_FIRST_FLAG	0x80000000	/* first fragment in frame */
+#define MP_LONG_LAST_FLAG	0x40000000	/* last fragment in frame */
+
+#define MP_SEQ_MASK		(priv->conf.recvShortSeq ? \
+				    MP_SHORT_SEQ_MASK : MP_LONG_SEQ_MASK)
+
+/* Sign extension of MP sequence numbers */
+#define MP_SHORT_EXTEND(s)	(((s) & MP_SHORT_SEQ_HIBIT) ? \
+				    ((s) | ~MP_SHORT_SEQ_MASK) : (s))
+#define MP_LONG_EXTEND(s)	(((s) & MP_LONG_SEQ_HIBIT) ? \
+				    ((s) | ~MP_LONG_SEQ_MASK) : (s))
+
+/* Comparision of MP sequence numbers */
+#define MP_SHORT_SEQ_DIFF(x,y)	(MP_SHORT_EXTEND(x) - MP_SHORT_EXTEND(y))
+#define MP_LONG_SEQ_DIFF(x,y)	(MP_LONG_EXTEND(x) - MP_LONG_EXTEND(y))
+
+#define MP_SEQ_DIFF(x,y)	(priv->conf.recvShortSeq ? \
+				    MP_SHORT_SEQ_DIFF((x), (y)) : \
+				    MP_LONG_SEQ_DIFF((x), (y)))
+
+/* We store incoming fragments this way */
+struct ng_ppp_frag {
+	int				seq;
+	u_char				first;
+	u_char				last;
+	struct mbuf			*data;
+	meta_p				meta;
+	CIRCLEQ_ENTRY(ng_ppp_frag)	f_qent;
+};
+
+/* We keep track of link queue status this way */
+struct ng_ppp_link_qstat {
+	struct timeval		lastWrite;	/* time of last write */
+	int			bytesInQueue;	/* bytes in the queue then */
+};
+
+/* We use integer indicies to refer to the non-link hooks */
+static const char *const ng_ppp_hook_names[] = {
+	NG_PPP_HOOK_ATALK,
+#define HOOK_INDEX_ATALK		0
+	NG_PPP_HOOK_BYPASS,
+#define HOOK_INDEX_BYPASS		1
+	NG_PPP_HOOK_COMPRESS,
+#define HOOK_INDEX_COMPRESS		2
+	NG_PPP_HOOK_ENCRYPT,
+#define HOOK_INDEX_ENCRYPT		3
+	NG_PPP_HOOK_DECOMPRESS,
+#define HOOK_INDEX_DECOMPRESS		4
+	NG_PPP_HOOK_DECRYPT,
+#define HOOK_INDEX_DECRYPT		5
+	NG_PPP_HOOK_INET,
+#define HOOK_INDEX_INET			6
+	NG_PPP_HOOK_IPX,
+#define HOOK_INDEX_IPX			7
+	NG_PPP_HOOK_VJC_COMP,
+#define HOOK_INDEX_VJC_COMP		8
+	NG_PPP_HOOK_VJC_IP,
+#define HOOK_INDEX_VJC_IP		9
+	NG_PPP_HOOK_VJC_UNCOMP,
+#define HOOK_INDEX_VJC_UNCOMP		10
+	NG_PPP_HOOK_VJC_VJIP,
+#define HOOK_INDEX_VJC_VJIP		11
+	NULL
+#define HOOK_INDEX_MAX			12
+};
+
+/* We store index numbers in the hook private pointer. The HOOK_INDEX()
+   for a hook is either the index (above) for normal hooks, or the ones
+   complement of the link number for link hooks. */
+#define HOOK_INDEX(hook)	(*((int16_t *) &(hook)->private))
 
 /* Node private data */
 struct private {
-	struct	ng_ppp_stat stats;
-	u_int   protocomp:1;
+	struct ng_ppp_node_config	conf;
+	struct ng_ppp_link_stat		bundleStats;
+	struct ng_ppp_link_stat		linkStats[NG_PPP_MAX_LINKS];
+	hook_p				links[NG_PPP_MAX_LINKS];
+	hook_p				hooks[HOOK_INDEX_MAX];
+	u_char				vjCompHooked;
+	u_char				allLinksEqual;
+	u_short				activeLinks[NG_PPP_MAX_LINKS];
+	u_int				numActiveLinks;
+	u_int				lastLink;	/* for round robin */
+	struct ng_ppp_link_qstat	qstat[NG_PPP_MAX_LINKS];
+	CIRCLEQ_HEAD(ng_ppp_fraglist, ng_ppp_frag)
+					frags;		/* incoming fragments */
+	int				mpSeqOut;	/* next out MP seq # */
 };
 typedef struct private *priv_p;
 
-/* Protocol aliases */
-struct protoalias {
-	char   *name;
-	u_int16_t proto;
-};
-
 /* Netgraph node methods */
 static int	ng_ppp_constructor(node_p *nodep);
 static int	ng_ppp_rcvmsg(node_p node, struct ng_mesg *msg,
@@ -92,12 +187,21 @@ static int	ng_ppp_newhook(node_p node, hook_p hook, const char *name);
 static int	ng_ppp_rcvdata(hook_p hook, struct mbuf *m, meta_p meta);
 static int	ng_ppp_disconnect(hook_p hook);
 
-/* Helper stuff */
-static int	ng_ppp_decodehookname(const char *name);
-static hook_p	ng_ppp_findhook(node_p node, int proto);
+/* Helper functions */
+static int	ng_ppp_input(node_p node, int ln, struct mbuf *m, meta_p meta);
+static int	ng_ppp_output(node_p node, int ln, struct mbuf *m, meta_p meta);
+static int	ng_ppp_mp_input(node_p nd, int ln, struct mbuf *m, meta_p meta);
+static int	ng_ppp_mp_output(node_p node, struct mbuf *m, meta_p meta);
+static void	ng_ppp_mp_strategy(node_p node, int len, int *distrib);
+static int	ng_ppp_intcmp(const void *v1, const void *v2);
+static struct	mbuf *ng_ppp_addproto(struct mbuf *m, int proto, int compOK);
+static int	ng_ppp_config_valid(node_p node,
+			const struct ng_ppp_node_config *newConf);
+static void	ng_ppp_update(node_p node, int newConf);
+static void	ng_ppp_free_frags(node_p node);
 
 /* Node type descriptor */
-static struct ng_type typestruct = {
+static struct ng_type ng_ppp_typestruct = {
 	NG_VERSION,
 	NG_PPP_NODE_TYPE,
 	NULL,
@@ -111,29 +215,9 @@ static struct ng_type typestruct = {
 	ng_ppp_rcvdata,
 	ng_ppp_disconnect
 };
-NETGRAPH_INIT(ppp, &typestruct);
+NETGRAPH_INIT(ppp, &ng_ppp_typestruct);
 
-/* Protocol aliases */
-static const struct protoalias gAliases[] =
-{
-	{ NG_PPP_HOOK_DOWNLINK,		PROT_DOWNLINK	},
-	{ NG_PPP_HOOK_BYPASS,		PROT_BYPASS	},
-	{ NG_PPP_HOOK_LCP,		0xc021		},
-	{ NG_PPP_HOOK_IPCP,		0x8021		},
-	{ NG_PPP_HOOK_ATCP,		0x8029		},
-	{ NG_PPP_HOOK_CCP,		0x80fd		},
-	{ NG_PPP_HOOK_ECP,		0x8053		},
-	{ NG_PPP_HOOK_IP,		0x0021		},
-	{ NG_PPP_HOOK_VJCOMP,		0x002d		},
-	{ NG_PPP_HOOK_VJUNCOMP,		0x002f		},
-	{ NG_PPP_HOOK_MP,		0x003d		},
-	{ NG_PPP_HOOK_COMPD,		0x00fd		},
-	{ NG_PPP_HOOK_CRYPTD,		0x0053		},
-	{ NG_PPP_HOOK_PAP,		0xc023		},
-	{ NG_PPP_HOOK_CHAP,		0xc223		},
-	{ NG_PPP_HOOK_LQR,		0xc025		},
-	{ NULL,				0		}
-};
+static int	*compareLatencies;		/* hack for ng_ppp_intcmp() */
 
 #define ERROUT(x)	do { error = (x); goto done; } while (0)
 
@@ -142,7 +226,7 @@ static const struct protoalias gAliases[] =
  ************************************************************************/
 
 /*
- * Node constructor
+ * Node type constructor
  */
 static int
 ng_ppp_constructor(node_p *nodep)
@@ -157,12 +241,15 @@ ng_ppp_constructor(node_p *nodep)
 	bzero(priv, sizeof(*priv));
 
 	/* Call generic node constructor */
-	if ((error = ng_make_node_common(&typestruct, nodep))) {
+	if ((error = ng_make_node_common(&ng_ppp_typestruct, nodep))) {
 		FREE(priv, M_NETGRAPH);
 		return (error);
 	}
 	(*nodep)->private = priv;
 
+	/* Initialize state */
+	CIRCLEQ_INIT(&priv->frags);
+
 	/* Done */
 	return (0);
 }
@@ -174,22 +261,59 @@ static int
 ng_ppp_newhook(node_p node, hook_p hook, const char *name)
 {
 	const priv_p priv = node->private;
-	int proto;
+	int linkNum = -1;
+	hook_p *hookPtr = NULL;
+	int hookIndex = -1;
 
-	/* Decode protocol number */
-	if ((proto = ng_ppp_decodehookname(name)) < 0)
-		return (EINVAL);
+	/* Figure out which hook it is */
+	if (strncmp(name, NG_PPP_HOOK_LINK_PREFIX,	/* a link hook? */
+	    strlen(NG_PPP_HOOK_LINK_PREFIX)) == 0) {
+		int gotDigit = 0;
+		const char *cp;
+
+		for (cp = name + strlen(NG_PPP_HOOK_LINK_PREFIX);
+		    *cp >= '0' && *cp <= '9'; cp++) {
+			if (!gotDigit) {
+				if (*cp == '0')		/* no leading zeros */
+					return (EINVAL);
+				linkNum = *cp - '0';
+				gotDigit = 1;
+			} else
+				linkNum = (linkNum * 10) + (*cp - '0');
+			if (linkNum >= NG_PPP_MAX_LINKS)
+				return (EINVAL);
+		}
+		if (!gotDigit || *cp != '\0')
+			return (EINVAL);
+		hookPtr = &priv->links[linkNum];
+		hookIndex = ~linkNum;
+	} else {				/* must be a non-link hook */
+		int i;
+
+		for (i = 0; ng_ppp_hook_names[i] != NULL; i++) {
+			if (strcmp(name, ng_ppp_hook_names[i]) == 0) {
+				hookPtr = &priv->hooks[i];
+				hookIndex = i;
+				break;
+			}
+		}
+		if (ng_ppp_hook_names[i] == NULL)
+			return (EINVAL);	/* no such hook */
+	}
 
-	/* See if already connected */
-	if (ng_ppp_findhook(node, proto) != NULL)
+	/* See if hook is already connected */
+	if (*hookPtr != NULL)
 		return (EISCONN);
 
-	/* Clear stats when downstream hook reconnected */
-	if (proto == PROT_DOWNLINK)
-		bzero(&priv->stats, sizeof(priv->stats));
+	/* Disallow more than one link unless multilink is enabled */
+	if (linkNum != -1 && priv->conf.links[linkNum].enableLink
+	    && !priv->conf.enableMultilink && priv->numActiveLinks >= 1)
+		return (ENODEV);
 
 	/* OK */
-	HOOK_PROTO(hook) = proto;
+	*hookPtr = hook;
+	HOOK_INDEX(hook) = hookIndex;
+	ng_ppp_update(node, 0);
 	return (0);
 }
 
@@ -207,25 +331,67 @@ ng_ppp_rcvmsg(node_p node, struct ng_mesg *msg,
 	switch (msg->header.typecookie) {
 	case NGM_PPP_COOKIE:
 		switch (msg->header.cmd) {
-		case NGM_PPP_SET_PROTOCOMP:
-			if (msg->header.arglen < sizeof(int))
+		case NGM_PPP_SET_CONFIG:
+		    {
+			struct ng_ppp_node_config *const newConf =
+				(struct ng_ppp_node_config *) msg->data;
+
+			/* Check for invalid or illegal config */
+			if (msg->header.arglen != sizeof(*newConf))
+				ERROUT(EINVAL);
+			if (!ng_ppp_config_valid(node, newConf))
 				ERROUT(EINVAL);
-			priv->protocomp = !!*((int *) msg->data);
+			priv->conf = *newConf;
+			ng_ppp_update(node, 1);
 			break;
-		case NGM_PPP_GET_STATS:
-			NG_MKRESPONSE(resp, msg, sizeof(priv->stats), M_NOWAIT);
+		    }
+		case NGM_PPP_GET_CONFIG:
+			NG_MKRESPONSE(resp, msg, sizeof(priv->conf), M_NOWAIT);
 			if (resp == NULL)
 				ERROUT(ENOMEM);
-			*((struct ng_ppp_stat *) resp->data) = priv->stats;
+			bcopy(&priv->conf, resp->data, sizeof(priv->conf));
 			break;
-		case NGM_PPP_CLR_STATS:
-			bzero(&priv->stats, sizeof(priv->stats));
+		case NGM_PPP_GET_LINK_STATS:
+		case NGM_PPP_CLR_LINK_STATS:
+		    {
+			struct ng_ppp_link_stat *stats;
+			u_int16_t linkNum;
+
+			if (msg->header.arglen != sizeof(u_int16_t))
+				ERROUT(EINVAL);
+			linkNum = *((u_int16_t *) msg->data);
+			if (linkNum >= NG_PPP_MAX_LINKS
+			    && linkNum != NG_PPP_BUNDLE_LINKNUM)
+				ERROUT(EINVAL);
+			stats = (linkNum == NG_PPP_BUNDLE_LINKNUM) ?
+				&priv->bundleStats : &priv->linkStats[linkNum];
+			if (msg->header.cmd == NGM_PPP_GET_LINK_STATS) {
+				NG_MKRESPONSE(resp, msg,
+				    sizeof(struct ng_ppp_link_stat), M_NOWAIT);
+				if (resp == NULL)
+					ERROUT(ENOMEM);
+				bcopy(stats, resp->data, sizeof(*stats));
+			} else
+				bzero(stats, sizeof(*stats));
 			break;
+		    }
 		default:
 			error = EINVAL;
 			break;
 		}
 		break;
+	case NGM_VJC_COOKIE:
+	   {
+	       char path[NG_PATHLEN + 1];
+	       node_p origNode;
+
+	       if ((error = ng_path2node(node, raddr, &origNode, NULL)) != 0)
+		       ERROUT(error);
+	       snprintf(path, sizeof(path), "[%lx]:%s",
+		   (long) node, NG_PPP_HOOK_VJC_IP);
+	       return ng_send_msg(origNode, msg, path, rptr);
+	       break;
+	   }
 	default:
 		error = EINVAL;
 		break;
@@ -248,80 +414,178 @@ ng_ppp_rcvdata(hook_p hook, struct mbuf *m, meta_p meta)
 {
 	const node_p node = hook->node;
 	const priv_p priv = node->private;
-	u_int16_t proto = HOOK_PROTO(hook);
-	int error = 0;
+	const int index = HOOK_INDEX(hook);
+	u_int16_t linkNum = NG_PPP_BUNDLE_LINKNUM;
+	hook_p outHook = NULL;
+	int proto = 0, error;
 
-	switch (proto) {
+	/* Did it come from a link hook? */
+	if (index < 0) {
 
-	/* Prepend the (possibly compressed) protocol number */
-	default:
-	    {
-		int psize = (priv->protocomp
-				&& PROT_COMPRESSIBLE(proto)) ? 1 : 2;
-
-		M_PREPEND(m, psize, M_NOWAIT);
-		if (!m || !(m = m_pullup(m, psize)))
-			ERROUT(ENOBUFS);
-		if (psize == 1)
-			*mtod(m, u_char *) = proto;
-		else
-			*mtod(m, u_short *) = htons(proto);
-		hook = ng_ppp_findhook(node, PROT_DOWNLINK);
-		break;
-	    }
+		/* Is link active? */
+		linkNum = (u_int16_t)~index;
+		KASSERT(linkNum < NG_PPP_MAX_LINKS,
+		    ("%s: bogus index 0x%x", __FUNCTION__, index));
+		if (!priv->conf.links[linkNum].enableLink) {
+			NG_FREE_DATA(m, meta);
+			return (ENXIO);
+		}
 
-	/* Extract the protocol number and direct to the corresponding hook */
-	case PROT_DOWNLINK:
-	    {
 		/* Stats */
-		priv->stats.recvFrames++;
-		priv->stats.recvOctets += m->m_pkthdr.len;
-
-		/* Extract protocol number */
-		for (proto = 0;
-		     !PROT_VALID(proto);
-		     proto = (proto << 8) + *mtod(m, u_char *), m_adj(m, 1)) {
-			if (m == NULL) {
-				priv->stats.badProto++;
-				ERROUT(EINVAL);
-			}
-			if ((m = m_pullup(m, 1)) == NULL)
-				ERROUT(ENOBUFS);
-		}
+		priv->linkStats[linkNum].recvFrames++;
+		priv->linkStats[linkNum].recvOctets += m->m_pkthdr.len;
+
+		/* Dispatch incoming frame */
+		return ng_ppp_input(node, linkNum, m, meta);
+	}
+
+	/* Get protocol & check if data allowed from this hook */
+	switch (index) {
 
-		/* Find corresponding hook; if none, use the "unhooked"
-		   hook and leave the two-byte protocol prepended */
-		if ((hook = ng_ppp_findhook(node, proto)) == NULL) {
-			priv->stats.unknownProto++;
-			hook = ng_ppp_findhook(node, PROT_BYPASS);
-			M_PREPEND(m, 2, M_NOWAIT);
-			if (m == NULL || (m = m_pullup(m, 2)) == NULL)
-				ERROUT(ENOBUFS);
-			*mtod(m, u_short *) = htons(proto);
+	/* Downwards flowing data */
+	case HOOK_INDEX_ATALK:
+		if (!priv->conf.enableAtalk) {
+			NG_FREE_DATA(m, meta);
+			return (ENXIO);
+		}
+		proto = PROT_APPLETALK;
+		break;
+	case HOOK_INDEX_IPX:
+		if (!priv->conf.enableIPX) {
+			NG_FREE_DATA(m, meta);
+			return (ENXIO);
+		}
+		proto = PROT_IPX;
+		break;
+	case HOOK_INDEX_INET:
+	case HOOK_INDEX_VJC_VJIP:
+		if (!priv->conf.enableIP) {
+			NG_FREE_DATA(m, meta);
+			return (ENXIO);
+		}
+		proto = PROT_IP;
+		break;
+	case HOOK_INDEX_VJC_COMP:
+		if (!priv->conf.enableVJCompression) {
+			NG_FREE_DATA(m, meta);
+			return (ENXIO);
+		}
+		proto = PROT_VJCOMP;
+		break;
+	case HOOK_INDEX_VJC_UNCOMP:
+		if (!priv->conf.enableVJCompression) {
+			NG_FREE_DATA(m, meta);
+			return (ENXIO);
+		}
+		proto = PROT_VJUNCOMP;
+		break;
+	case HOOK_INDEX_COMPRESS:
+		if (!priv->conf.enableCompression) {
+			NG_FREE_DATA(m, meta);
+			return (ENXIO);
+		}
+		proto = PROT_COMPD;
+		break;
+	case HOOK_INDEX_ENCRYPT:
+		if (!priv->conf.enableEncryption) {
+			NG_FREE_DATA(m, meta);
+			return (ENXIO);
 		}
+		proto = PROT_CRYPTD;
+		break;
+	case HOOK_INDEX_BYPASS:
+		if (m->m_pkthdr.len < 4) {
+			NG_FREE_META(meta);
+			return (EINVAL);
+		}
+		if (m->m_len < 4 && (m = m_pullup(m, 4)) == NULL) {
+			NG_FREE_META(meta);
+			return (ENOBUFS);
+		}
+		linkNum = ntohs(mtod(m, u_int16_t *)[0]);
+		proto = ntohs(mtod(m, u_int16_t *)[1]);
+		m_adj(m, 4);
+		if (linkNum >= NG_PPP_MAX_LINKS
+		    && linkNum != NG_PPP_BUNDLE_LINKNUM)
+			return (EINVAL);
 		break;
-	    }
 
-	/* Send raw data from "unhooked" hook as-is; we assume the
-	   protocol is already prepended */
-	case PROT_BYPASS:
-		hook = ng_ppp_findhook(node, PROT_DOWNLINK);
+	/* Upwards flowing data */
+	case HOOK_INDEX_VJC_IP:
+		if (!priv->conf.enableVJDecompression) {
+			NG_FREE_DATA(m, meta);
+			return (ENXIO);
+		}
+		break;
+	case HOOK_INDEX_DECOMPRESS:
+		if (!priv->conf.enableDecompression) {
+			NG_FREE_DATA(m, meta);
+			return (ENXIO);
+		}
 		break;
+	case HOOK_INDEX_DECRYPT:
+		if (!priv->conf.enableDecryption) {
+			NG_FREE_DATA(m, meta);
+			return (ENXIO);
+		}
+		break;
+	default:
+		KASSERT(0, ("%s: bogus index 0x%x", __FUNCTION__, index));
 	}
 
-	/* Stats */
-	if (m != NULL && hook != NULL && HOOK_PROTO(hook) == PROT_DOWNLINK) {
-		priv->stats.xmitFrames++;
-		priv->stats.xmitOctets += m->m_pkthdr.len;
-	}
+	/* Now figure out what to do with the frame */
+	switch (index) {
+	case HOOK_INDEX_INET:
+		if (priv->conf.enableVJCompression && priv->vjCompHooked) {
+			outHook = priv->hooks[HOOK_INDEX_VJC_IP];
+			break;
+		}
+		/* FALLTHROUGH */
+	case HOOK_INDEX_ATALK:
+	case HOOK_INDEX_IPX:
+	case HOOK_INDEX_VJC_COMP:
+	case HOOK_INDEX_VJC_UNCOMP:
+	case HOOK_INDEX_VJC_VJIP:
+		if (priv->conf.enableCompression
+		    && priv->hooks[HOOK_INDEX_COMPRESS] != NULL) {
+			if ((m = ng_ppp_addproto(m, proto, 1)) == NULL) {
+				NG_FREE_META(meta);
+				return (ENOBUFS);
+			}
+			outHook = priv->hooks[HOOK_INDEX_COMPRESS];
+			break;
+		}
+		/* FALLTHROUGH */
+	case HOOK_INDEX_COMPRESS:
+		if (priv->conf.enableEncryption
+		    && priv->hooks[HOOK_INDEX_ENCRYPT] != NULL) {
+			if ((m = ng_ppp_addproto(m, proto, 1)) == NULL) {
+				NG_FREE_META(meta);
+				return (ENOBUFS);
+			}
+			outHook = priv->hooks[HOOK_INDEX_ENCRYPT];
+			break;
+		}
+		/* FALLTHROUGH */
+	case HOOK_INDEX_ENCRYPT:
+	case HOOK_INDEX_BYPASS:
+		if ((m = ng_ppp_addproto(m, proto,
+		    linkNum == NG_PPP_BUNDLE_LINKNUM
+		      || priv->conf.links[linkNum].enableProtoComp)) == NULL) {
+			NG_FREE_META(meta);
+			return (ENOBUFS);
+		}
+		return ng_ppp_output(node, NG_PPP_BUNDLE_LINKNUM, m, meta);
 
-	/* Forward packet on hook */
-	NG_SEND_DATA(error, hook, m, meta);
-	return (error);
+	/* Incoming data */
+	case HOOK_INDEX_DECRYPT:
+	case HOOK_INDEX_DECOMPRESS:
+	case HOOK_INDEX_VJC_IP:
+		return ng_ppp_input(node, NG_PPP_BUNDLE_LINKNUM, m, meta);
+	}
 
-done:
-	/* Something went wrong */
-	NG_FREE_DATA(m, meta);
+	/* Send packet out hook */
+	NG_SEND_DATA(error, outHook, m, meta);
 	return (error);
 }
 
@@ -360,47 +624,781 @@ ng_ppp_disconnect(hook_p hook)
  ************************************************************************/
 
 /*
- * Decode ASCII protocol name
+ * Handle an incoming frame.  Extract the PPP protocol number
+ * and dispatch accordingly.
  */
 static int
-ng_ppp_decodehookname(const char *name)
+ng_ppp_input(node_p node, int linkNum, struct mbuf *m, meta_p meta)
 {
-	int     k, proto;
-
-	for (k = 0; gAliases[k].name; k++)
-		if (!strcmp(gAliases[k].name, name))
-			return (gAliases[k].proto);
-	if (strlen(name) != 6 || name[0] != '0' || name[1] != 'x')
-		return (-1);
-	for (proto = k = 2; k < 6; k++) {
-		const u_char ch = name[k] | 0x20;
-		int dig;
-
-		if (ch >= '0' && ch <= '9')
-			dig = ch - '0';
-		else if (ch >= 'a' && ch <= 'f')
-			dig = ch - 'a' + 10;
+	const priv_p priv = node->private;
+	hook_p outHook = NULL;
+	int proto, error;
+
+	/* Extract protocol number */
+	for (proto = 0; !PROT_VALID(proto) && m->m_pkthdr.len > 0; ) {
+		if (m->m_len < 1 && (m = m_pullup(m, 1)) == NULL) {
+			NG_FREE_META(meta);
+			return (ENOBUFS);
+		}
+		proto = (proto << 8) + *mtod(m, u_char *);
+		m_adj(m, 1);
+	}
+	if (!PROT_VALID(proto)) {
+		if (linkNum == NG_PPP_BUNDLE_LINKNUM)
+			priv->bundleStats.badProtos++;
 		else
-			return (-1);
-		proto = (proto << 4) + dig;
+			priv->linkStats[linkNum].badProtos++;
+		NG_FREE_DATA(m, meta);
+		return (EINVAL);
+	}
+
+	/* Check protocol */
+	switch (proto) {
+	case PROT_COMPD:
+		if (priv->conf.enableDecompression)
+			outHook = priv->hooks[HOOK_INDEX_DECOMPRESS];
+		break;
+	case PROT_CRYPTD:
+		if (priv->conf.enableDecryption)
+			outHook = priv->hooks[HOOK_INDEX_DECRYPT];
+		break;
+	case PROT_VJCOMP:
+		if (priv->conf.enableVJDecompression && priv->vjCompHooked)
+			outHook = priv->hooks[HOOK_INDEX_VJC_COMP];
+		break;
+	case PROT_VJUNCOMP:
+		if (priv->conf.enableVJDecompression && priv->vjCompHooked)
+			outHook = priv->hooks[HOOK_INDEX_VJC_UNCOMP];
+		break;
+	case PROT_MP:
+		if (priv->conf.enableMultilink) {
+			NG_FREE_META(meta);
+			return ng_ppp_mp_input(node, linkNum, m, meta);
+		}
+		break;
+	case PROT_APPLETALK:
+		if (priv->conf.enableAtalk)
+			outHook = priv->hooks[HOOK_INDEX_ATALK];
+		break;
+	case PROT_IPX:
+		if (priv->conf.enableIPX)
+			outHook = priv->hooks[HOOK_INDEX_IPX];
+		break;
+	case PROT_IP:
+		if (priv->conf.enableIP)
+			outHook = priv->hooks[HOOK_INDEX_INET];
+		break;
+	}
+
+	/* For unknown/inactive protocols, forward out the bypass hook */
+	if (outHook == NULL) {
+		M_PREPEND(m, 4, M_NOWAIT);
+		if (m == NULL || (m->m_len < 4 && (m = m_pullup(m, 4)) == NULL))
+			return (ENOBUFS);
+		mtod(m, u_int16_t *)[0] = htons(linkNum);
+		mtod(m, u_int16_t *)[1] = htons(proto);
+		outHook = priv->hooks[HOOK_INDEX_BYPASS];
+	}
+
+	/* Forward frame */
+	NG_SEND_DATA(error, outHook, m, meta);
+	return (error);
+}
+
+/*
+ * Deliver a frame out a link, either a real one or NG_PPP_BUNDLE_LINKNUM
+ */
+static int
+ng_ppp_output(node_p node, int linkNum, struct mbuf *m, meta_p meta)
+{
+	const priv_p priv = node->private;
+	int error;
+
+	/* Check for bundle virtual link */
+	if (linkNum == NG_PPP_BUNDLE_LINKNUM) {
+		if (priv->conf.enableMultilink)
+			return ng_ppp_mp_output(node, m, meta);
+		linkNum = priv->activeLinks[0];
 	}
-	if (!PROT_VALID(proto))
-		return(-1);
-	return (proto);
+
+	/* Check link status */
+	if (!priv->conf.links[linkNum].enableLink)
+		return (ENXIO);
+	if (priv->links[linkNum] == NULL) {
+		NG_FREE_DATA(m, meta);
+		return (ENETDOWN);
+	}
+
+	/* Update stats XXX even if error? */
+	priv->linkStats[linkNum].xmitFrames++;
+	priv->linkStats[linkNum].xmitOctets += m->m_pkthdr.len;
+
+	/* Deliver frame */
+	NG_SEND_DATA(error, priv->links[linkNum], m, meta);
+	return error;
 }
 
 /*
- * Find a hook by protocol number
+ * Handle an incoming multi-link fragment
  */
-static hook_p
-ng_ppp_findhook(node_p node, int proto)
+static int
+ng_ppp_mp_input(node_p node, int linkNum, struct mbuf *m, meta_p meta)
 {
-	hook_p hook;
+	const priv_p priv = node->private;
+	struct ng_ppp_frag frag0, *frag = &frag0;
+	struct ng_ppp_frag *qent, *qnext;
+	struct ng_ppp_frag *first = NULL, *last = NULL;
+	int diff, highSeq, nextSeq;
+	struct mbuf *tail;
+
+	/* Extract fragment information from MP header */
+	if (priv->conf.recvShortSeq) {
+		u_int16_t shdr;
+
+		if (m->m_pkthdr.len < 2) {
+			NG_FREE_DATA(m, meta);
+			return (EINVAL);
+		}
+		if (m->m_len < 2 && (m = m_pullup(m, 2)) == NULL) {
+			NG_FREE_META(meta);
+			return (ENOBUFS);
+		}
+		shdr = ntohs(*mtod(m, u_int16_t *));
+		frag->seq = shdr & MP_SHORT_SEQ_MASK;
+		frag->first = (shdr & MP_SHORT_FIRST_FLAG) != 0;
+		frag->last = (shdr & MP_SHORT_LAST_FLAG) != 0;
+		highSeq = CIRCLEQ_EMPTY(&priv->frags) ?
+		    frag->seq : CIRCLEQ_FIRST(&priv->frags)->seq;
+		diff = MP_SHORT_SEQ_DIFF(frag->seq, highSeq);
+		m_adj(m, 2);
+	} else {
+		u_int32_t lhdr;
+
+		if (m->m_pkthdr.len < 4) {
+			NG_FREE_DATA(m, meta);
+			return (EINVAL);
+		}
+		if (m->m_len < 4 && (m = m_pullup(m, 4)) == NULL) {
+			NG_FREE_META(meta);
+			return (ENOBUFS);
+		}
+		lhdr = ntohl(*mtod(m, u_int32_t *));
+		frag->seq = lhdr & MP_LONG_SEQ_MASK;
+		frag->first = (lhdr & MP_LONG_FIRST_FLAG) != 0;
+		frag->last = (lhdr & MP_LONG_LAST_FLAG) != 0;
+		highSeq = CIRCLEQ_EMPTY(&priv->frags) ?
+		    frag->seq : CIRCLEQ_FIRST(&priv->frags)->seq;
+		diff = MP_LONG_SEQ_DIFF(frag->seq, highSeq);
+		m_adj(m, 4);
+	}
+	frag->data = m;
+	frag->meta = meta;
+
+	/* If the sequence number makes a large jump, empty the queue */
+	if (diff <= -MP_INSANE_SEQ_JUMP || diff >= MP_INSANE_SEQ_JUMP)
+		ng_ppp_free_frags(node);
+
+	/* Optimization: handle a frame that's all in one fragment */
+	if (frag->first && frag->last)
+		return ng_ppp_input(node, NG_PPP_BUNDLE_LINKNUM, m, meta);
+
+	/* Allocate a new frag struct for the queue */
+	MALLOC(frag, struct ng_ppp_frag *, sizeof(*frag), M_NETGRAPH, M_NOWAIT);
+	if (frag == NULL) {
+		NG_FREE_DATA(m, meta);
+		return (ENOMEM);
+	}
+	*frag = frag0;
+	meta = NULL;
+	m = NULL;
+
+	/* Add fragment to queue, which is reverse sorted by sequence number */
+	CIRCLEQ_FOREACH(qent, &priv->frags, f_qent) {
+		diff = MP_SEQ_DIFF(frag->seq, qent->seq);
+		if (diff > 0) {
+			CIRCLEQ_INSERT_BEFORE(&priv->frags, qent, frag, f_qent);
+			break;
+		} else if (diff == 0) {	     /* should never happen! */
+			log(LOG_ERR, "%s: rec'd dup MP fragment\n", node->name);
+			if (linkNum == NG_PPP_BUNDLE_LINKNUM)
+				priv->linkStats[linkNum].dupFragments++;
+			else
+				priv->bundleStats.dupFragments++;
+			NG_FREE_DATA(frag->data, frag->meta);
+			FREE(frag, M_NETGRAPH);
+			return (EINVAL);
+		}
+	}
+	if (qent == NULL)
+		CIRCLEQ_INSERT_TAIL(&priv->frags, frag, f_qent);
+
+	/* Find the first fragment in the possibly newly completed frame */
+	for (nextSeq = frag->seq, qent = frag;
+	    qent != (void *) &priv->frags;
+	    qent = CIRCLEQ_PREV(qent, f_qent)) {
+		if (qent->seq != nextSeq)
+			goto pruneQueue;
+		if (qent->first) {
+			first = qent;
+			break;
+		}
+		nextSeq = (nextSeq + 1) & MP_SEQ_MASK;
+	}
+
+	/* Find the last fragment in the possibly newly completed frame */
+	for (nextSeq = frag->seq, qent = frag;
+	    qent != (void *) &priv->frags;
+	    qent = CIRCLEQ_NEXT(qent, f_qent)) {
+		if (qent->seq != nextSeq)
+			goto pruneQueue;
+		if (qent->last) {
+			last = qent;
+			break;
+		}
+		nextSeq = (nextSeq - 1) & MP_SEQ_MASK;
+	}
+
+	/* We have a complete frame, extract it from the queue */
+	for (tail = NULL, qent = first; qent != NULL; qent = qnext) {
+		qnext = CIRCLEQ_PREV(qent, f_qent);
+		CIRCLEQ_REMOVE(&priv->frags, qent, f_qent);
+		if (tail == NULL) {
+			tail = m = qent->data;
+			meta = qent->meta;	/* inherit first frag's meta */
+		} else {
+			m->m_pkthdr.len += qent->data->m_pkthdr.len;
+			tail->m_next = qent->data;
+			NG_FREE_META(qent->meta); /* drop other frag's metas */
+		}
+		while (tail->m_next != NULL)
+			tail = tail->m_next;
+		if (qent == last)
+			qnext = NULL;
+		FREE(qent, M_NETGRAPH);
+	}
+
+pruneQueue:
+	/* Prune out stale entries in the queue */
+	for (qent = CIRCLEQ_LAST(&priv->frags); 
+	    qent != (void *) &priv->frags; qent = qnext) {
+		if (MP_SEQ_DIFF(highSeq, qent->seq) <= MP_MAX_SEQ_LINGER)
+			break;
+		qnext = CIRCLEQ_PREV(qent, f_qent);
+		CIRCLEQ_REMOVE(&priv->frags, qent, f_qent);
+		NG_FREE_DATA(qent->data, qent->meta);
+		FREE(qent, M_NETGRAPH);
+	}
+
+	/* Deliver newly completed frame, if any */
+	return m ? ng_ppp_input(node, NG_PPP_BUNDLE_LINKNUM, m, meta) : 0;
+}
+
+/*
+ * Deliver a frame out on the bundle, i.e., figure out how to fragment
+ * the frame across the individual PPP links and do so.
+ */
+static int
+ng_ppp_mp_output(node_p node, struct mbuf *m, meta_p meta)
+{
+	const priv_p priv = node->private;
+	int distrib[NG_PPP_MAX_LINKS];
+	int firstFragment;
+	int activeLinkNum;
+
+	/* At least one link must be active */
+	if (priv->numActiveLinks == 0) {
+		NG_FREE_DATA(m, meta);
+		return (ENETDOWN);
+	}
+
+	/* Round-robin strategy */
+	if (priv->conf.enableRoundRobin || m->m_pkthdr.len < MP_MIN_FRAG_LEN) {
+		activeLinkNum = priv->lastLink++ % priv->numActiveLinks;
+		bzero(&distrib, priv->numActiveLinks * sizeof(distrib[0]));
+		distrib[activeLinkNum] = m->m_pkthdr.len;
+		goto deliver;
+	}
+
+	/* Strategy when all links are equivalent (optimize the common case) */
+	if (priv->allLinksEqual) {
+		const int fraction = m->m_pkthdr.len / priv->numActiveLinks;
+		int i, remain;
+
+		for (i = 0; i < priv->numActiveLinks; i++)
+			distrib[priv->lastLink++ % priv->numActiveLinks]
+			    = fraction;
+		remain = m->m_pkthdr.len - (fraction * priv->numActiveLinks);
+		while (remain > 0) {
+			distrib[priv->lastLink++ % priv->numActiveLinks]++;
+			remain--;
+		}
+		goto deliver;
+	}
+
+	/* Strategy when all links are not equivalent */
+	ng_ppp_mp_strategy(node, m->m_pkthdr.len, distrib);
+
+deliver:
+	/* Update stats */
+	priv->bundleStats.xmitFrames++;
+	priv->bundleStats.xmitOctets += m->m_pkthdr.len;
+
+	/* Send alloted portions of frame out on the link(s) */
+	for (firstFragment = 1, activeLinkNum = priv->numActiveLinks - 1;
+	    activeLinkNum >= 0; activeLinkNum--) {
+		const int linkNum = priv->activeLinks[activeLinkNum];
+
+		/* Deliver fragment(s) out the next link */
+		for ( ; distrib[activeLinkNum] > 0; firstFragment = 0) {
+			int len, lastFragment, error;
+			struct mbuf *m2;
+			meta_p meta2;
+
+			/* Calculate fragment length; don't exceed link MTU */
+			len = distrib[activeLinkNum];
+			if (len > priv->conf.links[linkNum].mru)
+				len = priv->conf.links[linkNum].mru;
+			distrib[activeLinkNum] -= len;
+			lastFragment = (len == m->m_pkthdr.len);
+
+			/* Split off next fragment as "m2" */
+			m2 = m;
+			if (!lastFragment) {
+				struct mbuf *n = m_split(m, len, M_NOWAIT);
+
+				if (n == NULL) {
+					NG_FREE_DATA(m, meta);
+					return (ENOMEM);
+				}
+				m = n;
+			}
+
+			/* Prepend MP header */
+			if (priv->conf.xmitShortSeq) {
+				u_int16_t shdr;
+
+				M_PREPEND(m2, 2, M_NOWAIT);
+				if (m2 == NULL
+				    || (m2->m_len < 2
+				      && (m2 = m_pullup(m2, 2)) == NULL)) {
+					if (!lastFragment)
+						m_freem(m);
+					NG_FREE_META(meta);
+					return (ENOBUFS);
+				}
+				shdr = priv->mpSeqOut;
+				priv->mpSeqOut =
+				    (priv->mpSeqOut + 1) % MP_SHORT_SEQ_MASK;
+				if (firstFragment)
+					shdr |= MP_SHORT_FIRST_FLAG;
+				if (lastFragment)
+					shdr |= MP_SHORT_LAST_FLAG;
+				*mtod(m2, u_int16_t *) = htons(shdr);
+			} else {
+				u_int32_t lhdr;
+
+				M_PREPEND(m2, 4, M_NOWAIT);
+				if (m2 == NULL
+				    || (m2->m_len < 4
+				      && (m2 = m_pullup(m2, 4)) == NULL)) {
+					if (!lastFragment)
+						m_freem(m);
+					NG_FREE_META(meta);
+					return (ENOBUFS);
+				}
+				lhdr = priv->mpSeqOut;
+				priv->mpSeqOut =
+				    (priv->mpSeqOut + 1) % MP_LONG_SEQ_MASK;
+				if (firstFragment)
+					lhdr |= MP_LONG_FIRST_FLAG;
+				if (lastFragment)
+					lhdr |= MP_LONG_LAST_FLAG;
+				*mtod(m2, u_int32_t *) = htonl(lhdr);
+			}
+
+			/* Add MP protocol number */
+			m2 = ng_ppp_addproto(m, PROT_MP,
+			    priv->conf.links[linkNum].enableProtoComp);
+			if (m2 == NULL) {
+				if (!lastFragment)
+					m_freem(m);
+				NG_FREE_META(meta);
+				return (ENOBUFS);
+			}
+
+			/* Copy the meta information, if any */
+			if (meta != NULL && !lastFragment) {
+				MALLOC(meta2, meta_p,
+				    meta->used_len, M_NETGRAPH, M_NOWAIT);
+				if (meta2 == NULL) {
+					m_freem(m2);
+					NG_FREE_DATA(m, meta);
+					return (ENOMEM);
+				}
+				meta2->allocated_len = meta->used_len;
+				bcopy(meta, meta2, meta->used_len);
+			} else
+				meta2 = meta;
+
+			/* Send fragment */
+			error = ng_ppp_output(node, linkNum, m2, meta2);
+
+			/* Abort for error */
+			if (error != 0) {
+				if (!lastFragment)
+					NG_FREE_DATA(m, meta);
+				return (error);
+			}
+		}
+	}
+
+	/* Done */
+	return (0);
+}
+
+/*
+ * Computing the optimal fragmentation
+ * -----------------------------------
+ *
+ * This routine tries to compute the optimal fragmentation pattern based
+ * on each link's latency, bandwidth, and calculated additional latency.
+ * The latter quantity is the additional latency caused by previously
+ * written data that has not been transmitted yet.
+ *
+ * This algorithm is only useful when not all of the links have the
+ * same latency and bandwidth values.
+ *
+ * The essential idea is to make the last bit of each fragment of the
+ * frame arrive at the opposite end at the exact same time. This greedy
+ * algorithm is optimal, in that no other scheduling could result in any
+ * packet arriving any sooner unless packets are delivered out of order.
+ *
+ * Suppose link i has bandwidth b_i (in tens of bytes per milisecond) and
+ * latency l_i (in miliseconds). Consider the function function f_i(t)
+ * which is equal to the number of bytes that will have arrived at
+ * the peer after t miliseconds if we start writing continuously at
+ * time t = 0. Then f_i(t) = b_i * (t - l_i) = ((b_i * t) - (l_i * b_i).
+ * That is, f_i(t) is a line with slope b_i and y-intersect -(l_i * b_i).
+ * Note that the y-intersect is always <= zero because latency can't be
+ * negative.  Note also that really the function is f_i(t) except when
+ * f_i(t) is negative, in which case the function is zero.  To take
+ * care of this, let Q_i(t) = { if (f_i(t) > 0) return 1; else return 0; }.
+ * So the actual number of bytes that will have arrived at the peer after
+ * t miliseconds is f_i(t) * Q_i(t).
+ *
+ * At any given time, each link has some additional latency a_i >= 0
+ * due to previously written fragment(s) which are still in the queue.
+ * This value is easily computed from the time since last transmission,
+ * the previous latency value, the number of bytes written, and the
+ * link's bandwidth.
+ *
+ * Assume that l_i includes any a_i already, and that the links are
+ * sorted by latency, so that l_i <= l_{i+1}.
+ *
+ * Let N be the total number of bytes in the current frame we are sending.
+ *
+ * Suppose we were to start writing bytes at time t = 0 on all links
+ * simultaneously, which is the most we can possibly do.  Then let
+ * F(t) be equal to the total number of bytes received by the peer
+ * after t miliseconds. Then F(t) = Sum_i (f_i(t) * Q_i(t)).
+ *
+ * Our goal is simply this: fragment the frame across the links such
+ * that the peer is able to reconstruct the completed frame as soon as
+ * possible, i.e., at the least possible value of t. Call this value t_0.
+ *
+ * Then it follows that F(t_0) = N. Our strategy is first to find the value
+ * of t_0, and then deduce how many bytes to write to each link.
+ *
+ * Rewriting F(t_0):
+ *
+ *   t_0 = ( N + Sum_i ( l_i * b_i * Q_i(t_0) ) ) / Sum_i ( b_i * Q_i(t_0) )
+ *
+ * Now, we note that Q_i(t) is constant for l_i <= t <= l_{i+1}. t_0 will
+ * lie in one of these ranges.  To find it, we just need to find the i such
+ * that F(l_i) <= N <= F(l_{i+1}).  Then we compute all the constant values
+ * for Q_i() in this range, plug in the remaining values, solving for t_0.
+ *
+ * Once t_0 is known, then the number of bytes to send on link i is
+ * just f_i(t_0) * Q_i(t_0).
+ *
+ * In other words, we start allocating bytes to the links one at a time.
+ * We keep adding links until the frame is completely sent.  Some links
+ * may not get any bytes because their latency is too high.
+ *
+ * Is all this work really worth the trouble?  Depends on the situation.
+ * The bigger the ratio of computer speed to link speed, and the more
+ * important total bundle latency is (e.g., for interactive response time),
+ * the more it's worth it.  There is however the cost of calling this
+ * function for every frame.  The running time is O(n^2) where n is the
+ * number of links that receive a non-zero number of bytes.
+ *
+ * Since latency is measured in miliseconds, the "resolution" of this
+ * algorithm is one milisecond.
+ *
+ * To avoid this algorithm altogether, configure all links to have the
+ * same latency and bandwidth.
+ */
+static void
+ng_ppp_mp_strategy(node_p node, int len, int *distrib)
+{
+	const priv_p priv = node->private;
+	int latency[NG_PPP_MAX_LINKS];
+	int sortByLatency[NG_PPP_MAX_LINKS];
+	int activeLinkNum, linkNum;
+	int t0, total, topSum, botSum;
+	struct timeval now;
+	int i, numFragments;
+
+	/* If only one link, this gets real easy */
+	if (priv->numActiveLinks == 1) {
+		distrib[0] = len;
+		return;
+	}
+
+	/* Get current time */
+	getmicrotime(&now);
+
+	/* Compute latencies for each link at this point in time */
+	for (activeLinkNum = 0;
+	    activeLinkNum < priv->numActiveLinks; activeLinkNum++) {
+		struct timeval diff;
+		int xmitBytes;
+
+		/* Start with base latency value */
+		linkNum = priv->activeLinks[activeLinkNum];
+		latency[activeLinkNum] = priv->conf.links[linkNum].latency;
+		sortByLatency[activeLinkNum] = activeLinkNum;	/* see below */
+
+		/* Any additional latency? */
+		if (priv->qstat[activeLinkNum].bytesInQueue == 0)
+			continue;
+
+		/* Compute time delta since last write */
+		diff = now;
+		timevalsub(&diff, &priv->qstat[activeLinkNum].lastWrite);
+		if (now.tv_sec < 0 || diff.tv_sec >= 10) {	/* sanity */
+			priv->qstat[activeLinkNum].bytesInQueue = 0;
+			continue;
+		}
+
+		/* How many bytes could have transmitted since last write? */
+		xmitBytes = priv->conf.links[linkNum].bandwidth * diff.tv_sec
+		    + (priv->conf.links[linkNum].bandwidth
+			* (diff.tv_usec / 1000)) / 100;
+		priv->qstat[activeLinkNum].bytesInQueue -= xmitBytes;
+		if (priv->qstat[activeLinkNum].bytesInQueue < 0)
+			priv->qstat[activeLinkNum].bytesInQueue = 0;
+		else
+			latency[activeLinkNum] +=
+			    (100 * priv->qstat[activeLinkNum].bytesInQueue)
+				/ priv->conf.links[linkNum].bandwidth;
+	}
+
+	/* Sort links by latency */
+	compareLatencies = latency;
+	qsort(sortByLatency,
+	    priv->numActiveLinks, sizeof(*sortByLatency), ng_ppp_intcmp);
+	compareLatencies = NULL;
+
+	/* Find the interval we need (add links in sortByLatency[] order) */
+	for (numFragments = 1;
+	    numFragments < priv->numActiveLinks; numFragments++) {
+		for (total = i = 0; i < numFragments; i++) {
+			int flowTime;
+
+			flowTime = latency[sortByLatency[numFragments]]
+			    - latency[sortByLatency[i]];
+			total += ((flowTime * priv->conf.links[
+			    priv->activeLinks[sortByLatency[i]]].bandwidth)
+			    	+ 99) / 100;
+		}
+		if (total >= len)
+			break;
+	}
+
+	/* Solve for t_0 in that interval */
+	for (topSum = botSum = i = 0; i < numFragments; i++) {
+		int bw = priv->conf.links[
+		    priv->activeLinks[sortByLatency[i]]].bandwidth;
+
+		topSum += latency[sortByLatency[i]] * bw;	/* / 100 */
+		botSum += bw;					/* / 100 */
+	}
+	t0 = ((len * 100) + topSum + botSum / 2) / botSum;
+
+	/* Compute f_i(t_0) all i */
+	bzero(distrib, priv->numActiveLinks * sizeof(*distrib));
+	for (total = i = 0; i < numFragments; i++) {
+		int bw = priv->conf.links[
+		    priv->activeLinks[sortByLatency[i]]].bandwidth;
+
+		distrib[sortByLatency[i]] =
+		    (bw * (t0 - latency[sortByLatency[i]]) + 50) / 100;
+		total += distrib[sortByLatency[i]];
+	}
+
+	/* Deal with any rounding error by adjusting fastest link */
+	if (total != len) {
+		int fast = 0;
+
+		for (i = 1; i < numFragments; i++) {
+			if (priv->conf.links[
+			      priv->activeLinks[sortByLatency[i]]].bandwidth >
+			    priv->conf.links[
+			      priv->activeLinks[sortByLatency[fast]]].bandwidth)
+				fast = i;
+		}
+		distrib[sortByLatency[fast]] += len - total;
+	}
+
+	/* Update bytes in queue counters */
+	for (i = 0; i < priv->numActiveLinks; i++) {
+		priv->qstat[i].bytesInQueue += distrib[i];
+		priv->qstat[i].lastWrite = now;
+	}
+}
+
+/*
+ * Compare two integers
+ */
+static int
+ng_ppp_intcmp(const void *v1, const void *v2)
+{
+	const int index1 = *((const int *) v1);
+	const int index2 = *((const int *) v2);
+
+	return compareLatencies[index1] - compareLatencies[index2];
+}
+
+/*
+ * Prepend a possibly compressed PPP protocol number in front of a frame
+ */
+static struct mbuf *
+ng_ppp_addproto(struct mbuf *m, int proto, int compOK)
+{
+	int psize = (PROT_COMPRESSIBLE(proto) && compOK) ? 1 : 2;
+
+	/* Add protocol number */
+	M_PREPEND(m, psize, M_NOWAIT);
+	if (m == NULL || (m->m_len < psize && (m = m_pullup(m, psize)) == NULL))
+		return (NULL);
+	if (psize == 1)
+		*mtod(m, u_char *) = (u_char)proto;
+	else
+		*mtod(m, u_int16_t *) = htons((u_int16_t)proto);
+	return (m);
+}
+
+/*
+ * Update private information that is derived from other private information
+ */
+static void
+ng_ppp_update(node_p node, int newConf)
+{
+	const priv_p priv = node->private;
+	int i;
+
+	/* Update active status for VJ Compression */
+	priv->vjCompHooked = priv->hooks[HOOK_INDEX_VJC_IP] != NULL
+	    && priv->hooks[HOOK_INDEX_VJC_COMP] != NULL
+	    && priv->hooks[HOOK_INDEX_VJC_UNCOMP] != NULL
+	    && priv->hooks[HOOK_INDEX_VJC_VJIP] != NULL;
+
+	/* Increase latency for each link an amount equal to one MP header */
+	if (newConf) {
+		for (i = 0; i < NG_PPP_MAX_LINKS; i++) {
+			int hdrBytes;
+
+			hdrBytes = (priv->conf.links[i].enableProtoComp ? 1 : 2)
+			    + (priv->conf.xmitShortSeq ? 2 : 4);
+			priv->conf.links[i].latency +=
+			    ((hdrBytes * priv->conf.links[i].bandwidth) + 50)
+				/ 100;
+		}
+	}
+
+	/* Update list of active links */
+	bzero(&priv->activeLinks, sizeof(priv->activeLinks));
+	priv->numActiveLinks = 0;
+	priv->allLinksEqual = 1;
+	for (i = 0; i < NG_PPP_MAX_LINKS; i++) {
+		if (priv->conf.links[i].enableLink && priv->links[i] != NULL) {
+			priv->activeLinks[priv->numActiveLinks++] = i;
+			if (priv->conf.links[i].latency
+				  != priv->conf.links[0].latency
+			    || priv->conf.links[i].bandwidth
+				  != priv->conf.links[0].bandwidth)
+				priv->allLinksEqual = 0;
+		}
+	}
+
+	/* Reset MP state if no longer active */
+	if (!priv->conf.enableMultilink || priv->numActiveLinks == 0) {
+		ng_ppp_free_frags(node);
+		priv->mpSeqOut = MP_INITIAL_SEQ;
+		bzero(&priv->qstat, sizeof(priv->qstat));
+	}
+}
+
+/*
+ * Determine if a new configuration would represent a valid change
+ * from the current configuration and link activity status.
+ */
+static int
+ng_ppp_config_valid(node_p node, const struct ng_ppp_node_config *newConf)
+{
+	const priv_p priv = node->private;
+	int i, newNumLinksActive;
+
+	/* Check per-link config and count how many links would be active */
+	for (newNumLinksActive = i = 0; i < NG_PPP_MAX_LINKS; i++) {
+		if (newConf->links[i].mru < MP_MIN_LINK_MRU)
+			return (0);
+		if (newConf->links[i].bandwidth == 0)
+			return (0);
+		if (newConf->links[i].bandwidth > NG_PPP_MAX_BANDWIDTH)
+			return (0);
+		if (newConf->links[i].latency > NG_PPP_MAX_LATENCY)
+			return (0);
+		if (newConf->links[i].enableLink && priv->links[i] != NULL)
+			newNumLinksActive++;
+	}
+
+	/* Check bundle parameters */
+	if (priv->conf.enableMultilink && newConf->mrru < MP_MIN_MRRU)
+		return (0);
+
+	/* At most one link can be active unless multi-link is enabled */
+	if (!newConf->enableMultilink && newNumLinksActive > 1)
+		return (0);
+
+	/* Disallow changes to multi-link configuration while MP is active */
+	if (priv->numActiveLinks > 0 && newNumLinksActive > 0) {
+		if (!priv->conf.enableMultilink != !newConf->enableMultilink
+		    || !priv->conf.xmitShortSeq != !newConf->xmitShortSeq
+		    || !priv->conf.recvShortSeq != !newConf->recvShortSeq)
+			return (0);
+	}
+
+	/* Configuration change is valid */
+	return (1);
+}
+
+/*
+ * Free all entries in the fragment queue
+ */
+static void
+ng_ppp_free_frags(node_p node)
+{
+	const priv_p priv = node->private;
+	struct ng_ppp_frag *qent, *next;
 
-	LIST_FOREACH(hook, &node->hooks, hooks) {
-		if (HOOK_PROTO(hook) == proto)
-			return (hook);
+	for (qent = CIRCLEQ_FIRST(&priv->frags);
+	    qent != (void *) &priv->frags; qent = next) {
+		next = CIRCLEQ_NEXT(qent, f_qent);
+		NG_FREE_DATA(qent->data, qent->meta);
+		FREE(qent, M_NETGRAPH);
 	}
-	return (NULL);
+	CIRCLEQ_INIT(&priv->frags);
 }