source3/libsmb/namecache.c

   1 /*
   2    Unix SMB/CIFS implementation.
   3
   4    NetBIOS name cache module on top of gencache mechanism.
   5
   6    Copyright (C) Tim Potter         2002
   7    Copyright (C) Rafal Szczesniak   2002
   8    Copyright (C) Jeremy Allison     2007
   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 as published by
  12    the Free Software Foundation; either version 3 of the License, or
  13    (at your option) any later version.
  14
  15    This program is distributed in the hope that it will be useful,
  16    but WITHOUT ANY WARRANTY; without even the implied warranty of
  17    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18    GNU General Public License for more details.
  19
  20    You should have received a copy of the GNU General Public License
  21    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  22 */
  23
  24 #include "includes.h"
  25 #include "lib/gencache.h"
  26
  27 #define NBTKEY_FMT  "NBT/%s#%02X"
  28
  29 /**
  30  * Generates a key for netbios name lookups on basis of
  31  * netbios name and type.
  32  * The caller must free returned key string when finished.
  33  *
  34  * @param name netbios name string (case insensitive)
  35  * @param name_type netbios type of the name being looked up
  36  *
  37  * @return string consisted of uppercased name and appended
  38  *         type number
  39  */
  40
  41 static char *namecache_key(const char *name,
  42                                 int name_type)
  43 {
  44         char *keystr = NULL;
  45         asprintf_strupper_m(&keystr, NBTKEY_FMT, name, name_type);
  46
  47         return keystr;
  48 }
  49
  50 /**
  51  * Store a name(s) in the name cache
  52  *
  53  * @param name netbios names array
  54  * @param name_type integer netbios name type
  55  * @param num_names number of names being stored
  56  * @param ip_list array of in_addr structures containing
  57  *        ip addresses being stored
  58  **/
  59
  60 bool namecache_store(const char *name,
  61                         int name_type,
  62                         int num_names,
  63                         struct ip_service *ip_list)
  64 {
  65         time_t expiry;
  66         char *key, *value_string;
  67         int i;
  68         bool ret;
  69
  70         if (name_type > 255) {
  71                 return False; /* Don't store non-real name types. */
  72         }
  73
  74         if ( DEBUGLEVEL >= 5 ) {
  75                 TALLOC_CTX *ctx = talloc_stackframe();
  76                 char *addr = NULL;
  77
  78                 DEBUG(5, ("namecache_store: storing %d address%s for %s#%02x: ",
  79                         num_names, num_names == 1 ? "": "es", name, name_type));
  80
  81                 for (i = 0; i < num_names; i++) {
  82                         addr = print_canonical_sockaddr(ctx,
  83                                                         &ip_list[i].ss);
  84                         if (!addr) {
  85                                 continue;
  86                         }
  87                         DEBUGADD(5, ("%s%s", addr,
  88                                 (i == (num_names - 1) ? "" : ",")));
  89
  90                 }
  91                 DEBUGADD(5, ("\n"));
  92                 TALLOC_FREE(ctx);
  93         }
  94
  95         key = namecache_key(name, name_type);
  96         if (!key) {
  97                 return False;
  98         }
  99
 100         expiry = time(NULL) + lp_name_cache_timeout();
 101
 102         /*
 103          * Generate string representation of ip addresses list
 104          * First, store the number of ip addresses and then
 105          * place each single ip
 106          */
 107         if (!ipstr_list_make(&value_string, ip_list, num_names)) {
 108                 SAFE_FREE(key);
 109                 SAFE_FREE(value_string);
 110                 return false;
 111         }
 112
 113         /* set the entry */
 114         ret = gencache_set(key, value_string, expiry);
 115         SAFE_FREE(key);
 116         SAFE_FREE(value_string);
 117         return ret;
 118 }
 119
 120 /**
 121  * Look up a name in the cache.
 122  *
 123  * @param name netbios name to look up for
 124  * @param name_type netbios name type of @param name
 125  * @param ip_list mallocated list of IP addresses if found in the cache,
 126  *        NULL otherwise
 127  * @param num_names number of entries found
 128  *
 129  * @return true upon successful fetch or
 130  *         false if name isn't found in the cache or has expired
 131  **/
 132
 133 bool namecache_fetch(const char *name,
 134                         int name_type,
 135                         struct ip_service **ip_list,
 136                         int *num_names)
 137 {
 138         char *key, *value;
 139         time_t timeout;
 140
 141         /* exit now if null pointers were passed as they're required further */
 142         if (!ip_list || !num_names) {
 143                 return False;
 144         }
 145
 146         if (name_type > 255) {
 147                 return False; /* Don't fetch non-real name types. */
 148         }
 149
 150         *num_names = 0;
 151
 152         /*
 153          * Use gencache interface - lookup the key
 154          */
 155         key = namecache_key(name, name_type);
 156         if (!key) {
 157                 return False;
 158         }
 159
 160         if (!gencache_get(key, talloc_tos(), &value, &timeout)) {
 161                 DEBUG(5, ("no entry for %s#%02X found.\n", name, name_type));
 162                 SAFE_FREE(key);
 163                 return False;
 164         }
 165
 166         DEBUG(5, ("name %s#%02X found.\n", name, name_type));
 167
 168         /*
 169          * Split up the stored value into the list of IP adresses
 170          */
 171         *num_names = ipstr_list_parse(value, ip_list);
 172
 173         SAFE_FREE(key);
 174         TALLOC_FREE(value);
 175
 176         return *num_names > 0; /* true only if some ip has been fetched */
 177 }
 178
 179 /**
 180  * Remove a namecache entry. Needed for site support.
 181  *
 182  **/
 183
 184 bool namecache_delete(const char *name, int name_type)
 185 {
 186         bool ret;
 187         char *key;
 188
 189         if (name_type > 255) {
 190                 return False; /* Don't fetch non-real name types. */
 191         }
 192
 193         key = namecache_key(name, name_type);
 194         if (!key) {
 195                 return False;
 196         }
 197         ret = gencache_del(key);
 198         SAFE_FREE(key);
 199         return ret;
 200 }
 201
 202 /**
 203  * Delete single namecache entry. Look at the
 204  * gencache_iterate definition.
 205  *
 206  **/
 207
 208 static void flush_netbios_name(const char *key,
 209                         const char *value,
 210                         time_t timeout,
 211                         void *dptr)
 212 {
 213         gencache_del(key);
 214         DEBUG(5, ("Deleting entry %s\n", key));
 215 }
 216
 217 /**
 218  * Flush all names from the name cache.
 219  * It's done by gencache_iterate()
 220  *
 221  * @return true upon successful deletion or
 222  *         false in case of an error
 223  **/
 224
 225 void namecache_flush(void)
 226 {
 227         /*
 228          * iterate through each NBT cache's entry and flush it
 229          * by flush_netbios_name function
 230          */
 231         gencache_iterate(flush_netbios_name, NULL, "NBT/*");
 232         DEBUG(5, ("Namecache flushed\n"));
 233 }
 234
 235 /* Construct a name status record key. */
 236
 237 static char *namecache_status_record_key(const char *name,
 238                                 int name_type1,
 239                                 int name_type2,
 240                                 const struct sockaddr_storage *keyip)
 241 {
 242         char addr[INET6_ADDRSTRLEN];
 243         char *keystr = NULL;
 244
 245         print_sockaddr(addr, sizeof(addr), keyip);
 246         asprintf_strupper_m(&keystr, "NBT/%s#%02X.%02X.%s", name,
 247                             name_type1, name_type2, addr);
 248         return keystr;
 249 }
 250
 251 /* Store a name status record. */
 252
 253 bool namecache_status_store(const char *keyname, int keyname_type,
 254                 int name_type, const struct sockaddr_storage *keyip,
 255                 const char *srvname)
 256 {
 257         char *key;
 258         time_t expiry;
 259         bool ret;
 260
 261         key = namecache_status_record_key(keyname, keyname_type,
 262                         name_type, keyip);
 263         if (!key)
 264                 return False;
 265
 266         expiry = time(NULL) + lp_name_cache_timeout();
 267         ret = gencache_set(key, srvname, expiry);
 268
 269         if (ret) {
 270                 DEBUG(5, ("namecache_status_store: entry %s -> %s\n",
 271                                         key, srvname ));
 272         } else {
 273                 DEBUG(5, ("namecache_status_store: entry %s store failed.\n",
 274                                         key ));
 275         }
 276
 277         SAFE_FREE(key);
 278         return ret;
 279 }
 280
 281 /* Fetch a name status record. */
 282
 283 bool namecache_status_fetch(const char *keyname,
 284                                 int keyname_type,
 285                                 int name_type,
 286                                 const struct sockaddr_storage *keyip,
 287                                 char *srvname_out)
 288 {
 289         char *key = NULL;
 290         char *value = NULL;
 291         time_t timeout;
 292
 293         key = namecache_status_record_key(keyname, keyname_type,
 294                         name_type, keyip);
 295         if (!key)
 296                 return False;
 297
 298         if (!gencache_get(key, talloc_tos(), &value, &timeout)) {
 299                 DEBUG(5, ("namecache_status_fetch: no entry for %s found.\n",
 300                                         key));
 301                 SAFE_FREE(key);
 302                 return False;
 303         } else {
 304                 DEBUG(5, ("namecache_status_fetch: key %s -> %s\n",
 305                                         key, value ));
 306         }
 307
 308         strlcpy(srvname_out, value, 16);
 309         SAFE_FREE(key);
 310         TALLOC_FREE(value);
 311         return True;
 312 }