release/src/router/openvpn/tap-win32/instance.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 #define INSTANCE_KEY(a) ((PVOID)((a)->m_Extension.m_TapDevice))
  26
  27 #define N_INSTANCE_BUCKETS 256
  28
  29 typedef struct _INSTANCE {
  30   struct _INSTANCE *next;
  31   TapAdapterPointer m_Adapter;
  32 } INSTANCE;
  33
  34 typedef struct {
  35   INSTANCE *list;
  36   MUTEX lock;
  37 } INSTANCE_BUCKET;
  38
  39 typedef struct {
  40   INSTANCE_BUCKET buckets[N_INSTANCE_BUCKETS];
  41 } INSTANCE_HASH;
  42
  43 INSTANCE_HASH *g_InstanceHash = NULL;
  44
  45 // must return a hash >= 0 and < N_INSTANCE_BUCKETS
  46 int
  47 InstanceHashValue (PVOID addr)
  48 {
  49   UCHAR *p = (UCHAR *) &addr;
  50
  51   if (sizeof (addr) == 4)
  52     return p[0] ^ p[1] ^ p[2] ^ p[3];
  53   else if (sizeof (addr) == 8)
  54     return p[0] ^ p[1] ^ p[2] ^ p[3] ^ p[4] ^ p[5] ^ p[6] ^ p[7];
  55   else
  56     {
  57       MYASSERT (0);
  58     }
  59 }
  60
  61 BOOLEAN
  62 InitInstanceList (VOID)
  63 {
  64   MYASSERT (g_InstanceHash == NULL);
  65   g_InstanceHash = MemAlloc (sizeof (INSTANCE_HASH), TRUE);
  66   if (g_InstanceHash)
  67     {
  68       int i;
  69       for (i = 0; i < N_INSTANCE_BUCKETS; ++i)
  70         INIT_MUTEX (&g_InstanceHash->buckets[i].lock);
  71       return TRUE;
  72     }
  73   else
  74     return FALSE;
  75 }
  76
  77 int
  78 NInstances (VOID)
  79 {
  80   int i, n = 0;
  81
  82   if (g_InstanceHash)
  83     {
  84       for (i = 0; i < N_INSTANCE_BUCKETS; ++i)
  85         {
  86           BOOLEAN got_lock;
  87           INSTANCE_BUCKET *ib = &g_InstanceHash->buckets[i];
  88           ACQUIRE_MUTEX_ADAPTIVE (&ib->lock, got_lock);
  89
  90           if (got_lock)
  91             {
  92               INSTANCE *current;
  93               for (current = ib->list; current != NULL; current = current->next)
  94                 ++n;
  95               RELEASE_MUTEX (&ib->lock);
  96             }
  97           else
  98             return -1;
  99         }
 100     }
 101
 102   return n;
 103 }
 104
 105 int
 106 InstanceMaxBucketSize (VOID)
 107 {
 108   int i, n = 0;
 109
 110   if (g_InstanceHash)
 111     {
 112       for (i = 0; i < N_INSTANCE_BUCKETS; ++i)
 113         {
 114           BOOLEAN got_lock;
 115           int bucket_size = 0;
 116           INSTANCE_BUCKET *ib = &g_InstanceHash->buckets[i];
 117           ACQUIRE_MUTEX_ADAPTIVE (&ib->lock, got_lock);
 118
 119           if (got_lock)
 120             {
 121               INSTANCE *current;
 122               for (current = ib->list; current != NULL; current = current->next)
 123                   ++bucket_size;
 124               if (bucket_size > n)
 125                 n = bucket_size;
 126               RELEASE_MUTEX (&ib->lock);
 127             }
 128           else
 129             return -1;
 130         }
 131     }
 132
 133   return n;
 134 }
 135
 136 VOID
 137 FreeInstanceList (VOID)
 138 {
 139   if (g_InstanceHash)
 140     {
 141       MYASSERT (NInstances() == 0);
 142       MemFree (g_InstanceHash, sizeof (INSTANCE_HASH));
 143       g_InstanceHash = NULL;
 144     }
 145 }
 146
 147 BOOLEAN
 148 AddAdapterToInstanceList (TapAdapterPointer p_Adapter)
 149 {
 150   BOOLEAN got_lock;
 151   BOOLEAN ret = FALSE;
 152   const int hash = InstanceHashValue(INSTANCE_KEY(p_Adapter));
 153   INSTANCE_BUCKET *ib = &g_InstanceHash->buckets[hash];
 154
 155   DEBUGP (("[TAP] AddAdapterToInstanceList hash=%d\n", hash));
 156
 157   ACQUIRE_MUTEX_ADAPTIVE (&ib->lock, got_lock);
 158
 159   if (got_lock)
 160     {
 161       INSTANCE *i = MemAlloc (sizeof (INSTANCE), FALSE);
 162       if (i)
 163         {
 164           MYASSERT (p_Adapter);
 165           i->m_Adapter = p_Adapter;
 166           i->next = ib->list;
 167           ib->list = i;
 168           ret = TRUE;
 169         }
 170       RELEASE_MUTEX (&ib->lock);
 171     }
 172
 173   return ret;
 174 }
 175
 176 BOOLEAN
 177 RemoveAdapterFromInstanceList (TapAdapterPointer p_Adapter)
 178 {
 179   BOOLEAN got_lock;
 180   BOOLEAN ret = FALSE;
 181   INSTANCE_BUCKET *ib = &g_InstanceHash->buckets[InstanceHashValue(INSTANCE_KEY(p_Adapter))];
 182
 183   ACQUIRE_MUTEX_ADAPTIVE (&ib->lock, got_lock);
 184
 185   if (got_lock)
 186     {
 187       INSTANCE *current, *prev=NULL;
 188       for (current = ib->list; current != NULL; current = current->next)
 189         {
 190           if (current->m_Adapter == p_Adapter) // found match
 191             {
 192               if (prev)
 193                 prev->next = current->next;
 194               else
 195                 ib->list = current->next;
 196               MemFree (current->m_Adapter, sizeof (TapAdapter));
 197               MemFree (current, sizeof (INSTANCE));
 198               ret = TRUE;
 199               break;
 200             }
 201           prev = current;
 202         }
 203       RELEASE_MUTEX (&ib->lock);
 204     }
 205
 206   return ret;
 207 }
 208
 209 TapAdapterPointer
 210 LookupAdapterInInstanceList (PDEVICE_OBJECT p_DeviceObject)
 211 {
 212   BOOLEAN got_lock;
 213   TapAdapterPointer ret = NULL;
 214   INSTANCE_BUCKET *ib = &g_InstanceHash->buckets[InstanceHashValue((PVOID)p_DeviceObject)];
 215
 216   ACQUIRE_MUTEX_ADAPTIVE (&ib->lock, got_lock);
 217
 218   if (got_lock)
 219     {
 220       INSTANCE *current, *prev=NULL;
 221       for (current = ib->list; current != NULL; current = current->next)
 222         {
 223           if (p_DeviceObject == INSTANCE_KEY (current->m_Adapter)) // found match
 224             {
 225               // move it to head of list
 226               if (prev)
 227                 {
 228                   prev->next = current->next;
 229                   current->next = ib->list;
 230                   ib->list = current;
 231                 }
 232               ret = ib->list->m_Adapter;
 233               break;
 234             }
 235           prev = current;
 236         }
 237       RELEASE_MUTEX (&ib->lock);
 238     }
 239
 240   return ret;
 241 }