2 Unix SMB/CIFS implementation.
3 NBT netbios routines and daemon - version 2
4 Copyright (C) Andrew Tridgell 1994-1998
5 Copyright (C) Luke Kenneth Casson Leighton 1994-1998
6 Copyright (C) Jeremy Allison 1994-1998
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
27 extern int ClientDGRAM;
28 extern int global_nmb_port;
30 extern int num_response_packets;
32 extern struct in_addr loopback_ip;
34 static void queue_packet(struct packet_struct *packet);
36 BOOL rescan_listen_set = False;
39 /*******************************************************************
40 The global packet linked-list. Incoming entries are
41 added to the end of this list. It is supposed to remain fairly
42 short so we won't bother with an end pointer.
43 ******************************************************************/
45 static struct packet_struct *packet_queue = NULL;
47 /***************************************************************************
48 Utility function to find the specific fd to send a packet out on.
49 **************************************************************************/
51 static int find_subnet_fd_for_address( struct in_addr local_ip )
53 struct subnet_record *subrec;
55 for( subrec = FIRST_SUBNET; subrec; subrec = NEXT_SUBNET_EXCLUDING_UNICAST(subrec))
56 if(ip_equal(local_ip, subrec->myip))
57 return subrec->nmb_sock;
62 /***************************************************************************
63 Utility function to find the specific fd to send a mailslot packet out on.
64 **************************************************************************/
66 static int find_subnet_mailslot_fd_for_address( struct in_addr local_ip )
68 struct subnet_record *subrec;
70 for( subrec = FIRST_SUBNET; subrec; subrec = NEXT_SUBNET_EXCLUDING_UNICAST(subrec))
71 if(ip_equal(local_ip, subrec->myip))
72 return subrec->dgram_sock;
77 /***************************************************************************
78 Get/Set problematic nb_flags as network byte order 16 bit int.
79 **************************************************************************/
81 uint16 get_nb_flags(char *buf)
83 return ((((uint16)*buf)&0xFFFF) & NB_FLGMSK);
86 void set_nb_flags(char *buf, uint16 nb_flags)
88 *buf++ = ((nb_flags & NB_FLGMSK) & 0xFF);
92 /***************************************************************************
93 Dumps out the browse packet data.
94 **************************************************************************/
96 static void debug_browse_data(char *outbuf, int len)
100 DEBUG( 4, ( "debug_browse_data():\n" ) );
101 for (i = 0; i < len; i+= 16)
103 DEBUGADD( 4, ( "%3x char ", i ) );
105 for (j = 0; j < 16; j++)
112 if (x < 32 || x > 127)
115 DEBUGADD( 4, ( "%c", x ) );
118 DEBUGADD( 4, ( "%*s hex", 16-j, "" ) );
120 for (j = 0; j < 16; j++)
124 DEBUGADD( 4, ( " %02x", (unsigned char)outbuf[i+j] ) );
127 DEBUGADD( 4, ("\n") );
131 /***************************************************************************
132 Generates the unique transaction identifier
133 **************************************************************************/
135 static uint16 name_trn_id=0;
137 static uint16 generate_name_trn_id(void)
142 name_trn_id = ((unsigned)time(NULL)%(unsigned)0x7FFF) + ((unsigned)sys_getpid()%(unsigned)100);
144 name_trn_id = (name_trn_id+1) % (unsigned)0x7FFF;
148 /***************************************************************************
149 Either loops back or sends out a completed NetBIOS packet.
150 **************************************************************************/
152 static BOOL send_netbios_packet(struct packet_struct *p)
154 BOOL loopback_this_packet = False;
156 /* Check if we are sending to or from ourselves as a WINS server. */
157 if(ismyip(p->ip) && (p->port == global_nmb_port))
158 loopback_this_packet = True;
160 if(loopback_this_packet)
162 struct packet_struct *lo_packet = NULL;
163 DEBUG(5,("send_netbios_packet: sending packet to ourselves.\n"));
164 if((lo_packet = copy_packet(p)) == NULL)
166 queue_packet(lo_packet);
168 else if (!send_packet(p))
170 DEBUG(0,("send_netbios_packet: send_packet() to IP %s port %d failed\n",
171 inet_ntoa(p->ip),p->port));
178 /***************************************************************************
179 Sets up the common elements of an outgoing NetBIOS packet.
181 Note: do not attempt to rationalise whether rec_des should be set or not
182 in a particular situation. Just follow rfc_1002 or look at examples from WinXX.
183 It does NOT follow the rule that requests to the wins server always have
184 rec_des true. See for example name releases and refreshes
185 **************************************************************************/
187 static struct packet_struct *create_and_init_netbios_packet(struct nmb_name *nmbname,
188 BOOL bcast, BOOL rec_des,
189 struct in_addr to_ip)
191 struct packet_struct *packet = NULL;
192 struct nmb_packet *nmb = NULL;
194 /* Allocate the packet_struct we will return. */
195 if((packet = (struct packet_struct *)malloc(sizeof(*packet))) == NULL)
197 DEBUG(0,("create_and_init_netbios_packet: malloc fail (1) for packet struct.\n"));
201 memset((char *)packet,'\0',sizeof(*packet));
203 nmb = &packet->packet.nmb;
205 nmb->header.name_trn_id = generate_name_trn_id();
206 nmb->header.response = False;
207 nmb->header.nm_flags.recursion_desired = rec_des;
208 nmb->header.nm_flags.recursion_available = False;
209 nmb->header.nm_flags.trunc = False;
210 nmb->header.nm_flags.authoritative = False;
211 nmb->header.nm_flags.bcast = bcast;
213 nmb->header.rcode = 0;
214 nmb->header.qdcount = 1;
215 nmb->header.ancount = 0;
216 nmb->header.nscount = 0;
218 nmb->question.question_name = *nmbname;
219 nmb->question.question_type = QUESTION_TYPE_NB_QUERY;
220 nmb->question.question_class = QUESTION_CLASS_IN;
223 packet->port = NMB_PORT;
224 packet->fd = ClientNMB;
225 packet->timestamp = time(NULL);
226 packet->packet_type = NMB_PACKET;
227 packet->locked = False;
229 return packet; /* Caller must free. */
232 /***************************************************************************
233 Sets up the common elements of register, refresh or release packet.
234 **************************************************************************/
236 static BOOL create_and_init_additional_record(struct packet_struct *packet,
238 struct in_addr *register_ip)
240 struct nmb_packet *nmb = &packet->packet.nmb;
242 if((nmb->additional = (struct res_rec *)malloc(sizeof(struct res_rec))) == NULL) {
243 DEBUG(0,("initiate_name_register_packet: malloc fail for additional record.\n"));
247 memset((char *)nmb->additional,'\0',sizeof(struct res_rec));
249 nmb->additional->rr_name = nmb->question.question_name;
250 nmb->additional->rr_type = RR_TYPE_NB;
251 nmb->additional->rr_class = RR_CLASS_IN;
253 /* See RFC 1002, sections 5.1.1.1, 5.1.1.2 and 5.1.1.3 */
254 if (nmb->header.nm_flags.bcast)
255 nmb->additional->ttl = PERMANENT_TTL;
257 nmb->additional->ttl = lp_max_ttl();
259 nmb->additional->rdlength = 6;
261 set_nb_flags(nmb->additional->rdata,nb_flags);
263 /* Set the address for the name we are registering. */
264 putip(&nmb->additional->rdata[2], register_ip);
267 it turns out that Jeremys code was correct, we are supposed
268 to send registrations from the IP we are registering. The
269 trick is what to do on timeouts! When we send on a
270 non-routable IP then the reply will timeout, and we should
271 treat this as success, not failure. That means we go into
272 our standard refresh cycle for that name which copes nicely
273 with disconnected networks.
275 packet->fd = find_subnet_fd_for_address(*register_ip);
280 /***************************************************************************
281 Sends out a name query.
282 **************************************************************************/
284 static BOOL initiate_name_query_packet( struct packet_struct *packet)
286 struct nmb_packet *nmb = NULL;
288 nmb = &packet->packet.nmb;
290 nmb->header.opcode = NMB_NAME_QUERY_OPCODE;
291 nmb->header.arcount = 0;
293 nmb->header.nm_flags.recursion_desired = True;
295 DEBUG(4,("initiate_name_query_packet: sending query for name %s (bcast=%s) to IP %s\n",
296 nmb_namestr(&nmb->question.question_name),
297 BOOLSTR(nmb->header.nm_flags.bcast), inet_ntoa(packet->ip)));
299 return send_netbios_packet( packet );
302 /***************************************************************************
303 Sends out a name query - from a WINS server.
304 **************************************************************************/
306 static BOOL initiate_name_query_packet_from_wins_server( struct packet_struct *packet)
308 struct nmb_packet *nmb = NULL;
310 nmb = &packet->packet.nmb;
312 nmb->header.opcode = NMB_NAME_QUERY_OPCODE;
313 nmb->header.arcount = 0;
315 nmb->header.nm_flags.recursion_desired = False;
317 DEBUG(4,("initiate_name_query_packet_from_wins_server: sending query for name %s (bcast=%s) to IP %s\n",
318 nmb_namestr(&nmb->question.question_name),
319 BOOLSTR(nmb->header.nm_flags.bcast), inet_ntoa(packet->ip)));
321 return send_netbios_packet( packet );
324 /***************************************************************************
325 Sends out a name register.
326 **************************************************************************/
328 static BOOL initiate_name_register_packet( struct packet_struct *packet,
329 uint16 nb_flags, struct in_addr *register_ip)
331 struct nmb_packet *nmb = &packet->packet.nmb;
333 nmb->header.opcode = NMB_NAME_REG_OPCODE;
334 nmb->header.arcount = 1;
336 nmb->header.nm_flags.recursion_desired = True;
338 if(create_and_init_additional_record(packet, nb_flags, register_ip) == False)
341 DEBUG(4,("initiate_name_register_packet: sending registration for name %s (bcast=%s) to IP %s\n",
342 nmb_namestr(&nmb->additional->rr_name),
343 BOOLSTR(nmb->header.nm_flags.bcast), inet_ntoa(packet->ip)));
345 return send_netbios_packet( packet );
348 /***************************************************************************
349 Sends out a multihomed name register.
350 **************************************************************************/
352 static BOOL initiate_multihomed_name_register_packet(struct packet_struct *packet,
353 uint16 nb_flags, struct in_addr *register_ip)
355 struct nmb_packet *nmb = &packet->packet.nmb;
356 fstring second_ip_buf;
358 fstrcpy(second_ip_buf, inet_ntoa(packet->ip));
360 nmb->header.opcode = NMB_NAME_MULTIHOMED_REG_OPCODE;
361 nmb->header.arcount = 1;
363 nmb->header.nm_flags.recursion_desired = True;
365 if(create_and_init_additional_record(packet, nb_flags, register_ip) == False)
368 DEBUG(4,("initiate_multihomed_name_register_packet: sending registration \
369 for name %s IP %s (bcast=%s) to IP %s\n",
370 nmb_namestr(&nmb->additional->rr_name), inet_ntoa(*register_ip),
371 BOOLSTR(nmb->header.nm_flags.bcast), second_ip_buf ));
373 return send_netbios_packet( packet );
376 /***************************************************************************
377 Sends out a name refresh.
378 **************************************************************************/
380 static BOOL initiate_name_refresh_packet( struct packet_struct *packet,
381 uint16 nb_flags, struct in_addr *refresh_ip)
383 struct nmb_packet *nmb = &packet->packet.nmb;
385 nmb->header.opcode = NMB_NAME_REFRESH_OPCODE_8;
386 nmb->header.arcount = 1;
388 nmb->header.nm_flags.recursion_desired = False;
390 if(create_and_init_additional_record(packet, nb_flags, refresh_ip) == False)
393 DEBUG(4,("initiate_name_refresh_packet: sending refresh for name %s (bcast=%s) to IP %s\n",
394 nmb_namestr(&nmb->additional->rr_name),
395 BOOLSTR(nmb->header.nm_flags.bcast), inet_ntoa(packet->ip)));
397 return send_netbios_packet( packet );
400 /***************************************************************************
401 Sends out a name release.
402 **************************************************************************/
404 static BOOL initiate_name_release_packet( struct packet_struct *packet,
405 uint16 nb_flags, struct in_addr *release_ip)
407 struct nmb_packet *nmb = &packet->packet.nmb;
409 nmb->header.opcode = NMB_NAME_RELEASE_OPCODE;
410 nmb->header.arcount = 1;
412 nmb->header.nm_flags.recursion_desired = False;
414 if(create_and_init_additional_record(packet, nb_flags, release_ip) == False)
417 DEBUG(4,("initiate_name_release_packet: sending release for name %s (bcast=%s) to IP %s\n",
418 nmb_namestr(&nmb->additional->rr_name),
419 BOOLSTR(nmb->header.nm_flags.bcast), inet_ntoa(packet->ip)));
421 return send_netbios_packet( packet );
424 /***************************************************************************
425 Sends out a node status.
426 **************************************************************************/
428 static BOOL initiate_node_status_packet( struct packet_struct *packet )
430 struct nmb_packet *nmb = &packet->packet.nmb;
432 nmb->header.opcode = NMB_NAME_QUERY_OPCODE;
433 nmb->header.arcount = 0;
435 nmb->header.nm_flags.recursion_desired = False;
437 nmb->question.question_type = QUESTION_TYPE_NB_STATUS;
439 DEBUG(4,("initiate_node_status_packet: sending node status request for name %s to IP %s\n",
440 nmb_namestr(&nmb->question.question_name),
441 inet_ntoa(packet->ip)));
443 return send_netbios_packet( packet );
446 /****************************************************************************
447 Simplification functions for queuing standard packets.
448 These should be the only publicly callable functions for sending
450 ****************************************************************************/
452 /****************************************************************************
453 Assertion - we should never be sending nmbd packets on the remote
455 ****************************************************************************/
457 static BOOL assert_check_subnet(struct subnet_record *subrec)
459 if( subrec == remote_broadcast_subnet)
461 DEBUG(0,("assert_check_subnet: Attempt to send packet on remote broadcast subnet. \
468 /****************************************************************************
469 Queue a register name packet to the broadcast address of a subnet.
470 ****************************************************************************/
472 struct response_record *queue_register_name( struct subnet_record *subrec,
473 response_function resp_fn,
474 timeout_response_function timeout_fn,
475 register_name_success_function success_fn,
476 register_name_fail_function fail_fn,
477 struct userdata_struct *userdata,
478 struct nmb_name *nmbname,
481 struct packet_struct *p;
482 struct response_record *rrec;
484 if(assert_check_subnet(subrec))
487 /* note that all name registration requests have RD set (rfc1002 -
489 if ((p = create_and_init_netbios_packet(nmbname, (subrec != unicast_subnet), True,
490 subrec->bcast_ip)) == NULL)
493 if(initiate_name_register_packet( p, nb_flags,
494 iface_ip(subrec->bcast_ip)) == False)
501 if((rrec = make_response_record(subrec, /* subnet record. */
502 p, /* packet we sent. */
503 resp_fn, /* function to call on response. */
504 timeout_fn, /* function to call on timeout. */
505 (success_function)success_fn, /* function to call on operation success. */
506 (fail_function)fail_fn, /* function to call on operation fail. */
518 /****************************************************************************
519 Queue a refresh name packet to the broadcast address of a subnet.
520 ****************************************************************************/
521 void queue_wins_refresh(struct nmb_name *nmbname,
522 response_function resp_fn,
523 timeout_response_function timeout_fn,
525 struct in_addr refresh_ip,
528 struct packet_struct *p;
529 struct response_record *rrec;
530 struct in_addr wins_ip;
531 struct userdata_struct *userdata;
534 wins_ip = wins_srv_ip_tag(tag, refresh_ip);
536 if ((p = create_and_init_netbios_packet(nmbname, False, False, wins_ip)) == NULL) {
540 if (!initiate_name_refresh_packet(p, nb_flags, &refresh_ip)) {
546 fstrcpy(ip_str, inet_ntoa(refresh_ip));
548 DEBUG(6,("Refreshing name %s IP %s with WINS server %s using tag '%s'\n",
549 nmb_namestr(nmbname), ip_str, inet_ntoa(wins_ip), tag));
551 userdata = (struct userdata_struct *)malloc(sizeof(*userdata) + strlen(tag) + 1);
553 DEBUG(0,("Failed to allocate userdata structure!\n"));
556 ZERO_STRUCTP(userdata);
557 userdata->userdata_len = strlen(tag) + 1;
558 strlcpy(userdata->data, tag, userdata->userdata_len);
560 if ((rrec = make_response_record(unicast_subnet,
565 userdata)) == NULL) {
573 /* we don't want to repeat refresh packets */
574 rrec->repeat_count = 0;
578 /****************************************************************************
579 Queue a multihomed register name packet to a given WINS server IP
580 ****************************************************************************/
582 struct response_record *queue_register_multihomed_name( struct subnet_record *subrec,
583 response_function resp_fn,
584 timeout_response_function timeout_fn,
585 register_name_success_function success_fn,
586 register_name_fail_function fail_fn,
587 struct userdata_struct *userdata,
588 struct nmb_name *nmbname,
590 struct in_addr register_ip,
591 struct in_addr wins_ip)
593 struct packet_struct *p;
594 struct response_record *rrec;
598 if(subrec != unicast_subnet) {
599 DEBUG(0,("queue_register_multihomed_name: should only be done on \
600 unicast subnet. subnet is %s\n.", subrec->subnet_name ));
604 if(assert_check_subnet(subrec))
607 if ((p = create_and_init_netbios_packet(nmbname, False, True, wins_ip)) == NULL)
610 if (nb_flags & NB_GROUP)
611 ret = initiate_name_register_packet( p, nb_flags, ®ister_ip);
613 ret = initiate_multihomed_name_register_packet(p, nb_flags, ®ister_ip);
621 if ((rrec = make_response_record(subrec, /* subnet record. */
622 p, /* packet we sent. */
623 resp_fn, /* function to call on response. */
624 timeout_fn, /* function to call on timeout. */
625 (success_function)success_fn, /* function to call on operation success. */
626 (fail_function)fail_fn, /* function to call on operation fail. */
627 userdata)) == NULL) {
636 /****************************************************************************
637 Queue a release name packet to the broadcast address of a subnet.
638 ****************************************************************************/
640 struct response_record *queue_release_name( struct subnet_record *subrec,
641 response_function resp_fn,
642 timeout_response_function timeout_fn,
643 release_name_success_function success_fn,
644 release_name_fail_function fail_fn,
645 struct userdata_struct *userdata,
646 struct nmb_name *nmbname,
648 struct in_addr release_ip,
649 struct in_addr dest_ip)
651 struct packet_struct *p;
652 struct response_record *rrec;
654 if(assert_check_subnet(subrec))
657 if ((p = create_and_init_netbios_packet(nmbname, (subrec != unicast_subnet), False,
661 if(initiate_name_release_packet( p, nb_flags, &release_ip) == False)
668 if((rrec = make_response_record(subrec, /* subnet record. */
669 p, /* packet we sent. */
670 resp_fn, /* function to call on response. */
671 timeout_fn, /* function to call on timeout. */
672 (success_function)success_fn, /* function to call on operation success. */
673 (fail_function)fail_fn, /* function to call on operation fail. */
682 * For a broadcast release packet, only send once.
683 * This will cause us to remove the name asap. JRA.
686 if (subrec != unicast_subnet) {
687 rrec->repeat_count = 0;
688 rrec->repeat_time = 0;
694 /****************************************************************************
695 Queue a query name packet to the broadcast address of a subnet.
696 ****************************************************************************/
698 struct response_record *queue_query_name( struct subnet_record *subrec,
699 response_function resp_fn,
700 timeout_response_function timeout_fn,
701 query_name_success_function success_fn,
702 query_name_fail_function fail_fn,
703 struct userdata_struct *userdata,
704 struct nmb_name *nmbname)
706 struct packet_struct *p;
707 struct response_record *rrec;
709 if(assert_check_subnet(subrec))
712 if(( p = create_and_init_netbios_packet(nmbname,
713 (subrec != unicast_subnet),
714 (subrec == unicast_subnet),
715 subrec->bcast_ip)) == NULL)
718 if(lp_bind_interfaces_only()) {
721 DEBUG(10,("queue_query_name: bind_interfaces_only is set, looking for suitable source IP\n"));
722 for(i = 0; i < iface_count(); i++) {
723 struct in_addr *ifip = iface_n_ip(i);
726 DEBUG(0,("queue_query_name: interface %d has NULL IP address !\n", i));
730 if (ip_equal(*ifip,loopback_ip)) {
731 DEBUG(5,("queue_query_name: ignoring loopback interface (%d)\n", i));
735 DEBUG(10,("queue_query_name: using source IP %s\n",inet_ntoa(*ifip)));
736 p->fd = find_subnet_fd_for_address( *ifip );
741 if(initiate_name_query_packet( p ) == False) {
747 if((rrec = make_response_record(subrec, /* subnet record. */
748 p, /* packet we sent. */
749 resp_fn, /* function to call on response. */
750 timeout_fn, /* function to call on timeout. */
751 (success_function)success_fn, /* function to call on operation success. */
752 (fail_function)fail_fn, /* function to call on operation fail. */
763 /****************************************************************************
764 Queue a query name packet to a given address from the WINS subnet.
765 ****************************************************************************/
767 struct response_record *queue_query_name_from_wins_server( struct in_addr to_ip,
768 response_function resp_fn,
769 timeout_response_function timeout_fn,
770 query_name_success_function success_fn,
771 query_name_fail_function fail_fn,
772 struct userdata_struct *userdata,
773 struct nmb_name *nmbname)
775 struct packet_struct *p;
776 struct response_record *rrec;
778 if ((p = create_and_init_netbios_packet(nmbname, False, False, to_ip)) == NULL)
781 if(initiate_name_query_packet_from_wins_server( p ) == False)
788 if((rrec = make_response_record(wins_server_subnet, /* subnet record. */
789 p, /* packet we sent. */
790 resp_fn, /* function to call on response. */
791 timeout_fn, /* function to call on timeout. */
792 (success_function)success_fn, /* function to call on operation success. */
793 (fail_function)fail_fn, /* function to call on operation fail. */
804 /****************************************************************************
805 Queue a node status packet to a given name and address.
806 ****************************************************************************/
808 struct response_record *queue_node_status( struct subnet_record *subrec,
809 response_function resp_fn,
810 timeout_response_function timeout_fn,
811 node_status_success_function success_fn,
812 node_status_fail_function fail_fn,
813 struct userdata_struct *userdata,
814 struct nmb_name *nmbname,
815 struct in_addr send_ip)
817 struct packet_struct *p;
818 struct response_record *rrec;
821 if(subrec != unicast_subnet)
823 DEBUG(0,("queue_register_multihomed_name: should only be done on \
824 unicast subnet. subnet is %s\n.", subrec->subnet_name ));
828 if(assert_check_subnet(subrec))
831 if(( p = create_and_init_netbios_packet(nmbname, False, False,
835 if(initiate_node_status_packet(p) == False)
842 if((rrec = make_response_record(subrec, /* subnet record. */
843 p, /* packet we sent. */
844 resp_fn, /* function to call on response. */
845 timeout_fn, /* function to call on timeout. */
846 (success_function)success_fn, /* function to call on operation success. */
847 (fail_function)fail_fn, /* function to call on operation fail. */
858 /****************************************************************************
859 Reply to a netbios name packet. see rfc1002.txt
860 ****************************************************************************/
862 void reply_netbios_packet(struct packet_struct *orig_packet,
863 int rcode, enum netbios_reply_type_code rcv_code, int opcode,
864 int ttl, char *data,int len)
866 struct packet_struct packet;
867 struct nmb_packet *nmb = NULL;
868 struct res_rec answers;
869 struct nmb_packet *orig_nmb = &orig_packet->packet.nmb;
870 BOOL loopback_this_packet = False;
871 char *packet_type = "unknown";
873 /* Check if we are sending to or from ourselves. */
874 if(ismyip(orig_packet->ip) && (orig_packet->port == global_nmb_port))
875 loopback_this_packet = True;
877 nmb = &packet.packet.nmb;
879 /* Do a partial copy of the packet. We clear the locked flag and
880 the resource record pointers. */
881 packet = *orig_packet; /* Full structure copy. */
882 packet.locked = False;
885 nmb->additional = NULL;
891 packet_type = "nmb_status";
892 nmb->header.nm_flags.recursion_desired = False;
893 nmb->header.nm_flags.recursion_available = False;
898 packet_type = "nmb_query";
899 nmb->header.nm_flags.recursion_desired = True;
900 nmb->header.nm_flags.recursion_available = True;
904 case NMB_REG_REFRESH:
906 packet_type = "nmb_reg";
907 nmb->header.nm_flags.recursion_desired = True;
908 nmb->header.nm_flags.recursion_available = True;
913 packet_type = "nmb_rel";
914 nmb->header.nm_flags.recursion_desired = False;
915 nmb->header.nm_flags.recursion_available = False;
920 packet_type = "nmb_wack";
921 nmb->header.nm_flags.recursion_desired = False;
922 nmb->header.nm_flags.recursion_available = False;
927 packet_type = "wins_reg";
928 nmb->header.nm_flags.recursion_desired = True;
929 nmb->header.nm_flags.recursion_available = True;
934 packet_type = "wins_query";
935 nmb->header.nm_flags.recursion_desired = True;
936 nmb->header.nm_flags.recursion_available = True;
942 DEBUG(0,("reply_netbios_packet: Unknown packet type: %s %s to ip %s\n",
943 packet_type, nmb_namestr(&orig_nmb->question.question_name),
944 inet_ntoa(packet.ip)));
950 DEBUG(4,("reply_netbios_packet: sending a reply of packet type: %s %s to ip %s \
952 packet_type, nmb_namestr(&orig_nmb->question.question_name),
953 inet_ntoa(packet.ip), orig_nmb->header.name_trn_id));
955 nmb->header.name_trn_id = orig_nmb->header.name_trn_id;
956 nmb->header.opcode = opcode;
957 nmb->header.response = True;
958 nmb->header.nm_flags.bcast = False;
959 nmb->header.nm_flags.trunc = False;
960 nmb->header.nm_flags.authoritative = True;
962 nmb->header.rcode = rcode;
963 nmb->header.qdcount = 0;
964 nmb->header.ancount = 1;
965 nmb->header.nscount = 0;
966 nmb->header.arcount = 0;
968 memset((char*)&nmb->question,'\0',sizeof(nmb->question));
970 nmb->answers = &answers;
971 memset((char*)nmb->answers,'\0',sizeof(*nmb->answers));
973 nmb->answers->rr_name = orig_nmb->question.question_name;
974 nmb->answers->rr_type = orig_nmb->question.question_type;
975 nmb->answers->rr_class = orig_nmb->question.question_class;
976 nmb->answers->ttl = ttl;
980 nmb->answers->rdlength = len;
981 memcpy(nmb->answers->rdata, data, len);
984 packet.packet_type = NMB_PACKET;
985 /* Ensure we send out on the same fd that the original
986 packet came in on to give the correct source IP address. */
987 packet.fd = orig_packet->fd;
988 packet.timestamp = time(NULL);
990 debug_nmb_packet(&packet);
992 if(loopback_this_packet)
994 struct packet_struct *lo_packet;
995 DEBUG(5,("reply_netbios_packet: sending packet to ourselves.\n"));
996 if((lo_packet = copy_packet(&packet)) == NULL)
998 queue_packet(lo_packet);
1000 else if (!send_packet(&packet))
1002 DEBUG(0,("reply_netbios_packet: send_packet to IP %s port %d failed\n",
1003 inet_ntoa(packet.ip),packet.port));
1007 /*******************************************************************
1008 Queue a packet into a packet queue
1009 ******************************************************************/
1010 static void queue_packet(struct packet_struct *packet)
1012 struct packet_struct *p;
1016 packet->prev = NULL;
1017 packet->next = NULL;
1018 packet_queue = packet;
1022 /* find the bottom */
1023 for (p=packet_queue;p->next;p=p->next)
1027 packet->next = NULL;
1031 /****************************************************************************
1032 Try and find a matching subnet record for a datagram port 138 packet.
1033 ****************************************************************************/
1035 static struct subnet_record *find_subnet_for_dgram_browse_packet(struct packet_struct *p)
1037 struct subnet_record *subrec;
1039 /* Go through all the broadcast subnets and see if the mask matches. */
1040 for (subrec = FIRST_SUBNET; subrec ; subrec = NEXT_SUBNET_EXCLUDING_UNICAST(subrec))
1042 if(same_net(p->ip, subrec->bcast_ip, subrec->mask_ip))
1046 /* If the subnet record is the remote announce broadcast subnet,
1047 hack it here to be the first subnet. This is really gross and
1048 is needed due to people turning on port 137/138 broadcast
1049 forwarding on their routers. May fire and brimstone rain
1053 return FIRST_SUBNET;
1056 /****************************************************************************
1057 Dispatch a browse frame from port 138 to the correct processing function.
1058 ****************************************************************************/
1059 static void process_browse_packet(struct packet_struct *p, char *buf,int len)
1061 struct dgram_packet *dgram = &p->packet.dgram;
1062 int command = CVAL(buf,0);
1063 struct subnet_record *subrec = find_subnet_for_dgram_browse_packet(p);
1064 extern pstring global_scope;
1066 /* Drop the packet if it's a different NetBIOS scope, or
1067 the source is from one of our names. */
1069 if (!strequal(dgram->dest_name.scope, global_scope))
1071 DEBUG(7,("process_browse_packet: Discarding datagram from IP %s. Scope (%s) \
1072 mismatch with our scope (%s).\n", inet_ntoa(p->ip), dgram->dest_name.scope, global_scope));
1076 if (is_myname(dgram->source_name.name))
1078 DEBUG(0,("process_browse_packet: Discarding datagram from IP %s. Source name \
1079 %s is one of our names !\n", inet_ntoa(p->ip), nmb_namestr(&dgram->source_name)));
1085 case ANN_HostAnnouncement:
1087 debug_browse_data(buf, len);
1088 process_host_announce(subrec, p, buf+1);
1091 case ANN_DomainAnnouncement:
1093 debug_browse_data(buf, len);
1094 process_workgroup_announce(subrec, p, buf+1);
1097 case ANN_LocalMasterAnnouncement:
1099 debug_browse_data(buf, len);
1100 process_local_master_announce(subrec, p, buf+1);
1103 case ANN_AnnouncementRequest:
1105 debug_browse_data(buf, len);
1106 process_announce_request(subrec, p, buf+1);
1111 debug_browse_data(buf, len);
1112 process_election(subrec, p, buf+1);
1115 case ANN_GetBackupListReq:
1117 debug_browse_data(buf, len);
1118 process_get_backup_list_request(subrec, p, buf+1);
1121 case ANN_GetBackupListResp:
1123 debug_browse_data(buf, len);
1124 /* We never send ANN_GetBackupListReq so we
1125 should never get these. */
1126 DEBUG(0,("process_browse_packet: Discarding GetBackupListResponse \
1127 packet from %s IP %s\n", nmb_namestr(&dgram->source_name), inet_ntoa(p->ip)));
1130 case ANN_ResetBrowserState:
1132 debug_browse_data(buf, len);
1133 process_reset_browser(subrec, p, buf+1);
1136 case ANN_MasterAnnouncement:
1138 /* Master browser datagrams must be processed
1139 on the unicast subnet. */
1140 subrec = unicast_subnet;
1142 debug_browse_data(buf, len);
1143 process_master_browser_announce(subrec, p, buf+1);
1146 case ANN_BecomeBackup:
1149 * We don't currently implement this. Log it just in case.
1151 debug_browse_data(buf, len);
1152 DEBUG(10,("process_browse_packet: On subnet %s ignoring browse packet \
1153 command ANN_BecomeBackup from %s IP %s to %s\n",
1154 subrec->subnet_name, nmb_namestr(&dgram->source_name),
1155 inet_ntoa(p->ip), nmb_namestr(&dgram->dest_name)));
1160 debug_browse_data(buf, len);
1161 DEBUG(0,("process_browse_packet: On subnet %s ignoring browse packet \
1162 command code %d from %s IP %s to %s\n",
1163 subrec->subnet_name, command, nmb_namestr(&dgram->source_name),
1164 inet_ntoa(p->ip), nmb_namestr(&dgram->dest_name)));
1169 /****************************************************************************
1170 Dispatch a LanMan browse frame from port 138 to the correct processing function.
1171 ****************************************************************************/
1172 static void process_lanman_packet(struct packet_struct *p, char *buf,int len)
1174 struct dgram_packet *dgram = &p->packet.dgram;
1175 int command = SVAL(buf,0);
1176 struct subnet_record *subrec = find_subnet_for_dgram_browse_packet(p);
1177 extern pstring global_scope;
1179 /* Drop the packet if it's a different NetBIOS scope, or
1180 the source is from one of our names. */
1182 if (!strequal(dgram->dest_name.scope, global_scope))
1184 DEBUG(7,("process_lanman_packet: Discarding datagram from IP %s. Scope (%s) \
1185 mismatch with our scope (%s).\n", inet_ntoa(p->ip), dgram->dest_name.scope, global_scope));
1189 if (is_myname(dgram->source_name.name))
1191 DEBUG(0,("process_lanman_packet: Discarding datagram from IP %s. Source name \
1192 %s is one of our names !\n", inet_ntoa(p->ip), nmb_namestr(&dgram->source_name)));
1198 case ANN_HostAnnouncement:
1200 debug_browse_data(buf, len);
1201 process_lm_host_announce(subrec, p, buf+1);
1204 case ANN_AnnouncementRequest:
1206 process_lm_announce_request(subrec, p, buf+1);
1211 DEBUG(0,("process_lanman_packet: On subnet %s ignoring browse packet \
1212 command code %d from %s IP %s to %s\n",
1213 subrec->subnet_name, command, nmb_namestr(&dgram->source_name),
1214 inet_ntoa(p->ip), nmb_namestr(&dgram->dest_name)));
1219 /****************************************************************************
1220 Determine if a packet is for us on port 138. Note that to have any chance of
1221 being efficient we need to drop as many packets as possible at this
1222 stage as subsequent processing is expensive.
1223 ****************************************************************************/
1225 static BOOL listening(struct packet_struct *p,struct nmb_name *nbname)
1227 struct subnet_record *subrec = NULL;
1229 for (subrec = FIRST_SUBNET; subrec ; subrec = NEXT_SUBNET_EXCLUDING_UNICAST(subrec))
1231 if(same_net(p->ip, subrec->bcast_ip, subrec->mask_ip))
1236 subrec = unicast_subnet;
1238 return (find_name_on_subnet(subrec, nbname, FIND_SELF_NAME) != NULL);
1241 /****************************************************************************
1242 Process udp 138 datagrams
1243 ****************************************************************************/
1244 static void process_dgram(struct packet_struct *p)
1249 struct dgram_packet *dgram = &p->packet.dgram;
1251 /* If we aren't listening to the destination name then ignore the packet */
1252 if (!listening(p,&dgram->dest_name))
1254 unexpected_packet(p);
1255 DEBUG(5,("process_dgram: ignoring dgram packet sent to name %s from %s\n",
1256 nmb_namestr(&dgram->dest_name), inet_ntoa(p->ip)));
1260 if (dgram->header.msg_type != 0x10 &&
1261 dgram->header.msg_type != 0x11 &&
1262 dgram->header.msg_type != 0x12)
1264 unexpected_packet(p);
1265 /* Don't process error packets etc yet */
1266 DEBUG(5,("process_dgram: ignoring dgram packet sent to name %s from IP %s as it is \
1267 an error packet of type %x\n",
1268 nmb_namestr(&dgram->dest_name), inet_ntoa(p->ip), dgram->header.msg_type));
1272 buf = &dgram->data[0];
1273 buf -= 4; /* XXXX for the pseudo tcp length -
1274 someday I need to get rid of this */
1276 if (CVAL(buf,smb_com) != SMBtrans)
1279 len = SVAL(buf,smb_vwv11);
1280 buf2 = smb_base(buf) + SVAL(buf,smb_vwv12);
1285 if (buf2 + len > buf + sizeof(dgram->data)) {
1286 DEBUG(2,("process_dgram: datagram from %s to %s IP %s for %s len=%d too long.\n",
1287 nmb_namestr(&dgram->source_name),nmb_namestr(&dgram->dest_name),
1288 inet_ntoa(p->ip), smb_buf(buf),len));
1289 len = (buf + sizeof(dgram->data)) - buf;
1292 DEBUG(4,("process_dgram: datagram from %s to %s IP %s for %s of type %d len=%d\n",
1293 nmb_namestr(&dgram->source_name),nmb_namestr(&dgram->dest_name),
1294 inet_ntoa(p->ip), smb_buf(buf),CVAL(buf2,0),len));
1297 /* Datagram packet received for the browser mailslot */
1298 if (strequal(smb_buf(buf),BROWSE_MAILSLOT))
1300 process_browse_packet(p,buf2,len);
1304 /* Datagram packet received for the LAN Manager mailslot */
1305 if (strequal(smb_buf(buf),LANMAN_MAILSLOT)) {
1306 process_lanman_packet(p,buf2,len);
1310 /* Datagram packet received for the domain logon mailslot */
1311 if (strequal(smb_buf(buf),NET_LOGON_MAILSLOT))
1313 process_logon_packet(p,buf2,len,NET_LOGON_MAILSLOT);
1317 /* Datagram packet received for the NT domain logon mailslot */
1318 if (strequal(smb_buf(buf),NT_LOGON_MAILSLOT))
1320 process_logon_packet(p,buf2,len,NT_LOGON_MAILSLOT);
1324 unexpected_packet(p);
1327 /****************************************************************************
1328 Validate a response nmb packet.
1329 ****************************************************************************/
1331 static BOOL validate_nmb_response_packet( struct nmb_packet *nmb )
1333 BOOL ignore = False;
1335 switch (nmb->header.opcode)
1337 case NMB_NAME_REG_OPCODE:
1338 case NMB_NAME_REFRESH_OPCODE_8: /* ambiguity in rfc1002 about which is correct. */
1339 case NMB_NAME_REFRESH_OPCODE_9: /* WinNT uses 8 by default. */
1340 if (nmb->header.ancount == 0)
1342 DEBUG(0,("validate_nmb_response_packet: Bad REG/REFRESH Packet. "));
1347 case NMB_NAME_QUERY_OPCODE:
1348 if ((nmb->header.ancount != 0) && (nmb->header.ancount != 1))
1350 DEBUG(0,("validate_nmb_response_packet: Bad QUERY Packet. "));
1354 case NMB_NAME_RELEASE_OPCODE:
1355 if (nmb->header.ancount == 0)
1357 DEBUG(0,("validate_nmb_response_packet: Bad RELEASE Packet. "));
1361 case NMB_WACK_OPCODE:
1362 /* Check WACK response here. */
1363 if (nmb->header.ancount != 1)
1365 DEBUG(0,("validate_nmb_response_packet: Bad WACK Packet. "));
1370 DEBUG(0,("validate_nmb_response_packet: Ignoring packet with unknown opcode %d.\n",
1371 nmb->header.opcode));
1376 DEBUG(0,("Ignoring response packet with opcode %d.\n", nmb->header.opcode));
1381 /****************************************************************************
1382 Validate a request nmb packet.
1383 ****************************************************************************/
1385 static BOOL validate_nmb_packet( struct nmb_packet *nmb )
1387 BOOL ignore = False;
1389 switch (nmb->header.opcode)
1391 case NMB_NAME_REG_OPCODE:
1392 case NMB_NAME_REFRESH_OPCODE_8: /* ambiguity in rfc1002 about which is correct. */
1393 case NMB_NAME_REFRESH_OPCODE_9: /* WinNT uses 8 by default. */
1394 case NMB_NAME_MULTIHOMED_REG_OPCODE:
1395 if (nmb->header.qdcount==0 || nmb->header.arcount==0)
1397 DEBUG(0,("validate_nmb_packet: Bad REG/REFRESH Packet. "));
1402 case NMB_NAME_QUERY_OPCODE:
1403 if ((nmb->header.qdcount == 0) ||
1404 ((nmb->question.question_type != QUESTION_TYPE_NB_QUERY) &&
1405 (nmb->question.question_type != QUESTION_TYPE_NB_STATUS)))
1407 DEBUG(0,("validate_nmb_packet: Bad QUERY Packet. "));
1412 case NMB_NAME_RELEASE_OPCODE:
1413 if (nmb->header.qdcount==0 || nmb->header.arcount==0)
1415 DEBUG(0,("validate_nmb_packet: Bad RELEASE Packet. "));
1420 DEBUG(0,("validate_nmb_packet: Ignoring packet with unknown opcode %d.\n",
1421 nmb->header.opcode));
1426 DEBUG(0,("validate_nmb_packet: Ignoring request packet with opcode %d.\n", nmb->header.opcode));
1431 /****************************************************************************
1432 Find a subnet (and potentially a response record) for a packet.
1433 ****************************************************************************/
1435 static struct subnet_record *find_subnet_for_nmb_packet( struct packet_struct *p,
1436 struct response_record **pprrec)
1438 struct nmb_packet *nmb = &p->packet.nmb;
1439 struct response_record *rrec = NULL;
1440 struct subnet_record *subrec = NULL;
1445 if(nmb->header.response)
1447 /* It's a response packet. Find a record for it or it's an error. */
1449 rrec = find_response_record( &subrec, nmb->header.name_trn_id);
1452 DEBUG(3,("find_subnet_for_nmb_packet: response record not found for response id %hu\n",
1453 nmb->header.name_trn_id));
1454 unexpected_packet(p);
1460 DEBUG(0,("find_subnet_for_nmb_packet: subnet record not found for response id %hu\n",
1461 nmb->header.name_trn_id));
1470 /* Try and see what subnet this packet belongs to. */
1473 if(packet_is_for_wins_server(p))
1474 return wins_server_subnet;
1476 /* If it wasn't a broadcast packet then send to the UNICAST subnet. */
1477 if(nmb->header.nm_flags.bcast == False)
1478 return unicast_subnet;
1480 /* Go through all the broadcast subnets and see if the mask matches. */
1481 for (subrec = FIRST_SUBNET; subrec ; subrec = NEXT_SUBNET_EXCLUDING_UNICAST(subrec))
1483 if(same_net(p->ip, subrec->bcast_ip, subrec->mask_ip))
1487 /* If none match it must have been a directed broadcast - assign
1488 the remote_broadcast_subnet. */
1489 return remote_broadcast_subnet;
1492 /****************************************************************************
1493 Process a nmb request packet - validate the packet and route it.
1494 ****************************************************************************/
1496 static void process_nmb_request(struct packet_struct *p)
1498 struct nmb_packet *nmb = &p->packet.nmb;
1499 struct subnet_record *subrec = NULL;
1501 debug_nmb_packet(p);
1503 /* Ensure we have a good packet. */
1504 if(validate_nmb_packet(nmb))
1507 /* Allocate a subnet to this packet - if we cannot - fail. */
1508 if((subrec = find_subnet_for_nmb_packet(p, NULL))==NULL)
1511 switch (nmb->header.opcode)
1513 case NMB_NAME_REG_OPCODE:
1514 if(subrec == wins_server_subnet)
1515 wins_process_name_registration_request(subrec, p);
1517 process_name_registration_request(subrec, p);
1520 case NMB_NAME_REFRESH_OPCODE_8: /* ambiguity in rfc1002 about which is correct. */
1521 case NMB_NAME_REFRESH_OPCODE_9:
1522 if(subrec == wins_server_subnet)
1523 wins_process_name_refresh_request(subrec, p);
1525 process_name_refresh_request(subrec, p);
1528 case NMB_NAME_MULTIHOMED_REG_OPCODE:
1529 if(subrec == wins_server_subnet)
1530 wins_process_multihomed_name_registration_request(subrec, p);
1533 DEBUG(0,("process_nmb_request: Multihomed registration request must be \
1534 directed at a WINS server.\n"));
1538 case NMB_NAME_QUERY_OPCODE:
1539 switch (nmb->question.question_type)
1541 case QUESTION_TYPE_NB_QUERY:
1543 if(subrec == wins_server_subnet)
1544 wins_process_name_query_request(subrec, p);
1546 process_name_query_request(subrec, p);
1549 case QUESTION_TYPE_NB_STATUS:
1551 if(subrec == wins_server_subnet)
1553 DEBUG(0,("process_nmb_request: NB_STATUS request directed at WINS server is \
1558 process_node_status_request(subrec, p);
1564 case NMB_NAME_RELEASE_OPCODE:
1565 if(subrec == wins_server_subnet)
1566 wins_process_name_release_request(subrec, p);
1568 process_name_release_request(subrec, p);
1573 /****************************************************************************
1574 Process a nmb response packet - validate the packet and route it.
1575 to either the WINS server or a normal response.
1576 ****************************************************************************/
1578 static void process_nmb_response(struct packet_struct *p)
1580 struct nmb_packet *nmb = &p->packet.nmb;
1581 struct subnet_record *subrec = NULL;
1582 struct response_record *rrec = NULL;
1584 debug_nmb_packet(p);
1586 if(validate_nmb_response_packet(nmb))
1589 if((subrec = find_subnet_for_nmb_packet(p, &rrec))==NULL)
1594 DEBUG(0,("process_nmb_response: response packet received but no response record \
1595 found for id = %hu. Ignoring packet.\n", nmb->header.name_trn_id));
1599 /* Increment the number of responses received for this record. */
1601 /* Ensure we don't re-send the request. */
1602 rrec->repeat_count = 0;
1604 /* Call the response received function for this packet. */
1605 (*rrec->resp_fn)(subrec, rrec, p);
1609 /*******************************************************************
1610 Run elements off the packet queue till its empty
1611 ******************************************************************/
1613 void run_packet_queue(void)
1615 struct packet_struct *p;
1617 while ((p = packet_queue))
1619 packet_queue = p->next;
1621 packet_queue->prev = NULL;
1622 p->next = p->prev = NULL;
1624 switch (p->packet_type)
1627 if(p->packet.nmb.header.response)
1628 process_nmb_response(p);
1630 process_nmb_request(p);
1641 /*******************************************************************
1642 Retransmit or timeout elements from all the outgoing subnet response
1643 record queues. NOTE that this code must also check the WINS server
1644 subnet for response records to timeout as the WINS server code
1645 can send requests to check if a client still owns a name.
1646 (Patch from Andrey Alekseyev <fetch@muffin.arcadia.spb.ru>).
1647 ******************************************************************/
1649 void retransmit_or_expire_response_records(time_t t)
1651 struct subnet_record *subrec;
1653 for (subrec = FIRST_SUBNET; subrec;
1654 subrec = get_next_subnet_maybe_unicast_or_wins_server(subrec))
1656 struct response_record *rrec, *nextrrec;
1658 for (rrec = subrec->responselist; rrec; rrec = nextrrec)
1660 nextrrec = rrec->next;
1662 if (rrec->repeat_time <= t)
1664 if (rrec->repeat_count > 0)
1666 /* Resend while we have a non-zero repeat_count. */
1667 if(!send_packet(rrec->packet))
1669 DEBUG(0,("retransmit_or_expire_response_records: Failed to resend packet id %hu \
1670 to IP %s on subnet %s\n", rrec->response_id, inet_ntoa(rrec->packet->ip),
1671 subrec->subnet_name));
1673 rrec->repeat_time += rrec->repeat_interval;
1674 rrec->repeat_count--;
1678 DEBUG(4,("retransmit_or_expire_response_records: timeout for packet id %hu to IP %s \
1679 on subnet %s\n", rrec->response_id, inet_ntoa(rrec->packet->ip),
1680 subrec->subnet_name));
1683 * Check the flag in this record to prevent recursion if we end
1684 * up in this function again via the timeout function call.
1687 if(!rrec->in_expiration_processing)
1691 * Set the recursion protection flag in this record.
1694 rrec->in_expiration_processing = True;
1696 /* Call the timeout function. This will deal with removing the
1697 timed out packet. */
1698 if(rrec->timeout_fn)
1699 (*rrec->timeout_fn)(subrec, rrec);
1702 /* We must remove the record ourself if there is
1703 no timeout function. */
1704 remove_response_record(subrec, rrec);
1706 } /* !rrec->in_expitation_processing */
1707 } /* rrec->repeat_count > 0 */
1708 } /* rrec->repeat_time <= t */
1709 } /* end for rrec */
1710 } /* end for subnet */
1713 /****************************************************************************
1714 Create an fd_set containing all the sockets in the subnet structures,
1715 plus the broadcast sockets.
1716 ***************************************************************************/
1718 static BOOL create_listen_fdset(fd_set **ppset, int **psock_array, int *listen_number)
1720 int *sock_array = NULL;
1721 struct subnet_record *subrec = NULL;
1724 fd_set *pset = (fd_set *)malloc(sizeof(fd_set));
1728 DEBUG(0,("create_listen_fdset: malloc fail !\n"));
1732 /* Check that we can add all the fd's we need. */
1733 for (subrec = FIRST_SUBNET; subrec; subrec = NEXT_SUBNET_EXCLUDING_UNICAST(subrec))
1736 if((count*2) + 2 > FD_SETSIZE)
1738 DEBUG(0,("create_listen_fdset: Too many file descriptors needed (%d). We can \
1739 only use %d.\n", (count*2) + 2, FD_SETSIZE));
1743 if((sock_array = (int *)malloc(((count*2) + 2)*sizeof(int))) == NULL)
1745 DEBUG(0,("create_listen_fdset: malloc fail for socket array.\n"));
1751 /* Add in the broadcast socket on 137. */
1752 FD_SET(ClientNMB,pset);
1753 sock_array[num++] = ClientNMB;
1755 /* Add in the 137 sockets on all the interfaces. */
1756 for (subrec = FIRST_SUBNET; subrec; subrec = NEXT_SUBNET_EXCLUDING_UNICAST(subrec))
1758 FD_SET(subrec->nmb_sock,pset);
1759 sock_array[num++] = subrec->nmb_sock;
1762 /* Add in the broadcast socket on 138. */
1763 FD_SET(ClientDGRAM,pset);
1764 sock_array[num++] = ClientDGRAM;
1766 /* Add in the 138 sockets on all the interfaces. */
1767 for (subrec = FIRST_SUBNET; subrec; subrec = NEXT_SUBNET_EXCLUDING_UNICAST(subrec))
1769 FD_SET(subrec->dgram_sock,pset);
1770 sock_array[num++] = subrec->dgram_sock;
1773 *listen_number = (count*2) + 2;
1776 SAFE_FREE(*psock_array);
1779 *psock_array = sock_array;
1784 /****************************************************************************
1785 Listens for NMB or DGRAM packets, and queues them.
1786 return True if the socket is dead
1787 ***************************************************************************/
1789 BOOL listen_for_packets(BOOL run_election)
1791 static fd_set *listen_set = NULL;
1792 static int listen_number = 0;
1793 static int *sock_array = NULL;
1798 struct timeval timeout;
1803 if(listen_set == NULL || rescan_listen_set)
1805 if(create_listen_fdset(&listen_set, &sock_array, &listen_number))
1807 DEBUG(0,("listen_for_packets: Fatal error. unable to create listen set. Exiting.\n"));
1810 rescan_listen_set = False;
1813 memcpy((char *)&fds, (char *)listen_set, sizeof(fd_set));
1816 dns_fd = asyncdns_fd();
1818 FD_SET(dns_fd, &fds);
1824 * During elections and when expecting a netbios response packet we
1825 * need to send election packets at tighter intervals.
1826 * Ideally it needs to be the interval (in ms) between time now and
1827 * the time we are expecting the next netbios packet.
1830 timeout.tv_sec = (run_election||num_response_packets) ? 1 : NMBD_SELECT_LOOP;
1831 timeout.tv_usec = 0;
1833 /* Prepare for the select - allow certain signals. */
1835 BlockSignals(False, SIGTERM);
1837 selrtn = sys_select(FD_SETSIZE,&fds,NULL,NULL,&timeout);
1839 /* We can only take signals when we are in the select - block them again here. */
1841 BlockSignals(True, SIGTERM);
1848 if (dns_fd != -1 && FD_ISSET(dns_fd,&fds)) {
1853 for(i = 0; i < listen_number; i++) {
1854 if (i < (listen_number/2)) {
1855 /* Processing a 137 socket. */
1856 if (FD_ISSET(sock_array[i],&fds)) {
1857 struct packet_struct *packet = read_packet(sock_array[i], NMB_PACKET);
1860 * If we got a packet on the broadcast socket and interfaces
1861 * only is set then check it came from one of our local nets.
1863 if(lp_bind_interfaces_only() && (sock_array[i] == ClientNMB) &&
1864 (!is_local_net(packet->ip))) {
1865 DEBUG(7,("discarding nmb packet sent to broadcast socket from %s:%d\n",
1866 inet_ntoa(packet->ip),packet->port));
1867 free_packet(packet);
1868 } else if ((ip_equal(loopback_ip, packet->ip) ||
1869 ismyip(packet->ip)) && packet->port == global_nmb_port &&
1870 packet->packet.nmb.header.nm_flags.bcast) {
1871 DEBUG(7,("discarding own bcast packet from %s:%d\n",
1872 inet_ntoa(packet->ip),packet->port));
1873 free_packet(packet);
1875 /* Save the file descriptor this packet came in on. */
1876 packet->fd = sock_array[i];
1877 queue_packet(packet);
1882 /* Processing a 138 socket. */
1883 if (FD_ISSET(sock_array[i],&fds)) {
1884 struct packet_struct *packet = read_packet(sock_array[i], DGRAM_PACKET);
1887 * If we got a packet on the broadcast socket and interfaces
1888 * only is set then check it came from one of our local nets.
1890 if(lp_bind_interfaces_only() && (sock_array[i] == ClientDGRAM) &&
1891 (!is_local_net(packet->ip))) {
1892 DEBUG(7,("discarding dgram packet sent to broadcast socket from %s:%d\n",
1893 inet_ntoa(packet->ip),packet->port));
1894 free_packet(packet);
1895 } else if ((ip_equal(loopback_ip, packet->ip) ||
1896 ismyip(packet->ip)) && packet->port == DGRAM_PORT) {
1897 DEBUG(7,("discarding own dgram packet from %s:%d\n",
1898 inet_ntoa(packet->ip),packet->port));
1899 free_packet(packet);
1901 /* Save the file descriptor this packet came in on. */
1902 packet->fd = sock_array[i];
1903 queue_packet(packet);
1907 } /* end processing 138 socket. */
1912 /****************************************************************************
1913 Construct and send a netbios DGRAM.
1914 **************************************************************************/
1915 BOOL send_mailslot(BOOL unique, char *mailslot,char *buf,int len,
1916 char *srcname, int src_type,
1917 char *dstname, int dest_type,
1918 struct in_addr dest_ip,struct in_addr src_ip,
1921 BOOL loopback_this_packet = False;
1922 struct packet_struct p;
1923 struct dgram_packet *dgram = &p.packet.dgram;
1927 memset((char *)&p,'\0',sizeof(p));
1929 if(ismyip(dest_ip) && (dest_port == DGRAM_PORT)) /* Only if to DGRAM_PORT */
1930 loopback_this_packet = True;
1932 /* generate_name_trn_id(); */ /* Not used, so gone, RJS */
1934 /* DIRECT GROUP or UNIQUE datagram. */
1935 dgram->header.msg_type = unique ? 0x10 : 0x11;
1936 dgram->header.flags.node_type = M_NODE;
1937 dgram->header.flags.first = True;
1938 dgram->header.flags.more = False;
1939 dgram->header.dgm_id = generate_name_trn_id();
1940 dgram->header.source_ip = src_ip;
1941 dgram->header.source_port = DGRAM_PORT;
1942 dgram->header.dgm_length = 0; /* Let build_dgram() handle this. */
1943 dgram->header.packet_offset = 0;
1945 make_nmb_name(&dgram->source_name,srcname,src_type);
1946 make_nmb_name(&dgram->dest_name,dstname,dest_type);
1948 ptr = &dgram->data[0];
1950 /* Setup the smb part. */
1951 ptr -= 4; /* XXX Ugliness because of handling of tcp SMB length. */
1953 set_message(ptr,17,17 + len,True);
1956 SCVAL(ptr,smb_com,SMBtrans);
1957 SSVAL(ptr,smb_vwv1,len);
1958 SSVAL(ptr,smb_vwv11,len);
1959 SSVAL(ptr,smb_vwv12,70 + strlen(mailslot));
1960 SSVAL(ptr,smb_vwv13,3);
1961 SSVAL(ptr,smb_vwv14,1);
1962 SSVAL(ptr,smb_vwv15,1);
1963 SSVAL(ptr,smb_vwv16,2);
1965 pstrcpy(p2,mailslot);
1966 p2 = skip_string(p2,1);
1971 dgram->datasize = PTR_DIFF(p2,ptr+4); /* +4 for tcp length. */
1975 p.fd = find_subnet_mailslot_fd_for_address( src_ip );
1976 p.timestamp = time(NULL);
1977 p.packet_type = DGRAM_PACKET;
1979 DEBUG(4,("send_mailslot: Sending to mailslot %s from %s IP %s ", mailslot,
1980 nmb_namestr(&dgram->source_name), inet_ntoa(src_ip)));
1981 DEBUG(4,("to %s IP %s\n", nmb_namestr(&dgram->dest_name), inet_ntoa(dest_ip)));
1983 debug_browse_data(buf, len);
1985 if(loopback_this_packet)
1987 struct packet_struct *lo_packet = NULL;
1988 DEBUG(5,("send_mailslot: sending packet to ourselves.\n"));
1989 if((lo_packet = copy_packet(&p)) == NULL)
1991 queue_packet(lo_packet);
1995 return(send_packet(&p));