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 void 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;
  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;
  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;
  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
  70 /* Return a key for a name and name type.  The caller must free
  71    retval.dptr when finished. */
  72
  73 static TDB_DATA namecache_key(const char *name, int name_type)
  74 {
  75         TDB_DATA retval;
  76         char *keystr;
  77
  78         asprintf(&keystr, "%s#%02X", strupper_static(name), name_type);
  79
  80         retval.dsize = strlen(keystr) + 1;
  81         retval.dptr = keystr;
  82
  83         return retval;
  84 }
  85
  86 /* Return a data value for an IP list.  The caller must free
  87    retval.dptr when finished. */
  88
  89 static TDB_DATA namecache_value(struct in_addr *ip_list, int num_names,
  90                                 time_t expiry)
  91 {
  92         TDB_DATA retval;
  93         struct nc_value *value;
  94         int size;
  95
  96         size = sizeof(struct nc_value) + sizeof(struct in_addr) *
  97                 (num_names-1);
  98
  99         value = (struct nc_value *)malloc(size);
 100
 101         value->expiry = expiry;
 102         value->count = num_names;
 103
 104         memcpy(value->ip_list, ip_list, sizeof(*ip_list));
 105
 106         retval.dptr = (char *)value;
 107         retval.dsize = size;
 108
 109         return retval;
 110 }
 111
 112 /* Store a name in the name cache */
 113
 114 void namecache_store(const char *name, int name_type,
 115                      int num_names, struct in_addr *ip_list)
 116 {
 117         TDB_DATA key, value;
 118         time_t expiry;
 119         int i;
 120
 121         if (!enable_namecache)
 122                 return;
 123
 124         DEBUG(5, ("namecache_store: storing %d address%s for %s#%02x: ",
 125                   num_names, num_names == 1 ? "": "es", name, name_type));
 126
 127         for (i = 0; i < num_names; i++)
 128                 DEBUGADD(5, ("%s%s", inet_ntoa(ip_list[i]),
 129                              i == (num_names - 1) ? "" : ", "));
 130
 131         DEBUGADD(5, ("\n"));
 132
 133         key = namecache_key(name, name_type);
 134
 135         /* Cache pdc location or dc lists for only a little while
 136            otherwise if we lock on to a bad DC we can potentially be
 137            out of action for the entire cache timeout time! */
 138
 139         if (name_type != 0x1b || name_type != 0x1c)
 140                 expiry = time(NULL) + 10;
 141         else
 142                 expiry = time(NULL) + lp_name_cache_timeout();
 143
 144         value = namecache_value(ip_list, num_names, expiry);
 145
 146         tdb_store(namecache_tdb, key, value, TDB_REPLACE);
 147
 148         free(key.dptr);
 149         free(value.dptr);
 150 }
 151
 152 /* Look up a name in the name cache.  Return a mallocated list of IP
 153    addresses if the name is contained in the cache. */
 154
 155 BOOL namecache_fetch(const char *name, int name_type, struct in_addr **ip_list,
 156                      int *num_names)
 157 {
 158         TDB_DATA key, value;
 159         struct nc_value *data;
 160         time_t now;
 161         int i;
 162
 163         if (!enable_namecache)
 164                 return False;
 165
 166         /* Read value */
 167
 168         key = namecache_key(name, name_type);
 169
 170         value = tdb_fetch(namecache_tdb, key);
 171
 172         if (!value.dptr) {
 173                 DEBUG(5, ("namecache_fetch: %s#%02x not found\n",
 174                           name, name_type));
 175                 goto done;
 176         }
 177
 178         data = (struct nc_value *)value.dptr;
 179
 180         /* Check expiry time */
 181
 182         now = time(NULL);
 183
 184         if (now > data->expiry) {
 185
 186                 DEBUG(5, ("namecache_fetch: entry for %s#%02x expired\n",
 187                           name, name_type));
 188
 189                 tdb_delete(namecache_tdb, key);
 190
 191                 value = tdb_null;
 192
 193                 goto done;
 194         }
 195
 196         if ((data->expiry - now) > lp_name_cache_timeout()) {
 197
 198                 /* Someone may have changed the system time on us */
 199
 200                 DEBUG(5, ("namecache_fetch: entry for %s#%02x has bad expiry\n",
 201                           name, name_type));
 202
 203                 tdb_delete(namecache_tdb, key);
 204
 205                 value = tdb_null;
 206
 207                 goto done;
 208         }
 209
 210         /* Extract and return namelist */
 211
 212         *ip_list = (struct in_addr *)malloc(
 213                 sizeof(struct in_addr) * (data->count-1));
 214
 215         memcpy(*ip_list, data->ip_list, sizeof(struct in_addr) *
 216                (data->count-1));
 217
 218         *num_names = data->count;
 219
 220         DEBUG(5, ("namecache_fetch: returning %d address%s for %s#%02x: ",
 221                   *num_names, *num_names == 1 ? "" : "es", name, name_type));
 222
 223         for (i = 0; i < *num_names; i++)
 224                 DEBUGADD(5, ("%s%s", inet_ntoa((*ip_list)[i]),
 225                              i == (*num_names - 1) ? "" : ", "));
 226
 227         DEBUGADD(5, ("\n"));
 228
 229 done:
 230         SAFE_FREE(key.dptr);
 231         SAFE_FREE(value.dptr);
 232
 233         return value.dsize > 0;
 234 }
 235
 236 /* Flush all names from the name cache */
 237
 238 void namecache_flush(void)
 239 {
 240         int result;
 241
 242         if (!namecache_tdb)
 243                 return;
 244
 245         result = tdb_traverse(namecache_tdb, tdb_traverse_delete_fn, NULL);
 246
 247         if (result == -1)
 248                 DEBUG(5, ("namecache_flush: error deleting cache entries\n"));
 249         else
 250                 DEBUG(5, ("namecache_flush: deleted %d cache entr%s\n",
 251                           result, result == 1 ? "y" : "ies"));
 252 }