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)
244 DEBUG(0,("initiate_name_register_packet: malloc fail for additional record.\n"));
248 memset((char *)nmb->additional,'\0',sizeof(struct res_rec));
250 nmb->additional->rr_name = nmb->question.question_name;
251 nmb->additional->rr_type = RR_TYPE_NB;
252 nmb->additional->rr_class = RR_CLASS_IN;
254 /* See RFC 1002, sections 5.1.1.1, 5.1.1.2 and 5.1.1.3 */
255 if (nmb->header.nm_flags.bcast)
256 nmb->additional->ttl = PERMANENT_TTL;
258 nmb->additional->ttl = lp_max_ttl();
260 nmb->additional->rdlength = 6;
262 set_nb_flags(nmb->additional->rdata,nb_flags);
264 /* Set the address for the name we are registering. */
265 putip(&nmb->additional->rdata[2], register_ip);
268 /* I removed this forced source IP as it breaks wins failover. The
269 problem is that our 2nd interface IP may not be routable to the
270 wins server, in which case all these nice packets we are senidng
271 out will never get a response and we end up marking a perfectly good wins server dead.
273 In general I can't see any reason why we should force the source
274 ip on a packet anyway. We should just let the kernels routin
275 table take care of it, as that is the only place which really
276 knows what is routable and what isn't. (tridge)
278 packet->fd = find_subnet_fd_for_address( *register_ip );
284 /***************************************************************************
285 Sends out a name query.
286 **************************************************************************/
288 static BOOL initiate_name_query_packet( struct packet_struct *packet)
290 struct nmb_packet *nmb = NULL;
292 nmb = &packet->packet.nmb;
294 nmb->header.opcode = NMB_NAME_QUERY_OPCODE;
295 nmb->header.arcount = 0;
297 nmb->header.nm_flags.recursion_desired = True;
299 DEBUG(4,("initiate_name_query_packet: sending query for name %s (bcast=%s) to IP %s\n",
300 nmb_namestr(&nmb->question.question_name),
301 BOOLSTR(nmb->header.nm_flags.bcast), inet_ntoa(packet->ip)));
303 return send_netbios_packet( packet );
306 /***************************************************************************
307 Sends out a name query - from a WINS server.
308 **************************************************************************/
310 static BOOL initiate_name_query_packet_from_wins_server( struct packet_struct *packet)
312 struct nmb_packet *nmb = NULL;
314 nmb = &packet->packet.nmb;
316 nmb->header.opcode = NMB_NAME_QUERY_OPCODE;
317 nmb->header.arcount = 0;
319 nmb->header.nm_flags.recursion_desired = False;
321 DEBUG(4,("initiate_name_query_packet_from_wins_server: sending query for name %s (bcast=%s) to IP %s\n",
322 nmb_namestr(&nmb->question.question_name),
323 BOOLSTR(nmb->header.nm_flags.bcast), inet_ntoa(packet->ip)));
325 return send_netbios_packet( packet );
328 /***************************************************************************
329 Sends out a name register.
330 **************************************************************************/
332 static BOOL initiate_name_register_packet( struct packet_struct *packet,
333 uint16 nb_flags, struct in_addr *register_ip)
335 struct nmb_packet *nmb = &packet->packet.nmb;
337 nmb->header.opcode = NMB_NAME_REG_OPCODE;
338 nmb->header.arcount = 1;
340 nmb->header.nm_flags.recursion_desired = True;
342 if(create_and_init_additional_record(packet, nb_flags, register_ip) == False)
345 DEBUG(4,("initiate_name_register_packet: sending registration for name %s (bcast=%s) to IP %s\n",
346 nmb_namestr(&nmb->additional->rr_name),
347 BOOLSTR(nmb->header.nm_flags.bcast), inet_ntoa(packet->ip)));
349 return send_netbios_packet( packet );
352 /***************************************************************************
353 Sends out a multihomed name register.
354 **************************************************************************/
356 static BOOL initiate_multihomed_name_register_packet( struct packet_struct *packet,
357 uint16 nb_flags, struct in_addr *register_ip)
359 struct nmb_packet *nmb = &packet->packet.nmb;
360 fstring second_ip_buf;
362 fstrcpy(second_ip_buf, inet_ntoa(packet->ip));
364 nmb->header.opcode = NMB_NAME_MULTIHOMED_REG_OPCODE;
365 nmb->header.arcount = 1;
367 nmb->header.nm_flags.recursion_desired = True;
369 if(create_and_init_additional_record(packet, nb_flags, register_ip) == False)
372 DEBUG(4,("initiate_multihomed_name_register_packet: sending registration \
373 for name %s IP %s (bcast=%s) to IP %s\n",
374 nmb_namestr(&nmb->additional->rr_name), inet_ntoa(*register_ip),
375 BOOLSTR(nmb->header.nm_flags.bcast), second_ip_buf ));
377 return send_netbios_packet( packet );
380 /***************************************************************************
381 Sends out a name refresh.
382 **************************************************************************/
384 static BOOL initiate_name_refresh_packet( struct packet_struct *packet,
385 uint16 nb_flags, struct in_addr *refresh_ip)
387 struct nmb_packet *nmb = &packet->packet.nmb;
389 nmb->header.opcode = NMB_NAME_REFRESH_OPCODE_8;
390 nmb->header.arcount = 1;
392 nmb->header.nm_flags.recursion_desired = False;
394 if(create_and_init_additional_record(packet, nb_flags, refresh_ip) == False)
397 DEBUG(4,("initiate_name_refresh_packet: sending refresh for name %s (bcast=%s) to IP %s\n",
398 nmb_namestr(&nmb->additional->rr_name),
399 BOOLSTR(nmb->header.nm_flags.bcast), inet_ntoa(packet->ip)));
401 return send_netbios_packet( packet );
404 /***************************************************************************
405 Sends out a name release.
406 **************************************************************************/
408 static BOOL initiate_name_release_packet( struct packet_struct *packet,
409 uint16 nb_flags, struct in_addr *release_ip)
411 struct nmb_packet *nmb = &packet->packet.nmb;
413 nmb->header.opcode = NMB_NAME_RELEASE_OPCODE;
414 nmb->header.arcount = 1;
416 nmb->header.nm_flags.recursion_desired = False;
418 if(create_and_init_additional_record(packet, nb_flags, release_ip) == False)
421 DEBUG(4,("initiate_name_release_packet: sending release for name %s (bcast=%s) to IP %s\n",
422 nmb_namestr(&nmb->additional->rr_name),
423 BOOLSTR(nmb->header.nm_flags.bcast), inet_ntoa(packet->ip)));
425 return send_netbios_packet( packet );
428 /***************************************************************************
429 Sends out a node status.
430 **************************************************************************/
432 static BOOL initiate_node_status_packet( struct packet_struct *packet )
434 struct nmb_packet *nmb = &packet->packet.nmb;
436 nmb->header.opcode = NMB_NAME_QUERY_OPCODE;
437 nmb->header.arcount = 0;
439 nmb->header.nm_flags.recursion_desired = False;
441 nmb->question.question_type = QUESTION_TYPE_NB_STATUS;
443 DEBUG(4,("initiate_node_status_packet: sending node status request for name %s to IP %s\n",
444 nmb_namestr(&nmb->question.question_name),
445 inet_ntoa(packet->ip)));
447 return send_netbios_packet( packet );
450 /****************************************************************************
451 Simplification functions for queuing standard packets.
452 These should be the only publicly callable functions for sending
454 ****************************************************************************/
456 /****************************************************************************
457 Assertion - we should never be sending nmbd packets on the remote
459 ****************************************************************************/
461 static BOOL assert_check_subnet(struct subnet_record *subrec)
463 if( subrec == remote_broadcast_subnet)
465 DEBUG(0,("assert_check_subnet: Attempt to send packet on remote broadcast subnet. \
472 /****************************************************************************
473 Queue a register name packet to the broadcast address of a subnet.
474 ****************************************************************************/
476 struct response_record *queue_register_name( struct subnet_record *subrec,
477 response_function resp_fn,
478 timeout_response_function timeout_fn,
479 register_name_success_function success_fn,
480 register_name_fail_function fail_fn,
481 struct userdata_struct *userdata,
482 struct nmb_name *nmbname,
485 struct packet_struct *p;
486 struct response_record *rrec;
488 if(assert_check_subnet(subrec))
491 /* note that all name registration requests have RD set (rfc1002 -
493 if ((p = create_and_init_netbios_packet(nmbname, (subrec != unicast_subnet), True,
494 subrec->bcast_ip)) == NULL)
497 if(initiate_name_register_packet( p, nb_flags,
498 iface_ip(subrec->bcast_ip)) == False)
505 if((rrec = make_response_record(subrec, /* subnet record. */
506 p, /* packet we sent. */
507 resp_fn, /* function to call on response. */
508 timeout_fn, /* function to call on timeout. */
509 (success_function)success_fn, /* function to call on operation success. */
510 (fail_function)fail_fn, /* function to call on operation fail. */
521 /****************************************************************************
522 Queue a multihomed register name packet to a given WINS server IP
523 ****************************************************************************/
525 struct response_record *queue_register_multihomed_name( struct subnet_record *subrec,
526 response_function resp_fn,
527 timeout_response_function timeout_fn,
528 register_name_success_function success_fn,
529 register_name_fail_function fail_fn,
530 struct userdata_struct *userdata,
531 struct nmb_name *nmbname,
533 struct in_addr register_ip,
534 struct in_addr wins_ip)
536 struct packet_struct *p;
537 struct response_record *rrec;
541 if(subrec != unicast_subnet) {
542 DEBUG(0,("queue_register_multihomed_name: should only be done on \
543 unicast subnet. subnet is %s\n.", subrec->subnet_name ));
547 if(assert_check_subnet(subrec))
550 if ((p = create_and_init_netbios_packet(nmbname, False, True, wins_ip)) == NULL)
553 if (nb_flags & NB_GROUP)
554 ret = initiate_name_register_packet( p, nb_flags, ®ister_ip);
556 ret = initiate_multihomed_name_register_packet(p, nb_flags, ®ister_ip);
564 if ((rrec = make_response_record(subrec, /* subnet record. */
565 p, /* packet we sent. */
566 resp_fn, /* function to call on response. */
567 timeout_fn, /* function to call on timeout. */
568 (success_function)success_fn, /* function to call on operation success. */
569 (fail_function)fail_fn, /* function to call on operation fail. */
570 userdata)) == NULL) {
579 /****************************************************************************
580 Queue a release name packet to the broadcast address of a subnet.
581 ****************************************************************************/
583 struct response_record *queue_release_name( struct subnet_record *subrec,
584 response_function resp_fn,
585 timeout_response_function timeout_fn,
586 release_name_success_function success_fn,
587 release_name_fail_function fail_fn,
588 struct userdata_struct *userdata,
589 struct nmb_name *nmbname,
591 struct in_addr release_ip)
593 struct packet_struct *p;
594 struct response_record *rrec;
596 if(assert_check_subnet(subrec))
599 if ((p = create_and_init_netbios_packet(nmbname, (subrec != unicast_subnet), False,
600 subrec->bcast_ip)) == NULL)
603 if(initiate_name_release_packet( p, nb_flags, &release_ip) == False)
610 if((rrec = make_response_record(subrec, /* subnet record. */
611 p, /* packet we sent. */
612 resp_fn, /* function to call on response. */
613 timeout_fn, /* function to call on timeout. */
614 (success_function)success_fn, /* function to call on operation success. */
615 (fail_function)fail_fn, /* function to call on operation fail. */
624 * For a broadcast release packet, only send once.
625 * This will cause us to remove the name asap. JRA.
628 if (subrec != unicast_subnet) {
629 rrec->repeat_count = 0;
630 rrec->repeat_time = 0;
636 /****************************************************************************
637 Queue a refresh name packet to the broadcast address of a subnet.
638 ****************************************************************************/
640 struct response_record *queue_refresh_name( struct subnet_record *subrec,
641 response_function resp_fn,
642 timeout_response_function timeout_fn,
643 refresh_name_success_function success_fn,
644 refresh_name_fail_function fail_fn,
645 struct userdata_struct *userdata,
646 struct name_record *namerec,
647 struct in_addr refresh_ip)
649 struct packet_struct *p;
650 struct response_record *rrec;
652 if(assert_check_subnet(subrec))
655 if(( p = create_and_init_netbios_packet(&namerec->name, (subrec != unicast_subnet), False,
656 subrec->bcast_ip)) == NULL)
659 if( !initiate_name_refresh_packet( p, namerec->data.nb_flags, &refresh_ip ) )
666 if((rrec = make_response_record(subrec, /* subnet record. */
667 p, /* packet we sent. */
668 resp_fn, /* function to call on response. */
669 timeout_fn, /* function to call on timeout. */
670 (success_function)success_fn, /* function to call on operation success. */
671 (fail_function)fail_fn, /* function to call on operation fail. */
682 /****************************************************************************
683 Queue a query name packet to the broadcast address of a subnet.
684 ****************************************************************************/
686 struct response_record *queue_query_name( struct subnet_record *subrec,
687 response_function resp_fn,
688 timeout_response_function timeout_fn,
689 query_name_success_function success_fn,
690 query_name_fail_function fail_fn,
691 struct userdata_struct *userdata,
692 struct nmb_name *nmbname)
694 struct packet_struct *p;
695 struct response_record *rrec;
697 if(assert_check_subnet(subrec))
700 if(( p = create_and_init_netbios_packet(nmbname,
701 (subrec != unicast_subnet),
702 (subrec == unicast_subnet),
703 subrec->bcast_ip)) == NULL)
706 if(lp_bind_interfaces_only()) {
709 DEBUG(10,("queue_query_name: bind_interfaces_only is set, looking for suitable source IP\n"));
710 for(i = 0; i < iface_count(); i++) {
711 struct in_addr *ifip = iface_n_ip(i);
714 DEBUG(0,("queue_query_name: interface %d has NULL IP address !\n", i));
718 if (ip_equal(*ifip,loopback_ip)) {
719 DEBUG(5,("queue_query_name: ignoring loopback interface (%d)\n", i));
723 DEBUG(10,("queue_query_name: using source IP %s\n",inet_ntoa(*ifip)));
724 p->fd = find_subnet_fd_for_address( *ifip );
729 if(initiate_name_query_packet( p ) == False) {
735 if((rrec = make_response_record(subrec, /* subnet record. */
736 p, /* packet we sent. */
737 resp_fn, /* function to call on response. */
738 timeout_fn, /* function to call on timeout. */
739 (success_function)success_fn, /* function to call on operation success. */
740 (fail_function)fail_fn, /* function to call on operation fail. */
751 /****************************************************************************
752 Queue a query name packet to a given address from the WINS subnet.
753 ****************************************************************************/
755 struct response_record *queue_query_name_from_wins_server( struct in_addr to_ip,
756 response_function resp_fn,
757 timeout_response_function timeout_fn,
758 query_name_success_function success_fn,
759 query_name_fail_function fail_fn,
760 struct userdata_struct *userdata,
761 struct nmb_name *nmbname)
763 struct packet_struct *p;
764 struct response_record *rrec;
766 if ((p = create_and_init_netbios_packet(nmbname, False, False, to_ip)) == NULL)
769 if(initiate_name_query_packet_from_wins_server( p ) == False)
776 if((rrec = make_response_record(wins_server_subnet, /* subnet record. */
777 p, /* packet we sent. */
778 resp_fn, /* function to call on response. */
779 timeout_fn, /* function to call on timeout. */
780 (success_function)success_fn, /* function to call on operation success. */
781 (fail_function)fail_fn, /* function to call on operation fail. */
792 /****************************************************************************
793 Queue a node status packet to a given name and address.
794 ****************************************************************************/
796 struct response_record *queue_node_status( struct subnet_record *subrec,
797 response_function resp_fn,
798 timeout_response_function timeout_fn,
799 node_status_success_function success_fn,
800 node_status_fail_function fail_fn,
801 struct userdata_struct *userdata,
802 struct nmb_name *nmbname,
803 struct in_addr send_ip)
805 struct packet_struct *p;
806 struct response_record *rrec;
809 if(subrec != unicast_subnet)
811 DEBUG(0,("queue_register_multihomed_name: should only be done on \
812 unicast subnet. subnet is %s\n.", subrec->subnet_name ));
816 if(assert_check_subnet(subrec))
819 if(( p = create_and_init_netbios_packet(nmbname, False, False,
823 if(initiate_node_status_packet(p) == False)
830 if((rrec = make_response_record(subrec, /* subnet record. */
831 p, /* packet we sent. */
832 resp_fn, /* function to call on response. */
833 timeout_fn, /* function to call on timeout. */
834 (success_function)success_fn, /* function to call on operation success. */
835 (fail_function)fail_fn, /* function to call on operation fail. */
846 /****************************************************************************
847 Reply to a netbios name packet. see rfc1002.txt
848 ****************************************************************************/
850 void reply_netbios_packet(struct packet_struct *orig_packet,
851 int rcode, enum netbios_reply_type_code rcv_code, int opcode,
852 int ttl, char *data,int len)
854 struct packet_struct packet;
855 struct nmb_packet *nmb = NULL;
856 struct res_rec answers;
857 struct nmb_packet *orig_nmb = &orig_packet->packet.nmb;
858 BOOL loopback_this_packet = False;
859 char *packet_type = "unknown";
861 /* Check if we are sending to or from ourselves. */
862 if(ismyip(orig_packet->ip) && (orig_packet->port == global_nmb_port))
863 loopback_this_packet = True;
865 nmb = &packet.packet.nmb;
867 /* Do a partial copy of the packet. We clear the locked flag and
868 the resource record pointers. */
869 packet = *orig_packet; /* Full structure copy. */
870 packet.locked = False;
873 nmb->additional = NULL;
879 packet_type = "nmb_status";
880 nmb->header.nm_flags.recursion_desired = False;
881 nmb->header.nm_flags.recursion_available = False;
886 packet_type = "nmb_query";
887 nmb->header.nm_flags.recursion_desired = True;
888 nmb->header.nm_flags.recursion_available = True;
892 case NMB_REG_REFRESH:
894 packet_type = "nmb_reg";
895 nmb->header.nm_flags.recursion_desired = True;
896 nmb->header.nm_flags.recursion_available = True;
901 packet_type = "nmb_rel";
902 nmb->header.nm_flags.recursion_desired = False;
903 nmb->header.nm_flags.recursion_available = False;
908 packet_type = "nmb_wack";
909 nmb->header.nm_flags.recursion_desired = False;
910 nmb->header.nm_flags.recursion_available = False;
915 packet_type = "wins_reg";
916 nmb->header.nm_flags.recursion_desired = True;
917 nmb->header.nm_flags.recursion_available = True;
922 packet_type = "wins_query";
923 nmb->header.nm_flags.recursion_desired = True;
924 nmb->header.nm_flags.recursion_available = True;
930 DEBUG(0,("reply_netbios_packet: Unknown packet type: %s %s to ip %s\n",
931 packet_type, nmb_namestr(&orig_nmb->question.question_name),
932 inet_ntoa(packet.ip)));
938 DEBUG(4,("reply_netbios_packet: sending a reply of packet type: %s %s to ip %s \
940 packet_type, nmb_namestr(&orig_nmb->question.question_name),
941 inet_ntoa(packet.ip), orig_nmb->header.name_trn_id));
943 nmb->header.name_trn_id = orig_nmb->header.name_trn_id;
944 nmb->header.opcode = opcode;
945 nmb->header.response = True;
946 nmb->header.nm_flags.bcast = False;
947 nmb->header.nm_flags.trunc = False;
948 nmb->header.nm_flags.authoritative = True;
950 nmb->header.rcode = rcode;
951 nmb->header.qdcount = 0;
952 nmb->header.ancount = 1;
953 nmb->header.nscount = 0;
954 nmb->header.arcount = 0;
956 memset((char*)&nmb->question,'\0',sizeof(nmb->question));
958 nmb->answers = &answers;
959 memset((char*)nmb->answers,'\0',sizeof(*nmb->answers));
961 nmb->answers->rr_name = orig_nmb->question.question_name;
962 nmb->answers->rr_type = orig_nmb->question.question_type;
963 nmb->answers->rr_class = orig_nmb->question.question_class;
964 nmb->answers->ttl = ttl;
968 nmb->answers->rdlength = len;
969 memcpy(nmb->answers->rdata, data, len);
972 packet.packet_type = NMB_PACKET;
973 /* Ensure we send out on the same fd that the original
974 packet came in on to give the correct source IP address. */
975 packet.fd = orig_packet->fd;
976 packet.timestamp = time(NULL);
978 debug_nmb_packet(&packet);
980 if(loopback_this_packet)
982 struct packet_struct *lo_packet;
983 DEBUG(5,("reply_netbios_packet: sending packet to ourselves.\n"));
984 if((lo_packet = copy_packet(&packet)) == NULL)
986 queue_packet(lo_packet);
988 else if (!send_packet(&packet))
990 DEBUG(0,("reply_netbios_packet: send_packet to IP %s port %d failed\n",
991 inet_ntoa(packet.ip),packet.port));
995 /*******************************************************************
996 Queue a packet into a packet queue
997 ******************************************************************/
998 static void queue_packet(struct packet_struct *packet)
1000 struct packet_struct *p;
1004 packet->prev = NULL;
1005 packet->next = NULL;
1006 packet_queue = packet;
1010 /* find the bottom */
1011 for (p=packet_queue;p->next;p=p->next)
1015 packet->next = NULL;
1019 /****************************************************************************
1020 Try and find a matching subnet record for a datagram port 138 packet.
1021 ****************************************************************************/
1023 static struct subnet_record *find_subnet_for_dgram_browse_packet(struct packet_struct *p)
1025 struct subnet_record *subrec;
1027 /* Go through all the broadcast subnets and see if the mask matches. */
1028 for (subrec = FIRST_SUBNET; subrec ; subrec = NEXT_SUBNET_EXCLUDING_UNICAST(subrec))
1030 if(same_net(p->ip, subrec->bcast_ip, subrec->mask_ip))
1034 /* If the subnet record is the remote announce broadcast subnet,
1035 hack it here to be the first subnet. This is really gross and
1036 is needed due to people turning on port 137/138 broadcast
1037 forwarding on their routers. May fire and brimstone rain
1041 return FIRST_SUBNET;
1044 /****************************************************************************
1045 Dispatch a browse frame from port 138 to the correct processing function.
1046 ****************************************************************************/
1047 static void process_browse_packet(struct packet_struct *p, char *buf,int len)
1049 struct dgram_packet *dgram = &p->packet.dgram;
1050 int command = CVAL(buf,0);
1051 struct subnet_record *subrec = find_subnet_for_dgram_browse_packet(p);
1052 extern pstring global_scope;
1054 /* Drop the packet if it's a different NetBIOS scope, or
1055 the source is from one of our names. */
1057 if (!strequal(dgram->dest_name.scope, global_scope))
1059 DEBUG(7,("process_browse_packet: Discarding datagram from IP %s. Scope (%s) \
1060 mismatch with our scope (%s).\n", inet_ntoa(p->ip), dgram->dest_name.scope, global_scope));
1064 if (is_myname(dgram->source_name.name))
1066 DEBUG(0,("process_browse_packet: Discarding datagram from IP %s. Source name \
1067 %s is one of our names !\n", inet_ntoa(p->ip), nmb_namestr(&dgram->source_name)));
1073 case ANN_HostAnnouncement:
1075 debug_browse_data(buf, len);
1076 process_host_announce(subrec, p, buf+1);
1079 case ANN_DomainAnnouncement:
1081 debug_browse_data(buf, len);
1082 process_workgroup_announce(subrec, p, buf+1);
1085 case ANN_LocalMasterAnnouncement:
1087 debug_browse_data(buf, len);
1088 process_local_master_announce(subrec, p, buf+1);
1091 case ANN_AnnouncementRequest:
1093 debug_browse_data(buf, len);
1094 process_announce_request(subrec, p, buf+1);
1099 debug_browse_data(buf, len);
1100 process_election(subrec, p, buf+1);
1103 case ANN_GetBackupListReq:
1105 debug_browse_data(buf, len);
1106 process_get_backup_list_request(subrec, p, buf+1);
1109 case ANN_GetBackupListResp:
1111 debug_browse_data(buf, len);
1112 /* We never send ANN_GetBackupListReq so we
1113 should never get these. */
1114 DEBUG(0,("process_browse_packet: Discarding GetBackupListResponse \
1115 packet from %s IP %s\n", nmb_namestr(&dgram->source_name), inet_ntoa(p->ip)));
1118 case ANN_ResetBrowserState:
1120 debug_browse_data(buf, len);
1121 process_reset_browser(subrec, p, buf+1);
1124 case ANN_MasterAnnouncement:
1126 /* Master browser datagrams must be processed
1127 on the unicast subnet. */
1128 subrec = unicast_subnet;
1130 debug_browse_data(buf, len);
1131 process_master_browser_announce(subrec, p, buf+1);
1134 case ANN_BecomeBackup:
1137 * We don't currently implement this. Log it just in case.
1139 debug_browse_data(buf, len);
1140 DEBUG(10,("process_browse_packet: On subnet %s ignoring browse packet \
1141 command ANN_BecomeBackup from %s IP %s to %s\n",
1142 subrec->subnet_name, nmb_namestr(&dgram->source_name),
1143 inet_ntoa(p->ip), nmb_namestr(&dgram->dest_name)));
1148 debug_browse_data(buf, len);
1149 DEBUG(0,("process_browse_packet: On subnet %s ignoring browse packet \
1150 command code %d from %s IP %s to %s\n",
1151 subrec->subnet_name, command, nmb_namestr(&dgram->source_name),
1152 inet_ntoa(p->ip), nmb_namestr(&dgram->dest_name)));
1157 /****************************************************************************
1158 Dispatch a LanMan browse frame from port 138 to the correct processing function.
1159 ****************************************************************************/
1160 static void process_lanman_packet(struct packet_struct *p, char *buf,int len)
1162 struct dgram_packet *dgram = &p->packet.dgram;
1163 int command = SVAL(buf,0);
1164 struct subnet_record *subrec = find_subnet_for_dgram_browse_packet(p);
1165 extern pstring global_scope;
1167 /* Drop the packet if it's a different NetBIOS scope, or
1168 the source is from one of our names. */
1170 if (!strequal(dgram->dest_name.scope, global_scope))
1172 DEBUG(7,("process_lanman_packet: Discarding datagram from IP %s. Scope (%s) \
1173 mismatch with our scope (%s).\n", inet_ntoa(p->ip), dgram->dest_name.scope, global_scope));
1177 if (is_myname(dgram->source_name.name))
1179 DEBUG(0,("process_lanman_packet: Discarding datagram from IP %s. Source name \
1180 %s is one of our names !\n", inet_ntoa(p->ip), nmb_namestr(&dgram->source_name)));
1186 case ANN_HostAnnouncement:
1188 debug_browse_data(buf, len);
1189 process_lm_host_announce(subrec, p, buf+1);
1192 case ANN_AnnouncementRequest:
1194 process_lm_announce_request(subrec, p, buf+1);
1199 DEBUG(0,("process_lanman_packet: On subnet %s ignoring browse packet \
1200 command code %d from %s IP %s to %s\n",
1201 subrec->subnet_name, command, nmb_namestr(&dgram->source_name),
1202 inet_ntoa(p->ip), nmb_namestr(&dgram->dest_name)));
1207 /****************************************************************************
1208 Determine if a packet is for us on port 138. Note that to have any chance of
1209 being efficient we need to drop as many packets as possible at this
1210 stage as subsequent processing is expensive.
1211 ****************************************************************************/
1213 static BOOL listening(struct packet_struct *p,struct nmb_name *nbname)
1215 struct subnet_record *subrec = NULL;
1217 for (subrec = FIRST_SUBNET; subrec ; subrec = NEXT_SUBNET_EXCLUDING_UNICAST(subrec))
1219 if(same_net(p->ip, subrec->bcast_ip, subrec->mask_ip))
1224 subrec = unicast_subnet;
1226 return (find_name_on_subnet(subrec, nbname, FIND_SELF_NAME) != NULL);
1229 /****************************************************************************
1230 Process udp 138 datagrams
1231 ****************************************************************************/
1232 static void process_dgram(struct packet_struct *p)
1237 struct dgram_packet *dgram = &p->packet.dgram;
1239 /* If we aren't listening to the destination name then ignore the packet */
1240 if (!listening(p,&dgram->dest_name))
1242 unexpected_packet(p);
1243 DEBUG(5,("process_dgram: ignoring dgram packet sent to name %s from %s\n",
1244 nmb_namestr(&dgram->dest_name), inet_ntoa(p->ip)));
1248 if (dgram->header.msg_type != 0x10 &&
1249 dgram->header.msg_type != 0x11 &&
1250 dgram->header.msg_type != 0x12)
1252 unexpected_packet(p);
1253 /* Don't process error packets etc yet */
1254 DEBUG(5,("process_dgram: ignoring dgram packet sent to name %s from IP %s as it is \
1255 an error packet of type %x\n",
1256 nmb_namestr(&dgram->dest_name), inet_ntoa(p->ip), dgram->header.msg_type));
1260 buf = &dgram->data[0];
1261 buf -= 4; /* XXXX for the pseudo tcp length -
1262 someday I need to get rid of this */
1264 if (CVAL(buf,smb_com) != SMBtrans)
1267 len = SVAL(buf,smb_vwv11);
1268 buf2 = smb_base(buf) + SVAL(buf,smb_vwv12);
1273 if (buf2 + len > buf + sizeof(dgram->data)) {
1274 DEBUG(2,("process_dgram: datagram from %s to %s IP %s for %s len=%d too long.\n",
1275 nmb_namestr(&dgram->source_name),nmb_namestr(&dgram->dest_name),
1276 inet_ntoa(p->ip), smb_buf(buf),len));
1277 len = (buf + sizeof(dgram->data)) - buf;
1280 DEBUG(4,("process_dgram: datagram from %s to %s IP %s for %s of type %d len=%d\n",
1281 nmb_namestr(&dgram->source_name),nmb_namestr(&dgram->dest_name),
1282 inet_ntoa(p->ip), smb_buf(buf),CVAL(buf2,0),len));
1285 /* Datagram packet received for the browser mailslot */
1286 if (strequal(smb_buf(buf),BROWSE_MAILSLOT))
1288 process_browse_packet(p,buf2,len);
1292 /* Datagram packet received for the LAN Manager mailslot */
1293 if (strequal(smb_buf(buf),LANMAN_MAILSLOT)) {
1294 process_lanman_packet(p,buf2,len);
1298 /* Datagram packet received for the domain logon mailslot */
1299 if (strequal(smb_buf(buf),NET_LOGON_MAILSLOT))
1301 process_logon_packet(p,buf2,len,NET_LOGON_MAILSLOT);
1305 /* Datagram packet received for the NT domain logon mailslot */
1306 if (strequal(smb_buf(buf),NT_LOGON_MAILSLOT))
1308 process_logon_packet(p,buf2,len,NT_LOGON_MAILSLOT);
1312 unexpected_packet(p);
1315 /****************************************************************************
1316 Validate a response nmb packet.
1317 ****************************************************************************/
1319 static BOOL validate_nmb_response_packet( struct nmb_packet *nmb )
1321 BOOL ignore = False;
1323 switch (nmb->header.opcode)
1325 case NMB_NAME_REG_OPCODE:
1326 case NMB_NAME_REFRESH_OPCODE_8: /* ambiguity in rfc1002 about which is correct. */
1327 case NMB_NAME_REFRESH_OPCODE_9: /* WinNT uses 8 by default. */
1328 if (nmb->header.ancount == 0)
1330 DEBUG(0,("validate_nmb_response_packet: Bad REG/REFRESH Packet. "));
1335 case NMB_NAME_QUERY_OPCODE:
1336 if ((nmb->header.ancount != 0) && (nmb->header.ancount != 1))
1338 DEBUG(0,("validate_nmb_response_packet: Bad QUERY Packet. "));
1342 case NMB_NAME_RELEASE_OPCODE:
1343 if (nmb->header.ancount == 0)
1345 DEBUG(0,("validate_nmb_response_packet: Bad RELEASE Packet. "));
1349 case NMB_WACK_OPCODE:
1350 /* Check WACK response here. */
1351 if (nmb->header.ancount != 1)
1353 DEBUG(0,("validate_nmb_response_packet: Bad WACK Packet. "));
1358 DEBUG(0,("validate_nmb_response_packet: Ignoring packet with unknown opcode %d.\n",
1359 nmb->header.opcode));
1364 DEBUG(0,("Ignoring response packet with opcode %d.\n", nmb->header.opcode));
1369 /****************************************************************************
1370 Validate a request nmb packet.
1371 ****************************************************************************/
1373 static BOOL validate_nmb_packet( struct nmb_packet *nmb )
1375 BOOL ignore = False;
1377 switch (nmb->header.opcode)
1379 case NMB_NAME_REG_OPCODE:
1380 case NMB_NAME_REFRESH_OPCODE_8: /* ambiguity in rfc1002 about which is correct. */
1381 case NMB_NAME_REFRESH_OPCODE_9: /* WinNT uses 8 by default. */
1382 case NMB_NAME_MULTIHOMED_REG_OPCODE:
1383 if (nmb->header.qdcount==0 || nmb->header.arcount==0)
1385 DEBUG(0,("validate_nmb_packet: Bad REG/REFRESH Packet. "));
1390 case NMB_NAME_QUERY_OPCODE:
1391 if ((nmb->header.qdcount == 0) ||
1392 ((nmb->question.question_type != QUESTION_TYPE_NB_QUERY) &&
1393 (nmb->question.question_type != QUESTION_TYPE_NB_STATUS)))
1395 DEBUG(0,("validate_nmb_packet: Bad QUERY Packet. "));
1400 case NMB_NAME_RELEASE_OPCODE:
1401 if (nmb->header.qdcount==0 || nmb->header.arcount==0)
1403 DEBUG(0,("validate_nmb_packet: Bad RELEASE Packet. "));
1408 DEBUG(0,("validate_nmb_packet: Ignoring packet with unknown opcode %d.\n",
1409 nmb->header.opcode));
1414 DEBUG(0,("validate_nmb_packet: Ignoring request packet with opcode %d.\n", nmb->header.opcode));
1419 /****************************************************************************
1420 Find a subnet (and potentially a response record) for a packet.
1421 ****************************************************************************/
1423 static struct subnet_record *find_subnet_for_nmb_packet( struct packet_struct *p,
1424 struct response_record **pprrec)
1426 struct nmb_packet *nmb = &p->packet.nmb;
1427 struct response_record *rrec = NULL;
1428 struct subnet_record *subrec = NULL;
1433 if(nmb->header.response)
1435 /* It's a response packet. Find a record for it or it's an error. */
1437 rrec = find_response_record( &subrec, nmb->header.name_trn_id);
1440 DEBUG(3,("find_subnet_for_nmb_packet: response record not found for response id %hu\n",
1441 nmb->header.name_trn_id));
1442 unexpected_packet(p);
1448 DEBUG(0,("find_subnet_for_nmb_packet: subnet record not found for response id %hu\n",
1449 nmb->header.name_trn_id));
1458 /* Try and see what subnet this packet belongs to. */
1461 if(packet_is_for_wins_server(p))
1462 return wins_server_subnet;
1464 /* If it wasn't a broadcast packet then send to the UNICAST subnet. */
1465 if(nmb->header.nm_flags.bcast == False)
1466 return unicast_subnet;
1468 /* Go through all the broadcast subnets and see if the mask matches. */
1469 for (subrec = FIRST_SUBNET; subrec ; subrec = NEXT_SUBNET_EXCLUDING_UNICAST(subrec))
1471 if(same_net(p->ip, subrec->bcast_ip, subrec->mask_ip))
1475 /* If none match it must have been a directed broadcast - assign
1476 the remote_broadcast_subnet. */
1477 return remote_broadcast_subnet;
1480 /****************************************************************************
1481 Process a nmb request packet - validate the packet and route it.
1482 ****************************************************************************/
1484 static void process_nmb_request(struct packet_struct *p)
1486 struct nmb_packet *nmb = &p->packet.nmb;
1487 struct subnet_record *subrec = NULL;
1489 debug_nmb_packet(p);
1491 /* Ensure we have a good packet. */
1492 if(validate_nmb_packet(nmb))
1495 /* Allocate a subnet to this packet - if we cannot - fail. */
1496 if((subrec = find_subnet_for_nmb_packet(p, NULL))==NULL)
1499 switch (nmb->header.opcode)
1501 case NMB_NAME_REG_OPCODE:
1502 if(subrec == wins_server_subnet)
1503 wins_process_name_registration_request(subrec, p);
1505 process_name_registration_request(subrec, p);
1508 case NMB_NAME_REFRESH_OPCODE_8: /* ambiguity in rfc1002 about which is correct. */
1509 case NMB_NAME_REFRESH_OPCODE_9:
1510 if(subrec == wins_server_subnet)
1511 wins_process_name_refresh_request(subrec, p);
1513 process_name_refresh_request(subrec, p);
1516 case NMB_NAME_MULTIHOMED_REG_OPCODE:
1517 if(subrec == wins_server_subnet)
1518 wins_process_multihomed_name_registration_request(subrec, p);
1521 DEBUG(0,("process_nmb_request: Multihomed registration request must be \
1522 directed at a WINS server.\n"));
1526 case NMB_NAME_QUERY_OPCODE:
1527 switch (nmb->question.question_type)
1529 case QUESTION_TYPE_NB_QUERY:
1531 if(subrec == wins_server_subnet)
1532 wins_process_name_query_request(subrec, p);
1534 process_name_query_request(subrec, p);
1537 case QUESTION_TYPE_NB_STATUS:
1539 if(subrec == wins_server_subnet)
1541 DEBUG(0,("process_nmb_request: NB_STATUS request directed at WINS server is \
1546 process_node_status_request(subrec, p);
1552 case NMB_NAME_RELEASE_OPCODE:
1553 if(subrec == wins_server_subnet)
1554 wins_process_name_release_request(subrec, p);
1556 process_name_release_request(subrec, p);
1561 /****************************************************************************
1562 Process a nmb response packet - validate the packet and route it.
1563 to either the WINS server or a normal response.
1564 ****************************************************************************/
1566 static void process_nmb_response(struct packet_struct *p)
1568 struct nmb_packet *nmb = &p->packet.nmb;
1569 struct subnet_record *subrec = NULL;
1570 struct response_record *rrec = NULL;
1572 debug_nmb_packet(p);
1574 if(validate_nmb_response_packet(nmb))
1577 if((subrec = find_subnet_for_nmb_packet(p, &rrec))==NULL)
1582 DEBUG(0,("process_nmb_response: response packet received but no response record \
1583 found for id = %hu. Ignoring packet.\n", nmb->header.name_trn_id));
1587 /* Increment the number of responses received for this record. */
1589 /* Ensure we don't re-send the request. */
1590 rrec->repeat_count = 0;
1592 /* Call the response received function for this packet. */
1593 (*rrec->resp_fn)(subrec, rrec, p);
1597 /*******************************************************************
1598 Run elements off the packet queue till its empty
1599 ******************************************************************/
1601 void run_packet_queue(void)
1603 struct packet_struct *p;
1605 while ((p = packet_queue))
1607 packet_queue = p->next;
1609 packet_queue->prev = NULL;
1610 p->next = p->prev = NULL;
1612 switch (p->packet_type)
1615 if(p->packet.nmb.header.response)
1616 process_nmb_response(p);
1618 process_nmb_request(p);
1629 /*******************************************************************
1630 Retransmit or timeout elements from all the outgoing subnet response
1631 record queues. NOTE that this code must also check the WINS server
1632 subnet for response records to timeout as the WINS server code
1633 can send requests to check if a client still owns a name.
1634 (Patch from Andrey Alekseyev <fetch@muffin.arcadia.spb.ru>).
1635 ******************************************************************/
1637 void retransmit_or_expire_response_records(time_t t)
1639 struct subnet_record *subrec;
1641 for (subrec = FIRST_SUBNET; subrec;
1642 subrec = get_next_subnet_maybe_unicast_or_wins_server(subrec))
1644 struct response_record *rrec, *nextrrec;
1646 for (rrec = subrec->responselist; rrec; rrec = nextrrec)
1648 nextrrec = rrec->next;
1650 if (rrec->repeat_time <= t)
1652 if (rrec->repeat_count > 0)
1654 /* Resend while we have a non-zero repeat_count. */
1655 if(!send_packet(rrec->packet))
1657 DEBUG(0,("retransmit_or_expire_response_records: Failed to resend packet id %hu \
1658 to IP %s on subnet %s\n", rrec->response_id, inet_ntoa(rrec->packet->ip),
1659 subrec->subnet_name));
1661 rrec->repeat_time += rrec->repeat_interval;
1662 rrec->repeat_count--;
1666 DEBUG(4,("retransmit_or_expire_response_records: timeout for packet id %hu to IP %s \
1667 on subnet %s\n", rrec->response_id, inet_ntoa(rrec->packet->ip),
1668 subrec->subnet_name));
1671 * Check the flag in this record to prevent recursion if we end
1672 * up in this function again via the timeout function call.
1675 if(!rrec->in_expiration_processing)
1679 * Set the recursion protection flag in this record.
1682 rrec->in_expiration_processing = True;
1684 /* Call the timeout function. This will deal with removing the
1685 timed out packet. */
1686 if(rrec->timeout_fn)
1687 (*rrec->timeout_fn)(subrec, rrec);
1690 /* We must remove the record ourself if there is
1691 no timeout function. */
1692 remove_response_record(subrec, rrec);
1694 } /* !rrec->in_expitation_processing */
1695 } /* rrec->repeat_count > 0 */
1696 } /* rrec->repeat_time <= t */
1697 } /* end for rrec */
1698 } /* end for subnet */
1701 /****************************************************************************
1702 Create an fd_set containing all the sockets in the subnet structures,
1703 plus the broadcast sockets.
1704 ***************************************************************************/
1706 static BOOL create_listen_fdset(fd_set **ppset, int **psock_array, int *listen_number)
1708 int *sock_array = NULL;
1709 struct subnet_record *subrec = NULL;
1712 fd_set *pset = (fd_set *)malloc(sizeof(fd_set));
1716 DEBUG(0,("create_listen_fdset: malloc fail !\n"));
1720 /* Check that we can add all the fd's we need. */
1721 for (subrec = FIRST_SUBNET; subrec; subrec = NEXT_SUBNET_EXCLUDING_UNICAST(subrec))
1724 if((count*2) + 2 > FD_SETSIZE)
1726 DEBUG(0,("create_listen_fdset: Too many file descriptors needed (%d). We can \
1727 only use %d.\n", (count*2) + 2, FD_SETSIZE));
1731 if((sock_array = (int *)malloc(((count*2) + 2)*sizeof(int))) == NULL)
1733 DEBUG(0,("create_listen_fdset: malloc fail for socket array.\n"));
1739 /* Add in the broadcast socket on 137. */
1740 FD_SET(ClientNMB,pset);
1741 sock_array[num++] = ClientNMB;
1743 /* Add in the 137 sockets on all the interfaces. */
1744 for (subrec = FIRST_SUBNET; subrec; subrec = NEXT_SUBNET_EXCLUDING_UNICAST(subrec))
1746 FD_SET(subrec->nmb_sock,pset);
1747 sock_array[num++] = subrec->nmb_sock;
1750 /* Add in the broadcast socket on 138. */
1751 FD_SET(ClientDGRAM,pset);
1752 sock_array[num++] = ClientDGRAM;
1754 /* Add in the 138 sockets on all the interfaces. */
1755 for (subrec = FIRST_SUBNET; subrec; subrec = NEXT_SUBNET_EXCLUDING_UNICAST(subrec))
1757 FD_SET(subrec->dgram_sock,pset);
1758 sock_array[num++] = subrec->dgram_sock;
1761 *listen_number = (count*2) + 2;
1764 SAFE_FREE(*psock_array);
1767 *psock_array = sock_array;
1772 /****************************************************************************
1773 Listens for NMB or DGRAM packets, and queues them.
1774 return True if the socket is dead
1775 ***************************************************************************/
1777 BOOL listen_for_packets(BOOL run_election)
1779 static fd_set *listen_set = NULL;
1780 static int listen_number = 0;
1781 static int *sock_array = NULL;
1786 struct timeval timeout;
1791 if(listen_set == NULL || rescan_listen_set)
1793 if(create_listen_fdset(&listen_set, &sock_array, &listen_number))
1795 DEBUG(0,("listen_for_packets: Fatal error. unable to create listen set. Exiting.\n"));
1798 rescan_listen_set = False;
1801 memcpy((char *)&fds, (char *)listen_set, sizeof(fd_set));
1804 dns_fd = asyncdns_fd();
1806 FD_SET(dns_fd, &fds);
1812 * During elections and when expecting a netbios response packet we
1813 * need to send election packets at tighter intervals.
1814 * Ideally it needs to be the interval (in ms) between time now and
1815 * the time we are expecting the next netbios packet.
1818 timeout.tv_sec = (run_election||num_response_packets) ? 1 : NMBD_SELECT_LOOP;
1819 timeout.tv_usec = 0;
1821 /* Prepare for the select - allow certain signals. */
1823 BlockSignals(False, SIGTERM);
1825 selrtn = sys_select(FD_SETSIZE,&fds,NULL,NULL,&timeout);
1827 /* We can only take signals when we are in the select - block them again here. */
1829 BlockSignals(True, SIGTERM);
1836 if (dns_fd != -1 && FD_ISSET(dns_fd,&fds)) {
1841 for(i = 0; i < listen_number; i++) {
1842 if (i < (listen_number/2)) {
1843 /* Processing a 137 socket. */
1844 if (FD_ISSET(sock_array[i],&fds)) {
1845 struct packet_struct *packet = read_packet(sock_array[i], NMB_PACKET);
1848 * If we got a packet on the broadcast socket and interfaces
1849 * only is set then check it came from one of our local nets.
1851 if(lp_bind_interfaces_only() && (sock_array[i] == ClientNMB) &&
1852 (!is_local_net(packet->ip))) {
1853 DEBUG(7,("discarding nmb packet sent to broadcast socket from %s:%d\n",
1854 inet_ntoa(packet->ip),packet->port));
1855 free_packet(packet);
1856 } else if ((ip_equal(loopback_ip, packet->ip) ||
1857 ismyip(packet->ip)) && packet->port == global_nmb_port) {
1858 DEBUG(7,("discarding own packet from %s:%d\n",
1859 inet_ntoa(packet->ip),packet->port));
1860 free_packet(packet);
1862 /* Save the file descriptor this packet came in on. */
1863 packet->fd = sock_array[i];
1864 queue_packet(packet);
1869 /* Processing a 138 socket. */
1870 if (FD_ISSET(sock_array[i],&fds)) {
1871 struct packet_struct *packet = read_packet(sock_array[i], DGRAM_PACKET);
1874 * If we got a packet on the broadcast socket and interfaces
1875 * only is set then check it came from one of our local nets.
1877 if(lp_bind_interfaces_only() && (sock_array[i] == ClientDGRAM) &&
1878 (!is_local_net(packet->ip))) {
1879 DEBUG(7,("discarding dgram packet sent to broadcast socket from %s:%d\n",
1880 inet_ntoa(packet->ip),packet->port));
1881 free_packet(packet);
1882 } else if ((ip_equal(loopback_ip, packet->ip) ||
1883 ismyip(packet->ip)) && packet->port == DGRAM_PORT) {
1884 DEBUG(7,("discarding own packet from %s:%d\n",
1885 inet_ntoa(packet->ip),packet->port));
1886 free_packet(packet);
1888 /* Save the file descriptor this packet came in on. */
1889 packet->fd = sock_array[i];
1890 queue_packet(packet);
1894 } /* end processing 138 socket. */
1899 /****************************************************************************
1900 Construct and send a netbios DGRAM.
1901 **************************************************************************/
1902 BOOL send_mailslot(BOOL unique, char *mailslot,char *buf,int len,
1903 char *srcname, int src_type,
1904 char *dstname, int dest_type,
1905 struct in_addr dest_ip,struct in_addr src_ip,
1908 BOOL loopback_this_packet = False;
1909 struct packet_struct p;
1910 struct dgram_packet *dgram = &p.packet.dgram;
1914 memset((char *)&p,'\0',sizeof(p));
1916 if(ismyip(dest_ip) && (dest_port == DGRAM_PORT)) /* Only if to DGRAM_PORT */
1917 loopback_this_packet = True;
1919 /* generate_name_trn_id(); */ /* Not used, so gone, RJS */
1921 /* DIRECT GROUP or UNIQUE datagram. */
1922 dgram->header.msg_type = unique ? 0x10 : 0x11;
1923 dgram->header.flags.node_type = M_NODE;
1924 dgram->header.flags.first = True;
1925 dgram->header.flags.more = False;
1926 dgram->header.dgm_id = generate_name_trn_id();
1927 dgram->header.source_ip = src_ip;
1928 dgram->header.source_port = DGRAM_PORT;
1929 dgram->header.dgm_length = 0; /* Let build_dgram() handle this. */
1930 dgram->header.packet_offset = 0;
1932 make_nmb_name(&dgram->source_name,srcname,src_type);
1933 make_nmb_name(&dgram->dest_name,dstname,dest_type);
1935 ptr = &dgram->data[0];
1937 /* Setup the smb part. */
1938 ptr -= 4; /* XXX Ugliness because of handling of tcp SMB length. */
1940 set_message(ptr,17,17 + len,True);
1943 SCVAL(ptr,smb_com,SMBtrans);
1944 SSVAL(ptr,smb_vwv1,len);
1945 SSVAL(ptr,smb_vwv11,len);
1946 SSVAL(ptr,smb_vwv12,70 + strlen(mailslot));
1947 SSVAL(ptr,smb_vwv13,3);
1948 SSVAL(ptr,smb_vwv14,1);
1949 SSVAL(ptr,smb_vwv15,1);
1950 SSVAL(ptr,smb_vwv16,2);
1952 pstrcpy(p2,mailslot);
1953 p2 = skip_string(p2,1);
1958 dgram->datasize = PTR_DIFF(p2,ptr+4); /* +4 for tcp length. */
1962 p.fd = find_subnet_mailslot_fd_for_address( src_ip );
1963 p.timestamp = time(NULL);
1964 p.packet_type = DGRAM_PACKET;
1966 DEBUG(4,("send_mailslot: Sending to mailslot %s from %s IP %s ", mailslot,
1967 nmb_namestr(&dgram->source_name), inet_ntoa(src_ip)));
1968 DEBUG(4,("to %s IP %s\n", nmb_namestr(&dgram->dest_name), inet_ntoa(dest_ip)));
1970 debug_browse_data(buf, len);
1972 if(loopback_this_packet)
1974 struct packet_struct *lo_packet = NULL;
1975 DEBUG(5,("send_mailslot: sending packet to ourselves.\n"));
1976 if((lo_packet = copy_packet(&p)) == NULL)
1978 queue_packet(lo_packet);
1982 return(send_packet(&p));