2 Unix SMB/Netbios implementation.
4 NBT netbios routines and daemon - version 2
5 Copyright (C) Andrew Tridgell 1994-1998
6 Copyright (C) Luke Kenneth Casson Leighton 1994-1998
7 Copyright (C) Jeremy Allison 1994-1998
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 2 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program; if not, write to the Free Software
21 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
28 extern int ClientDGRAM;
29 extern int global_nmb_port;
31 extern int DEBUGLEVEL;
33 extern int num_response_packets;
36 extern struct in_addr loopback_ip;
38 static void queue_packet(struct packet_struct *packet);
40 BOOL rescan_listen_set = False;
43 /*******************************************************************
44 The global packet linked-list. Incoming entries are
45 added to the end of this list. It is supposed to remain fairly
46 short so we won't bother with an end pointer.
47 ******************************************************************/
49 static struct packet_struct *packet_queue = NULL;
51 /***************************************************************************
52 Utility function to find the specific fd to send a packet out on.
53 **************************************************************************/
55 static int find_subnet_fd_for_address( struct in_addr local_ip )
57 struct subnet_record *subrec;
59 for( subrec = FIRST_SUBNET; subrec; subrec = NEXT_SUBNET_EXCLUDING_UNICAST(subrec))
60 if(ip_equal(local_ip, subrec->myip))
61 return subrec->nmb_sock;
66 /***************************************************************************
67 Utility function to find the specific fd to send a mailslot packet out on.
68 **************************************************************************/
70 static int find_subnet_mailslot_fd_for_address( struct in_addr local_ip )
72 struct subnet_record *subrec;
74 for( subrec = FIRST_SUBNET; subrec; subrec = NEXT_SUBNET_EXCLUDING_UNICAST(subrec))
75 if(ip_equal(local_ip, subrec->myip))
76 return subrec->dgram_sock;
81 /***************************************************************************
82 Get/Set problematic nb_flags as network byte order 16 bit int.
83 **************************************************************************/
85 uint16 get_nb_flags(char *buf)
87 return ((((uint16)*buf)&0xFFFF) & NB_FLGMSK);
90 void set_nb_flags(char *buf, uint16 nb_flags)
92 *buf++ = ((nb_flags & NB_FLGMSK) & 0xFF);
96 /***************************************************************************
97 Dumps out the browse packet data.
98 **************************************************************************/
100 static void debug_browse_data(char *outbuf, int len)
104 DEBUG( 4, ( "debug_browse_data():\n" ) );
105 for (i = 0; i < len; i+= 16)
107 DEBUGADD( 4, ( "%3x char ", i ) );
109 for (j = 0; j < 16; j++)
111 unsigned char x = outbuf[i+j];
112 if (x < 32 || x > 127)
117 DEBUGADD( 4, ( "%c", x ) );
120 DEBUGADD( 4, ( "%*s hex", 16-j, "" ) );
122 for (j = 0; j < 16; j++)
126 DEBUGADD( 4, ( " %02x", (unsigned char)outbuf[i+j] ) );
129 DEBUGADD( 4, ("\n") );
133 /***************************************************************************
134 Generates the unique transaction identifier
135 **************************************************************************/
137 static uint16 name_trn_id=0;
139 static uint16 generate_name_trn_id(void)
144 name_trn_id = ((unsigned)time(NULL)%(unsigned)0x7FFF) + ((unsigned)getpid()%(unsigned)100);
146 name_trn_id = (name_trn_id+1) % (unsigned)0x7FFF;
150 /***************************************************************************
151 Either loops back or sends out a completed NetBIOS packet.
152 **************************************************************************/
154 static BOOL send_netbios_packet(struct packet_struct *p)
156 BOOL loopback_this_packet = False;
158 /* Check if we are sending to or from ourselves as a WINS server. */
159 if(ismyip(p->ip) && (p->port == global_nmb_port))
160 loopback_this_packet = True;
162 if(loopback_this_packet)
164 struct packet_struct *lo_packet = NULL;
165 DEBUG(5,("send_netbios_packet: sending packet to ourselves.\n"));
166 if((lo_packet = copy_packet(p)) == NULL)
168 queue_packet(lo_packet);
170 else if (!send_packet(p))
172 DEBUG(0,("send_netbios_packet: send_packet() to IP %s port %d failed\n",
173 inet_ntoa(p->ip),p->port));
180 /***************************************************************************
181 Sets up the common elements of an outgoing NetBIOS packet.
182 **************************************************************************/
184 static struct packet_struct *create_and_init_netbios_packet(struct nmb_name *nmbname,
186 struct in_addr to_ip)
188 struct packet_struct *packet = NULL;
189 struct nmb_packet *nmb = NULL;
191 /* Allocate the packet_struct we will return. */
192 if((packet = (struct packet_struct *)malloc(sizeof(*packet))) == NULL)
194 DEBUG(0,("create_and_init_netbios_packet: malloc fail (1) for packet struct.\n"));
198 memset((char *)packet,'\0',sizeof(*packet));
200 nmb = &packet->packet.nmb;
202 nmb->header.name_trn_id = generate_name_trn_id();
203 nmb->header.response = False;
204 nmb->header.nm_flags.recursion_desired = False;
205 nmb->header.nm_flags.recursion_available = False;
206 nmb->header.nm_flags.trunc = False;
207 nmb->header.nm_flags.authoritative = False;
208 nmb->header.nm_flags.bcast = bcast;
210 nmb->header.rcode = 0;
211 nmb->header.qdcount = 1;
212 nmb->header.ancount = 0;
213 nmb->header.nscount = 0;
215 nmb->question.question_name = *nmbname;
216 nmb->question.question_type = QUESTION_TYPE_NB_QUERY;
217 nmb->question.question_class = QUESTION_CLASS_IN;
220 packet->port = NMB_PORT;
221 packet->fd = ClientNMB;
222 packet->timestamp = time(NULL);
223 packet->packet_type = NMB_PACKET;
224 packet->locked = False;
226 return packet; /* Caller must free. */
229 /***************************************************************************
230 Sets up the common elements of register, refresh or release packet.
231 **************************************************************************/
233 static BOOL create_and_init_additional_record(struct packet_struct *packet,
235 struct in_addr *register_ip)
237 struct nmb_packet *nmb = &packet->packet.nmb;
239 if((nmb->additional = (struct res_rec *)malloc(sizeof(struct res_rec))) == NULL)
241 DEBUG(0,("initiate_name_register_packet: malloc fail for additional record.\n"));
245 memset((char *)nmb->additional,'\0',sizeof(struct res_rec));
247 nmb->additional->rr_name = nmb->question.question_name;
248 nmb->additional->rr_type = RR_TYPE_NB;
249 nmb->additional->rr_class = RR_CLASS_IN;
251 /* See RFC 1002, sections 5.1.1.1, 5.1.1.2 and 5.1.1.3 */
252 if (nmb->header.nm_flags.bcast)
253 nmb->additional->ttl = PERMANENT_TTL;
255 nmb->additional->ttl = lp_max_ttl();
257 nmb->additional->rdlength = 6;
259 set_nb_flags(nmb->additional->rdata,nb_flags);
261 /* Set the address for the name we are registering. */
262 putip(&nmb->additional->rdata[2], register_ip);
264 /* Ensure that we send out the file descriptor to give us the
265 the specific source address we are registering as our
266 IP source address. */
268 packet->fd = find_subnet_fd_for_address( *register_ip );
273 /***************************************************************************
274 Sends out a name query.
275 **************************************************************************/
277 static BOOL initiate_name_query_packet( struct packet_struct *packet)
279 struct nmb_packet *nmb = NULL;
281 nmb = &packet->packet.nmb;
283 nmb->header.opcode = NMB_NAME_QUERY_OPCODE;
284 nmb->header.arcount = 0;
286 nmb->header.nm_flags.recursion_desired = True;
288 DEBUG(4,("initiate_name_query_packet: sending query for name %s (bcast=%s) to IP %s\n",
289 nmb_namestr(&nmb->question.question_name),
290 BOOLSTR(nmb->header.nm_flags.bcast), inet_ntoa(packet->ip)));
292 return send_netbios_packet( packet );
295 /***************************************************************************
296 Sends out a name query - from a WINS server.
297 **************************************************************************/
299 static BOOL initiate_name_query_packet_from_wins_server( struct packet_struct *packet)
301 struct nmb_packet *nmb = NULL;
303 nmb = &packet->packet.nmb;
305 nmb->header.opcode = NMB_NAME_QUERY_OPCODE;
306 nmb->header.arcount = 0;
308 nmb->header.nm_flags.recursion_desired = False;
310 DEBUG(4,("initiate_name_query_packet_from_wins_server: sending query for name %s (bcast=%s) to IP %s\n",
311 nmb_namestr(&nmb->question.question_name),
312 BOOLSTR(nmb->header.nm_flags.bcast), inet_ntoa(packet->ip)));
314 return send_netbios_packet( packet );
317 /***************************************************************************
318 Sends out a name register.
319 **************************************************************************/
321 static BOOL initiate_name_register_packet( struct packet_struct *packet,
322 uint16 nb_flags, struct in_addr *register_ip)
324 struct nmb_packet *nmb = &packet->packet.nmb;
326 nmb->header.opcode = NMB_NAME_REG_OPCODE;
327 nmb->header.arcount = 1;
329 nmb->header.nm_flags.recursion_desired = True;
331 if(create_and_init_additional_record(packet, nb_flags, register_ip) == False)
334 DEBUG(4,("initiate_name_register_packet: sending registration for name %s (bcast=%s) to IP %s\n",
335 nmb_namestr(&nmb->additional->rr_name),
336 BOOLSTR(nmb->header.nm_flags.bcast), inet_ntoa(packet->ip)));
338 return send_netbios_packet( packet );
341 /***************************************************************************
342 Sends out a multihomed name register.
343 **************************************************************************/
345 static BOOL initiate_multihomed_name_register_packet( struct packet_struct *packet,
346 uint16 nb_flags, struct in_addr *register_ip)
348 struct nmb_packet *nmb = &packet->packet.nmb;
349 fstring second_ip_buf;
351 fstrcpy(second_ip_buf, inet_ntoa(packet->ip));
353 nmb->header.opcode = NMB_NAME_MULTIHOMED_REG_OPCODE;
354 nmb->header.arcount = 1;
356 nmb->header.nm_flags.recursion_desired = True;
358 if(create_and_init_additional_record(packet, nb_flags, register_ip) == False)
361 DEBUG(4,("initiate_multihomed_name_register_packet: sending registration \
362 for name %s IP %s (bcast=%s) to IP %s\n",
363 nmb_namestr(&nmb->additional->rr_name), inet_ntoa(*register_ip),
364 BOOLSTR(nmb->header.nm_flags.bcast), second_ip_buf ));
366 return send_netbios_packet( packet );
369 /***************************************************************************
370 Sends out a name refresh.
371 **************************************************************************/
373 static BOOL initiate_name_refresh_packet( struct packet_struct *packet,
374 uint16 nb_flags, struct in_addr *refresh_ip)
376 struct nmb_packet *nmb = &packet->packet.nmb;
378 nmb->header.opcode = NMB_NAME_REFRESH_OPCODE_8;
379 nmb->header.arcount = 1;
381 nmb->header.nm_flags.recursion_desired = False;
383 if(create_and_init_additional_record(packet, nb_flags, refresh_ip) == False)
386 DEBUG(4,("initiate_name_refresh_packet: sending refresh for name %s (bcast=%s) to IP %s\n",
387 nmb_namestr(&nmb->additional->rr_name),
388 BOOLSTR(nmb->header.nm_flags.bcast), inet_ntoa(packet->ip)));
390 return send_netbios_packet( packet );
393 /***************************************************************************
394 Sends out a name release.
395 **************************************************************************/
397 static BOOL initiate_name_release_packet( struct packet_struct *packet,
398 uint16 nb_flags, struct in_addr *release_ip)
400 struct nmb_packet *nmb = &packet->packet.nmb;
402 nmb->header.opcode = NMB_NAME_RELEASE_OPCODE;
403 nmb->header.arcount = 1;
405 nmb->header.nm_flags.recursion_desired = False;
407 if(create_and_init_additional_record(packet, nb_flags, release_ip) == False)
410 DEBUG(4,("initiate_name_release_packet: sending release for name %s (bcast=%s) to IP %s\n",
411 nmb_namestr(&nmb->additional->rr_name),
412 BOOLSTR(nmb->header.nm_flags.bcast), inet_ntoa(packet->ip)));
414 return send_netbios_packet( packet );
417 /***************************************************************************
418 Sends out a node status.
419 **************************************************************************/
421 static BOOL initiate_node_status_packet( struct packet_struct *packet )
423 struct nmb_packet *nmb = &packet->packet.nmb;
425 nmb->header.opcode = NMB_NAME_QUERY_OPCODE;
426 nmb->header.arcount = 0;
428 nmb->header.nm_flags.recursion_desired = False;
430 nmb->question.question_type = QUESTION_TYPE_NB_STATUS;
432 DEBUG(4,("initiate_node_status_packet: sending node status request for name %s to IP %s\n",
433 nmb_namestr(&nmb->question.question_name),
434 inet_ntoa(packet->ip)));
436 return send_netbios_packet( packet );
439 /****************************************************************************
440 Simplification functions for queuing standard packets.
441 These should be the only publicly callable functions for sending
443 ****************************************************************************/
445 /****************************************************************************
446 Assertion - we should never be sending nmbd packets on the remote
448 ****************************************************************************/
450 static BOOL assert_check_subnet(struct subnet_record *subrec)
452 if( subrec == remote_broadcast_subnet)
454 DEBUG(0,("assert_check_subnet: Attempt to send packet on remote broadcast subnet. \
461 /****************************************************************************
462 Queue a register name packet to the broadcast address of a subnet.
463 ****************************************************************************/
465 struct response_record *queue_register_name( struct subnet_record *subrec,
466 response_function resp_fn,
467 timeout_response_function timeout_fn,
468 register_name_success_function success_fn,
469 register_name_fail_function fail_fn,
470 struct userdata_struct *userdata,
471 struct nmb_name *nmbname,
474 struct packet_struct *p;
475 struct response_record *rrec;
476 BOOL bcast = (subrec == unicast_subnet) ? False : True;
478 if(assert_check_subnet(subrec))
481 if(( p = create_and_init_netbios_packet(nmbname, bcast,
482 subrec->bcast_ip)) == NULL)
485 if(initiate_name_register_packet( p, nb_flags,
486 iface_ip(subrec->bcast_ip)) == False)
493 if((rrec = make_response_record(subrec, /* subnet record. */
494 p, /* packet we sent. */
495 resp_fn, /* function to call on response. */
496 timeout_fn, /* function to call on timeout. */
497 (success_function)success_fn, /* function to call on operation success. */
498 (fail_function)fail_fn, /* function to call on operation fail. */
509 /****************************************************************************
510 Queue a multihomed register name packet to the broadcast address of a subnet.
511 ****************************************************************************/
513 struct response_record *queue_register_multihomed_name( struct subnet_record *subrec,
514 response_function resp_fn,
515 timeout_response_function timeout_fn,
516 register_name_success_function success_fn,
517 register_name_fail_function fail_fn,
518 struct userdata_struct *userdata,
519 struct nmb_name *nmbname,
521 struct in_addr register_ip)
523 struct packet_struct *p;
524 struct response_record *rrec;
529 if(subrec != unicast_subnet)
531 DEBUG(0,("queue_register_multihomed_name: should only be done on \
532 unicast subnet. subnet is %s\n.", subrec->subnet_name ));
536 if(assert_check_subnet(subrec))
539 if(( p = create_and_init_netbios_packet(nmbname, bcast,
540 subrec->bcast_ip)) == NULL)
543 if (nb_flags & NB_GROUP)
544 ret = initiate_name_register_packet( p, nb_flags, ®ister_ip);
546 ret = initiate_multihomed_name_register_packet( p, nb_flags, ®ister_ip);
555 if((rrec = make_response_record(subrec, /* subnet record. */
556 p, /* packet we sent. */
557 resp_fn, /* function to call on response. */
558 timeout_fn, /* function to call on timeout. */
559 (success_function)success_fn, /* function to call on operation success. */
560 (fail_function)fail_fn, /* function to call on operation fail. */
571 /****************************************************************************
572 Queue a release name packet to the broadcast address of a subnet.
573 ****************************************************************************/
575 struct response_record *queue_release_name( struct subnet_record *subrec,
576 response_function resp_fn,
577 timeout_response_function timeout_fn,
578 release_name_success_function success_fn,
579 release_name_fail_function fail_fn,
580 struct userdata_struct *userdata,
581 struct nmb_name *nmbname,
583 struct in_addr release_ip)
585 BOOL bcast = (subrec == unicast_subnet) ? False : True;
586 struct packet_struct *p;
587 struct response_record *rrec;
589 if(assert_check_subnet(subrec))
592 if(( p = create_and_init_netbios_packet(nmbname, bcast,
593 subrec->bcast_ip)) == NULL)
596 if(initiate_name_release_packet( p, nb_flags, &release_ip) == False)
603 if((rrec = make_response_record(subrec, /* subnet record. */
604 p, /* packet we sent. */
605 resp_fn, /* function to call on response. */
606 timeout_fn, /* function to call on timeout. */
607 (success_function)success_fn, /* function to call on operation success. */
608 (fail_function)fail_fn, /* function to call on operation fail. */
617 * For a broadcast release packet, only send once.
618 * This will cause us to remove the name asap. JRA.
623 rrec->repeat_count = 0;
624 rrec->repeat_time = 0;
630 /****************************************************************************
631 Queue a refresh name packet to the broadcast address of a subnet.
632 ****************************************************************************/
634 struct response_record *queue_refresh_name( struct subnet_record *subrec,
635 response_function resp_fn,
636 timeout_response_function timeout_fn,
637 refresh_name_success_function success_fn,
638 refresh_name_fail_function fail_fn,
639 struct userdata_struct *userdata,
640 struct name_record *namerec,
641 struct in_addr refresh_ip)
643 BOOL bcast = (subrec == unicast_subnet) ? False : True;
644 struct packet_struct *p;
645 struct response_record *rrec;
647 if(assert_check_subnet(subrec))
650 if(( p = create_and_init_netbios_packet(&namerec->name, bcast,
651 subrec->bcast_ip)) == NULL)
654 if( !initiate_name_refresh_packet( p, namerec->data.nb_flags, &refresh_ip ) )
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. */
677 /****************************************************************************
678 Queue a query name packet to the broadcast address of a subnet.
679 ****************************************************************************/
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)
689 struct packet_struct *p;
690 struct response_record *rrec;
693 if ((subrec == unicast_subnet) || (subrec == wins_server_subnet))
696 if(assert_check_subnet(subrec))
699 if(( p = create_and_init_netbios_packet(nmbname, bcast,
700 subrec->bcast_ip)) == NULL)
703 if(initiate_name_query_packet( p ) == False)
710 if((rrec = make_response_record(subrec, /* subnet record. */
711 p, /* packet we sent. */
712 resp_fn, /* function to call on response. */
713 timeout_fn, /* function to call on timeout. */
714 (success_function)success_fn, /* function to call on operation success. */
715 (fail_function)fail_fn, /* function to call on operation fail. */
726 /****************************************************************************
727 Queue a query name packet to a given address from the WINS subnet.
728 ****************************************************************************/
730 struct response_record *queue_query_name_from_wins_server( struct in_addr to_ip,
731 response_function resp_fn,
732 timeout_response_function timeout_fn,
733 query_name_success_function success_fn,
734 query_name_fail_function fail_fn,
735 struct userdata_struct *userdata,
736 struct nmb_name *nmbname)
738 struct packet_struct *p;
739 struct response_record *rrec;
742 if(( p = create_and_init_netbios_packet(nmbname, bcast, to_ip)) == NULL)
745 if(initiate_name_query_packet_from_wins_server( p ) == False)
752 if((rrec = make_response_record(wins_server_subnet, /* subnet record. */
753 p, /* packet we sent. */
754 resp_fn, /* function to call on response. */
755 timeout_fn, /* function to call on timeout. */
756 (success_function)success_fn, /* function to call on operation success. */
757 (fail_function)fail_fn, /* function to call on operation fail. */
768 /****************************************************************************
769 Queue a node status packet to a given name and address.
770 ****************************************************************************/
772 struct response_record *queue_node_status( struct subnet_record *subrec,
773 response_function resp_fn,
774 timeout_response_function timeout_fn,
775 node_status_success_function success_fn,
776 node_status_fail_function fail_fn,
777 struct userdata_struct *userdata,
778 struct nmb_name *nmbname,
779 struct in_addr send_ip)
781 struct packet_struct *p;
782 struct response_record *rrec;
786 if(subrec != unicast_subnet)
788 DEBUG(0,("queue_register_multihomed_name: should only be done on \
789 unicast subnet. subnet is %s\n.", subrec->subnet_name ));
793 if(assert_check_subnet(subrec))
796 if(( p = create_and_init_netbios_packet(nmbname, bcast,
800 if(initiate_node_status_packet(p) == False)
807 if((rrec = make_response_record(subrec, /* subnet record. */
808 p, /* packet we sent. */
809 resp_fn, /* function to call on response. */
810 timeout_fn, /* function to call on timeout. */
811 (success_function)success_fn, /* function to call on operation success. */
812 (fail_function)fail_fn, /* function to call on operation fail. */
823 /****************************************************************************
824 Reply to a netbios name packet. see rfc1002.txt
825 ****************************************************************************/
827 void reply_netbios_packet(struct packet_struct *orig_packet,
828 int rcode, enum netbios_reply_type_code rcv_code, int opcode,
829 int ttl, char *data,int len)
831 struct packet_struct packet;
832 struct nmb_packet *nmb = NULL;
833 struct res_rec answers;
834 struct nmb_packet *orig_nmb = &orig_packet->packet.nmb;
835 BOOL loopback_this_packet = False;
836 char *packet_type = "unknown";
838 /* Check if we are sending to or from ourselves. */
839 if(ismyip(orig_packet->ip) && (orig_packet->port == global_nmb_port))
840 loopback_this_packet = True;
842 nmb = &packet.packet.nmb;
844 /* Do a partial copy of the packet. We clear the locked flag and
845 the resource record pointers. */
846 packet = *orig_packet; /* Full structure copy. */
847 packet.locked = False;
850 nmb->additional = NULL;
856 packet_type = "nmb_status";
857 nmb->header.nm_flags.recursion_desired = False;
858 nmb->header.nm_flags.recursion_available = False;
863 packet_type = "nmb_query";
864 nmb->header.nm_flags.recursion_desired = True;
865 nmb->header.nm_flags.recursion_available = True;
869 case NMB_REG_REFRESH:
871 packet_type = "nmb_reg";
872 nmb->header.nm_flags.recursion_desired = True;
873 nmb->header.nm_flags.recursion_available = True;
878 packet_type = "nmb_rel";
879 nmb->header.nm_flags.recursion_desired = False;
880 nmb->header.nm_flags.recursion_available = False;
885 packet_type = "nmb_wack";
886 nmb->header.nm_flags.recursion_desired = False;
887 nmb->header.nm_flags.recursion_available = False;
892 packet_type = "wins_reg";
893 nmb->header.nm_flags.recursion_desired = True;
894 nmb->header.nm_flags.recursion_available = True;
899 packet_type = "wins_query";
900 nmb->header.nm_flags.recursion_desired = True;
901 nmb->header.nm_flags.recursion_available = True;
907 DEBUG(0,("reply_netbios_packet: Unknown packet type: %s %s to ip %s\n",
908 packet_type, nmb_namestr(&orig_nmb->question.question_name),
909 inet_ntoa(packet.ip)));
915 DEBUG(4,("reply_netbios_packet: sending a reply of packet type: %s %s to ip %s \
917 packet_type, nmb_namestr(&orig_nmb->question.question_name),
918 inet_ntoa(packet.ip), orig_nmb->header.name_trn_id));
920 nmb->header.name_trn_id = orig_nmb->header.name_trn_id;
921 nmb->header.opcode = opcode;
922 nmb->header.response = True;
923 nmb->header.nm_flags.bcast = False;
924 nmb->header.nm_flags.trunc = False;
925 nmb->header.nm_flags.authoritative = True;
927 nmb->header.rcode = rcode;
928 nmb->header.qdcount = 0;
929 nmb->header.ancount = 1;
930 nmb->header.nscount = 0;
931 nmb->header.arcount = 0;
933 memset((char*)&nmb->question,'\0',sizeof(nmb->question));
935 nmb->answers = &answers;
936 memset((char*)nmb->answers,'\0',sizeof(*nmb->answers));
938 nmb->answers->rr_name = orig_nmb->question.question_name;
939 nmb->answers->rr_type = orig_nmb->question.question_type;
940 nmb->answers->rr_class = orig_nmb->question.question_class;
941 nmb->answers->ttl = ttl;
945 nmb->answers->rdlength = len;
946 memcpy(nmb->answers->rdata, data, len);
949 packet.packet_type = NMB_PACKET;
950 /* Ensure we send out on the same fd that the original
951 packet came in on to give the correct source IP address. */
952 packet.fd = orig_packet->fd;
953 packet.timestamp = time(NULL);
955 debug_nmb_packet(&packet);
957 if(loopback_this_packet)
959 struct packet_struct *lo_packet;
960 DEBUG(5,("reply_netbios_packet: sending packet to ourselves.\n"));
961 if((lo_packet = copy_packet(&packet)) == NULL)
963 queue_packet(lo_packet);
965 else if (!send_packet(&packet))
967 DEBUG(0,("reply_netbios_packet: send_packet to IP %s port %d failed\n",
968 inet_ntoa(packet.ip),packet.port));
972 /*******************************************************************
973 Queue a packet into a packet queue
974 ******************************************************************/
975 static void queue_packet(struct packet_struct *packet)
977 struct packet_struct *p;
983 packet_queue = packet;
987 /* find the bottom */
988 for (p=packet_queue;p->next;p=p->next)
996 /****************************************************************************
997 Try and find a matching subnet record for a datagram port 138 packet.
998 ****************************************************************************/
1000 static struct subnet_record *find_subnet_for_dgram_browse_packet(struct packet_struct *p)
1002 struct subnet_record *subrec;
1004 /* Go through all the broadcast subnets and see if the mask matches. */
1005 for (subrec = FIRST_SUBNET; subrec ; subrec = NEXT_SUBNET_EXCLUDING_UNICAST(subrec))
1007 if(same_net(p->ip, subrec->bcast_ip, subrec->mask_ip))
1011 /* If the subnet record is the remote announce broadcast subnet,
1012 hack it here to be the first subnet. This is really gross and
1013 is needed due to people turning on port 137/138 broadcast
1014 forwarding on their routers. May fire and brimstone rain
1018 return FIRST_SUBNET;
1021 /****************************************************************************
1022 Dispatch a browse frame from port 138 to the correct processing function.
1023 ****************************************************************************/
1024 static void process_browse_packet(struct packet_struct *p, char *buf,int len)
1026 struct dgram_packet *dgram = &p->packet.dgram;
1027 int command = CVAL(buf,0);
1028 struct subnet_record *subrec = find_subnet_for_dgram_browse_packet(p);
1030 /* Drop the packet if it's a different NetBIOS scope, or
1031 the source is from one of our names. */
1033 if (!strequal(dgram->dest_name.scope,scope ))
1035 DEBUG(7,("process_browse_packet: Discarding datagram from IP %s. Scope (%s) \
1036 mismatch with our scope (%s).\n", inet_ntoa(p->ip), dgram->dest_name.scope, scope));
1040 if (is_myname(dgram->source_name.name))
1042 DEBUG(0,("process_browse_packet: Discarding datagram from IP %s. Source name \
1043 %s is one of our names !\n", inet_ntoa(p->ip), nmb_namestr(&dgram->source_name)));
1049 case ANN_HostAnnouncement:
1051 debug_browse_data(buf, len);
1052 process_host_announce(subrec, p, buf+1);
1055 case ANN_DomainAnnouncement:
1057 debug_browse_data(buf, len);
1058 process_workgroup_announce(subrec, p, buf+1);
1061 case ANN_LocalMasterAnnouncement:
1063 debug_browse_data(buf, len);
1064 process_local_master_announce(subrec, p, buf+1);
1067 case ANN_AnnouncementRequest:
1069 debug_browse_data(buf, len);
1070 process_announce_request(subrec, p, buf+1);
1075 debug_browse_data(buf, len);
1076 process_election(subrec, p, buf+1);
1079 case ANN_GetBackupListReq:
1081 debug_browse_data(buf, len);
1082 process_get_backup_list_request(subrec, p, buf+1);
1085 case ANN_GetBackupListResp:
1087 debug_browse_data(buf, len);
1088 /* We never send ANN_GetBackupListReq so we
1089 should never get these. */
1090 DEBUG(0,("process_browse_packet: Discarding GetBackupListResponse \
1091 packet from %s IP %s\n", nmb_namestr(&dgram->source_name), inet_ntoa(p->ip)));
1094 case ANN_ResetBrowserState:
1096 debug_browse_data(buf, len);
1097 process_reset_browser(subrec, p, buf+1);
1100 case ANN_MasterAnnouncement:
1102 /* Master browser datagrams must be processed
1103 on the unicast subnet. */
1104 subrec = unicast_subnet;
1106 debug_browse_data(buf, len);
1107 process_master_browser_announce(subrec, p, buf+1);
1110 case ANN_BecomeBackup:
1113 * We don't currently implement this. Log it just in case.
1115 debug_browse_data(buf, len);
1116 DEBUG(10,("process_browse_packet: On subnet %s ignoring browse packet \
1117 command ANN_BecomeBackup from %s IP %s to %s\n",
1118 subrec->subnet_name, nmb_namestr(&dgram->source_name),
1119 inet_ntoa(p->ip), nmb_namestr(&dgram->dest_name)));
1124 debug_browse_data(buf, len);
1125 DEBUG(0,("process_browse_packet: On subnet %s ignoring browse packet \
1126 command code %d from %s IP %s to %s\n",
1127 subrec->subnet_name, command, nmb_namestr(&dgram->source_name),
1128 inet_ntoa(p->ip), nmb_namestr(&dgram->dest_name)));
1133 /****************************************************************************
1134 Dispatch a LanMan browse frame from port 138 to the correct processing function.
1135 ****************************************************************************/
1136 static void process_lanman_packet(struct packet_struct *p, char *buf,int len)
1138 struct dgram_packet *dgram = &p->packet.dgram;
1139 int command = SVAL(buf,0);
1140 struct subnet_record *subrec = find_subnet_for_dgram_browse_packet(p);
1142 /* Drop the packet if it's a different NetBIOS scope, or
1143 the source is from one of our names. */
1145 if (!strequal(dgram->dest_name.scope,scope ))
1147 DEBUG(7,("process_lanman_packet: Discarding datagram from IP %s. Scope (%s) \
1148 mismatch with our scope (%s).\n", inet_ntoa(p->ip), dgram->dest_name.scope, scope));
1152 if (is_myname(dgram->source_name.name))
1154 DEBUG(0,("process_lanman_packet: Discarding datagram from IP %s. Source name \
1155 %s is one of our names !\n", inet_ntoa(p->ip), nmb_namestr(&dgram->source_name)));
1161 case ANN_HostAnnouncement:
1163 debug_browse_data(buf, len);
1164 process_lm_host_announce(subrec, p, buf+1);
1167 case ANN_AnnouncementRequest:
1169 process_lm_announce_request(subrec, p, buf+1);
1174 DEBUG(0,("process_lanman_packet: On subnet %s ignoring browse packet \
1175 command code %d from %s IP %s to %s\n",
1176 subrec->subnet_name, command, nmb_namestr(&dgram->source_name),
1177 inet_ntoa(p->ip), nmb_namestr(&dgram->dest_name)));
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 ****************************************************************************/
1188 static BOOL listening(struct packet_struct *p,struct nmb_name *nbname)
1190 struct subnet_record *subrec = NULL;
1192 for (subrec = FIRST_SUBNET; subrec ; subrec = NEXT_SUBNET_EXCLUDING_UNICAST(subrec))
1194 if(same_net(p->ip, subrec->bcast_ip, subrec->mask_ip))
1199 subrec = unicast_subnet;
1201 return (find_name_on_subnet(subrec, nbname, FIND_SELF_NAME) != NULL);
1204 /****************************************************************************
1205 Process udp 138 datagrams
1206 ****************************************************************************/
1208 static void process_dgram(struct packet_struct *p)
1213 struct dgram_packet *dgram = &p->packet.dgram;
1215 /* If we aren't listening to the destination name then ignore the packet */
1216 if (!listening(p,&dgram->dest_name))
1218 DEBUG(5,("process_dgram: ignoring dgram packet sent to name %s from %s\n",
1219 nmb_namestr(&dgram->dest_name), inet_ntoa(p->ip)));
1223 if (dgram->header.msg_type != 0x10 &&
1224 dgram->header.msg_type != 0x11 &&
1225 dgram->header.msg_type != 0x12)
1227 /* Don't process error packets etc yet */
1228 DEBUG(5,("process_dgram: ignoring dgram packet sent to name %s from IP %s as it is \
1229 an error packet of type %x\n",
1230 nmb_namestr(&dgram->dest_name), inet_ntoa(p->ip), dgram->header.msg_type));
1234 buf = &dgram->data[0];
1235 buf -= 4; /* XXXX for the pseudo tcp length -
1236 someday I need to get rid of this */
1238 if (CVAL(buf,smb_com) != SMBtrans)
1241 len = SVAL(buf,smb_vwv11);
1242 buf2 = smb_base(buf) + SVAL(buf,smb_vwv12);
1244 DEBUG(4,("process_dgram: datagram from %s to %s IP %s for %s of type %d len=%d\n",
1245 nmb_namestr(&dgram->source_name),nmb_namestr(&dgram->dest_name),
1246 inet_ntoa(p->ip), smb_buf(buf),CVAL(buf2,0),len));
1252 /* Datagram packet received for the browser mailslot */
1253 if (strequal(smb_buf(buf),BROWSE_MAILSLOT))
1255 process_browse_packet(p,buf2,len);
1259 /* Datagram packet received for the LAN Manager mailslot */
1260 if (strequal(smb_buf(buf),LANMAN_MAILSLOT)) {
1261 process_lanman_packet(p,buf2,len);
1265 /* Datagram packet received for the domain logon mailslot */
1266 if (strequal(smb_buf(buf),NET_LOGON_MAILSLOT))
1268 process_logon_packet(p,buf2,len,NET_LOGON_MAILSLOT);
1272 /* Datagram packet received for the NT domain logon mailslot */
1273 if (strequal(smb_buf(buf),NT_LOGON_MAILSLOT))
1275 process_logon_packet(p,buf2,len,NT_LOGON_MAILSLOT);
1280 /****************************************************************************
1281 Validate a response nmb packet.
1282 ****************************************************************************/
1284 static BOOL validate_nmb_response_packet( struct nmb_packet *nmb )
1286 BOOL ignore = False;
1288 switch (nmb->header.opcode)
1290 case NMB_NAME_REG_OPCODE:
1291 case NMB_NAME_REFRESH_OPCODE_8: /* ambiguity in rfc1002 about which is correct. */
1292 case NMB_NAME_REFRESH_OPCODE_9: /* WinNT uses 8 by default. */
1293 if (nmb->header.ancount == 0)
1295 DEBUG(0,("validate_nmb_response_packet: Bad REG/REFRESH Packet. "));
1300 case NMB_NAME_QUERY_OPCODE:
1301 if ((nmb->header.ancount != 0) && (nmb->header.ancount != 1))
1303 DEBUG(0,("validate_nmb_response_packet: Bad QUERY Packet. "));
1307 case NMB_NAME_RELEASE_OPCODE:
1308 if (nmb->header.ancount == 0)
1310 DEBUG(0,("validate_nmb_response_packet: Bad RELEASE Packet. "));
1314 case NMB_WACK_OPCODE:
1315 /* Check WACK response here. */
1316 if (nmb->header.ancount != 1)
1318 DEBUG(0,("validate_nmb_response_packet: Bad WACK Packet. "));
1323 DEBUG(0,("validate_nmb_response_packet: Ignoring packet with unknown opcode %d.\n",
1324 nmb->header.opcode));
1329 DEBUG(0,("Ignoring response packet with opcode %d.\n", nmb->header.opcode));
1334 /****************************************************************************
1335 Validate a request nmb packet.
1336 ****************************************************************************/
1338 static BOOL validate_nmb_packet( struct nmb_packet *nmb )
1340 BOOL ignore = False;
1342 switch (nmb->header.opcode)
1344 case NMB_NAME_REG_OPCODE:
1345 case NMB_NAME_REFRESH_OPCODE_8: /* ambiguity in rfc1002 about which is correct. */
1346 case NMB_NAME_REFRESH_OPCODE_9: /* WinNT uses 8 by default. */
1347 case NMB_NAME_MULTIHOMED_REG_OPCODE:
1348 if (nmb->header.qdcount==0 || nmb->header.arcount==0)
1350 DEBUG(0,("validate_nmb_packet: Bad REG/REFRESH Packet. "));
1355 case NMB_NAME_QUERY_OPCODE:
1356 if ((nmb->header.qdcount == 0) ||
1357 ((nmb->question.question_type != QUESTION_TYPE_NB_QUERY) &&
1358 (nmb->question.question_type != QUESTION_TYPE_NB_STATUS)))
1360 DEBUG(0,("validate_nmb_packet: Bad QUERY Packet. "));
1365 case NMB_NAME_RELEASE_OPCODE:
1366 if (nmb->header.qdcount==0 || nmb->header.arcount==0)
1368 DEBUG(0,("validate_nmb_packet: Bad RELEASE Packet. "));
1373 DEBUG(0,("validate_nmb_packet: Ignoring packet with unknown opcode %d.\n",
1374 nmb->header.opcode));
1379 DEBUG(0,("validate_nmb_packet: Ignoring request packet with opcode %d.\n", nmb->header.opcode));
1384 /****************************************************************************
1385 Find a subnet (and potentially a response record) for a packet.
1386 ****************************************************************************/
1388 static struct subnet_record *find_subnet_for_nmb_packet( struct packet_struct *p,
1389 struct response_record **pprrec)
1391 struct nmb_packet *nmb = &p->packet.nmb;
1392 struct response_record *rrec = NULL;
1393 struct subnet_record *subrec = NULL;
1398 if(nmb->header.response)
1400 /* It's a response packet. Find a record for it or it's an error. */
1402 rrec = find_response_record( &subrec, nmb->header.name_trn_id);
1405 DEBUG(0,("find_subnet_for_nmb_packet: response record not found for response id %hu\n",
1406 nmb->header.name_trn_id));
1412 DEBUG(0,("find_subnet_for_nmb_packet: subnet record not found for response id %hu\n",
1413 nmb->header.name_trn_id));
1422 /* Try and see what subnet this packet belongs to. */
1425 if(packet_is_for_wins_server(p))
1426 return wins_server_subnet;
1428 /* If it wasn't a broadcast packet then send to the UNICAST subnet. */
1429 if(nmb->header.nm_flags.bcast == False)
1430 return unicast_subnet;
1432 /* Go through all the broadcast subnets and see if the mask matches. */
1433 for (subrec = FIRST_SUBNET; subrec ; subrec = NEXT_SUBNET_EXCLUDING_UNICAST(subrec))
1435 if(same_net(p->ip, subrec->bcast_ip, subrec->mask_ip))
1439 /* If none match it must have been a directed broadcast - assign
1440 the remote_broadcast_subnet. */
1441 return remote_broadcast_subnet;
1444 /****************************************************************************
1445 Process a nmb request packet - validate the packet and route it.
1446 ****************************************************************************/
1448 static void process_nmb_request(struct packet_struct *p)
1450 struct nmb_packet *nmb = &p->packet.nmb;
1451 struct subnet_record *subrec = NULL;
1453 debug_nmb_packet(p);
1455 /* Ensure we have a good packet. */
1456 if(validate_nmb_packet(nmb))
1459 /* Allocate a subnet to this packet - if we cannot - fail. */
1460 if((subrec = find_subnet_for_nmb_packet(p, NULL))==NULL)
1463 switch (nmb->header.opcode)
1465 case NMB_NAME_REG_OPCODE:
1466 if(subrec == wins_server_subnet)
1467 wins_process_name_registration_request(subrec, p);
1469 process_name_registration_request(subrec, p);
1472 case NMB_NAME_REFRESH_OPCODE_8: /* ambiguity in rfc1002 about which is correct. */
1473 case NMB_NAME_REFRESH_OPCODE_9:
1474 if(subrec == wins_server_subnet)
1475 wins_process_name_refresh_request(subrec, p);
1477 process_name_refresh_request(subrec, p);
1480 case NMB_NAME_MULTIHOMED_REG_OPCODE:
1481 if(subrec == wins_server_subnet)
1482 wins_process_multihomed_name_registration_request(subrec, p);
1485 DEBUG(0,("process_nmb_request: Multihomed registration request must be \
1486 directed at a WINS server.\n"));
1490 case NMB_NAME_QUERY_OPCODE:
1491 switch (nmb->question.question_type)
1493 case QUESTION_TYPE_NB_QUERY:
1495 if(subrec == wins_server_subnet)
1496 wins_process_name_query_request(subrec, p);
1498 process_name_query_request(subrec, p);
1501 case QUESTION_TYPE_NB_STATUS:
1503 if(subrec == wins_server_subnet)
1505 DEBUG(0,("process_nmb_request: NB_STATUS request directed at WINS server is \
1510 process_node_status_request(subrec, p);
1516 case NMB_NAME_RELEASE_OPCODE:
1517 if(subrec == wins_server_subnet)
1518 wins_process_name_release_request(subrec, p);
1520 process_name_release_request(subrec, p);
1525 /****************************************************************************
1526 Process a nmb response packet - validate the packet and route it.
1527 to either the WINS server or a normal response.
1528 ****************************************************************************/
1530 static void process_nmb_response(struct packet_struct *p)
1532 struct nmb_packet *nmb = &p->packet.nmb;
1533 struct subnet_record *subrec = NULL;
1534 struct response_record *rrec = NULL;
1536 debug_nmb_packet(p);
1538 if(validate_nmb_response_packet(nmb))
1541 if((subrec = find_subnet_for_nmb_packet(p, &rrec))==NULL)
1546 DEBUG(0,("process_nmb_response: response packet received but no response record \
1547 found for id = %hu. Ignoring packet.\n", nmb->header.name_trn_id));
1551 /* Increment the number of responses received for this record. */
1553 /* Ensure we don't re-send the request. */
1554 rrec->repeat_count = 0;
1556 /* Call the response received function for this packet. */
1557 (*rrec->resp_fn)(subrec, rrec, p);
1561 /*******************************************************************
1562 Run elements off the packet queue till its empty
1563 ******************************************************************/
1565 void run_packet_queue(void)
1567 struct packet_struct *p;
1569 while ((p = packet_queue))
1571 packet_queue = p->next;
1573 packet_queue->prev = NULL;
1574 p->next = p->prev = NULL;
1576 switch (p->packet_type)
1579 if(p->packet.nmb.header.response)
1580 process_nmb_response(p);
1582 process_nmb_request(p);
1593 /*******************************************************************
1594 Retransmit or timeout elements from all the outgoing subnet response
1595 record queues. NOTE that this code must also check the WINS server
1596 subnet for response records to timeout as the WINS server code
1597 can send requests to check if a client still owns a name.
1598 (Patch from Andrey Alekseyev <fetch@muffin.arcadia.spb.ru>).
1599 ******************************************************************/
1601 void retransmit_or_expire_response_records(time_t t)
1603 struct subnet_record *subrec;
1605 for (subrec = FIRST_SUBNET; subrec;
1606 subrec = get_next_subnet_maybe_unicast_or_wins_server(subrec))
1608 struct response_record *rrec, *nextrrec;
1610 for (rrec = subrec->responselist; rrec; rrec = nextrrec)
1612 nextrrec = rrec->next;
1614 if (rrec->repeat_time <= t)
1616 if (rrec->repeat_count > 0)
1618 /* Resend while we have a non-zero repeat_count. */
1619 if(!send_packet(rrec->packet))
1621 DEBUG(0,("retransmit_or_expire_response_records: Failed to resend packet id %hu \
1622 to IP %s on subnet %s\n", rrec->response_id, inet_ntoa(rrec->packet->ip),
1623 subrec->subnet_name));
1625 rrec->repeat_time += rrec->repeat_interval;
1626 rrec->repeat_count--;
1630 DEBUG(4,("retransmit_or_expire_response_records: timeout for packet id %hu to IP %s \
1631 on subnet %s\n", rrec->response_id, inet_ntoa(rrec->packet->ip),
1632 subrec->subnet_name));
1635 * Check the flag in this record to prevent recursion if we end
1636 * up in this function again via the timeout function call.
1639 if(!rrec->in_expiration_processing)
1643 * Set the recursion protection flag in this record.
1646 rrec->in_expiration_processing = True;
1648 /* Call the timeout function. This will deal with removing the
1649 timed out packet. */
1650 if(rrec->timeout_fn)
1651 (*rrec->timeout_fn)(subrec, rrec);
1654 /* We must remove the record ourself if there is
1655 no timeout function. */
1656 remove_response_record(subrec, rrec);
1658 } /* !rrec->in_expitation_processing */
1659 } /* rrec->repeat_count > 0 */
1660 } /* rrec->repeat_time <= t */
1661 } /* end for rrec */
1662 } /* end for subnet */
1665 /****************************************************************************
1666 Create an fd_set containing all the sockets in the subnet structures,
1667 plus the broadcast sockets.
1668 ***************************************************************************/
1670 static BOOL create_listen_fdset(fd_set **ppset, int **psock_array, int *listen_number)
1672 int *sock_array = NULL;
1673 struct subnet_record *subrec = NULL;
1676 fd_set *pset = (fd_set *)malloc(sizeof(fd_set));
1680 DEBUG(0,("create_listen_fdset: malloc fail !\n"));
1684 /* Check that we can add all the fd's we need. */
1685 for (subrec = FIRST_SUBNET; subrec; subrec = NEXT_SUBNET_EXCLUDING_UNICAST(subrec))
1688 if((count*2) + 2 > FD_SETSIZE)
1690 DEBUG(0,("create_listen_fdset: Too many file descriptors needed (%d). We can \
1691 only use %d.\n", (count*2) + 2, FD_SETSIZE));
1695 if((sock_array = (int *)malloc(((count*2) + 2)*sizeof(int))) == NULL)
1697 DEBUG(0,("create_listen_fdset: malloc fail for socket array.\n"));
1703 /* Add in the broadcast socket on 137. */
1704 FD_SET(ClientNMB,pset);
1705 sock_array[num++] = ClientNMB;
1707 /* Add in the 137 sockets on all the interfaces. */
1708 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;
1714 /* Add in the broadcast socket on 138. */
1715 FD_SET(ClientDGRAM,pset);
1716 sock_array[num++] = ClientDGRAM;
1718 /* Add in the 138 sockets on all the interfaces. */
1719 for (subrec = FIRST_SUBNET; subrec; subrec = NEXT_SUBNET_EXCLUDING_UNICAST(subrec))
1721 FD_SET(subrec->dgram_sock,pset);
1722 sock_array[num++] = subrec->dgram_sock;
1725 *listen_number = (count*2) + 2;
1727 if (*ppset) free(*ppset);
1728 if (*psock_array) free(*psock_array);
1731 *psock_array = sock_array;
1736 /****************************************************************************
1737 Listens for NMB or DGRAM packets, and queues them.
1738 ***************************************************************************/
1740 BOOL listen_for_packets(BOOL run_election)
1742 static fd_set *listen_set = NULL;
1743 static int listen_number = 0;
1744 static int *sock_array = NULL;
1748 struct timeval timeout;
1753 if(listen_set == NULL || rescan_listen_set)
1755 if(create_listen_fdset(&listen_set, &sock_array, &listen_number))
1757 DEBUG(0,("listen_for_packets: Fatal error. unable to create listen set. Exiting.\n"));
1760 rescan_listen_set = False;
1763 memcpy((char *)&fds, (char *)listen_set, sizeof(fd_set));
1766 dns_fd = asyncdns_fd();
1768 FD_SET(dns_fd, &fds);
1774 * During elections and when expecting a netbios response packet we
1775 * need to send election packets at tighter intervals.
1776 * Ideally it needs to be the interval (in ms) between time now and
1777 * the time we are expecting the next netbios packet.
1780 timeout.tv_sec = (run_election||num_response_packets) ? 1 : NMBD_SELECT_LOOP;
1781 timeout.tv_usec = 0;
1783 /* Prepare for the select - allow certain signals. */
1785 BlockSignals(False, SIGTERM);
1786 #if defined(SIGUSR1)
1787 BlockSignals(False, SIGUSR1);
1788 #endif /* SIGUSR1 */
1789 #if defined(SIGUSR2)
1790 BlockSignals(False, SIGUSR2);
1791 #endif /* SIGUSR2 */
1793 selrtn = sys_select(FD_SETSIZE,&fds,&timeout);
1795 /* We can only take signals when we are in the select - block them again here. */
1797 BlockSignals(True, SIGTERM);
1798 #if defined(SIGUSR1)
1799 BlockSignals(True, SIGUSR1);
1800 #endif /* SIGUSR1 */
1801 #if defined(SIGUSR2)
1802 BlockSignals(True, SIGUSR2);
1803 #endif /* SIGUSR2 */
1810 if (dns_fd != -1 && FD_ISSET(dns_fd,&fds)) {
1815 for(i = 0; i < listen_number; i++)
1817 if(i < (listen_number/2))
1819 /* Processing a 137 socket. */
1820 if (FD_ISSET(sock_array[i],&fds))
1822 struct packet_struct *packet = read_packet(sock_array[i], NMB_PACKET);
1826 * If we got a packet on the broadcast socket and interfaces
1827 * only is set then check it came from one of our local nets.
1829 if(lp_bind_interfaces_only() && (sock_array[i] == ClientNMB) &&
1830 (!is_local_net(packet->ip)))
1832 DEBUG(7,("discarding nmb packet sent to broadcast socket from %s:%d\n",
1833 inet_ntoa(packet->ip),packet->port));
1834 free_packet(packet);
1836 else if ((ip_equal(loopback_ip, packet->ip) ||
1837 ismyip(packet->ip)) && packet->port == global_nmb_port)
1839 DEBUG(7,("discarding own packet from %s:%d\n",
1840 inet_ntoa(packet->ip),packet->port));
1841 free_packet(packet);
1845 /* Save the file descriptor this packet came in on. */
1846 packet->fd = sock_array[i];
1847 queue_packet(packet);
1854 /* Processing a 138 socket. */
1856 if (FD_ISSET(sock_array[i],&fds))
1858 struct packet_struct *packet = read_packet(sock_array[i], DGRAM_PACKET);
1862 * If we got a packet on the broadcast socket and interfaces
1863 * only is set then check it came from one of our local nets.
1865 if(lp_bind_interfaces_only() && (sock_array[i] == ClientDGRAM) &&
1866 (!is_local_net(packet->ip)))
1868 DEBUG(7,("discarding dgram packet sent to broadcast socket from %s:%d\n",
1869 inet_ntoa(packet->ip),packet->port));
1870 free_packet(packet);
1872 else if ((ip_equal(loopback_ip, packet->ip) ||
1873 ismyip(packet->ip)) && packet->port == DGRAM_PORT)
1875 DEBUG(7,("discarding own packet from %s:%d\n",
1876 inet_ntoa(packet->ip),packet->port));
1877 free_packet(packet);
1881 /* Save the file descriptor this packet came in on. */
1882 packet->fd = sock_array[i];
1883 queue_packet(packet);
1887 } /* end processing 138 socket. */
1889 } /* end if selret > 0 */
1893 /****************************************************************************
1894 Construct and send a netbios DGRAM.
1895 **************************************************************************/
1896 BOOL send_mailslot(BOOL unique, char *mailslot,char *buf,int len,
1897 char *srcname, int src_type,
1898 char *dstname, int dest_type,
1899 struct in_addr dest_ip,struct in_addr src_ip,
1902 BOOL loopback_this_packet = False;
1903 struct packet_struct p;
1904 struct dgram_packet *dgram = &p.packet.dgram;
1908 memset((char *)&p,'\0',sizeof(p));
1911 loopback_this_packet = True;
1913 generate_name_trn_id();
1915 /* DIRECT GROUP or UNIQUE datagram. */
1916 dgram->header.msg_type = unique ? 0x10 : 0x11;
1917 dgram->header.flags.node_type = M_NODE;
1918 dgram->header.flags.first = True;
1919 dgram->header.flags.more = False;
1920 dgram->header.dgm_id = name_trn_id;
1921 dgram->header.source_ip = src_ip;
1922 dgram->header.source_port = DGRAM_PORT;
1923 dgram->header.dgm_length = 0; /* Let build_dgram() handle this. */
1924 dgram->header.packet_offset = 0;
1926 make_nmb_name(&dgram->source_name,srcname,src_type,scope);
1927 make_nmb_name(&dgram->dest_name,dstname,dest_type,scope);
1929 ptr = &dgram->data[0];
1931 /* Setup the smb part. */
1932 ptr -= 4; /* XXX Ugliness because of handling of tcp SMB length. */
1934 set_message(ptr,17,17 + len,True);
1937 CVAL(ptr,smb_com) = SMBtrans;
1938 SSVAL(ptr,smb_vwv1,len);
1939 SSVAL(ptr,smb_vwv11,len);
1940 SSVAL(ptr,smb_vwv12,70 + strlen(mailslot));
1941 SSVAL(ptr,smb_vwv13,3);
1942 SSVAL(ptr,smb_vwv14,1);
1943 SSVAL(ptr,smb_vwv15,1);
1944 SSVAL(ptr,smb_vwv16,2);
1946 pstrcpy(p2,mailslot);
1947 p2 = skip_string(p2,1);
1952 dgram->datasize = PTR_DIFF(p2,ptr+4); /* +4 for tcp length. */
1956 p.fd = find_subnet_mailslot_fd_for_address( src_ip );
1957 p.timestamp = time(NULL);
1958 p.packet_type = DGRAM_PACKET;
1960 DEBUG(4,("send_mailslot: Sending to mailslot %s from %s IP %s ", mailslot,
1961 nmb_namestr(&dgram->source_name), inet_ntoa(src_ip)));
1962 DEBUG(4,("to %s IP %s\n", nmb_namestr(&dgram->dest_name), inet_ntoa(dest_ip)));
1964 debug_browse_data(buf, len);
1966 if(loopback_this_packet)
1968 struct packet_struct *lo_packet = NULL;
1969 DEBUG(5,("send_mailslot: sending packet to ourselves.\n"));
1970 if((lo_packet = copy_packet(&p)) == NULL)
1972 queue_packet(lo_packet);
1976 return(send_packet(&p));