source3/nmbd/nmbd_nameregister.c

   1 /*
   2    Unix SMB/CIFS implementation.
   3    NBT netbios routines and daemon - version 2
   4    Copyright (C) Andrew Tridgell 1994-1998
   5    Copyright (C) Luke Kenneth Casson Leighton 1994-1998
   6    Copyright (C) Jeremy Allison 1994-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
  23 #include "includes.h"
  24
  25 /* forward declarations */
  26 static void wins_next_registration(struct response_record *rrec);
  27
  28
  29 /****************************************************************************
  30  Deal with a response packet when registering one of our names.
  31 ****************************************************************************/
  32
  33 static void register_name_response(struct subnet_record *subrec,
  34                        struct response_record *rrec, struct packet_struct *p)
  35 {
  36         /*
  37          * If we are registering broadcast, then getting a response is an
  38          * error - we do not have the name. If we are registering unicast,
  39          * then we expect to get a response.
  40          */
  41
  42         struct nmb_packet *nmb = &p->packet.nmb;
  43         bool bcast = nmb->header.nm_flags.bcast;
  44         bool success = True;
  45         struct nmb_name *question_name = &rrec->packet->packet.nmb.question.question_name;
  46         struct nmb_name *answer_name = &nmb->answers->rr_name;
  47         struct nmb_packet *sent_nmb = &rrec->packet->packet.nmb;
  48         int ttl = 0;
  49         uint16 nb_flags = 0;
  50         struct in_addr register_ip;
  51         fstring reg_name;
  52
  53         putip(&register_ip,&sent_nmb->additional->rdata[2]);
  54         fstrcpy(reg_name, inet_ntoa(register_ip));
  55
  56         if (subrec == unicast_subnet) {
  57                 /* we know that this wins server is definately alive - for the moment! */
  58                 wins_srv_alive(rrec->packet->ip, register_ip);
  59         }
  60
  61         /* Sanity check. Ensure that the answer name in the incoming packet is the
  62            same as the requested name in the outgoing packet. */
  63
  64         if(!question_name || !answer_name) {
  65                 DEBUG(0,("register_name_response: malformed response (%s is NULL).\n",
  66                          question_name ? "question_name" : "answer_name" ));
  67                 return;
  68         }
  69
  70         if(!nmb_name_equal(question_name, answer_name)) {
  71                 DEBUG(0,("register_name_response: Answer name %s differs from question name %s.\n",
  72                          nmb_namestr(answer_name), nmb_namestr(question_name)));
  73                 return;
  74         }
  75
  76         if(bcast) {
  77                 /*
  78                  * Special hack to cope with old Samba nmbd's.
  79                  * Earlier versions of Samba (up to 1.9.16p11) respond
  80                  * to a broadcast name registration of WORKGROUP<1b> when
  81                  * they should not. Hence, until these versions are gone,
  82                  * we should treat such errors as success for this particular
  83                  * case only. jallison@whistle.com.
  84                  */
  85
  86 #if 1 /* OLD_SAMBA_SERVER_HACK */
  87                 unstring ans_name;
  88                 pull_ascii_nstring(ans_name, sizeof(ans_name), answer_name->name);
  89                 if((nmb->header.rcode == ACT_ERR) && strequal(lp_workgroup(), ans_name) &&
  90                    (answer_name->name_type == 0x1b)) {
  91                         /* Pretend we did not get this. */
  92                         rrec->num_msgs--;
  93
  94                         DEBUG(5,("register_name_response: Ignoring broadcast response to registration of name %s due to old Samba server bug.\n",
  95                                  nmb_namestr(answer_name)));
  96                         return;
  97                 }
  98 #endif /* OLD_SAMBA_SERVER_HACK */
  99
 100                 /* Someone else has the name. Log the problem. */
 101                 DEBUG(1,("register_name_response: Failed to register name %s IP %s on subnet %s via broadcast. Error code was %d. Reject came from IP %s\n",
 102                          nmb_namestr(answer_name),
 103                          reg_name,
 104                          subrec->subnet_name, nmb->header.rcode, inet_ntoa(p->ip)));
 105                 success = False;
 106         } else {
 107                 if (!ip_equal_v4(rrec->packet->ip, p->ip)) {
 108                         DEBUG(5,("register_name_response: Ignoring WINS server response "
 109                                 "from IP %s, for name %s. We sent to IP %s\n",
 110                                 inet_ntoa(p->ip),
 111                                 nmb_namestr(answer_name),
 112                                 inet_ntoa(rrec->packet->ip)));
 113                         return;
 114                 }
 115                 /* Unicast - check to see if the response allows us to have the name. */
 116                 if (nmb->header.opcode == NMB_WACK_OPCODE) {
 117                         /* WINS server is telling us to wait. Pretend we didn't get
 118                            the response but don't send out any more register requests. */
 119
 120                         DEBUG(5,("register_name_response: WACK from WINS server %s in registering name %s IP %s\n",
 121                                  inet_ntoa(p->ip), nmb_namestr(answer_name), reg_name));
 122
 123                         rrec->repeat_count = 0;
 124                         /* How long we should wait for. */
 125                         rrec->repeat_time = p->timestamp + nmb->answers->ttl;
 126                         rrec->num_msgs--;
 127                         return;
 128                 } else if (nmb->header.rcode != 0) {
 129                         /* Error code - we didn't get the name. */
 130                         success = False;
 131
 132                         DEBUG(0,("register_name_response: %sserver at IP %s rejected our name registration of %s IP %s with error code %d.\n",
 133                                  subrec==unicast_subnet?"WINS ":"",
 134                                  inet_ntoa(p->ip),
 135                                  nmb_namestr(answer_name),
 136                                  reg_name,
 137                                  nmb->header.rcode));
 138                 } else {
 139                         success = True;
 140                         /* Get the data we need to pass to the success function. */
 141                         nb_flags = get_nb_flags(nmb->answers->rdata);
 142                         ttl = nmb->answers->ttl;
 143
 144                         /* send off a registration for the next IP, if any */
 145                         wins_next_registration(rrec);
 146                 }
 147         }
 148
 149         DEBUG(5,("register_name_response: %s in registering %sname %s IP %s with %s.\n",
 150                  success ? "success" : "failure",
 151                  subrec==unicast_subnet?"WINS ":"",
 152                  nmb_namestr(answer_name),
 153                  reg_name,
 154                  inet_ntoa(rrec->packet->ip)));
 155
 156         if(success) {
 157                 /* Enter the registered name into the subnet name database before calling
 158                    the success function. */
 159                 standard_success_register(subrec, rrec->userdata, answer_name, nb_flags, ttl, register_ip);
 160                 if( rrec->success_fn)
 161                         (*(register_name_success_function)rrec->success_fn)(subrec, rrec->userdata, answer_name, nb_flags, ttl, register_ip);
 162         } else {
 163                 struct nmb_name qname = *question_name;
 164                 if( rrec->fail_fn)
 165                         (*(register_name_fail_function)rrec->fail_fn)(subrec, rrec, question_name);
 166                 /* Remove the name. */
 167                 standard_fail_register( subrec, &qname);
 168         }
 169
 170         /* Ensure we don't retry. */
 171         remove_response_record(subrec, rrec);
 172 }
 173
 174 /****************************************************************************
 175  Deal with a timeout of a WINS registration request
 176 ****************************************************************************/
 177
 178 static void wins_registration_timeout(struct subnet_record *subrec,
 179                                       struct response_record *rrec)
 180 {
 181         struct userdata_struct *userdata = rrec->userdata;
 182         struct nmb_packet *sent_nmb = &rrec->packet->packet.nmb;
 183         struct nmb_name *nmbname = &sent_nmb->question.question_name;
 184         struct in_addr register_ip;
 185         fstring src_addr;
 186
 187         putip(&register_ip,&sent_nmb->additional->rdata[2]);
 188
 189         fstrcpy(src_addr, inet_ntoa(register_ip));
 190
 191         DEBUG(2,("wins_registration_timeout: WINS server %s timed out registering IP %s\n",
 192                  inet_ntoa(rrec->packet->ip), src_addr));
 193
 194         /* mark it temporarily dead for this source address */
 195         wins_srv_died(rrec->packet->ip, register_ip);
 196
 197         /* if we have some userdata then use that to work out what
 198            wins server to try next */
 199         if (userdata) {
 200                 const char *tag = (const char *)userdata->data;
 201
 202                 /* try the next wins server in our failover list for
 203                    this tag */
 204                 rrec->packet->ip = wins_srv_ip_tag(tag, register_ip);
 205         }
 206
 207         /* if we have run out of wins servers for this tag then they
 208            must all have timed out. We treat this as *success*, not
 209            failure, and go into our standard name refresh mode. This
 210            copes with all the wins servers being down */
 211         if (wins_srv_is_dead(rrec->packet->ip, register_ip)) {
 212                 uint16 nb_flags = get_nb_flags(sent_nmb->additional->rdata);
 213                 int ttl = sent_nmb->additional->ttl;
 214
 215                 standard_success_register(subrec, userdata, nmbname, nb_flags, ttl, register_ip);
 216                 if(rrec->success_fn) {
 217                         (*(register_name_success_function)rrec->success_fn)(subrec,
 218                                                                             rrec->userdata,
 219                                                                             nmbname,
 220                                                                             nb_flags,
 221                                                                             ttl,
 222                                                                             register_ip);
 223                 }
 224
 225                 /* send off a registration for the next IP, if any */
 226                 wins_next_registration(rrec);
 227
 228                 /* don't need to send this packet any more */
 229                 remove_response_record(subrec, rrec);
 230                 return;
 231         }
 232
 233         /* we will be moving to the next WINS server for this group,
 234            send it immediately */
 235         rrec->repeat_count = 2;
 236         rrec->repeat_time = time(NULL) + 1;
 237         rrec->in_expiration_processing = False;
 238
 239         DEBUG(6,("Retrying register of name %s IP %s with WINS server %s\n",
 240                  nmb_namestr(nmbname), src_addr, inet_ntoa(rrec->packet->ip)));
 241
 242         /* notice that we don't remove the response record. This keeps
 243            us trying to register with each of our failover wins servers */
 244 }
 245
 246 /****************************************************************************
 247  Deal with a timeout when registering one of our names.
 248 ****************************************************************************/
 249
 250 static void register_name_timeout_response(struct subnet_record *subrec,
 251                                            struct response_record *rrec)
 252 {
 253         /*
 254          * If we are registering unicast, then NOT getting a response is an
 255          * error - we do not have the name. If we are registering broadcast,
 256          * then we don't expect to get a response.
 257          */
 258
 259         struct nmb_packet *sent_nmb = &rrec->packet->packet.nmb;
 260         bool bcast = sent_nmb->header.nm_flags.bcast;
 261         bool success = False;
 262         struct nmb_name *question_name = &sent_nmb->question.question_name;
 263         uint16 nb_flags = 0;
 264         int ttl = 0;
 265         struct in_addr registered_ip;
 266
 267         if (bcast) {
 268                 if(rrec->num_msgs == 0) {
 269                         /* Not receiving a message is success for broadcast registration. */
 270                         success = True;
 271
 272                         /* Pull the success values from the original request packet. */
 273                         nb_flags = get_nb_flags(sent_nmb->additional->rdata);
 274                         ttl = sent_nmb->additional->ttl;
 275                         putip(&registered_ip,&sent_nmb->additional->rdata[2]);
 276                 }
 277         } else {
 278                 /* wins timeouts are special */
 279                 wins_registration_timeout(subrec, rrec);
 280                 return;
 281         }
 282
 283         DEBUG(5,("register_name_timeout_response: %s in registering name %s on subnet %s.\n",
 284                  success ? "success" : "failure", nmb_namestr(question_name), subrec->subnet_name));
 285         if(success) {
 286                 /* Enter the registered name into the subnet name database before calling
 287                    the success function. */
 288                 standard_success_register(subrec, rrec->userdata, question_name, nb_flags, ttl, registered_ip);
 289                 if( rrec->success_fn)
 290                         (*(register_name_success_function)rrec->success_fn)(subrec, rrec->userdata, question_name, nb_flags, ttl, registered_ip);
 291         } else {
 292                 struct nmb_name qname = *question_name;
 293                 if( rrec->fail_fn)
 294                         (*(register_name_fail_function)rrec->fail_fn)(subrec, rrec, question_name);
 295                 /* Remove the name. */
 296                 standard_fail_register( subrec, &qname);
 297         }
 298
 299         /* Ensure we don't retry. */
 300         remove_response_record(subrec, rrec);
 301 }
 302
 303 /****************************************************************************
 304  Initiate one multi-homed name registration packet.
 305 ****************************************************************************/
 306
 307 static void multihomed_register_one(struct nmb_name *nmbname,
 308                                     uint16 nb_flags,
 309                                     register_name_success_function success_fn,
 310                                     register_name_fail_function fail_fn,
 311                                     struct in_addr ip,
 312                                     const char *tag)
 313 {
 314         struct userdata_struct *userdata;
 315         struct in_addr wins_ip = wins_srv_ip_tag(tag, ip);
 316         fstring ip_str;
 317
 318         userdata = (struct userdata_struct *)SMB_MALLOC(sizeof(*userdata) + strlen(tag) + 1);
 319         if (!userdata) {
 320                 DEBUG(0,("Failed to allocate userdata structure!\n"));
 321                 return;
 322         }
 323         ZERO_STRUCTP(userdata);
 324         userdata->userdata_len = strlen(tag) + 1;
 325         strlcpy(userdata->data, tag, userdata->userdata_len);
 326
 327         fstrcpy(ip_str, inet_ntoa(ip));
 328
 329         DEBUG(6,("Registering name %s IP %s with WINS server %s using tag '%s'\n",
 330                  nmb_namestr(nmbname), ip_str, inet_ntoa(wins_ip), tag));
 331
 332         if (queue_register_multihomed_name(unicast_subnet,
 333                                            register_name_response,
 334                                            register_name_timeout_response,
 335                                            success_fn,
 336                                            fail_fn,
 337                                            userdata,
 338                                            nmbname,
 339                                            nb_flags,
 340                                            ip,
 341                                            wins_ip) == NULL) {
 342                 DEBUG(0,("multihomed_register_one: Failed to send packet trying to register name %s IP %s\n",
 343                          nmb_namestr(nmbname), inet_ntoa(ip)));
 344         }
 345
 346         free(userdata);
 347 }
 348
 349 /****************************************************************************
 350  We have finished the registration of one IP and need to see if we have
 351  any more IPs left to register with this group of wins server for this name.
 352 ****************************************************************************/
 353
 354 static void wins_next_registration(struct response_record *rrec)
 355 {
 356         struct nmb_packet *sent_nmb = &rrec->packet->packet.nmb;
 357         struct nmb_name *nmbname = &sent_nmb->question.question_name;
 358         uint16 nb_flags = get_nb_flags(sent_nmb->additional->rdata);
 359         struct userdata_struct *userdata = rrec->userdata;
 360         const char *tag;
 361         struct in_addr last_ip;
 362         struct subnet_record *subrec;
 363
 364         putip(&last_ip,&sent_nmb->additional->rdata[2]);
 365
 366         if (!userdata) {
 367                 /* it wasn't multi-homed */
 368                 return;
 369         }
 370
 371         tag = (const char *)userdata->data;
 372
 373         for (subrec = FIRST_SUBNET; subrec; subrec = NEXT_SUBNET_EXCLUDING_UNICAST(subrec)) {
 374                 if (ip_equal_v4(last_ip, subrec->myip)) {
 375                         subrec = NEXT_SUBNET_EXCLUDING_UNICAST(subrec);
 376                         break;
 377                 }
 378         }
 379
 380         if (!subrec) {
 381                 /* no more to do! */
 382                 return;
 383         }
 384
 385         switch (sent_nmb->header.opcode) {
 386         case NMB_NAME_MULTIHOMED_REG_OPCODE:
 387                 multihomed_register_one(nmbname, nb_flags, NULL, NULL, subrec->myip, tag);
 388                 break;
 389         case NMB_NAME_REFRESH_OPCODE_8:
 390                 queue_wins_refresh(nmbname,
 391                                    register_name_response,
 392                                    register_name_timeout_response,
 393                                    nb_flags, subrec->myip, tag);
 394                 break;
 395         }
 396 }
 397
 398 /****************************************************************************
 399  Try and register one of our names on the unicast subnet - multihomed.
 400 ****************************************************************************/
 401
 402 static void multihomed_register_name(struct nmb_name *nmbname, uint16 nb_flags,
 403                                      register_name_success_function success_fn,
 404                                      register_name_fail_function fail_fn)
 405 {
 406         /*
 407           If we are adding a group name, we just send multiple
 408           register name packets to the WINS server (this is an
 409           internet group name.
 410
 411           If we are adding a unique name, We need first to add
 412           our names to the unicast subnet namelist. This is
 413           because when a WINS server receives a multihomed
 414           registration request, the first thing it does is to
 415           send a name query to the registering machine, to see
 416           if it has put the name in it's local namelist.
 417           We need the name there so the query response code in
 418           nmbd_incomingrequests.c will find it.
 419
 420           We are adding this name prematurely (we don't really
 421           have it yet), but as this is on the unicast subnet
 422           only we will get away with this (only the WINS server
 423           will ever query names from us on this subnet).
 424         */
 425         int num_ips=0;
 426         int i, t;
 427         struct subnet_record *subrec;
 428         char **wins_tags;
 429         struct in_addr *ip_list;
 430         unstring name;
 431
 432         for(subrec = FIRST_SUBNET; subrec; subrec = NEXT_SUBNET_EXCLUDING_UNICAST(subrec) )
 433                 num_ips++;
 434
 435         if((ip_list = SMB_MALLOC_ARRAY(struct in_addr, num_ips))==NULL) {
 436                 DEBUG(0,("multihomed_register_name: malloc fail !\n"));
 437                 return;
 438         }
 439
 440         for (subrec = FIRST_SUBNET, i = 0;
 441              subrec;
 442              subrec = NEXT_SUBNET_EXCLUDING_UNICAST(subrec), i++ ) {
 443                 ip_list[i] = subrec->myip;
 444         }
 445
 446         pull_ascii_nstring(name, sizeof(name), nmbname->name);
 447         add_name_to_subnet(unicast_subnet, name, nmbname->name_type,
 448                            nb_flags, lp_max_ttl(), SELF_NAME,
 449                            num_ips, ip_list);
 450
 451         /* get the list of wins tags - we try to register for each of them */
 452         wins_tags = wins_srv_tags();
 453
 454         /* Now try and register the name for each wins tag.  Note that
 455            at this point we only register our first IP with each wins
 456            group. We will register the rest from
 457            wins_next_registration() when we get the reply for this
 458            one. That follows the way W2K does things (tridge)
 459         */
 460         for (t=0; wins_tags && wins_tags[t]; t++) {
 461                 multihomed_register_one(nmbname, nb_flags,
 462                                         success_fn, fail_fn,
 463                                         ip_list[0],
 464                                         wins_tags[t]);
 465         }
 466
 467         wins_srv_tags_free(wins_tags);
 468
 469         SAFE_FREE(ip_list);
 470 }
 471
 472 /****************************************************************************
 473  Try and register one of our names.
 474 ****************************************************************************/
 475
 476 void register_name(struct subnet_record *subrec,
 477                    const char *name, int type, uint16 nb_flags,
 478                    register_name_success_function success_fn,
 479                    register_name_fail_function fail_fn,
 480                    struct userdata_struct *userdata)
 481 {
 482         struct nmb_name nmbname;
 483         nstring nname;
 484
 485         errno = 0;
 486         push_ascii_nstring(nname, name);
 487         if (errno == E2BIG) {
 488                 unstring tname;
 489                 pull_ascii_nstring(tname, sizeof(tname), nname);
 490                 DEBUG(0,("register_name: NetBIOS name %s is too long. Truncating to %s\n",
 491                         name, tname));
 492                 make_nmb_name(&nmbname, tname, type);
 493         } else {
 494                 make_nmb_name(&nmbname, name, type);
 495         }
 496
 497         /* Always set the NB_ACTIVE flag on the name we are
 498            registering. Doesn't make sense without it.
 499         */
 500
 501         nb_flags |= NB_ACTIVE;
 502
 503         if (subrec == unicast_subnet) {
 504                 /* we now always do multi-homed registration if we are
 505                    registering to a WINS server. This copes much
 506                    better with complex WINS setups */
 507                 multihomed_register_name(&nmbname, nb_flags,
 508                                          success_fn, fail_fn);
 509                 return;
 510         }
 511
 512         if (queue_register_name(subrec,
 513                                 register_name_response,
 514                                 register_name_timeout_response,
 515                                 success_fn,
 516                                 fail_fn,
 517                                 userdata,
 518                                 &nmbname,
 519                                 nb_flags) == NULL) {
 520                 DEBUG(0,("register_name: Failed to send packet trying to register name %s\n",
 521                          nmb_namestr(&nmbname)));
 522         }
 523 }
 524
 525 /****************************************************************************
 526  Try and refresh one of our names. This is *only* called for WINS refresh
 527 ****************************************************************************/
 528
 529 void wins_refresh_name(struct name_record *namerec)
 530 {
 531         int t;
 532         char **wins_tags;
 533
 534         /* get the list of wins tags - we try to refresh for each of them */
 535         wins_tags = wins_srv_tags();
 536
 537         for (t=0; wins_tags && wins_tags[t]; t++) {
 538                 queue_wins_refresh(&namerec->name,
 539                                    register_name_response,
 540                                    register_name_timeout_response,
 541                                    namerec->data.nb_flags,
 542                                    namerec->data.ip[0], wins_tags[t]);
 543         }
 544
 545         wins_srv_tags_free(wins_tags);
 546 }