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;
35 extern struct in_addr loopback_ip;
37 static void queue_packet(struct packet_struct *packet);
39 BOOL rescan_listen_set = False;
42 /*******************************************************************
43 The global packet linked-list. Incoming entries are
44 added to the end of this list. It is supposed to remain fairly
45 short so we won't bother with an end pointer.
46 ******************************************************************/
48 static struct packet_struct *packet_queue = NULL;
50 /***************************************************************************
51 Utility function to find the specific fd to send a packet out on.
52 **************************************************************************/
54 static int find_subnet_fd_for_address( struct in_addr local_ip )
56 struct subnet_record *subrec;
58 for( subrec = FIRST_SUBNET; subrec; subrec = NEXT_SUBNET_EXCLUDING_UNICAST(subrec))
59 if(ip_equal(local_ip, subrec->myip))
60 return subrec->nmb_sock;
65 /***************************************************************************
66 Utility function to find the specific fd to send a mailslot packet out on.
67 **************************************************************************/
69 static int find_subnet_mailslot_fd_for_address( struct in_addr local_ip )
71 struct subnet_record *subrec;
73 for( subrec = FIRST_SUBNET; subrec; subrec = NEXT_SUBNET_EXCLUDING_UNICAST(subrec))
74 if(ip_equal(local_ip, subrec->myip))
75 return subrec->dgram_sock;
80 /***************************************************************************
81 Get/Set problematic nb_flags as network byte order 16 bit int.
82 **************************************************************************/
84 uint16 get_nb_flags(char *buf)
86 return ((((uint16)*buf)&0xFFFF) & NB_FLGMSK);
89 void set_nb_flags(char *buf, uint16 nb_flags)
91 *buf++ = ((nb_flags & NB_FLGMSK) & 0xFF);
95 /***************************************************************************
96 Dumps out the browse packet data.
97 **************************************************************************/
99 static void debug_browse_data(char *outbuf, int len)
103 DEBUG( 4, ( "debug_browse_data():\n" ) );
104 for (i = 0; i < len; i+= 16)
106 DEBUGADD( 4, ( "%3x char ", i ) );
108 for (j = 0; j < 16; j++)
110 unsigned char x = outbuf[i+j];
111 if (x < 32 || x > 127)
116 DEBUGADD( 4, ( "%c", x ) );
119 DEBUGADD( 4, ( "%*s hex", 16-j, "" ) );
121 for (j = 0; j < 16; j++)
125 DEBUGADD( 4, ( " %02x", (unsigned char)outbuf[i+j] ) );
128 DEBUGADD( 4, ("\n") );
132 /***************************************************************************
133 Generates the unique transaction identifier
134 **************************************************************************/
136 static uint16 name_trn_id=0;
138 static uint16 generate_name_trn_id(void)
143 name_trn_id = ((unsigned)time(NULL)%(unsigned)0x7FFF) + ((unsigned)sys_getpid()%(unsigned)100);
145 name_trn_id = (name_trn_id+1) % (unsigned)0x7FFF;
149 /***************************************************************************
150 Either loops back or sends out a completed NetBIOS packet.
151 **************************************************************************/
153 static BOOL send_netbios_packet(struct packet_struct *p)
155 BOOL loopback_this_packet = False;
157 /* Check if we are sending to or from ourselves as a WINS server. */
158 if(ismyip(p->ip) && (p->port == global_nmb_port))
159 loopback_this_packet = True;
161 if(loopback_this_packet)
163 struct packet_struct *lo_packet = NULL;
164 DEBUG(5,("send_netbios_packet: sending packet to ourselves.\n"));
165 if((lo_packet = copy_packet(p)) == NULL)
167 queue_packet(lo_packet);
169 else if (!send_packet(p))
171 DEBUG(0,("send_netbios_packet: send_packet() to IP %s port %d failed\n",
172 inet_ntoa(p->ip),p->port));
179 /***************************************************************************
180 Sets up the common elements of an outgoing NetBIOS packet.
182 Note: do not attempt to rationalise whether rec_des should be set or not
183 in a particular situation. Just follow rfc_1002 or look at examples from WinXX.
184 It does NOT follow the rule that requests to the wins server always have
185 rec_des true. See for example name releases and refreshes
186 **************************************************************************/
188 static struct packet_struct *create_and_init_netbios_packet(struct nmb_name *nmbname,
189 BOOL bcast, BOOL rec_des,
190 struct in_addr to_ip)
192 struct packet_struct *packet = NULL;
193 struct nmb_packet *nmb = NULL;
195 /* Allocate the packet_struct we will return. */
196 if((packet = (struct packet_struct *)malloc(sizeof(*packet))) == NULL)
198 DEBUG(0,("create_and_init_netbios_packet: malloc fail (1) for packet struct.\n"));
202 memset((char *)packet,'\0',sizeof(*packet));
204 nmb = &packet->packet.nmb;
206 nmb->header.name_trn_id = generate_name_trn_id();
207 nmb->header.response = False;
208 nmb->header.nm_flags.recursion_desired = rec_des;
209 nmb->header.nm_flags.recursion_available = False;
210 nmb->header.nm_flags.trunc = False;
211 nmb->header.nm_flags.authoritative = False;
212 nmb->header.nm_flags.bcast = bcast;
214 nmb->header.rcode = 0;
215 nmb->header.qdcount = 1;
216 nmb->header.ancount = 0;
217 nmb->header.nscount = 0;
219 nmb->question.question_name = *nmbname;
220 nmb->question.question_type = QUESTION_TYPE_NB_QUERY;
221 nmb->question.question_class = QUESTION_CLASS_IN;
224 packet->port = NMB_PORT;
225 packet->fd = ClientNMB;
226 packet->timestamp = time(NULL);
227 packet->packet_type = NMB_PACKET;
228 packet->locked = False;
230 return packet; /* Caller must free. */
233 /***************************************************************************
234 Sets up the common elements of register, refresh or release packet.
235 **************************************************************************/
237 static BOOL create_and_init_additional_record(struct packet_struct *packet,
239 struct in_addr *register_ip)
241 struct nmb_packet *nmb = &packet->packet.nmb;
243 if((nmb->additional = (struct res_rec *)malloc(sizeof(struct res_rec))) == NULL)
245 DEBUG(0,("initiate_name_register_packet: malloc fail for additional record.\n"));
249 memset((char *)nmb->additional,'\0',sizeof(struct res_rec));
251 nmb->additional->rr_name = nmb->question.question_name;
252 nmb->additional->rr_type = RR_TYPE_NB;
253 nmb->additional->rr_class = RR_CLASS_IN;
255 /* See RFC 1002, sections 5.1.1.1, 5.1.1.2 and 5.1.1.3 */
256 if (nmb->header.nm_flags.bcast)
257 nmb->additional->ttl = PERMANENT_TTL;
259 nmb->additional->ttl = lp_max_ttl();
261 nmb->additional->rdlength = 6;
263 set_nb_flags(nmb->additional->rdata,nb_flags);
265 /* Set the address for the name we are registering. */
266 putip(&nmb->additional->rdata[2], register_ip);
268 /* Ensure that we send out the file descriptor to give us the
269 the specific source address we are registering as our
270 IP source address. */
272 packet->fd = find_subnet_fd_for_address( *register_ip );
277 /***************************************************************************
278 Sends out a name query.
279 **************************************************************************/
281 static BOOL initiate_name_query_packet( struct packet_struct *packet)
283 struct nmb_packet *nmb = NULL;
285 nmb = &packet->packet.nmb;
287 nmb->header.opcode = NMB_NAME_QUERY_OPCODE;
288 nmb->header.arcount = 0;
290 nmb->header.nm_flags.recursion_desired = True;
292 DEBUG(4,("initiate_name_query_packet: sending query for name %s (bcast=%s) to IP %s\n",
293 nmb_namestr(&nmb->question.question_name),
294 BOOLSTR(nmb->header.nm_flags.bcast), inet_ntoa(packet->ip)));
296 return send_netbios_packet( packet );
299 /***************************************************************************
300 Sends out a name query - from a WINS server.
301 **************************************************************************/
303 static BOOL initiate_name_query_packet_from_wins_server( struct packet_struct *packet)
305 struct nmb_packet *nmb = NULL;
307 nmb = &packet->packet.nmb;
309 nmb->header.opcode = NMB_NAME_QUERY_OPCODE;
310 nmb->header.arcount = 0;
312 nmb->header.nm_flags.recursion_desired = False;
314 DEBUG(4,("initiate_name_query_packet_from_wins_server: sending query for name %s (bcast=%s) to IP %s\n",
315 nmb_namestr(&nmb->question.question_name),
316 BOOLSTR(nmb->header.nm_flags.bcast), inet_ntoa(packet->ip)));
318 return send_netbios_packet( packet );
321 /***************************************************************************
322 Sends out a name register.
323 **************************************************************************/
325 static BOOL initiate_name_register_packet( struct packet_struct *packet,
326 uint16 nb_flags, struct in_addr *register_ip)
328 struct nmb_packet *nmb = &packet->packet.nmb;
330 nmb->header.opcode = NMB_NAME_REG_OPCODE;
331 nmb->header.arcount = 1;
333 nmb->header.nm_flags.recursion_desired = True;
335 if(create_and_init_additional_record(packet, nb_flags, register_ip) == False)
338 DEBUG(4,("initiate_name_register_packet: sending registration for name %s (bcast=%s) to IP %s\n",
339 nmb_namestr(&nmb->additional->rr_name),
340 BOOLSTR(nmb->header.nm_flags.bcast), inet_ntoa(packet->ip)));
342 return send_netbios_packet( packet );
345 /***************************************************************************
346 Sends out a multihomed name register.
347 **************************************************************************/
349 static BOOL initiate_multihomed_name_register_packet( struct packet_struct *packet,
350 uint16 nb_flags, struct in_addr *register_ip)
352 struct nmb_packet *nmb = &packet->packet.nmb;
353 fstring second_ip_buf;
355 fstrcpy(second_ip_buf, inet_ntoa(packet->ip));
357 nmb->header.opcode = NMB_NAME_MULTIHOMED_REG_OPCODE;
358 nmb->header.arcount = 1;
360 nmb->header.nm_flags.recursion_desired = True;
362 if(create_and_init_additional_record(packet, nb_flags, register_ip) == False)
365 DEBUG(4,("initiate_multihomed_name_register_packet: sending registration \
366 for name %s IP %s (bcast=%s) to IP %s\n",
367 nmb_namestr(&nmb->additional->rr_name), inet_ntoa(*register_ip),
368 BOOLSTR(nmb->header.nm_flags.bcast), second_ip_buf ));
370 return send_netbios_packet( packet );
373 /***************************************************************************
374 Sends out a name refresh.
375 **************************************************************************/
377 static BOOL initiate_name_refresh_packet( struct packet_struct *packet,
378 uint16 nb_flags, struct in_addr *refresh_ip)
380 struct nmb_packet *nmb = &packet->packet.nmb;
382 nmb->header.opcode = NMB_NAME_REFRESH_OPCODE_8;
383 nmb->header.arcount = 1;
385 nmb->header.nm_flags.recursion_desired = False;
387 if(create_and_init_additional_record(packet, nb_flags, refresh_ip) == False)
390 DEBUG(4,("initiate_name_refresh_packet: sending refresh for name %s (bcast=%s) to IP %s\n",
391 nmb_namestr(&nmb->additional->rr_name),
392 BOOLSTR(nmb->header.nm_flags.bcast), inet_ntoa(packet->ip)));
394 return send_netbios_packet( packet );
397 /***************************************************************************
398 Sends out a name release.
399 **************************************************************************/
401 static BOOL initiate_name_release_packet( struct packet_struct *packet,
402 uint16 nb_flags, struct in_addr *release_ip)
404 struct nmb_packet *nmb = &packet->packet.nmb;
406 nmb->header.opcode = NMB_NAME_RELEASE_OPCODE;
407 nmb->header.arcount = 1;
409 nmb->header.nm_flags.recursion_desired = False;
411 if(create_and_init_additional_record(packet, nb_flags, release_ip) == False)
414 DEBUG(4,("initiate_name_release_packet: sending release for name %s (bcast=%s) to IP %s\n",
415 nmb_namestr(&nmb->additional->rr_name),
416 BOOLSTR(nmb->header.nm_flags.bcast), inet_ntoa(packet->ip)));
418 return send_netbios_packet( packet );
421 /***************************************************************************
422 Sends out a node status.
423 **************************************************************************/
425 static BOOL initiate_node_status_packet( struct packet_struct *packet )
427 struct nmb_packet *nmb = &packet->packet.nmb;
429 nmb->header.opcode = NMB_NAME_QUERY_OPCODE;
430 nmb->header.arcount = 0;
432 nmb->header.nm_flags.recursion_desired = False;
434 nmb->question.question_type = QUESTION_TYPE_NB_STATUS;
436 DEBUG(4,("initiate_node_status_packet: sending node status request for name %s to IP %s\n",
437 nmb_namestr(&nmb->question.question_name),
438 inet_ntoa(packet->ip)));
440 return send_netbios_packet( packet );
443 /****************************************************************************
444 Simplification functions for queuing standard packets.
445 These should be the only publicly callable functions for sending
447 ****************************************************************************/
449 /****************************************************************************
450 Assertion - we should never be sending nmbd packets on the remote
452 ****************************************************************************/
454 static BOOL assert_check_subnet(struct subnet_record *subrec)
456 if( subrec == remote_broadcast_subnet)
458 DEBUG(0,("assert_check_subnet: Attempt to send packet on remote broadcast subnet. \
465 /****************************************************************************
466 Queue a register name packet to the broadcast address of a subnet.
467 ****************************************************************************/
469 struct response_record *queue_register_name( struct subnet_record *subrec,
470 response_function resp_fn,
471 timeout_response_function timeout_fn,
472 register_name_success_function success_fn,
473 register_name_fail_function fail_fn,
474 struct userdata_struct *userdata,
475 struct nmb_name *nmbname,
478 struct packet_struct *p;
479 struct response_record *rrec;
481 if(assert_check_subnet(subrec))
484 /* note that all name registration requests have RD set (rfc1002 -
486 if ((p = create_and_init_netbios_packet(nmbname, (subrec != unicast_subnet), True,
487 subrec->bcast_ip)) == NULL)
490 if(initiate_name_register_packet( p, nb_flags,
491 iface_ip(subrec->bcast_ip)) == False)
498 if((rrec = make_response_record(subrec, /* subnet record. */
499 p, /* packet we sent. */
500 resp_fn, /* function to call on response. */
501 timeout_fn, /* function to call on timeout. */
502 (success_function)success_fn, /* function to call on operation success. */
503 (fail_function)fail_fn, /* function to call on operation fail. */
514 /****************************************************************************
515 Queue a multihomed register name packet to the broadcast address of a subnet.
516 ****************************************************************************/
518 struct response_record *queue_register_multihomed_name( struct subnet_record *subrec,
519 response_function resp_fn,
520 timeout_response_function timeout_fn,
521 register_name_success_function success_fn,
522 register_name_fail_function fail_fn,
523 struct userdata_struct *userdata,
524 struct nmb_name *nmbname,
526 struct in_addr register_ip)
528 struct packet_struct *p;
529 struct response_record *rrec;
533 if(subrec != unicast_subnet)
535 DEBUG(0,("queue_register_multihomed_name: should only be done on \
536 unicast subnet. subnet is %s\n.", subrec->subnet_name ));
540 if(assert_check_subnet(subrec))
543 if(( p = create_and_init_netbios_packet(nmbname, False, True,
544 subrec->bcast_ip)) == NULL)
547 if (nb_flags & NB_GROUP)
548 ret = initiate_name_register_packet( p, nb_flags, ®ister_ip);
550 ret = initiate_multihomed_name_register_packet( p, nb_flags, ®ister_ip);
559 if((rrec = make_response_record(subrec, /* subnet record. */
560 p, /* packet we sent. */
561 resp_fn, /* function to call on response. */
562 timeout_fn, /* function to call on timeout. */
563 (success_function)success_fn, /* function to call on operation success. */
564 (fail_function)fail_fn, /* function to call on operation fail. */
575 /****************************************************************************
576 Queue a release name packet to the broadcast address of a subnet.
577 ****************************************************************************/
579 struct response_record *queue_release_name( struct subnet_record *subrec,
580 response_function resp_fn,
581 timeout_response_function timeout_fn,
582 release_name_success_function success_fn,
583 release_name_fail_function fail_fn,
584 struct userdata_struct *userdata,
585 struct nmb_name *nmbname,
587 struct in_addr release_ip)
589 struct packet_struct *p;
590 struct response_record *rrec;
592 if(assert_check_subnet(subrec))
595 if ((p = create_and_init_netbios_packet(nmbname, (subrec != unicast_subnet), False,
596 subrec->bcast_ip)) == NULL)
599 if(initiate_name_release_packet( p, nb_flags, &release_ip) == False)
606 if((rrec = make_response_record(subrec, /* subnet record. */
607 p, /* packet we sent. */
608 resp_fn, /* function to call on response. */
609 timeout_fn, /* function to call on timeout. */
610 (success_function)success_fn, /* function to call on operation success. */
611 (fail_function)fail_fn, /* function to call on operation fail. */
620 * For a broadcast release packet, only send once.
621 * This will cause us to remove the name asap. JRA.
624 if (subrec != unicast_subnet) {
625 rrec->repeat_count = 0;
626 rrec->repeat_time = 0;
632 /****************************************************************************
633 Queue a refresh name packet to the broadcast address of a subnet.
634 ****************************************************************************/
636 struct response_record *queue_refresh_name( struct subnet_record *subrec,
637 response_function resp_fn,
638 timeout_response_function timeout_fn,
639 refresh_name_success_function success_fn,
640 refresh_name_fail_function fail_fn,
641 struct userdata_struct *userdata,
642 struct name_record *namerec,
643 struct in_addr refresh_ip)
645 struct packet_struct *p;
646 struct response_record *rrec;
648 if(assert_check_subnet(subrec))
651 if(( p = create_and_init_netbios_packet(&namerec->name, (subrec != unicast_subnet), False,
652 subrec->bcast_ip)) == NULL)
655 if( !initiate_name_refresh_packet( p, namerec->data.nb_flags, &refresh_ip ) )
662 if((rrec = make_response_record(subrec, /* subnet record. */
663 p, /* packet we sent. */
664 resp_fn, /* function to call on response. */
665 timeout_fn, /* function to call on timeout. */
666 (success_function)success_fn, /* function to call on operation success. */
667 (fail_function)fail_fn, /* function to call on operation fail. */
678 /****************************************************************************
679 Queue a query name packet to the broadcast address of a subnet.
680 ****************************************************************************/
682 struct response_record *queue_query_name( struct subnet_record *subrec,
683 response_function resp_fn,
684 timeout_response_function timeout_fn,
685 query_name_success_function success_fn,
686 query_name_fail_function fail_fn,
687 struct userdata_struct *userdata,
688 struct nmb_name *nmbname)
690 struct packet_struct *p;
691 struct response_record *rrec;
693 if(assert_check_subnet(subrec))
696 if(( p = create_and_init_netbios_packet(nmbname,
697 (subrec != unicast_subnet),
698 (subrec == unicast_subnet),
699 subrec->bcast_ip)) == NULL)
702 if(initiate_name_query_packet( p ) == False)
709 if((rrec = make_response_record(subrec, /* subnet record. */
710 p, /* packet we sent. */
711 resp_fn, /* function to call on response. */
712 timeout_fn, /* function to call on timeout. */
713 (success_function)success_fn, /* function to call on operation success. */
714 (fail_function)fail_fn, /* function to call on operation fail. */
725 /****************************************************************************
726 Queue a query name packet to a given address from the WINS subnet.
727 ****************************************************************************/
729 struct response_record *queue_query_name_from_wins_server( struct in_addr to_ip,
730 response_function resp_fn,
731 timeout_response_function timeout_fn,
732 query_name_success_function success_fn,
733 query_name_fail_function fail_fn,
734 struct userdata_struct *userdata,
735 struct nmb_name *nmbname)
737 struct packet_struct *p;
738 struct response_record *rrec;
740 if ((p = create_and_init_netbios_packet(nmbname, False, False, to_ip)) == NULL)
743 if(initiate_name_query_packet_from_wins_server( p ) == False)
750 if((rrec = make_response_record(wins_server_subnet, /* 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. */
766 /****************************************************************************
767 Queue a node status packet to a given name and address.
768 ****************************************************************************/
770 struct response_record *queue_node_status( struct subnet_record *subrec,
771 response_function resp_fn,
772 timeout_response_function timeout_fn,
773 node_status_success_function success_fn,
774 node_status_fail_function fail_fn,
775 struct userdata_struct *userdata,
776 struct nmb_name *nmbname,
777 struct in_addr send_ip)
779 struct packet_struct *p;
780 struct response_record *rrec;
783 if(subrec != unicast_subnet)
785 DEBUG(0,("queue_register_multihomed_name: should only be done on \
786 unicast subnet. subnet is %s\n.", subrec->subnet_name ));
790 if(assert_check_subnet(subrec))
793 if(( p = create_and_init_netbios_packet(nmbname, False, False,
797 if(initiate_node_status_packet(p) == False)
804 if((rrec = make_response_record(subrec, /* subnet record. */
805 p, /* packet we sent. */
806 resp_fn, /* function to call on response. */
807 timeout_fn, /* function to call on timeout. */
808 (success_function)success_fn, /* function to call on operation success. */
809 (fail_function)fail_fn, /* function to call on operation fail. */
820 /****************************************************************************
821 Reply to a netbios name packet. see rfc1002.txt
822 ****************************************************************************/
824 void reply_netbios_packet(struct packet_struct *orig_packet,
825 int rcode, enum netbios_reply_type_code rcv_code, int opcode,
826 int ttl, char *data,int len)
828 struct packet_struct packet;
829 struct nmb_packet *nmb = NULL;
830 struct res_rec answers;
831 struct nmb_packet *orig_nmb = &orig_packet->packet.nmb;
832 BOOL loopback_this_packet = False;
833 char *packet_type = "unknown";
835 /* Check if we are sending to or from ourselves. */
836 if(ismyip(orig_packet->ip) && (orig_packet->port == global_nmb_port))
837 loopback_this_packet = True;
839 nmb = &packet.packet.nmb;
841 /* Do a partial copy of the packet. We clear the locked flag and
842 the resource record pointers. */
843 packet = *orig_packet; /* Full structure copy. */
844 packet.locked = False;
847 nmb->additional = NULL;
853 packet_type = "nmb_status";
854 nmb->header.nm_flags.recursion_desired = False;
855 nmb->header.nm_flags.recursion_available = False;
860 packet_type = "nmb_query";
861 nmb->header.nm_flags.recursion_desired = True;
862 nmb->header.nm_flags.recursion_available = True;
866 case NMB_REG_REFRESH:
868 packet_type = "nmb_reg";
869 nmb->header.nm_flags.recursion_desired = True;
870 nmb->header.nm_flags.recursion_available = True;
875 packet_type = "nmb_rel";
876 nmb->header.nm_flags.recursion_desired = False;
877 nmb->header.nm_flags.recursion_available = False;
882 packet_type = "nmb_wack";
883 nmb->header.nm_flags.recursion_desired = False;
884 nmb->header.nm_flags.recursion_available = False;
889 packet_type = "wins_reg";
890 nmb->header.nm_flags.recursion_desired = True;
891 nmb->header.nm_flags.recursion_available = True;
896 packet_type = "wins_query";
897 nmb->header.nm_flags.recursion_desired = True;
898 nmb->header.nm_flags.recursion_available = True;
904 DEBUG(0,("reply_netbios_packet: Unknown packet type: %s %s to ip %s\n",
905 packet_type, nmb_namestr(&orig_nmb->question.question_name),
906 inet_ntoa(packet.ip)));
912 DEBUG(4,("reply_netbios_packet: sending a reply of packet type: %s %s to ip %s \
914 packet_type, nmb_namestr(&orig_nmb->question.question_name),
915 inet_ntoa(packet.ip), orig_nmb->header.name_trn_id));
917 nmb->header.name_trn_id = orig_nmb->header.name_trn_id;
918 nmb->header.opcode = opcode;
919 nmb->header.response = True;
920 nmb->header.nm_flags.bcast = False;
921 nmb->header.nm_flags.trunc = False;
922 nmb->header.nm_flags.authoritative = True;
924 nmb->header.rcode = rcode;
925 nmb->header.qdcount = 0;
926 nmb->header.ancount = 1;
927 nmb->header.nscount = 0;
928 nmb->header.arcount = 0;
930 memset((char*)&nmb->question,'\0',sizeof(nmb->question));
932 nmb->answers = &answers;
933 memset((char*)nmb->answers,'\0',sizeof(*nmb->answers));
935 nmb->answers->rr_name = orig_nmb->question.question_name;
936 nmb->answers->rr_type = orig_nmb->question.question_type;
937 nmb->answers->rr_class = orig_nmb->question.question_class;
938 nmb->answers->ttl = ttl;
942 nmb->answers->rdlength = len;
943 memcpy(nmb->answers->rdata, data, len);
946 packet.packet_type = NMB_PACKET;
947 /* Ensure we send out on the same fd that the original
948 packet came in on to give the correct source IP address. */
949 packet.fd = orig_packet->fd;
950 packet.timestamp = time(NULL);
952 debug_nmb_packet(&packet);
954 if(loopback_this_packet)
956 struct packet_struct *lo_packet;
957 DEBUG(5,("reply_netbios_packet: sending packet to ourselves.\n"));
958 if((lo_packet = copy_packet(&packet)) == NULL)
960 queue_packet(lo_packet);
962 else if (!send_packet(&packet))
964 DEBUG(0,("reply_netbios_packet: send_packet to IP %s port %d failed\n",
965 inet_ntoa(packet.ip),packet.port));
969 /*******************************************************************
970 Queue a packet into a packet queue
971 ******************************************************************/
972 static void queue_packet(struct packet_struct *packet)
974 struct packet_struct *p;
980 packet_queue = packet;
984 /* find the bottom */
985 for (p=packet_queue;p->next;p=p->next)
993 /****************************************************************************
994 Try and find a matching subnet record for a datagram port 138 packet.
995 ****************************************************************************/
997 static struct subnet_record *find_subnet_for_dgram_browse_packet(struct packet_struct *p)
999 struct subnet_record *subrec;
1001 /* Go through all the broadcast subnets and see if the mask matches. */
1002 for (subrec = FIRST_SUBNET; subrec ; subrec = NEXT_SUBNET_EXCLUDING_UNICAST(subrec))
1004 if(same_net(p->ip, subrec->bcast_ip, subrec->mask_ip))
1008 /* If the subnet record is the remote announce broadcast subnet,
1009 hack it here to be the first subnet. This is really gross and
1010 is needed due to people turning on port 137/138 broadcast
1011 forwarding on their routers. May fire and brimstone rain
1015 return FIRST_SUBNET;
1018 /****************************************************************************
1019 Dispatch a browse frame from port 138 to the correct processing function.
1020 ****************************************************************************/
1021 static void process_browse_packet(struct packet_struct *p, char *buf,int len)
1023 struct dgram_packet *dgram = &p->packet.dgram;
1024 int command = CVAL(buf,0);
1025 struct subnet_record *subrec = find_subnet_for_dgram_browse_packet(p);
1026 extern pstring global_scope;
1028 /* Drop the packet if it's a different NetBIOS scope, or
1029 the source is from one of our names. */
1031 if (!strequal(dgram->dest_name.scope, global_scope))
1033 DEBUG(7,("process_browse_packet: Discarding datagram from IP %s. Scope (%s) \
1034 mismatch with our scope (%s).\n", inet_ntoa(p->ip), dgram->dest_name.scope, global_scope));
1038 if (is_myname(dgram->source_name.name))
1040 DEBUG(0,("process_browse_packet: Discarding datagram from IP %s. Source name \
1041 %s is one of our names !\n", inet_ntoa(p->ip), nmb_namestr(&dgram->source_name)));
1047 case ANN_HostAnnouncement:
1049 debug_browse_data(buf, len);
1050 process_host_announce(subrec, p, buf+1);
1053 case ANN_DomainAnnouncement:
1055 debug_browse_data(buf, len);
1056 process_workgroup_announce(subrec, p, buf+1);
1059 case ANN_LocalMasterAnnouncement:
1061 debug_browse_data(buf, len);
1062 process_local_master_announce(subrec, p, buf+1);
1065 case ANN_AnnouncementRequest:
1067 debug_browse_data(buf, len);
1068 process_announce_request(subrec, p, buf+1);
1073 debug_browse_data(buf, len);
1074 process_election(subrec, p, buf+1);
1077 case ANN_GetBackupListReq:
1079 debug_browse_data(buf, len);
1080 process_get_backup_list_request(subrec, p, buf+1);
1083 case ANN_GetBackupListResp:
1085 debug_browse_data(buf, len);
1086 /* We never send ANN_GetBackupListReq so we
1087 should never get these. */
1088 DEBUG(0,("process_browse_packet: Discarding GetBackupListResponse \
1089 packet from %s IP %s\n", nmb_namestr(&dgram->source_name), inet_ntoa(p->ip)));
1092 case ANN_ResetBrowserState:
1094 debug_browse_data(buf, len);
1095 process_reset_browser(subrec, p, buf+1);
1098 case ANN_MasterAnnouncement:
1100 /* Master browser datagrams must be processed
1101 on the unicast subnet. */
1102 subrec = unicast_subnet;
1104 debug_browse_data(buf, len);
1105 process_master_browser_announce(subrec, p, buf+1);
1108 case ANN_BecomeBackup:
1111 * We don't currently implement this. Log it just in case.
1113 debug_browse_data(buf, len);
1114 DEBUG(10,("process_browse_packet: On subnet %s ignoring browse packet \
1115 command ANN_BecomeBackup from %s IP %s to %s\n",
1116 subrec->subnet_name, nmb_namestr(&dgram->source_name),
1117 inet_ntoa(p->ip), nmb_namestr(&dgram->dest_name)));
1122 debug_browse_data(buf, len);
1123 DEBUG(0,("process_browse_packet: On subnet %s ignoring browse packet \
1124 command code %d from %s IP %s to %s\n",
1125 subrec->subnet_name, command, nmb_namestr(&dgram->source_name),
1126 inet_ntoa(p->ip), nmb_namestr(&dgram->dest_name)));
1131 /****************************************************************************
1132 Dispatch a LanMan browse frame from port 138 to the correct processing function.
1133 ****************************************************************************/
1134 static void process_lanman_packet(struct packet_struct *p, char *buf,int len)
1136 struct dgram_packet *dgram = &p->packet.dgram;
1137 int command = SVAL(buf,0);
1138 struct subnet_record *subrec = find_subnet_for_dgram_browse_packet(p);
1139 extern pstring global_scope;
1141 /* Drop the packet if it's a different NetBIOS scope, or
1142 the source is from one of our names. */
1144 if (!strequal(dgram->dest_name.scope, global_scope))
1146 DEBUG(7,("process_lanman_packet: Discarding datagram from IP %s. Scope (%s) \
1147 mismatch with our scope (%s).\n", inet_ntoa(p->ip), dgram->dest_name.scope, global_scope));
1151 if (is_myname(dgram->source_name.name))
1153 DEBUG(0,("process_lanman_packet: Discarding datagram from IP %s. Source name \
1154 %s is one of our names !\n", inet_ntoa(p->ip), nmb_namestr(&dgram->source_name)));
1160 case ANN_HostAnnouncement:
1162 debug_browse_data(buf, len);
1163 process_lm_host_announce(subrec, p, buf+1);
1166 case ANN_AnnouncementRequest:
1168 process_lm_announce_request(subrec, p, buf+1);
1173 DEBUG(0,("process_lanman_packet: On subnet %s ignoring browse packet \
1174 command code %d from %s IP %s to %s\n",
1175 subrec->subnet_name, command, nmb_namestr(&dgram->source_name),
1176 inet_ntoa(p->ip), nmb_namestr(&dgram->dest_name)));
1181 /****************************************************************************
1182 Determine if a packet is for us on port 138. Note that to have any chance of
1183 being efficient we need to drop as many packets as possible at this
1184 stage as subsequent processing is expensive.
1185 ****************************************************************************/
1187 static BOOL listening(struct packet_struct *p,struct nmb_name *nbname)
1189 struct subnet_record *subrec = NULL;
1191 for (subrec = FIRST_SUBNET; subrec ; subrec = NEXT_SUBNET_EXCLUDING_UNICAST(subrec))
1193 if(same_net(p->ip, subrec->bcast_ip, subrec->mask_ip))
1198 subrec = unicast_subnet;
1200 return (find_name_on_subnet(subrec, nbname, FIND_SELF_NAME) != NULL);
1203 /****************************************************************************
1204 Process udp 138 datagrams
1205 ****************************************************************************/
1206 static void process_dgram(struct packet_struct *p)
1211 struct dgram_packet *dgram = &p->packet.dgram;
1213 /* If we aren't listening to the destination name then ignore the packet */
1214 if (!listening(p,&dgram->dest_name))
1216 unexpected_packet(p);
1217 DEBUG(5,("process_dgram: ignoring dgram packet sent to name %s from %s\n",
1218 nmb_namestr(&dgram->dest_name), inet_ntoa(p->ip)));
1222 if (dgram->header.msg_type != 0x10 &&
1223 dgram->header.msg_type != 0x11 &&
1224 dgram->header.msg_type != 0x12)
1226 unexpected_packet(p);
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);
1279 unexpected_packet(p);
1282 /****************************************************************************
1283 Validate a response nmb packet.
1284 ****************************************************************************/
1286 static BOOL validate_nmb_response_packet( struct nmb_packet *nmb )
1288 BOOL ignore = False;
1290 switch (nmb->header.opcode)
1292 case NMB_NAME_REG_OPCODE:
1293 case NMB_NAME_REFRESH_OPCODE_8: /* ambiguity in rfc1002 about which is correct. */
1294 case NMB_NAME_REFRESH_OPCODE_9: /* WinNT uses 8 by default. */
1295 if (nmb->header.ancount == 0)
1297 DEBUG(0,("validate_nmb_response_packet: Bad REG/REFRESH Packet. "));
1302 case NMB_NAME_QUERY_OPCODE:
1303 if ((nmb->header.ancount != 0) && (nmb->header.ancount != 1))
1305 DEBUG(0,("validate_nmb_response_packet: Bad QUERY Packet. "));
1309 case NMB_NAME_RELEASE_OPCODE:
1310 if (nmb->header.ancount == 0)
1312 DEBUG(0,("validate_nmb_response_packet: Bad RELEASE Packet. "));
1316 case NMB_WACK_OPCODE:
1317 /* Check WACK response here. */
1318 if (nmb->header.ancount != 1)
1320 DEBUG(0,("validate_nmb_response_packet: Bad WACK Packet. "));
1325 DEBUG(0,("validate_nmb_response_packet: Ignoring packet with unknown opcode %d.\n",
1326 nmb->header.opcode));
1331 DEBUG(0,("Ignoring response packet with opcode %d.\n", nmb->header.opcode));
1336 /****************************************************************************
1337 Validate a request nmb packet.
1338 ****************************************************************************/
1340 static BOOL validate_nmb_packet( struct nmb_packet *nmb )
1342 BOOL ignore = False;
1344 switch (nmb->header.opcode)
1346 case NMB_NAME_REG_OPCODE:
1347 case NMB_NAME_REFRESH_OPCODE_8: /* ambiguity in rfc1002 about which is correct. */
1348 case NMB_NAME_REFRESH_OPCODE_9: /* WinNT uses 8 by default. */
1349 case NMB_NAME_MULTIHOMED_REG_OPCODE:
1350 if (nmb->header.qdcount==0 || nmb->header.arcount==0)
1352 DEBUG(0,("validate_nmb_packet: Bad REG/REFRESH Packet. "));
1357 case NMB_NAME_QUERY_OPCODE:
1358 if ((nmb->header.qdcount == 0) ||
1359 ((nmb->question.question_type != QUESTION_TYPE_NB_QUERY) &&
1360 (nmb->question.question_type != QUESTION_TYPE_NB_STATUS)))
1362 DEBUG(0,("validate_nmb_packet: Bad QUERY Packet. "));
1367 case NMB_NAME_RELEASE_OPCODE:
1368 if (nmb->header.qdcount==0 || nmb->header.arcount==0)
1370 DEBUG(0,("validate_nmb_packet: Bad RELEASE Packet. "));
1375 DEBUG(0,("validate_nmb_packet: Ignoring packet with unknown opcode %d.\n",
1376 nmb->header.opcode));
1381 DEBUG(0,("validate_nmb_packet: Ignoring request packet with opcode %d.\n", nmb->header.opcode));
1386 /****************************************************************************
1387 Find a subnet (and potentially a response record) for a packet.
1388 ****************************************************************************/
1390 static struct subnet_record *find_subnet_for_nmb_packet( struct packet_struct *p,
1391 struct response_record **pprrec)
1393 struct nmb_packet *nmb = &p->packet.nmb;
1394 struct response_record *rrec = NULL;
1395 struct subnet_record *subrec = NULL;
1400 if(nmb->header.response)
1402 /* It's a response packet. Find a record for it or it's an error. */
1404 rrec = find_response_record( &subrec, nmb->header.name_trn_id);
1407 DEBUG(3,("find_subnet_for_nmb_packet: response record not found for response id %hu\n",
1408 nmb->header.name_trn_id));
1409 unexpected_packet(p);
1415 DEBUG(0,("find_subnet_for_nmb_packet: subnet record not found for response id %hu\n",
1416 nmb->header.name_trn_id));
1425 /* Try and see what subnet this packet belongs to. */
1428 if(packet_is_for_wins_server(p))
1429 return wins_server_subnet;
1431 /* If it wasn't a broadcast packet then send to the UNICAST subnet. */
1432 if(nmb->header.nm_flags.bcast == False)
1433 return unicast_subnet;
1435 /* Go through all the broadcast subnets and see if the mask matches. */
1436 for (subrec = FIRST_SUBNET; subrec ; subrec = NEXT_SUBNET_EXCLUDING_UNICAST(subrec))
1438 if(same_net(p->ip, subrec->bcast_ip, subrec->mask_ip))
1442 /* If none match it must have been a directed broadcast - assign
1443 the remote_broadcast_subnet. */
1444 return remote_broadcast_subnet;
1447 /****************************************************************************
1448 Process a nmb request packet - validate the packet and route it.
1449 ****************************************************************************/
1451 static void process_nmb_request(struct packet_struct *p)
1453 struct nmb_packet *nmb = &p->packet.nmb;
1454 struct subnet_record *subrec = NULL;
1456 debug_nmb_packet(p);
1458 /* Ensure we have a good packet. */
1459 if(validate_nmb_packet(nmb))
1462 /* Allocate a subnet to this packet - if we cannot - fail. */
1463 if((subrec = find_subnet_for_nmb_packet(p, NULL))==NULL)
1466 switch (nmb->header.opcode)
1468 case NMB_NAME_REG_OPCODE:
1469 if(subrec == wins_server_subnet)
1470 wins_process_name_registration_request(subrec, p);
1472 process_name_registration_request(subrec, p);
1475 case NMB_NAME_REFRESH_OPCODE_8: /* ambiguity in rfc1002 about which is correct. */
1476 case NMB_NAME_REFRESH_OPCODE_9:
1477 if(subrec == wins_server_subnet)
1478 wins_process_name_refresh_request(subrec, p);
1480 process_name_refresh_request(subrec, p);
1483 case NMB_NAME_MULTIHOMED_REG_OPCODE:
1484 if(subrec == wins_server_subnet)
1485 wins_process_multihomed_name_registration_request(subrec, p);
1488 DEBUG(0,("process_nmb_request: Multihomed registration request must be \
1489 directed at a WINS server.\n"));
1493 case NMB_NAME_QUERY_OPCODE:
1494 switch (nmb->question.question_type)
1496 case QUESTION_TYPE_NB_QUERY:
1498 if(subrec == wins_server_subnet)
1499 wins_process_name_query_request(subrec, p);
1501 process_name_query_request(subrec, p);
1504 case QUESTION_TYPE_NB_STATUS:
1506 if(subrec == wins_server_subnet)
1508 DEBUG(0,("process_nmb_request: NB_STATUS request directed at WINS server is \
1513 process_node_status_request(subrec, p);
1519 case NMB_NAME_RELEASE_OPCODE:
1520 if(subrec == wins_server_subnet)
1521 wins_process_name_release_request(subrec, p);
1523 process_name_release_request(subrec, p);
1528 /****************************************************************************
1529 Process a nmb response packet - validate the packet and route it.
1530 to either the WINS server or a normal response.
1531 ****************************************************************************/
1533 static void process_nmb_response(struct packet_struct *p)
1535 struct nmb_packet *nmb = &p->packet.nmb;
1536 struct subnet_record *subrec = NULL;
1537 struct response_record *rrec = NULL;
1539 debug_nmb_packet(p);
1541 if(validate_nmb_response_packet(nmb))
1544 if((subrec = find_subnet_for_nmb_packet(p, &rrec))==NULL)
1549 DEBUG(0,("process_nmb_response: response packet received but no response record \
1550 found for id = %hu. Ignoring packet.\n", nmb->header.name_trn_id));
1554 /* Increment the number of responses received for this record. */
1556 /* Ensure we don't re-send the request. */
1557 rrec->repeat_count = 0;
1559 /* Call the response received function for this packet. */
1560 (*rrec->resp_fn)(subrec, rrec, p);
1564 /*******************************************************************
1565 Run elements off the packet queue till its empty
1566 ******************************************************************/
1568 void run_packet_queue(void)
1570 struct packet_struct *p;
1572 while ((p = packet_queue))
1574 packet_queue = p->next;
1576 packet_queue->prev = NULL;
1577 p->next = p->prev = NULL;
1579 switch (p->packet_type)
1582 if(p->packet.nmb.header.response)
1583 process_nmb_response(p);
1585 process_nmb_request(p);
1596 /*******************************************************************
1597 Retransmit or timeout elements from all the outgoing subnet response
1598 record queues. NOTE that this code must also check the WINS server
1599 subnet for response records to timeout as the WINS server code
1600 can send requests to check if a client still owns a name.
1601 (Patch from Andrey Alekseyev <fetch@muffin.arcadia.spb.ru>).
1602 ******************************************************************/
1604 void retransmit_or_expire_response_records(time_t t)
1606 struct subnet_record *subrec;
1608 for (subrec = FIRST_SUBNET; subrec;
1609 subrec = get_next_subnet_maybe_unicast_or_wins_server(subrec))
1611 struct response_record *rrec, *nextrrec;
1613 for (rrec = subrec->responselist; rrec; rrec = nextrrec)
1615 nextrrec = rrec->next;
1617 if (rrec->repeat_time <= t)
1619 if (rrec->repeat_count > 0)
1621 /* Resend while we have a non-zero repeat_count. */
1622 if(!send_packet(rrec->packet))
1624 DEBUG(0,("retransmit_or_expire_response_records: Failed to resend packet id %hu \
1625 to IP %s on subnet %s\n", rrec->response_id, inet_ntoa(rrec->packet->ip),
1626 subrec->subnet_name));
1628 rrec->repeat_time += rrec->repeat_interval;
1629 rrec->repeat_count--;
1633 DEBUG(4,("retransmit_or_expire_response_records: timeout for packet id %hu to IP %s \
1634 on subnet %s\n", rrec->response_id, inet_ntoa(rrec->packet->ip),
1635 subrec->subnet_name));
1638 * Check the flag in this record to prevent recursion if we end
1639 * up in this function again via the timeout function call.
1642 if(!rrec->in_expiration_processing)
1646 * Set the recursion protection flag in this record.
1649 rrec->in_expiration_processing = True;
1651 /* Call the timeout function. This will deal with removing the
1652 timed out packet. */
1653 if(rrec->timeout_fn)
1654 (*rrec->timeout_fn)(subrec, rrec);
1657 /* We must remove the record ourself if there is
1658 no timeout function. */
1659 remove_response_record(subrec, rrec);
1661 } /* !rrec->in_expitation_processing */
1662 } /* rrec->repeat_count > 0 */
1663 } /* rrec->repeat_time <= t */
1664 } /* end for rrec */
1665 } /* end for subnet */
1668 /****************************************************************************
1669 Create an fd_set containing all the sockets in the subnet structures,
1670 plus the broadcast sockets.
1671 ***************************************************************************/
1673 static BOOL create_listen_fdset(fd_set **ppset, int **psock_array, int *listen_number)
1675 int *sock_array = NULL;
1676 struct subnet_record *subrec = NULL;
1679 fd_set *pset = (fd_set *)malloc(sizeof(fd_set));
1683 DEBUG(0,("create_listen_fdset: malloc fail !\n"));
1687 /* Check that we can add all the fd's we need. */
1688 for (subrec = FIRST_SUBNET; subrec; subrec = NEXT_SUBNET_EXCLUDING_UNICAST(subrec))
1691 if((count*2) + 2 > FD_SETSIZE)
1693 DEBUG(0,("create_listen_fdset: Too many file descriptors needed (%d). We can \
1694 only use %d.\n", (count*2) + 2, FD_SETSIZE));
1698 if((sock_array = (int *)malloc(((count*2) + 2)*sizeof(int))) == NULL)
1700 DEBUG(0,("create_listen_fdset: malloc fail for socket array.\n"));
1706 /* Add in the broadcast socket on 137. */
1707 FD_SET(ClientNMB,pset);
1708 sock_array[num++] = ClientNMB;
1710 /* Add in the 137 sockets on all the interfaces. */
1711 for (subrec = FIRST_SUBNET; subrec; subrec = NEXT_SUBNET_EXCLUDING_UNICAST(subrec))
1713 FD_SET(subrec->nmb_sock,pset);
1714 sock_array[num++] = subrec->nmb_sock;
1717 /* Add in the broadcast socket on 138. */
1718 FD_SET(ClientDGRAM,pset);
1719 sock_array[num++] = ClientDGRAM;
1721 /* Add in the 138 sockets on all the interfaces. */
1722 for (subrec = FIRST_SUBNET; subrec; subrec = NEXT_SUBNET_EXCLUDING_UNICAST(subrec))
1724 FD_SET(subrec->dgram_sock,pset);
1725 sock_array[num++] = subrec->dgram_sock;
1728 *listen_number = (count*2) + 2;
1730 if (*ppset) free(*ppset);
1731 if (*psock_array) free(*psock_array);
1734 *psock_array = sock_array;
1739 /****************************************************************************
1740 Listens for NMB or DGRAM packets, and queues them.
1741 ***************************************************************************/
1743 BOOL listen_for_packets(BOOL run_election)
1745 static fd_set *listen_set = NULL;
1746 static int listen_number = 0;
1747 static int *sock_array = NULL;
1751 struct timeval timeout;
1756 if(listen_set == NULL || rescan_listen_set)
1758 if(create_listen_fdset(&listen_set, &sock_array, &listen_number))
1760 DEBUG(0,("listen_for_packets: Fatal error. unable to create listen set. Exiting.\n"));
1763 rescan_listen_set = False;
1766 memcpy((char *)&fds, (char *)listen_set, sizeof(fd_set));
1769 dns_fd = asyncdns_fd();
1771 FD_SET(dns_fd, &fds);
1777 * During elections and when expecting a netbios response packet we
1778 * need to send election packets at tighter intervals.
1779 * Ideally it needs to be the interval (in ms) between time now and
1780 * the time we are expecting the next netbios packet.
1783 timeout.tv_sec = (run_election||num_response_packets) ? 1 : NMBD_SELECT_LOOP;
1784 timeout.tv_usec = 0;
1786 /* Prepare for the select - allow certain signals. */
1788 BlockSignals(False, SIGTERM);
1789 #if defined(SIGUSR1)
1790 BlockSignals(False, SIGUSR1);
1791 #endif /* SIGUSR1 */
1792 #if defined(SIGUSR2)
1793 BlockSignals(False, SIGUSR2);
1794 #endif /* SIGUSR2 */
1796 selrtn = sys_select_intr(FD_SETSIZE,&fds,&timeout);
1798 /* We can only take signals when we are in the select - block them again here. */
1800 BlockSignals(True, SIGTERM);
1801 #if defined(SIGUSR1)
1802 BlockSignals(True, SIGUSR1);
1803 #endif /* SIGUSR1 */
1804 #if defined(SIGUSR2)
1805 BlockSignals(True, SIGUSR2);
1806 #endif /* SIGUSR2 */
1813 if (dns_fd != -1 && FD_ISSET(dns_fd,&fds)) {
1818 for(i = 0; i < listen_number; i++)
1820 if(i < (listen_number/2))
1822 /* Processing a 137 socket. */
1823 if (FD_ISSET(sock_array[i],&fds))
1825 struct packet_struct *packet = read_packet(sock_array[i], NMB_PACKET);
1829 * If we got a packet on the broadcast socket and interfaces
1830 * only is set then check it came from one of our local nets.
1832 if(lp_bind_interfaces_only() && (sock_array[i] == ClientNMB) &&
1833 (!is_local_net(packet->ip)))
1835 DEBUG(7,("discarding nmb packet sent to broadcast socket from %s:%d\n",
1836 inet_ntoa(packet->ip),packet->port));
1837 free_packet(packet);
1839 else if ((ip_equal(loopback_ip, packet->ip) ||
1840 ismyip(packet->ip)) && packet->port == global_nmb_port)
1842 DEBUG(7,("discarding own packet from %s:%d\n",
1843 inet_ntoa(packet->ip),packet->port));
1844 free_packet(packet);
1848 /* Save the file descriptor this packet came in on. */
1849 packet->fd = sock_array[i];
1850 queue_packet(packet);
1857 /* Processing a 138 socket. */
1859 if (FD_ISSET(sock_array[i],&fds))
1861 struct packet_struct *packet = read_packet(sock_array[i], DGRAM_PACKET);
1865 * If we got a packet on the broadcast socket and interfaces
1866 * only is set then check it came from one of our local nets.
1868 if(lp_bind_interfaces_only() && (sock_array[i] == ClientDGRAM) &&
1869 (!is_local_net(packet->ip)))
1871 DEBUG(7,("discarding dgram packet sent to broadcast socket from %s:%d\n",
1872 inet_ntoa(packet->ip),packet->port));
1873 free_packet(packet);
1875 else if ((ip_equal(loopback_ip, packet->ip) ||
1876 ismyip(packet->ip)) && packet->port == DGRAM_PORT)
1878 DEBUG(7,("discarding own packet from %s:%d\n",
1879 inet_ntoa(packet->ip),packet->port));
1880 free_packet(packet);
1884 /* Save the file descriptor this packet came in on. */
1885 packet->fd = sock_array[i];
1886 queue_packet(packet);
1890 } /* end processing 138 socket. */
1892 } /* end if selret > 0 */
1896 /****************************************************************************
1897 Construct and send a netbios DGRAM.
1898 **************************************************************************/
1899 BOOL send_mailslot(BOOL unique, char *mailslot,char *buf,int len,
1900 char *srcname, int src_type,
1901 char *dstname, int dest_type,
1902 struct in_addr dest_ip,struct in_addr src_ip,
1905 BOOL loopback_this_packet = False;
1906 struct packet_struct p;
1907 struct dgram_packet *dgram = &p.packet.dgram;
1911 memset((char *)&p,'\0',sizeof(p));
1914 loopback_this_packet = True;
1916 generate_name_trn_id();
1918 /* DIRECT GROUP or UNIQUE datagram. */
1919 dgram->header.msg_type = unique ? 0x10 : 0x11;
1920 dgram->header.flags.node_type = M_NODE;
1921 dgram->header.flags.first = True;
1922 dgram->header.flags.more = False;
1923 dgram->header.dgm_id = name_trn_id;
1924 dgram->header.source_ip = src_ip;
1925 dgram->header.source_port = DGRAM_PORT;
1926 dgram->header.dgm_length = 0; /* Let build_dgram() handle this. */
1927 dgram->header.packet_offset = 0;
1929 make_nmb_name(&dgram->source_name,srcname,src_type);
1930 make_nmb_name(&dgram->dest_name,dstname,dest_type);
1932 ptr = &dgram->data[0];
1934 /* Setup the smb part. */
1935 ptr -= 4; /* XXX Ugliness because of handling of tcp SMB length. */
1937 set_message(ptr,17,17 + len,True);
1940 CVAL(ptr,smb_com) = SMBtrans;
1941 SSVAL(ptr,smb_vwv1,len);
1942 SSVAL(ptr,smb_vwv11,len);
1943 SSVAL(ptr,smb_vwv12,70 + strlen(mailslot));
1944 SSVAL(ptr,smb_vwv13,3);
1945 SSVAL(ptr,smb_vwv14,1);
1946 SSVAL(ptr,smb_vwv15,1);
1947 SSVAL(ptr,smb_vwv16,2);
1949 pstrcpy(p2,mailslot);
1950 p2 = skip_string(p2,1);
1955 dgram->datasize = PTR_DIFF(p2,ptr+4); /* +4 for tcp length. */
1959 p.fd = find_subnet_mailslot_fd_for_address( src_ip );
1960 p.timestamp = time(NULL);
1961 p.packet_type = DGRAM_PACKET;
1963 DEBUG(4,("send_mailslot: Sending to mailslot %s from %s IP %s ", mailslot,
1964 nmb_namestr(&dgram->source_name), inet_ntoa(src_ip)));
1965 DEBUG(4,("to %s IP %s\n", nmb_namestr(&dgram->dest_name), inet_ntoa(dest_ip)));
1967 debug_browse_data(buf, len);
1969 if(loopback_this_packet)
1971 struct packet_struct *lo_packet = NULL;
1972 DEBUG(5,("send_mailslot: sending packet to ourselves.\n"));
1973 if((lo_packet = copy_packet(&p)) == NULL)
1975 queue_packet(lo_packet);
1979 return(send_packet(&p));