source3/libsmb/conncache.c

   1 /*
   2    Unix SMB/CIFS implementation.
   3
   4    Winbind daemon connection manager
   5
   6    Copyright (C) Tim Potter             2001
   7    Copyright (C) Andrew Bartlett        2002
   8    Copyright (C) Gerald (Jerry) Carter  2003
   9    Copyright (C) Marc VanHeyningen      2008
  10
  11    This program is free software; you can redistribute it and/or modify
  12    it under the terms of the GNU General Public License as published by
  13    the Free Software Foundation; either version 3 of the License, or
  14    (at your option) any later version.
  15
  16    This program is distributed in the hope that it will be useful,
  17    but WITHOUT ANY WARRANTY; without even the implied warranty of
  18    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  19    GNU General Public License for more details.
  20
  21    You should have received a copy of the GNU General Public License
  22    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  23 */
  24
  25
  26 #include "includes.h"
  27
  28 /**
  29  * @file
  30  * Negative connection cache implemented in terms of gencache API
  31  *
  32  * The negative connection cache stores names of servers which have
  33  * been unresponsive so that we don't waste time repeatedly trying
  34  * to contact them.  It used to use an in-memory linked list, but
  35  * this limited its utility to a single process
  36  */
  37
  38
  39 /**
  40  * prefix used for all entries put into the general cache
  41  */
  42 static const char NEGATIVE_CONN_CACHE_PREFIX[] = "NEG_CONN_CACHE";
  43
  44 /**
  45  * Marshalls the domain and server name into the key for the gencache
  46  * record
  47  *
  48  * @param[in] domain required
  49  * @param[in] server may be a FQDN or an IP address
  50  * @return the resulting string, which the caller is responsible for
  51  *   SAFE_FREE()ing
  52  * @retval NULL returned on error
  53  */
  54 static char *negative_conn_cache_keystr(const char *domain, const char *server)
  55 {
  56         const char NEGATIVE_CONN_CACHE_KEY_FMT[] = "%s/%s,%s";
  57         char *keystr = NULL;
  58
  59         SMB_ASSERT(domain != NULL);
  60         if (server == NULL)
  61                 server = "";
  62
  63         keystr = talloc_asprintf(talloc_tos(),NEGATIVE_CONN_CACHE_KEY_FMT,
  64                                  NEGATIVE_CONN_CACHE_PREFIX, domain, server);
  65         if (keystr == NULL) {
  66                 DEBUG(0, ("negative_conn_cache_keystr: malloc error\n"));
  67         }
  68
  69         return keystr;
  70 }
  71
  72 /**
  73  * Marshalls the NT status into a printable value field for the gencache
  74  * record
  75  *
  76  * @param[in] status
  77  * @return the resulting string, which the caller is responsible for
  78  *   SAFE_FREE()ing
  79  * @retval NULL returned on error
  80  */
  81 static char *negative_conn_cache_valuestr(NTSTATUS status)
  82 {
  83         char *valuestr = NULL;
  84
  85         valuestr = talloc_asprintf(talloc_tos(), "%x", NT_STATUS_V(status));
  86         if (valuestr == NULL) {
  87                 DEBUG(0, ("negative_conn_cache_valuestr: malloc error\n"));
  88         }
  89
  90         return valuestr;
  91 }
  92
  93 /**
  94  * Un-marshalls the NT status from a printable field for the gencache
  95  * record
  96  *
  97  * @param[in] value  The value field from the record
  98  * @return the decoded NT status
  99  * @retval NT_STATUS_OK returned on error
 100  */
 101 static NTSTATUS negative_conn_cache_valuedecode(const char *value)
 102 {
 103         NTSTATUS result = NT_STATUS_OK;
 104
 105         SMB_ASSERT(value != NULL);
 106         if (sscanf(value, "%x", &(NT_STATUS_V(result))) != 1)
 107                 DEBUG(0, ("negative_conn_cache_valuestr: unable to parse "
 108                           "value field '%s'\n", value));
 109         return result;
 110 }
 111
 112 /**
 113  * Function passed to gencache_iterate to remove any matching items
 114  * from the list
 115  *
 116  * @param[in] key Key to the record found and to be deleted
 117  * @param[in] value Value to the record (ignored)
 118  * @param[in] timeout Timeout remaining for the record (ignored)
 119  * @param[in] dptr Handle for passing additional data (ignored)
 120  */
 121 static void delete_matches(const char *key, const char *value,
 122     time_t timeout, void *dptr)
 123 {
 124         gencache_del(key);
 125 }
 126
 127
 128 /**
 129  * Checks for a given domain/server record in the negative cache
 130  *
 131  * @param[in] domain
 132  * @param[in] server may be either a FQDN or an IP address
 133  * @return The cached failure status
 134  * @retval NT_STATUS_OK returned if no record is found or an error occurs
 135  */
 136 NTSTATUS check_negative_conn_cache( const char *domain, const char *server)
 137 {
 138         NTSTATUS result = NT_STATUS_OK;
 139         char *key = NULL;
 140         char *value = NULL;
 141
 142         key = negative_conn_cache_keystr(domain, server);
 143         if (key == NULL)
 144                 goto done;
 145
 146         if (gencache_get(key, &value, (time_t *) NULL))
 147                 result = negative_conn_cache_valuedecode(value);
 148  done:
 149         DEBUG(9,("check_negative_conn_cache returning result %d for domain %s "
 150                   "server %s\n", NT_STATUS_V(result), domain, server));
 151         TALLOC_FREE(key);
 152         SAFE_FREE(value);
 153         return result;
 154 }
 155
 156 /**
 157  * Delete any negative cache entry for the given domain/server
 158  *
 159  * @param[in] domain
 160  * @param[in] server may be either a FQDN or an IP address
 161  */
 162 void delete_negative_conn_cache(const char *domain, const char *server)
 163 {
 164         char *key = NULL;
 165
 166         key = negative_conn_cache_keystr(domain, server);
 167         if (key == NULL)
 168                 goto done;
 169
 170         gencache_del(key);
 171         DEBUG(9,("delete_negative_conn_cache removing domain %s server %s\n",
 172                   domain, server));
 173  done:
 174         TALLOC_FREE(key);
 175         return;
 176 }
 177
 178
 179 /**
 180  * Add an entry to the failed connection cache
 181  *
 182  * @param[in] domain
 183  * @param[in] server may be a FQDN or an IP addr in printable form
 184  * @param[in] result error to cache; must not be NT_STATUS_OK
 185  */
 186 void add_failed_connection_entry(const char *domain, const char *server,
 187     NTSTATUS result)
 188 {
 189         char *key = NULL;
 190         char *value = NULL;
 191
 192         SMB_ASSERT(!NT_STATUS_IS_OK(result));
 193
 194         key = negative_conn_cache_keystr(domain, server);
 195         if (key == NULL) {
 196                 DEBUG(0, ("add_failed_connection_entry: key creation error\n"));
 197                 goto done;
 198         }
 199
 200         value = negative_conn_cache_valuestr(result);
 201         if (value == NULL) {
 202                 DEBUG(0, ("add_failed_connection_entry: value creation error\n"));
 203                 goto done;
 204         }
 205
 206         if (gencache_set(key, value,
 207                          time((time_t *) NULL)
 208                          + FAILED_CONNECTION_CACHE_TIMEOUT))
 209                 DEBUG(9,("add_failed_connection_entry: added domain %s (%s) "
 210                           "to failed conn cache\n", domain, server ));
 211         else
 212                 DEBUG(1,("add_failed_connection_entry: failed to add "
 213                           "domain %s (%s) to failed conn cache\n",
 214                           domain, server));
 215
 216  done:
 217         TALLOC_FREE(key);
 218         TALLOC_FREE(value);
 219         return;
 220 }
 221
 222 /**
 223  * Deletes all records from the negative connection cache in all domains
 224  */
 225 void flush_negative_conn_cache( void )
 226 {
 227         flush_negative_conn_cache_for_domain("*");
 228 }
 229
 230
 231 /**
 232  * Deletes all records for a specified domain from the negative connection
 233  * cache
 234  *
 235  * @param[in] domain String to match against domain portion of keys, or "*"
 236  *  to match all domains
 237  */
 238 void flush_negative_conn_cache_for_domain(const char *domain)
 239 {
 240         char *key_pattern = NULL;
 241
 242         key_pattern = negative_conn_cache_keystr(domain,"*");
 243         if (key_pattern == NULL) {
 244                 DEBUG(0, ("flush_negative_conn_cache_for_domain: "
 245                           "key creation error\n"));
 246                 goto done;
 247         }
 248
 249         gencache_iterate(delete_matches, (void *) NULL, key_pattern);
 250         DEBUG(8, ("flush_negative_conn_cache_for_domain: flushed domain %s\n",
 251                   domain));
 252
 253  done:
 254         TALLOC_FREE(key_pattern);
 255         return;
 256 }