source/nameservresp.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-1996
   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    Module name: nameservresp.c
  24
  25    14 jan 96: lkcl@pires.co.uk
  26    added multiple workgroup domain master support
  27
  28    05 jul 96: lkcl@pires.co.uk
  29    created module nameservresp containing NetBIOS response functions
  30
  31 */
  32
  33 #include "includes.h"
  34
  35 extern int ClientNMB;
  36
  37 extern int DEBUGLEVEL;
  38
  39 extern pstring scope;
  40 extern struct in_addr ipzero;
  41
  42 #define GET_TTL(ttl) ((ttl)?MIN(ttl,lp_max_ttl()):lp_max_ttl())
  43
  44
  45 /****************************************************************************
  46   response for a reg release received. samba has asked a WINS server if it
  47   could release a name.
  48   **************************************************************************/
  49 static void response_name_release(struct subnet_record *d,
  50                                                                 struct packet_struct *p)
  51 {
  52   struct nmb_packet *nmb = &p->packet.nmb;
  53   char *name = nmb->question.question_name.name;
  54   int   type = nmb->question.question_name.name_type;
  55
  56   DEBUG(4,("response name release received\n"));
  57
  58   if (nmb->header.rcode == 0 && nmb->answers->rdata)
  59   {
  60     /* IMPORTANT: see expire_netbios_response_entries() */
  61
  62     struct in_addr found_ip;
  63     putip((char*)&found_ip,&nmb->answers->rdata[2]);
  64
  65     /* NOTE: we only release our own names at present */
  66     if (ismyip(found_ip))
  67     {
  68       name_unregister_work(d,name,type);
  69     }
  70     else
  71     {
  72       DEBUG(2,("name release for different ip! %s %s\n",
  73                   inet_ntoa(found_ip),
  74                   namestr(&nmb->question.question_name)));
  75     }
  76   }
  77   else
  78   {
  79     DEBUG(2,("name release for %s rejected!\n",
  80                namestr(&nmb->question.question_name)));
  81
  82     /* XXXX PANIC! what to do if it's one of samba's own names? */
  83
  84     /* XXXX do we honestly care if our name release was rejected?
  85        only if samba is issuing the release on behalf of some out-of-sync
  86        server. if it's one of samba's SELF names, we don't care. */
  87   }
  88 }
  89
  90
  91 /****************************************************************************
  92 response for a reg request received
  93 **************************************************************************/
  94 static void response_name_reg(struct subnet_record *d, struct packet_struct *p)
  95 {
  96   struct nmb_packet *nmb = &p->packet.nmb;
  97   char *name = nmb->question.question_name.name;
  98   int   type = nmb->question.question_name.name_type;
  99   BOOL bcast = nmb->header.nm_flags.bcast;
 100
 101   DEBUG(4,("response name registration received!\n"));
 102
 103   if (nmb->header.rcode == 0 && nmb->answers->rdata)
 104   {
 105     /* IMPORTANT: see expire_netbios_response_entries() */
 106
 107     int nb_flags = nmb->answers->rdata[0];
 108     int ttl = nmb->answers->ttl;
 109     struct in_addr found_ip;
 110
 111     putip((char*)&found_ip,&nmb->answers->rdata[2]);
 112
 113     name_register_work(d,name,type,nb_flags,ttl,found_ip,bcast);
 114   }
 115   else
 116   {
 117     DEBUG(1,("name registration for %s rejected!\n",
 118                namestr(&nmb->question.question_name)));
 119
 120         /* oh dear. we have problems. possibly unbecome a master browser. */
 121     name_unregister_work(d,name,type);
 122   }
 123 }
 124
 125
 126 /****************************************************************************
 127   response from a name query announce host
 128   NAME_QUERY_ANNOUNCE_HOST is dealt with here
 129   ****************************************************************************/
 130 static void response_announce_host(struct nmb_name *ans_name,
 131                 struct nmb_packet *nmb,
 132                 struct response_record *n, struct subnet_record *d)
 133 {
 134         DEBUG(4, ("Name query at %s ip %s - ",
 135                   namestr(&n->name), inet_ntoa(n->send_ip)));
 136
 137         if (!name_equal(&n->name, ans_name))
 138         {
 139                 /* someone gave us the wrong name as a reply. oops. */
 140                 /* XXXX should say to them 'oi! release that name!' */
 141
 142                 DEBUG(4,("unexpected name received: %s\n", namestr(ans_name)));
 143                 return;
 144         }
 145
 146         if (nmb->header.rcode == 0 && nmb->answers->rdata)
 147     {
 148                 /* we had sent out a name query to the current owner
 149                    of a name because someone else wanted it. now they
 150                    have responded saying that they still want the name,
 151                    so the other host can't have it.
 152                  */
 153
 154                 /* first check all the details are correct */
 155
 156                 int nb_flags = nmb->answers->rdata[0];
 157                 struct in_addr found_ip;
 158
 159                 putip((char*)&found_ip,&nmb->answers->rdata[2]);
 160
 161                 if (nb_flags != n->nb_flags)
 162                 {
 163                         /* someone gave us the wrong nb_flags as a reply. oops. */
 164                         /* XXXX should say to them 'oi! release that name!' */
 165
 166                         DEBUG(4,("expected nb_flags: %d\n", n->nb_flags));
 167                         DEBUG(4,("unexpected nb_flags: %d\n", nb_flags));
 168                         return;
 169                 }
 170
 171         /* do an announce host */
 172         do_announce_host(ANN_HostAnnouncement,
 173                                 n->my_name  , 0x00, d->myip,
 174                                 n->name.name, 0x1d, found_ip,
 175                                 n->ttl,
 176                                 n->my_name, n->server_type, n->my_comment);
 177         }
 178         else
 179         {
 180                 /* XXXX negative name query response. no master exists. oops */
 181         }
 182 }
 183
 184
 185 /****************************************************************************
 186   response from a name query server check. states of type NAME_QUERY_DOM_SRV_CHK,
 187   NAME_QUERY_SRV_CHK, and NAME_QUERY_FIND_MST dealt with here.
 188   ****************************************************************************/
 189 static void response_server_check(struct nmb_name *ans_name,
 190                 struct response_record *n, struct subnet_record *d)
 191 {
 192     /* issue another state: this time to do a name status check */
 193
 194     enum state_type cmd = (n->state == NAME_QUERY_DOM_SRV_CHK) ?
 195               NAME_STATUS_DOM_SRV_CHK : NAME_STATUS_SRV_CHK;
 196
 197     /* initiate a name status check on the server that replied */
 198     queue_netbios_packet(d,ClientNMB,NMB_STATUS, cmd,
 199                                 ans_name->name, ans_name->name_type,
 200                                 0,0,0,NULL,NULL,
 201                                 False,False,n->send_ip,n->reply_to_ip);
 202 }
 203
 204
 205 /****************************************************************************
 206   interpret a node status response. this is pretty hacked: we need two bits of
 207   info. a) the name of the workgroup b) the name of the server. it will also
 208   add all the names it finds into the namelist.
 209 ****************************************************************************/
 210 static BOOL interpret_node_status(struct subnet_record *d,
 211                                 char *p, struct nmb_name *name,int t,
 212                            char *serv_name, struct in_addr ip, BOOL bcast)
 213 {
 214   int level = t==0x20 ? 4 : 0;
 215   int numnames = CVAL(p,0);
 216   BOOL found = False;
 217
 218   DEBUG(level,("received %d names\n",numnames));
 219
 220   p += 1;
 221
 222   if (serv_name) *serv_name = 0;
 223
 224   while (numnames--)
 225     {
 226       char qname[17];
 227       int type;
 228       fstring flags;
 229       int nb_flags;
 230
 231       BOOL group = False;
 232       BOOL add   = False;
 233
 234       *flags = 0;
 235
 236       StrnCpy(qname,p,15);
 237       type = CVAL(p,15);
 238       nb_flags = p[16];
 239       trim_string(qname,NULL," ");
 240
 241       p += 18;
 242
 243       if (NAME_GROUP    (nb_flags)) { strcat(flags,"<GROUP> "); group=True;}
 244       if (NAME_BFLAG    (nb_flags)) { strcat(flags,"B "); }
 245       if (NAME_PFLAG    (nb_flags)) { strcat(flags,"P "); }
 246       if (NAME_MFLAG    (nb_flags)) { strcat(flags,"M "); }
 247       if (NAME_HFLAG    (nb_flags)) { strcat(flags,"H "); }
 248       if (NAME_DEREG    (nb_flags)) { strcat(flags,"<DEREGISTERING> "); }
 249       if (NAME_CONFLICT (nb_flags)) { strcat(flags,"<CONFLICT> "); add=True;}
 250       if (NAME_ACTIVE   (nb_flags)) { strcat(flags,"<ACTIVE> "); add=True; }
 251       if (NAME_PERMANENT(nb_flags)) { strcat(flags,"<PERMANENT> "); add=True;}
 252
 253       /* might as well update our namelist while we're at it */
 254       if (add)
 255         {
 256           struct in_addr nameip;
 257           enum name_source src;
 258
 259           if (ismyip(ip)) {
 260             nameip = ipzero;
 261             src = SELF;
 262           } else {
 263             nameip = ip;
 264             src = STATUS_QUERY;
 265           }
 266           add_netbios_entry(d,qname,type,nb_flags,2*60*60,src,nameip,True,bcast);
 267         }
 268
 269       /* we want the server name */
 270       if (serv_name && !*serv_name && !group && t == 0)
 271         {
 272           StrnCpy(serv_name,qname,15);
 273           serv_name[15] = 0;
 274         }
 275
 276       /* looking for a name and type? */
 277       if (name && !found && (t == type))
 278         {
 279           /* take a guess at some of the name types we're going to ask for.
 280              evaluate whether they are group names or no... */
 281           if (((t == 0x1b || t == 0x1d             ) && !group) ||
 282               ((t == 0x20 || t == 0x1c || t == 0x1e) &&  group))
 283             {
 284               found = True;
 285               make_nmb_name(name,qname,type,scope);
 286             }
 287         }
 288
 289       DEBUG(level,("\t%s(0x%x)\t%s\n",qname,type,flags));
 290     }
 291   DEBUG(level,("num_good_sends=%d num_good_receives=%d\n",
 292                IVAL(p,20),IVAL(p,24)));
 293   return found;
 294 }
 295
 296
 297 /****************************************************************************
 298   response from a name status check. states of type NAME_STATUS_DOM_SRV_CHK
 299   and NAME_STATUS_SRV_CHK dealt with here.
 300   ****************************************************************************/
 301 static void response_name_status_check(struct in_addr ip,
 302                 struct nmb_packet *nmb, BOOL bcast,
 303                 struct response_record *n, struct subnet_record *d)
 304 {
 305         /* NMB_STATUS arrives: contains workgroup name and server name required.
 306        amongst other things. */
 307
 308         struct nmb_name name;
 309         fstring serv_name;
 310
 311         if (interpret_node_status(d,nmb->answers->rdata,
 312                                   &name,name.name_type,serv_name,ip,bcast))
 313         {
 314                 if (*serv_name)
 315                 {
 316                         sync_server(n->state,serv_name,
 317                                     name.name,name.name_type, n->send_ip);
 318                 }
 319         }
 320         else
 321         {
 322                 DEBUG(1,("No 0x1d name type in interpret_node_status()\n"));
 323         }
 324 }
 325
 326
 327 /****************************************************************************
 328   response from a name query for secured WINS registration. a state of
 329   NAME_REGISTER_CHALLENGE is dealt with here.
 330   ****************************************************************************/
 331 static void response_name_query_register(struct nmb_packet *nmb,
 332                 struct nmb_name *ans_name,
 333                 struct response_record *n, struct subnet_record *d)
 334 {
 335         struct in_addr register_ip;
 336         BOOL new_owner;
 337
 338         DEBUG(4, ("Name query at %s ip %s - ",
 339                   namestr(&n->name), inet_ntoa(n->send_ip)));
 340
 341         if (!name_equal(&n->name, ans_name))
 342         {
 343                 /* someone gave us the wrong name as a reply. oops. */
 344                 /* XXXX should say to them 'oi! release that name!' */
 345
 346                 DEBUG(4,("unexpected name received: %s\n", namestr(ans_name)));
 347                 return;
 348         }
 349
 350         if (nmb->header.rcode == 0 && nmb->answers->rdata)
 351     {
 352                 /* we had sent out a name query to the current owner
 353                    of a name because someone else wanted it. now they
 354                    have responded saying that they still want the name,
 355                    so the other host can't have it.
 356                  */
 357
 358                 /* first check all the details are correct */
 359
 360                 int nb_flags = nmb->answers->rdata[0];
 361                 struct in_addr found_ip;
 362
 363                 putip((char*)&found_ip,&nmb->answers->rdata[2]);
 364
 365                 if (nb_flags != n->nb_flags)
 366                 {
 367                         /* someone gave us the wrong nb_flags as a reply. oops. */
 368                         /* XXXX should say to them 'oi! release that name!' */
 369
 370                         DEBUG(4,("expected nb_flags: %d\n", n->nb_flags));
 371                         DEBUG(4,("unexpected nb_flags: %d\n", nb_flags));
 372                         return;
 373                 }
 374
 375                 if (!ip_equal(n->send_ip, found_ip))
 376                 {
 377                         /* someone gave us the wrong ip as a reply. oops. */
 378                         /* XXXX should say to them 'oi! release that name!' */
 379
 380                         DEBUG(4,("expected ip: %s\n", inet_ntoa(n->send_ip)));
 381                         DEBUG(4,("unexpected ip: %s\n", inet_ntoa(found_ip)));
 382                         return;
 383                 }
 384
 385                 DEBUG(4, (" OK: %s\n", inet_ntoa(found_ip)));
 386
 387                 /* fine: now tell the other host they can't have the name */
 388                 register_ip = n->send_ip;
 389                 new_owner = False;
 390         }
 391         else
 392         {
 393                 DEBUG(4, (" NEGATIVE RESPONSE!\n"));
 394
 395                 /* the owner didn't want the name: the other host can have it */
 396                 register_ip = n->reply_to_ip;
 397                 new_owner = True;
 398         }
 399
 400         /* register the old or the new owners' ip */
 401         add_name_respond(d, n->fd, d->myip, n->response_id,&n->name,n->nb_flags,
 402                                         GET_TTL(0), register_ip,
 403                                         new_owner, n->reply_to_ip);
 404 }
 405
 406
 407 /****************************************************************************
 408   response from a name query to sync browse lists or to update our netbios
 409   entry. states of type NAME_QUERY_SYNC and NAME_QUERY_CONFIRM
 410   ****************************************************************************/
 411 static void response_name_query_sync(struct nmb_packet *nmb,
 412                 struct nmb_name *ans_name, BOOL bcast,
 413                 struct response_record *n, struct subnet_record *d)
 414 {
 415         DEBUG(4, ("Name query at %s ip %s - ",
 416                   namestr(&n->name), inet_ntoa(n->send_ip)));
 417
 418         if (!name_equal(&n->name, ans_name))
 419         {
 420                 /* someone gave us the wrong name as a reply. oops. */
 421                 DEBUG(4,("unexpected name received: %s\n", namestr(ans_name)));
 422                 return;
 423         }
 424
 425         if (nmb->header.rcode == 0 && nmb->answers->rdata)
 426     {
 427                 int nb_flags = nmb->answers->rdata[0];
 428                 struct in_addr found_ip;
 429
 430                 putip((char*)&found_ip,&nmb->answers->rdata[2]);
 431
 432                 if (!ip_equal(n->send_ip, found_ip))
 433                 {
 434                         /* someone gave us the wrong ip as a reply. oops. */
 435                         DEBUG(4,("expected ip: %s\n", inet_ntoa(n->send_ip)));
 436                         DEBUG(4,("unexpected ip: %s\n", inet_ntoa(found_ip)));
 437                         return;
 438                 }
 439
 440                 DEBUG(4, (" OK: %s\n", inet_ntoa(found_ip)));
 441
 442                 if (n->state == NAME_QUERY_SYNC_LOCAL ||
 443                     n->state == NAME_QUERY_SYNC_REMOTE)
 444                 {
 445                         struct work_record *work = NULL;
 446                         if ((work = find_workgroupstruct(d, ans_name->name, False)))
 447                         {
 448                                 BOOL local_list_only = n->state == NAME_QUERY_SYNC_LOCAL;
 449
 450                                 /* the server is there: sync quick before it (possibly) dies! */
 451                                 sync_browse_lists(d, work, ans_name->name, ans_name->name_type,
 452                                                         found_ip, local_list_only);
 453                         }
 454                 }
 455                 else
 456                 {
 457                         /* update our netbios name list (re-register it if necessary) */
 458                         add_netbios_entry(d, ans_name->name, ans_name->name_type,
 459                                                                 nb_flags,GET_TTL(0),REGISTER,
 460                                                                 found_ip,False,!bcast);
 461                 }
 462         }
 463         else
 464         {
 465                 DEBUG(4, (" NEGATIVE RESPONSE!\n"));
 466
 467                 if (n->state == NAME_QUERY_CONFIRM)
 468                 {
 469                         /* XXXX remove_netbios_entry()? */
 470                         /* lots of things we ought to do, here. if we get here,
 471                            then we're in a mess: our name database doesn't match
 472                            reality. sort it out
 473              */
 474                 remove_netbios_name(d,n->name.name, n->name.name_type,
 475                                                                 REGISTER,n->send_ip);
 476                 }
 477         }
 478 }
 479
 480
 481 /****************************************************************************
 482   report the response record type
 483   ****************************************************************************/
 484 static void debug_rr_type(int rr_type)
 485 {
 486   switch (rr_type)
 487   {
 488       case NMB_STATUS: DEBUG(3,("Name status ")); break;
 489           case NMB_QUERY : DEBUG(3,("Name query ")); break;
 490           case NMB_REG   : DEBUG(3,("Name registration ")); break;
 491           case NMB_REL   : DEBUG(3,("Name release ")); break;
 492       default        : DEBUG(1,("wrong response packet type received")); break;
 493   }
 494 }
 495
 496 /****************************************************************************
 497   report the response record nmbd state
 498   ****************************************************************************/
 499 void debug_state_type(int state)
 500 {
 501   /* report the state type to help debugging */
 502   switch (state)
 503   {
 504     case NAME_QUERY_DOM_SRV_CHK  : DEBUG(4,("MASTER_SVR_CHECK\n")); break;
 505     case NAME_QUERY_SRV_CHK      : DEBUG(4,("NAME_QUERY_SRV_CHK\n")); break;
 506     case NAME_QUERY_FIND_MST     : DEBUG(4,("NAME_QUERY_FIND_MST\n")); break;
 507     case NAME_QUERY_MST_CHK      : DEBUG(4,("NAME_QUERY_MST_CHK\n")); break;
 508     case NAME_QUERY_CONFIRM      : DEBUG(4,("NAME_QUERY_CONFIRM\n")); break;
 509     case NAME_QUERY_SYNC_LOCAL   : DEBUG(4,("NAME_QUERY_SYNC_LOCAL\n")); break;
 510     case NAME_QUERY_SYNC_REMOTE  : DEBUG(4,("NAME_QUERY_SYNC_REMOTE\n")); break;
 511     case NAME_QUERY_ANNOUNCE_HOST: DEBUG(4,("NAME_QUERY_ANNCE_HOST\n"));break;
 512
 513     case NAME_REGISTER           : DEBUG(4,("NAME_REGISTER\n")); break;
 514     case NAME_REGISTER_CHALLENGE : DEBUG(4,("NAME_REGISTER_CHALLENGE\n"));break;
 515
 516     case NAME_RELEASE            : DEBUG(4,("NAME_RELEASE\n")); break;
 517
 518     case NAME_STATUS_DOM_SRV_CHK : DEBUG(4,("NAME_STAT_MST_CHK\n")); break;
 519     case NAME_STATUS_SRV_CHK     : DEBUG(4,("NAME_STATUS_SRV_CHK\n")); break;
 520
 521     default: break;
 522   }
 523 }
 524
 525 /****************************************************************************
 526   report any problems with the fact that a response has been received.
 527
 528   (responses for certain types of operations are only expected from one host)
 529   ****************************************************************************/
 530 static BOOL response_problem_check(struct response_record *n,
 531                         struct nmb_packet *nmb, char *qname)
 532 {
 533   switch (nmb->answers->rr_type)
 534   {
 535     case NMB_REL:
 536     {
 537         if (n->num_msgs > 1)
 538         {
 539             DEBUG(1,("more than one release name response received!\n"));
 540             return True;
 541         }
 542         break;
 543     }
 544
 545     case NMB_REG:
 546     {
 547         if (n->num_msgs > 1)
 548         {
 549             DEBUG(1,("more than one register name response received!\n"));
 550             return True;
 551         }
 552         break;
 553     }
 554
 555     case NMB_QUERY:
 556     {
 557       if (n->num_msgs > 1)
 558       {
 559                   if (nmb->header.rcode == 0 && nmb->answers->rdata)
 560                   {
 561                         int nb_flags = nmb->answers->rdata[0];
 562
 563                         if ((!NAME_GROUP(nb_flags)))
 564                         {
 565                            /* oh dear. more than one person responded to a unique name.
 566                                   there is either a network problem, a configuration problem
 567                                   or a server is mis-behaving */
 568
 569                            /* XXXX mark the name as in conflict, and then let the
 570                                   person who just responded know that they must also mark it
 571                                   as in conflict, and therefore must NOT use it.
 572                   see rfc1001.txt 15.1.3.5 */
 573
 574                /* this may cause problems for some early versions of nmbd */
 575
 576                switch (n->state)
 577                {
 578                 case NAME_QUERY_FIND_MST:
 579                 {
 580                   /* query for ^1^2__MSBROWSE__^2^1 expect lots of responses */
 581                   return False;
 582                 }
 583                         case NAME_QUERY_ANNOUNCE_HOST:
 584                         case NAME_QUERY_DOM_SRV_CHK:
 585                 case NAME_QUERY_SRV_CHK:
 586                 case NAME_QUERY_MST_CHK:
 587                 {
 588                       if (!strequal(qname,n->name.name))
 589                       {
 590                              /* one subnet, one master browser per workgroup */
 591                              /* XXXX force an election? */
 592
 593                              DEBUG(3,("more than one master browser replied!\n"));
 594                                  return True;
 595                           }
 596                    break;
 597                 }
 598                 default: break;
 599                }
 600                DEBUG(3,("Unique Name conflict detected!\n"));
 601                            return True;
 602                         }
 603                   }
 604                   else
 605                   {
 606              /* we have received a negative reply, having already received
 607                 at least one response (pos/neg). something's really wrong! */
 608
 609                  DEBUG(3,("wierd name query problem detected!\n"));
 610                      return True;
 611                   }
 612        }
 613     }
 614   }
 615   return False;
 616 }
 617
 618 /****************************************************************************
 619   check that the response received is compatible with the response record
 620   ****************************************************************************/
 621 static BOOL response_compatible(struct response_record *n,
 622                         struct nmb_packet *nmb)
 623 {
 624   switch (n->state)
 625   {
 626     case NAME_RELEASE:
 627     {
 628                 if (nmb->answers->rr_type != NMB_REL)
 629                 {
 630                         DEBUG(1,("Name release reply has wrong answer rr_type\n"));
 631                         return False;
 632                 }
 633         break;
 634     }
 635
 636     case NAME_REGISTER:
 637     {
 638                 if (nmb->answers->rr_type != NMB_REG)
 639                 {
 640                         DEBUG(1,("Name register reply has wrong answer rr_type\n"));
 641                         return False;
 642                 }
 643         break;
 644     }
 645
 646     case NAME_REGISTER_CHALLENGE: /* this is a query: we then do a register */
 647     case NAME_QUERY_CONFIRM:
 648     case NAME_QUERY_ANNOUNCE_HOST:
 649     case NAME_QUERY_SYNC_LOCAL:
 650     case NAME_QUERY_SYNC_REMOTE:
 651     case NAME_QUERY_DOM_SRV_CHK:
 652     case NAME_QUERY_SRV_CHK:
 653     case NAME_QUERY_FIND_MST:
 654     case NAME_QUERY_MST_CHK:
 655     {
 656                 if (nmb->answers->rr_type != NMB_QUERY)
 657                 {
 658                         DEBUG(1,("Name query reply has wrong answer rr_type\n"));
 659                         return False;
 660                 }
 661                 break;
 662     }
 663
 664     case NAME_STATUS_DOM_SRV_CHK:
 665     case NAME_STATUS_SRV_CHK:
 666     {
 667                 if (nmb->answers->rr_type != NMB_STATUS)
 668                 {
 669                         DEBUG(1,("Name status reply has wrong answer rr_type\n"));
 670                         return False;
 671                 }
 672                 break;
 673     }
 674
 675     default:
 676     {
 677                 DEBUG(1,("unknown state type received in response_netbios_packet\n"));
 678                 return False;
 679     }
 680   }
 681   return True;
 682 }
 683
 684
 685 /****************************************************************************
 686   process the response packet received
 687   ****************************************************************************/
 688 static void response_process(struct subnet_record *d, struct packet_struct *p,
 689                                 struct response_record *n, struct nmb_packet *nmb,
 690                                 BOOL bcast, struct nmb_name *ans_name)
 691 {
 692   switch (n->state)
 693   {
 694     case NAME_RELEASE:
 695     {
 696         response_name_release(d, p);
 697         break;
 698     }
 699
 700     case NAME_REGISTER:
 701     {
 702         response_name_reg(d, p);
 703         break;
 704     }
 705
 706     case NAME_REGISTER_CHALLENGE:
 707     {
 708         response_name_query_register(nmb, ans_name, n, d);
 709         break;
 710     }
 711
 712     case NAME_QUERY_DOM_SRV_CHK:
 713     case NAME_QUERY_SRV_CHK:
 714     case NAME_QUERY_FIND_MST:
 715     {
 716                 response_server_check(ans_name, n, d);
 717                 break;
 718     }
 719
 720     case NAME_STATUS_DOM_SRV_CHK:
 721     case NAME_STATUS_SRV_CHK:
 722     {
 723                 response_name_status_check(p->ip, nmb, bcast, n, d);
 724                 break;
 725     }
 726
 727     case NAME_QUERY_ANNOUNCE_HOST:
 728     {
 729                 response_announce_host(ans_name, nmb, n, d);
 730                 break;
 731     }
 732
 733     case NAME_QUERY_CONFIRM:
 734     case NAME_QUERY_SYNC_LOCAL:
 735     case NAME_QUERY_SYNC_REMOTE:
 736     {
 737                 response_name_query_sync(nmb, ans_name, bcast, n, d);
 738                 break;
 739     }
 740     case NAME_QUERY_MST_CHK:
 741     {
 742                 /* no action required here. it's when NO responses are received
 743                    that we need to do something. see expire_name_query_entries() */
 744
 745                 DEBUG(4, ("Master browser exists for %s at %s (just checking!)\n",
 746                                         namestr(&n->name), inet_ntoa(n->send_ip)));
 747                 break;
 748     }
 749
 750     default:
 751     {
 752                 DEBUG(1,("unknown state type received in response_netbios_packet\n"));
 753                 break;
 754     }
 755   }
 756 }
 757
 758
 759 /****************************************************************************
 760   response from a netbios packet.
 761   ****************************************************************************/
 762 void response_netbios_packet(struct packet_struct *p)
 763 {
 764   struct nmb_packet *nmb = &p->packet.nmb;
 765   struct nmb_name *question = &nmb->question.question_name;
 766   struct nmb_name *ans_name = NULL;
 767   char *qname = question->name;
 768   BOOL bcast = nmb->header.nm_flags.bcast;
 769   struct response_record *n;
 770   struct subnet_record *d = NULL;
 771
 772   if (!(n = find_response_record(&d,nmb->header.name_trn_id))) {
 773     DEBUG(2,("unknown netbios response (received late or from nmblookup?)\n"));
 774     return;
 775   }
 776
 777   if (!d)
 778   {
 779     DEBUG(2,("response packet: subnet %s not known\n", inet_ntoa(p->ip)));
 780     return;
 781   }
 782
 783   /* args wrong way round: spotted by ccm@shentel.net */
 784   if (!same_net(d->bcast_ip, p->ip, d->mask_ip)) /* copes with WINS 'subnet' */
 785   {
 786     DEBUG(2,("response from %s. ", inet_ntoa(p->ip)));
 787     DEBUG(2,("expected on subnet %s. hmm.\n", inet_ntoa(d->bcast_ip)));
 788     return;
 789   }
 790
 791   if (nmb->answers == NULL)
 792   {
 793       /* hm. the packet received was a response, but with no answer. wierd! */
 794       DEBUG(2,("NMB packet response from %s (bcast=%s) - UNKNOWN\n",
 795                inet_ntoa(p->ip), BOOLSTR(bcast)));
 796       return;
 797   }
 798
 799   ans_name = &nmb->answers->rr_name;
 800   DEBUG(3,("response for %s from %s (bcast=%s)\n",
 801            namestr(ans_name), inet_ntoa(p->ip), BOOLSTR(bcast)));
 802
 803   debug_rr_type(nmb->answers->rr_type);
 804
 805   n->num_msgs++; /* count number of responses received */
 806   n->repeat_count = 0; /* don't resend: see expire_netbios_packets() */
 807
 808   debug_state_type(n->state);
 809
 810   /* problem checking: multiple responses etc */
 811   if (response_problem_check(n, nmb, qname))
 812     return;
 813
 814   /* now check whether the 'state' has received the correct type of response */
 815   if (!response_compatible(n, nmb))
 816     return;
 817
 818   /* now deal with the current state */
 819   response_process(d, p, n, nmb, bcast, ans_name);
 820 }
 821
 822