source3/nmbd/nmbd_packets.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 extern int ClientNMB;
  26 extern int ClientDGRAM;
  27 extern int global_nmb_port;
  28
  29 extern int num_response_packets;
  30
  31 static void queue_packet(struct packet_struct *packet);
  32
  33 bool rescan_listen_set = False;
  34
  35
  36 /*******************************************************************
  37   The global packet linked-list. Incoming entries are
  38   added to the end of this list. It is supposed to remain fairly
  39   short so we won't bother with an end pointer.
  40 ******************************************************************/
  41
  42 static struct packet_struct *packet_queue = NULL;
  43
  44 /***************************************************************************
  45 Utility function to find the specific fd to send a packet out on.
  46 **************************************************************************/
  47
  48 static int find_subnet_fd_for_address( struct in_addr local_ip )
  49 {
  50         struct subnet_record *subrec;
  51
  52         for( subrec = FIRST_SUBNET; subrec; subrec = NEXT_SUBNET_EXCLUDING_UNICAST(subrec))
  53                 if(ip_equal_v4(local_ip, subrec->myip))
  54                         return subrec->nmb_sock;
  55
  56         return ClientNMB;
  57 }
  58
  59 /***************************************************************************
  60 Utility function to find the specific fd to send a mailslot packet out on.
  61 **************************************************************************/
  62
  63 static int find_subnet_mailslot_fd_for_address( struct in_addr local_ip )
  64 {
  65         struct subnet_record *subrec;
  66
  67         for( subrec = FIRST_SUBNET; subrec; subrec = NEXT_SUBNET_EXCLUDING_UNICAST(subrec))
  68                 if(ip_equal_v4(local_ip, subrec->myip))
  69                         return subrec->dgram_sock;
  70
  71         return ClientDGRAM;
  72 }
  73
  74 /***************************************************************************
  75 Get/Set problematic nb_flags as network byte order 16 bit int.
  76 **************************************************************************/
  77
  78 uint16 get_nb_flags(char *buf)
  79 {
  80         return ((((uint16)*buf)&0xFFFF) & NB_FLGMSK);
  81 }
  82
  83 void set_nb_flags(char *buf, uint16 nb_flags)
  84 {
  85         *buf++ = ((nb_flags & NB_FLGMSK) & 0xFF);
  86         *buf = '\0';
  87 }
  88
  89 /***************************************************************************
  90 Dumps out the browse packet data.
  91 **************************************************************************/
  92
  93 static void debug_browse_data(char *outbuf, int len)
  94 {
  95         int i,j;
  96
  97         DEBUG( 4, ( "debug_browse_data():\n" ) );
  98         for (i = 0; i < len; i+= 16) {
  99                 DEBUGADD( 4, ( "%3x char ", i ) );
 100
 101                 for (j = 0; j < 16; j++) {
 102                         unsigned char x;
 103                         if (i+j >= len)
 104                                 break;
 105
 106                         x = outbuf[i+j];
 107                         if (x < 32 || x > 127)
 108                                 x = '.';
 109
 110                         DEBUGADD( 4, ( "%c", x ) );
 111                 }
 112
 113                 DEBUGADD( 4, ( "%*s hex", 16-j, "" ) );
 114
 115                 for (j = 0; j < 16; j++) {
 116                         if (i+j >= len)
 117                                 break;
 118                         DEBUGADD( 4, ( " %02x", (unsigned char)outbuf[i+j] ) );
 119                 }
 120
 121                 DEBUGADD( 4, ("\n") );
 122         }
 123 }
 124
 125 /***************************************************************************
 126   Generates the unique transaction identifier
 127 **************************************************************************/
 128
 129 static uint16 name_trn_id=0;
 130
 131 static uint16 generate_name_trn_id(void)
 132 {
 133         if (!name_trn_id) {
 134                 name_trn_id = ((unsigned)time(NULL)%(unsigned)0x7FFF) + ((unsigned)sys_getpid()%(unsigned)100);
 135         }
 136         name_trn_id = (name_trn_id+1) % (unsigned)0x7FFF;
 137         return name_trn_id;
 138 }
 139
 140 /***************************************************************************
 141  Either loops back or sends out a completed NetBIOS packet.
 142 **************************************************************************/
 143
 144 static bool send_netbios_packet(struct packet_struct *p)
 145 {
 146         bool loopback_this_packet = False;
 147
 148         /* Check if we are sending to or from ourselves as a WINS server. */
 149         if(ismyip_v4(p->ip) && (p->port == global_nmb_port))
 150                 loopback_this_packet = True;
 151
 152         if(loopback_this_packet) {
 153                 struct packet_struct *lo_packet = NULL;
 154                 DEBUG(5,("send_netbios_packet: sending packet to ourselves.\n"));
 155                 if((lo_packet = copy_packet(p)) == NULL)
 156                         return False;
 157                 queue_packet(lo_packet);
 158         } else if (!send_packet(p)) {
 159                 DEBUG(0,("send_netbios_packet: send_packet() to IP %s port %d failed\n",
 160                         inet_ntoa(p->ip),p->port));
 161                 return False;
 162         }
 163
 164         return True;
 165 }
 166
 167 /***************************************************************************
 168  Sets up the common elements of an outgoing NetBIOS packet.
 169
 170  Note: do not attempt to rationalise whether rec_des should be set or not
 171  in a particular situation. Just follow rfc_1002 or look at examples from WinXX.
 172  It does NOT follow the rule that requests to the wins server always have
 173  rec_des true. See for example name releases and refreshes
 174 **************************************************************************/
 175
 176 static struct packet_struct *create_and_init_netbios_packet(struct nmb_name *nmbname,
 177                                                             bool bcast, bool rec_des,
 178                                                             struct in_addr to_ip)
 179 {
 180         struct packet_struct *packet = NULL;
 181         struct nmb_packet *nmb = NULL;
 182
 183         /* Allocate the packet_struct we will return. */
 184         if((packet = SMB_MALLOC_P(struct packet_struct)) == NULL) {
 185                 DEBUG(0,("create_and_init_netbios_packet: malloc fail (1) for packet struct.\n"));
 186                 return NULL;
 187         }
 188
 189         memset((char *)packet,'\0',sizeof(*packet));
 190
 191         nmb = &packet->packet.nmb;
 192
 193         nmb->header.name_trn_id = generate_name_trn_id();
 194         nmb->header.response = False;
 195         nmb->header.nm_flags.recursion_desired = rec_des;
 196         nmb->header.nm_flags.recursion_available = False;
 197         nmb->header.nm_flags.trunc = False;
 198         nmb->header.nm_flags.authoritative = False;
 199         nmb->header.nm_flags.bcast = bcast;
 200
 201         nmb->header.rcode = 0;
 202         nmb->header.qdcount = 1;
 203         nmb->header.ancount = 0;
 204         nmb->header.nscount = 0;
 205
 206         nmb->question.question_name = *nmbname;
 207         nmb->question.question_type = QUESTION_TYPE_NB_QUERY;
 208         nmb->question.question_class = QUESTION_CLASS_IN;
 209
 210         packet->ip = to_ip;
 211         packet->port = NMB_PORT;
 212         packet->fd = ClientNMB;
 213         packet->timestamp = time(NULL);
 214         packet->packet_type = NMB_PACKET;
 215         packet->locked = False;
 216
 217         return packet; /* Caller must free. */
 218 }
 219
 220 /***************************************************************************
 221  Sets up the common elements of register, refresh or release packet.
 222 **************************************************************************/
 223
 224 static bool create_and_init_additional_record(struct packet_struct *packet,
 225                                                      uint16 nb_flags,
 226                                                      const struct in_addr *register_ip)
 227 {
 228         struct nmb_packet *nmb = &packet->packet.nmb;
 229
 230         if((nmb->additional = SMB_MALLOC_P(struct res_rec)) == NULL) {
 231                 DEBUG(0,("create_and_init_additional_record: malloc fail for additional record.\n"));
 232                 return False;
 233         }
 234
 235         memset((char *)nmb->additional,'\0',sizeof(struct res_rec));
 236
 237         nmb->additional->rr_name  = nmb->question.question_name;
 238         nmb->additional->rr_type  = RR_TYPE_NB;
 239         nmb->additional->rr_class = RR_CLASS_IN;
 240
 241         /* See RFC 1002, sections 5.1.1.1, 5.1.1.2 and 5.1.1.3 */
 242         if (nmb->header.nm_flags.bcast)
 243                 nmb->additional->ttl = PERMANENT_TTL;
 244         else
 245                 nmb->additional->ttl = lp_max_ttl();
 246
 247         nmb->additional->rdlength = 6;
 248
 249         set_nb_flags(nmb->additional->rdata,nb_flags);
 250
 251         /* Set the address for the name we are registering. */
 252         putip(&nmb->additional->rdata[2], register_ip);
 253
 254         /*
 255            it turns out that Jeremys code was correct, we are supposed
 256            to send registrations from the IP we are registering. The
 257            trick is what to do on timeouts! When we send on a
 258            non-routable IP then the reply will timeout, and we should
 259            treat this as success, not failure. That means we go into
 260            our standard refresh cycle for that name which copes nicely
 261            with disconnected networks.
 262         */
 263         packet->fd = find_subnet_fd_for_address(*register_ip);
 264
 265         return True;
 266 }
 267
 268 /***************************************************************************
 269  Sends out a name query.
 270 **************************************************************************/
 271
 272 static bool initiate_name_query_packet( struct packet_struct *packet)
 273 {
 274         struct nmb_packet *nmb = NULL;
 275
 276         nmb = &packet->packet.nmb;
 277
 278         nmb->header.opcode = NMB_NAME_QUERY_OPCODE;
 279         nmb->header.arcount = 0;
 280
 281         nmb->header.nm_flags.recursion_desired = True;
 282
 283         DEBUG(4,("initiate_name_query_packet: sending query for name %s (bcast=%s) to IP %s\n",
 284                 nmb_namestr(&nmb->question.question_name),
 285                 BOOLSTR(nmb->header.nm_flags.bcast), inet_ntoa(packet->ip)));
 286
 287         return send_netbios_packet( packet );
 288 }
 289
 290 /***************************************************************************
 291  Sends out a name query - from a WINS server.
 292 **************************************************************************/
 293
 294 static bool initiate_name_query_packet_from_wins_server( struct packet_struct *packet)
 295 {
 296         struct nmb_packet *nmb = NULL;
 297
 298         nmb = &packet->packet.nmb;
 299
 300         nmb->header.opcode = NMB_NAME_QUERY_OPCODE;
 301         nmb->header.arcount = 0;
 302
 303         nmb->header.nm_flags.recursion_desired = False;
 304
 305         DEBUG(4,("initiate_name_query_packet_from_wins_server: sending query for name %s (bcast=%s) to IP %s\n",
 306                 nmb_namestr(&nmb->question.question_name),
 307                 BOOLSTR(nmb->header.nm_flags.bcast), inet_ntoa(packet->ip)));
 308
 309         return send_netbios_packet( packet );
 310 }
 311
 312 /***************************************************************************
 313  Sends out a name register.
 314 **************************************************************************/
 315
 316 static bool initiate_name_register_packet( struct packet_struct *packet,
 317                                     uint16 nb_flags, const struct in_addr *register_ip)
 318 {
 319         struct nmb_packet *nmb = &packet->packet.nmb;
 320
 321         nmb->header.opcode = NMB_NAME_REG_OPCODE;
 322         nmb->header.arcount = 1;
 323
 324         nmb->header.nm_flags.recursion_desired = True;
 325
 326         if(create_and_init_additional_record(packet, nb_flags, register_ip) == False)
 327                 return False;
 328
 329         DEBUG(4,("initiate_name_register_packet: sending registration for name %s (bcast=%s) to IP %s\n",
 330                 nmb_namestr(&nmb->additional->rr_name),
 331                 BOOLSTR(nmb->header.nm_flags.bcast), inet_ntoa(packet->ip)));
 332
 333         return send_netbios_packet( packet );
 334 }
 335
 336 /***************************************************************************
 337  Sends out a multihomed name register.
 338 **************************************************************************/
 339
 340 static bool initiate_multihomed_name_register_packet(struct packet_struct *packet,
 341                                                      uint16 nb_flags, struct in_addr *register_ip)
 342 {
 343         struct nmb_packet *nmb = &packet->packet.nmb;
 344         fstring second_ip_buf;
 345
 346         fstrcpy(second_ip_buf, inet_ntoa(packet->ip));
 347
 348         nmb->header.opcode = NMB_NAME_MULTIHOMED_REG_OPCODE;
 349         nmb->header.arcount = 1;
 350
 351         nmb->header.nm_flags.recursion_desired = True;
 352
 353         if(create_and_init_additional_record(packet, nb_flags, register_ip) == False)
 354                 return False;
 355
 356         DEBUG(4,("initiate_multihomed_name_register_packet: sending registration \
 357 for name %s IP %s (bcast=%s) to IP %s\n",
 358                  nmb_namestr(&nmb->additional->rr_name), inet_ntoa(*register_ip),
 359                  BOOLSTR(nmb->header.nm_flags.bcast), second_ip_buf ));
 360
 361         return send_netbios_packet( packet );
 362 }
 363
 364 /***************************************************************************
 365  Sends out a name refresh.
 366 **************************************************************************/
 367
 368 static bool initiate_name_refresh_packet( struct packet_struct *packet,
 369                                    uint16 nb_flags, struct in_addr *refresh_ip)
 370 {
 371         struct nmb_packet *nmb = &packet->packet.nmb;
 372
 373         nmb->header.opcode = NMB_NAME_REFRESH_OPCODE_8;
 374         nmb->header.arcount = 1;
 375
 376         nmb->header.nm_flags.recursion_desired = False;
 377
 378         if(create_and_init_additional_record(packet, nb_flags, refresh_ip) == False)
 379                 return False;
 380
 381         DEBUG(4,("initiate_name_refresh_packet: sending refresh for name %s (bcast=%s) to IP %s\n",
 382                 nmb_namestr(&nmb->additional->rr_name),
 383                 BOOLSTR(nmb->header.nm_flags.bcast), inet_ntoa(packet->ip)));
 384
 385         return send_netbios_packet( packet );
 386 }
 387
 388 /***************************************************************************
 389  Sends out a name release.
 390 **************************************************************************/
 391
 392 static bool initiate_name_release_packet( struct packet_struct *packet,
 393                                    uint16 nb_flags, struct in_addr *release_ip)
 394 {
 395         struct nmb_packet *nmb = &packet->packet.nmb;
 396
 397         nmb->header.opcode = NMB_NAME_RELEASE_OPCODE;
 398         nmb->header.arcount = 1;
 399
 400         nmb->header.nm_flags.recursion_desired = False;
 401
 402         if(create_and_init_additional_record(packet, nb_flags, release_ip) == False)
 403                 return False;
 404
 405         DEBUG(4,("initiate_name_release_packet: sending release for name %s (bcast=%s) to IP %s\n",
 406                 nmb_namestr(&nmb->additional->rr_name),
 407                 BOOLSTR(nmb->header.nm_flags.bcast), inet_ntoa(packet->ip)));
 408
 409         return send_netbios_packet( packet );
 410 }
 411
 412 /***************************************************************************
 413  Sends out a node status.
 414 **************************************************************************/
 415
 416 static bool initiate_node_status_packet( struct packet_struct *packet )
 417 {
 418         struct nmb_packet *nmb = &packet->packet.nmb;
 419
 420         nmb->header.opcode = NMB_NAME_QUERY_OPCODE;
 421         nmb->header.arcount = 0;
 422
 423         nmb->header.nm_flags.recursion_desired = False;
 424
 425         nmb->question.question_type = QUESTION_TYPE_NB_STATUS;
 426
 427         DEBUG(4,("initiate_node_status_packet: sending node status request for name %s to IP %s\n",
 428                 nmb_namestr(&nmb->question.question_name),
 429                 inet_ntoa(packet->ip)));
 430
 431         return send_netbios_packet( packet );
 432 }
 433
 434 /****************************************************************************
 435   Simplification functions for queuing standard packets.
 436   These should be the only publicly callable functions for sending
 437   out packets.
 438 ****************************************************************************/
 439
 440 /****************************************************************************
 441  Assertion - we should never be sending nmbd packets on the remote
 442  broadcast subnet.
 443 ****************************************************************************/
 444
 445 static bool assert_check_subnet(struct subnet_record *subrec)
 446 {
 447         if( subrec == remote_broadcast_subnet) {
 448                 DEBUG(0,("assert_check_subnet: Attempt to send packet on remote broadcast subnet. \
 449 This is a bug.\n"));
 450                 return True;
 451         }
 452         return False;
 453 }
 454
 455 /****************************************************************************
 456  Queue a register name packet to the broadcast address of a subnet.
 457 ****************************************************************************/
 458
 459 struct response_record *queue_register_name( struct subnet_record *subrec,
 460                           response_function resp_fn,
 461                           timeout_response_function timeout_fn,
 462                           register_name_success_function success_fn,
 463                           register_name_fail_function fail_fn,
 464                           struct userdata_struct *userdata,
 465                           struct nmb_name *nmbname,
 466                           uint16 nb_flags)
 467 {
 468         struct packet_struct *p;
 469         struct response_record *rrec;
 470         struct sockaddr_storage ss;
 471         const struct sockaddr_storage *pss = NULL;
 472         if(assert_check_subnet(subrec))
 473                 return NULL;
 474
 475         /* note that all name registration requests have RD set (rfc1002 - section 4.2.2 */
 476         if ((p = create_and_init_netbios_packet(nmbname, (subrec != unicast_subnet), True,
 477                                 subrec->bcast_ip)) == NULL)
 478                 return NULL;
 479
 480         in_addr_to_sockaddr_storage(&ss, subrec->bcast_ip);
 481         pss = iface_ip(&ss);
 482         if (!pss || pss->ss_family != AF_INET) {
 483                 p->locked = False;
 484                 free_packet(p);
 485                 return NULL;
 486         }
 487
 488         if(initiate_name_register_packet(p, nb_flags,
 489                         &((const struct sockaddr_in *)pss)->sin_addr) == False) {
 490                 p->locked = False;
 491                 free_packet(p);
 492                 return NULL;
 493         }
 494
 495         if((rrec = make_response_record(subrec,        /* subnet record. */
 496                                 p,                     /* packet we sent. */
 497                                 resp_fn,               /* function to call on response. */
 498                                 timeout_fn,            /* function to call on timeout. */
 499                                 (success_function)success_fn,            /* function to call on operation success. */
 500                                 (fail_function)fail_fn,               /* function to call on operation fail. */
 501                                 userdata)) == NULL)  {
 502                 p->locked = False;
 503                 free_packet(p);
 504                 return NULL;
 505         }
 506
 507         return rrec;
 508 }
 509
 510 /****************************************************************************
 511  Queue a refresh name packet to the broadcast address of a subnet.
 512 ****************************************************************************/
 513
 514 void queue_wins_refresh(struct nmb_name *nmbname,
 515                         response_function resp_fn,
 516                         timeout_response_function timeout_fn,
 517                         uint16 nb_flags,
 518                         struct in_addr refresh_ip,
 519                         const char *tag)
 520 {
 521         struct packet_struct *p;
 522         struct response_record *rrec;
 523         struct in_addr wins_ip;
 524         struct userdata_struct *userdata;
 525         fstring ip_str;
 526
 527         wins_ip = wins_srv_ip_tag(tag, refresh_ip);
 528
 529         if ((p = create_and_init_netbios_packet(nmbname, False, False, wins_ip)) == NULL) {
 530                 return;
 531         }
 532
 533         if (!initiate_name_refresh_packet(p, nb_flags, &refresh_ip)) {
 534                 p->locked = False;
 535                 free_packet(p);
 536                 return;
 537         }
 538
 539         fstrcpy(ip_str, inet_ntoa(refresh_ip));
 540
 541         DEBUG(6,("Refreshing name %s IP %s with WINS server %s using tag '%s'\n",
 542                  nmb_namestr(nmbname), ip_str, inet_ntoa(wins_ip), tag));
 543
 544         userdata = (struct userdata_struct *)SMB_MALLOC(sizeof(*userdata) + strlen(tag) + 1);
 545         if (!userdata) {
 546                 p->locked = False;
 547                 free_packet(p);
 548                 DEBUG(0,("Failed to allocate userdata structure!\n"));
 549                 return;
 550         }
 551         ZERO_STRUCTP(userdata);
 552         userdata->userdata_len = strlen(tag) + 1;
 553         strlcpy(userdata->data, tag, userdata->userdata_len);
 554
 555         if ((rrec = make_response_record(unicast_subnet,
 556                                          p,
 557                                          resp_fn, timeout_fn,
 558                                          NULL,
 559                                          NULL,
 560                                          userdata)) == NULL) {
 561                 p->locked = False;
 562                 free_packet(p);
 563                 return;
 564         }
 565
 566         free(userdata);
 567
 568         /* we don't want to repeat refresh packets */
 569         rrec->repeat_count = 0;
 570 }
 571
 572
 573 /****************************************************************************
 574  Queue a multihomed register name packet to a given WINS server IP
 575 ****************************************************************************/
 576
 577 struct response_record *queue_register_multihomed_name( struct subnet_record *subrec,
 578                                                         response_function resp_fn,
 579                                                         timeout_response_function timeout_fn,
 580                                                         register_name_success_function success_fn,
 581                                                         register_name_fail_function fail_fn,
 582                                                         struct userdata_struct *userdata,
 583                                                         struct nmb_name *nmbname,
 584                                                         uint16 nb_flags,
 585                                                         struct in_addr register_ip,
 586                                                         struct in_addr wins_ip)
 587 {
 588         struct packet_struct *p;
 589         struct response_record *rrec;
 590         bool ret;
 591
 592         /* Sanity check. */
 593         if(subrec != unicast_subnet) {
 594                 DEBUG(0,("queue_register_multihomed_name: should only be done on \
 595 unicast subnet. subnet is %s\n.", subrec->subnet_name ));
 596                 return NULL;
 597         }
 598
 599         if(assert_check_subnet(subrec))
 600                 return NULL;
 601
 602         if ((p = create_and_init_netbios_packet(nmbname, False, True, wins_ip)) == NULL)
 603                 return NULL;
 604
 605         if (nb_flags & NB_GROUP)
 606                 ret = initiate_name_register_packet( p, nb_flags, &register_ip);
 607         else
 608                 ret = initiate_multihomed_name_register_packet(p, nb_flags, &register_ip);
 609
 610         if (ret == False) {
 611                 p->locked = False;
 612                 free_packet(p);
 613                 return NULL;
 614         }
 615
 616         if ((rrec = make_response_record(subrec,    /* subnet record. */
 617                                          p,                     /* packet we sent. */
 618                                          resp_fn,               /* function to call on response. */
 619                                          timeout_fn,            /* function to call on timeout. */
 620                                          (success_function)success_fn, /* function to call on operation success. */
 621                                          (fail_function)fail_fn,       /* function to call on operation fail. */
 622                                          userdata)) == NULL) {
 623                 p->locked = False;
 624                 free_packet(p);
 625                 return NULL;
 626         }
 627
 628         return rrec;
 629 }
 630
 631 /****************************************************************************
 632  Queue a release name packet to the broadcast address of a subnet.
 633 ****************************************************************************/
 634
 635 struct response_record *queue_release_name( struct subnet_record *subrec,
 636                                             response_function resp_fn,
 637                                             timeout_response_function timeout_fn,
 638                                             release_name_success_function success_fn,
 639                                             release_name_fail_function fail_fn,
 640                                             struct userdata_struct *userdata,
 641                                             struct nmb_name *nmbname,
 642                                             uint16 nb_flags,
 643                                             struct in_addr release_ip,
 644                                             struct in_addr dest_ip)
 645 {
 646         struct packet_struct *p;
 647         struct response_record *rrec;
 648
 649         if(assert_check_subnet(subrec))
 650                 return NULL;
 651
 652         if ((p = create_and_init_netbios_packet(nmbname, (subrec != unicast_subnet), False, dest_ip)) == NULL)
 653                 return NULL;
 654
 655         if(initiate_name_release_packet( p, nb_flags, &release_ip) == False) {
 656                 p->locked = False;
 657                 free_packet(p);
 658                 return NULL;
 659         }
 660
 661         if((rrec = make_response_record(subrec,                /* subnet record. */
 662                                         p,                     /* packet we sent. */
 663                                         resp_fn,               /* function to call on response. */
 664                                         timeout_fn,            /* function to call on timeout. */
 665                                         (success_function)success_fn,            /* function to call on operation success. */
 666                                         (fail_function)fail_fn,               /* function to call on operation fail. */
 667                                         userdata)) == NULL)  {
 668                 p->locked = False;
 669                 free_packet(p);
 670                 return NULL;
 671         }
 672
 673         /*
 674          * For a broadcast release packet, only send once.
 675          * This will cause us to remove the name asap. JRA.
 676          */
 677
 678         if (subrec != unicast_subnet) {
 679                 rrec->repeat_count = 0;
 680                 rrec->repeat_time = 0;
 681         }
 682
 683         return rrec;
 684 }
 685
 686 /****************************************************************************
 687  Queue a query name packet to the broadcast address of a subnet.
 688 ****************************************************************************/
 689
 690 struct response_record *queue_query_name( struct subnet_record *subrec,
 691                           response_function resp_fn,
 692                           timeout_response_function timeout_fn,
 693                           query_name_success_function success_fn,
 694                           query_name_fail_function fail_fn,
 695                           struct userdata_struct *userdata,
 696                           struct nmb_name *nmbname)
 697 {
 698         struct packet_struct *p;
 699         struct response_record *rrec;
 700         struct in_addr to_ip;
 701
 702         if(assert_check_subnet(subrec))
 703                 return NULL;
 704
 705         to_ip = subrec->bcast_ip;
 706
 707         /* queries to the WINS server turn up here as queries to IP 0.0.0.0
 708                         These need to be handled a bit differently */
 709         if (subrec->type == UNICAST_SUBNET && is_zero_ip_v4(to_ip)) {
 710                 /* What we really need to do is loop over each of our wins
 711                  * servers and wins server tags here, but that just doesn't
 712                  * fit our architecture at the moment (userdata may already
 713                  * be used when we get here). For now we just query the first
 714                  * active wins server on the first tag.
 715                  */
 716                 char **tags = wins_srv_tags();
 717                 if (!tags) {
 718                         return NULL;
 719                 }
 720                 to_ip = wins_srv_ip_tag(tags[0], to_ip);
 721                 wins_srv_tags_free(tags);
 722         }
 723
 724         if(( p = create_and_init_netbios_packet(nmbname,
 725                                         (subrec != unicast_subnet),
 726                                         (subrec == unicast_subnet),
 727                                         to_ip)) == NULL)
 728                 return NULL;
 729
 730         if(lp_bind_interfaces_only()) {
 731                 int i;
 732
 733                 DEBUG(10,("queue_query_name: bind_interfaces_only is set, looking for suitable source IP\n"));
 734                 for(i = 0; i < iface_count(); i++) {
 735                         const struct in_addr *ifip = iface_n_ip_v4(i);
 736
 737                         if (ifip == NULL) {
 738                                 DEBUG(0,("queue_query_name: interface %d has NULL IP address !\n", i));
 739                                 continue;
 740                         }
 741
 742                         if (is_loopback_ip_v4(*ifip)) {
 743                                 DEBUG(5,("queue_query_name: ignoring loopback interface (%d)\n", i));
 744                                 continue;
 745                         }
 746
 747                         DEBUG(10,("queue_query_name: using source IP %s\n",inet_ntoa(*ifip)));
 748                                 p->fd = find_subnet_fd_for_address( *ifip );
 749                                 break;
 750                 }
 751         }
 752
 753         if(initiate_name_query_packet( p ) == False) {
 754                 p->locked = False;
 755                 free_packet(p);
 756                 return NULL;
 757         }
 758
 759         if((rrec = make_response_record(subrec,                /* subnet record. */
 760                                         p,                     /* packet we sent. */
 761                                         resp_fn,               /* function to call on response. */
 762                                         timeout_fn,            /* function to call on timeout. */
 763                                         (success_function)success_fn,            /* function to call on operation success. */
 764                                         (fail_function)fail_fn,               /* function to call on operation fail. */
 765                                         userdata)) == NULL) {
 766                 p->locked = False;
 767                 free_packet(p);
 768                 return NULL;
 769         }
 770
 771         return rrec;
 772 }
 773
 774 /****************************************************************************
 775  Queue a query name packet to a given address from the WINS subnet.
 776 ****************************************************************************/
 777
 778 struct response_record *queue_query_name_from_wins_server( struct in_addr to_ip,
 779                           response_function resp_fn,
 780                           timeout_response_function timeout_fn,
 781                           query_name_success_function success_fn,
 782                           query_name_fail_function fail_fn,
 783                           struct userdata_struct *userdata,
 784                           struct nmb_name *nmbname)
 785 {
 786         struct packet_struct *p;
 787         struct response_record *rrec;
 788
 789         if ((p = create_and_init_netbios_packet(nmbname, False, False, to_ip)) == NULL)
 790                 return NULL;
 791
 792         if(initiate_name_query_packet_from_wins_server( p ) == False) {
 793                 p->locked = False;
 794                 free_packet(p);
 795                 return NULL;
 796         }
 797
 798         if((rrec = make_response_record(wins_server_subnet,            /* subnet record. */
 799                                                 p,                     /* packet we sent. */
 800                                                 resp_fn,               /* function to call on response. */
 801                                                 timeout_fn,            /* function to call on timeout. */
 802                                                 (success_function)success_fn,            /* function to call on operation success. */
 803                                                 (fail_function)fail_fn,               /* function to call on operation fail. */
 804                                                 userdata)) == NULL) {
 805                 p->locked = False;
 806                 free_packet(p);
 807                 return NULL;
 808         }
 809
 810         return rrec;
 811 }
 812
 813 /****************************************************************************
 814  Queue a node status packet to a given name and address.
 815 ****************************************************************************/
 816
 817 struct response_record *queue_node_status( struct subnet_record *subrec,
 818                           response_function resp_fn,
 819                           timeout_response_function timeout_fn,
 820                           node_status_success_function success_fn,
 821                           node_status_fail_function fail_fn,
 822                           struct userdata_struct *userdata,
 823                           struct nmb_name *nmbname,
 824                           struct in_addr send_ip)
 825 {
 826         struct packet_struct *p;
 827         struct response_record *rrec;
 828
 829         /* Sanity check. */
 830         if(subrec != unicast_subnet) {
 831                 DEBUG(0,("queue_register_multihomed_name: should only be done on \
 832 unicast subnet. subnet is %s\n.", subrec->subnet_name ));
 833                 return NULL;
 834         }
 835
 836         if(assert_check_subnet(subrec))
 837                 return NULL;
 838
 839         if(( p = create_and_init_netbios_packet(nmbname, False, False, send_ip)) == NULL)
 840                 return NULL;
 841
 842         if(initiate_node_status_packet(p) == False) {
 843                 p->locked = False;
 844                 free_packet(p);
 845                 return NULL;
 846         }
 847
 848         if((rrec = make_response_record(subrec,           /* subnet record. */
 849                                         p,                     /* packet we sent. */
 850                                         resp_fn,               /* function to call on response. */
 851                                         timeout_fn,            /* function to call on timeout. */
 852                                         (success_function)success_fn,            /* function to call on operation success. */
 853                                         (fail_function)fail_fn,               /* function to call on operation fail. */
 854                                         userdata)) == NULL) {
 855                 p->locked = False;
 856                 free_packet(p);
 857                 return NULL;
 858         }
 859
 860         return rrec;
 861 }
 862
 863 /****************************************************************************
 864   Reply to a netbios name packet.  see rfc1002.txt
 865 ****************************************************************************/
 866
 867 void reply_netbios_packet(struct packet_struct *orig_packet,
 868                           int rcode, enum netbios_reply_type_code rcv_code, int opcode,
 869                           int ttl, char *data,int len)
 870 {
 871         struct packet_struct packet;
 872         struct nmb_packet *nmb = NULL;
 873         struct res_rec answers;
 874         struct nmb_packet *orig_nmb = &orig_packet->packet.nmb;
 875         bool loopback_this_packet = False;
 876         int rr_type = RR_TYPE_NB;
 877         const char *packet_type = "unknown";
 878
 879         /* Check if we are sending to or from ourselves. */
 880         if(ismyip_v4(orig_packet->ip) && (orig_packet->port == global_nmb_port))
 881                 loopback_this_packet = True;
 882
 883         nmb = &packet.packet.nmb;
 884
 885         /* Do a partial copy of the packet. We clear the locked flag and
 886                         the resource record pointers. */
 887         packet = *orig_packet;   /* Full structure copy. */
 888         packet.locked = False;
 889         nmb->answers = NULL;
 890         nmb->nsrecs = NULL;
 891         nmb->additional = NULL;
 892
 893         switch (rcv_code) {
 894                 case NMB_STATUS:
 895                         packet_type = "nmb_status";
 896                         nmb->header.nm_flags.recursion_desired = False;
 897                         nmb->header.nm_flags.recursion_available = False;
 898                         rr_type = RR_TYPE_NBSTAT;
 899                         break;
 900                 case NMB_QUERY:
 901                         packet_type = "nmb_query";
 902                         nmb->header.nm_flags.recursion_desired = True;
 903                         nmb->header.nm_flags.recursion_available = True;
 904                         if (rcode) {
 905                                 rr_type = RR_TYPE_NULL;
 906                         }
 907                         break;
 908                 case NMB_REG:
 909                 case NMB_REG_REFRESH:
 910                         packet_type = "nmb_reg";
 911                         nmb->header.nm_flags.recursion_desired = True;
 912                         nmb->header.nm_flags.recursion_available = True;
 913                         break;
 914                 case NMB_REL:
 915                         packet_type = "nmb_rel";
 916                         nmb->header.nm_flags.recursion_desired = False;
 917                         nmb->header.nm_flags.recursion_available = False;
 918                         break;
 919                 case NMB_WAIT_ACK:
 920                         packet_type = "nmb_wack";
 921                         nmb->header.nm_flags.recursion_desired = False;
 922                         nmb->header.nm_flags.recursion_available = False;
 923                         rr_type = RR_TYPE_NULL;
 924                         break;
 925                 case WINS_REG:
 926                         packet_type = "wins_reg";
 927                         nmb->header.nm_flags.recursion_desired = True;
 928                         nmb->header.nm_flags.recursion_available = True;
 929                         break;
 930                 case WINS_QUERY:
 931                         packet_type = "wins_query";
 932                         nmb->header.nm_flags.recursion_desired = True;
 933                         nmb->header.nm_flags.recursion_available = True;
 934                         if (rcode) {
 935                                 rr_type = RR_TYPE_NULL;
 936                         }
 937                         break;
 938                 default:
 939                         DEBUG(0,("reply_netbios_packet: Unknown packet type: %s %s to ip %s\n",
 940                                 packet_type, nmb_namestr(&orig_nmb->question.question_name),
 941                                 inet_ntoa(packet.ip)));
 942                         return;
 943         }
 944
 945         DEBUG(4,("reply_netbios_packet: sending a reply of packet type: %s %s to ip %s \
 946 for id %hu\n", packet_type, nmb_namestr(&orig_nmb->question.question_name),
 947                         inet_ntoa(packet.ip), orig_nmb->header.name_trn_id));
 948
 949         nmb->header.name_trn_id = orig_nmb->header.name_trn_id;
 950         nmb->header.opcode = opcode;
 951         nmb->header.response = True;
 952         nmb->header.nm_flags.bcast = False;
 953         nmb->header.nm_flags.trunc = False;
 954         nmb->header.nm_flags.authoritative = True;
 955
 956         nmb->header.rcode = rcode;
 957         nmb->header.qdcount = 0;
 958         nmb->header.ancount = 1;
 959         nmb->header.nscount = 0;
 960         nmb->header.arcount = 0;
 961
 962         memset((char*)&nmb->question,'\0',sizeof(nmb->question));
 963
 964         nmb->answers = &answers;
 965         memset((char*)nmb->answers,'\0',sizeof(*nmb->answers));
 966
 967         nmb->answers->rr_name  = orig_nmb->question.question_name;
 968         nmb->answers->rr_type  = rr_type;
 969         nmb->answers->rr_class = RR_CLASS_IN;
 970         nmb->answers->ttl      = ttl;
 971
 972         if (data && len) {
 973                 if (len < 0 || len > sizeof(nmb->answers->rdata)) {
 974                         DEBUG(5,("reply_netbios_packet: "
 975                                 "invalid packet len (%d)\n",
 976                                 len ));
 977                         return;
 978                 }
 979                 nmb->answers->rdlength = len;
 980                 memcpy(nmb->answers->rdata, data, len);
 981         }
 982
 983         packet.packet_type = NMB_PACKET;
 984         /* Ensure we send out on the same fd that the original
 985                 packet came in on to give the correct source IP address. */
 986         packet.fd = orig_packet->fd;
 987         packet.timestamp = time(NULL);
 988
 989         debug_nmb_packet(&packet);
 990
 991         if(loopback_this_packet) {
 992                 struct packet_struct *lo_packet;
 993                 DEBUG(5,("reply_netbios_packet: sending packet to ourselves.\n"));
 994                 if((lo_packet = copy_packet(&packet)) == NULL)
 995                         return;
 996                 queue_packet(lo_packet);
 997         } else if (!send_packet(&packet)) {
 998                 DEBUG(0,("reply_netbios_packet: send_packet to IP %s port %d failed\n",
 999                         inet_ntoa(packet.ip),packet.port));
1000         }
1001 }
1002
1003 /*******************************************************************
1004   Queue a packet into a packet queue
1005 ******************************************************************/
1006
1007 static void queue_packet(struct packet_struct *packet)
1008 {
1009         struct packet_struct *p;
1010
1011         if (!packet_queue) {
1012                 packet->prev = NULL;
1013                 packet->next = NULL;
1014                 packet_queue = packet;
1015                 return;
1016         }
1017
1018         /* find the bottom */
1019         for (p=packet_queue;p->next;p=p->next)
1020                 ;
1021
1022         p->next = packet;
1023         packet->next = NULL;
1024         packet->prev = p;
1025 }
1026
1027 /****************************************************************************
1028  Try and find a matching subnet record for a datagram port 138 packet.
1029 ****************************************************************************/
1030
1031 static struct subnet_record *find_subnet_for_dgram_browse_packet(struct packet_struct *p)
1032 {
1033         struct subnet_record *subrec;
1034
1035         /* Go through all the broadcast subnets and see if the mask matches. */
1036         for (subrec = FIRST_SUBNET; subrec ; subrec = NEXT_SUBNET_EXCLUDING_UNICAST(subrec)) {
1037                 if(same_net_v4(p->ip, subrec->bcast_ip, subrec->mask_ip))
1038                         return subrec;
1039         }
1040
1041         /* If the subnet record is the remote announce broadcast subnet,
1042                 hack it here to be the first subnet. This is really gross and
1043                 is needed due to people turning on port 137/138 broadcast
1044                 forwarding on their routers. May fire and brimstone rain
1045                 down upon them...
1046         */
1047
1048         return FIRST_SUBNET;
1049 }
1050
1051 /****************************************************************************
1052 Dispatch a browse frame from port 138 to the correct processing function.
1053 ****************************************************************************/
1054
1055 static void process_browse_packet(struct packet_struct *p, char *buf,int len)
1056 {
1057         struct dgram_packet *dgram = &p->packet.dgram;
1058         int command = CVAL(buf,0);
1059         struct subnet_record *subrec = find_subnet_for_dgram_browse_packet(p);
1060         char scope[64];
1061         unstring src_name;
1062
1063         /* Drop the packet if it's a different NetBIOS scope, or the source is from one of our names. */
1064         pull_ascii(scope, dgram->dest_name.scope, 64, 64, STR_TERMINATE);
1065         if (!strequal(scope, global_scope())) {
1066                 DEBUG(7,("process_browse_packet: Discarding datagram from IP %s. Scope (%s) \
1067 mismatch with our scope (%s).\n", inet_ntoa(p->ip), scope, global_scope()));
1068                 return;
1069         }
1070
1071         pull_ascii_nstring(src_name, sizeof(src_name), dgram->source_name.name);
1072         if (is_myname(src_name)) {
1073                 DEBUG(0,("process_browse_packet: Discarding datagram from IP %s. Source name \
1074 %s is one of our names !\n", inet_ntoa(p->ip), nmb_namestr(&dgram->source_name)));
1075                 return;
1076         }
1077
1078         switch (command) {
1079                 case ANN_HostAnnouncement:
1080                         debug_browse_data(buf, len);
1081                         process_host_announce(subrec, p, buf+1);
1082                         break;
1083                 case ANN_DomainAnnouncement:
1084                         debug_browse_data(buf, len);
1085                         process_workgroup_announce(subrec, p, buf+1);
1086                         break;
1087                 case ANN_LocalMasterAnnouncement:
1088                         debug_browse_data(buf, len);
1089                         process_local_master_announce(subrec, p, buf+1);
1090                         break;
1091                 case ANN_AnnouncementRequest:
1092                         debug_browse_data(buf, len);
1093                         process_announce_request(subrec, p, buf+1);
1094                         break;
1095                 case ANN_Election:
1096                         debug_browse_data(buf, len);
1097                         process_election(subrec, p, buf+1);
1098                         break;
1099                 case ANN_GetBackupListReq:
1100                         debug_browse_data(buf, len);
1101                         process_get_backup_list_request(subrec, p, buf+1);
1102                         break;
1103                 case ANN_GetBackupListResp:
1104                         debug_browse_data(buf, len);
1105                         /* We never send ANN_GetBackupListReq so we should never get these. */
1106                         DEBUG(0,("process_browse_packet: Discarding GetBackupListResponse \
1107 packet from %s IP %s\n", nmb_namestr(&dgram->source_name), inet_ntoa(p->ip)));
1108                         break;
1109                 case ANN_ResetBrowserState:
1110                         debug_browse_data(buf, len);
1111                         process_reset_browser(subrec, p, buf+1);
1112                         break;
1113                 case ANN_MasterAnnouncement:
1114                         /* Master browser datagrams must be processed on the unicast subnet. */
1115                         subrec = unicast_subnet;
1116
1117                         debug_browse_data(buf, len);
1118                         process_master_browser_announce(subrec, p, buf+1);
1119                         break;
1120                 case ANN_BecomeBackup:
1121                         /*
1122                          * We don't currently implement this. Log it just in case.
1123                          */
1124                         debug_browse_data(buf, len);
1125                         DEBUG(10,("process_browse_packet: On subnet %s ignoring browse packet \
1126 command ANN_BecomeBackup from %s IP %s to %s\n", subrec->subnet_name, nmb_namestr(&dgram->source_name),
1127                                         inet_ntoa(p->ip), nmb_namestr(&dgram->dest_name)));
1128                         break;
1129                 default:
1130                         debug_browse_data(buf, len);
1131                         DEBUG(0,("process_browse_packet: On subnet %s ignoring browse packet \
1132 command code %d from %s IP %s to %s\n", subrec->subnet_name, command, nmb_namestr(&dgram->source_name),
1133                                 inet_ntoa(p->ip), nmb_namestr(&dgram->dest_name)));
1134                         break;
1135         }
1136 }
1137
1138 /****************************************************************************
1139  Dispatch a LanMan browse frame from port 138 to the correct processing function.
1140 ****************************************************************************/
1141
1142 static void process_lanman_packet(struct packet_struct *p, char *buf,int len)
1143 {
1144         struct dgram_packet *dgram = &p->packet.dgram;
1145         int command = SVAL(buf,0);
1146         struct subnet_record *subrec = find_subnet_for_dgram_browse_packet(p);
1147         char scope[64];
1148         unstring src_name;
1149
1150         /* Drop the packet if it's a different NetBIOS scope, or the source is from one of our names. */
1151
1152         pull_ascii(scope, dgram->dest_name.scope, 64, 64, STR_TERMINATE);
1153         if (!strequal(scope, global_scope())) {
1154                 DEBUG(7,("process_lanman_packet: Discarding datagram from IP %s. Scope (%s) \
1155 mismatch with our scope (%s).\n", inet_ntoa(p->ip), scope, global_scope()));
1156                 return;
1157         }
1158
1159         pull_ascii_nstring(src_name, sizeof(src_name), dgram->source_name.name);
1160         if (is_myname(src_name)) {
1161                 DEBUG(0,("process_lanman_packet: Discarding datagram from IP %s. Source name \
1162 %s is one of our names !\n", inet_ntoa(p->ip), nmb_namestr(&dgram->source_name)));
1163                 return;
1164         }
1165
1166         switch (command) {
1167                 case ANN_HostAnnouncement:
1168                         debug_browse_data(buf, len);
1169                         process_lm_host_announce(subrec, p, buf+1, len > 1 ? len-1 : 0);
1170                         break;
1171                 case ANN_AnnouncementRequest:
1172                         process_lm_announce_request(subrec, p, buf+1, len > 1 ? len-1 : 0);
1173                         break;
1174                 default:
1175                         DEBUG(0,("process_lanman_packet: On subnet %s ignoring browse packet \
1176 command code %d from %s IP %s to %s\n", subrec->subnet_name, command, nmb_namestr(&dgram->source_name),
1177                                 inet_ntoa(p->ip), nmb_namestr(&dgram->dest_name)));
1178                         break;
1179         }
1180 }
1181
1182 /****************************************************************************
1183   Determine if a packet is for us on port 138. Note that to have any chance of
1184   being efficient we need to drop as many packets as possible at this
1185   stage as subsequent processing is expensive.
1186 ****************************************************************************/
1187
1188 static bool listening(struct packet_struct *p,struct nmb_name *nbname)
1189 {
1190         struct subnet_record *subrec = NULL;
1191
1192         for (subrec = FIRST_SUBNET; subrec ; subrec = NEXT_SUBNET_EXCLUDING_UNICAST(subrec)) {
1193                 if(same_net_v4(p->ip, subrec->bcast_ip, subrec->mask_ip))
1194                         break;
1195         }
1196
1197         if(subrec == NULL)
1198                 subrec = unicast_subnet;
1199
1200         return (find_name_on_subnet(subrec, nbname, FIND_SELF_NAME) != NULL);
1201 }
1202
1203 /****************************************************************************
1204   Process udp 138 datagrams
1205 ****************************************************************************/
1206
1207 static void process_dgram(struct packet_struct *p)
1208 {
1209         char *buf;
1210         char *buf2;
1211         int len;
1212         struct dgram_packet *dgram = &p->packet.dgram;
1213
1214         /* If we aren't listening to the destination name then ignore the packet */
1215         if (!listening(p,&dgram->dest_name)) {
1216                         unexpected_packet(p);
1217                         DEBUG(5,("process_dgram: ignoring dgram packet sent to name %s from %s\n",
1218                                 nmb_namestr(&dgram->dest_name), inet_ntoa(p->ip)));
1219                         return;
1220         }
1221
1222         if (dgram->header.msg_type != 0x10 && dgram->header.msg_type != 0x11 && dgram->header.msg_type != 0x12) {
1223                 unexpected_packet(p);
1224                 /* Don't process error packets etc yet */
1225                 DEBUG(5,("process_dgram: ignoring dgram packet sent to name %s from IP %s as it is \
1226 an error packet of type %x\n", nmb_namestr(&dgram->dest_name), inet_ntoa(p->ip), dgram->header.msg_type));
1227                 return;
1228         }
1229
1230         /* Ensure we have a large enough packet before looking inside. */
1231         if (dgram->datasize < (smb_vwv12 - 2)) {
1232                 /* That's the offset minus the 4 byte length + 2 bytes of offset. */
1233                 DEBUG(0,("process_dgram: ignoring too short dgram packet (%u) sent to name %s from IP %s\n",
1234                         (unsigned int)dgram->datasize,
1235                         nmb_namestr(&dgram->dest_name),
1236                         inet_ntoa(p->ip) ));
1237                 return;
1238         }
1239
1240         buf = &dgram->data[0];
1241         buf -= 4; /* XXXX for the pseudo tcp length - someday I need to get rid of this */
1242
1243         if (CVAL(buf,smb_com) != SMBtrans)
1244                 return;
1245
1246         len = SVAL(buf,smb_vwv11);
1247         buf2 = smb_base(buf) + SVAL(buf,smb_vwv12);
1248
1249         if (len <= 0 || len > dgram->datasize) {
1250                 DEBUG(0,("process_dgram: ignoring malformed1 (datasize = %d, len = %d) datagram \
1251 packet sent to name %s from IP %s\n",
1252                         dgram->datasize,
1253                         len,
1254                         nmb_namestr(&dgram->dest_name),
1255                         inet_ntoa(p->ip) ));
1256                 return;
1257         }
1258
1259         if (buf2 < dgram->data || (buf2 >= dgram->data + dgram->datasize)) {
1260                 DEBUG(0,("process_dgram: ignoring malformed2 (datasize = %d, len=%d, off=%d) datagram \
1261 packet sent to name %s from IP %s\n",
1262                         dgram->datasize,
1263                         len,
1264                         (int)PTR_DIFF(buf2, dgram->data),
1265                         nmb_namestr(&dgram->dest_name),
1266                         inet_ntoa(p->ip) ));
1267                 return;
1268         }
1269
1270         if ((buf2 + len < dgram->data) || (buf2 + len > dgram->data + dgram->datasize)) {
1271                 DEBUG(0,("process_dgram: ignoring malformed3 (datasize = %d, len=%d, off=%d) datagram \
1272 packet sent to name %s from IP %s\n",
1273                         dgram->datasize,
1274                         len,
1275                         (int)PTR_DIFF(buf2, dgram->data),
1276                         nmb_namestr(&dgram->dest_name),
1277                         inet_ntoa(p->ip) ));
1278                 return;
1279         }
1280
1281         DEBUG(4,("process_dgram: datagram from %s to %s IP %s for %s of type %d len=%d\n",
1282                 nmb_namestr(&dgram->source_name),nmb_namestr(&dgram->dest_name),
1283                 inet_ntoa(p->ip), smb_buf(buf),CVAL(buf2,0),len));
1284
1285         /* Datagram packet received for the browser mailslot */
1286         if (strequal(smb_buf(buf),BROWSE_MAILSLOT)) {
1287                 process_browse_packet(p,buf2,len);
1288                 return;
1289         }
1290
1291         /* Datagram packet received for the LAN Manager mailslot */
1292         if (strequal(smb_buf(buf),LANMAN_MAILSLOT)) {
1293                 process_lanman_packet(p,buf2,len);
1294                 return;
1295         }
1296
1297         /* Datagram packet received for the domain logon mailslot */
1298         if (strequal(smb_buf(buf),NET_LOGON_MAILSLOT)) {
1299                 process_logon_packet(p,buf2,len,NET_LOGON_MAILSLOT);
1300                 return;
1301         }
1302
1303         /* Datagram packet received for the NT domain logon mailslot */
1304         if (strequal(smb_buf(buf),NT_LOGON_MAILSLOT)) {
1305                 process_logon_packet(p,buf2,len,NT_LOGON_MAILSLOT);
1306                 return;
1307         }
1308
1309         unexpected_packet(p);
1310 }
1311
1312 /****************************************************************************
1313   Validate a response nmb packet.
1314 ****************************************************************************/
1315
1316 static bool validate_nmb_response_packet( struct nmb_packet *nmb )
1317 {
1318         bool ignore = False;
1319
1320         switch (nmb->header.opcode) {
1321                 case NMB_NAME_REG_OPCODE:
1322                 case NMB_NAME_REFRESH_OPCODE_8: /* ambiguity in rfc1002 about which is correct. */
1323                 case NMB_NAME_REFRESH_OPCODE_9: /* WinNT uses 8 by default. */
1324                         if (nmb->header.ancount == 0) {
1325                                 DEBUG(0,("validate_nmb_response_packet: Bad REG/REFRESH Packet. "));
1326                                 ignore = True;
1327                         }
1328                         break;
1329
1330                 case NMB_NAME_QUERY_OPCODE:
1331                         if ((nmb->header.ancount != 0) && (nmb->header.ancount != 1)) {
1332                                 DEBUG(0,("validate_nmb_response_packet: Bad QUERY Packet. "));
1333                                 ignore = True;
1334                         }
1335                         break;
1336
1337                 case NMB_NAME_RELEASE_OPCODE:
1338                         if (nmb->header.ancount == 0) {
1339                                 DEBUG(0,("validate_nmb_response_packet: Bad RELEASE Packet. "));
1340                                 ignore = True;
1341                         }
1342                         break;
1343
1344                 case NMB_WACK_OPCODE:
1345                         /* Check WACK response here. */
1346                         if (nmb->header.ancount != 1) {
1347                                 DEBUG(0,("validate_nmb_response_packet: Bad WACK Packet. "));
1348                                 ignore = True;
1349                         }
1350                         break;
1351                 default:
1352                         DEBUG(0,("validate_nmb_response_packet: Ignoring packet with unknown opcode %d.\n",
1353                                         nmb->header.opcode));
1354                         return True;
1355         }
1356
1357         if(ignore)
1358                 DEBUG(0,("Ignoring response packet with opcode %d.\n", nmb->header.opcode));
1359
1360         return ignore;
1361 }
1362
1363 /****************************************************************************
1364   Validate a request nmb packet.
1365 ****************************************************************************/
1366
1367 static bool validate_nmb_packet( struct nmb_packet *nmb )
1368 {
1369         bool ignore = False;
1370
1371         switch (nmb->header.opcode) {
1372                 case NMB_NAME_REG_OPCODE:
1373                 case NMB_NAME_REFRESH_OPCODE_8: /* ambiguity in rfc1002 about which is correct. */
1374                 case NMB_NAME_REFRESH_OPCODE_9: /* WinNT uses 8 by default. */
1375                 case NMB_NAME_MULTIHOMED_REG_OPCODE:
1376                         if (nmb->header.qdcount==0 || nmb->header.arcount==0) {
1377                                 DEBUG(0,("validate_nmb_packet: Bad REG/REFRESH Packet. "));
1378                                 ignore = True;
1379                         }
1380                         break;
1381
1382                 case NMB_NAME_QUERY_OPCODE:
1383                         if ((nmb->header.qdcount == 0) || ((nmb->question.question_type != QUESTION_TYPE_NB_QUERY) &&
1384                                         (nmb->question.question_type != QUESTION_TYPE_NB_STATUS))) {
1385                                 DEBUG(0,("validate_nmb_packet: Bad QUERY Packet. "));
1386                                 ignore = True;
1387                         }
1388                         break;
1389
1390                 case NMB_NAME_RELEASE_OPCODE:
1391                         if (nmb->header.qdcount==0 || nmb->header.arcount==0) {
1392                                 DEBUG(0,("validate_nmb_packet: Bad RELEASE Packet. "));
1393                                 ignore = True;
1394                         }
1395                         break;
1396                 default:
1397                         DEBUG(0,("validate_nmb_packet: Ignoring packet with unknown opcode %d.\n",
1398                                 nmb->header.opcode));
1399                         return True;
1400         }
1401
1402         if(ignore)
1403                 DEBUG(0,("validate_nmb_packet: Ignoring request packet with opcode %d.\n", nmb->header.opcode));
1404
1405         return ignore;
1406 }
1407
1408 /****************************************************************************
1409   Find a subnet (and potentially a response record) for a packet.
1410 ****************************************************************************/
1411
1412 static struct subnet_record *find_subnet_for_nmb_packet( struct packet_struct *p,
1413                                                          struct response_record **pprrec)
1414 {
1415         struct nmb_packet *nmb = &p->packet.nmb;
1416         struct response_record *rrec = NULL;
1417         struct subnet_record *subrec = NULL;
1418
1419         if(pprrec != NULL)
1420                 *pprrec = NULL;
1421
1422         if(nmb->header.response) {
1423                 /* It's a response packet. Find a record for it or it's an error. */
1424
1425                 rrec = find_response_record( &subrec, nmb->header.name_trn_id);
1426                 if(rrec == NULL) {
1427                         DEBUG(3,("find_subnet_for_nmb_packet: response record not found for response id %hu\n",
1428                                 nmb->header.name_trn_id));
1429                         unexpected_packet(p);
1430                         return NULL;
1431                 }
1432
1433                 if(subrec == NULL) {
1434                         DEBUG(0,("find_subnet_for_nmb_packet: subnet record not found for response id %hu\n",
1435                                 nmb->header.name_trn_id));
1436                         return NULL;
1437                 }
1438
1439                 if(pprrec != NULL)
1440                         *pprrec = rrec;
1441                 return subrec;
1442         }
1443
1444         /* Try and see what subnet this packet belongs to. */
1445
1446         /* WINS server ? */
1447         if(packet_is_for_wins_server(p))
1448                 return wins_server_subnet;
1449
1450         /* If it wasn't a broadcast packet then send to the UNICAST subnet. */
1451         if(nmb->header.nm_flags.bcast == False)
1452                 return unicast_subnet;
1453
1454         /* Go through all the broadcast subnets and see if the mask matches. */
1455         for (subrec = FIRST_SUBNET; subrec ; subrec = NEXT_SUBNET_EXCLUDING_UNICAST(subrec)) {
1456                 if(same_net_v4(p->ip, subrec->bcast_ip, subrec->mask_ip))
1457                         return subrec;
1458         }
1459
1460         /* If none match it must have been a directed broadcast - assign the remote_broadcast_subnet. */
1461         return remote_broadcast_subnet;
1462 }
1463
1464 /****************************************************************************
1465   Process a nmb request packet - validate the packet and route it.
1466 ****************************************************************************/
1467
1468 static void process_nmb_request(struct packet_struct *p)
1469 {
1470         struct nmb_packet *nmb = &p->packet.nmb;
1471         struct subnet_record *subrec = NULL;
1472
1473         debug_nmb_packet(p);
1474
1475         /* Ensure we have a good packet. */
1476         if(validate_nmb_packet(nmb))
1477                 return;
1478
1479         /* Allocate a subnet to this packet - if we cannot - fail. */
1480         if((subrec = find_subnet_for_nmb_packet(p, NULL))==NULL)
1481                 return;
1482
1483         switch (nmb->header.opcode) {
1484                 case NMB_NAME_REG_OPCODE:
1485                         if(subrec == wins_server_subnet)
1486                                 wins_process_name_registration_request(subrec, p);
1487                         else
1488                                 process_name_registration_request(subrec, p);
1489                         break;
1490
1491                 case NMB_NAME_REFRESH_OPCODE_8: /* ambiguity in rfc1002 about which is correct. */
1492                 case NMB_NAME_REFRESH_OPCODE_9:
1493                         if(subrec == wins_server_subnet)
1494                                 wins_process_name_refresh_request(subrec, p);
1495                         else
1496                                 process_name_refresh_request(subrec, p);
1497                         break;
1498
1499                 case NMB_NAME_MULTIHOMED_REG_OPCODE:
1500                         if(subrec == wins_server_subnet) {
1501                                 wins_process_multihomed_name_registration_request(subrec, p);
1502                         } else {
1503                                 DEBUG(0,("process_nmb_request: Multihomed registration request must be \
1504 directed at a WINS server.\n"));
1505                         }
1506                         break;
1507
1508                 case NMB_NAME_QUERY_OPCODE:
1509                         switch (nmb->question.question_type) {
1510                                 case QUESTION_TYPE_NB_QUERY:
1511                                         if(subrec == wins_server_subnet)
1512                                                 wins_process_name_query_request(subrec, p);
1513                                         else
1514                                                 process_name_query_request(subrec, p);
1515                                         break;
1516                                 case QUESTION_TYPE_NB_STATUS:
1517                                         if(subrec == wins_server_subnet) {
1518                                                 DEBUG(0,("process_nmb_request: NB_STATUS request directed at WINS server is \
1519 not allowed.\n"));
1520                                                 break;
1521                                         } else {
1522                                                 process_node_status_request(subrec, p);
1523                                         }
1524                                         break;
1525                         }
1526                         break;
1527
1528                 case NMB_NAME_RELEASE_OPCODE:
1529                         if(subrec == wins_server_subnet)
1530                                 wins_process_name_release_request(subrec, p);
1531                         else
1532                                 process_name_release_request(subrec, p);
1533                         break;
1534         }
1535 }
1536
1537 /****************************************************************************
1538   Process a nmb response packet - validate the packet and route it.
1539   to either the WINS server or a normal response.
1540 ****************************************************************************/
1541
1542 static void process_nmb_response(struct packet_struct *p)
1543 {
1544         struct nmb_packet *nmb = &p->packet.nmb;
1545         struct subnet_record *subrec = NULL;
1546         struct response_record *rrec = NULL;
1547
1548         debug_nmb_packet(p);
1549
1550         if(validate_nmb_response_packet(nmb))
1551                 return;
1552
1553         if((subrec = find_subnet_for_nmb_packet(p, &rrec))==NULL)
1554                 return;
1555
1556         if(rrec == NULL) {
1557                 DEBUG(0,("process_nmb_response: response packet received but no response record \
1558 found for id = %hu. Ignoring packet.\n", nmb->header.name_trn_id));
1559                 return;
1560         }
1561
1562         /* Increment the number of responses received for this record. */
1563         rrec->num_msgs++;
1564         /* Ensure we don't re-send the request. */
1565         rrec->repeat_count = 0;
1566
1567         /* Call the response received function for this packet. */
1568         (*rrec->resp_fn)(subrec, rrec, p);
1569 }
1570
1571 /*******************************************************************
1572   Run elements off the packet queue till its empty
1573 ******************************************************************/
1574
1575 void run_packet_queue(void)
1576 {
1577         struct packet_struct *p;
1578
1579         while ((p = packet_queue)) {
1580                 packet_queue = p->next;
1581                 if (packet_queue)
1582                         packet_queue->prev = NULL;
1583                 p->next = p->prev = NULL;
1584
1585                 switch (p->packet_type) {
1586                         case NMB_PACKET:
1587                                 if(p->packet.nmb.header.response)
1588                                         process_nmb_response(p);
1589                                 else
1590                                         process_nmb_request(p);
1591                                 break;
1592
1593                         case DGRAM_PACKET:
1594                                 process_dgram(p);
1595                                 break;
1596                 }
1597                 free_packet(p);
1598         }
1599 }
1600
1601 /*******************************************************************
1602  Retransmit or timeout elements from all the outgoing subnet response
1603  record queues. NOTE that this code must also check the WINS server
1604  subnet for response records to timeout as the WINS server code
1605  can send requests to check if a client still owns a name.
1606  (Patch from Andrey Alekseyev <fetch@muffin.arcadia.spb.ru>).
1607 ******************************************************************/
1608
1609 void retransmit_or_expire_response_records(time_t t)
1610 {
1611         struct subnet_record *subrec;
1612
1613         for (subrec = FIRST_SUBNET; subrec; subrec = get_next_subnet_maybe_unicast_or_wins_server(subrec)) {
1614                 struct response_record *rrec, *nextrrec;
1615
1616   restart:
1617
1618                 for (rrec = subrec->responselist; rrec; rrec = nextrrec) {
1619                         nextrrec = rrec->next;
1620
1621                         if (rrec->repeat_time <= t) {
1622                                 if (rrec->repeat_count > 0) {
1623                                         /* Resend while we have a non-zero repeat_count. */
1624                                         if(!send_packet(rrec->packet)) {
1625                                                 DEBUG(0,("retransmit_or_expire_response_records: Failed to resend packet id %hu \
1626 to IP %s on subnet %s\n", rrec->response_id, inet_ntoa(rrec->packet->ip), subrec->subnet_name));
1627                                         }
1628                                         rrec->repeat_time = t + rrec->repeat_interval;
1629                                         rrec->repeat_count--;
1630                                 } else {
1631                                         DEBUG(4,("retransmit_or_expire_response_records: timeout for packet id %hu to IP %s \
1632 on subnet %s\n", rrec->response_id, inet_ntoa(rrec->packet->ip), subrec->subnet_name));
1633
1634                                         /*
1635                                          * Check the flag in this record to prevent recursion if we end
1636                                          * up in this function again via the timeout function call.
1637                                          */
1638
1639                                         if(!rrec->in_expiration_processing) {
1640
1641                                                 /*
1642                                                  * Set the recursion protection flag in this record.
1643                                                  */
1644
1645                                                 rrec->in_expiration_processing = True;
1646
1647                                                 /* Call the timeout function. This will deal with removing the
1648                                                                 timed out packet. */
1649                                                 if(rrec->timeout_fn) {
1650                                                         (*rrec->timeout_fn)(subrec, rrec);
1651                                                 } else {
1652                                                         /* We must remove the record ourself if there is
1653                                                                         no timeout function. */
1654                                                         remove_response_record(subrec, rrec);
1655                                                 }
1656                                                 /* We have changed subrec->responselist,
1657                                                  * restart from the beginning of this list. */
1658                                                 goto restart;
1659                                         } /* !rrec->in_expitation_processing */
1660                                 } /* rrec->repeat_count > 0 */
1661                         } /* rrec->repeat_time <= t */
1662                 } /* end for rrec */
1663         } /* end for subnet */
1664 }
1665
1666 /****************************************************************************
1667   Create an fd_set containing all the sockets in the subnet structures,
1668   plus the broadcast sockets.
1669 ***************************************************************************/
1670
1671 static bool create_listen_fdset(fd_set **ppset, int **psock_array, int *listen_number, int *maxfd)
1672 {
1673         int *sock_array = NULL;
1674         struct subnet_record *subrec = NULL;
1675         int count = 0;
1676         int num = 0;
1677         fd_set *pset = SMB_MALLOC_P(fd_set);
1678
1679         if(pset == NULL) {
1680                 DEBUG(0,("create_listen_fdset: malloc fail !\n"));
1681                 return True;
1682         }
1683
1684         /* Check that we can add all the fd's we need. */
1685         for (subrec = FIRST_SUBNET; subrec; subrec = NEXT_SUBNET_EXCLUDING_UNICAST(subrec))
1686                 count++;
1687
1688         if((count*2) + 2 > FD_SETSIZE) {
1689                 DEBUG(0,("create_listen_fdset: Too many file descriptors needed (%d). We can \
1690 only use %d.\n", (count*2) + 2, FD_SETSIZE));
1691                 SAFE_FREE(pset);
1692                 return True;
1693         }
1694
1695         if((sock_array = SMB_MALLOC_ARRAY(int, (count*2) + 2)) == NULL) {
1696                 DEBUG(0,("create_listen_fdset: malloc fail for socket array.\n"));
1697                 SAFE_FREE(pset);
1698                 return True;
1699         }
1700
1701         FD_ZERO(pset);
1702
1703         /* Add in the broadcast socket on 137. */
1704         FD_SET(ClientNMB,pset);
1705         sock_array[num++] = ClientNMB;
1706         *maxfd = MAX( *maxfd, ClientNMB);
1707
1708         /* Add in the 137 sockets on all the interfaces. */
1709         for (subrec = FIRST_SUBNET; subrec; subrec = NEXT_SUBNET_EXCLUDING_UNICAST(subrec)) {
1710                 FD_SET(subrec->nmb_sock,pset);
1711                 sock_array[num++] = subrec->nmb_sock;
1712                 *maxfd = MAX( *maxfd, subrec->nmb_sock);
1713         }
1714
1715         /* Add in the broadcast socket on 138. */
1716         FD_SET(ClientDGRAM,pset);
1717         sock_array[num++] = ClientDGRAM;
1718         *maxfd = MAX( *maxfd, ClientDGRAM);
1719
1720         /* Add in the 138 sockets on all the interfaces. */
1721         for (subrec = FIRST_SUBNET; subrec; subrec = NEXT_SUBNET_EXCLUDING_UNICAST(subrec)) {
1722                 FD_SET(subrec->dgram_sock,pset);
1723                 sock_array[num++] = subrec->dgram_sock;
1724                 *maxfd = MAX( *maxfd, subrec->dgram_sock);
1725         }
1726
1727         *listen_number = (count*2) + 2;
1728
1729         SAFE_FREE(*ppset);
1730         SAFE_FREE(*psock_array);
1731
1732         *ppset = pset;
1733         *psock_array = sock_array;
1734
1735         return False;
1736 }
1737
1738 /****************************************************************************
1739   Listens for NMB or DGRAM packets, and queues them.
1740   return True if the socket is dead
1741 ***************************************************************************/
1742
1743 bool listen_for_packets(bool run_election)
1744 {
1745         static fd_set *listen_set = NULL;
1746         static int listen_number = 0;
1747         static int *sock_array = NULL;
1748         int i;
1749         static int maxfd = 0;
1750
1751         fd_set r_fds;
1752         fd_set w_fds;
1753         int selrtn;
1754         struct timeval timeout;
1755 #ifndef SYNC_DNS
1756         int dns_fd;
1757 #endif
1758
1759         if(listen_set == NULL || rescan_listen_set) {
1760                 if(create_listen_fdset(&listen_set, &sock_array, &listen_number, &maxfd)) {
1761                         DEBUG(0,("listen_for_packets: Fatal error. unable to create listen set. Exiting.\n"));
1762                         return True;
1763                 }
1764                 rescan_listen_set = False;
1765         }
1766
1767         memcpy((char *)&r_fds, (char *)listen_set, sizeof(fd_set));
1768         FD_ZERO(&w_fds);
1769
1770 #ifndef SYNC_DNS
1771         dns_fd = asyncdns_fd();
1772         if (dns_fd != -1) {
1773                 FD_SET(dns_fd, &r_fds);
1774                 maxfd = MAX( maxfd, dns_fd);
1775         }
1776 #endif
1777
1778         /*
1779          * During elections and when expecting a netbios response packet we
1780          * need to send election packets at tighter intervals.
1781          * Ideally it needs to be the interval (in ms) between time now and
1782          * the time we are expecting the next netbios packet.
1783          */
1784
1785         timeout.tv_sec = (run_election||num_response_packets) ? 1 : NMBD_SELECT_LOOP;
1786         timeout.tv_usec = 0;
1787
1788         {
1789                 struct timeval now = timeval_current();
1790                 event_add_to_select_args(nmbd_event_context(), &now,
1791                                          &r_fds, &w_fds, &timeout, &maxfd);
1792         }
1793
1794         if (timeval_is_zero(&timeout)) {
1795                 /* Process a timed event now... */
1796                 if (run_events(nmbd_event_context(), 0, NULL, NULL)) {
1797                         return False;
1798                 }
1799         }
1800
1801         /* Prepare for the select - allow certain signals. */
1802
1803         BlockSignals(False, SIGTERM);
1804
1805         selrtn = sys_select(maxfd+1,&r_fds,&w_fds,NULL,&timeout);
1806
1807         /* We can only take signals when we are in the select - block them again here. */
1808
1809         BlockSignals(True, SIGTERM);
1810
1811         if(selrtn == -1) {
1812                 return False;
1813         }
1814
1815         if (run_events(nmbd_event_context(), selrtn, &r_fds, &w_fds)) {
1816                 return False;
1817         }
1818
1819 #ifndef SYNC_DNS
1820         if (dns_fd != -1 && FD_ISSET(dns_fd,&r_fds)) {
1821                 run_dns_queue();
1822         }
1823 #endif
1824
1825         for(i = 0; i < listen_number; i++) {
1826                 if (i < (listen_number/2)) {
1827                         /* Processing a 137 socket. */
1828                         if (FD_ISSET(sock_array[i],&r_fds)) {
1829                                 struct packet_struct *packet = read_packet(sock_array[i], NMB_PACKET);
1830                                 if (packet) {
1831                                         /*
1832                                          * If we got a packet on the broadcast socket and interfaces
1833                                          * only is set then check it came from one of our local nets.
1834                                          */
1835                                         if(lp_bind_interfaces_only() && (sock_array[i] == ClientNMB) &&
1836                                                                 (!is_local_net_v4(packet->ip))) {
1837                                                 DEBUG(7,("discarding nmb packet sent to broadcast socket from %s:%d\n",
1838                                                         inet_ntoa(packet->ip),packet->port));
1839                                                 free_packet(packet);
1840                                         } else if ((is_loopback_ip_v4(packet->ip) ||
1841                                                                 ismyip_v4(packet->ip)) && packet->port == global_nmb_port &&
1842                                                                 packet->packet.nmb.header.nm_flags.bcast) {
1843                                                 DEBUG(7,("discarding own bcast packet from %s:%d\n",
1844                                                         inet_ntoa(packet->ip),packet->port));
1845                                                 free_packet(packet);
1846                                         } else {
1847                                                 /* Save the file descriptor this packet came in on. */
1848                                                 packet->fd = sock_array[i];
1849                                                 queue_packet(packet);
1850                                         }
1851                                 }
1852                         }
1853                 } else {
1854                         /* Processing a 138 socket. */
1855                                 if (FD_ISSET(sock_array[i],&r_fds)) {
1856                                 struct packet_struct *packet = read_packet(sock_array[i], DGRAM_PACKET);
1857                                 if (packet) {
1858                                         /*
1859                                          * If we got a packet on the broadcast socket and interfaces
1860                                          * only is set then check it came from one of our local nets.
1861                                          */
1862                                         if(lp_bind_interfaces_only() && (sock_array[i] == ClientDGRAM) &&
1863                                                                 (!is_local_net_v4(packet->ip))) {
1864                                                 DEBUG(7,("discarding dgram packet sent to broadcast socket from %s:%d\n",
1865                                                 inet_ntoa(packet->ip),packet->port));
1866                                                 free_packet(packet);
1867                                         } else if ((is_loopback_ip_v4(packet->ip) ||
1868                                                         ismyip_v4(packet->ip)) && packet->port == DGRAM_PORT) {
1869                                                 DEBUG(7,("discarding own dgram packet from %s:%d\n",
1870                                                         inet_ntoa(packet->ip),packet->port));
1871                                                 free_packet(packet);
1872                                         } else {
1873                                                 /* Save the file descriptor this packet came in on. */
1874                                                 packet->fd = sock_array[i];
1875                                                 queue_packet(packet);
1876                                         }
1877                                 }
1878                         }
1879                 } /* end processing 138 socket. */
1880         } /* end for */
1881         return False;
1882 }
1883
1884 /****************************************************************************
1885   Construct and send a netbios DGRAM.
1886 **************************************************************************/
1887
1888 bool send_mailslot(bool unique, const char *mailslot,char *buf, size_t len,
1889                    const char *srcname, int src_type,
1890                    const char *dstname, int dest_type,
1891                    struct in_addr dest_ip,struct in_addr src_ip,
1892                    int dest_port)
1893 {
1894         bool loopback_this_packet = False;
1895         struct packet_struct p;
1896         struct dgram_packet *dgram = &p.packet.dgram;
1897         char *ptr,*p2;
1898         char tmp[4];
1899
1900         memset((char *)&p,'\0',sizeof(p));
1901
1902         if(ismyip_v4(dest_ip) && (dest_port == DGRAM_PORT)) /* Only if to DGRAM_PORT */
1903                 loopback_this_packet = True;
1904
1905         /* generate_name_trn_id(); */ /* Not used, so gone, RJS */
1906
1907         /* DIRECT GROUP or UNIQUE datagram. */
1908         dgram->header.msg_type = unique ? 0x10 : 0x11;
1909         dgram->header.flags.node_type = M_NODE;
1910         dgram->header.flags.first = True;
1911         dgram->header.flags.more = False;
1912         dgram->header.dgm_id = generate_name_trn_id();
1913         dgram->header.source_ip = src_ip;
1914         dgram->header.source_port = DGRAM_PORT;
1915         dgram->header.dgm_length = 0; /* Let build_dgram() handle this. */
1916         dgram->header.packet_offset = 0;
1917
1918         make_nmb_name(&dgram->source_name,srcname,src_type);
1919         make_nmb_name(&dgram->dest_name,dstname,dest_type);
1920
1921         ptr = &dgram->data[0];
1922
1923         /* Setup the smb part. */
1924         ptr -= 4; /* XXX Ugliness because of handling of tcp SMB length. */
1925         memcpy(tmp,ptr,4);
1926
1927         if (smb_size + 17*2 + strlen(mailslot) + 1 + len > MAX_DGRAM_SIZE) {
1928                 DEBUG(0, ("send_mailslot: Cannot write beyond end of packet\n"));
1929                 return false;
1930         }
1931
1932         cli_set_message(ptr,17,strlen(mailslot) + 1 + len,True);
1933         memcpy(ptr,tmp,4);
1934
1935         SCVAL(ptr,smb_com,SMBtrans);
1936         SSVAL(ptr,smb_vwv1,len);
1937         SSVAL(ptr,smb_vwv11,len);
1938         SSVAL(ptr,smb_vwv12,70 + strlen(mailslot));
1939         SSVAL(ptr,smb_vwv13,3);
1940         SSVAL(ptr,smb_vwv14,1);
1941         SSVAL(ptr,smb_vwv15,1);
1942         SSVAL(ptr,smb_vwv16,2);
1943         p2 = smb_buf(ptr);
1944         safe_strcpy_base(p2, mailslot, dgram->data, sizeof(dgram->data));
1945         p2 = skip_string(ptr,MAX_DGRAM_SIZE,p2);
1946
1947         if (((p2+len) > dgram->data+sizeof(dgram->data)) || ((p2+len) < p2)) {
1948                 DEBUG(0, ("send_mailslot: Cannot write beyond end of packet\n"));
1949                 return False;
1950         } else {
1951                 memcpy(p2,buf,len);
1952                 p2 += len;
1953         }
1954
1955         dgram->datasize = PTR_DIFF(p2,ptr+4); /* +4 for tcp length. */
1956
1957         p.ip = dest_ip;
1958         p.port = dest_port;
1959         p.fd = find_subnet_mailslot_fd_for_address( src_ip );
1960         p.timestamp = time(NULL);
1961         p.packet_type = DGRAM_PACKET;
1962
1963         DEBUG(4,("send_mailslot: Sending to mailslot %s from %s IP %s ", mailslot,
1964                         nmb_namestr(&dgram->source_name), inet_ntoa(src_ip)));
1965         DEBUG(4,("to %s IP %s\n", nmb_namestr(&dgram->dest_name), inet_ntoa(dest_ip)));
1966
1967         debug_browse_data(buf, len);
1968
1969         if(loopback_this_packet) {
1970                 struct packet_struct *lo_packet = NULL;
1971                 DEBUG(5,("send_mailslot: sending packet to ourselves.\n"));
1972                 if((lo_packet = copy_packet(&p)) == NULL)
1973                         return False;
1974                 queue_packet(lo_packet);
1975                 return True;
1976         } else {
1977                 return(send_packet(&p));
1978         }
1979 }