src/util/peer.c

   1 /*
   2       This file is part of GNUnet
   3      (C) 2006, 2008, 2009 Christian Grothoff (and other contributing authors)
   4
   5       GNUnet is free software; you can redistribute it and/or modify
   6       it under the terms of the GNU General Public License as published
   7       by the Free Software Foundation; either version 2, or (at your
   8       option) any later version.
   9
  10       GNUnet is distributed in the hope that it will be useful, but
  11       WITHOUT ANY WARRANTY; without even the implied warranty of
  12       MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13       General Public License for more details.
  14
  15       You should have received a copy of the GNU General Public License
  16       along with GNUnet; see the file COPYING.  If not, write to the
  17       Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  18       Boston, MA 02110-1301, USA.
  19  */
  20
  21 /**
  22  * @file util/peer.c
  23  * @brief peer-ID table that assigns integer IDs to peer-IDs to save memory
  24  * @author Christian Grothoff
  25  */
  26
  27 #include "platform.h"
  28 #include "gnunet_peer_lib.h"
  29
  30 #define LOG(kind,...) GNUNET_log_from (kind, "util", __VA_ARGS__)
  31
  32
  33 struct PeerEntry
  34 {
  35   /**
  36    * The identifier itself
  37    */
  38   struct GNUNET_PeerIdentity id;
  39
  40   /**
  41    * Short version of the identifier; if the RC==0, then index of next
  42    * free slot in table, otherwise equal to this slot in the table.
  43    */
  44   GNUNET_PEER_Id pid;
  45
  46   /**
  47    * Reference counter, 0 if this slot is not used.
  48    */
  49   unsigned int rc;
  50 };
  51
  52
  53 /**
  54  * Table with our interned peer IDs.
  55  */
  56 static struct PeerEntry *table;
  57
  58 /**
  59  * Hashmap of PeerIdentities to "struct PeerEntry"
  60  * (for fast lookup).  NULL until the library
  61  * is actually being used.
  62  */
  63 static struct GNUNET_CONTAINER_MultiHashMap *map;
  64
  65 /**
  66  * Size of the "table".
  67  */
  68 static unsigned int size;
  69
  70 /**
  71  * Index of the beginning of the free list in the table; set to "size"
  72  * if no slots are free in the table.
  73  */
  74 static unsigned int free_list_start;
  75
  76
  77 /**
  78  * Search for a peer identity. The reference counter is not changed.
  79  *
  80  * @param pid identity to find
  81  * @return the interned identity or 0.
  82  */
  83 GNUNET_PEER_Id
  84 GNUNET_PEER_search (const struct GNUNET_PeerIdentity *pid)
  85 {
  86   struct PeerEntry *e;
  87   long off;
  88
  89   if (pid == NULL)
  90     return 0;
  91   if (NULL == map)
  92     return 0;
  93   off = (long) GNUNET_CONTAINER_multihashmap_get (map, &pid->hashPubKey);
  94   e = (off == 0) ? NULL : &table[off];
  95   if (e == NULL)
  96     return 0;
  97   GNUNET_assert (e->rc > 0);
  98   return e->pid;
  99 }
 100
 101
 102 /**
 103  * Intern an peer identity.  If the identity is already known, its
 104  * reference counter will be increased by one.
 105  *
 106  * @param pid identity to intern
 107  * @return the interned identity.
 108  */
 109 GNUNET_PEER_Id
 110 GNUNET_PEER_intern (const struct GNUNET_PeerIdentity * pid)
 111 {
 112   GNUNET_PEER_Id ret;
 113   struct PeerEntry *e;
 114   unsigned int i;
 115   long off;
 116
 117   if (pid == NULL)
 118     return 0;
 119   if (NULL == map)
 120     map = GNUNET_CONTAINER_multihashmap_create (32);
 121   off = (long) GNUNET_CONTAINER_multihashmap_get (map, &pid->hashPubKey);
 122   e = (off == 0) ? NULL : &table[off];
 123   if (e != NULL)
 124     {
 125       GNUNET_assert (e->rc > 0);
 126       e->rc++;
 127       return e->pid;
 128     }
 129   ret = free_list_start;
 130   if (ret == size)
 131     {
 132       GNUNET_array_grow (table, size, size + 16);
 133       for (i = ret; i < size; i++)
 134         table[i].pid = i + 1;
 135     }
 136   if (ret == 0)
 137     {
 138       table[0].pid = 0;
 139       table[0].rc = 1;
 140       ret = 1;
 141     }
 142   GNUNET_assert (ret < size);
 143   GNUNET_assert (table[ret].rc == 0);
 144   free_list_start = table[ret].pid;
 145   table[ret].id = *pid;
 146   table[ret].rc = 1;
 147   table[ret].pid = ret;
 148   GNUNET_break (GNUNET_OK ==
 149                 GNUNET_CONTAINER_multihashmap_put (map, &pid->hashPubKey,
 150                                                    (void *) (long) ret,
 151                                                    GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
 152   return ret;
 153 }
 154
 155
 156 /**
 157  * Decrement multiple RCs of peer identities by one.
 158  *
 159  * @param ids array of PIDs to decrement the RCs of
 160  * @param count size of the ids array
 161  */
 162 void
 163 GNUNET_PEER_decrement_rcs (const GNUNET_PEER_Id * ids, unsigned int count)
 164 {
 165   int i;
 166   GNUNET_PEER_Id id;
 167
 168   if (count == 0)
 169     return;
 170   for (i = count - 1; i >= 0; i--)
 171     {
 172       id = ids[i];
 173       if (id == 0)
 174         continue;
 175       GNUNET_assert (id < size);
 176       GNUNET_assert (table[id].rc > 0);
 177       table[id].rc--;
 178       if (table[id].rc == 0)
 179         {
 180           GNUNET_break (GNUNET_OK ==
 181                         GNUNET_CONTAINER_multihashmap_remove (map,
 182                                                               &table[id].
 183                                                               id.hashPubKey,
 184                                                               (void *) (long)
 185                                                               id));
 186           table[id].pid = free_list_start;
 187           free_list_start = id;
 188         }
 189     }
 190 }
 191
 192
 193 /**
 194  * Change the reference counter of an interned PID.
 195  *
 196  * @param id identity to change the RC of
 197  * @param delta how much to change the RC
 198  */
 199 void
 200 GNUNET_PEER_change_rc (GNUNET_PEER_Id id, int delta)
 201 {
 202   if (id == 0)
 203     return;
 204   GNUNET_assert (id < size);
 205   GNUNET_assert (table[id].rc > 0);
 206   GNUNET_assert ((delta >= 0) || (table[id].rc >= -delta));
 207   table[id].rc += delta;
 208   if (table[id].rc == 0)
 209     {
 210       GNUNET_break (GNUNET_OK ==
 211                     GNUNET_CONTAINER_multihashmap_remove (map,
 212                                                           &table[id].
 213                                                           id.hashPubKey,
 214                                                           (void *) (long)
 215                                                           id));
 216       table[id].pid = free_list_start;
 217       free_list_start = id;
 218     }
 219 }
 220
 221
 222 /**
 223  * Convert an interned PID to a normal peer identity.
 224  *
 225  * @param id interned PID to convert
 226  * @param pid where to write the normal peer identity
 227  */
 228 void
 229 GNUNET_PEER_resolve (GNUNET_PEER_Id id, struct GNUNET_PeerIdentity *pid)
 230 {
 231   if (id == 0)
 232     {
 233       memset (pid, 0, sizeof (struct GNUNET_PeerIdentity));
 234       GNUNET_break (0);
 235       return;
 236     }
 237   GNUNET_assert (id < size);
 238   GNUNET_assert (table[id].rc > 0);
 239   *pid = table[id].id;
 240 }
 241
 242
 243 /* end of peer.c */