openvpn/mbuf.c

   1 /*
   2  *  OpenVPN -- An application to securely tunnel IP networks
   3  *             over a single TCP/UDP port, with support for SSL/TLS-based
   4  *             session authentication and key exchange,
   5  *             packet encryption, packet authentication, and
   6  *             packet compression.
   7  *
   8  *  Copyright (C) 2002-2005 OpenVPN Solutions LLC <info@openvpn.net>
   9  *
  10  *  This program is free software; you can redistribute it and/or modify
  11  *  it under the terms of the GNU General Public License version 2
  12  *  as published by the Free Software Foundation.
  13  *
  14  *  This program is distributed in the hope that it will be useful,
  15  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17  *  GNU General Public License for more details.
  18  *
  19  *  You should have received a copy of the GNU General Public License
  20  *  along with this program (see the file COPYING included with this
  21  *  distribution); if not, write to the Free Software Foundation, Inc.,
  22  *  59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  23  */
  24
  25 #ifdef WIN32
  26 #include "config-win32.h"
  27 #else
  28 #include "config.h"
  29 #endif
  30
  31 #include "syshead.h"
  32
  33 #if P2MP
  34
  35 #include "buffer.h"
  36 #include "error.h"
  37 #include "misc.h"
  38 #include "mbuf.h"
  39
  40 #include "memdbg.h"
  41
  42 struct mbuf_set *
  43 mbuf_init (unsigned int size)
  44 {
  45   struct mbuf_set *ret;
  46   ALLOC_OBJ_CLEAR (ret, struct mbuf_set);
  47   mutex_init (&ret->mutex);
  48   ret->capacity = adjust_power_of_2 (size);
  49   ALLOC_ARRAY (ret->array, struct mbuf_item, ret->capacity);
  50   return ret;
  51 }
  52
  53 void
  54 mbuf_free (struct mbuf_set *ms)
  55 {
  56   if (ms)
  57     {
  58       int i;
  59       for (i = 0; i < (int) ms->len; ++i)
  60         {
  61           struct mbuf_item *item = &ms->array[MBUF_INDEX(ms->head, i, ms->capacity)];
  62           mbuf_free_buf (item->buffer);
  63         }
  64       free (ms->array);
  65       mutex_destroy (&ms->mutex);
  66       free (ms);
  67     }
  68 }
  69
  70 struct mbuf_buffer *
  71 mbuf_alloc_buf (const struct buffer *buf)
  72 {
  73   struct mbuf_buffer *ret;
  74   ALLOC_OBJ (ret, struct mbuf_buffer);
  75   ret->buf = clone_buf (buf);
  76   ret->refcount = 1;
  77   ret->flags = 0;
  78   return ret;
  79 }
  80
  81 void
  82 mbuf_free_buf (struct mbuf_buffer *mb)
  83 {
  84   if (mb)
  85     {
  86       if (--mb->refcount <= 0)
  87         {
  88           free_buf (&mb->buf);
  89           free (mb);
  90         }
  91     }
  92 }
  93
  94 void
  95 mbuf_add_item (struct mbuf_set *ms, const struct mbuf_item *item)
  96 {
  97   ASSERT (ms);
  98   mutex_lock (&ms->mutex);
  99   if (ms->len == ms->capacity)
 100     {
 101       struct mbuf_item rm;
 102       ASSERT (mbuf_extract_item (ms, &rm, false));
 103       mbuf_free_buf (rm.buffer);
 104       msg (D_MULTI_DROPPED, "MBUF: mbuf packet dropped");
 105     }
 106
 107   ASSERT (ms->len < ms->capacity);
 108
 109   ms->array[MBUF_INDEX(ms->head, ms->len, ms->capacity)] = *item;
 110   if (++ms->len > ms->max_queued)
 111     ms->max_queued = ms->len;
 112   ++item->buffer->refcount;
 113   mutex_unlock (&ms->mutex);
 114 }
 115
 116 bool
 117 mbuf_extract_item (struct mbuf_set *ms, struct mbuf_item *item, const bool lock)
 118 {
 119   bool ret = false;
 120   if (ms)
 121     {
 122       if (lock)
 123         mutex_lock (&ms->mutex);
 124       while (ms->len)
 125         {
 126           *item = ms->array[ms->head];
 127           ms->head = MBUF_INDEX(ms->head, 1, ms->capacity);
 128           --ms->len;
 129           if (item->instance) /* ignore dereferenced instances */
 130             {
 131               ret = true;
 132               break;
 133             }
 134         }
 135       if (lock)
 136         mutex_unlock (&ms->mutex);
 137     }
 138   return ret;
 139 }
 140
 141 struct multi_instance *
 142 mbuf_peek_dowork (struct mbuf_set *ms)
 143 {
 144   struct multi_instance *ret = NULL;
 145   if (ms)
 146     {
 147       int i;
 148       mutex_lock (&ms->mutex);
 149       for (i = 0; i < (int) ms->len; ++i)
 150         {
 151           struct mbuf_item *item = &ms->array[MBUF_INDEX(ms->head, i, ms->capacity)];
 152           if (item->instance)
 153             {
 154               ret = item->instance;
 155               break;
 156             }
 157         }
 158       mutex_unlock (&ms->mutex);
 159     }
 160   return ret;
 161 }
 162
 163 void
 164 mbuf_dereference_instance (struct mbuf_set *ms, struct multi_instance *mi)
 165 {
 166   if (ms)
 167     {
 168       int i;
 169       mutex_lock (&ms->mutex);
 170       for (i = 0; i < (int) ms->len; ++i)
 171         {
 172           struct mbuf_item *item = &ms->array[MBUF_INDEX(ms->head, i, ms->capacity)];
 173           if (item->instance == mi)
 174             {
 175               mbuf_free_buf (item->buffer);
 176               item->buffer = NULL;
 177               item->instance = NULL;
 178               msg (D_MBUF, "MBUF: dereferenced queued packet");
 179             }
 180         }
 181       mutex_unlock (&ms->mutex);
 182     }
 183 }
 184
 185 #else
 186 static void dummy(void) {}
 187 #endif /* P2MP */