source/lib/wins_srv.c

   1 /*
   2    Unix SMB/CIFS implementation.
   3    Samba wins server helper functions
   4    Copyright (C) Andrew Tridgell 1992-2002
   5    Copyright (C) Christopher R. Hertel 2000
   6    Copyright (C) Tim Potter 2003
   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 3 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, see <http://www.gnu.org/licenses/>.
  20 */
  21
  22 #include "includes.h"
  23
  24 extern struct in_addr loopback_ip;
  25
  26 /*
  27   This is pretty much a complete rewrite of the earlier code. The main
  28   aim of the rewrite is to add support for having multiple wins server
  29   lists, so Samba can register with multiple groups of wins servers
  30   and each group has a failover list of wins servers.
  31
  32   Central to the way it all works is the idea of a wins server
  33   'tag'. A wins tag is a label for a group of wins servers. For
  34   example if you use
  35
  36       wins server = fred:192.168.2.10 mary:192.168.3.199 fred:192.168.2.61
  37
  38   then you would have two groups of wins servers, one tagged with the
  39   name 'fred' and the other with the name 'mary'. I would usually
  40   recommend using interface names instead of 'fred' and 'mary' but
  41   they can be any alpha string.
  42
  43   Now, how does it all work. Well, nmbd needs to register each of its
  44   IPs with each of its names once with each group of wins servers. So
  45   it tries registering with the first one mentioned in the list, then
  46   if that fails it marks that WINS server dead and moves onto the next
  47   one.
  48
  49   In the client code things are a bit different. As each of the groups
  50   of wins servers is a separate name space we need to try each of the
  51   groups until we either succeed or we run out of wins servers to
  52   try. If we get a negative response from a wins server then that
  53   means the name doesn't exist in that group, so we give up on that
  54   group and move to the next group. If we don't get a response at all
  55   then maybe the wins server is down, in which case we need to
  56   failover to the next one for that group.
  57
  58   confused yet? (tridge)
  59 */
  60
  61 /* how long a server is marked dead for */
  62 #define DEATH_TIME 600
  63
  64 /* The list of dead wins servers is stored in gencache.tdb.  Each server is
  65    marked dead from the point of view of a given source address. We keep a
  66    separate dead list for each src address to cope with multiple interfaces
  67    that are not routable to each other.
  68   */
  69
  70 #define WINS_SRV_FMT "WINS_SRV_DEAD/%s,%s" /* wins_ip,src_ip */
  71
  72 static char *wins_srv_keystr(struct in_addr wins_ip, struct in_addr src_ip)
  73 {
  74         char *keystr = NULL, *wins_ip_addr = NULL, *src_ip_addr = NULL;
  75
  76         wins_ip_addr = SMB_STRDUP(inet_ntoa(wins_ip));
  77         src_ip_addr = SMB_STRDUP(inet_ntoa(src_ip));
  78
  79         if ( !wins_ip_addr || !src_ip_addr ) {
  80                 DEBUG(0,("wins_srv_keystr: malloc error\n"));
  81                 goto done;
  82         }
  83
  84         if (asprintf(&keystr, WINS_SRV_FMT, wins_ip_addr, src_ip_addr) == -1) {
  85                 DEBUG(0, (": ns_srv_keystr: malloc error for key string\n"));
  86         }
  87
  88 done:
  89         SAFE_FREE(wins_ip_addr);
  90         SAFE_FREE(src_ip_addr);
  91
  92         return keystr;
  93 }
  94
  95 /*
  96   see if an ip is on the dead list
  97 */
  98
  99 BOOL wins_srv_is_dead(struct in_addr wins_ip, struct in_addr src_ip)
 100 {
 101         char *keystr = wins_srv_keystr(wins_ip, src_ip);
 102         BOOL result;
 103
 104         /* If the key exists then the WINS server has been marked as dead */
 105
 106         result = gencache_get(keystr, NULL, NULL);
 107         SAFE_FREE(keystr);
 108
 109         DEBUG(4, ("wins_srv_is_dead: %s is %s\n", inet_ntoa(wins_ip),
 110                   result ? "dead" : "alive"));
 111
 112         return result;
 113 }
 114
 115
 116 /*
 117   mark a wins server as being alive (for the moment)
 118 */
 119 void wins_srv_alive(struct in_addr wins_ip, struct in_addr src_ip)
 120 {
 121         char *keystr = wins_srv_keystr(wins_ip, src_ip);
 122
 123         gencache_del(keystr);
 124         SAFE_FREE(keystr);
 125
 126         DEBUG(4, ("wins_srv_alive: marking wins server %s alive\n",
 127                   inet_ntoa(wins_ip)));
 128 }
 129
 130 /*
 131   mark a wins server as temporarily dead
 132 */
 133 void wins_srv_died(struct in_addr wins_ip, struct in_addr src_ip)
 134 {
 135         char *keystr;
 136
 137         if (is_zero_ip(wins_ip) || wins_srv_is_dead(wins_ip, src_ip))
 138                 return;
 139
 140         keystr = wins_srv_keystr(wins_ip, src_ip);
 141
 142         gencache_set(keystr, "DOWN", time(NULL) + DEATH_TIME);
 143
 144         SAFE_FREE(keystr);
 145
 146         DEBUG(4,("Marking wins server %s dead for %u seconds from source %s\n",
 147                  inet_ntoa(wins_ip), DEATH_TIME, inet_ntoa(src_ip)));
 148 }
 149
 150 /*
 151   return the total number of wins servers, dead or not
 152 */
 153 unsigned wins_srv_count(void)
 154 {
 155         const char **list;
 156         int count = 0;
 157
 158         if (lp_wins_support()) {
 159                 /* simple - just talk to ourselves */
 160                 return 1;
 161         }
 162
 163         list = lp_wins_server_list();
 164         for (count=0; list && list[count]; count++)
 165                 /* nop */ ;
 166
 167         return count;
 168 }
 169
 170 /* an internal convenience structure for an IP with a short string tag
 171    attached */
 172 struct tagged_ip {
 173         fstring tag;
 174         struct in_addr ip;
 175 };
 176
 177 /*
 178   parse an IP string that might be in tagged format
 179   the result is a tagged_ip structure containing the tag
 180   and the ip in in_addr format. If there is no tag then
 181   use the tag '*'
 182 */
 183 static void parse_ip(struct tagged_ip *ip, const char *str)
 184 {
 185         char *s = strchr(str, ':');
 186         if (!s) {
 187                 fstrcpy(ip->tag, "*");
 188                 ip->ip = *interpret_addr2(str);
 189                 return;
 190         }
 191
 192         ip->ip = *interpret_addr2(s+1);
 193         fstrcpy(ip->tag, str);
 194         s = strchr(ip->tag, ':');
 195         if (s) *s = 0;
 196 }
 197
 198
 199
 200 /*
 201   return the list of wins server tags. A 'tag' is used to distinguish
 202   wins server as either belonging to the same name space or a separate
 203   name space. Usually you would setup your 'wins server' option to
 204   list one or more wins server per interface and use the interface
 205   name as your tag, but you are free to use any tag you like.
 206 */
 207 char **wins_srv_tags(void)
 208 {
 209         char **ret = NULL;
 210         int count=0, i, j;
 211         const char **list;
 212
 213         if (lp_wins_support()) {
 214                 /* give the caller something to chew on. This makes
 215                    the rest of the logic simpler (ie. less special cases) */
 216                 ret = SMB_MALLOC_ARRAY(char *, 2);
 217                 if (!ret) return NULL;
 218                 ret[0] = SMB_STRDUP("*");
 219                 ret[1] = NULL;
 220                 return ret;
 221         }
 222
 223         list = lp_wins_server_list();
 224         if (!list)
 225                 return NULL;
 226
 227         /* yes, this is O(n^2) but n is very small */
 228         for (i=0;list[i];i++) {
 229                 struct tagged_ip t_ip;
 230
 231                 parse_ip(&t_ip, list[i]);
 232
 233                 /* see if we already have it */
 234                 for (j=0;j<count;j++) {
 235                         if (strcmp(ret[j], t_ip.tag) == 0) {
 236                                 break;
 237                         }
 238                 }
 239
 240                 if (j != count) {
 241                         /* we already have it. Move along */
 242                         continue;
 243                 }
 244
 245                 /* add it to the list */
 246                 ret = SMB_REALLOC_ARRAY(ret, char *, count+2);
 247                 if (!ret) {
 248                         return NULL;
 249                 }
 250                 ret[count] = SMB_STRDUP(t_ip.tag);
 251                 if (!ret[count]) break;
 252                 count++;
 253         }
 254
 255         if (count) {
 256                 /* make sure we null terminate */
 257                 ret[count] = NULL;
 258         }
 259
 260         return ret;
 261 }
 262
 263 /* free a list of wins server tags given by wins_srv_tags */
 264 void wins_srv_tags_free(char **list)
 265 {
 266         int i;
 267         if (!list) return;
 268         for (i=0; list[i]; i++) {
 269                 free(list[i]);
 270         }
 271         free(list);
 272 }
 273
 274
 275 /*
 276   return the IP of the currently active wins server for the given tag,
 277   or the zero IP otherwise
 278 */
 279 struct in_addr wins_srv_ip_tag(const char *tag, struct in_addr src_ip)
 280 {
 281         const char **list;
 282         int i;
 283         struct tagged_ip t_ip;
 284
 285         /* if we are a wins server then we always just talk to ourselves */
 286         if (lp_wins_support()) {
 287                 return loopback_ip;
 288         }
 289
 290         list = lp_wins_server_list();
 291         if (!list || !list[0]) {
 292                 struct in_addr ip;
 293                 zero_ip(&ip);
 294                 return ip;
 295         }
 296
 297         /* find the first live one for this tag */
 298         for (i=0; list[i]; i++) {
 299                 parse_ip(&t_ip, list[i]);
 300                 if (strcmp(tag, t_ip.tag) != 0) {
 301                         /* not for the right tag. Move along */
 302                         continue;
 303                 }
 304                 if (!wins_srv_is_dead(t_ip.ip, src_ip)) {
 305                         fstring src_name;
 306                         fstrcpy(src_name, inet_ntoa(src_ip));
 307                         DEBUG(6,("Current wins server for tag '%s' with source %s is %s\n",
 308                                  tag,
 309                                  src_name,
 310                                  inet_ntoa(t_ip.ip)));
 311                         return t_ip.ip;
 312                 }
 313         }
 314
 315         /* they're all dead - try the first one until they revive */
 316         for (i=0; list[i]; i++) {
 317                 parse_ip(&t_ip, list[i]);
 318                 if (strcmp(tag, t_ip.tag) != 0) {
 319                         continue;
 320                 }
 321                 return t_ip.ip;
 322         }
 323
 324         /* this can't happen?? */
 325         zero_ip(&t_ip.ip);
 326         return t_ip.ip;
 327 }
 328
 329
 330 /*
 331   return a count of the number of IPs for a particular tag, including
 332   dead ones
 333 */
 334 unsigned wins_srv_count_tag(const char *tag)
 335 {
 336         const char **list;
 337         int i, count=0;
 338
 339         /* if we are a wins server then we always just talk to ourselves */
 340         if (lp_wins_support()) {
 341                 return 1;
 342         }
 343
 344         list = lp_wins_server_list();
 345         if (!list || !list[0]) {
 346                 return 0;
 347         }
 348
 349         /* find the first live one for this tag */
 350         for (i=0; list[i]; i++) {
 351                 struct tagged_ip t_ip;
 352                 parse_ip(&t_ip, list[i]);
 353                 if (strcmp(tag, t_ip.tag) == 0) {
 354                         count++;
 355                 }
 356         }
 357
 358         return count;
 359 }