source3/lib/wins_srv.c

   1 /*
   2    Unix SMB/Netbios implementation.
   3    Version 2.
   4    Samba utility functions
   5    Copyright (C) Andrew Tridgell 1992-1998
   6    Copyright (C) Christopher R. Hertel 2000
   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 /* -------------------------------------------------------------------------- **
  26  * Discussion...
  27  *
  28  * This module implements WINS failover.
  29  *
  30  * Microsoft's WINS servers provide a feature called WINS replication,
  31  * which synchronises the WINS name databases between two or more servers.
  32  * This means that the two servers can be used interchangably (more or
  33  * less). WINS replication is particularly useful if you are trying to
  34  * synchronise the WINS namespace between servers in remote locations, or
  35  * if your WINS servers tend to crash a lot.
  36  *
  37  * WINS failover allows the client to 'switch' to a different WINS server
  38  * if the current WINS server mysteriously disappears.  On Windows
  39  * systems, this is typically represented as 'primary' and 'secondary'
  40  * WINS servers.
  41  *
  42  * Failover only works if the WINS servers are synced.  If they are not,
  43  * then
  44  *   a) if the primary WINS server never fails the client will never 'see'
  45  *      the secondary (or tertiary or...) WINS server name space.
  46  *   b) if the primary *does* fail, the client will be entering an
  47  *      unfamiliar namespace.  The client itself will not be registered in
  48  *      that namespace and any names which match names in the previous
  49  *      space will likely resolve to different host IP addresses.
  50  *
  51  * One key thing to remember regarding WINS failover is that Samba does
  52  * not (yet) implement WINS replication.  For those interested, sniff port
  53  * 42 (TCP? UDP? ...dunno off hand) and see what two MS WINS servers do.
  54  *
  55  * At this stage, only failover is implemented.  The next thing is to add
  56  * support for multi-WINS server registration and query (multi-membership).
  57  *
  58  * Multi-membership is a little wierd.  The idea is that the client can
  59  * register itself with multiple non-replicated WINS servers, and query
  60  * all of those servers (in a prescribed sequence) to resolve a name.
  61  *
  62  * The implications of multi-membership are not quite clear.  Worth
  63  * trying, I suppose.  Changes will be needed in the name query and
  64  * registration code to accomodate this feature.  Also, there will need to
  65  * be some sort of syntax extension for the 'wins server' parameter in
  66  * smb.conf.  I'm thinking that a colon could be used as a separator.
  67  *
  68  * Of course, for each WINS namespace there might be multiple, synced WINS
  69  * servers.  The change to this module would likely be the addition of a
  70  * linked list of linked lists.
  71  *
  72  * crh@samba.org
  73  */
  74
  75 /* -------------------------------------------------------------------------- **
  76  * Defines...
  77  *
  78  *   NECROMANCYCLE - The dead server retry period, in seconds.  When a WINS
  79  *                   server is declared dead, wait this many seconds before
  80  *                   attempting to communicate with it.
  81  */
  82
  83 #define NECROMANCYCLE 600   /* 600 seconds == 10 minutes. */
  84
  85 /* -------------------------------------------------------------------------- **
  86  * Typedefs...
  87  */
  88
  89 typedef struct
  90   {
  91   ubi_slNode     node;      /* Linked list node structure.                  */
  92   time_t         mourning;  /* If > current time then server is dead, Jim.  */
  93   char          *server;    /* DNS name or IP of NBNS server to query.      */
  94   struct in_addr ip_addr;   /* Cache translated IP.                         */
  95   } list_entry;
  96
  97 /* -------------------------------------------------------------------------- **
  98  * Private, static variables.
  99  */
 100
 101 static ubi_slNewList( wins_srv_list );
 102
 103 /* -------------------------------------------------------------------------- **
 104  * Functions...
 105  */
 106
 107
 108 BOOL wins_srv_load_list( char *src )
 109   /* ------------------------------------------------------------------------ **
 110    * Create or recreate the linked list of failover WINS servers.
 111    *
 112    *  Input:  src - String of DNS names and/or IP addresses delimited by the
 113    *                characters listed in LIST_SEP (see include/local.h).
 114    *
 115    *  Output: True if at least one name or IP could be parsed out of the
 116    *          list, else False.
 117    *
 118    *  Notes:  There is no syntax checking done on the names or IPs.  We do
 119    *          check to see if the field is an IP, in which case we copy it
 120    *          to the ip_addr field of the entry.  Don't bother to to a host
 121    *          name lookup on all names now.  They're done as needed in
 122    *          wins_srv_ip().
 123    * ------------------------------------------------------------------------ **
 124    */
 125   {
 126   list_entry   *entry;
 127   char         *p = src;
 128   pstring       wins_id_bufr;
 129   unsigned long count;
 130
 131   /* Empty the list. */
 132   while( NULL != (entry =(list_entry *)ubi_slRemHead( wins_srv_list )) )
 133     {
 134     if( entry->server )
 135       free( entry->server );
 136     free( entry );
 137     }
 138   (void)ubi_slInitList( wins_srv_list );  /* shouldn't be needed */
 139
 140   /* Parse out the DNS names or IP addresses of the WINS servers. */
 141   DEBUG( 4, ("wins_srv_load_list(): Building WINS server list:\n") );
 142   while( next_token( &p, wins_id_bufr, LIST_SEP, sizeof( wins_id_bufr ) ) )
 143     {
 144     entry = (list_entry *)malloc( sizeof( list_entry ) );
 145     if( NULL == entry )
 146       {
 147       DEBUG( 0, ("wins_srv_load_list(): malloc(list_entry) failed.\n") );
 148       }
 149     else
 150       {
 151       entry->mourning = 0;
 152       /* Create a copy of the server name and store it in the list. */
 153       if( NULL == (entry->server = strdup( wins_id_bufr )) )
 154         {
 155         free( entry );
 156         DEBUG( 0,
 157           ("wins_srv_load_list(): strdup(\"%s\") failed.\n", wins_id_bufr) );
 158         }
 159       else
 160         {
 161         /* Add server to list.
 162          * If the server name was actually an IP address we will store that
 163          * too.  It it was a DNS name, we will wait until we need to use
 164          * the WINS server before doing the DNS lookup.  Since this may be
 165          * a list, and since we will reload the list whenever smb.conf is
 166          * reloaded, there's no point in trying to look up names until we
 167          * need them.  ...of course, once we do the lookup we will cache
 168          * the result.  See wins_srv_ip().
 169          */
 170         if( is_ipaddress( wins_id_bufr ) )
 171           entry->ip_addr = *interpret_addr2( wins_id_bufr );
 172         else
 173           entry->ip_addr = *interpret_addr2( "0.0.0.0" );
 174         (void)ubi_slAddTail( wins_srv_list, entry );
 175         DEBUGADD( 4, ("%s,\n", wins_id_bufr) );
 176         }
 177       }
 178     }
 179
 180   count = ubi_slCount( wins_srv_list );
 181   DEBUGADD( 4,
 182     ( "%d WINS server%s listed.\n", (int)count, (1==count)?"":"s" ) );
 183
 184   return( (count > 0) ? True : False );
 185   } /* wins_srv_load_list */
 186
 187
 188 struct in_addr wins_srv_ip( void )
 189   /* ------------------------------------------------------------------------ **
 190    * Return the IP address of an NBNS (WINS) server thought to be active.
 191    *
 192    *  Input:  none.
 193    *
 194    *  Output: An IP address in struct in_addr form.
 195    *
 196    *  Notes:  This function will return the IP address of the first available
 197    *          NBNS (WINS) server.  The order of the list is determined in
 198    *          smb.conf.  If all of the WINS servers have been marked 'dead'
 199    *          then the zero IP (0.0.0.0) is returned.  The zero IP is not a
 200    *          valid Unicast address on any system.
 201    *
 202    * ------------------------------------------------------------------------ **
 203    */
 204   {
 205   time_t      now     = time(NULL);
 206   list_entry *entry   = (list_entry *)ubi_slFirst( wins_srv_list );
 207
 208   while( NULL != entry )
 209     {
 210     if( now >= entry->mourning )        /* Found a live one. */
 211       {
 212       /* If we don't have the IP, look it up. */
 213       if( zero_ip( entry->ip_addr ) )
 214         entry->ip_addr = *interpret_addr2( entry->server );
 215
 216       /* If we still don't have the IP then kill it, else return it. */
 217       if( zero_ip( entry->ip_addr ) )
 218         entry->mourning = now + NECROMANCYCLE;
 219       else
 220         return( entry->ip_addr );
 221       }
 222     entry = (list_entry *)ubi_slNext( entry );
 223     }
 224
 225   /* If there are no live entries, return the zero IP. */
 226   return( *interpret_addr2( "0.0.0.0" ) );
 227   } /* wins_srv_ip */
 228
 229
 230 char *wins_srv_name( void )
 231   /* ------------------------------------------------------------------------ **
 232    * Return the name of first live WINS server in the list.
 233    *
 234    *  Input:  none.
 235    *
 236    *  Output: A pointer to a string containing either the DNS name or IP
 237    *          address of the WINS server as given in the WINS SERVER
 238    *          parameter in smb.conf, or NULL if no (live) WINS servers are
 239    *          in the list.
 240    *
 241    *  Notes:  This function will return the name of the first available
 242    *          NBNS (WINS) server.  The order of the list is determined in
 243    *          smb.conf.  If all of the WINS servers have been marked 'dead'
 244    *          then NULL is returned.
 245    *
 246    *        - This function does not verify that the name can be mapped to
 247    *          an IP address, or that the WINS server is running.
 248    *
 249    * ------------------------------------------------------------------------ **
 250    */
 251   {
 252   time_t      now     = time(NULL);
 253   list_entry *entry   = (list_entry *)ubi_slFirst( wins_srv_list );
 254
 255   while( NULL != entry )
 256     {
 257     if( now >= entry->mourning )
 258       return( entry->server );          /* Found a live one. */
 259     entry = (list_entry *)ubi_slNext( entry );
 260     }
 261
 262   /* If there are no live entries, return NULL. */
 263   return( NULL );
 264   } /* wins_srv_name */
 265
 266
 267 void wins_srv_died( struct in_addr boothill_ip )
 268   /* ------------------------------------------------------------------------ **
 269    * Called to indicate that a specific WINS server has died.
 270    *
 271    *  Input:  boothill_ip - IP address of an NBNS (WINS) server that has
 272    *                        failed.
 273    *
 274    *  Notes:  This function marks the record 'dead' for NECROMANCYCLE
 275    *          seconds.
 276    *
 277    * ------------------------------------------------------------------------ **
 278    */
 279   {
 280   list_entry *entry;
 281
 282   if( zero_ip( boothill_ip ) )
 283     {
 284     DEBUG( 4, ("wins_srv_died(): Invalid request to mark zero IP down.\n") );
 285     return;
 286     }
 287
 288   entry = (list_entry *)ubi_slFirst( wins_srv_list );
 289   while( NULL != entry )
 290     {
 291     /* Match based on IP. */
 292     if( ip_equal( boothill_ip, entry->ip_addr ) )
 293       {
 294       entry->mourning = time(NULL) + NECROMANCYCLE;
 295       entry->ip_addr.s_addr = 0;  /* Force a re-lookup at re-birth. */
 296       DEBUG( 2, ( "wins_srv_died(): WINS server %s appears to be down.\n",
 297                   entry->server ) );
 298       return;
 299       }
 300     entry = (list_entry *)ubi_slNext( entry );
 301     }
 302
 303   if( DEBUGLVL( 1 ) )
 304     {
 305     dbgtext( "wins_srv_died(): Could not mark WINS server %s down.\n",
 306               inet_ntoa( boothill_ip ) );
 307     dbgtext( "Address not found in server list.\n" );
 308     }
 309   } /* wins_srv_died */
 310
 311
 312 unsigned long wins_srv_count( void )
 313   /* ------------------------------------------------------------------------ **
 314    * Return the total number of entries in the list, dead or alive.
 315    * ------------------------------------------------------------------------ **
 316    */
 317   {
 318   unsigned long count = ubi_slCount( wins_srv_list );
 319
 320   if( DEBUGLVL( 8 ) )
 321     {
 322     list_entry *entry = (list_entry *)ubi_slFirst( wins_srv_list );
 323     time_t      now   = time(NULL);
 324
 325     dbgtext( "wins_srv_count: WINS status: %ld servers.\n", count );
 326     while( NULL != entry )
 327       {
 328       dbgtext( "  %s <%s>: ", entry->server, inet_ntoa( entry->ip_addr ) );
 329       if( now >= entry->mourning )
 330         dbgtext( "alive\n" );
 331       else
 332         dbgtext( "dead for %d more seconds\n", (int)(entry->mourning - now) );
 333
 334       entry = (list_entry *)ubi_slNext( entry );
 335       }
 336     }
 337
 338   return( count );
 339   } /* wins_srv_count */
 340
 341 /* ========================================================================== */