release/src/router/openvpn/tap-win32/mem.c

   1 /*
   2  *  TAP-Win32/TAP-Win64 -- A kernel driver to provide virtual tap
   3  *                         device functionality on Windows.
   4  *
   5  *  This code was inspired by the CIPE-Win32 driver by Damion K. Wilson.
   6  *
   7  *  This source code is Copyright (C) 2002-2009 OpenVPN Technologies, Inc.,
   8  *  and is released under the GPL version 2 (see below).
   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 //------------------
  26 // Memory Management
  27 //------------------
  28
  29 PVOID
  30 MemAlloc (ULONG p_Size, BOOLEAN zero)
  31 {
  32   PVOID l_Return = NULL;
  33
  34   if (p_Size)
  35     {
  36       __try
  37       {
  38         if (NdisAllocateMemoryWithTag (&l_Return, p_Size, 'APAT')
  39             == NDIS_STATUS_SUCCESS)
  40           {
  41             if (zero)
  42               NdisZeroMemory (l_Return, p_Size);
  43           }
  44         else
  45           l_Return = NULL;
  46       }
  47       __except (EXCEPTION_EXECUTE_HANDLER)
  48       {
  49         l_Return = NULL;
  50       }
  51     }
  52
  53   return l_Return;
  54 }
  55
  56 VOID
  57 MemFree (PVOID p_Addr, ULONG p_Size)
  58 {
  59   if (p_Addr && p_Size)
  60     {
  61       __try
  62       {
  63 #if DBG
  64         NdisZeroMemory (p_Addr, p_Size);
  65 #endif
  66         NdisFreeMemory (p_Addr, p_Size, 0);
  67       }
  68       __except (EXCEPTION_EXECUTE_HANDLER)
  69       {
  70       }
  71     }
  72 }
  73
  74 /*
  75  * Circular queue management routines.
  76  */
  77
  78 #define QUEUE_BYTE_ALLOCATION(size) \
  79   (sizeof (Queue) + (size * sizeof (PVOID)))
  80
  81 #define QUEUE_ADD_INDEX(var, inc) \
  82 { \
  83   var += inc; \
  84   if (var >= q->capacity) \
  85     var -= q->capacity; \
  86   MYASSERT (var < q->capacity); \
  87 }
  88
  89 #define QUEUE_SANITY_CHECK() \
  90   MYASSERT (q != NULL && q->base < q->capacity && q->size <= q->capacity)
  91
  92 #define QueueCount(q) (q->size)
  93
  94 #define UPDATE_MAX_SIZE() \
  95 { \
  96   if (q->size > q->max_size) \
  97     q->max_size = q->size; \
  98 }
  99
 100 Queue *
 101 QueueInit (ULONG capacity)
 102 {
 103   Queue *q;
 104
 105   MYASSERT (capacity > 0);
 106   q = (Queue *) MemAlloc (QUEUE_BYTE_ALLOCATION (capacity), TRUE);
 107   if (!q)
 108     return NULL;
 109
 110   q->base = q->size = 0;
 111   q->capacity = capacity;
 112   q->max_size = 0;
 113   return q;
 114 }
 115
 116 VOID
 117 QueueFree (Queue *q)
 118 {
 119   if (q)
 120     {
 121       QUEUE_SANITY_CHECK ();
 122       MemFree (q, QUEUE_BYTE_ALLOCATION (q->capacity));
 123     }
 124 }
 125
 126 PVOID
 127 QueuePush (Queue *q, PVOID item)
 128 {
 129   ULONG dest;
 130   QUEUE_SANITY_CHECK ();
 131   if (q->size == q->capacity)
 132     return NULL;
 133   dest = q->base;
 134   QUEUE_ADD_INDEX (dest, q->size);
 135   q->data[dest] = item;
 136   ++q->size;
 137   UPDATE_MAX_SIZE();
 138   return item;
 139 }
 140
 141 PVOID
 142 QueuePop (Queue *q)
 143 {
 144   ULONG oldbase;
 145   QUEUE_SANITY_CHECK ();
 146   if (!q->size)
 147     return NULL;
 148   oldbase = q->base;
 149   QUEUE_ADD_INDEX (q->base, 1);
 150   --q->size;
 151   UPDATE_MAX_SIZE();
 152   return q->data[oldbase];
 153 }
 154
 155 PVOID
 156 QueueExtract (Queue *q, PVOID item)
 157 {
 158   ULONG src, dest, count, n;
 159   QUEUE_SANITY_CHECK ();
 160   n = 0;
 161   src = dest = q->base;
 162   count = q->size;
 163   while (count--)
 164     {
 165       if (item == q->data[src])
 166         {
 167           ++n;
 168           --q->size;
 169         }
 170       else
 171         {
 172           q->data[dest] = q->data[src];
 173           QUEUE_ADD_INDEX (dest, 1);
 174         }
 175       QUEUE_ADD_INDEX (src, 1);
 176     }
 177   if (n)
 178     return item;
 179   else
 180     return NULL;
 181 }
 182
 183 #undef QUEUE_BYTE_ALLOCATION
 184 #undef QUEUE_ADD_INDEX
 185 #undef QUEUE_SANITY_CHECK
 186 #undef UPDATE_MAX_SIZE