sys/netgraph/ng_pptpgre.c

   1 /*
   2  * ng_pptpgre.c
   3  */
   4
   5 /*-
   6  * Copyright (c) 1996-1999 Whistle Communications, Inc.
   7  * All rights reserved.
   8  *
   9  * Subject to the following obligations and disclaimer of warranty, use and
  10  * redistribution of this software, in source or object code forms, with or
  11  * without modifications are expressly permitted by Whistle Communications;
  12  * provided, however, that:
  13  * 1. Any and all reproductions of the source or object code must include the
  14  *    copyright notice above and the following disclaimer of warranties; and
  15  * 2. No rights are granted, in any manner or form, to use Whistle
  16  *    Communications, Inc. trademarks, including the mark "WHISTLE
  17  *    COMMUNICATIONS" on advertising, endorsements, or otherwise except as
  18  *    such appears in the above copyright notice or in the software.
  19  *
  20  * THIS SOFTWARE IS BEING PROVIDED BY WHISTLE COMMUNICATIONS "AS IS", AND
  21  * TO THE MAXIMUM EXTENT PERMITTED BY LAW, WHISTLE COMMUNICATIONS MAKES NO
  22  * REPRESENTATIONS OR WARRANTIES, EXPRESS OR IMPLIED, REGARDING THIS SOFTWARE,
  23  * INCLUDING WITHOUT LIMITATION, ANY AND ALL IMPLIED WARRANTIES OF
  24  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, OR NON-INFRINGEMENT.
  25  * WHISTLE COMMUNICATIONS DOES NOT WARRANT, GUARANTEE, OR MAKE ANY
  26  * REPRESENTATIONS REGARDING THE USE OF, OR THE RESULTS OF THE USE OF THIS
  27  * SOFTWARE IN TERMS OF ITS CORRECTNESS, ACCURACY, RELIABILITY OR OTHERWISE.
  28  * IN NO EVENT SHALL WHISTLE COMMUNICATIONS BE LIABLE FOR ANY DAMAGES
  29  * RESULTING FROM OR ARISING OUT OF ANY USE OF THIS SOFTWARE, INCLUDING
  30  * WITHOUT LIMITATION, ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY,
  31  * PUNITIVE, OR CONSEQUENTIAL DAMAGES, PROCUREMENT OF SUBSTITUTE GOODS OR
  32  * SERVICES, LOSS OF USE, DATA OR PROFITS, HOWEVER CAUSED AND UNDER ANY
  33  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  34  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  35  * THIS SOFTWARE, EVEN IF WHISTLE COMMUNICATIONS IS ADVISED OF THE POSSIBILITY
  36  * OF SUCH DAMAGE.
  37  *
  38  * Author: Archie Cobbs <archie@freebsd.org>
  39  *
  40  * $FreeBSD$
  41  * $Whistle: ng_pptpgre.c,v 1.7 1999/12/08 00:10:06 archie Exp $
  42  */
  43
  44 /*
  45  * PPTP/GRE netgraph node type.
  46  *
  47  * This node type does the GRE encapsulation as specified for the PPTP
  48  * protocol (RFC 2637, section 4).  This includes sequencing and
  49  * retransmission of frames, but not the actual packet delivery nor
  50  * any of the TCP control stream protocol.
  51  *
  52  * The "upper" hook of this node is suitable for attaching to a "ppp"
  53  * node link hook.  The "lower" hook of this node is suitable for attaching
  54  * to a "ksocket" node on hook "inet/raw/gre".
  55  */
  56
  57 #include <sys/param.h>
  58 #include <sys/systm.h>
  59 #include <sys/kernel.h>
  60 #include <sys/time.h>
  61 #include <sys/lock.h>
  62 #include <sys/malloc.h>
  63 #include <sys/mbuf.h>
  64 #include <sys/mutex.h>
  65 #include <sys/endian.h>
  66 #include <sys/errno.h>
  67 #include <sys/sysctl.h>
  68
  69 #include <netinet/in.h>
  70 #include <netinet/in_systm.h>
  71 #include <netinet/ip.h>
  72
  73 #include <netgraph/ng_message.h>
  74 #include <netgraph/netgraph.h>
  75 #include <netgraph/ng_parse.h>
  76 #include <netgraph/ng_pptpgre.h>
  77
  78 /* GRE packet format, as used by PPTP */
  79 struct greheader {
  80 #if BYTE_ORDER == LITTLE_ENDIAN
  81         u_char          recursion:3;            /* recursion control */
  82         u_char          ssr:1;                  /* strict source route */
  83         u_char          hasSeq:1;               /* sequence number present */
  84         u_char          hasKey:1;               /* key present */
  85         u_char          hasRoute:1;             /* routing present */
  86         u_char          hasSum:1;               /* checksum present */
  87         u_char          vers:3;                 /* version */
  88         u_char          flags:4;                /* flags */
  89         u_char          hasAck:1;               /* acknowlege number present */
  90 #elif BYTE_ORDER == BIG_ENDIAN
  91         u_char          hasSum:1;               /* checksum present */
  92         u_char          hasRoute:1;             /* routing present */
  93         u_char          hasKey:1;               /* key present */
  94         u_char          hasSeq:1;               /* sequence number present */
  95         u_char          ssr:1;                  /* strict source route */
  96         u_char          recursion:3;            /* recursion control */
  97         u_char          hasAck:1;               /* acknowlege number present */
  98         u_char          flags:4;                /* flags */
  99         u_char          vers:3;                 /* version */
 100 #else
 101 #error BYTE_ORDER is not defined properly
 102 #endif
 103         u_int16_t       proto;                  /* protocol (ethertype) */
 104         u_int16_t       length;                 /* payload length */
 105         u_int16_t       cid;                    /* call id */
 106         u_int32_t       data[0];                /* opt. seq, ack, then data */
 107 };
 108
 109 /* The PPTP protocol ID used in the GRE 'proto' field */
 110 #define PPTP_GRE_PROTO          0x880b
 111
 112 /* Bits that must be set a certain way in all PPTP/GRE packets */
 113 #define PPTP_INIT_VALUE         ((0x2001 << 16) | PPTP_GRE_PROTO)
 114 #define PPTP_INIT_MASK          0xef7fffff
 115
 116 /* Min and max packet length */
 117 #define PPTP_MAX_PAYLOAD        (0xffff - sizeof(struct greheader) - 8)
 118
 119 /* All times are scaled by this (PPTP_TIME_SCALE time units = 1 sec.) */
 120 #define PPTP_TIME_SCALE         1024                    /* milliseconds */
 121 typedef u_int64_t               pptptime_t;
 122
 123 /* Acknowledgment timeout parameters and functions */
 124 #define PPTP_XMIT_WIN           16                      /* max xmit window */
 125 #define PPTP_MIN_TIMEOUT        (PPTP_TIME_SCALE / 83)  /* 12 milliseconds */
 126 #define PPTP_MAX_TIMEOUT        (3 * PPTP_TIME_SCALE)   /* 3 seconds */
 127
 128 #define PPTP_REORDER_TIMEOUT    1
 129
 130 /* When we receive a packet, we wait to see if there's an outgoing packet
 131    we can piggy-back the ACK off of. These parameters determine the mimimum
 132    and maxmimum length of time we're willing to wait in order to do that.
 133    These have no effect unless "enableDelayedAck" is turned on. */
 134 #define PPTP_MIN_ACK_DELAY      (PPTP_TIME_SCALE / 500) /* 2 milliseconds */
 135 #define PPTP_MAX_ACK_DELAY      (PPTP_TIME_SCALE / 2)   /* 500 milliseconds */
 136
 137 /* See RFC 2637 section 4.4 */
 138 #define PPTP_ACK_ALPHA(x)       (((x) + 4) >> 3)        /* alpha = 0.125 */
 139 #define PPTP_ACK_BETA(x)        (((x) + 2) >> 2)        /* beta = 0.25 */
 140 #define PPTP_ACK_CHI(x)         ((x) << 2)      /* chi = 4 */
 141 #define PPTP_ACK_DELTA(x)       ((x) << 1)      /* delta = 2 */
 142
 143 #define PPTP_SEQ_DIFF(x,y)      ((int32_t)(x) - (int32_t)(y))
 144
 145 #define SESSHASHSIZE            0x0020
 146 #define SESSHASH(x)             (((x) ^ ((x) >> 8)) & (SESSHASHSIZE - 1))
 147
 148 SYSCTL_NODE(_net_graph, OID_AUTO, pptpgre, CTLFLAG_RW | CTLFLAG_MPSAFE, 0,
 149     "PPTPGRE");
 150
 151 /*
 152  * Reorder queue maximum length. Zero disables reorder.
 153  *
 154  * The node may keep reorder_max queue entries per session
 155  * if reorder is enabled, plus allocate one more for short time.
 156  *
 157  * Be conservative in memory consumption by default.
 158  * Lots of sessions with large queues can overflow M_NETGRAPH zone.
 159  */
 160 static int reorder_max = 1; /* reorder up to two swapped packets in a row */
 161 SYSCTL_UINT(_net_graph_pptpgre, OID_AUTO, reorder_max, CTLFLAG_RWTUN,
 162         &reorder_max, 0, "Reorder queue maximum length");
 163
 164 static int reorder_timeout = PPTP_REORDER_TIMEOUT;
 165 SYSCTL_UINT(_net_graph_pptpgre, OID_AUTO, reorder_timeout, CTLFLAG_RWTUN,
 166         &reorder_timeout, 0, "Reorder timeout is milliseconds");
 167
 168 /* Packet reorder FIFO queue */
 169 struct ng_pptpgre_roq {
 170         SLIST_ENTRY(ng_pptpgre_roq)  next;      /* next entry of the queue */
 171         item_p                  item;           /* netgraph item */
 172         u_int32_t               seq;            /* packet sequence number */
 173 };
 174 SLIST_HEAD(ng_pptpgre_roq_head, ng_pptpgre_roq);
 175 typedef struct ng_pptpgre_roq_head roqh;
 176
 177 /* We keep packet retransmit and acknowlegement state in this struct */
 178 struct ng_pptpgre_sess {
 179         node_p                  node;           /* this node pointer */
 180         hook_p                  hook;           /* hook to upper layers */
 181         struct ng_pptpgre_conf  conf;           /* configuration info */
 182         struct mtx              mtx;            /* session mutex */
 183         u_int32_t               recvSeq;        /* last seq # we rcv'd */
 184         u_int32_t               xmitSeq;        /* last seq # we sent */
 185         u_int32_t               recvAck;        /* last seq # peer ack'd */
 186         u_int32_t               xmitAck;        /* last seq # we ack'd */
 187         int32_t                 ato;            /* adaptive time-out value */
 188         int32_t                 rtt;            /* round trip time estimate */
 189         int32_t                 dev;            /* deviation estimate */
 190         u_int16_t               xmitWin;        /* size of xmit window */
 191         struct callout          sackTimer;      /* send ack timer */
 192         struct callout          rackTimer;      /* recv ack timer */
 193         u_int32_t               winAck;         /* seq when xmitWin will grow */
 194         pptptime_t              timeSent[PPTP_XMIT_WIN];
 195         LIST_ENTRY(ng_pptpgre_sess) sessions;
 196         roqh                    roq;            /* reorder queue head */
 197         u_int8_t                roq_len;        /* reorder queue length */
 198         struct callout          reorderTimer;   /* reorder timeout handler */
 199 };
 200 typedef struct ng_pptpgre_sess *hpriv_p;
 201
 202 /* Node private data */
 203 struct ng_pptpgre_private {
 204         hook_p                  upper;          /* hook to upper layers */
 205         hook_p                  lower;          /* hook to lower layers */
 206         struct ng_pptpgre_sess  uppersess;      /* default session for compat */
 207         LIST_HEAD(, ng_pptpgre_sess) sesshash[SESSHASHSIZE];
 208         struct ng_pptpgre_stats stats;          /* node statistics */
 209 };
 210 typedef struct ng_pptpgre_private *priv_p;
 211
 212 /* Netgraph node methods */
 213 static ng_constructor_t ng_pptpgre_constructor;
 214 static ng_rcvmsg_t      ng_pptpgre_rcvmsg;
 215 static ng_shutdown_t    ng_pptpgre_shutdown;
 216 static ng_newhook_t     ng_pptpgre_newhook;
 217 static ng_rcvdata_t     ng_pptpgre_rcvdata;
 218 static ng_rcvdata_t     ng_pptpgre_rcvdata_lower;
 219 static ng_disconnect_t  ng_pptpgre_disconnect;
 220
 221 /* Helper functions */
 222 static int      ng_pptpgre_xmit(hpriv_p hpriv, item_p item);
 223 static void     ng_pptpgre_start_send_ack_timer(hpriv_p hpriv);
 224 static void     ng_pptpgre_start_recv_ack_timer(hpriv_p hpriv);
 225 static void     ng_pptpgre_start_reorder_timer(hpriv_p hpriv);
 226 static void     ng_pptpgre_recv_ack_timeout(node_p node, hook_p hook,
 227                     void *arg1, int arg2);
 228 static void     ng_pptpgre_send_ack_timeout(node_p node, hook_p hook,
 229                     void *arg1, int arg2);
 230 static void     ng_pptpgre_reorder_timeout(node_p node, hook_p hook,
 231                     void *arg1, int arg2);
 232 static hpriv_p  ng_pptpgre_find_session(priv_p privp, u_int16_t cid);
 233 static void     ng_pptpgre_reset(hpriv_p hpriv);
 234 static pptptime_t ng_pptpgre_time(void);
 235 static void     ng_pptpgre_ack(const hpriv_p hpriv);
 236 static int      ng_pptpgre_sendq(const hpriv_p hpriv, roqh *q,
 237                     const struct ng_pptpgre_roq *st);
 238
 239 /* Parse type for struct ng_pptpgre_conf */
 240 static const struct ng_parse_struct_field ng_pptpgre_conf_type_fields[]
 241         = NG_PPTPGRE_CONF_TYPE_INFO;
 242 static const struct ng_parse_type ng_pptpgre_conf_type = {
 243         &ng_parse_struct_type,
 244         &ng_pptpgre_conf_type_fields,
 245 };
 246
 247 /* Parse type for struct ng_pptpgre_stats */
 248 static const struct ng_parse_struct_field ng_pptpgre_stats_type_fields[]
 249         = NG_PPTPGRE_STATS_TYPE_INFO;
 250 static const struct ng_parse_type ng_pptp_stats_type = {
 251         &ng_parse_struct_type,
 252         &ng_pptpgre_stats_type_fields
 253 };
 254
 255 /* List of commands and how to convert arguments to/from ASCII */
 256 static const struct ng_cmdlist ng_pptpgre_cmdlist[] = {
 257         {
 258           NGM_PPTPGRE_COOKIE,
 259           NGM_PPTPGRE_SET_CONFIG,
 260           "setconfig",
 261           &ng_pptpgre_conf_type,
 262           NULL
 263         },
 264         {
 265           NGM_PPTPGRE_COOKIE,
 266           NGM_PPTPGRE_GET_CONFIG,
 267           "getconfig",
 268           &ng_parse_hint16_type,
 269           &ng_pptpgre_conf_type
 270         },
 271         {
 272           NGM_PPTPGRE_COOKIE,
 273           NGM_PPTPGRE_GET_STATS,
 274           "getstats",
 275           NULL,
 276           &ng_pptp_stats_type
 277         },
 278         {
 279           NGM_PPTPGRE_COOKIE,
 280           NGM_PPTPGRE_CLR_STATS,
 281           "clrstats",
 282           NULL,
 283           NULL
 284         },
 285         {
 286           NGM_PPTPGRE_COOKIE,
 287           NGM_PPTPGRE_GETCLR_STATS,
 288           "getclrstats",
 289           NULL,
 290           &ng_pptp_stats_type
 291         },
 292         { 0 }
 293 };
 294
 295 /* Node type descriptor */
 296 static struct ng_type ng_pptpgre_typestruct = {
 297         .version =      NG_ABI_VERSION,
 298         .name =         NG_PPTPGRE_NODE_TYPE,
 299         .constructor =  ng_pptpgre_constructor,
 300         .rcvmsg =       ng_pptpgre_rcvmsg,
 301         .shutdown =     ng_pptpgre_shutdown,
 302         .newhook =      ng_pptpgre_newhook,
 303         .rcvdata =      ng_pptpgre_rcvdata,
 304         .disconnect =   ng_pptpgre_disconnect,
 305         .cmdlist =      ng_pptpgre_cmdlist,
 306 };
 307 NETGRAPH_INIT(pptpgre, &ng_pptpgre_typestruct);
 308
 309 #define ERROUT(x)       do { error = (x); goto done; } while (0)
 310
 311 /************************************************************************
 312                         NETGRAPH NODE STUFF
 313  ************************************************************************/
 314
 315 /*
 316  * Node type constructor
 317  */
 318 static int
 319 ng_pptpgre_constructor(node_p node)
 320 {
 321         priv_p priv;
 322         int i;
 323
 324         /* Allocate private structure */
 325         priv = malloc(sizeof(*priv), M_NETGRAPH, M_WAITOK | M_ZERO);
 326
 327         NG_NODE_SET_PRIVATE(node, priv);
 328
 329         /* Initialize state */
 330         mtx_init(&priv->uppersess.mtx, "ng_pptp", NULL, MTX_DEF);
 331         ng_callout_init(&priv->uppersess.sackTimer);
 332         ng_callout_init(&priv->uppersess.rackTimer);
 333         priv->uppersess.node = node;
 334
 335         SLIST_INIT(&priv->uppersess.roq);
 336         priv->uppersess.roq_len = 0;
 337         ng_callout_init(&priv->uppersess.reorderTimer);
 338
 339         for (i = 0; i < SESSHASHSIZE; i++)
 340             LIST_INIT(&priv->sesshash[i]);
 341
 342         LIST_INSERT_HEAD(&priv->sesshash[0], &priv->uppersess, sessions);
 343
 344         /* Done */
 345         return (0);
 346 }
 347
 348 /*
 349  * Give our OK for a hook to be added.
 350  */
 351 static int
 352 ng_pptpgre_newhook(node_p node, hook_p hook, const char *name)
 353 {
 354         const priv_p priv = NG_NODE_PRIVATE(node);
 355
 356         /* Check hook name */
 357         if (strcmp(name, NG_PPTPGRE_HOOK_UPPER) == 0) {
 358                 priv->upper = hook;
 359                 priv->uppersess.hook = hook;
 360                 NG_HOOK_SET_PRIVATE(hook, &priv->uppersess);
 361         } else if (strcmp(name, NG_PPTPGRE_HOOK_LOWER) == 0) {
 362                 priv->lower = hook;
 363                 NG_HOOK_SET_RCVDATA(hook, ng_pptpgre_rcvdata_lower);
 364         } else {
 365                 static const char hexdig[16] = "0123456789abcdef";
 366                 const char *hex;
 367                 hpriv_p hpriv;
 368                 int i, j;
 369                 uint16_t cid, hash;
 370
 371                 /* Parse hook name to get session ID */
 372                 if (strncmp(name, NG_PPTPGRE_HOOK_SESSION_P,
 373                     sizeof(NG_PPTPGRE_HOOK_SESSION_P) - 1) != 0)
 374                         return (EINVAL);
 375                 hex = name + sizeof(NG_PPTPGRE_HOOK_SESSION_P) - 1;
 376                 for (cid = i = 0; i < 4; i++) {
 377                         for (j = 0; j < 16 && hex[i] != hexdig[j]; j++);
 378                         if (j == 16)
 379                                 return (EINVAL);
 380                         cid = (cid << 4) | j;
 381                 }
 382                 if (hex[i] != '\0')
 383                         return (EINVAL);
 384
 385                 hpriv = malloc(sizeof(*hpriv), M_NETGRAPH, M_NOWAIT | M_ZERO);
 386                 if (hpriv == NULL)
 387                         return (ENOMEM);
 388
 389                 /* Initialize state */
 390                 mtx_init(&hpriv->mtx, "ng_pptp", NULL, MTX_DEF);
 391                 ng_callout_init(&hpriv->sackTimer);
 392                 ng_callout_init(&hpriv->rackTimer);
 393                 hpriv->conf.cid = cid;
 394                 hpriv->node = node;
 395                 hpriv->hook = hook;
 396
 397                 SLIST_INIT(&hpriv->roq);
 398                 hpriv->roq_len = 0;
 399                 ng_callout_init(&hpriv->reorderTimer);
 400
 401                 NG_HOOK_SET_PRIVATE(hook, hpriv);
 402
 403                 hash = SESSHASH(cid);
 404                 LIST_INSERT_HEAD(&priv->sesshash[hash], hpriv, sessions);
 405         }
 406
 407         return (0);
 408 }
 409
 410 /*
 411  * Receive a control message.
 412  */
 413 static int
 414 ng_pptpgre_rcvmsg(node_p node, item_p item, hook_p lasthook)
 415 {
 416         const priv_p priv = NG_NODE_PRIVATE(node);
 417         struct ng_mesg *resp = NULL;
 418         int error = 0;
 419         struct ng_mesg *msg;
 420
 421         NGI_GET_MSG(item, msg);
 422         switch (msg->header.typecookie) {
 423         case NGM_PPTPGRE_COOKIE:
 424                 switch (msg->header.cmd) {
 425                 case NGM_PPTPGRE_SET_CONFIG:
 426                     {
 427                         struct ng_pptpgre_conf *const newConf =
 428                                 (struct ng_pptpgre_conf *) msg->data;
 429                         hpriv_p hpriv;
 430                         uint16_t hash;
 431
 432                         /* Check for invalid or illegal config */
 433                         if (msg->header.arglen != sizeof(*newConf))
 434                                 ERROUT(EINVAL);
 435                         /* Try to find session by cid. */
 436                         hpriv = ng_pptpgre_find_session(priv, newConf->cid);
 437                         /* If not present - use upper. */
 438                         if (hpriv == NULL) {
 439                                 hpriv = &priv->uppersess;
 440                                 LIST_REMOVE(hpriv, sessions);
 441                                 hash = SESSHASH(newConf->cid);
 442                                 LIST_INSERT_HEAD(&priv->sesshash[hash], hpriv,
 443                                     sessions);
 444                         }
 445                         ng_pptpgre_reset(hpriv);        /* reset on configure */
 446                         hpriv->conf = *newConf;
 447                         break;
 448                     }
 449                 case NGM_PPTPGRE_GET_CONFIG:
 450                     {
 451                         hpriv_p hpriv;
 452
 453                         if (msg->header.arglen == 2) {
 454                                 /* Try to find session by cid. */
 455                                 hpriv = ng_pptpgre_find_session(priv,
 456                                     *((uint16_t *)msg->data));
 457                                 if (hpriv == NULL)
 458                                         ERROUT(EINVAL);
 459                         } else if (msg->header.arglen == 0) {
 460                                 /* Use upper. */
 461                                 hpriv = &priv->uppersess;
 462                         } else
 463                                 ERROUT(EINVAL);
 464                         NG_MKRESPONSE(resp, msg, sizeof(hpriv->conf), M_NOWAIT);
 465                         if (resp == NULL)
 466                                 ERROUT(ENOMEM);
 467                         bcopy(&hpriv->conf, resp->data, sizeof(hpriv->conf));
 468                         break;
 469                     }
 470                 case NGM_PPTPGRE_GET_STATS:
 471                 case NGM_PPTPGRE_CLR_STATS:
 472                 case NGM_PPTPGRE_GETCLR_STATS:
 473                     {
 474                         if (msg->header.cmd != NGM_PPTPGRE_CLR_STATS) {
 475                                 NG_MKRESPONSE(resp, msg,
 476                                     sizeof(priv->stats), M_NOWAIT);
 477                                 if (resp == NULL)
 478                                         ERROUT(ENOMEM);
 479                                 bcopy(&priv->stats,
 480                                     resp->data, sizeof(priv->stats));
 481                         }
 482                         if (msg->header.cmd != NGM_PPTPGRE_GET_STATS)
 483                                 bzero(&priv->stats, sizeof(priv->stats));
 484                         break;
 485                     }
 486                 default:
 487                         error = EINVAL;
 488                         break;
 489                 }
 490                 break;
 491         default:
 492                 error = EINVAL;
 493                 break;
 494         }
 495 done:
 496         NG_RESPOND_MSG(error, node, item, resp);
 497         NG_FREE_MSG(msg);
 498         return (error);
 499 }
 500
 501 /*
 502  * Receive incoming data on a hook.
 503  */
 504 static int
 505 ng_pptpgre_rcvdata(hook_p hook, item_p item)
 506 {
 507         const hpriv_p hpriv = NG_HOOK_PRIVATE(hook);
 508         int rval;
 509
 510         /* If not configured, reject */
 511         if (!hpriv->conf.enabled) {
 512                 NG_FREE_ITEM(item);
 513                 return (ENXIO);
 514         }
 515
 516         mtx_lock(&hpriv->mtx);
 517
 518         rval = ng_pptpgre_xmit(hpriv, item);
 519
 520         mtx_assert(&hpriv->mtx, MA_NOTOWNED);
 521
 522         return (rval);
 523 }
 524
 525 /*
 526  * Hook disconnection
 527  */
 528 static int
 529 ng_pptpgre_disconnect(hook_p hook)
 530 {
 531         const node_p node = NG_HOOK_NODE(hook);
 532         const priv_p priv = NG_NODE_PRIVATE(node);
 533         const hpriv_p hpriv = NG_HOOK_PRIVATE(hook);
 534
 535         /* Zero out hook pointer */
 536         if (hook == priv->upper) {
 537                 priv->upper = NULL;
 538                 priv->uppersess.hook = NULL;
 539         } else if (hook == priv->lower) {
 540                 priv->lower = NULL;
 541         } else {
 542                 /* Reset node (stops timers) */
 543                 ng_pptpgre_reset(hpriv);
 544
 545                 LIST_REMOVE(hpriv, sessions);
 546                 mtx_destroy(&hpriv->mtx);
 547                 free(hpriv, M_NETGRAPH);
 548         }
 549
 550         /* Go away if no longer connected to anything */
 551         if ((NG_NODE_NUMHOOKS(node) == 0)
 552         && (NG_NODE_IS_VALID(node)))
 553                 ng_rmnode_self(node);
 554         return (0);
 555 }
 556
 557 /*
 558  * Destroy node
 559  */
 560 static int
 561 ng_pptpgre_shutdown(node_p node)
 562 {
 563         const priv_p priv = NG_NODE_PRIVATE(node);
 564
 565         /* Reset node (stops timers) */
 566         ng_pptpgre_reset(&priv->uppersess);
 567
 568         LIST_REMOVE(&priv->uppersess, sessions);
 569         mtx_destroy(&priv->uppersess.mtx);
 570
 571         free(priv, M_NETGRAPH);
 572
 573         /* Decrement ref count */
 574         NG_NODE_UNREF(node);
 575         return (0);
 576 }
 577
 578 /*************************************************************************
 579                     TRANSMIT AND RECEIVE FUNCTIONS
 580 *************************************************************************/
 581
 582 /*
 583  * Transmit an outgoing frame, or just an ack if m is NULL.
 584  */
 585 static int
 586 ng_pptpgre_xmit(hpriv_p hpriv, item_p item)
 587 {
 588         const priv_p priv = NG_NODE_PRIVATE(hpriv->node);
 589         u_char buf[sizeof(struct greheader) + 2 * sizeof(u_int32_t)];
 590         struct greheader *const gre = (struct greheader *)buf;
 591         int grelen, error;
 592         struct mbuf *m;
 593
 594         mtx_assert(&hpriv->mtx, MA_OWNED);
 595
 596         if (item) {
 597                 NGI_GET_M(item, m);
 598         } else {
 599                 m = NULL;
 600         }
 601         /* Check if there's data */
 602         if (m != NULL) {
 603                 /* Check if windowing is enabled */
 604                 if (hpriv->conf.enableWindowing) {
 605                         /* Is our transmit window full? */
 606                         if ((u_int32_t)PPTP_SEQ_DIFF(hpriv->xmitSeq,
 607                             hpriv->recvAck) >= hpriv->xmitWin) {
 608                                 priv->stats.xmitDrops++;
 609                                 ERROUT(ENOBUFS);
 610                         }
 611                 }
 612
 613                 /* Sanity check frame length */
 614                 if (m->m_pkthdr.len > PPTP_MAX_PAYLOAD) {
 615                         priv->stats.xmitTooBig++;
 616                         ERROUT(EMSGSIZE);
 617                 }
 618         } else {
 619                 priv->stats.xmitLoneAcks++;
 620         }
 621
 622         /* Build GRE header */
 623         be32enc(gre, PPTP_INIT_VALUE);
 624         be16enc(&gre->length, (m != NULL) ? m->m_pkthdr.len : 0);
 625         be16enc(&gre->cid, hpriv->conf.peerCid);
 626
 627         /* Include sequence number if packet contains any data */
 628         if (m != NULL) {
 629                 gre->hasSeq = 1;
 630                 if (hpriv->conf.enableWindowing) {
 631                         hpriv->timeSent[hpriv->xmitSeq - hpriv->recvAck]
 632                             = ng_pptpgre_time();
 633                 }
 634                 hpriv->xmitSeq++;
 635                 be32enc(&gre->data[0], hpriv->xmitSeq);
 636         }
 637
 638         /* Include acknowledgement (and stop send ack timer) if needed */
 639         if (hpriv->conf.enableAlwaysAck || hpriv->xmitAck != hpriv->recvSeq) {
 640                 gre->hasAck = 1;
 641                 be32enc(&gre->data[gre->hasSeq], hpriv->recvSeq);
 642                 hpriv->xmitAck = hpriv->recvSeq;
 643                 if (hpriv->conf.enableDelayedAck)
 644                         ng_uncallout(&hpriv->sackTimer, hpriv->node);
 645         }
 646
 647         /* Prepend GRE header to outgoing frame */
 648         grelen = sizeof(*gre) + sizeof(u_int32_t) * (gre->hasSeq + gre->hasAck);
 649         if (m == NULL) {
 650                 MGETHDR(m, M_NOWAIT, MT_DATA);
 651                 if (m == NULL) {
 652                         priv->stats.memoryFailures++;
 653                         ERROUT(ENOBUFS);
 654                 }
 655                 m->m_len = m->m_pkthdr.len = grelen;
 656                 m->m_pkthdr.rcvif = NULL;
 657         } else {
 658                 M_PREPEND(m, grelen, M_NOWAIT);
 659                 if (m == NULL || (m->m_len < grelen
 660                     && (m = m_pullup(m, grelen)) == NULL)) {
 661                         priv->stats.memoryFailures++;
 662                         ERROUT(ENOBUFS);
 663                 }
 664         }
 665         bcopy(gre, mtod(m, u_char *), grelen);
 666
 667         /* Update stats */
 668         priv->stats.xmitPackets++;
 669         priv->stats.xmitOctets += m->m_pkthdr.len;
 670
 671         /*
 672          * XXX: we should reset timer only after an item has been sent
 673          * successfully.
 674          */
 675         if (hpriv->conf.enableWindowing &&
 676             gre->hasSeq && hpriv->xmitSeq == hpriv->recvAck + 1)
 677                 ng_pptpgre_start_recv_ack_timer(hpriv);
 678
 679         mtx_unlock(&hpriv->mtx);
 680
 681         /* Deliver packet */
 682         if (item) {
 683                 NG_FWD_NEW_DATA(error, item, priv->lower, m);
 684         } else {
 685                 NG_SEND_DATA_ONLY(error, priv->lower, m);
 686         }
 687
 688         return (error);
 689
 690 done:
 691         mtx_unlock(&hpriv->mtx);
 692         NG_FREE_M(m);
 693         if (item)
 694                 NG_FREE_ITEM(item);
 695         return (error);
 696 }
 697
 698 static void
 699 ng_pptpgre_ack(const hpriv_p hpriv)
 700 {
 701         mtx_assert(&hpriv->mtx, MA_OWNED);
 702         if (!(callout_pending(&hpriv->sackTimer))) {
 703                 /* If delayed ACK is disabled, send it now */
 704                 if (!hpriv->conf.enableDelayedAck) {    /* ack now */
 705                         ng_pptpgre_xmit(hpriv, NULL);
 706                         /* ng_pptpgre_xmit() drops the mutex */
 707                         return;
 708                 }
 709                 /* ack later */
 710                 ng_pptpgre_start_send_ack_timer(hpriv);
 711                 mtx_unlock(&hpriv->mtx);
 712                 return;
 713         }
 714         mtx_unlock(&hpriv->mtx);
 715 }
 716
 717 /*
 718  * Delivers packets from the queue "q" to upper layers. Frees delivered
 719  * entries with the exception of one equal to "st" that is allocated
 720  * on caller's stack and not on the heap.
 721  */
 722 static int
 723 ng_pptpgre_sendq(const hpriv_p hpriv, roqh *q, const struct ng_pptpgre_roq *st)
 724 {
 725         struct ng_pptpgre_roq *np;
 726         struct mbuf *m;
 727         int error = 0;
 728
 729         mtx_assert(&hpriv->mtx, MA_NOTOWNED);
 730         while (!SLIST_EMPTY(q)) {
 731                 np = SLIST_FIRST(q);
 732                 SLIST_REMOVE_HEAD(q, next);
 733                 NGI_GET_M(np->item, m);
 734                 NG_FWD_NEW_DATA(error, np->item, hpriv->hook, m);
 735                 if (np != st)
 736                         free(np, M_NETGRAPH);
 737         }
 738         return (error);
 739 }
 740
 741 /*
 742  * Handle an incoming packet.  The packet includes the IP header.
 743  */
 744 static int
 745 ng_pptpgre_rcvdata_lower(hook_p hook, item_p item)
 746 {
 747         hpriv_p hpriv;
 748         node_p node = NG_HOOK_NODE(hook);
 749         const priv_p priv = NG_NODE_PRIVATE(node);
 750         int iphlen, grelen, extralen;
 751         const struct greheader *gre;
 752         const struct ip *ip;
 753         int error = 0;
 754         struct mbuf *m;
 755
 756         roqh sendq = SLIST_HEAD_INITIALIZER(sendq);  /* send queue on stack */
 757         struct ng_pptpgre_roq *last = NULL;     /* last packet in the sendq */
 758         struct ng_pptpgre_roq *np, *prev;
 759         struct ng_pptpgre_roq temp = { { NULL }, NULL, 0 };
 760         long diff;
 761         u_int32_t seq;
 762
 763         m = NGI_M(item);
 764         /* Update stats */
 765         priv->stats.recvPackets++;
 766         priv->stats.recvOctets += m->m_pkthdr.len;
 767
 768         /* Sanity check packet length */
 769         if (m->m_pkthdr.len < sizeof(*ip) + sizeof(*gre)) {
 770                 priv->stats.recvRunts++;
 771                 ERROUT(EINVAL);
 772         }
 773
 774         /* Safely pull up the complete IP+GRE headers */
 775         if (m->m_len < sizeof(*ip) + sizeof(*gre)) {
 776                 if ((m = m_pullup(m, sizeof(*ip) + sizeof(*gre))) == NULL) {
 777                         priv->stats.memoryFailures++;
 778                         _NGI_M(item) = NULL;
 779                         ERROUT(ENOBUFS);
 780                 }
 781                 _NGI_M(item) = m;
 782         }
 783         ip = mtod(m, const struct ip *);
 784         iphlen = ip->ip_hl << 2;
 785         if (m->m_len < iphlen + sizeof(*gre)) {
 786                 if ((m = m_pullup(m, iphlen + sizeof(*gre))) == NULL) {
 787                         priv->stats.memoryFailures++;
 788                         _NGI_M(item) = NULL;
 789                         ERROUT(ENOBUFS);
 790                 }
 791                 _NGI_M(item) = m;
 792                 ip = mtod(m, const struct ip *);
 793         }
 794         gre = (const struct greheader *)((const u_char *)ip + iphlen);
 795         grelen = sizeof(*gre) + sizeof(u_int32_t) * (gre->hasSeq + gre->hasAck);
 796         if (m->m_pkthdr.len < iphlen + grelen) {
 797                 priv->stats.recvRunts++;
 798                 ERROUT(EINVAL);
 799         }
 800         if (m->m_len < iphlen + grelen) {
 801                 if ((m = m_pullup(m, iphlen + grelen)) == NULL) {
 802                         priv->stats.memoryFailures++;
 803                         _NGI_M(item) = NULL;
 804                         ERROUT(ENOBUFS);
 805                 }
 806                 _NGI_M(item) = m;
 807                 ip = mtod(m, const struct ip *);
 808                 gre = (const struct greheader *)((const u_char *)ip + iphlen);
 809         }
 810
 811         /* Sanity check packet length and GRE header bits */
 812         extralen = m->m_pkthdr.len
 813             - (iphlen + grelen + gre->hasSeq * be16dec(&gre->length));
 814         if (extralen < 0) {
 815                 priv->stats.recvBadGRE++;
 816                 ERROUT(EINVAL);
 817         }
 818         if ((be32dec(gre) & PPTP_INIT_MASK) != PPTP_INIT_VALUE) {
 819                 priv->stats.recvBadGRE++;
 820                 ERROUT(EINVAL);
 821         }
 822
 823         hpriv = ng_pptpgre_find_session(priv, be16dec(&gre->cid));
 824         if (hpriv == NULL || hpriv->hook == NULL || !hpriv->conf.enabled) {
 825                 priv->stats.recvBadCID++;
 826                 ERROUT(EINVAL);
 827         }
 828         mtx_lock(&hpriv->mtx);
 829
 830         /* Look for peer ack */
 831         if (gre->hasAck) {
 832                 const u_int32_t ack = be32dec(&gre->data[gre->hasSeq]);
 833                 const int index = ack - hpriv->recvAck - 1;
 834                 long sample;
 835
 836                 /* Sanity check ack value */
 837                 if (PPTP_SEQ_DIFF(ack, hpriv->xmitSeq) > 0) {
 838                         priv->stats.recvBadAcks++;
 839                         goto badAck;            /* we never sent it! */
 840                 }
 841                 if (PPTP_SEQ_DIFF(ack, hpriv->recvAck) <= 0)
 842                         goto badAck;            /* ack already timed out */
 843                 hpriv->recvAck = ack;
 844
 845                 /* Update adaptive timeout stuff */
 846                 if (hpriv->conf.enableWindowing) {
 847                         sample = ng_pptpgre_time() - hpriv->timeSent[index];
 848                         diff = sample - hpriv->rtt;
 849                         hpriv->rtt += PPTP_ACK_ALPHA(diff);
 850                         if (diff < 0)
 851                                 diff = -diff;
 852                         hpriv->dev += PPTP_ACK_BETA(diff - hpriv->dev);
 853                             /* +2 to compensate low precision of int math */
 854                         hpriv->ato = hpriv->rtt + PPTP_ACK_CHI(hpriv->dev + 2);
 855                         if (hpriv->ato > PPTP_MAX_TIMEOUT)
 856                                 hpriv->ato = PPTP_MAX_TIMEOUT;
 857                         else if (hpriv->ato < PPTP_MIN_TIMEOUT)
 858                                 hpriv->ato = PPTP_MIN_TIMEOUT;
 859
 860                         /* Shift packet transmit times in our transmit window */
 861                         bcopy(hpriv->timeSent + index + 1, hpriv->timeSent,
 862                             sizeof(*hpriv->timeSent)
 863                               * (PPTP_XMIT_WIN - (index + 1)));
 864
 865                         /* If we sent an entire window, increase window size */
 866                         if (PPTP_SEQ_DIFF(ack, hpriv->winAck) >= 0
 867                             && hpriv->xmitWin < PPTP_XMIT_WIN) {
 868                                 hpriv->xmitWin++;
 869                                 hpriv->winAck = ack + hpriv->xmitWin;
 870                         }
 871
 872                         /* Stop/(re)start receive ACK timer as necessary */
 873                         ng_uncallout(&hpriv->rackTimer, hpriv->node);
 874                         if (hpriv->recvAck != hpriv->xmitSeq)
 875                                 ng_pptpgre_start_recv_ack_timer(hpriv);
 876                 }
 877         }
 878 badAck:
 879
 880         /* See if frame contains any data */
 881         if (!gre->hasSeq) {             /* no data to deliver */
 882                 priv->stats.recvLoneAcks++;
 883                 mtx_unlock(&hpriv->mtx);
 884                 ERROUT(0);
 885         }
 886
 887         seq = be32dec(&gre->data[0]);
 888
 889         diff = PPTP_SEQ_DIFF(seq, hpriv->recvSeq);
 890         if (diff <= 0) {                        /* late or duplicate packet */
 891                 if (diff < 0 && reorder_max == 0)       /* reorder disabled */
 892                         priv->stats.recvOutOfOrder++;   /* late */
 893                 else
 894                         priv->stats.recvDuplicates++;   /* duplicate */
 895                 mtx_unlock(&hpriv->mtx);
 896                 ERROUT(EINVAL);
 897         }
 898
 899         /* Trim mbuf down to internal payload */
 900         m_adj(m, iphlen + grelen);
 901         if (extralen > 0)
 902                 m_adj(m, -extralen);
 903
 904 #define INIT_SENDQ(t) do {                              \
 905                 t.item = item;                          \
 906                 t.seq = seq;                            \
 907                 SLIST_INSERT_HEAD(&sendq, &t, next);    \
 908                 last = &t;                              \
 909                 hpriv->recvSeq = seq;                   \
 910                 goto deliver;                           \
 911         } while(0)
 912
 913         if (diff == 1)
 914                 /* the packet came in order, place it at the start of sendq */
 915                 INIT_SENDQ(temp);
 916
 917         /* The packet came too early, try to enqueue it.
 918          *
 919          * Check for duplicate in the queue. After this loop, "prev" will be
 920          * NULL if the packet should become new head of the queue,
 921          * or else it should be inserted after the "prev".
 922          */
 923         prev = SLIST_FIRST(&hpriv->roq);
 924         SLIST_FOREACH(np, &hpriv->roq, next) {
 925                 diff = PPTP_SEQ_DIFF(np->seq, seq);
 926                 if (diff == 0) { /* do not add duplicate, drop it */
 927                         priv->stats.recvDuplicates++;
 928                         mtx_unlock(&hpriv->mtx);
 929                         ERROUT(EINVAL);
 930                 }
 931                 if (diff > 0) {         /* we found newer packet */
 932                         if (np == prev) /* that is the head of the queue */
 933                             prev = NULL; /* put current packet to the head */
 934                         break;
 935                 }
 936                 prev = np;
 937         }
 938
 939         priv->stats.recvOutOfOrder++;   /* duplicate not found */
 940         if (hpriv->roq_len < reorder_max)
 941                 goto enqueue;   /* reorder enabled and there is a room */
 942
 943         /*
 944          * There is no room in the queue or reorder disabled.
 945          *
 946          * It the latter case, we may still have non-empty reorder queue
 947          * if reorder was disabled in process of reordering.
 948          * Then we correctly deliver the queue without growing it.
 949          *
 950          * In both cases, no malloc()'s until the queue is shortened.
 951          */
 952         priv->stats.recvReorderOverflow++;
 953         if (prev == NULL) {       /* new packet goes before the head      */
 954                 INIT_SENDQ(temp); /* of reorder queue, so put it to sendq */
 955         }
 956 #undef INIT_SENDQ
 957
 958         /*
 959          * Current packet goes after the head of reorder queue.
 960          * Move the head to sendq to make room for current packet.
 961          */
 962         np = SLIST_FIRST(&hpriv->roq);
 963         if (prev == np)
 964                 prev = NULL;
 965         SLIST_REMOVE_HEAD(&hpriv->roq, next);
 966         hpriv->roq_len--;       /* we are allowed to use malloc() now */
 967         SLIST_INSERT_HEAD(&sendq, np, next);
 968         last = np;
 969         hpriv->recvSeq = np->seq;
 970
 971 enqueue:
 972         np = malloc(sizeof(*np), M_NETGRAPH, M_NOWAIT | M_ZERO);
 973         if (np == NULL) {
 974                 priv->stats.memoryFailures++;
 975                 /*
 976                  * Emergency: we cannot save new data.
 977                  * Flush the queue delivering all queued packets preceeding
 978                  * current one despite of gaps.
 979                  */
 980                 while (!SLIST_EMPTY(&hpriv->roq)) {
 981                         np = SLIST_FIRST(&hpriv->roq);
 982                         if (np->seq > seq)
 983                                 break;
 984                         SLIST_REMOVE_HEAD(&hpriv->roq, next);
 985                         hpriv->roq_len--;
 986                         if (last == NULL)
 987                                 SLIST_INSERT_HEAD(&sendq, np, next);
 988                         else
 989                                 SLIST_INSERT_AFTER(last, np, next);
 990                         last = np;
 991                 }
 992
 993                 /*
 994                  * Pretend we got all packets till the current one
 995                  * and acknowledge it.
 996                  */
 997                 hpriv->recvSeq = seq;
 998                 ng_pptpgre_ack(hpriv);  /* drops lock */
 999                 ng_pptpgre_sendq(hpriv, &sendq, &temp);
1000                 NG_FWD_NEW_DATA(error, item, hpriv->hook, m);
1001                 ERROUT(ENOMEM);
1002         }
1003
1004         /* Add current (early) packet to the reorder queue. */
1005         np->item = item;
1006         np->seq = seq;
1007         if (prev == NULL)
1008                 SLIST_INSERT_HEAD(&hpriv->roq, np, next);
1009         else
1010                 SLIST_INSERT_AFTER(prev, np, next);
1011         hpriv->roq_len++;
1012
1013 deliver:
1014         /* Look if we have some packets in sequence after sendq. */
1015         while (!SLIST_EMPTY(&hpriv->roq)) {
1016                 np = SLIST_FIRST(&hpriv->roq);
1017                 if (PPTP_SEQ_DIFF(np->seq, hpriv->recvSeq) > 1)
1018                         break; /* the gap in the sequence */
1019
1020                 /* "np" is in sequence, move it to the sendq. */
1021                 SLIST_REMOVE_HEAD(&hpriv->roq, next);
1022                 hpriv->roq_len--;
1023                 hpriv->recvSeq = np->seq;
1024
1025                 if (last == NULL)
1026                         SLIST_INSERT_HEAD(&sendq, np, next);
1027                 else
1028                         SLIST_INSERT_AFTER(last, np, next);
1029                 last = np;
1030         }
1031
1032         if (SLIST_EMPTY(&hpriv->roq)) {
1033                 if (callout_pending(&hpriv->reorderTimer))
1034                         ng_uncallout(&hpriv->reorderTimer, hpriv->node);
1035         } else {
1036                 if (!callout_pending(&hpriv->reorderTimer))
1037                         ng_pptpgre_start_reorder_timer(hpriv);
1038         }
1039
1040         if (SLIST_EMPTY(&sendq)) {
1041                 /* Current packet has been queued, nothing to free/deliver. */
1042                 mtx_unlock(&hpriv->mtx);
1043                 return (error);
1044         }
1045
1046         /* We need to acknowledge last packet; do it soon... */
1047         ng_pptpgre_ack(hpriv);          /* drops lock */
1048         ng_pptpgre_sendq(hpriv, &sendq, &temp);
1049         return (error);
1050
1051 done:
1052         NG_FREE_ITEM(item);
1053         return (error);
1054 }
1055
1056 /*************************************************************************
1057                     TIMER RELATED FUNCTIONS
1058 *************************************************************************/
1059
1060 /*
1061  * Start a timer for the peer's acknowledging our oldest unacknowledged
1062  * sequence number.  If we get an ack for this sequence number before
1063  * the timer goes off, we cancel the timer.  Resets currently running
1064  * recv ack timer, if any.
1065  */
1066 static void
1067 ng_pptpgre_start_recv_ack_timer(hpriv_p hpriv)
1068 {
1069         int remain, ticks;
1070
1071         /* Compute how long until oldest unack'd packet times out,
1072            and reset the timer to that time. */
1073         remain = (hpriv->timeSent[0] + hpriv->ato) - ng_pptpgre_time();
1074         if (remain < 0)
1075                 remain = 0;
1076
1077         /* Be conservative: timeout can happen up to 1 tick early */
1078         ticks = howmany(remain * hz, PPTP_TIME_SCALE) + 1;
1079         ng_callout(&hpriv->rackTimer, hpriv->node, hpriv->hook,
1080             ticks, ng_pptpgre_recv_ack_timeout, hpriv, 0);
1081 }
1082
1083 /*
1084  * The peer has failed to acknowledge the oldest unacknowledged sequence
1085  * number within the time allotted.  Update our adaptive timeout parameters
1086  * and reset/restart the recv ack timer.
1087  */
1088 static void
1089 ng_pptpgre_recv_ack_timeout(node_p node, hook_p hook, void *arg1, int arg2)
1090 {
1091         const priv_p priv = NG_NODE_PRIVATE(node);
1092         const hpriv_p hpriv = arg1;
1093
1094         /* Update adaptive timeout stuff */
1095         priv->stats.recvAckTimeouts++;
1096         hpriv->rtt = PPTP_ACK_DELTA(hpriv->rtt) + 1; /* +1 to avoid delta*0 case */
1097         hpriv->ato = hpriv->rtt + PPTP_ACK_CHI(hpriv->dev);
1098         if (hpriv->ato > PPTP_MAX_TIMEOUT)
1099                 hpriv->ato = PPTP_MAX_TIMEOUT;
1100         else if (hpriv->ato < PPTP_MIN_TIMEOUT)
1101                 hpriv->ato = PPTP_MIN_TIMEOUT;
1102
1103         /* Reset ack and sliding window */
1104         hpriv->recvAck = hpriv->xmitSeq;                /* pretend we got the ack */
1105         hpriv->xmitWin = (hpriv->xmitWin + 1) / 2;      /* shrink transmit window */
1106         hpriv->winAck = hpriv->recvAck + hpriv->xmitWin;        /* reset win expand time */
1107 }
1108
1109 /*
1110  * Start the send ack timer. This assumes the timer is not
1111  * already running.
1112  */
1113 static void
1114 ng_pptpgre_start_send_ack_timer(hpriv_p hpriv)
1115 {
1116         int ackTimeout, ticks;
1117
1118         /* Take 1/4 of the estimated round trip time */
1119         ackTimeout = (hpriv->rtt >> 2);
1120         if (ackTimeout < PPTP_MIN_ACK_DELAY)
1121                 ackTimeout = PPTP_MIN_ACK_DELAY;
1122         else if (ackTimeout > PPTP_MAX_ACK_DELAY)
1123                 ackTimeout = PPTP_MAX_ACK_DELAY;
1124
1125         /* Be conservative: timeout can happen up to 1 tick early */
1126         ticks = howmany(ackTimeout * hz, PPTP_TIME_SCALE);
1127         ng_callout(&hpriv->sackTimer, hpriv->node, hpriv->hook,
1128             ticks, ng_pptpgre_send_ack_timeout, hpriv, 0);
1129 }
1130
1131 /*
1132  * We've waited as long as we're willing to wait before sending an
1133  * acknowledgement to the peer for received frames. We had hoped to
1134  * be able to piggy back our acknowledgement on an outgoing data frame,
1135  * but apparently there haven't been any since. So send the ack now.
1136  */
1137 static void
1138 ng_pptpgre_send_ack_timeout(node_p node, hook_p hook, void *arg1, int arg2)
1139 {
1140         const hpriv_p hpriv = arg1;
1141
1142         mtx_lock(&hpriv->mtx);
1143         /* Send a frame with an ack but no payload */
1144         ng_pptpgre_xmit(hpriv, NULL);
1145         mtx_assert(&hpriv->mtx, MA_NOTOWNED);
1146 }
1147
1148 /*
1149  * Start a timer for the reorder queue. This assumes the timer is not
1150  * already running.
1151  */
1152 static void
1153 ng_pptpgre_start_reorder_timer(hpriv_p hpriv)
1154 {
1155         int ticks;
1156
1157         /* Be conservative: timeout can happen up to 1 tick early */
1158         ticks = (((reorder_timeout * hz) + 1000 - 1) / 1000) + 1;
1159         ng_callout(&hpriv->reorderTimer, hpriv->node, hpriv->hook,
1160                 ticks, ng_pptpgre_reorder_timeout, hpriv, 0);
1161 }
1162
1163 /*
1164  * The oldest packet spent too much time in the reorder queue.
1165  * Deliver it and next packets in sequence, if any.
1166  */
1167 static void
1168 ng_pptpgre_reorder_timeout(node_p node, hook_p hook, void *arg1, int arg2)
1169 {
1170         const priv_p priv = NG_NODE_PRIVATE(node);
1171         const hpriv_p hpriv = arg1;
1172         roqh sendq = SLIST_HEAD_INITIALIZER(sendq);
1173         struct ng_pptpgre_roq *np, *last = NULL;
1174
1175         priv->stats.recvReorderTimeouts++;
1176         mtx_lock(&hpriv->mtx);
1177         if (SLIST_EMPTY(&hpriv->roq)) { /* should not happen */
1178                 mtx_unlock(&hpriv->mtx);
1179                 return;
1180         }
1181
1182         last = np = SLIST_FIRST(&hpriv->roq);
1183         hpriv->roq_len--;
1184         SLIST_REMOVE_HEAD(&hpriv->roq, next);
1185         SLIST_INSERT_HEAD(&sendq, np, next);
1186
1187         /* Look if we have more packets in sequence */
1188         while (!SLIST_EMPTY(&hpriv->roq)) {
1189                 np = SLIST_FIRST(&hpriv->roq);
1190                 if (PPTP_SEQ_DIFF(np->seq, last->seq) > 1)
1191                         break; /* the gap in the sequence */
1192
1193                 /* Next packet is in sequence, move it to the sendq. */
1194                 hpriv->roq_len--;
1195                 SLIST_REMOVE_HEAD(&hpriv->roq, next);
1196                 SLIST_INSERT_AFTER(last, np, next);
1197                 last = np;
1198         }
1199
1200         hpriv->recvSeq = last->seq;
1201         if (!SLIST_EMPTY(&hpriv->roq))
1202                 ng_pptpgre_start_reorder_timer(hpriv);
1203
1204         /* We need to acknowledge last packet; do it soon... */
1205         ng_pptpgre_ack(hpriv);          /* drops lock */
1206         ng_pptpgre_sendq(hpriv, &sendq, NULL);
1207         mtx_assert(&hpriv->mtx, MA_NOTOWNED);
1208 }
1209
1210 /*************************************************************************
1211                     MISC FUNCTIONS
1212 *************************************************************************/
1213
1214 /*
1215  * Find the hook with a given session ID.
1216  */
1217 static hpriv_p
1218 ng_pptpgre_find_session(priv_p privp, u_int16_t cid)
1219 {
1220         uint16_t        hash = SESSHASH(cid);
1221         hpriv_p hpriv = NULL;
1222
1223         LIST_FOREACH(hpriv, &privp->sesshash[hash], sessions) {
1224                 if (hpriv->conf.cid == cid)
1225                         break;
1226         }
1227
1228         return (hpriv);
1229 }
1230
1231 /*
1232  * Reset state (must be called with lock held or from writer)
1233  */
1234 static void
1235 ng_pptpgre_reset(hpriv_p hpriv)
1236 {
1237         struct ng_pptpgre_roq *np;
1238
1239         /* Reset adaptive timeout state */
1240         hpriv->ato = PPTP_MAX_TIMEOUT;
1241         hpriv->rtt = PPTP_TIME_SCALE / 10;
1242         if (hpriv->conf.peerPpd > 1)    /* ppd = 0 treat as = 1 */
1243                 hpriv->rtt *= hpriv->conf.peerPpd;
1244         hpriv->dev = 0;
1245         hpriv->xmitWin = (hpriv->conf.recvWin + 1) / 2;
1246         if (hpriv->xmitWin < 2)         /* often the first packet is lost */
1247                 hpriv->xmitWin = 2;             /*   because the peer isn't ready */
1248         else if (hpriv->xmitWin > PPTP_XMIT_WIN)
1249                 hpriv->xmitWin = PPTP_XMIT_WIN;
1250         hpriv->winAck = hpriv->xmitWin;
1251
1252         /* Reset sequence numbers */
1253         hpriv->recvSeq = ~0;
1254         hpriv->recvAck = ~0;
1255         hpriv->xmitSeq = ~0;
1256         hpriv->xmitAck = ~0;
1257
1258         /* Stop timers */
1259         ng_uncallout(&hpriv->sackTimer, hpriv->node);
1260         ng_uncallout(&hpriv->rackTimer, hpriv->node);
1261         ng_uncallout(&hpriv->reorderTimer, hpriv->node);
1262
1263         /* Clear reorder queue */
1264         while (!SLIST_EMPTY(&hpriv->roq)) {
1265                 np = SLIST_FIRST(&hpriv->roq);
1266                 SLIST_REMOVE_HEAD(&hpriv->roq, next);
1267                 NG_FREE_ITEM(np->item);
1268                 free(np, M_NETGRAPH);
1269         }
1270         hpriv->roq_len = 0;
1271 }
1272
1273 /*
1274  * Return the current time scaled & translated to our internally used format.
1275  */
1276 static pptptime_t
1277 ng_pptpgre_time(void)
1278 {
1279         struct timeval tv;
1280         pptptime_t t;
1281
1282         microuptime(&tv);
1283         t = (pptptime_t)tv.tv_sec * PPTP_TIME_SCALE;
1284         t += tv.tv_usec / (1000000 / PPTP_TIME_SCALE);
1285         return(t);
1286 }