source/namebrowse.c

   1 /*
   2    Unix SMB/Netbios implementation.
   3    Version 1.9.
   4    NBT netbios routines and daemon - version 2
   5    Copyright (C) Andrew Tridgell 1994-1995
   6
   7    This program is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 2 of the License, or
  10    (at your option) any later version.
  11
  12    This program is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with this program; if not, write to the Free Software
  19    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  20
  21    Revision History:
  22
  23    14 jan 96: lkcl@pires.co.uk
  24    added multiple workgroup domain master support
  25
  26 */
  27
  28 #include "includes.h"
  29 #include "smb.h"
  30
  31 extern int ClientNMB;
  32
  33 extern int DEBUGLEVEL;
  34
  35 extern struct in_addr wins_ip;
  36
  37 /* this is our browse master/backup cache database */
  38 static struct browse_cache_record *browserlist = NULL;
  39
  40
  41 /***************************************************************************
  42   add a browser into the list
  43   **************************************************************************/
  44 static void add_browse_cache(struct browse_cache_record *b)
  45 {
  46   struct browse_cache_record *b2;
  47
  48   if (!browserlist)
  49     {
  50       browserlist = b;
  51       b->prev = NULL;
  52       b->next = NULL;
  53       return;
  54     }
  55
  56   for (b2 = browserlist; b2->next; b2 = b2->next) ;
  57
  58   b2->next = b;
  59   b->next = NULL;
  60   b->prev = b2;
  61 }
  62
  63
  64 /*******************************************************************
  65   remove old browse entries
  66   ******************************************************************/
  67 void expire_browse_cache(time_t t)
  68 {
  69   struct browse_cache_record *b;
  70   struct browse_cache_record *nextb;
  71
  72   /* expire old entries in the serverlist */
  73   for (b = browserlist; b; b = nextb)
  74     {
  75       if (b->synced && b->sync_time < t)
  76         {
  77           DEBUG(3,("Removing dead cached browser %s\n",b->name));
  78           nextb = b->next;
  79
  80           if (b->prev) b->prev->next = b->next;
  81           if (b->next) b->next->prev = b->prev;
  82
  83           if (browserlist == b) browserlist = b->next;
  84
  85           free(b);
  86         }
  87       else
  88         {
  89           nextb = b->next;
  90         }
  91     }
  92 }
  93
  94 /****************************************************************************
  95   add a browser entry
  96   ****************************************************************************/
  97 struct browse_cache_record *add_browser_entry(char *name, int type, char *wg,
  98                                               time_t ttl, struct in_addr ip, BOOL local)
  99 {
 100   BOOL newentry=False;
 101
 102   struct browse_cache_record *b;
 103
 104   /* search for the entry: if it's already in the cache, update that entry */
 105   for (b = browserlist; b; b = b->next)
 106     {
 107       if (ip_equal(ip,b->ip) && strequal(b->group, wg)) break;
 108     }
 109
 110   if (b && b->synced)
 111     {
 112       /* entries get left in the cache for a while. this stops sync'ing too
 113          often if the network is large */
 114       DEBUG(4, ("browser %s %s %s already sync'd at time %d\n",
 115                 b->name, b->group, inet_ntoa(b->ip), b->sync_time));
 116       return NULL;
 117     }
 118
 119   if (!b)
 120     {
 121       newentry = True;
 122       b = (struct browse_cache_record *)malloc(sizeof(*b));
 123
 124       if (!b) return(NULL);
 125
 126       bzero((char *)b,sizeof(*b));
 127     }
 128
 129   /* update the entry */
 130   ttl = time(NULL)+ttl;
 131
 132   StrnCpy(b->name ,name,sizeof(b->name )-1);
 133   StrnCpy(b->group,wg  ,sizeof(b->group)-1);
 134   strupper(b->name);
 135   strupper(b->group);
 136
 137   b->ip     = ip;
 138   b->type   = type;
 139   b->local  = local; /* local server list sync or complete sync required */
 140
 141   if (newentry || ttl < b->sync_time)
 142     b->sync_time = ttl;
 143
 144   if (newentry)
 145     {
 146       b->synced = False;
 147       add_browse_cache(b);
 148
 149       DEBUG(3,("Added cache entry %s %s(%2x) %s ttl %d\n",
 150                wg, name, type, inet_ntoa(ip),ttl));
 151     }
 152   else
 153     {
 154       DEBUG(3,("Updated cache entry %s %s(%2x) %s ttl %d\n",
 155                wg, name, type, inet_ntoa(ip),ttl));
 156     }
 157
 158   return(b);
 159 }
 160
 161
 162 /****************************************************************************
 163 find a server responsible for a workgroup, and sync browse lists
 164 **************************************************************************/
 165 static void start_sync_browse_entry(struct browse_cache_record *b)
 166 {
 167   struct subnet_record *d;
 168   struct work_record *work;
 169
 170   /* Look for the workgroup first on the local subnet. If this
 171      fails try WINS - we may need to sync with the domain master,
 172      or we may be the domain master and need to sync with subnet
 173      masters.
 174   */
 175
 176   if (!(d = find_subnet_all(b->ip))) {
 177     DEBUG(0, ("start_sync_browse_entry: failed to get a \
 178 subnet for a browse cache entry workgroup %s, server %s\n",
 179                   b->group, b->name));
 180     return;
 181   }
 182
 183   if (!(work = find_workgroupstruct(d, b->group, False))) {
 184       DEBUG(0, ("start_sync_browse_entry: failed to get a \
 185 workgroup for a browse cache entry workgroup %s, server %s\n",
 186                 b->group, b->name));
 187       return;
 188   }
 189
 190   /* only sync if we are a subnet master or domain master - but
 191      we sync if we are a master for this workgroup on *any*
 192      of our interfaces. */
 193   if (AM_MASTER(work) || AM_DOMMST(work) || AM_ANY_MASTER(work)) {
 194
 195     DEBUG(4, ("start_sync_browse_entry: Initiating %s sync with %s<0x20>, \
 196 workgroup %s\n",
 197                b->local ? "local" : "remote", b->name, b->group));
 198
 199     /* first check whether the server we intend to sync with exists. if it
 200        doesn't, the server must have died. o dear. */
 201
 202     /* see response_netbios_packet() or expire_netbios_response_entries() */
 203     /* We cheat here by using the my_comment field of the response_record
 204        struct as the workgroup name we are going to do the sync for.
 205        This is because the reply packet doesn't include the workgroup, but
 206        we need it when the reply comes back.
 207     */
 208     queue_netbios_packet(d,ClientNMB,NMB_QUERY,
 209                          b->local?NAME_QUERY_SYNC_LOCAL:NAME_QUERY_SYNC_REMOTE,
 210                          b->name,0x20,0,0,0,NULL,b->group,
 211                          False,False,b->ip,b->ip);
 212   }
 213
 214   b->synced = True;
 215 }
 216
 217
 218 /****************************************************************************
 219   search through browser list for an entry to sync with
 220   **************************************************************************/
 221 void do_browser_lists(time_t t)
 222 {
 223   struct browse_cache_record *b;
 224   static time_t last = 0;
 225
 226   if (t-last < 20)
 227    {
 228      DEBUG(9,("do_browser_lists: returning due to t(%d) - last(%d) < 20\n",
 229              t, last));
 230      return; /* don't do too many of these at once! */
 231                            /* XXXX equally this period should not be too long
 232                               the server may die in the intervening gap */
 233    }
 234   last = t;
 235
 236   /* pick any entry in the list, preferably one whose time is up */
 237   for (b = browserlist; b && b->next; b = b->next)
 238     {
 239       if (b->sync_time < t && b->synced == False) break;
 240     }
 241
 242   if (b && !b->synced)
 243   {
 244     /* sync with the selected entry then remove some dead entries */
 245     DEBUG(4,("do_browser_lists: Initiating sync with %s, workgroup %s\n",
 246               b->name, b->group));
 247     start_sync_browse_entry(b);
 248     expire_browse_cache(t - 60);
 249   }
 250   else
 251   {
 252     DEBUG(9, ("do_browser_lists: no entries to sync.\n"));
 253   }
 254
 255 }
 256