source/nameserv.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-1997
   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    Module name: nameserv.c
  22
  23    Revision History:
  24
  25    14 jan 96: lkcl@pires.co.uk
  26    added multiple workgroup domain master support
  27
  28    04 jul 96: lkcl@pires.co.uk
  29    module nameserv contains name server management functions
  30 */
  31
  32 #include "includes.h"
  33
  34 extern int ClientNMB;
  35
  36 extern int DEBUGLEVEL;
  37
  38 extern pstring scope;
  39 extern pstring myname;
  40 extern fstring myworkgroup;
  41 extern struct in_addr ipzero;
  42 extern struct in_addr wins_ip;
  43
  44 extern struct subnet_record *subnetlist;
  45
  46 extern uint16 nb_type; /* samba's NetBIOS type */
  47
  48 /****************************************************************************
  49   remove an entry from the name list
  50
  51   note: the name will _always_ be removed
  52   XXXX at present, the name is removed _even_ if a WINS server says keep it.
  53
  54   ****************************************************************************/
  55 void remove_name_entry(struct subnet_record *d, char *name,int type)
  56 {
  57   /* XXXX BUG: if samba is offering WINS support, it should still broadcast
  58       a de-registration packet to the local subnet before removing the
  59       name from its local-subnet name database. */
  60
  61   int search = FIND_SELF;
  62   struct name_record n;
  63   struct name_record *n2=NULL;
  64
  65   make_nmb_name(&n.name,name,type,scope);
  66
  67   if(d == wins_subnet)
  68     search |= FIND_WINS;
  69   else
  70     search |= FIND_LOCAL;
  71
  72   if ((n2 = find_name_search(&d, &n.name, search, ipzero)))
  73   {
  74     /* check name isn't already being de-registered */
  75     if (NAME_DEREG(n2->ip_flgs[0].nb_flags))
  76       return;
  77
  78     /* mark the name as in the process of deletion. */
  79     n2->ip_flgs[0].nb_flags &= NB_DEREG;
  80   }
  81
  82   if (!n2) return;
  83
  84   /* Only remove names with non-zero death times. */
  85   if(n2->death_time == 0)
  86   {
  87     DEBUG(5,("remove_name_entry: Name %s(%d) has zero ttl - not removing.\n",
  88              name, type));
  89     return;
  90   }
  91
  92   /* remove the name immediately. even if the spec says we should
  93      first try to release them, this is too dangerous with our current
  94      name structures as otherwise we will end up replying to names we
  95      don't really own */
  96   remove_netbios_name(d,name,type,SELF,n2->ip_flgs[0].ip);
  97
  98   if (ip_equal(d->bcast_ip, wins_ip))
  99   {
 100     if (!lp_wins_support())
 101     {
 102       /* not a WINS server: we have to release them on the network */
 103       queue_netbios_pkt_wins(ClientNMB,NMB_REL,NAME_RELEASE,
 104                              name, type, 0, 0,0,NULL,NULL,
 105                              False, True, ipzero, ipzero);
 106     }
 107   }
 108   else
 109   {
 110       /* local interface: release them on the network */
 111       queue_netbios_packet(d,ClientNMB,NMB_REL,NAME_RELEASE,
 112                          name, type, 0, 0,0,NULL,NULL,
 113                          True, False, d->bcast_ip, d->bcast_ip);
 114   }
 115 }
 116
 117
 118 /****************************************************************************
 119   add an entry to the name list
 120
 121   big note: our name will _always_ be added (if there are no objections).
 122   it's just a matter of when this will be done (e.g after a time-out).
 123
 124   ****************************************************************************/
 125 void add_my_name_entry(struct subnet_record *d,char *name,int type,int nb_flags)
 126 {
 127   BOOL re_reg = False;
 128   struct nmb_name n;
 129
 130   if (!d) return;
 131
 132   /* not that it particularly matters, but if the SELF name already exists,
 133      it must be re-registered, rather than just registered */
 134
 135   make_nmb_name(&n, name, type, scope);
 136   if (find_name(d->namelist, &n, SELF))
 137         re_reg = True;
 138
 139   /* XXXX BUG: if samba is offering WINS support, it should still add the
 140      name entry to a local-subnet name database. see rfc1001.txt 15.1.1 p28
 141      regarding the point about M-nodes. */
 142
 143   if (ip_equal(d->bcast_ip, wins_ip))
 144   {
 145     if (lp_wins_support())
 146     {
 147       /* we are a WINS server. */
 148       if(lp_wins_support())
 149       {
 150         DEBUG(4,("add_my_name_entry: samba as WINS server adding: "));
 151       }
 152
 153       /* this will call add_netbios_entry() */
 154       name_register_work(d, name, type, nb_flags,0, ipzero, False);
 155     }
 156     else
 157     {
 158       DEBUG(4,("add_my_name_entry registering name %s with WINS server.\n",
 159                 name));
 160
 161       /* a time-to-live allows us to refresh this name with the WINS server. */
 162           queue_netbios_pkt_wins(ClientNMB,
 163                                  re_reg ? NMB_REG_REFRESH : NMB_REG, NAME_REGISTER,
 164                              name, type, nb_flags, GET_TTL(0),0,NULL,NULL,
 165                              False, True, ipzero, ipzero);
 166     }
 167   }
 168   else
 169   {
 170     /* broadcast the packet, but it comes from ipzero */
 171     queue_netbios_packet(d,ClientNMB,
 172          re_reg ? NMB_REG_REFRESH : NMB_REG, NAME_REGISTER,
 173          name, type, nb_flags, GET_TTL(0),0,NULL,NULL,
 174          True, False, d->bcast_ip, ipzero);
 175   }
 176 }
 177
 178
 179 /****************************************************************************
 180   add the internet group <1c> domain logon names by wins unicast and broadcast.
 181   ****************************************************************************/
 182 void add_domain_logon_names(void)
 183 {
 184         struct subnet_record *d;
 185
 186         if (!lp_domain_logons()) return;
 187
 188         for (d = FIRST_SUBNET; d; d = NEXT_SUBNET_INCLUDING_WINS(d))
 189         {
 190                 struct work_record *work = find_workgroupstruct(d, myworkgroup, True);
 191
 192                 if (work && work->log_state == LOGON_NONE)
 193                 {
 194                         struct nmb_name n;
 195                         make_nmb_name(&n,myworkgroup,0x1c,scope);
 196
 197                         if (!find_name(d->namelist, &n, FIND_SELF))
 198                         {
 199                                 /* logon servers are group names. don't expect failure */
 200
 201                                 DEBUG(0,("%s attempting to become logon server for %s %s\n",
 202                                                 timestring(), myworkgroup, inet_ntoa(d->bcast_ip)));
 203
 204                                 become_logon_server(d, work);
 205                         }
 206                 }
 207         }
 208 }
 209
 210
 211 /****************************************************************************
 212   add the <1b> domain master names by broadcast.
 213   ****************************************************************************/
 214 void add_domain_master_bcast(void)
 215 {
 216         struct subnet_record *d;
 217
 218         if (!lp_domain_master()) return;
 219
 220         for (d = FIRST_SUBNET; d; d = NEXT_SUBNET_EXCLUDING_WINS(d))
 221         {
 222                 struct work_record *work = find_workgroupstruct(d, myworkgroup, True);
 223
 224                 if (work && work->dom_state == DOMAIN_NONE)
 225                 {
 226                         struct nmb_name n;
 227                         make_nmb_name(&n,myworkgroup,0x1b,scope);
 228
 229                         if (!find_name(d->namelist, &n, FIND_SELF))
 230                         {
 231                                 DEBUG(0,("%s add_domain_names: attempting to become domain \
 232 master browser on workgroup %s %s\n",
 233                                 timestring(), myworkgroup, inet_ntoa(d->bcast_ip)));
 234
 235                                 /* send out a query to establish whether there's a
 236                                    domain controller on the local subnet.  if not,
 237                                    we can become a domain controller.  it's only
 238                                    polite that we check, before claiming the
 239                                    NetBIOS name 0x1b.
 240                                 */
 241
 242                                 DEBUG(0,("add_domain_names:querying subnet %s \
 243 for domain master on workgroup %s\n",
 244                                                   inet_ntoa(d->bcast_ip), myworkgroup));
 245
 246                                 queue_netbios_packet(d,ClientNMB,NMB_QUERY,
 247                                                                          NAME_QUERY_DOMAIN,
 248                                                                          myworkgroup, 0x1b,
 249                                                                          0, 0,0,NULL,NULL,
 250                                                                          True, False,
 251                                                                          d->bcast_ip, d->bcast_ip);
 252                         }
 253                 }
 254         }
 255 }
 256
 257
 258 /****************************************************************************
 259   add the <1b> domain master name by wins unicast.
 260   ****************************************************************************/
 261 void add_domain_master_wins(void)
 262 {
 263         struct work_record *work;
 264
 265         if (!lp_domain_master() || wins_subnet == NULL) return;
 266
 267         work = find_workgroupstruct(wins_subnet, myworkgroup, True);
 268
 269         if (work && work->dom_state == DOMAIN_NONE)
 270         {
 271                 struct nmb_name n;
 272                 make_nmb_name(&n,myworkgroup,0x1b,scope);
 273
 274                 if (!find_name(wins_subnet->namelist, &n, FIND_SELF))
 275                 {
 276                         DEBUG(0,("%s add_domain_names: attempting to become domain \
 277 master browser on workgroup %s %s\n",
 278                         timestring(), myworkgroup, inet_ntoa(wins_subnet->bcast_ip)));
 279
 280                         if (lp_wins_support())
 281                         {
 282                                 /* use the wins server's capabilities (indirectly).  if
 283                                    someone has already registered the domain<1b>
 284                                    name with the WINS server, then the WINS
 285                                    server's job is to _check_ that the owner still
 286                                    wants it, before giving it away.
 287                                 */
 288
 289                                 DEBUG(1,("%s initiate become domain master for %s\n",
 290                                                   timestring(), myworkgroup));
 291
 292                                 become_domain_master(wins_subnet, work);
 293                         }
 294                         else
 295                         {
 296                                 /* send out a query to establish whether there's a
 297                                    domain controller on the WINS subnet.  if not,
 298                                    we can become a domain controller.  it's only
 299                                    polite that we check, before claiming the
 300                                    NetBIOS name 0x1b.
 301                                 */
 302
 303                                 DEBUG(0,("add_domain_names:querying WINS \
 304 for domain master on workgroup %s\n", myworkgroup));
 305
 306                                 queue_netbios_pkt_wins(ClientNMB,NMB_QUERY,
 307                                                                            NAME_QUERY_DOMAIN,
 308                                                                            myworkgroup, 0x1b,
 309                                                                            0, 0,0,NULL,NULL,
 310                                                                            False, True, ipzero, ipzero);
 311                         }
 312                 }
 313         }
 314 }
 315
 316
 317 /****************************************************************************
 318   add the domain logon server and domain master browser names
 319
 320   this code was written so that several samba servers can co-operate in
 321   sharing the task of (one server) being a domain master, and of being
 322   domain logon servers.
 323
 324   **************************************************************************/
 325 void add_domain_names(time_t t)
 326 {
 327         static time_t lastrun = 0;
 328
 329         if (lastrun != 0 && t < lastrun + CHECK_TIME_ADD_DOM_NAMES * 60) return;
 330         lastrun = t;
 331
 332         /* do the "internet group" - <1c> names */
 333         add_domain_logon_names();
 334
 335         /* do the domain master names */
 336         if (wins_subnet != NULL)
 337         {
 338                 /* if the registration of the <1b> name is successful, then
 339                    add_domain_master_bcast() will be called.  this will
 340                    result in domain logon services being gracefully provided,
 341                    as opposed to the aggressive nature of 1.9.16p2 to 1.9.16p11.
 342
 343                    which, due to a bug in namelogon.c from 1.9.16p2 to 1.9.16p11
 344                    cannot _provide_ domain master / domain logon services!!!
 345
 346                  */
 347                 add_domain_master_wins();
 348         }
 349         else
 350         {
 351                 add_domain_master_bcast();
 352         }
 353 }
 354
 355 /****************************************************************************
 356   add the magic samba names, useful for finding samba servers
 357   **************************************************************************/
 358 void add_my_names(void)
 359 {
 360   struct subnet_record *d;
 361   /* each subnet entry, including WINS pseudo-subnet, has SELF names */
 362
 363   /* XXXX if there was a transport layer added to samba (ipx/spx etc) then
 364      there would be yet _another_ for-loop, this time on the transport type
 365    */
 366
 367   for (d = FIRST_SUBNET; d; d = NEXT_SUBNET_INCLUDING_WINS(d))
 368   {
 369     BOOL wins = (lp_wins_support() && (d == wins_subnet));
 370
 371     add_my_name_entry(d, myname,0x20,nb_type|NB_ACTIVE);
 372     add_my_name_entry(d, myname,0x03,nb_type|NB_ACTIVE);
 373     add_my_name_entry(d, myname,0x00,nb_type|NB_ACTIVE);
 374
 375     /* these names are added permanently (ttl of zero) and will NOT be
 376        refreshed with the WINS server  */
 377     add_netbios_entry(d,"*",0x0,nb_type|NB_ACTIVE,0,SELF,d->myip,False,wins);
 378     add_netbios_entry(d,"*",0x20,nb_type|NB_ACTIVE,0,SELF,d->myip,False,wins);
 379     add_netbios_entry(d,"__SAMBA__",0x20,nb_type|NB_ACTIVE,0,SELF,d->myip,False,wins);
 380     add_netbios_entry(d,"__SAMBA__",0x00,nb_type|NB_ACTIVE,0,SELF,d->myip,False,wins);
 381   }
 382 }
 383
 384
 385 /****************************************************************************
 386   remove all the samba names... from a WINS server if necessary.
 387   **************************************************************************/
 388 void remove_my_names()
 389 {
 390         struct subnet_record *d;
 391
 392         for (d = FIRST_SUBNET; d; d = NEXT_SUBNET_INCLUDING_WINS(d))
 393         {
 394                 struct name_record *n, *next;
 395
 396                 for (n = d->namelist; n; n = next)
 397                 {
 398                         next = n->next;
 399                         if (n->source == SELF)
 400                         {
 401                                 /* get all SELF names removed from the WINS server's database */
 402                                 /* XXXX note: problem occurs if this removes the wrong one! */
 403
 404                                 remove_name_entry(d,n->name.name, n->name.name_type);
 405                         }
 406                 }
 407         }
 408 }
 409
 410
 411 /*******************************************************************
 412   refresh my own names
 413   ******************************************************************/
 414 void refresh_my_names(time_t t)
 415 {
 416   struct subnet_record *d;
 417
 418   for (d = FIRST_SUBNET; d; d = NEXT_SUBNET_INCLUDING_WINS(d))
 419   {
 420     struct name_record *n;
 421
 422     for (n = d->namelist; n; n = n->next)
 423     {
 424       /* each SELF name has an individual time to be refreshed */
 425       if (n->source == SELF && n->refresh_time < t &&
 426           n->death_time != 0)
 427       {
 428         add_my_name_entry(d,n->name.name,n->name.name_type,
 429                           n->ip_flgs[0].nb_flags);
 430         /* they get a new lease on life :-) */
 431         n->death_time += GET_TTL(0);
 432         n->refresh_time += GET_TTL(0);
 433       }
 434     }
 435   }
 436 }
 437
 438
 439 /*******************************************************************
 440   queries names occasionally. an over-cautious, non-trusting WINS server!
 441
 442   this function has been added because nmbd could be restarted. it
 443   is generally a good idea to check all the names that have been
 444   reloaded from file.
 445
 446   XXXX which names to poll and which not can be refined at a later date.
 447   ******************************************************************/
 448 void query_refresh_names(time_t t)
 449 {
 450         struct name_record *n;
 451         struct subnet_record *d = wins_subnet;
 452
 453         static time_t lasttime = 0;
 454
 455         int count = 0;
 456         int name_refresh_time = NAME_POLL_REFRESH_TIME;
 457         int max_count = name_refresh_time * 2 / NAME_POLL_INTERVAL;
 458         if (max_count > 10) max_count = 10;
 459
 460         name_refresh_time = NAME_POLL_INTERVAL * max_count / 2;
 461
 462         /* if (!lp_poll_wins()) return; polling of registered names allowed */
 463
 464         if (!d) return;
 465
 466     if (!lasttime) lasttime = t;
 467         if (t - lasttime < NAME_POLL_INTERVAL) return;
 468
 469     lasttime = time(NULL);
 470
 471         for (n = d->namelist; n; n = n->next)
 472         {
 473                 /* only do unique, registered names */
 474
 475                 if (n->source != REGISTER) continue;
 476                 if (!NAME_GROUP(n->ip_flgs[0].nb_flags)) continue;
 477
 478                 if (n->refresh_time < t)
 479                 {
 480                   DEBUG(3,("Polling name %s\n", namestr(&n->name)));
 481
 482           queue_netbios_packet(d,ClientNMB,NMB_QUERY,NAME_QUERY_CONFIRM,
 483                                 n->name.name, n->name.name_type,
 484                                 0,0,0,NULL,NULL,
 485                                 False,False,n->ip_flgs[0].ip,n->ip_flgs[0].ip);
 486                   count++;
 487                 }
 488
 489                 if (count >= max_count)
 490                 {
 491                         /* don't do too many of these at once, but do enough to
 492                            cover everyone in the list */
 493                         return;
 494                 }
 495
 496                 /* this name will be checked on again, if it's not removed */
 497                 n->refresh_time += name_refresh_time;
 498         }
 499 }
 500