release/src/router/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-2009 OpenVPN Technologies, Inc. <sales@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 #include "syshead.h"
  26
  27 #if P2MP
  28
  29 #include "buffer.h"
  30 #include "error.h"
  31 #include "misc.h"
  32 #include "mbuf.h"
  33
  34 #include "memdbg.h"
  35
  36 struct mbuf_set *
  37 mbuf_init (unsigned int size)
  38 {
  39   struct mbuf_set *ret;
  40   ALLOC_OBJ_CLEAR (ret, struct mbuf_set);
  41   mutex_init (&ret->mutex);
  42   ret->capacity = adjust_power_of_2 (size);
  43   ALLOC_ARRAY (ret->array, struct mbuf_item, ret->capacity);
  44   return ret;
  45 }
  46
  47 void
  48 mbuf_free (struct mbuf_set *ms)
  49 {
  50   if (ms)
  51     {
  52       int i;
  53       for (i = 0; i < (int) ms->len; ++i)
  54         {
  55           struct mbuf_item *item = &ms->array[MBUF_INDEX(ms->head, i, ms->capacity)];
  56           mbuf_free_buf (item->buffer);
  57         }
  58       free (ms->array);
  59       mutex_destroy (&ms->mutex);
  60       free (ms);
  61     }
  62 }
  63
  64 struct mbuf_buffer *
  65 mbuf_alloc_buf (const struct buffer *buf)
  66 {
  67   struct mbuf_buffer *ret;
  68   ALLOC_OBJ (ret, struct mbuf_buffer);
  69   ret->buf = clone_buf (buf);
  70   ret->refcount = 1;
  71   ret->flags = 0;
  72   return ret;
  73 }
  74
  75 void
  76 mbuf_free_buf (struct mbuf_buffer *mb)
  77 {
  78   if (mb)
  79     {
  80       if (--mb->refcount <= 0)
  81         {
  82           free_buf (&mb->buf);
  83           free (mb);
  84         }
  85     }
  86 }
  87
  88 void
  89 mbuf_add_item (struct mbuf_set *ms, const struct mbuf_item *item)
  90 {
  91   ASSERT (ms);
  92   mutex_lock (&ms->mutex);
  93   if (ms->len == ms->capacity)
  94     {
  95       struct mbuf_item rm;
  96       ASSERT (mbuf_extract_item (ms, &rm, false));
  97       mbuf_free_buf (rm.buffer);
  98       msg (D_MULTI_DROPPED, "MBUF: mbuf packet dropped");
  99     }
 100
 101   ASSERT (ms->len < ms->capacity);
 102
 103   ms->array[MBUF_INDEX(ms->head, ms->len, ms->capacity)] = *item;
 104   if (++ms->len > ms->max_queued)
 105     ms->max_queued = ms->len;
 106   ++item->buffer->refcount;
 107   mutex_unlock (&ms->mutex);
 108 }
 109
 110 bool
 111 mbuf_extract_item (struct mbuf_set *ms, struct mbuf_item *item, const bool lock)
 112 {
 113   bool ret = false;
 114   if (ms)
 115     {
 116       if (lock)
 117         mutex_lock (&ms->mutex);
 118       while (ms->len)
 119         {
 120           *item = ms->array[ms->head];
 121           ms->head = MBUF_INDEX(ms->head, 1, ms->capacity);
 122           --ms->len;
 123           if (item->instance) /* ignore dereferenced instances */
 124             {
 125               ret = true;
 126               break;
 127             }
 128         }
 129       if (lock)
 130         mutex_unlock (&ms->mutex);
 131     }
 132   return ret;
 133 }
 134
 135 struct multi_instance *
 136 mbuf_peek_dowork (struct mbuf_set *ms)
 137 {
 138   struct multi_instance *ret = NULL;
 139   if (ms)
 140     {
 141       int i;
 142       mutex_lock (&ms->mutex);
 143       for (i = 0; i < (int) ms->len; ++i)
 144         {
 145           struct mbuf_item *item = &ms->array[MBUF_INDEX(ms->head, i, ms->capacity)];
 146           if (item->instance)
 147             {
 148               ret = item->instance;
 149               break;
 150             }
 151         }
 152       mutex_unlock (&ms->mutex);
 153     }
 154   return ret;
 155 }
 156
 157 void
 158 mbuf_dereference_instance (struct mbuf_set *ms, struct multi_instance *mi)
 159 {
 160   if (ms)
 161     {
 162       int i;
 163       mutex_lock (&ms->mutex);
 164       for (i = 0; i < (int) ms->len; ++i)
 165         {
 166           struct mbuf_item *item = &ms->array[MBUF_INDEX(ms->head, i, ms->capacity)];
 167           if (item->instance == mi)
 168             {
 169               mbuf_free_buf (item->buffer);
 170               item->buffer = NULL;
 171               item->instance = NULL;
 172               msg (D_MBUF, "MBUF: dereferenced queued packet");
 173             }
 174         }
 175       mutex_unlock (&ms->mutex);
 176     }
 177 }
 178
 179 #else
 180 static void dummy(void) {}
 181 #endif /* P2MP */