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