source/nmbd/nmbd_nameregister.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-1998
   6    Copyright (C) Luke Kenneth Casson Leighton 1994-1998
   7    Copyright (C) Jeremy Allison 1994-1998
   8
   9    This program is free software; you can redistribute it and/or modify
  10    it under the terms of the GNU General Public License as published by
  11    the Free Software Foundation; either version 2 of the License, or
  12    (at your option) any later version.
  13
  14    This program is distributed in the hope that it will be useful,
  15    but WITHOUT ANY WARRANTY; without even the implied warranty of
  16    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17    GNU General Public License for more details.
  18
  19    You should have received a copy of the GNU General Public License
  20    along with this program; if not, write to the Free Software
  21    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  22
  23 */
  24
  25 #include "includes.h"
  26
  27 extern int DEBUGLEVEL;
  28
  29 extern fstring global_myworkgroup;
  30
  31 /****************************************************************************
  32  Deal with a response packet when registering one of our names.
  33 ****************************************************************************/
  34
  35 static void register_name_response(struct subnet_record *subrec,
  36                        struct response_record *rrec, struct packet_struct *p)
  37 {
  38   /*
  39    * If we are registering broadcast, then getting a response is an
  40    * error - we do not have the name. If we are registering unicast,
  41    * then we expect to get a response.
  42    */
  43
  44   struct nmb_packet *nmb = &p->packet.nmb;
  45   BOOL bcast = nmb->header.nm_flags.bcast;
  46   BOOL success = True;
  47   struct nmb_name *question_name = &rrec->packet->packet.nmb.question.question_name;
  48   struct nmb_name *answer_name = &nmb->answers->rr_name;
  49   int ttl = 0;
  50   uint16 nb_flags = 0;
  51   struct in_addr registered_ip;
  52
  53   /* Sanity check. Ensure that the answer name in the incoming packet is the
  54      same as the requested name in the outgoing packet. */
  55
  56   if(!question_name || !answer_name)
  57   {
  58     DEBUG(0,("register_name_response: malformed response (%s is NULL).\n",
  59            question_name ? "question_name" : "answer_name" ));
  60     return;
  61   }
  62
  63   if(!nmb_name_equal(question_name, answer_name))
  64   {
  65     DEBUG(0,("register_name_response: Answer name %s differs from question \
  66 name %s.\n", nmb_namestr(answer_name), nmb_namestr(question_name)));
  67     return;
  68   }
  69
  70   if(bcast)
  71   {
  72     /*
  73      * Special hack to cope with old Samba nmbd's.
  74      * Earlier versions of Samba (up to 1.9.16p11) respond
  75      * to a broadcast name registration of WORKGROUP<1b> when
  76      * they should not. Hence, until these versions are gone,
  77      * we should treat such errors as success for this particular
  78      * case only. jallison@whistle.com.
  79      */
  80
  81 #if 1 /* OLD_SAMBA_SERVER_HACK */
  82     if((nmb->header.rcode == ACT_ERR) && strequal(global_myworkgroup, answer_name->name) &&
  83          (answer_name->name_type == 0x1b))
  84     {
  85       /* Pretend we did not get this. */
  86       rrec->num_msgs--;
  87
  88       DEBUG(5,("register_name_response: Ignoring broadcast response to \
  89 registration of name %s due to old Samba server bug.\n", nmb_namestr(answer_name)));
  90       return;
  91     }
  92 #endif /* OLD_SAMBA_SERVER_HACK */
  93
  94     /* Someone else has the name. Log the problem. */
  95     DEBUG(1,("register_name_response: Failed to register \
  96 name %s on subnet %s via broadcast. Error code was %d. Reject came from IP %s\n",
  97               nmb_namestr(answer_name),
  98               subrec->subnet_name, nmb->header.rcode, inet_ntoa(p->ip)));
  99     success = False;
 100   }
 101   else
 102   {
 103     /* Unicast - check to see if the response allows us to have the name. */
 104     if(nmb->header.rcode != 0)
 105     {
 106       /* Error code - we didn't get the name. */
 107       success = False;
 108
 109       DEBUG(0,("register_name_response: server at IP %s rejected our \
 110 name registration of %s with error code %d.\n", inet_ntoa(p->ip),
 111                   nmb_namestr(answer_name), nmb->header.rcode));
 112
 113     }
 114     else if(nmb->header.opcode == NMB_WACK_OPCODE)
 115     {
 116       /* WINS server is telling us to wait. Pretend we didn't get
 117          the response but don't send out any more register requests. */
 118
 119       DEBUG(5,("register_name_response: WACK from WINS server %s in registering \
 120 name %s on subnet %s.\n", inet_ntoa(p->ip), nmb_namestr(answer_name), subrec->subnet_name));
 121
 122       rrec->repeat_count = 0;
 123       /* How long we should wait for. */
 124       rrec->repeat_time = p->timestamp + nmb->answers->ttl;
 125       rrec->num_msgs--;
 126       return;
 127     }
 128     else
 129     {
 130       success = True;
 131       /* Get the data we need to pass to the success function. */
 132       nb_flags = get_nb_flags(nmb->answers->rdata);
 133       putip((char*)&registered_ip,&nmb->answers->rdata[2]);
 134       ttl = nmb->answers->ttl;
 135     }
 136   }
 137
 138   DEBUG(5,("register_name_response: %s in registering name %s on subnet %s.\n",
 139         success ? "success" : "failure", nmb_namestr(answer_name), subrec->subnet_name));
 140
 141   if(success)
 142   {
 143     /* Enter the registered name into the subnet name database before calling
 144        the success function. */
 145     standard_success_register(subrec, rrec->userdata, answer_name, nb_flags, ttl, registered_ip);
 146     if( rrec->success_fn)
 147       (*(register_name_success_function)rrec->success_fn)(subrec, rrec->userdata, answer_name, nb_flags, ttl, registered_ip);
 148   }
 149   else
 150   {
 151     if( rrec->fail_fn)
 152       (*(register_name_fail_function)rrec->fail_fn)(subrec, rrec, question_name);
 153     /* Remove the name. */
 154     standard_fail_register( subrec, rrec, question_name);
 155   }
 156
 157   /* Ensure we don't retry. */
 158   remove_response_record(subrec, rrec);
 159 }
 160
 161 /****************************************************************************
 162  Deal with a timeout when registering one of our names.
 163 ****************************************************************************/
 164
 165 static void register_name_timeout_response(struct subnet_record *subrec,
 166                        struct response_record *rrec)
 167 {
 168   /*
 169    * If we are registering unicast, then NOT getting a response is an
 170    * error - we do not have the name. If we are registering broadcast,
 171    * then we don't expect to get a response.
 172    */
 173
 174   struct nmb_packet *sent_nmb = &rrec->packet->packet.nmb;
 175   BOOL bcast = sent_nmb->header.nm_flags.bcast;
 176   BOOL success = False;
 177   struct nmb_name *question_name = &sent_nmb->question.question_name;
 178   uint16 nb_flags = 0;
 179   int ttl = 0;
 180   struct in_addr registered_ip;
 181
 182   if(bcast)
 183   {
 184     if(rrec->num_msgs == 0)
 185     {
 186       /* Not receiving a message is success for broadcast registration. */
 187       success = True;
 188
 189       /* Pull the success values from the original request packet. */
 190       nb_flags = get_nb_flags(sent_nmb->additional->rdata);
 191       ttl = sent_nmb->additional->ttl;
 192       putip(&registered_ip,&sent_nmb->additional->rdata[2]);
 193     }
 194   }
 195   else
 196   {
 197     /* Unicast - if no responses then it's an error. */
 198     if(rrec->num_msgs == 0)
 199     {
 200       DEBUG(2,("register_name_timeout_response: WINS server at address %s is not \
 201 responding.\n", inet_ntoa(rrec->packet->ip)));
 202
 203       /* Keep trying to contact the WINS server periodically. This allows
 204          us to work correctly if the WINS server is down temporarily when
 205          we come up. */
 206
 207       /* Reset the number of attempts to zero and double the interval between
 208          retries. Max out at 5 minutes. */
 209       rrec->repeat_count = 3;
 210       rrec->repeat_interval *= 2;
 211       if(rrec->repeat_interval > (5 * 60))
 212         rrec->repeat_interval = (5 * 60);
 213       rrec->repeat_time = time(NULL) + rrec->repeat_interval;
 214
 215       DEBUG(5,("register_name_timeout_response: increasing WINS timeout to %d seconds.\n",
 216               (int)rrec->repeat_interval));
 217       return; /* Don't remove the response record. */
 218     }
 219   }
 220
 221   DEBUG(5,("register_name_timeout_response: %s in registering name %s on subnet %s.\n",
 222         success ? "success" : "failure", nmb_namestr(question_name), subrec->subnet_name));
 223   if(success)
 224   {
 225     /* Enter the registered name into the subnet name database before calling
 226        the success function. */
 227     standard_success_register(subrec, rrec->userdata, question_name, nb_flags, ttl, registered_ip);
 228     if( rrec->success_fn)
 229       (*(register_name_success_function)rrec->success_fn)(subrec, rrec->userdata, question_name, nb_flags, ttl, registered_ip);
 230   }
 231   else
 232   {
 233     if( rrec->fail_fn)
 234       (*(register_name_fail_function)rrec->fail_fn)(subrec, rrec, question_name);
 235     /* Remove the name. */
 236     standard_fail_register( subrec, rrec, question_name);
 237   }
 238
 239   /* Ensure we don't retry. */
 240   remove_response_record(subrec, rrec);
 241 }
 242
 243 /****************************************************************************
 244  Try and register one of our names on the unicast subnet - multihomed.
 245 ****************************************************************************/
 246
 247 static BOOL multihomed_register_name( struct nmb_name *nmbname, uint16 nb_flags,
 248                                       register_name_success_function success_fn,
 249                                       register_name_fail_function fail_fn,
 250                                       struct userdata_struct *userdata)
 251 {
 252   /*
 253      If we are adding a group name, we just send multiple
 254      register name packets to the WINS server (this is an
 255      internet group name.
 256
 257      If we are adding a unique name, We need first to add
 258      our names to the unicast subnet namelist. This is
 259      because when a WINS server receives a multihomed
 260      registration request, the first thing it does is to
 261      send a name query to the registering machine, to see
 262      if it has put the name in it's local namelist.
 263      We need the name there so the query response code in
 264      nmbd_incomingrequests.c will find it.
 265
 266      We are adding this name prematurely (we don't really
 267      have it yet), but as this is on the unicast subnet
 268      only we will get away with this (only the WINS server
 269      will ever query names from us on this subnet).
 270    */
 271
 272   int num_ips=0;
 273   int i;
 274   struct in_addr *ip_list = NULL;
 275   struct subnet_record *subrec;
 276
 277   for(subrec = FIRST_SUBNET; subrec; subrec = NEXT_SUBNET_EXCLUDING_UNICAST(subrec) )
 278     num_ips++;
 279
 280   if((ip_list = (struct in_addr *)malloc(num_ips * sizeof(struct in_addr)))==NULL)
 281   {
 282     DEBUG(0,("multihomed_register_name: malloc fail !\n"));
 283     return True;
 284   }
 285
 286   for( subrec = FIRST_SUBNET, i = 0;
 287        subrec;
 288        subrec = NEXT_SUBNET_EXCLUDING_UNICAST(subrec), i++ )
 289     ip_list[i] = subrec->myip;
 290
 291   (void)add_name_to_subnet( unicast_subnet, nmbname->name, nmbname->name_type,
 292                             nb_flags, lp_max_ttl(), SELF_NAME,
 293                             num_ips, ip_list);
 294
 295   /* Now try and register the name, num_ips times. On the last time use
 296      the given success and fail functions. */
 297
 298   for( i = 0; i < num_ips; i++)
 299   {
 300     if(queue_register_multihomed_name( unicast_subnet,
 301         register_name_response,
 302         register_name_timeout_response,
 303         (i == num_ips - 1) ? success_fn : NULL,
 304         (i == num_ips - 1) ? fail_fn : NULL,
 305         (i == num_ips - 1) ? userdata : NULL,
 306         nmbname,
 307         nb_flags,
 308         ip_list[i]) == NULL)
 309     {
 310       DEBUG(0,("multihomed_register_name: Failed to send packet trying to \
 311 register name %s IP %s\n", nmb_namestr(nmbname), inet_ntoa(ip_list[i]) ));
 312
 313       SAFE_FREE(ip_list);
 314       return True;
 315     }
 316   }
 317
 318   SAFE_FREE(ip_list);
 319
 320   return False;
 321 }
 322
 323 /****************************************************************************
 324  Try and register one of our names.
 325 ****************************************************************************/
 326
 327 BOOL register_name(struct subnet_record *subrec,
 328                    char *name, int type, uint16 nb_flags,
 329                    register_name_success_function success_fn,
 330                    register_name_fail_function fail_fn,
 331                    struct userdata_struct *userdata)
 332 {
 333   struct nmb_name nmbname;
 334
 335   make_nmb_name(&nmbname, name, type);
 336
 337   /* Always set the NB_ACTIVE flag on the name we are
 338      registering. Doesn't make sense without it.
 339    */
 340
 341   nb_flags |= NB_ACTIVE;
 342
 343   /* If this is the unicast subnet, and we are a multi-homed
 344      host, then register a multi-homed name. */
 345
 346   if( (subrec == unicast_subnet) && we_are_multihomed())
 347     return multihomed_register_name(&nmbname, nb_flags,
 348                                     success_fn, fail_fn,
 349                                     userdata);
 350
 351   if(queue_register_name( subrec,
 352         register_name_response,
 353         register_name_timeout_response,
 354         success_fn,
 355         fail_fn,
 356         userdata,
 357         &nmbname,
 358         nb_flags) == NULL)
 359   {
 360     DEBUG(0,("register_name: Failed to send packet trying to register name %s\n",
 361           nmb_namestr(&nmbname)));
 362     return True;
 363   }
 364   return False;
 365 }
 366
 367 /****************************************************************************
 368  Try and refresh one of our names.
 369 ****************************************************************************/
 370
 371 BOOL refresh_name(struct subnet_record *subrec, struct name_record *namerec,
 372                   refresh_name_success_function success_fn,
 373                   refresh_name_fail_function fail_fn,
 374                   struct userdata_struct *userdata)
 375 {
 376   int i;
 377
 378   /*
 379    * Go through and refresh the name for all known ip addresses.
 380    * Only call the success/fail function on the last one (it should
 381    * only be done once).
 382    */
 383
 384   for( i = 0; i < namerec->data.num_ips; i++)
 385   {
 386     if(queue_refresh_name( subrec,
 387         register_name_response,
 388         register_name_timeout_response,
 389         (i == (namerec->data.num_ips - 1)) ? success_fn : NULL,
 390         (i == (namerec->data.num_ips - 1)) ? fail_fn : NULL,
 391         (i == (namerec->data.num_ips - 1)) ? userdata : NULL,
 392         namerec,
 393         namerec->data.ip[i]) == NULL)
 394     {
 395       DEBUG(0,("refresh_name: Failed to send packet trying to refresh name %s\n",
 396             nmb_namestr(&namerec->name)));
 397       return True;
 398     }
 399   }
 400   return False;
 401 }