2 Unix SMB/CIFS implementation.
3 NBT netbios routines and daemon - version 2
4 Copyright (C) Andrew Tridgell 1994-1998
5 Copyright (C) Luke Kenneth Casson Leighton 1994-1998
6 Copyright (C) Jeremy Allison 1994-2003
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 3 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, see <http://www.gnu.org/licenses/>.
26 extern int ClientDGRAM;
27 extern int global_nmb_port;
29 extern int num_response_packets;
31 bool rescan_listen_set = False;
34 /*******************************************************************
35 The global packet linked-list. Incoming entries are
36 added to the end of this list. It is supposed to remain fairly
37 short so we won't bother with an end pointer.
38 ******************************************************************/
40 static struct packet_struct *packet_queue = NULL;
42 /***************************************************************************
43 Utility function to find the specific fd to send a packet out on.
44 **************************************************************************/
46 static int find_subnet_fd_for_address( struct in_addr local_ip )
48 struct subnet_record *subrec;
50 for( subrec = FIRST_SUBNET; subrec; subrec = NEXT_SUBNET_EXCLUDING_UNICAST(subrec))
51 if(ip_equal_v4(local_ip, subrec->myip))
52 return subrec->nmb_sock;
57 /***************************************************************************
58 Utility function to find the specific fd to send a mailslot packet out on.
59 **************************************************************************/
61 static int find_subnet_mailslot_fd_for_address( struct in_addr local_ip )
63 struct subnet_record *subrec;
65 for( subrec = FIRST_SUBNET; subrec; subrec = NEXT_SUBNET_EXCLUDING_UNICAST(subrec))
66 if(ip_equal_v4(local_ip, subrec->myip))
67 return subrec->dgram_sock;
72 /***************************************************************************
73 Get/Set problematic nb_flags as network byte order 16 bit int.
74 **************************************************************************/
76 uint16 get_nb_flags(char *buf)
78 return ((((uint16)*buf)&0xFFFF) & NB_FLGMSK);
81 void set_nb_flags(char *buf, uint16 nb_flags)
83 *buf++ = ((nb_flags & NB_FLGMSK) & 0xFF);
87 /***************************************************************************
88 Dumps out the browse packet data.
89 **************************************************************************/
91 static void debug_browse_data(char *outbuf, int len)
95 DEBUG( 4, ( "debug_browse_data():\n" ) );
96 for (i = 0; i < len; i+= 16) {
97 DEBUGADD( 4, ( "%3x char ", i ) );
99 for (j = 0; j < 16; j++) {
105 if (x < 32 || x > 127)
108 DEBUGADD( 4, ( "%c", x ) );
111 DEBUGADD( 4, ( "%*s hex", 16-j, "" ) );
113 for (j = 0; j < 16; j++) {
116 DEBUGADD( 4, ( " %02x", (unsigned char)outbuf[i+j] ) );
119 DEBUGADD( 4, ("\n") );
123 /***************************************************************************
124 Generates the unique transaction identifier
125 **************************************************************************/
127 static uint16 name_trn_id=0;
129 static uint16 generate_name_trn_id(void)
132 name_trn_id = ((unsigned)time(NULL)%(unsigned)0x7FFF) + ((unsigned)sys_getpid()%(unsigned)100);
134 name_trn_id = (name_trn_id+1) % (unsigned)0x7FFF;
138 /***************************************************************************
139 Either loops back or sends out a completed NetBIOS packet.
140 **************************************************************************/
142 static bool send_netbios_packet(struct packet_struct *p)
144 bool loopback_this_packet = False;
146 /* Check if we are sending to or from ourselves as a WINS server. */
147 if(ismyip_v4(p->ip) && (p->port == global_nmb_port))
148 loopback_this_packet = True;
150 if(loopback_this_packet) {
151 struct packet_struct *lo_packet = NULL;
152 DEBUG(5,("send_netbios_packet: sending packet to ourselves.\n"));
153 if((lo_packet = copy_packet(p)) == NULL)
155 queue_packet(lo_packet);
156 } else if (!send_packet(p)) {
157 DEBUG(0,("send_netbios_packet: send_packet() to IP %s port %d failed\n",
158 inet_ntoa(p->ip),p->port));
165 /***************************************************************************
166 Sets up the common elements of an outgoing NetBIOS packet.
168 Note: do not attempt to rationalise whether rec_des should be set or not
169 in a particular situation. Just follow rfc_1002 or look at examples from WinXX.
170 It does NOT follow the rule that requests to the wins server always have
171 rec_des true. See for example name releases and refreshes
172 **************************************************************************/
174 static struct packet_struct *create_and_init_netbios_packet(struct nmb_name *nmbname,
175 bool bcast, bool rec_des,
176 struct in_addr to_ip)
178 struct packet_struct *packet = NULL;
179 struct nmb_packet *nmb = NULL;
181 /* Allocate the packet_struct we will return. */
182 if((packet = SMB_MALLOC_P(struct packet_struct)) == NULL) {
183 DEBUG(0,("create_and_init_netbios_packet: malloc fail (1) for packet struct.\n"));
187 memset((char *)packet,'\0',sizeof(*packet));
189 nmb = &packet->packet.nmb;
191 nmb->header.name_trn_id = generate_name_trn_id();
192 nmb->header.response = False;
193 nmb->header.nm_flags.recursion_desired = rec_des;
194 nmb->header.nm_flags.recursion_available = False;
195 nmb->header.nm_flags.trunc = False;
196 nmb->header.nm_flags.authoritative = False;
197 nmb->header.nm_flags.bcast = bcast;
199 nmb->header.rcode = 0;
200 nmb->header.qdcount = 1;
201 nmb->header.ancount = 0;
202 nmb->header.nscount = 0;
204 nmb->question.question_name = *nmbname;
205 nmb->question.question_type = QUESTION_TYPE_NB_QUERY;
206 nmb->question.question_class = QUESTION_CLASS_IN;
209 packet->port = NMB_PORT;
210 packet->recv_fd = -1;
211 packet->send_fd = ClientNMB;
212 packet->timestamp = time(NULL);
213 packet->packet_type = NMB_PACKET;
214 packet->locked = False;
216 return packet; /* Caller must free. */
219 /***************************************************************************
220 Sets up the common elements of register, refresh or release packet.
221 **************************************************************************/
223 static bool create_and_init_additional_record(struct packet_struct *packet,
225 const struct in_addr *register_ip)
227 struct nmb_packet *nmb = &packet->packet.nmb;
229 if((nmb->additional = SMB_MALLOC_P(struct res_rec)) == NULL) {
230 DEBUG(0,("create_and_init_additional_record: malloc fail for additional record.\n"));
234 memset((char *)nmb->additional,'\0',sizeof(struct res_rec));
236 nmb->additional->rr_name = nmb->question.question_name;
237 nmb->additional->rr_type = RR_TYPE_NB;
238 nmb->additional->rr_class = RR_CLASS_IN;
240 /* See RFC 1002, sections 5.1.1.1, 5.1.1.2 and 5.1.1.3 */
241 if (nmb->header.nm_flags.bcast)
242 nmb->additional->ttl = PERMANENT_TTL;
244 nmb->additional->ttl = lp_max_ttl();
246 nmb->additional->rdlength = 6;
248 set_nb_flags(nmb->additional->rdata,nb_flags);
250 /* Set the address for the name we are registering. */
251 putip(&nmb->additional->rdata[2], register_ip);
254 it turns out that Jeremys code was correct, we are supposed
255 to send registrations from the IP we are registering. The
256 trick is what to do on timeouts! When we send on a
257 non-routable IP then the reply will timeout, and we should
258 treat this as success, not failure. That means we go into
259 our standard refresh cycle for that name which copes nicely
260 with disconnected networks.
262 packet->recv_fd = -1;
263 packet->send_fd = find_subnet_fd_for_address(*register_ip);
268 /***************************************************************************
269 Sends out a name query.
270 **************************************************************************/
272 static bool initiate_name_query_packet( struct packet_struct *packet)
274 struct nmb_packet *nmb = NULL;
276 nmb = &packet->packet.nmb;
278 nmb->header.opcode = NMB_NAME_QUERY_OPCODE;
279 nmb->header.arcount = 0;
281 nmb->header.nm_flags.recursion_desired = True;
283 DEBUG(4,("initiate_name_query_packet: sending query for name %s (bcast=%s) to IP %s\n",
284 nmb_namestr(&nmb->question.question_name),
285 BOOLSTR(nmb->header.nm_flags.bcast), inet_ntoa(packet->ip)));
287 return send_netbios_packet( packet );
290 /***************************************************************************
291 Sends out a name query - from a WINS server.
292 **************************************************************************/
294 static bool initiate_name_query_packet_from_wins_server( struct packet_struct *packet)
296 struct nmb_packet *nmb = NULL;
298 nmb = &packet->packet.nmb;
300 nmb->header.opcode = NMB_NAME_QUERY_OPCODE;
301 nmb->header.arcount = 0;
303 nmb->header.nm_flags.recursion_desired = False;
305 DEBUG(4,("initiate_name_query_packet_from_wins_server: sending query for name %s (bcast=%s) to IP %s\n",
306 nmb_namestr(&nmb->question.question_name),
307 BOOLSTR(nmb->header.nm_flags.bcast), inet_ntoa(packet->ip)));
309 return send_netbios_packet( packet );
312 /***************************************************************************
313 Sends out a name register.
314 **************************************************************************/
316 static bool initiate_name_register_packet( struct packet_struct *packet,
317 uint16 nb_flags, const struct in_addr *register_ip)
319 struct nmb_packet *nmb = &packet->packet.nmb;
321 nmb->header.opcode = NMB_NAME_REG_OPCODE;
322 nmb->header.arcount = 1;
324 nmb->header.nm_flags.recursion_desired = True;
326 if(create_and_init_additional_record(packet, nb_flags, register_ip) == False)
329 DEBUG(4,("initiate_name_register_packet: sending registration for name %s (bcast=%s) to IP %s\n",
330 nmb_namestr(&nmb->additional->rr_name),
331 BOOLSTR(nmb->header.nm_flags.bcast), inet_ntoa(packet->ip)));
333 return send_netbios_packet( packet );
336 /***************************************************************************
337 Sends out a multihomed name register.
338 **************************************************************************/
340 static bool initiate_multihomed_name_register_packet(struct packet_struct *packet,
341 uint16 nb_flags, struct in_addr *register_ip)
343 struct nmb_packet *nmb = &packet->packet.nmb;
344 fstring second_ip_buf;
346 fstrcpy(second_ip_buf, inet_ntoa(packet->ip));
348 nmb->header.opcode = NMB_NAME_MULTIHOMED_REG_OPCODE;
349 nmb->header.arcount = 1;
351 nmb->header.nm_flags.recursion_desired = True;
353 if(create_and_init_additional_record(packet, nb_flags, register_ip) == False)
356 DEBUG(4,("initiate_multihomed_name_register_packet: sending registration \
357 for name %s IP %s (bcast=%s) to IP %s\n",
358 nmb_namestr(&nmb->additional->rr_name), inet_ntoa(*register_ip),
359 BOOLSTR(nmb->header.nm_flags.bcast), second_ip_buf ));
361 return send_netbios_packet( packet );
364 /***************************************************************************
365 Sends out a name refresh.
366 **************************************************************************/
368 static bool initiate_name_refresh_packet( struct packet_struct *packet,
369 uint16 nb_flags, struct in_addr *refresh_ip)
371 struct nmb_packet *nmb = &packet->packet.nmb;
373 nmb->header.opcode = NMB_NAME_REFRESH_OPCODE_8;
374 nmb->header.arcount = 1;
376 nmb->header.nm_flags.recursion_desired = False;
378 if(create_and_init_additional_record(packet, nb_flags, refresh_ip) == False)
381 DEBUG(4,("initiate_name_refresh_packet: sending refresh for name %s (bcast=%s) to IP %s\n",
382 nmb_namestr(&nmb->additional->rr_name),
383 BOOLSTR(nmb->header.nm_flags.bcast), inet_ntoa(packet->ip)));
385 return send_netbios_packet( packet );
388 /***************************************************************************
389 Sends out a name release.
390 **************************************************************************/
392 static bool initiate_name_release_packet( struct packet_struct *packet,
393 uint16 nb_flags, struct in_addr *release_ip)
395 struct nmb_packet *nmb = &packet->packet.nmb;
397 nmb->header.opcode = NMB_NAME_RELEASE_OPCODE;
398 nmb->header.arcount = 1;
400 nmb->header.nm_flags.recursion_desired = False;
402 if(create_and_init_additional_record(packet, nb_flags, release_ip) == False)
405 DEBUG(4,("initiate_name_release_packet: sending release for name %s (bcast=%s) to IP %s\n",
406 nmb_namestr(&nmb->additional->rr_name),
407 BOOLSTR(nmb->header.nm_flags.bcast), inet_ntoa(packet->ip)));
409 return send_netbios_packet( packet );
412 /***************************************************************************
413 Sends out a node status.
414 **************************************************************************/
416 static bool initiate_node_status_packet( struct packet_struct *packet )
418 struct nmb_packet *nmb = &packet->packet.nmb;
420 nmb->header.opcode = NMB_NAME_QUERY_OPCODE;
421 nmb->header.arcount = 0;
423 nmb->header.nm_flags.recursion_desired = False;
425 nmb->question.question_type = QUESTION_TYPE_NB_STATUS;
427 DEBUG(4,("initiate_node_status_packet: sending node status request for name %s to IP %s\n",
428 nmb_namestr(&nmb->question.question_name),
429 inet_ntoa(packet->ip)));
431 return send_netbios_packet( packet );
434 /****************************************************************************
435 Simplification functions for queuing standard packets.
436 These should be the only publicly callable functions for sending
438 ****************************************************************************/
440 /****************************************************************************
441 Assertion - we should never be sending nmbd packets on the remote
443 ****************************************************************************/
445 static bool assert_check_subnet(struct subnet_record *subrec)
447 if( subrec == remote_broadcast_subnet) {
448 DEBUG(0,("assert_check_subnet: Attempt to send packet on remote broadcast subnet. \
455 /****************************************************************************
456 Queue a register name packet to the broadcast address of a subnet.
457 ****************************************************************************/
459 struct response_record *queue_register_name( struct subnet_record *subrec,
460 response_function resp_fn,
461 timeout_response_function timeout_fn,
462 register_name_success_function success_fn,
463 register_name_fail_function fail_fn,
464 struct userdata_struct *userdata,
465 struct nmb_name *nmbname,
468 struct packet_struct *p;
469 struct response_record *rrec;
470 struct sockaddr_storage ss;
471 const struct sockaddr_storage *pss = NULL;
472 if(assert_check_subnet(subrec))
475 /* note that all name registration requests have RD set (rfc1002 - section 4.2.2 */
476 if ((p = create_and_init_netbios_packet(nmbname, (subrec != unicast_subnet), True,
477 subrec->bcast_ip)) == NULL)
480 in_addr_to_sockaddr_storage(&ss, subrec->bcast_ip);
481 pss = iface_ip((struct sockaddr *)&ss);
482 if (!pss || pss->ss_family != AF_INET) {
488 if(initiate_name_register_packet(p, nb_flags,
489 &((const struct sockaddr_in *)pss)->sin_addr) == False) {
495 if((rrec = make_response_record(subrec, /* subnet record. */
496 p, /* packet we sent. */
497 resp_fn, /* function to call on response. */
498 timeout_fn, /* function to call on timeout. */
499 (success_function)success_fn, /* function to call on operation success. */
500 (fail_function)fail_fn, /* function to call on operation fail. */
501 userdata)) == NULL) {
510 /****************************************************************************
511 Queue a refresh name packet to the broadcast address of a subnet.
512 ****************************************************************************/
514 void queue_wins_refresh(struct nmb_name *nmbname,
515 response_function resp_fn,
516 timeout_response_function timeout_fn,
518 struct in_addr refresh_ip,
521 struct packet_struct *p;
522 struct response_record *rrec;
523 struct in_addr wins_ip;
524 struct userdata_struct *userdata;
527 wins_ip = wins_srv_ip_tag(tag, refresh_ip);
529 if ((p = create_and_init_netbios_packet(nmbname, False, False, wins_ip)) == NULL) {
533 if (!initiate_name_refresh_packet(p, nb_flags, &refresh_ip)) {
539 fstrcpy(ip_str, inet_ntoa(refresh_ip));
541 DEBUG(6,("Refreshing name %s IP %s with WINS server %s using tag '%s'\n",
542 nmb_namestr(nmbname), ip_str, inet_ntoa(wins_ip), tag));
544 userdata = (struct userdata_struct *)SMB_MALLOC(sizeof(*userdata) + strlen(tag) + 1);
548 DEBUG(0,("Failed to allocate userdata structure!\n"));
551 ZERO_STRUCTP(userdata);
552 userdata->userdata_len = strlen(tag) + 1;
553 strlcpy(userdata->data, tag, userdata->userdata_len);
555 if ((rrec = make_response_record(unicast_subnet,
560 userdata)) == NULL) {
568 /* we don't want to repeat refresh packets */
569 rrec->repeat_count = 0;
573 /****************************************************************************
574 Queue a multihomed register name packet to a given WINS server IP
575 ****************************************************************************/
577 struct response_record *queue_register_multihomed_name( struct subnet_record *subrec,
578 response_function resp_fn,
579 timeout_response_function timeout_fn,
580 register_name_success_function success_fn,
581 register_name_fail_function fail_fn,
582 struct userdata_struct *userdata,
583 struct nmb_name *nmbname,
585 struct in_addr register_ip,
586 struct in_addr wins_ip)
588 struct packet_struct *p;
589 struct response_record *rrec;
593 if(subrec != unicast_subnet) {
594 DEBUG(0,("queue_register_multihomed_name: should only be done on \
595 unicast subnet. subnet is %s\n.", subrec->subnet_name ));
599 if(assert_check_subnet(subrec))
602 if ((p = create_and_init_netbios_packet(nmbname, False, True, wins_ip)) == NULL)
605 if (nb_flags & NB_GROUP)
606 ret = initiate_name_register_packet( p, nb_flags, ®ister_ip);
608 ret = initiate_multihomed_name_register_packet(p, nb_flags, ®ister_ip);
616 if ((rrec = make_response_record(subrec, /* subnet record. */
617 p, /* packet we sent. */
618 resp_fn, /* function to call on response. */
619 timeout_fn, /* function to call on timeout. */
620 (success_function)success_fn, /* function to call on operation success. */
621 (fail_function)fail_fn, /* function to call on operation fail. */
622 userdata)) == NULL) {
631 /****************************************************************************
632 Queue a release name packet to the broadcast address of a subnet.
633 ****************************************************************************/
635 struct response_record *queue_release_name( struct subnet_record *subrec,
636 response_function resp_fn,
637 timeout_response_function timeout_fn,
638 release_name_success_function success_fn,
639 release_name_fail_function fail_fn,
640 struct userdata_struct *userdata,
641 struct nmb_name *nmbname,
643 struct in_addr release_ip,
644 struct in_addr dest_ip)
646 struct packet_struct *p;
647 struct response_record *rrec;
649 if(assert_check_subnet(subrec))
652 if ((p = create_and_init_netbios_packet(nmbname, (subrec != unicast_subnet), False, dest_ip)) == NULL)
655 if(initiate_name_release_packet( p, nb_flags, &release_ip) == False) {
661 if((rrec = make_response_record(subrec, /* subnet record. */
662 p, /* packet we sent. */
663 resp_fn, /* function to call on response. */
664 timeout_fn, /* function to call on timeout. */
665 (success_function)success_fn, /* function to call on operation success. */
666 (fail_function)fail_fn, /* function to call on operation fail. */
667 userdata)) == NULL) {
674 * For a broadcast release packet, only send once.
675 * This will cause us to remove the name asap. JRA.
678 if (subrec != unicast_subnet) {
679 rrec->repeat_count = 0;
680 rrec->repeat_time = 0;
686 /****************************************************************************
687 Queue a query name packet to the broadcast address of a subnet.
688 ****************************************************************************/
690 struct response_record *queue_query_name( struct subnet_record *subrec,
691 response_function resp_fn,
692 timeout_response_function timeout_fn,
693 query_name_success_function success_fn,
694 query_name_fail_function fail_fn,
695 struct userdata_struct *userdata,
696 struct nmb_name *nmbname)
698 struct packet_struct *p;
699 struct response_record *rrec;
700 struct in_addr to_ip;
702 if(assert_check_subnet(subrec))
705 to_ip = subrec->bcast_ip;
707 /* queries to the WINS server turn up here as queries to IP 0.0.0.0
708 These need to be handled a bit differently */
709 if (subrec->type == UNICAST_SUBNET && is_zero_ip_v4(to_ip)) {
710 /* What we really need to do is loop over each of our wins
711 * servers and wins server tags here, but that just doesn't
712 * fit our architecture at the moment (userdata may already
713 * be used when we get here). For now we just query the first
714 * active wins server on the first tag.
716 char **tags = wins_srv_tags();
720 to_ip = wins_srv_ip_tag(tags[0], to_ip);
721 wins_srv_tags_free(tags);
724 if(( p = create_and_init_netbios_packet(nmbname,
725 (subrec != unicast_subnet),
726 (subrec == unicast_subnet),
730 if(lp_bind_interfaces_only()) {
733 DEBUG(10,("queue_query_name: bind_interfaces_only is set, looking for suitable source IP\n"));
734 for(i = 0; i < iface_count(); i++) {
735 const struct in_addr *ifip = iface_n_ip_v4(i);
738 DEBUG(0,("queue_query_name: interface %d has NULL IP address !\n", i));
742 if (is_loopback_ip_v4(*ifip)) {
743 DEBUG(5,("queue_query_name: ignoring loopback interface (%d)\n", i));
747 DEBUG(10,("queue_query_name: using source IP %s\n",inet_ntoa(*ifip)));
748 p->send_fd = find_subnet_fd_for_address( *ifip );
753 if(initiate_name_query_packet( p ) == False) {
759 if((rrec = make_response_record(subrec, /* subnet record. */
760 p, /* packet we sent. */
761 resp_fn, /* function to call on response. */
762 timeout_fn, /* function to call on timeout. */
763 (success_function)success_fn, /* function to call on operation success. */
764 (fail_function)fail_fn, /* function to call on operation fail. */
765 userdata)) == NULL) {
774 /****************************************************************************
775 Queue a query name packet to a given address from the WINS subnet.
776 ****************************************************************************/
778 struct response_record *queue_query_name_from_wins_server( struct in_addr to_ip,
779 response_function resp_fn,
780 timeout_response_function timeout_fn,
781 query_name_success_function success_fn,
782 query_name_fail_function fail_fn,
783 struct userdata_struct *userdata,
784 struct nmb_name *nmbname)
786 struct packet_struct *p;
787 struct response_record *rrec;
789 if ((p = create_and_init_netbios_packet(nmbname, False, False, to_ip)) == NULL)
792 if(initiate_name_query_packet_from_wins_server( p ) == False) {
798 if((rrec = make_response_record(wins_server_subnet, /* subnet record. */
799 p, /* packet we sent. */
800 resp_fn, /* function to call on response. */
801 timeout_fn, /* function to call on timeout. */
802 (success_function)success_fn, /* function to call on operation success. */
803 (fail_function)fail_fn, /* function to call on operation fail. */
804 userdata)) == NULL) {
813 /****************************************************************************
814 Queue a node status packet to a given name and address.
815 ****************************************************************************/
817 struct response_record *queue_node_status( struct subnet_record *subrec,
818 response_function resp_fn,
819 timeout_response_function timeout_fn,
820 node_status_success_function success_fn,
821 node_status_fail_function fail_fn,
822 struct userdata_struct *userdata,
823 struct nmb_name *nmbname,
824 struct in_addr send_ip)
826 struct packet_struct *p;
827 struct response_record *rrec;
830 if(subrec != unicast_subnet) {
831 DEBUG(0,("queue_register_multihomed_name: should only be done on \
832 unicast subnet. subnet is %s\n.", subrec->subnet_name ));
836 if(assert_check_subnet(subrec))
839 if(( p = create_and_init_netbios_packet(nmbname, False, False, send_ip)) == NULL)
842 if(initiate_node_status_packet(p) == False) {
848 if((rrec = make_response_record(subrec, /* subnet record. */
849 p, /* packet we sent. */
850 resp_fn, /* function to call on response. */
851 timeout_fn, /* function to call on timeout. */
852 (success_function)success_fn, /* function to call on operation success. */
853 (fail_function)fail_fn, /* function to call on operation fail. */
854 userdata)) == NULL) {
863 /****************************************************************************
864 Reply to a netbios name packet. see rfc1002.txt
865 ****************************************************************************/
867 void reply_netbios_packet(struct packet_struct *orig_packet,
868 int rcode, enum netbios_reply_type_code rcv_code, int opcode,
869 int ttl, char *data,int len)
871 struct packet_struct packet;
872 struct nmb_packet *nmb = NULL;
873 struct res_rec answers;
874 struct nmb_packet *orig_nmb = &orig_packet->packet.nmb;
875 bool loopback_this_packet = False;
876 int rr_type = RR_TYPE_NB;
877 const char *packet_type = "unknown";
879 /* Check if we are sending to or from ourselves. */
880 if(ismyip_v4(orig_packet->ip) && (orig_packet->port == global_nmb_port))
881 loopback_this_packet = True;
883 nmb = &packet.packet.nmb;
885 /* Do a partial copy of the packet. We clear the locked flag and
886 the resource record pointers. */
887 packet = *orig_packet; /* Full structure copy. */
888 packet.locked = False;
891 nmb->additional = NULL;
895 packet_type = "nmb_status";
896 nmb->header.nm_flags.recursion_desired = False;
897 nmb->header.nm_flags.recursion_available = False;
898 rr_type = RR_TYPE_NBSTAT;
901 packet_type = "nmb_query";
902 nmb->header.nm_flags.recursion_desired = True;
903 nmb->header.nm_flags.recursion_available = True;
905 rr_type = RR_TYPE_NULL;
909 case NMB_REG_REFRESH:
910 packet_type = "nmb_reg";
911 nmb->header.nm_flags.recursion_desired = True;
912 nmb->header.nm_flags.recursion_available = True;
915 packet_type = "nmb_rel";
916 nmb->header.nm_flags.recursion_desired = False;
917 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;
923 rr_type = RR_TYPE_NULL;
926 packet_type = "wins_reg";
927 nmb->header.nm_flags.recursion_desired = True;
928 nmb->header.nm_flags.recursion_available = True;
931 packet_type = "wins_query";
932 nmb->header.nm_flags.recursion_desired = True;
933 nmb->header.nm_flags.recursion_available = True;
935 rr_type = RR_TYPE_NULL;
939 DEBUG(0,("reply_netbios_packet: Unknown packet type: %s %s to ip %s\n",
940 packet_type, nmb_namestr(&orig_nmb->question.question_name),
941 inet_ntoa(packet.ip)));
945 DEBUG(4,("reply_netbios_packet: sending a reply of packet type: %s %s to ip %s \
946 for id %hu\n", packet_type, nmb_namestr(&orig_nmb->question.question_name),
947 inet_ntoa(packet.ip), orig_nmb->header.name_trn_id));
949 nmb->header.name_trn_id = orig_nmb->header.name_trn_id;
950 nmb->header.opcode = opcode;
951 nmb->header.response = True;
952 nmb->header.nm_flags.bcast = False;
953 nmb->header.nm_flags.trunc = False;
954 nmb->header.nm_flags.authoritative = True;
956 nmb->header.rcode = rcode;
957 nmb->header.qdcount = 0;
958 nmb->header.ancount = 1;
959 nmb->header.nscount = 0;
960 nmb->header.arcount = 0;
962 memset((char*)&nmb->question,'\0',sizeof(nmb->question));
964 nmb->answers = &answers;
965 memset((char*)nmb->answers,'\0',sizeof(*nmb->answers));
967 nmb->answers->rr_name = orig_nmb->question.question_name;
968 nmb->answers->rr_type = rr_type;
969 nmb->answers->rr_class = RR_CLASS_IN;
970 nmb->answers->ttl = ttl;
973 if (len < 0 || len > sizeof(nmb->answers->rdata)) {
974 DEBUG(5,("reply_netbios_packet: "
975 "invalid packet len (%d)\n",
979 nmb->answers->rdlength = len;
980 memcpy(nmb->answers->rdata, data, len);
983 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 if (orig_packet->send_fd != -1) {
988 packet.send_fd = orig_packet->send_fd;
990 packet.send_fd = orig_packet->recv_fd;
992 packet.timestamp = time(NULL);
994 debug_nmb_packet(&packet);
996 if(loopback_this_packet) {
997 struct packet_struct *lo_packet;
998 DEBUG(5,("reply_netbios_packet: sending packet to ourselves.\n"));
999 if((lo_packet = copy_packet(&packet)) == NULL)
1001 queue_packet(lo_packet);
1002 } else if (!send_packet(&packet)) {
1003 DEBUG(0,("reply_netbios_packet: send_packet to IP %s port %d failed\n",
1004 inet_ntoa(packet.ip),packet.port));
1008 /*******************************************************************
1009 Queue a packet into a packet queue
1010 ******************************************************************/
1012 void queue_packet(struct packet_struct *packet)
1014 struct packet_struct *p;
1016 if (!packet_queue) {
1017 packet->prev = NULL;
1018 packet->next = NULL;
1019 packet_queue = packet;
1023 /* find the bottom */
1024 for (p=packet_queue;p->next;p=p->next)
1028 packet->next = NULL;
1032 /****************************************************************************
1033 Try and find a matching subnet record for a datagram port 138 packet.
1034 ****************************************************************************/
1036 static struct subnet_record *find_subnet_for_dgram_browse_packet(struct packet_struct *p)
1038 struct subnet_record *subrec;
1040 /* Go through all the broadcast subnets and see if the mask matches. */
1041 for (subrec = FIRST_SUBNET; subrec ; subrec = NEXT_SUBNET_EXCLUDING_UNICAST(subrec)) {
1042 if(same_net_v4(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 ****************************************************************************/
1060 static void process_browse_packet(struct packet_struct *p, char *buf,int len)
1062 struct dgram_packet *dgram = &p->packet.dgram;
1063 int command = CVAL(buf,0);
1064 struct subnet_record *subrec = find_subnet_for_dgram_browse_packet(p);
1068 /* Drop the packet if it's a different NetBIOS scope, or the source is from one of our names. */
1069 pull_ascii(scope, dgram->dest_name.scope, 64, 64, STR_TERMINATE);
1070 if (!strequal(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), scope, global_scope()));
1076 pull_ascii_nstring(src_name, sizeof(src_name), dgram->source_name.name);
1077 if (is_myname(src_name)) {
1078 DEBUG(7,("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)));
1084 case ANN_HostAnnouncement:
1085 debug_browse_data(buf, len);
1086 process_host_announce(subrec, p, buf+1);
1088 case ANN_DomainAnnouncement:
1089 debug_browse_data(buf, len);
1090 process_workgroup_announce(subrec, p, buf+1);
1092 case ANN_LocalMasterAnnouncement:
1093 debug_browse_data(buf, len);
1094 process_local_master_announce(subrec, p, buf+1);
1096 case ANN_AnnouncementRequest:
1097 debug_browse_data(buf, len);
1098 process_announce_request(subrec, p, buf+1);
1101 debug_browse_data(buf, len);
1102 process_election(subrec, p, buf+1);
1104 case ANN_GetBackupListReq:
1105 debug_browse_data(buf, len);
1106 process_get_backup_list_request(subrec, p, buf+1);
1108 case ANN_GetBackupListResp:
1109 debug_browse_data(buf, len);
1110 /* We never send ANN_GetBackupListReq so we should never get these. */
1111 DEBUG(0,("process_browse_packet: Discarding GetBackupListResponse \
1112 packet from %s IP %s\n", nmb_namestr(&dgram->source_name), inet_ntoa(p->ip)));
1114 case ANN_ResetBrowserState:
1115 debug_browse_data(buf, len);
1116 process_reset_browser(subrec, p, buf+1);
1118 case ANN_MasterAnnouncement:
1119 /* Master browser datagrams must be processed on the unicast subnet. */
1120 subrec = unicast_subnet;
1122 debug_browse_data(buf, len);
1123 process_master_browser_announce(subrec, p, buf+1);
1125 case ANN_BecomeBackup:
1127 * We don't currently implement this. Log it just in case.
1129 debug_browse_data(buf, len);
1130 DEBUG(10,("process_browse_packet: On subnet %s ignoring browse packet \
1131 command ANN_BecomeBackup from %s IP %s to %s\n", subrec->subnet_name, nmb_namestr(&dgram->source_name),
1132 inet_ntoa(p->ip), nmb_namestr(&dgram->dest_name)));
1135 debug_browse_data(buf, len);
1136 DEBUG(0,("process_browse_packet: On subnet %s ignoring browse packet \
1137 command code %d from %s IP %s to %s\n", subrec->subnet_name, command, nmb_namestr(&dgram->source_name),
1138 inet_ntoa(p->ip), nmb_namestr(&dgram->dest_name)));
1143 /****************************************************************************
1144 Dispatch a LanMan browse frame from port 138 to the correct processing function.
1145 ****************************************************************************/
1147 static void process_lanman_packet(struct packet_struct *p, char *buf,int len)
1149 struct dgram_packet *dgram = &p->packet.dgram;
1150 int command = SVAL(buf,0);
1151 struct subnet_record *subrec = find_subnet_for_dgram_browse_packet(p);
1155 /* Drop the packet if it's a different NetBIOS scope, or the source is from one of our names. */
1157 pull_ascii(scope, dgram->dest_name.scope, 64, 64, STR_TERMINATE);
1158 if (!strequal(scope, global_scope())) {
1159 DEBUG(7,("process_lanman_packet: Discarding datagram from IP %s. Scope (%s) \
1160 mismatch with our scope (%s).\n", inet_ntoa(p->ip), scope, global_scope()));
1164 pull_ascii_nstring(src_name, sizeof(src_name), dgram->source_name.name);
1165 if (is_myname(src_name)) {
1166 DEBUG(0,("process_lanman_packet: Discarding datagram from IP %s. Source name \
1167 %s is one of our names !\n", inet_ntoa(p->ip), nmb_namestr(&dgram->source_name)));
1172 case ANN_HostAnnouncement:
1173 debug_browse_data(buf, len);
1174 process_lm_host_announce(subrec, p, buf+1, len > 1 ? len-1 : 0);
1176 case ANN_AnnouncementRequest:
1177 process_lm_announce_request(subrec, p, buf+1, len > 1 ? len-1 : 0);
1180 DEBUG(0,("process_lanman_packet: On subnet %s ignoring browse packet \
1181 command code %d from %s IP %s to %s\n", subrec->subnet_name, command, nmb_namestr(&dgram->source_name),
1182 inet_ntoa(p->ip), nmb_namestr(&dgram->dest_name)));
1187 /****************************************************************************
1188 Determine if a packet is for us on port 138. Note that to have any chance of
1189 being efficient we need to drop as many packets as possible at this
1190 stage as subsequent processing is expensive.
1191 ****************************************************************************/
1193 static bool listening(struct packet_struct *p,struct nmb_name *nbname)
1195 struct subnet_record *subrec = NULL;
1197 for (subrec = FIRST_SUBNET; subrec ; subrec = NEXT_SUBNET_EXCLUDING_UNICAST(subrec)) {
1198 if(same_net_v4(p->ip, subrec->bcast_ip, subrec->mask_ip))
1203 subrec = unicast_subnet;
1205 return (find_name_on_subnet(subrec, nbname, FIND_SELF_NAME) != NULL);
1208 /****************************************************************************
1209 Process udp 138 datagrams
1210 ****************************************************************************/
1212 static void process_dgram(struct packet_struct *p)
1217 struct dgram_packet *dgram = &p->packet.dgram;
1219 /* If we aren't listening to the destination name then ignore the packet */
1220 if (!listening(p,&dgram->dest_name)) {
1221 unexpected_packet(p);
1222 DEBUG(5,("process_dgram: ignoring dgram packet sent to name %s from %s\n",
1223 nmb_namestr(&dgram->dest_name), inet_ntoa(p->ip)));
1227 if (dgram->header.msg_type != 0x10 && dgram->header.msg_type != 0x11 && dgram->header.msg_type != 0x12) {
1228 unexpected_packet(p);
1229 /* Don't process error packets etc yet */
1230 DEBUG(5,("process_dgram: ignoring dgram packet sent to name %s from IP %s as it is \
1231 an error packet of type %x\n", nmb_namestr(&dgram->dest_name), inet_ntoa(p->ip), dgram->header.msg_type));
1235 /* Ensure we have a large enough packet before looking inside. */
1236 if (dgram->datasize < (smb_vwv12 - 2)) {
1237 /* That's the offset minus the 4 byte length + 2 bytes of offset. */
1238 DEBUG(0,("process_dgram: ignoring too short dgram packet (%u) sent to name %s from IP %s\n",
1239 (unsigned int)dgram->datasize,
1240 nmb_namestr(&dgram->dest_name),
1241 inet_ntoa(p->ip) ));
1245 buf = &dgram->data[0];
1246 buf -= 4; /* XXXX for the pseudo tcp length - someday I need to get rid of this */
1248 if (CVAL(buf,smb_com) != SMBtrans)
1251 len = SVAL(buf,smb_vwv11);
1252 buf2 = smb_base(buf) + SVAL(buf,smb_vwv12);
1254 if (len <= 0 || len > dgram->datasize) {
1255 DEBUG(0,("process_dgram: ignoring malformed1 (datasize = %d, len = %d) datagram \
1256 packet sent to name %s from IP %s\n",
1259 nmb_namestr(&dgram->dest_name),
1260 inet_ntoa(p->ip) ));
1264 if (buf2 < dgram->data || (buf2 >= dgram->data + dgram->datasize)) {
1265 DEBUG(0,("process_dgram: ignoring malformed2 (datasize = %d, len=%d, off=%d) datagram \
1266 packet sent to name %s from IP %s\n",
1269 (int)PTR_DIFF(buf2, dgram->data),
1270 nmb_namestr(&dgram->dest_name),
1271 inet_ntoa(p->ip) ));
1275 if ((buf2 + len < dgram->data) || (buf2 + len > dgram->data + dgram->datasize)) {
1276 DEBUG(0,("process_dgram: ignoring malformed3 (datasize = %d, len=%d, off=%d) datagram \
1277 packet sent to name %s from IP %s\n",
1280 (int)PTR_DIFF(buf2, dgram->data),
1281 nmb_namestr(&dgram->dest_name),
1282 inet_ntoa(p->ip) ));
1286 DEBUG(4,("process_dgram: datagram from %s to %s IP %s for %s of type %d len=%d\n",
1287 nmb_namestr(&dgram->source_name),nmb_namestr(&dgram->dest_name),
1288 inet_ntoa(p->ip), smb_buf(buf),CVAL(buf2,0),len));
1290 /* Datagram packet received for the browser mailslot */
1291 if (strequal(smb_buf(buf),BROWSE_MAILSLOT)) {
1292 process_browse_packet(p,buf2,len);
1296 /* Datagram packet received for the LAN Manager mailslot */
1297 if (strequal(smb_buf(buf),LANMAN_MAILSLOT)) {
1298 process_lanman_packet(p,buf2,len);
1302 /* Datagram packet received for the domain logon mailslot */
1303 if (strequal(smb_buf(buf),NET_LOGON_MAILSLOT)) {
1304 process_logon_packet(p,buf2,len,NET_LOGON_MAILSLOT);
1308 /* Datagram packet received for the NT domain logon mailslot */
1309 if (strequal(smb_buf(buf),NT_LOGON_MAILSLOT)) {
1310 process_logon_packet(p,buf2,len,NT_LOGON_MAILSLOT);
1314 unexpected_packet(p);
1317 /****************************************************************************
1318 Validate a response nmb packet.
1319 ****************************************************************************/
1321 static bool validate_nmb_response_packet( struct nmb_packet *nmb )
1323 bool ignore = False;
1325 switch (nmb->header.opcode) {
1326 case NMB_NAME_REG_OPCODE:
1327 case NMB_NAME_REFRESH_OPCODE_8: /* ambiguity in rfc1002 about which is correct. */
1328 case NMB_NAME_REFRESH_OPCODE_9: /* WinNT uses 8 by default. */
1329 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)) {
1337 DEBUG(0,("validate_nmb_response_packet: Bad QUERY Packet. "));
1342 case NMB_NAME_RELEASE_OPCODE:
1343 if (nmb->header.ancount == 0) {
1344 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) {
1352 DEBUG(0,("validate_nmb_response_packet: Bad WACK Packet. "));
1357 DEBUG(0,("validate_nmb_response_packet: Ignoring packet with unknown opcode %d.\n",
1358 nmb->header.opcode));
1363 DEBUG(0,("Ignoring response packet with opcode %d.\n", nmb->header.opcode));
1368 /****************************************************************************
1369 Validate a request nmb packet.
1370 ****************************************************************************/
1372 static bool validate_nmb_packet( struct nmb_packet *nmb )
1374 bool ignore = False;
1376 switch (nmb->header.opcode) {
1377 case NMB_NAME_REG_OPCODE:
1378 case NMB_NAME_REFRESH_OPCODE_8: /* ambiguity in rfc1002 about which is correct. */
1379 case NMB_NAME_REFRESH_OPCODE_9: /* WinNT uses 8 by default. */
1380 case NMB_NAME_MULTIHOMED_REG_OPCODE:
1381 if (nmb->header.qdcount==0 || nmb->header.arcount==0) {
1382 DEBUG(0,("validate_nmb_packet: Bad REG/REFRESH Packet. "));
1387 case NMB_NAME_QUERY_OPCODE:
1388 if ((nmb->header.qdcount == 0) || ((nmb->question.question_type != QUESTION_TYPE_NB_QUERY) &&
1389 (nmb->question.question_type != QUESTION_TYPE_NB_STATUS))) {
1390 DEBUG(0,("validate_nmb_packet: Bad QUERY Packet. "));
1395 case NMB_NAME_RELEASE_OPCODE:
1396 if (nmb->header.qdcount==0 || nmb->header.arcount==0) {
1397 DEBUG(0,("validate_nmb_packet: Bad RELEASE Packet. "));
1402 DEBUG(0,("validate_nmb_packet: Ignoring packet with unknown opcode %d.\n",
1403 nmb->header.opcode));
1408 DEBUG(0,("validate_nmb_packet: Ignoring request packet with opcode %d.\n", nmb->header.opcode));
1413 /****************************************************************************
1414 Find a subnet (and potentially a response record) for a packet.
1415 ****************************************************************************/
1417 static struct subnet_record *find_subnet_for_nmb_packet( struct packet_struct *p,
1418 struct response_record **pprrec)
1420 struct nmb_packet *nmb = &p->packet.nmb;
1421 struct response_record *rrec = NULL;
1422 struct subnet_record *subrec = NULL;
1427 if(nmb->header.response) {
1428 /* It's a response packet. Find a record for it or it's an error. */
1430 rrec = find_response_record( &subrec, nmb->header.name_trn_id);
1432 DEBUG(3,("find_subnet_for_nmb_packet: response record not found for response id %hu\n",
1433 nmb->header.name_trn_id));
1434 unexpected_packet(p);
1438 if(subrec == NULL) {
1439 DEBUG(0,("find_subnet_for_nmb_packet: subnet record not found for response id %hu\n",
1440 nmb->header.name_trn_id));
1449 /* Try and see what subnet this packet belongs to. */
1452 if(packet_is_for_wins_server(p))
1453 return wins_server_subnet;
1455 /* If it wasn't a broadcast packet then send to the UNICAST subnet. */
1456 if(nmb->header.nm_flags.bcast == False)
1457 return unicast_subnet;
1459 /* Go through all the broadcast subnets and see if the mask matches. */
1460 for (subrec = FIRST_SUBNET; subrec ; subrec = NEXT_SUBNET_EXCLUDING_UNICAST(subrec)) {
1461 if(same_net_v4(p->ip, subrec->bcast_ip, subrec->mask_ip))
1465 /* If none match it must have been a directed broadcast - assign the remote_broadcast_subnet. */
1466 return remote_broadcast_subnet;
1469 /****************************************************************************
1470 Process a nmb request packet - validate the packet and route it.
1471 ****************************************************************************/
1473 static void process_nmb_request(struct packet_struct *p)
1475 struct nmb_packet *nmb = &p->packet.nmb;
1476 struct subnet_record *subrec = NULL;
1478 debug_nmb_packet(p);
1480 /* Ensure we have a good packet. */
1481 if(validate_nmb_packet(nmb))
1484 /* Allocate a subnet to this packet - if we cannot - fail. */
1485 if((subrec = find_subnet_for_nmb_packet(p, NULL))==NULL)
1488 switch (nmb->header.opcode) {
1489 case NMB_NAME_REG_OPCODE:
1490 if(subrec == wins_server_subnet)
1491 wins_process_name_registration_request(subrec, p);
1493 process_name_registration_request(subrec, p);
1496 case NMB_NAME_REFRESH_OPCODE_8: /* ambiguity in rfc1002 about which is correct. */
1497 case NMB_NAME_REFRESH_OPCODE_9:
1498 if(subrec == wins_server_subnet)
1499 wins_process_name_refresh_request(subrec, p);
1501 process_name_refresh_request(subrec, p);
1504 case NMB_NAME_MULTIHOMED_REG_OPCODE:
1505 if(subrec == wins_server_subnet) {
1506 wins_process_multihomed_name_registration_request(subrec, p);
1508 DEBUG(0,("process_nmb_request: Multihomed registration request must be \
1509 directed at a WINS server.\n"));
1513 case NMB_NAME_QUERY_OPCODE:
1514 switch (nmb->question.question_type) {
1515 case QUESTION_TYPE_NB_QUERY:
1516 if(subrec == wins_server_subnet)
1517 wins_process_name_query_request(subrec, p);
1519 process_name_query_request(subrec, p);
1521 case QUESTION_TYPE_NB_STATUS:
1522 if(subrec == wins_server_subnet) {
1523 DEBUG(0,("process_nmb_request: NB_STATUS request directed at WINS server is \
1527 process_node_status_request(subrec, p);
1533 case NMB_NAME_RELEASE_OPCODE:
1534 if(subrec == wins_server_subnet)
1535 wins_process_name_release_request(subrec, p);
1537 process_name_release_request(subrec, p);
1542 /****************************************************************************
1543 Process a nmb response packet - validate the packet and route it.
1544 to either the WINS server or a normal response.
1545 ****************************************************************************/
1547 static void process_nmb_response(struct packet_struct *p)
1549 struct nmb_packet *nmb = &p->packet.nmb;
1550 struct subnet_record *subrec = NULL;
1551 struct response_record *rrec = NULL;
1553 debug_nmb_packet(p);
1555 if(validate_nmb_response_packet(nmb))
1558 if((subrec = find_subnet_for_nmb_packet(p, &rrec))==NULL)
1562 DEBUG(0,("process_nmb_response: response packet received but no response record \
1563 found for id = %hu. Ignoring packet.\n", nmb->header.name_trn_id));
1567 /* Increment the number of responses received for this record. */
1569 /* Ensure we don't re-send the request. */
1570 rrec->repeat_count = 0;
1572 /* Call the response received function for this packet. */
1573 (*rrec->resp_fn)(subrec, rrec, p);
1576 /*******************************************************************
1577 Run elements off the packet queue till its empty
1578 ******************************************************************/
1580 void run_packet_queue(void)
1582 struct packet_struct *p;
1584 while ((p = packet_queue)) {
1585 packet_queue = p->next;
1587 packet_queue->prev = NULL;
1588 p->next = p->prev = NULL;
1590 switch (p->packet_type) {
1592 if(p->packet.nmb.header.response)
1593 process_nmb_response(p);
1595 process_nmb_request(p);
1606 /*******************************************************************
1607 Retransmit or timeout elements from all the outgoing subnet response
1608 record queues. NOTE that this code must also check the WINS server
1609 subnet for response records to timeout as the WINS server code
1610 can send requests to check if a client still owns a name.
1611 (Patch from Andrey Alekseyev <fetch@muffin.arcadia.spb.ru>).
1612 ******************************************************************/
1614 void retransmit_or_expire_response_records(time_t t)
1616 struct subnet_record *subrec;
1618 for (subrec = FIRST_SUBNET; subrec; subrec = get_next_subnet_maybe_unicast_or_wins_server(subrec)) {
1619 struct response_record *rrec, *nextrrec;
1623 for (rrec = subrec->responselist; rrec; rrec = nextrrec) {
1624 nextrrec = rrec->next;
1626 if (rrec->repeat_time <= t) {
1627 if (rrec->repeat_count > 0) {
1628 /* Resend while we have a non-zero repeat_count. */
1629 if(!send_packet(rrec->packet)) {
1630 DEBUG(0,("retransmit_or_expire_response_records: Failed to resend packet id %hu \
1631 to IP %s on subnet %s\n", rrec->response_id, inet_ntoa(rrec->packet->ip), subrec->subnet_name));
1633 rrec->repeat_time = t + rrec->repeat_interval;
1634 rrec->repeat_count--;
1636 DEBUG(4,("retransmit_or_expire_response_records: timeout for packet id %hu to IP %s \
1637 on subnet %s\n", rrec->response_id, inet_ntoa(rrec->packet->ip), subrec->subnet_name));
1640 * Check the flag in this record to prevent recursion if we end
1641 * up in this function again via the timeout function call.
1644 if(!rrec->in_expiration_processing) {
1647 * Set the recursion protection flag in this record.
1650 rrec->in_expiration_processing = True;
1652 /* Call the timeout function. This will deal with removing the
1653 timed out packet. */
1654 if(rrec->timeout_fn) {
1655 (*rrec->timeout_fn)(subrec, rrec);
1657 /* We must remove the record ourself if there is
1658 no timeout function. */
1659 remove_response_record(subrec, rrec);
1661 /* We have changed subrec->responselist,
1662 * restart from the beginning of this list. */
1664 } /* !rrec->in_expitation_processing */
1665 } /* rrec->repeat_count > 0 */
1666 } /* rrec->repeat_time <= t */
1667 } /* end for rrec */
1668 } /* end for subnet */
1671 /****************************************************************************
1672 Create an fd_set containing all the sockets in the subnet structures,
1673 plus the broadcast sockets.
1674 ***************************************************************************/
1676 static bool create_listen_fdset(fd_set **ppset, int **psock_array, int *listen_number, int *maxfd)
1678 int *sock_array = NULL;
1679 struct subnet_record *subrec = NULL;
1682 fd_set *pset = SMB_MALLOC_P(fd_set);
1685 DEBUG(0,("create_listen_fdset: malloc fail !\n"));
1689 /* The Client* sockets */
1692 /* Check that we can add all the fd's we need. */
1693 for (subrec = FIRST_SUBNET; subrec; subrec = NEXT_SUBNET_EXCLUDING_UNICAST(subrec))
1696 /* each interface gets 4 sockets */
1699 if(count > FD_SETSIZE) {
1700 DEBUG(0,("create_listen_fdset: Too many file descriptors needed (%d). We can \
1701 only use %d.\n", count, FD_SETSIZE));
1706 if((sock_array = SMB_MALLOC_ARRAY(int, count)) == NULL) {
1707 DEBUG(0,("create_listen_fdset: malloc fail for socket array. size %d\n", count));
1714 /* Add in the lp_socket_address() interface on 137. */
1715 FD_SET(ClientNMB,pset);
1716 sock_array[num++] = ClientNMB;
1717 *maxfd = MAX( *maxfd, ClientNMB);
1719 /* the lp_socket_address() interface has only one socket */
1720 sock_array[num++] = -1;
1722 /* Add in the 137 sockets on all the interfaces. */
1723 for (subrec = FIRST_SUBNET; subrec; subrec = NEXT_SUBNET_EXCLUDING_UNICAST(subrec)) {
1724 FD_SET(subrec->nmb_sock,pset);
1725 sock_array[num++] = subrec->nmb_sock;
1726 *maxfd = MAX( *maxfd, subrec->nmb_sock);
1728 sock_array[num++] = subrec->nmb_bcast;
1729 if (subrec->nmb_bcast != -1) {
1730 FD_SET(subrec->nmb_bcast,pset);
1731 *maxfd = MAX( *maxfd, subrec->nmb_bcast);
1735 /* Add in the lp_socket_address() interface on 138. */
1736 FD_SET(ClientDGRAM,pset);
1737 sock_array[num++] = ClientDGRAM;
1738 *maxfd = MAX( *maxfd, ClientDGRAM);
1740 /* the lp_socket_address() interface has only one socket */
1741 sock_array[num++] = -1;
1743 /* Add in the 138 sockets on all the interfaces. */
1744 for (subrec = FIRST_SUBNET; subrec; subrec = NEXT_SUBNET_EXCLUDING_UNICAST(subrec)) {
1745 FD_SET(subrec->dgram_sock,pset);
1746 sock_array[num++] = subrec->dgram_sock;
1747 *maxfd = MAX( *maxfd, subrec->dgram_sock);
1749 sock_array[num++] = subrec->dgram_bcast;
1750 if (subrec->dgram_bcast != -1) {
1751 FD_SET(subrec->dgram_bcast,pset);
1752 *maxfd = MAX( *maxfd, subrec->dgram_bcast);
1756 *listen_number = count;
1759 SAFE_FREE(*psock_array);
1762 *psock_array = sock_array;
1767 /****************************************************************************
1768 Listens for NMB or DGRAM packets, and queues them.
1769 return True if the socket is dead
1770 ***************************************************************************/
1772 bool listen_for_packets(bool run_election)
1774 static fd_set *listen_set = NULL;
1775 static int listen_number = 0;
1776 static int *sock_array = NULL;
1778 static int maxfd = 0;
1783 struct timeval timeout;
1788 if(listen_set == NULL || rescan_listen_set) {
1789 if(create_listen_fdset(&listen_set, &sock_array, &listen_number, &maxfd)) {
1790 DEBUG(0,("listen_for_packets: Fatal error. unable to create listen set. Exiting.\n"));
1793 rescan_listen_set = False;
1796 memcpy((char *)&r_fds, (char *)listen_set, sizeof(fd_set));
1800 dns_fd = asyncdns_fd();
1802 FD_SET(dns_fd, &r_fds);
1803 maxfd = MAX( maxfd, dns_fd);
1807 /* Process a signal and timer events now... */
1808 if (run_events(nmbd_event_context(), 0, NULL, NULL)) {
1813 * During elections and when expecting a netbios response packet we
1814 * need to send election packets at tighter intervals.
1815 * Ideally it needs to be the interval (in ms) between time now and
1816 * the time we are expecting the next netbios packet.
1819 timeout.tv_sec = (run_election||num_response_packets) ? 1 : NMBD_SELECT_LOOP;
1820 timeout.tv_usec = 0;
1823 struct timeval now = timeval_current();
1824 event_add_to_select_args(nmbd_event_context(), &now,
1825 &r_fds, &w_fds, &timeout, &maxfd);
1828 selrtn = sys_select(maxfd+1,&r_fds,&w_fds,NULL,&timeout);
1830 if (run_events(nmbd_event_context(), selrtn, &r_fds, &w_fds)) {
1839 if (dns_fd != -1 && FD_ISSET(dns_fd,&r_fds)) {
1844 for(i = 0; i < listen_number; i++) {
1845 enum packet_type packet_type;
1846 struct packet_struct *packet;
1847 const char *packet_name;
1851 if (sock_array[i] == -1) {
1855 if (!FD_ISSET(sock_array[i],&r_fds)) {
1859 if (i < (listen_number/2)) {
1861 packet_type = NMB_PACKET;
1862 packet_name = "nmb";
1863 client_fd = ClientNMB;
1864 client_port = global_nmb_port;
1867 packet_type = DGRAM_PACKET;
1868 packet_name = "dgram";
1869 client_fd = ClientDGRAM;
1870 client_port = DGRAM_PORT;
1873 packet = read_packet(sock_array[i], packet_type);
1879 * If we got a packet on the broadcast socket and interfaces
1880 * only is set then check it came from one of our local nets.
1882 if (lp_bind_interfaces_only() &&
1883 (sock_array[i] == client_fd) &&
1884 (!is_local_net_v4(packet->ip))) {
1885 DEBUG(7,("discarding %s packet sent to broadcast socket from %s:%d\n",
1886 packet_name, inet_ntoa(packet->ip), packet->port));
1887 free_packet(packet);
1891 if ((is_loopback_ip_v4(packet->ip) || ismyip_v4(packet->ip)) &&
1892 packet->port == client_port)
1894 if (client_port == DGRAM_PORT) {
1895 DEBUG(7,("discarding own dgram packet from %s:%d\n",
1896 inet_ntoa(packet->ip),packet->port));
1897 free_packet(packet);
1901 if (packet->packet.nmb.header.nm_flags.bcast) {
1902 DEBUG(7,("discarding own nmb bcast packet from %s:%d\n",
1903 inet_ntoa(packet->ip),packet->port));
1904 free_packet(packet);
1910 * 0,2,4,... are unicast sockets
1911 * 1,3,5,... are broadcast sockets
1913 * on broadcast socket we only receive packets
1914 * and send replies via the unicast socket.
1916 * 0,1 and 2,3 and ... belong together.
1919 /* this is a broadcast socket */
1920 packet->send_fd = sock_array[i-1];
1922 /* this is already a unicast socket */
1923 packet->send_fd = sock_array[i];
1926 queue_packet(packet);
1932 /****************************************************************************
1933 Construct and send a netbios DGRAM.
1934 **************************************************************************/
1936 bool send_mailslot(bool unique, const char *mailslot,char *buf, size_t len,
1937 const char *srcname, int src_type,
1938 const char *dstname, int dest_type,
1939 struct in_addr dest_ip,struct in_addr src_ip,
1942 bool loopback_this_packet = False;
1943 struct packet_struct p;
1944 struct dgram_packet *dgram = &p.packet.dgram;
1948 memset((char *)&p,'\0',sizeof(p));
1950 if(ismyip_v4(dest_ip) && (dest_port == DGRAM_PORT)) /* Only if to DGRAM_PORT */
1951 loopback_this_packet = True;
1953 /* generate_name_trn_id(); */ /* Not used, so gone, RJS */
1955 /* DIRECT GROUP or UNIQUE datagram. */
1956 dgram->header.msg_type = unique ? 0x10 : 0x11;
1957 dgram->header.flags.node_type = M_NODE;
1958 dgram->header.flags.first = True;
1959 dgram->header.flags.more = False;
1960 dgram->header.dgm_id = generate_name_trn_id();
1961 dgram->header.source_ip = src_ip;
1962 dgram->header.source_port = DGRAM_PORT;
1963 dgram->header.dgm_length = 0; /* Let build_dgram() handle this. */
1964 dgram->header.packet_offset = 0;
1966 make_nmb_name(&dgram->source_name,srcname,src_type);
1967 make_nmb_name(&dgram->dest_name,dstname,dest_type);
1969 ptr = &dgram->data[0];
1971 /* Setup the smb part. */
1972 ptr -= 4; /* XXX Ugliness because of handling of tcp SMB length. */
1975 if (smb_size + 17*2 + strlen(mailslot) + 1 + len > MAX_DGRAM_SIZE) {
1976 DEBUG(0, ("send_mailslot: Cannot write beyond end of packet\n"));
1980 cli_set_message(ptr,17,strlen(mailslot) + 1 + len,True);
1983 SCVAL(ptr,smb_com,SMBtrans);
1984 SSVAL(ptr,smb_vwv1,len);
1985 SSVAL(ptr,smb_vwv11,len);
1986 SSVAL(ptr,smb_vwv12,70 + strlen(mailslot));
1987 SSVAL(ptr,smb_vwv13,3);
1988 SSVAL(ptr,smb_vwv14,1);
1989 SSVAL(ptr,smb_vwv15,1);
1990 SSVAL(ptr,smb_vwv16,2);
1992 safe_strcpy_base(p2, mailslot, dgram->data, sizeof(dgram->data));
1993 p2 = skip_string(ptr,MAX_DGRAM_SIZE,p2);
1995 if (((p2+len) > dgram->data+sizeof(dgram->data)) || ((p2+len) < p2)) {
1996 DEBUG(0, ("send_mailslot: Cannot write beyond end of packet\n"));
2005 dgram->datasize = PTR_DIFF(p2,ptr+4); /* +4 for tcp length. */
2010 p.send_fd = find_subnet_mailslot_fd_for_address( src_ip );
2011 p.timestamp = time(NULL);
2012 p.packet_type = DGRAM_PACKET;
2014 DEBUG(4,("send_mailslot: Sending to mailslot %s from %s IP %s ", mailslot,
2015 nmb_namestr(&dgram->source_name), inet_ntoa(src_ip)));
2016 DEBUG(4,("to %s IP %s\n", nmb_namestr(&dgram->dest_name), inet_ntoa(dest_ip)));
2018 debug_browse_data(buf, len);
2020 if(loopback_this_packet) {
2021 struct packet_struct *lo_packet = NULL;
2022 DEBUG(5,("send_mailslot: sending packet to ourselves.\n"));
2023 if((lo_packet = copy_packet(&p)) == NULL)
2025 queue_packet(lo_packet);
2028 return(send_packet(&p));