source/libsmb/namecache.c

   1 /*
   2    Unix SMB/CIFS implementation.
   3
   4    NetBIOS name cache module.
   5
   6    Copyright (C) Tim Potter, 2002
   7
   8    This program is free software; you can redistribute it and/or modify
   9    it under the terms of the GNU General Public License as published by
  10    the Free Software Foundation; either version 2 of the License, or
  11    (at your option) any later version.
  12
  13    This program is distributed in the hope that it will be useful,
  14    but WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16    GNU General Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with this program; if not, write to the Free Software
  20    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  21 */
  22
  23 #include "includes.h"
  24
  25 static BOOL done_namecache_init;
  26 static BOOL enable_namecache;
  27 static TDB_CONTEXT *namecache_tdb;
  28
  29 struct nc_value {
  30         time_t expiry;               /* When entry expires */
  31         int count;                   /* Number of addresses */
  32         struct in_addr ip_list[1];   /* Address list */
  33 };
  34
  35 /* Initialise namecache system */
  36
  37 BOOL namecache_enable(void)
  38 {
  39         /* Check if we have been here before, or name caching disabled
  40            by setting the name cache timeout to zero. */
  41
  42         if (done_namecache_init)
  43                 return False;
  44
  45         done_namecache_init = True;
  46
  47         if (lp_name_cache_timeout() == 0) {
  48                 DEBUG(5, ("namecache_init: disabling netbios name cache\n"));
  49                 return False;
  50         }
  51
  52         /* Open namecache tdb in read/write or readonly mode */
  53
  54         namecache_tdb = tdb_open_log(
  55                 lock_path("namecache.tdb"), 0,
  56                 TDB_DEFAULT, O_RDWR | O_CREAT, 0644);
  57
  58         if (!namecache_tdb) {
  59                 DEBUG(5, ("namecache_init: could not open %s\n",
  60                           lock_path("namecache.tdb")));
  61                 return False;
  62         }
  63
  64         DEBUG(5, ("namecache_init: enabling netbios namecache, timeout %d "
  65                   "seconds\n", lp_name_cache_timeout()));
  66
  67         enable_namecache = True;
  68
  69         return True;
  70 }
  71
  72 /* Return a key for a name and name type.  The caller must free
  73    retval.dptr when finished. */
  74
  75 static TDB_DATA namecache_key(const char *name, int name_type)
  76 {
  77         TDB_DATA retval;
  78         char *keystr;
  79
  80         asprintf(&keystr, "%s#%02X", strupper_static(name), name_type);
  81
  82         retval.dsize = strlen(keystr) + 1;
  83         retval.dptr = keystr;
  84
  85         return retval;
  86 }
  87
  88 /* Return a data value for an IP list.  The caller must free
  89    retval.dptr when finished. */
  90
  91 static TDB_DATA namecache_value(struct in_addr *ip_list, int num_names,
  92                                 time_t expiry)
  93 {
  94         TDB_DATA retval;
  95         struct nc_value *value;
  96         int size = sizeof(struct nc_value);
  97
  98         if (num_names > 0)
  99                 size += sizeof(struct in_addr) * (num_names-1);
 100
 101         value = (struct nc_value *)malloc(size);
 102
 103         memset(value, 0, size);
 104
 105         value->expiry = expiry;
 106         value->count = num_names;
 107
 108         if (ip_list)
 109                 memcpy(value->ip_list, ip_list, sizeof(struct in_addr) * num_names);
 110
 111         retval.dptr = (char *)value;
 112         retval.dsize = size;
 113
 114         return retval;
 115 }
 116
 117 /* Store a name in the name cache */
 118
 119 void namecache_store(const char *name, int name_type,
 120                      int num_names, struct in_addr *ip_list)
 121 {
 122         TDB_DATA key, value;
 123         time_t expiry;
 124         int i;
 125
 126         if (!enable_namecache)
 127                 return;
 128
 129         DEBUG(5, ("namecache_store: storing %d address%s for %s#%02x: ",
 130                   num_names, num_names == 1 ? "": "es", name, name_type));
 131
 132         for (i = 0; i < num_names; i++)
 133                 DEBUGADD(5, ("%s%s", inet_ntoa(ip_list[i]),
 134                              i == (num_names - 1) ? "" : ", "));
 135
 136         DEBUGADD(5, ("\n"));
 137
 138         key = namecache_key(name, name_type);
 139
 140         /* Cache pdc location or dc lists for only a little while
 141            otherwise if we lock on to a bad DC we can potentially be
 142            out of action for the entire cache timeout time! */
 143
 144         if (name_type != 0x1b || name_type != 0x1c)
 145                 expiry = time(NULL) + 10;
 146         else
 147                 expiry = time(NULL) + lp_name_cache_timeout();
 148
 149         value = namecache_value(ip_list, num_names, expiry);
 150
 151         tdb_store(namecache_tdb, key, value, TDB_REPLACE);
 152
 153         free(key.dptr);
 154         free(value.dptr);
 155 }
 156
 157 /* Look up a name in the name cache.  Return a mallocated list of IP
 158    addresses if the name is contained in the cache. */
 159
 160 BOOL namecache_fetch(const char *name, int name_type, struct in_addr **ip_list,
 161                      int *num_names)
 162 {
 163         TDB_DATA key, value;
 164         struct nc_value *data;
 165         time_t now;
 166         int i;
 167
 168         *ip_list = NULL;
 169         *num_names = 0;
 170
 171         if (!enable_namecache)
 172                 return False;
 173
 174         /* Read value */
 175
 176         key = namecache_key(name, name_type);
 177
 178         value = tdb_fetch(namecache_tdb, key);
 179
 180         if (!value.dptr) {
 181                 DEBUG(5, ("namecache_fetch: %s#%02x not found\n",
 182                           name, name_type));
 183                 goto done;
 184         }
 185
 186         data = (struct nc_value *)value.dptr;
 187
 188         /* Check expiry time */
 189
 190         now = time(NULL);
 191
 192         if (now > data->expiry) {
 193
 194                 DEBUG(5, ("namecache_fetch: entry for %s#%02x expired\n",
 195                           name, name_type));
 196
 197                 tdb_delete(namecache_tdb, key);
 198
 199                 value = tdb_null;
 200
 201                 goto done;
 202         }
 203
 204         if ((data->expiry - now) > lp_name_cache_timeout()) {
 205
 206                 /* Someone may have changed the system time on us */
 207
 208                 DEBUG(5, ("namecache_fetch: entry for %s#%02x has bad expiry\n",
 209                           name, name_type));
 210
 211                 tdb_delete(namecache_tdb, key);
 212
 213                 value = tdb_null;
 214
 215                 goto done;
 216         }
 217
 218         /* Extract and return namelist */
 219
 220         DEBUG(5, ("namecache_fetch: returning %d address%s for %s#%02x: ",
 221                   data->count, data->count == 1 ? "" : "es", name, name_type));
 222
 223         if (data->count) {
 224
 225                 *ip_list = (struct in_addr *)malloc(
 226                         sizeof(struct in_addr) * data->count);
 227
 228                 memcpy(*ip_list, data->ip_list, sizeof(struct in_addr) * data->count);
 229
 230                 *num_names = data->count;
 231
 232                 for (i = 0; i < *num_names; i++)
 233                         DEBUGADD(5, ("%s%s", inet_ntoa((*ip_list)[i]),
 234                                      i == (*num_names - 1) ? "" : ", "));
 235
 236         }
 237
 238         DEBUGADD(5, ("\n"));
 239
 240 done:
 241         SAFE_FREE(key.dptr);
 242         SAFE_FREE(value.dptr);
 243
 244         return value.dsize > 0;
 245 }
 246
 247 /* Flush all names from the name cache */
 248
 249 void namecache_flush(void)
 250 {
 251         int result;
 252
 253         if (!namecache_tdb)
 254                 return;
 255
 256         result = tdb_traverse(namecache_tdb, tdb_traverse_delete_fn, NULL);
 257
 258         if (result == -1)
 259                 DEBUG(5, ("namecache_flush: error deleting cache entries\n"));
 260         else
 261                 DEBUG(5, ("namecache_flush: deleted %d cache entr%s\n",
 262                           result, result == 1 ? "y" : "ies"));
 263 }