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