?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
r23784: use the GPLv3 boilerplate as recommended by the FSF and the license text
[Samba/bb.git] / source / nmbd / nmbd_packets.c
blobbaf243cda1fe4337073b849dcbd9cb871e3ffcea
1 /*
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
7
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.
12
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.
17
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/>.
20
21 */
22
23 #include "includes.h"
24
25 extern int ClientNMB;
26 extern int ClientDGRAM;
27 extern int global_nmb_port;
28
29 extern int num_response_packets;
30
31 extern struct in_addr loopback_ip;
32
33 static void queue_packet(struct packet_struct *packet);
34
35 BOOL rescan_listen_set = False;
36
37
38 /*******************************************************************
39 The global packet linked-list. Incoming entries are
40 added to the end of this list. It is supposed to remain fairly
41 short so we won't bother with an end pointer.
42 ******************************************************************/
43
44 static struct packet_struct *packet_queue = NULL;
45
46 /***************************************************************************
47 Utility function to find the specific fd to send a packet out on.
48 **************************************************************************/
49
50 static int find_subnet_fd_for_address( struct in_addr local_ip )
51 {
52 struct subnet_record *subrec;
53
54 for( subrec = FIRST_SUBNET; subrec; subrec = NEXT_SUBNET_EXCLUDING_UNICAST(subrec))
55 if(ip_equal(local_ip, subrec->myip))
56 return subrec->nmb_sock;
57
58 return ClientNMB;
59 }
60
61 /***************************************************************************
62 Utility function to find the specific fd to send a mailslot packet out on.
63 **************************************************************************/
64
65 static int find_subnet_mailslot_fd_for_address( struct in_addr local_ip )
66 {
67 struct subnet_record *subrec;
68
69 for( subrec = FIRST_SUBNET; subrec; subrec = NEXT_SUBNET_EXCLUDING_UNICAST(subrec))
70 if(ip_equal(local_ip, subrec->myip))
71 return subrec->dgram_sock;
72
73 return ClientDGRAM;
74 }
75
76 /***************************************************************************
77 Get/Set problematic nb_flags as network byte order 16 bit int.
78 **************************************************************************/
79
80 uint16 get_nb_flags(char *buf)
81 {
82 return ((((uint16)*buf)&0xFFFF) & NB_FLGMSK);
83 }
84
85 void set_nb_flags(char *buf, uint16 nb_flags)
86 {
87 *buf++ = ((nb_flags & NB_FLGMSK) & 0xFF);
88 *buf = '\0';
89 }
90
91 /***************************************************************************
92 Dumps out the browse packet data.
93 **************************************************************************/
94
95 static void debug_browse_data(char *outbuf, int len)
96 {
97 int i,j;
98
99 DEBUG( 4, ( "debug_browse_data():\n" ) );
100 for (i = 0; i < len; i+= 16) {
101 DEBUGADD( 4, ( "%3x char ", i ) );
102
103 for (j = 0; j < 16; j++) {
104 unsigned char x;
105 if (i+j >= len)
106 break;
107
108 x = outbuf[i+j];
109 if (x < 32 || x > 127)
110 x = '.';
111
112 DEBUGADD( 4, ( "%c", x ) );
113 }
114
115 DEBUGADD( 4, ( "%*s hex", 16-j, "" ) );
116
117 for (j = 0; j < 16; j++) {
118 if (i+j >= len)
119 break;
120 DEBUGADD( 4, ( " %02x", (unsigned char)outbuf[i+j] ) );
121 }
122
123 DEBUGADD( 4, ("\n") );
124 }
125 }
126
127 /***************************************************************************
128 Generates the unique transaction identifier
129 **************************************************************************/
130
131 static uint16 name_trn_id=0;
132
133 static uint16 generate_name_trn_id(void)
134 {
135 if (!name_trn_id) {
136 name_trn_id = ((unsigned)time(NULL)%(unsigned)0x7FFF) + ((unsigned)sys_getpid()%(unsigned)100);
137 }
138 name_trn_id = (name_trn_id+1) % (unsigned)0x7FFF;
139 return name_trn_id;
140 }
141
142 /***************************************************************************
143 Either loops back or sends out a completed NetBIOS packet.
144 **************************************************************************/
145
146 static BOOL send_netbios_packet(struct packet_struct *p)
147 {
148 BOOL loopback_this_packet = False;
149
150 /* Check if we are sending to or from ourselves as a WINS server. */
151 if(ismyip(p->ip) && (p->port == global_nmb_port))
152 loopback_this_packet = True;
153
154 if(loopback_this_packet) {
155 struct packet_struct *lo_packet = NULL;
156 DEBUG(5,("send_netbios_packet: sending packet to ourselves.\n"));
157 if((lo_packet = copy_packet(p)) == NULL)
158 return False;
159 queue_packet(lo_packet);
160 } else if (!send_packet(p)) {
161 DEBUG(0,("send_netbios_packet: send_packet() to IP %s port %d failed\n",
162 inet_ntoa(p->ip),p->port));
163 return False;
164 }
165
166 return True;
167 }
168
169 /***************************************************************************
170 Sets up the common elements of an outgoing NetBIOS packet.
171
172 Note: do not attempt to rationalise whether rec_des should be set or not
173 in a particular situation. Just follow rfc_1002 or look at examples from WinXX.
174 It does NOT follow the rule that requests to the wins server always have
175 rec_des true. See for example name releases and refreshes
176 **************************************************************************/
177
178 static struct packet_struct *create_and_init_netbios_packet(struct nmb_name *nmbname,
179 BOOL bcast, BOOL rec_des,
180 struct in_addr to_ip)
181 {
182 struct packet_struct *packet = NULL;
183 struct nmb_packet *nmb = NULL;
184
185 /* Allocate the packet_struct we will return. */
186 if((packet = SMB_MALLOC_P(struct packet_struct)) == NULL) {
187 DEBUG(0,("create_and_init_netbios_packet: malloc fail (1) for packet struct.\n"));
188 return NULL;
189 }
190
191 memset((char *)packet,'\0',sizeof(*packet));
192
193 nmb = &packet->packet.nmb;
194
195 nmb->header.name_trn_id = generate_name_trn_id();
196 nmb->header.response = False;
197 nmb->header.nm_flags.recursion_desired = rec_des;
198 nmb->header.nm_flags.recursion_available = False;
199 nmb->header.nm_flags.trunc = False;
200 nmb->header.nm_flags.authoritative = False;
201 nmb->header.nm_flags.bcast = bcast;
202
203 nmb->header.rcode = 0;
204 nmb->header.qdcount = 1;
205 nmb->header.ancount = 0;
206 nmb->header.nscount = 0;
207
208 nmb->question.question_name = *nmbname;
209 nmb->question.question_type = QUESTION_TYPE_NB_QUERY;
210 nmb->question.question_class = QUESTION_CLASS_IN;
211
212 packet->ip = to_ip;
213 packet->port = NMB_PORT;
214 packet->fd = ClientNMB;
215 packet->timestamp = time(NULL);
216 packet->packet_type = NMB_PACKET;
217 packet->locked = False;
218
219 return packet; /* Caller must free. */
220 }
221
222 /***************************************************************************
223 Sets up the common elements of register, refresh or release packet.
224 **************************************************************************/
225
226 static BOOL create_and_init_additional_record(struct packet_struct *packet,
227 uint16 nb_flags,
228 struct in_addr *register_ip)
229 {
230 struct nmb_packet *nmb = &packet->packet.nmb;
231
232 if((nmb->additional = SMB_MALLOC_P(struct res_rec)) == NULL) {
233 DEBUG(0,("initiate_name_register_packet: malloc fail for additional record.\n"));
234 return False;
235 }
236
237 memset((char *)nmb->additional,'\0',sizeof(struct res_rec));
238
239 nmb->additional->rr_name = nmb->question.question_name;
240 nmb->additional->rr_type = RR_TYPE_NB;
241 nmb->additional->rr_class = RR_CLASS_IN;
242
243 /* See RFC 1002, sections 5.1.1.1, 5.1.1.2 and 5.1.1.3 */
244 if (nmb->header.nm_flags.bcast)
245 nmb->additional->ttl = PERMANENT_TTL;
246 else
247 nmb->additional->ttl = lp_max_ttl();
248
249 nmb->additional->rdlength = 6;
250
251 set_nb_flags(nmb->additional->rdata,nb_flags);
252
253 /* Set the address for the name we are registering. */
254 putip(&nmb->additional->rdata[2], register_ip);
255
256 /*
257 it turns out that Jeremys code was correct, we are supposed
258 to send registrations from the IP we are registering. The
259 trick is what to do on timeouts! When we send on a
260 non-routable IP then the reply will timeout, and we should
261 treat this as success, not failure. That means we go into
262 our standard refresh cycle for that name which copes nicely
263 with disconnected networks.
264 */
265 packet->fd = find_subnet_fd_for_address(*register_ip);
266
267 return True;
268 }
269
270 /***************************************************************************
271 Sends out a name query.
272 **************************************************************************/
273
274 static BOOL initiate_name_query_packet( struct packet_struct *packet)
275 {
276 struct nmb_packet *nmb = NULL;
277
278 nmb = &packet->packet.nmb;
279
280 nmb->header.opcode = NMB_NAME_QUERY_OPCODE;
281 nmb->header.arcount = 0;
282
283 nmb->header.nm_flags.recursion_desired = True;
284
285 DEBUG(4,("initiate_name_query_packet: sending query for name %s (bcast=%s) to IP %s\n",
286 nmb_namestr(&nmb->question.question_name),
287 BOOLSTR(nmb->header.nm_flags.bcast), inet_ntoa(packet->ip)));
288
289 return send_netbios_packet( packet );
290 }
291
292 /***************************************************************************
293 Sends out a name query - from a WINS server.
294 **************************************************************************/
295
296 static BOOL initiate_name_query_packet_from_wins_server( struct packet_struct *packet)
297 {
298 struct nmb_packet *nmb = NULL;
299
300 nmb = &packet->packet.nmb;
301
302 nmb->header.opcode = NMB_NAME_QUERY_OPCODE;
303 nmb->header.arcount = 0;
304
305 nmb->header.nm_flags.recursion_desired = False;
306
307 DEBUG(4,("initiate_name_query_packet_from_wins_server: sending query for name %s (bcast=%s) to IP %s\n",
308 nmb_namestr(&nmb->question.question_name),
309 BOOLSTR(nmb->header.nm_flags.bcast), inet_ntoa(packet->ip)));
310
311 return send_netbios_packet( packet );
312 }
313
314 /***************************************************************************
315 Sends out a name register.
316 **************************************************************************/
317
318 static BOOL initiate_name_register_packet( struct packet_struct *packet,
319 uint16 nb_flags, struct in_addr *register_ip)
320 {
321 struct nmb_packet *nmb = &packet->packet.nmb;
322
323 nmb->header.opcode = NMB_NAME_REG_OPCODE;
324 nmb->header.arcount = 1;
325
326 nmb->header.nm_flags.recursion_desired = True;
327
328 if(create_and_init_additional_record(packet, nb_flags, register_ip) == False)
329 return False;
330
331 DEBUG(4,("initiate_name_register_packet: sending registration for name %s (bcast=%s) to IP %s\n",
332 nmb_namestr(&nmb->additional->rr_name),
333 BOOLSTR(nmb->header.nm_flags.bcast), inet_ntoa(packet->ip)));
334
335 return send_netbios_packet( packet );
336 }
337
338 /***************************************************************************
339 Sends out a multihomed name register.
340 **************************************************************************/
341
342 static BOOL initiate_multihomed_name_register_packet(struct packet_struct *packet,
343 uint16 nb_flags, struct in_addr *register_ip)
344 {
345 struct nmb_packet *nmb = &packet->packet.nmb;
346 fstring second_ip_buf;
347
348 fstrcpy(second_ip_buf, inet_ntoa(packet->ip));
349
350 nmb->header.opcode = NMB_NAME_MULTIHOMED_REG_OPCODE;
351 nmb->header.arcount = 1;
352
353 nmb->header.nm_flags.recursion_desired = True;
354
355 if(create_and_init_additional_record(packet, nb_flags, register_ip) == False)
356 return False;
357
358 DEBUG(4,("initiate_multihomed_name_register_packet: sending registration \
359 for name %s IP %s (bcast=%s) to IP %s\n",
360 nmb_namestr(&nmb->additional->rr_name), inet_ntoa(*register_ip),
361 BOOLSTR(nmb->header.nm_flags.bcast), second_ip_buf ));
362
363 return send_netbios_packet( packet );
364 }
365
366 /***************************************************************************
367 Sends out a name refresh.
368 **************************************************************************/
369
370 static BOOL initiate_name_refresh_packet( struct packet_struct *packet,
371 uint16 nb_flags, struct in_addr *refresh_ip)
372 {
373 struct nmb_packet *nmb = &packet->packet.nmb;
374
375 nmb->header.opcode = NMB_NAME_REFRESH_OPCODE_8;
376 nmb->header.arcount = 1;
377
378 nmb->header.nm_flags.recursion_desired = False;
379
380 if(create_and_init_additional_record(packet, nb_flags, refresh_ip) == False)
381 return False;
382
383 DEBUG(4,("initiate_name_refresh_packet: sending refresh for name %s (bcast=%s) to IP %s\n",
384 nmb_namestr(&nmb->additional->rr_name),
385 BOOLSTR(nmb->header.nm_flags.bcast), inet_ntoa(packet->ip)));
386
387 return send_netbios_packet( packet );
388 }
389
390 /***************************************************************************
391 Sends out a name release.
392 **************************************************************************/
393
394 static BOOL initiate_name_release_packet( struct packet_struct *packet,
395 uint16 nb_flags, struct in_addr *release_ip)
396 {
397 struct nmb_packet *nmb = &packet->packet.nmb;
398
399 nmb->header.opcode = NMB_NAME_RELEASE_OPCODE;
400 nmb->header.arcount = 1;
401
402 nmb->header.nm_flags.recursion_desired = False;
403
404 if(create_and_init_additional_record(packet, nb_flags, release_ip) == False)
405 return False;
406
407 DEBUG(4,("initiate_name_release_packet: sending release for name %s (bcast=%s) to IP %s\n",
408 nmb_namestr(&nmb->additional->rr_name),
409 BOOLSTR(nmb->header.nm_flags.bcast), inet_ntoa(packet->ip)));
410
411 return send_netbios_packet( packet );
412 }
413
414 /***************************************************************************
415 Sends out a node status.
416 **************************************************************************/
417
418 static BOOL initiate_node_status_packet( struct packet_struct *packet )
419 {
420 struct nmb_packet *nmb = &packet->packet.nmb;
421
422 nmb->header.opcode = NMB_NAME_QUERY_OPCODE;
423 nmb->header.arcount = 0;
424
425 nmb->header.nm_flags.recursion_desired = False;
426
427 nmb->question.question_type = QUESTION_TYPE_NB_STATUS;
428
429 DEBUG(4,("initiate_node_status_packet: sending node status request for name %s to IP %s\n",
430 nmb_namestr(&nmb->question.question_name),
431 inet_ntoa(packet->ip)));
432
433 return send_netbios_packet( packet );
434 }
435
436 /****************************************************************************
437 Simplification functions for queuing standard packets.
438 These should be the only publicly callable functions for sending
439 out packets.
440 ****************************************************************************/
441
442 /****************************************************************************
443 Assertion - we should never be sending nmbd packets on the remote
444 broadcast subnet.
445 ****************************************************************************/
446
447 static BOOL assert_check_subnet(struct subnet_record *subrec)
448 {
449 if( subrec == remote_broadcast_subnet) {
450 DEBUG(0,("assert_check_subnet: Attempt to send packet on remote broadcast subnet. \
451 This is a bug.\n"));
452 return True;
453 }
454 return False;
455 }
456
457 /****************************************************************************
458 Queue a register name packet to the broadcast address of a subnet.
459 ****************************************************************************/
460
461 struct response_record *queue_register_name( struct subnet_record *subrec,
462 response_function resp_fn,
463 timeout_response_function timeout_fn,
464 register_name_success_function success_fn,
465 register_name_fail_function fail_fn,
466 struct userdata_struct *userdata,
467 struct nmb_name *nmbname,
468 uint16 nb_flags)
469 {
470 struct packet_struct *p;
471 struct response_record *rrec;
472
473 if(assert_check_subnet(subrec))
474 return NULL;
475
476 /* note that all name registration requests have RD set (rfc1002 - section 4.2.2 */
477 if ((p = create_and_init_netbios_packet(nmbname, (subrec != unicast_subnet), True,
478 subrec->bcast_ip)) == NULL)
479 return NULL;
480
481 if(initiate_name_register_packet( p, nb_flags, iface_ip(subrec->bcast_ip)) == False) {
482 p->locked = False;
483 free_packet(p);
484 return NULL;
485 }
486
487 if((rrec = make_response_record(subrec, /* subnet record. */
488 p, /* packet we sent. */
489 resp_fn, /* function to call on response. */
490 timeout_fn, /* function to call on timeout. */
491 (success_function)success_fn, /* function to call on operation success. */
492 (fail_function)fail_fn, /* function to call on operation fail. */
493 userdata)) == NULL) {
494 p->locked = False;
495 free_packet(p);
496 return NULL;
497 }
498
499 return rrec;
500 }
501
502 /****************************************************************************
503 Queue a refresh name packet to the broadcast address of a subnet.
504 ****************************************************************************/
505
506 void queue_wins_refresh(struct nmb_name *nmbname,
507 response_function resp_fn,
508 timeout_response_function timeout_fn,
509 uint16 nb_flags,
510 struct in_addr refresh_ip,
511 const char *tag)
512 {
513 struct packet_struct *p;
514 struct response_record *rrec;
515 struct in_addr wins_ip;
516 struct userdata_struct *userdata;
517 fstring ip_str;
518
519 wins_ip = wins_srv_ip_tag(tag, refresh_ip);
520
521 if ((p = create_and_init_netbios_packet(nmbname, False, False, wins_ip)) == NULL) {
522 return;
523 }
524
525 if (!initiate_name_refresh_packet(p, nb_flags, &refresh_ip)) {
526 p->locked = False;
527 free_packet(p);
528 return;
529 }
530
531 fstrcpy(ip_str, inet_ntoa(refresh_ip));
532
533 DEBUG(6,("Refreshing name %s IP %s with WINS server %s using tag '%s'\n",
534 nmb_namestr(nmbname), ip_str, inet_ntoa(wins_ip), tag));
535
536 userdata = (struct userdata_struct *)SMB_MALLOC(sizeof(*userdata) + strlen(tag) + 1);
537 if (!userdata) {
538 p->locked = False;
539 free_packet(p);
540 DEBUG(0,("Failed to allocate userdata structure!\n"));
541 return;
542 }
543 ZERO_STRUCTP(userdata);
544 userdata->userdata_len = strlen(tag) + 1;
545 strlcpy(userdata->data, tag, userdata->userdata_len);
546
547 if ((rrec = make_response_record(unicast_subnet,
548 p,
549 resp_fn, timeout_fn,
550 NULL,
551 NULL,
552 userdata)) == NULL) {
553 p->locked = False;
554 free_packet(p);
555 return;
556 }
557
558 free(userdata);
559
560 /* we don't want to repeat refresh packets */
561 rrec->repeat_count = 0;
562 }
563
564
565 /****************************************************************************
566 Queue a multihomed register name packet to a given WINS server IP
567 ****************************************************************************/
568
569 struct response_record *queue_register_multihomed_name( struct subnet_record *subrec,
570 response_function resp_fn,
571 timeout_response_function timeout_fn,
572 register_name_success_function success_fn,
573 register_name_fail_function fail_fn,
574 struct userdata_struct *userdata,
575 struct nmb_name *nmbname,
576 uint16 nb_flags,
577 struct in_addr register_ip,
578 struct in_addr wins_ip)
579 {
580 struct packet_struct *p;
581 struct response_record *rrec;
582 BOOL ret;
583
584 /* Sanity check. */
585 if(subrec != unicast_subnet) {
586 DEBUG(0,("queue_register_multihomed_name: should only be done on \
587 unicast subnet. subnet is %s\n.", subrec->subnet_name ));
588 return NULL;
589 }
590
591 if(assert_check_subnet(subrec))
592 return NULL;
593
594 if ((p = create_and_init_netbios_packet(nmbname, False, True, wins_ip)) == NULL)
595 return NULL;
596
597 if (nb_flags & NB_GROUP)
598 ret = initiate_name_register_packet( p, nb_flags, &register_ip);
599 else
600 ret = initiate_multihomed_name_register_packet(p, nb_flags, &register_ip);
601
602 if (ret == False) {
603 p->locked = False;
604 free_packet(p);
605 return NULL;
606 }
607
608 if ((rrec = make_response_record(subrec, /* subnet record. */
609 p, /* packet we sent. */
610 resp_fn, /* function to call on response. */
611 timeout_fn, /* function to call on timeout. */
612 (success_function)success_fn, /* function to call on operation success. */
613 (fail_function)fail_fn, /* function to call on operation fail. */
614 userdata)) == NULL) {
615 p->locked = False;
616 free_packet(p);
617 return NULL;
618 }
619
620 return rrec;
621 }
622
623 /****************************************************************************
624 Queue a release name packet to the broadcast address of a subnet.
625 ****************************************************************************/
626
627 struct response_record *queue_release_name( struct subnet_record *subrec,
628 response_function resp_fn,
629 timeout_response_function timeout_fn,
630 release_name_success_function success_fn,
631 release_name_fail_function fail_fn,
632 struct userdata_struct *userdata,
633 struct nmb_name *nmbname,
634 uint16 nb_flags,
635 struct in_addr release_ip,
636 struct in_addr dest_ip)
637 {
638 struct packet_struct *p;
639 struct response_record *rrec;
640
641 if(assert_check_subnet(subrec))
642 return NULL;
643
644 if ((p = create_and_init_netbios_packet(nmbname, (subrec != unicast_subnet), False, dest_ip)) == NULL)
645 return NULL;
646
647 if(initiate_name_release_packet( p, nb_flags, &release_ip) == False) {
648 p->locked = False;
649 free_packet(p);
650 return NULL;
651 }
652
653 if((rrec = make_response_record(subrec, /* subnet record. */
654 p, /* packet we sent. */
655 resp_fn, /* function to call on response. */
656 timeout_fn, /* function to call on timeout. */
657 (success_function)success_fn, /* function to call on operation success. */
658 (fail_function)fail_fn, /* function to call on operation fail. */
659 userdata)) == NULL) {
660 p->locked = False;
661 free_packet(p);
662 return NULL;
663 }
664
665 /*
666 * For a broadcast release packet, only send once.
667 * This will cause us to remove the name asap. JRA.
668 */
669
670 if (subrec != unicast_subnet) {
671 rrec->repeat_count = 0;
672 rrec->repeat_time = 0;
673 }
674
675 return rrec;
676 }
677
678 /****************************************************************************
679 Queue a query name packet to the broadcast address of a subnet.
680 ****************************************************************************/
681
682 struct response_record *queue_query_name( struct subnet_record *subrec,
683 response_function resp_fn,
684 timeout_response_function timeout_fn,
685 query_name_success_function success_fn,
686 query_name_fail_function fail_fn,
687 struct userdata_struct *userdata,
688 struct nmb_name *nmbname)
689 {
690 struct packet_struct *p;
691 struct response_record *rrec;
692 struct in_addr to_ip;
693
694 if(assert_check_subnet(subrec))
695 return NULL;
696
697 to_ip = subrec->bcast_ip;
698
699 /* queries to the WINS server turn up here as queries to IP 0.0.0.0
700 These need to be handled a bit differently */
701 if (subrec->type == UNICAST_SUBNET && is_zero_ip(to_ip)) {
702 /* What we really need to do is loop over each of our wins
703 * servers and wins server tags here, but that just doesn't
704 * fit our architecture at the moment (userdata may already
705 * be used when we get here). For now we just query the first
706 * active wins server on the first tag.
707 */
708 char **tags = wins_srv_tags();
709 if (!tags) {
710 return NULL;
711 }
712 to_ip = wins_srv_ip_tag(tags[0], to_ip);
713 wins_srv_tags_free(tags);
714 }
715
716 if(( p = create_and_init_netbios_packet(nmbname,
717 (subrec != unicast_subnet),
718 (subrec == unicast_subnet),
719 to_ip)) == NULL)
720 return NULL;
721
722 if(lp_bind_interfaces_only()) {
723 int i;
724
725 DEBUG(10,("queue_query_name: bind_interfaces_only is set, looking for suitable source IP\n"));
726 for(i = 0; i < iface_count(); i++) {
727 struct in_addr *ifip = iface_n_ip(i);
728
729 if(ifip == NULL) {
730 DEBUG(0,("queue_query_name: interface %d has NULL IP address !\n", i));
731 continue;
732 }
733
734 if (ip_equal(*ifip,loopback_ip)) {
735 DEBUG(5,("queue_query_name: ignoring loopback interface (%d)\n", i));
736 continue;
737 }
738
739 DEBUG(10,("queue_query_name: using source IP %s\n",inet_ntoa(*ifip)));
740 p->fd = find_subnet_fd_for_address( *ifip );
741 break;
742 }
743 }
744
745 if(initiate_name_query_packet( p ) == False) {
746 p->locked = False;
747 free_packet(p);
748 return NULL;
749 }
750
751 if((rrec = make_response_record(subrec, /* subnet record. */
752 p, /* packet we sent. */
753 resp_fn, /* function to call on response. */
754 timeout_fn, /* function to call on timeout. */
755 (success_function)success_fn, /* function to call on operation success. */
756 (fail_function)fail_fn, /* function to call on operation fail. */
757 userdata)) == NULL) {
758 p->locked = False;
759 free_packet(p);
760 return NULL;
761 }
762
763 return rrec;
764 }
765
766 /****************************************************************************
767 Queue a query name packet to a given address from the WINS subnet.
768 ****************************************************************************/
769
770 struct response_record *queue_query_name_from_wins_server( struct in_addr to_ip,
771 response_function resp_fn,
772 timeout_response_function timeout_fn,
773 query_name_success_function success_fn,
774 query_name_fail_function fail_fn,
775 struct userdata_struct *userdata,
776 struct nmb_name *nmbname)
777 {
778 struct packet_struct *p;
779 struct response_record *rrec;
780
781 if ((p = create_and_init_netbios_packet(nmbname, False, False, to_ip)) == NULL)
782 return NULL;
783
784 if(initiate_name_query_packet_from_wins_server( p ) == False) {
785 p->locked = False;
786 free_packet(p);
787 return NULL;
788 }
789
790 if((rrec = make_response_record(wins_server_subnet, /* subnet record. */
791 p, /* packet we sent. */
792 resp_fn, /* function to call on response. */
793 timeout_fn, /* function to call on timeout. */
794 (success_function)success_fn, /* function to call on operation success. */
795 (fail_function)fail_fn, /* function to call on operation fail. */
796 userdata)) == NULL) {
797 p->locked = False;
798 free_packet(p);
799 return NULL;
800 }
801
802 return rrec;
803 }
804
805 /****************************************************************************
806 Queue a node status packet to a given name and address.
807 ****************************************************************************/
808
809 struct response_record *queue_node_status( struct subnet_record *subrec,
810 response_function resp_fn,
811 timeout_response_function timeout_fn,
812 node_status_success_function success_fn,
813 node_status_fail_function fail_fn,
814 struct userdata_struct *userdata,
815 struct nmb_name *nmbname,
816 struct in_addr send_ip)
817 {
818 struct packet_struct *p;
819 struct response_record *rrec;
820
821 /* Sanity check. */
822 if(subrec != unicast_subnet) {
823 DEBUG(0,("queue_register_multihomed_name: should only be done on \
824 unicast subnet. subnet is %s\n.", subrec->subnet_name ));
825 return NULL;
826 }
827
828 if(assert_check_subnet(subrec))
829 return NULL;
830
831 if(( p = create_and_init_netbios_packet(nmbname, False, False, send_ip)) == NULL)
832 return NULL;
833
834 if(initiate_node_status_packet(p) == False) {
835 p->locked = False;
836 free_packet(p);
837 return NULL;
838 }
839
840 if((rrec = make_response_record(subrec, /* subnet record. */
841 p, /* packet we sent. */
842 resp_fn, /* function to call on response. */
843 timeout_fn, /* function to call on timeout. */
844 (success_function)success_fn, /* function to call on operation success. */
845 (fail_function)fail_fn, /* function to call on operation fail. */
846 userdata)) == NULL) {
847 p->locked = False;
848 free_packet(p);
849 return NULL;
850 }
851
852 return rrec;
853 }
854
855 /****************************************************************************
856 Reply to a netbios name packet. see rfc1002.txt
857 ****************************************************************************/
858
859 void reply_netbios_packet(struct packet_struct *orig_packet,
860 int rcode, enum netbios_reply_type_code rcv_code, int opcode,
861 int ttl, char *data,int len)
862 {
863 struct packet_struct packet;
864 struct nmb_packet *nmb = NULL;
865 struct res_rec answers;
866 struct nmb_packet *orig_nmb = &orig_packet->packet.nmb;
867 BOOL loopback_this_packet = False;
868 int rr_type = RR_TYPE_NB;
869 const char *packet_type = "unknown";
870
871 /* Check if we are sending to or from ourselves. */
872 if(ismyip(orig_packet->ip) && (orig_packet->port == global_nmb_port))
873 loopback_this_packet = True;
874
875 nmb = &packet.packet.nmb;
876
877 /* Do a partial copy of the packet. We clear the locked flag and
878 the resource record pointers. */
879 packet = *orig_packet; /* Full structure copy. */
880 packet.locked = False;
881 nmb->answers = NULL;
882 nmb->nsrecs = NULL;
883 nmb->additional = NULL;
884
885 switch (rcv_code) {
886 case NMB_STATUS:
887 packet_type = "nmb_status";
888 nmb->header.nm_flags.recursion_desired = False;
889 nmb->header.nm_flags.recursion_available = False;
890 rr_type = RR_TYPE_NBSTAT;
891 break;
892 case NMB_QUERY:
893 packet_type = "nmb_query";
894 nmb->header.nm_flags.recursion_desired = True;
895 nmb->header.nm_flags.recursion_available = True;
896 if (rcode) {
897 rr_type = RR_TYPE_NULL;
898 }
899 break;
900 case NMB_REG:
901 case NMB_REG_REFRESH:
902 packet_type = "nmb_reg";
903 nmb->header.nm_flags.recursion_desired = True;
904 nmb->header.nm_flags.recursion_available = True;
905 break;
906 case NMB_REL:
907 packet_type = "nmb_rel";
908 nmb->header.nm_flags.recursion_desired = False;
909 nmb->header.nm_flags.recursion_available = False;
910 break;
911 case NMB_WAIT_ACK:
912 packet_type = "nmb_wack";
913 nmb->header.nm_flags.recursion_desired = False;
914 nmb->header.nm_flags.recursion_available = False;
915 rr_type = RR_TYPE_NULL;
916 break;
917 case WINS_REG:
918 packet_type = "wins_reg";
919 nmb->header.nm_flags.recursion_desired = True;
920 nmb->header.nm_flags.recursion_available = True;
921 break;
922 case WINS_QUERY:
923 packet_type = "wins_query";
924 nmb->header.nm_flags.recursion_desired = True;
925 nmb->header.nm_flags.recursion_available = True;
926 if (rcode) {
927 rr_type = RR_TYPE_NULL;
928 }
929 break;
930 default:
931 DEBUG(0,("reply_netbios_packet: Unknown packet type: %s %s to ip %s\n",
932 packet_type, nmb_namestr(&orig_nmb->question.question_name),
933 inet_ntoa(packet.ip)));
934 return;
935 }
936
937 DEBUG(4,("reply_netbios_packet: sending a reply of packet type: %s %s to ip %s \
938 for id %hu\n", packet_type, nmb_namestr(&orig_nmb->question.question_name),
939 inet_ntoa(packet.ip), orig_nmb->header.name_trn_id));
940
941 nmb->header.name_trn_id = orig_nmb->header.name_trn_id;
942 nmb->header.opcode = opcode;
943 nmb->header.response = True;
944 nmb->header.nm_flags.bcast = False;
945 nmb->header.nm_flags.trunc = False;
946 nmb->header.nm_flags.authoritative = True;
947
948 nmb->header.rcode = rcode;
949 nmb->header.qdcount = 0;
950 nmb->header.ancount = 1;
951 nmb->header.nscount = 0;
952 nmb->header.arcount = 0;
953
954 memset((char*)&nmb->question,'\0',sizeof(nmb->question));
955
956 nmb->answers = &answers;
957 memset((char*)nmb->answers,'\0',sizeof(*nmb->answers));
958
959 nmb->answers->rr_name = orig_nmb->question.question_name;
960 nmb->answers->rr_type = rr_type;
961 nmb->answers->rr_class = RR_CLASS_IN;
962 nmb->answers->ttl = ttl;
963
964 if (data && len) {
965 nmb->answers->rdlength = len;
966 memcpy(nmb->answers->rdata, data, len);
967 }
968
969 packet.packet_type = NMB_PACKET;
970 /* Ensure we send out on the same fd that the original
971 packet came in on to give the correct source IP address. */
972 packet.fd = orig_packet->fd;
973 packet.timestamp = time(NULL);
974
975 debug_nmb_packet(&packet);
976
977 if(loopback_this_packet) {
978 struct packet_struct *lo_packet;
979 DEBUG(5,("reply_netbios_packet: sending packet to ourselves.\n"));
980 if((lo_packet = copy_packet(&packet)) == NULL)
981 return;
982 queue_packet(lo_packet);
983 } else if (!send_packet(&packet)) {
984 DEBUG(0,("reply_netbios_packet: send_packet to IP %s port %d failed\n",
985 inet_ntoa(packet.ip),packet.port));
986 }
987 }
988
989 /*******************************************************************
990 Queue a packet into a packet queue
991 ******************************************************************/
992
993 static void queue_packet(struct packet_struct *packet)
994 {
995 struct packet_struct *p;
996
997 if (!packet_queue) {
998 packet->prev = NULL;
999 packet->next = NULL;
1000 packet_queue = packet;
1001 return;
1002 }
1003
1004 /* find the bottom */
1005 for (p=packet_queue;p->next;p=p->next)
1006 ;
1007
1008 p->next = packet;
1009 packet->next = NULL;
1010 packet->prev = p;
1011 }
1012
1013 /****************************************************************************
1014 Try and find a matching subnet record for a datagram port 138 packet.
1015 ****************************************************************************/
1016
1017 static struct subnet_record *find_subnet_for_dgram_browse_packet(struct packet_struct *p)
1018 {
1019 struct subnet_record *subrec;
1020
1021 /* Go through all the broadcast subnets and see if the mask matches. */
1022 for (subrec = FIRST_SUBNET; subrec ; subrec = NEXT_SUBNET_EXCLUDING_UNICAST(subrec)) {
1023 if(same_net(p->ip, subrec->bcast_ip, subrec->mask_ip))
1024 return subrec;
1025 }
1026
1027 /* If the subnet record is the remote announce broadcast subnet,
1028 hack it here to be the first subnet. This is really gross and
1029 is needed due to people turning on port 137/138 broadcast
1030 forwarding on their routers. May fire and brimstone rain
1031 down upon them...
1032 */
1033
1034 return FIRST_SUBNET;
1035 }
1036
1037 /****************************************************************************
1038 Dispatch a browse frame from port 138 to the correct processing function.
1039 ****************************************************************************/
1040
1041 static void process_browse_packet(struct packet_struct *p, char *buf,int len)
1042 {
1043 struct dgram_packet *dgram = &p->packet.dgram;
1044 int command = CVAL(buf,0);
1045 struct subnet_record *subrec = find_subnet_for_dgram_browse_packet(p);
1046 char scope[64];
1047 unstring src_name;
1048
1049 /* Drop the packet if it's a different NetBIOS scope, or the source is from one of our names. */
1050 pull_ascii(scope, dgram->dest_name.scope, 64, 64, STR_TERMINATE);
1051 if (!strequal(scope, global_scope())) {
1052 DEBUG(7,("process_browse_packet: Discarding datagram from IP %s. Scope (%s) \
1053 mismatch with our scope (%s).\n", inet_ntoa(p->ip), scope, global_scope()));
1054 return;
1055 }
1056
1057 pull_ascii_nstring(src_name, sizeof(src_name), dgram->source_name.name);
1058 if (is_myname(src_name)) {
1059 DEBUG(0,("process_browse_packet: Discarding datagram from IP %s. Source name \
1060 %s is one of our names !\n", inet_ntoa(p->ip), nmb_namestr(&dgram->source_name)));
1061 return;
1062 }
1063
1064 switch (command) {
1065 case ANN_HostAnnouncement:
1066 debug_browse_data(buf, len);
1067 process_host_announce(subrec, p, buf+1);
1068 break;
1069 case ANN_DomainAnnouncement:
1070 debug_browse_data(buf, len);
1071 process_workgroup_announce(subrec, p, buf+1);
1072 break;
1073 case ANN_LocalMasterAnnouncement:
1074 debug_browse_data(buf, len);
1075 process_local_master_announce(subrec, p, buf+1);
1076 break;
1077 case ANN_AnnouncementRequest:
1078 debug_browse_data(buf, len);
1079 process_announce_request(subrec, p, buf+1);
1080 break;
1081 case ANN_Election:
1082 debug_browse_data(buf, len);
1083 process_election(subrec, p, buf+1);
1084 break;
1085 case ANN_GetBackupListReq:
1086 debug_browse_data(buf, len);
1087 process_get_backup_list_request(subrec, p, buf+1);
1088 break;
1089 case ANN_GetBackupListResp:
1090 debug_browse_data(buf, len);
1091 /* We never send ANN_GetBackupListReq so we should never get these. */
1092 DEBUG(0,("process_browse_packet: Discarding GetBackupListResponse \
1093 packet from %s IP %s\n", nmb_namestr(&dgram->source_name), inet_ntoa(p->ip)));
1094 break;
1095 case ANN_ResetBrowserState:
1096 debug_browse_data(buf, len);
1097 process_reset_browser(subrec, p, buf+1);
1098 break;
1099 case ANN_MasterAnnouncement:
1100 /* Master browser datagrams must be processed on the unicast subnet. */
1101 subrec = unicast_subnet;
1102
1103 debug_browse_data(buf, len);
1104 process_master_browser_announce(subrec, p, buf+1);
1105 break;
1106 case ANN_BecomeBackup:
1107 /*
1108 * We don't currently implement this. Log it just in case.
1109 */
1110 debug_browse_data(buf, len);
1111 DEBUG(10,("process_browse_packet: On subnet %s ignoring browse packet \
1112 command ANN_BecomeBackup from %s IP %s to %s\n", subrec->subnet_name, nmb_namestr(&dgram->source_name),
1113 inet_ntoa(p->ip), nmb_namestr(&dgram->dest_name)));
1114 break;
1115 default:
1116 debug_browse_data(buf, len);
1117 DEBUG(0,("process_browse_packet: On subnet %s ignoring browse packet \
1118 command code %d from %s IP %s to %s\n", subrec->subnet_name, command, nmb_namestr(&dgram->source_name),
1119 inet_ntoa(p->ip), nmb_namestr(&dgram->dest_name)));
1120 break;
1121 }
1122 }
1123
1124 /****************************************************************************
1125 Dispatch a LanMan browse frame from port 138 to the correct processing function.
1126 ****************************************************************************/
1127
1128 static void process_lanman_packet(struct packet_struct *p, char *buf,int len)
1129 {
1130 struct dgram_packet *dgram = &p->packet.dgram;
1131 int command = SVAL(buf,0);
1132 struct subnet_record *subrec = find_subnet_for_dgram_browse_packet(p);
1133 char scope[64];
1134 unstring src_name;
1135
1136 /* Drop the packet if it's a different NetBIOS scope, or the source is from one of our names. */
1137
1138 pull_ascii(scope, dgram->dest_name.scope, 64, 64, STR_TERMINATE);
1139 if (!strequal(scope, global_scope())) {
1140 DEBUG(7,("process_lanman_packet: Discarding datagram from IP %s. Scope (%s) \
1141 mismatch with our scope (%s).\n", inet_ntoa(p->ip), scope, global_scope()));
1142 return;
1143 }
1144
1145 pull_ascii_nstring(src_name, sizeof(src_name), dgram->source_name.name);
1146 if (is_myname(src_name)) {
1147 DEBUG(0,("process_lanman_packet: Discarding datagram from IP %s. Source name \
1148 %s is one of our names !\n", inet_ntoa(p->ip), nmb_namestr(&dgram->source_name)));
1149 return;
1150 }
1151
1152 switch (command) {
1153 case ANN_HostAnnouncement:
1154 debug_browse_data(buf, len);
1155 process_lm_host_announce(subrec, p, buf+1, len > 1 ? len-1 : 0);
1156 break;
1157 case ANN_AnnouncementRequest:
1158 process_lm_announce_request(subrec, p, buf+1, len > 1 ? len-1 : 0);
1159 break;
1160 default:
1161 DEBUG(0,("process_lanman_packet: On subnet %s ignoring browse packet \
1162 command code %d from %s IP %s to %s\n", subrec->subnet_name, command, nmb_namestr(&dgram->source_name),
1163 inet_ntoa(p->ip), nmb_namestr(&dgram->dest_name)));
1164 break;
1165 }
1166 }
1167
1168 /****************************************************************************
1169 Determine if a packet is for us on port 138. Note that to have any chance of
1170 being efficient we need to drop as many packets as possible at this
1171 stage as subsequent processing is expensive.
1172 ****************************************************************************/
1173
1174 static BOOL listening(struct packet_struct *p,struct nmb_name *nbname)
1175 {
1176 struct subnet_record *subrec = NULL;
1177
1178 for (subrec = FIRST_SUBNET; subrec ; subrec = NEXT_SUBNET_EXCLUDING_UNICAST(subrec)) {
1179 if(same_net(p->ip, subrec->bcast_ip, subrec->mask_ip))
1180 break;
1181 }
1182
1183 if(subrec == NULL)
1184 subrec = unicast_subnet;
1185
1186 return (find_name_on_subnet(subrec, nbname, FIND_SELF_NAME) != NULL);
1187 }
1188
1189 /****************************************************************************
1190 Process udp 138 datagrams
1191 ****************************************************************************/
1192
1193 static void process_dgram(struct packet_struct *p)
1194 {
1195 char *buf;
1196 char *buf2;
1197 int len;
1198 struct dgram_packet *dgram = &p->packet.dgram;
1199
1200 /* If we aren't listening to the destination name then ignore the packet */
1201 if (!listening(p,&dgram->dest_name)) {
1202 unexpected_packet(p);
1203 DEBUG(5,("process_dgram: ignoring dgram packet sent to name %s from %s\n",
1204 nmb_namestr(&dgram->dest_name), inet_ntoa(p->ip)));
1205 return;
1206 }
1207
1208 if (dgram->header.msg_type != 0x10 && dgram->header.msg_type != 0x11 && dgram->header.msg_type != 0x12) {
1209 unexpected_packet(p);
1210 /* Don't process error packets etc yet */
1211 DEBUG(5,("process_dgram: ignoring dgram packet sent to name %s from IP %s as it is \
1212 an error packet of type %x\n", nmb_namestr(&dgram->dest_name), inet_ntoa(p->ip), dgram->header.msg_type));
1213 return;
1214 }
1215
1216 /* Ensure we have a large enough packet before looking inside. */
1217 if (dgram->datasize < (smb_vwv12 - 2)) {
1218 /* That's the offset minus the 4 byte length + 2 bytes of offset. */
1219 DEBUG(0,("process_dgram: ignoring too short dgram packet (%u) sent to name %s from IP %s\n",
1220 (unsigned int)dgram->datasize,
1221 nmb_namestr(&dgram->dest_name),
1222 inet_ntoa(p->ip) ));
1223 return;
1224 }
1225
1226 buf = &dgram->data[0];
1227 buf -= 4; /* XXXX for the pseudo tcp length - someday I need to get rid of this */
1228
1229 if (CVAL(buf,smb_com) != SMBtrans)
1230 return;
1231
1232 len = SVAL(buf,smb_vwv11);
1233 buf2 = smb_base(buf) + SVAL(buf,smb_vwv12);
1234
1235 if (len <= 0 || len > dgram->datasize) {
1236 DEBUG(0,("process_dgram: ignoring malformed1 (datasize = %d, len = %d) datagram \
1237 packet sent to name %s from IP %s\n",
1238 dgram->datasize,
1239 len,
1240 nmb_namestr(&dgram->dest_name),
1241 inet_ntoa(p->ip) ));
1242 return;
1243 }
1244
1245 if (buf2 < dgram->data || (buf2 >= dgram->data + dgram->datasize)) {
1246 DEBUG(0,("process_dgram: ignoring malformed2 (datasize = %d, len=%d, off=%d) datagram \
1247 packet sent to name %s from IP %s\n",
1248 dgram->datasize,
1249 len,
1250 (int)PTR_DIFF(buf2, dgram->data),
1251 nmb_namestr(&dgram->dest_name),
1252 inet_ntoa(p->ip) ));
1253 return;
1254 }
1255
1256 if ((buf2 + len < dgram->data) || (buf2 + len > dgram->data + dgram->datasize)) {
1257 DEBUG(0,("process_dgram: ignoring malformed3 (datasize = %d, len=%d, off=%d) datagram \
1258 packet sent to name %s from IP %s\n",
1259 dgram->datasize,
1260 len,
1261 (int)PTR_DIFF(buf2, dgram->data),
1262 nmb_namestr(&dgram->dest_name),
1263 inet_ntoa(p->ip) ));
1264 return;
1265 }
1266
1267 DEBUG(4,("process_dgram: datagram from %s to %s IP %s for %s of type %d len=%d\n",
1268 nmb_namestr(&dgram->source_name),nmb_namestr(&dgram->dest_name),
1269 inet_ntoa(p->ip), smb_buf(buf),CVAL(buf2,0),len));
1270
1271 /* Datagram packet received for the browser mailslot */
1272 if (strequal(smb_buf(buf),BROWSE_MAILSLOT)) {
1273 process_browse_packet(p,buf2,len);
1274 return;
1275 }
1276
1277 /* Datagram packet received for the LAN Manager mailslot */
1278 if (strequal(smb_buf(buf),LANMAN_MAILSLOT)) {
1279 process_lanman_packet(p,buf2,len);
1280 return;
1281 }
1282
1283 /* Datagram packet received for the domain logon mailslot */
1284 if (strequal(smb_buf(buf),NET_LOGON_MAILSLOT)) {
1285 process_logon_packet(p,buf2,len,NET_LOGON_MAILSLOT);
1286 return;
1287 }
1288
1289 /* Datagram packet received for the NT domain logon mailslot */
1290 if (strequal(smb_buf(buf),NT_LOGON_MAILSLOT)) {
1291 process_logon_packet(p,buf2,len,NT_LOGON_MAILSLOT);
1292 return;
1293 }
1294
1295 unexpected_packet(p);
1296 }
1297
1298 /****************************************************************************
1299 Validate a response nmb packet.
1300 ****************************************************************************/
1301
1302 static BOOL validate_nmb_response_packet( struct nmb_packet *nmb )
1303 {
1304 BOOL ignore = False;
1305
1306 switch (nmb->header.opcode) {
1307 case NMB_NAME_REG_OPCODE:
1308 case NMB_NAME_REFRESH_OPCODE_8: /* ambiguity in rfc1002 about which is correct. */
1309 case NMB_NAME_REFRESH_OPCODE_9: /* WinNT uses 8 by default. */
1310 if (nmb->header.ancount == 0) {
1311 DEBUG(0,("validate_nmb_response_packet: Bad REG/REFRESH Packet. "));
1312 ignore = True;
1313 }
1314 break;
1315
1316 case NMB_NAME_QUERY_OPCODE:
1317 if ((nmb->header.ancount != 0) && (nmb->header.ancount != 1)) {
1318 DEBUG(0,("validate_nmb_response_packet: Bad QUERY Packet. "));
1319 ignore = True;
1320 }
1321 break;
1322
1323 case NMB_NAME_RELEASE_OPCODE:
1324 if (nmb->header.ancount == 0) {
1325 DEBUG(0,("validate_nmb_response_packet: Bad RELEASE Packet. "));
1326 ignore = True;
1327 }
1328 break;
1329
1330 case NMB_WACK_OPCODE:
1331 /* Check WACK response here. */
1332 if (nmb->header.ancount != 1) {
1333 DEBUG(0,("validate_nmb_response_packet: Bad WACK Packet. "));
1334 ignore = True;
1335 }
1336 break;
1337 default:
1338 DEBUG(0,("validate_nmb_response_packet: Ignoring packet with unknown opcode %d.\n",
1339 nmb->header.opcode));
1340 return True;
1341 }
1342
1343 if(ignore)
1344 DEBUG(0,("Ignoring response packet with opcode %d.\n", nmb->header.opcode));
1345
1346 return ignore;
1347 }
1348
1349 /****************************************************************************
1350 Validate a request nmb packet.
1351 ****************************************************************************/
1352
1353 static BOOL validate_nmb_packet( struct nmb_packet *nmb )
1354 {
1355 BOOL ignore = False;
1356
1357 switch (nmb->header.opcode) {
1358 case NMB_NAME_REG_OPCODE:
1359 case NMB_NAME_REFRESH_OPCODE_8: /* ambiguity in rfc1002 about which is correct. */
1360 case NMB_NAME_REFRESH_OPCODE_9: /* WinNT uses 8 by default. */
1361 case NMB_NAME_MULTIHOMED_REG_OPCODE:
1362 if (nmb->header.qdcount==0 || nmb->header.arcount==0) {
1363 DEBUG(0,("validate_nmb_packet: Bad REG/REFRESH Packet. "));
1364 ignore = True;
1365 }
1366 break;
1367
1368 case NMB_NAME_QUERY_OPCODE:
1369 if ((nmb->header.qdcount == 0) || ((nmb->question.question_type != QUESTION_TYPE_NB_QUERY) &&
1370 (nmb->question.question_type != QUESTION_TYPE_NB_STATUS))) {
1371 DEBUG(0,("validate_nmb_packet: Bad QUERY Packet. "));
1372 ignore = True;
1373 }
1374 break;
1375
1376 case NMB_NAME_RELEASE_OPCODE:
1377 if (nmb->header.qdcount==0 || nmb->header.arcount==0) {
1378 DEBUG(0,("validate_nmb_packet: Bad RELEASE Packet. "));
1379 ignore = True;
1380 }
1381 break;
1382 default:
1383 DEBUG(0,("validate_nmb_packet: Ignoring packet with unknown opcode %d.\n",
1384 nmb->header.opcode));
1385 return True;
1386 }
1387
1388 if(ignore)
1389 DEBUG(0,("validate_nmb_packet: Ignoring request packet with opcode %d.\n", nmb->header.opcode));
1390
1391 return ignore;
1392 }
1393
1394 /****************************************************************************
1395 Find a subnet (and potentially a response record) for a packet.
1396 ****************************************************************************/
1397
1398 static struct subnet_record *find_subnet_for_nmb_packet( struct packet_struct *p,
1399 struct response_record **pprrec)
1400 {
1401 struct nmb_packet *nmb = &p->packet.nmb;
1402 struct response_record *rrec = NULL;
1403 struct subnet_record *subrec = NULL;
1404
1405 if(pprrec != NULL)
1406 *pprrec = NULL;
1407
1408 if(nmb->header.response) {
1409 /* It's a response packet. Find a record for it or it's an error. */
1410
1411 rrec = find_response_record( &subrec, nmb->header.name_trn_id);
1412 if(rrec == NULL) {
1413 DEBUG(3,("find_subnet_for_nmb_packet: response record not found for response id %hu\n",
1414 nmb->header.name_trn_id));
1415 unexpected_packet(p);
1416 return NULL;
1417 }
1418
1419 if(subrec == NULL) {
1420 DEBUG(0,("find_subnet_for_nmb_packet: subnet record not found for response id %hu\n",
1421 nmb->header.name_trn_id));
1422 return NULL;
1423 }
1424
1425 if(pprrec != NULL)
1426 *pprrec = rrec;
1427 return subrec;
1428 }
1429
1430 /* Try and see what subnet this packet belongs to. */
1431
1432 /* WINS server ? */
1433 if(packet_is_for_wins_server(p))
1434 return wins_server_subnet;
1435
1436 /* If it wasn't a broadcast packet then send to the UNICAST subnet. */
1437 if(nmb->header.nm_flags.bcast == False)
1438 return unicast_subnet;
1439
1440 /* Go through all the broadcast subnets and see if the mask matches. */
1441 for (subrec = FIRST_SUBNET; subrec ; subrec = NEXT_SUBNET_EXCLUDING_UNICAST(subrec)) {
1442 if(same_net(p->ip, subrec->bcast_ip, subrec->mask_ip))
1443 return subrec;
1444 }
1445
1446 /* If none match it must have been a directed broadcast - assign the remote_broadcast_subnet. */
1447 return remote_broadcast_subnet;
1448 }
1449
1450 /****************************************************************************
1451 Process a nmb request packet - validate the packet and route it.
1452 ****************************************************************************/
1453
1454 static void process_nmb_request(struct packet_struct *p)
1455 {
1456 struct nmb_packet *nmb = &p->packet.nmb;
1457 struct subnet_record *subrec = NULL;
1458
1459 debug_nmb_packet(p);
1460
1461 /* Ensure we have a good packet. */
1462 if(validate_nmb_packet(nmb))
1463 return;
1464
1465 /* Allocate a subnet to this packet - if we cannot - fail. */
1466 if((subrec = find_subnet_for_nmb_packet(p, NULL))==NULL)
1467 return;
1468
1469 switch (nmb->header.opcode) {
1470 case NMB_NAME_REG_OPCODE:
1471 if(subrec == wins_server_subnet)
1472 wins_process_name_registration_request(subrec, p);
1473 else
1474 process_name_registration_request(subrec, p);
1475 break;
1476
1477 case NMB_NAME_REFRESH_OPCODE_8: /* ambiguity in rfc1002 about which is correct. */
1478 case NMB_NAME_REFRESH_OPCODE_9:
1479 if(subrec == wins_server_subnet)
1480 wins_process_name_refresh_request(subrec, p);
1481 else
1482 process_name_refresh_request(subrec, p);
1483 break;
1484
1485 case NMB_NAME_MULTIHOMED_REG_OPCODE:
1486 if(subrec == wins_server_subnet) {
1487 wins_process_multihomed_name_registration_request(subrec, p);
1488 } else {
1489 DEBUG(0,("process_nmb_request: Multihomed registration request must be \
1490 directed at a WINS server.\n"));
1491 }
1492 break;
1493
1494 case NMB_NAME_QUERY_OPCODE:
1495 switch (nmb->question.question_type) {
1496 case QUESTION_TYPE_NB_QUERY:
1497 if(subrec == wins_server_subnet)
1498 wins_process_name_query_request(subrec, p);
1499 else
1500 process_name_query_request(subrec, p);
1501 break;
1502 case QUESTION_TYPE_NB_STATUS:
1503 if(subrec == wins_server_subnet) {
1504 DEBUG(0,("process_nmb_request: NB_STATUS request directed at WINS server is \
1505 not allowed.\n"));
1506 break;
1507 } else {
1508 process_node_status_request(subrec, p);
1509 }
1510 break;
1511 }
1512 break;
1513
1514 case NMB_NAME_RELEASE_OPCODE:
1515 if(subrec == wins_server_subnet)
1516 wins_process_name_release_request(subrec, p);
1517 else
1518 process_name_release_request(subrec, p);
1519 break;
1520 }
1521 }
1522
1523 /****************************************************************************
1524 Process a nmb response packet - validate the packet and route it.
1525 to either the WINS server or a normal response.
1526 ****************************************************************************/
1527
1528 static void process_nmb_response(struct packet_struct *p)
1529 {
1530 struct nmb_packet *nmb = &p->packet.nmb;
1531 struct subnet_record *subrec = NULL;
1532 struct response_record *rrec = NULL;
1533
1534 debug_nmb_packet(p);
1535
1536 if(validate_nmb_response_packet(nmb))
1537 return;
1538
1539 if((subrec = find_subnet_for_nmb_packet(p, &rrec))==NULL)
1540 return;
1541
1542 if(rrec == NULL) {
1543 DEBUG(0,("process_nmb_response: response packet received but no response record \
1544 found for id = %hu. Ignoring packet.\n", nmb->header.name_trn_id));
1545 return;
1546 }
1547
1548 /* Increment the number of responses received for this record. */
1549 rrec->num_msgs++;
1550 /* Ensure we don't re-send the request. */
1551 rrec->repeat_count = 0;
1552
1553 /* Call the response received function for this packet. */
1554 (*rrec->resp_fn)(subrec, rrec, p);
1555 }
1556
1557 /*******************************************************************
1558 Run elements off the packet queue till its empty
1559 ******************************************************************/
1560
1561 void run_packet_queue(void)
1562 {
1563 struct packet_struct *p;
1564
1565 while ((p = packet_queue)) {
1566 packet_queue = p->next;
1567 if (packet_queue)
1568 packet_queue->prev = NULL;
1569 p->next = p->prev = NULL;
1570
1571 switch (p->packet_type) {
1572 case NMB_PACKET:
1573 if(p->packet.nmb.header.response)
1574 process_nmb_response(p);
1575 else
1576 process_nmb_request(p);
1577 break;
1578
1579 case DGRAM_PACKET:
1580 process_dgram(p);
1581 break;
1582 }
1583 free_packet(p);
1584 }
1585 }
1586
1587 /*******************************************************************
1588 Retransmit or timeout elements from all the outgoing subnet response
1589 record queues. NOTE that this code must also check the WINS server
1590 subnet for response records to timeout as the WINS server code
1591 can send requests to check if a client still owns a name.
1592 (Patch from Andrey Alekseyev <fetch@muffin.arcadia.spb.ru>).
1593 ******************************************************************/
1594
1595 void retransmit_or_expire_response_records(time_t t)
1596 {
1597 struct subnet_record *subrec;
1598
1599 for (subrec = FIRST_SUBNET; subrec; subrec = get_next_subnet_maybe_unicast_or_wins_server(subrec)) {
1600 struct response_record *rrec, *nextrrec;
1601
1602 for (rrec = subrec->responselist; rrec; rrec = nextrrec) {
1603 nextrrec = rrec->next;
1604
1605 if (rrec->repeat_time <= t) {
1606 if (rrec->repeat_count > 0) {
1607 /* Resend while we have a non-zero repeat_count. */
1608 if(!send_packet(rrec->packet)) {
1609 DEBUG(0,("retransmit_or_expire_response_records: Failed to resend packet id %hu \
1610 to IP %s on subnet %s\n", rrec->response_id, inet_ntoa(rrec->packet->ip), subrec->subnet_name));
1611 }
1612 rrec->repeat_time = t + rrec->repeat_interval;
1613 rrec->repeat_count--;
1614 } else {
1615 DEBUG(4,("retransmit_or_expire_response_records: timeout for packet id %hu to IP %s \
1616 on subnet %s\n", rrec->response_id, inet_ntoa(rrec->packet->ip), subrec->subnet_name));
1617
1618 /*
1619 * Check the flag in this record to prevent recursion if we end
1620 * up in this function again via the timeout function call.
1621 */
1622
1623 if(!rrec->in_expiration_processing) {
1624
1625 /*
1626 * Set the recursion protection flag in this record.
1627 */
1628
1629 rrec->in_expiration_processing = True;
1630
1631 /* Call the timeout function. This will deal with removing the
1632 timed out packet. */
1633 if(rrec->timeout_fn) {
1634 (*rrec->timeout_fn)(subrec, rrec);
1635 } else {
1636 /* We must remove the record ourself if there is
1637 no timeout function. */
1638 remove_response_record(subrec, rrec);
1639 }
1640 } /* !rrec->in_expitation_processing */
1641 } /* rrec->repeat_count > 0 */
1642 } /* rrec->repeat_time <= t */
1643 } /* end for rrec */
1644 } /* end for subnet */
1645 }
1646
1647 /****************************************************************************
1648 Create an fd_set containing all the sockets in the subnet structures,
1649 plus the broadcast sockets.
1650 ***************************************************************************/
1651
1652 static BOOL create_listen_fdset(fd_set **ppset, int **psock_array, int *listen_number, int *maxfd)
1653 {
1654 int *sock_array = NULL;
1655 struct subnet_record *subrec = NULL;
1656 int count = 0;
1657 int num = 0;
1658 fd_set *pset = SMB_MALLOC_P(fd_set);
1659
1660 if(pset == NULL) {
1661 DEBUG(0,("create_listen_fdset: malloc fail !\n"));
1662 return True;
1663 }
1664
1665 /* Check that we can add all the fd's we need. */
1666 for (subrec = FIRST_SUBNET; subrec; subrec = NEXT_SUBNET_EXCLUDING_UNICAST(subrec))
1667 count++;
1668
1669 if((count*2) + 2 > FD_SETSIZE) {
1670 DEBUG(0,("create_listen_fdset: Too many file descriptors needed (%d). We can \
1671 only use %d.\n", (count*2) + 2, FD_SETSIZE));
1672 SAFE_FREE(pset);
1673 return True;
1674 }
1675
1676 if((sock_array = SMB_MALLOC_ARRAY(int, (count*2) + 2)) == NULL) {
1677 DEBUG(0,("create_listen_fdset: malloc fail for socket array.\n"));
1678 SAFE_FREE(pset);
1679 return True;
1680 }
1681
1682 FD_ZERO(pset);
1683
1684 /* Add in the broadcast socket on 137. */
1685 FD_SET(ClientNMB,pset);
1686 sock_array[num++] = ClientNMB;
1687 *maxfd = MAX( *maxfd, ClientNMB);
1688
1689 /* Add in the 137 sockets on all the interfaces. */
1690 for (subrec = FIRST_SUBNET; subrec; subrec = NEXT_SUBNET_EXCLUDING_UNICAST(subrec)) {
1691 FD_SET(subrec->nmb_sock,pset);
1692 sock_array[num++] = subrec->nmb_sock;
1693 *maxfd = MAX( *maxfd, subrec->nmb_sock);
1694 }
1695
1696 /* Add in the broadcast socket on 138. */
1697 FD_SET(ClientDGRAM,pset);
1698 sock_array[num++] = ClientDGRAM;
1699 *maxfd = MAX( *maxfd, ClientDGRAM);
1700
1701 /* Add in the 138 sockets on all the interfaces. */
1702 for (subrec = FIRST_SUBNET; subrec; subrec = NEXT_SUBNET_EXCLUDING_UNICAST(subrec)) {
1703 FD_SET(subrec->dgram_sock,pset);
1704 sock_array[num++] = subrec->dgram_sock;
1705 *maxfd = MAX( *maxfd, subrec->dgram_sock);
1706 }
1707
1708 *listen_number = (count*2) + 2;
1709
1710 SAFE_FREE(*ppset);
1711 SAFE_FREE(*psock_array);
1712
1713 *ppset = pset;
1714 *psock_array = sock_array;
1715
1716 return False;
1717 }
1718
1719 /****************************************************************************
1720 Listens for NMB or DGRAM packets, and queues them.
1721 return True if the socket is dead
1722 ***************************************************************************/
1723
1724 BOOL listen_for_packets(BOOL run_election)
1725 {
1726 static fd_set *listen_set = NULL;
1727 static int listen_number = 0;
1728 static int *sock_array = NULL;
1729 int i;
1730 static int maxfd = 0;
1731
1732 fd_set r_fds;
1733 fd_set w_fds;
1734 int selrtn;
1735 struct timeval timeout;
1736 #ifndef SYNC_DNS
1737 int dns_fd;
1738 #endif
1739
1740 if(listen_set == NULL || rescan_listen_set) {
1741 if(create_listen_fdset(&listen_set, &sock_array, &listen_number, &maxfd)) {
1742 DEBUG(0,("listen_for_packets: Fatal error. unable to create listen set. Exiting.\n"));
1743 return True;
1744 }
1745 rescan_listen_set = False;
1746 }
1747
1748 memcpy((char *)&r_fds, (char *)listen_set, sizeof(fd_set));
1749 FD_ZERO(&w_fds);
1750
1751 #ifndef SYNC_DNS
1752 dns_fd = asyncdns_fd();
1753 if (dns_fd != -1) {
1754 FD_SET(dns_fd, &r_fds);
1755 maxfd = MAX( maxfd, dns_fd);
1756 }
1757 #endif
1758
1759 /*
1760 * During elections and when expecting a netbios response packet we
1761 * need to send election packets at tighter intervals.
1762 * Ideally it needs to be the interval (in ms) between time now and
1763 * the time we are expecting the next netbios packet.
1764 */
1765
1766 timeout.tv_sec = (run_election||num_response_packets) ? 1 : NMBD_SELECT_LOOP;
1767 timeout.tv_usec = 0;
1768
1769 {
1770 struct timeval now = timeval_current();
1771 event_add_to_select_args(nmbd_event_context(), &now,
1772 &r_fds, &w_fds, &timeout, &maxfd);
1773 }
1774
1775 if (timeval_is_zero(&timeout)) {
1776 /* Process a timed event now... */
1777 if (run_events(nmbd_event_context(), 0, NULL, NULL)) {
1778 return False;
1779 }
1780 }
1781
1782 /* Prepare for the select - allow certain signals. */
1783
1784 BlockSignals(False, SIGTERM);
1785
1786 selrtn = sys_select(maxfd+1,&r_fds,&w_fds,NULL,&timeout);
1787
1788 /* We can only take signals when we are in the select - block them again here. */
1789
1790 BlockSignals(True, SIGTERM);
1791
1792 if(selrtn == -1) {
1793 return False;
1794 }
1795
1796 if (run_events(nmbd_event_context(), selrtn, &r_fds, &w_fds)) {
1797 return False;
1798 }
1799
1800 #ifndef SYNC_DNS
1801 if (dns_fd != -1 && FD_ISSET(dns_fd,&r_fds)) {
1802 run_dns_queue();
1803 }
1804 #endif
1805
1806 for(i = 0; i < listen_number; i++) {
1807 if (i < (listen_number/2)) {
1808 /* Processing a 137 socket. */
1809 if (FD_ISSET(sock_array[i],&r_fds)) {
1810 struct packet_struct *packet = read_packet(sock_array[i], NMB_PACKET);
1811 if (packet) {
1812 /*
1813 * If we got a packet on the broadcast socket and interfaces
1814 * only is set then check it came from one of our local nets.
1815 */
1816 if(lp_bind_interfaces_only() && (sock_array[i] == ClientNMB) &&
1817 (!is_local_net(packet->ip))) {
1818 DEBUG(7,("discarding nmb packet sent to broadcast socket from %s:%d\n",
1819 inet_ntoa(packet->ip),packet->port));
1820 free_packet(packet);
1821 } else if ((ip_equal(loopback_ip, packet->ip) ||
1822 ismyip(packet->ip)) && packet->port == global_nmb_port &&
1823 packet->packet.nmb.header.nm_flags.bcast) {
1824 DEBUG(7,("discarding own bcast packet from %s:%d\n",
1825 inet_ntoa(packet->ip),packet->port));
1826 free_packet(packet);
1827 } else {
1828 /* Save the file descriptor this packet came in on. */
1829 packet->fd = sock_array[i];
1830 queue_packet(packet);
1831 }
1832 }
1833 }
1834 } else {
1835 /* Processing a 138 socket. */
1836 if (FD_ISSET(sock_array[i],&r_fds)) {
1837 struct packet_struct *packet = read_packet(sock_array[i], DGRAM_PACKET);
1838 if (packet) {
1839 /*
1840 * If we got a packet on the broadcast socket and interfaces
1841 * only is set then check it came from one of our local nets.
1842 */
1843 if(lp_bind_interfaces_only() && (sock_array[i] == ClientDGRAM) &&
1844 (!is_local_net(packet->ip))) {
1845 DEBUG(7,("discarding dgram packet sent to broadcast socket from %s:%d\n",
1846 inet_ntoa(packet->ip),packet->port));
1847 free_packet(packet);
1848 } else if ((ip_equal(loopback_ip, packet->ip) ||
1849 ismyip(packet->ip)) && packet->port == DGRAM_PORT) {
1850 DEBUG(7,("discarding own dgram packet from %s:%d\n",
1851 inet_ntoa(packet->ip),packet->port));
1852 free_packet(packet);
1853 } else {
1854 /* Save the file descriptor this packet came in on. */
1855 packet->fd = sock_array[i];
1856 queue_packet(packet);
1857 }
1858 }
1859 }
1860 } /* end processing 138 socket. */
1861 } /* end for */
1862 return False;
1863 }
1864
1865 /****************************************************************************
1866 Construct and send a netbios DGRAM.
1867 **************************************************************************/
1868
1869 BOOL send_mailslot(BOOL unique, const char *mailslot,char *buf, size_t len,
1870 const char *srcname, int src_type,
1871 const char *dstname, int dest_type,
1872 struct in_addr dest_ip,struct in_addr src_ip,
1873 int dest_port)
1874 {
1875 BOOL loopback_this_packet = False;
1876 struct packet_struct p;
1877 struct dgram_packet *dgram = &p.packet.dgram;
1878 char *ptr,*p2;
1879 char tmp[4];
1880
1881 memset((char *)&p,'\0',sizeof(p));
1882
1883 if(ismyip(dest_ip) && (dest_port == DGRAM_PORT)) /* Only if to DGRAM_PORT */
1884 loopback_this_packet = True;
1885
1886 /* generate_name_trn_id(); */ /* Not used, so gone, RJS */
1887
1888 /* DIRECT GROUP or UNIQUE datagram. */
1889 dgram->header.msg_type = unique ? 0x10 : 0x11;
1890 dgram->header.flags.node_type = M_NODE;
1891 dgram->header.flags.first = True;
1892 dgram->header.flags.more = False;
1893 dgram->header.dgm_id = generate_name_trn_id();
1894 dgram->header.source_ip = src_ip;
1895 dgram->header.source_port = DGRAM_PORT;
1896 dgram->header.dgm_length = 0; /* Let build_dgram() handle this. */
1897 dgram->header.packet_offset = 0;
1898
1899 make_nmb_name(&dgram->source_name,srcname,src_type);
1900 make_nmb_name(&dgram->dest_name,dstname,dest_type);
1901
1902 ptr = &dgram->data[0];
1903
1904 /* Setup the smb part. */
1905 ptr -= 4; /* XXX Ugliness because of handling of tcp SMB length. */
1906 memcpy(tmp,ptr,4);
1907 set_message(NULL,ptr,17,strlen(mailslot) + 1 + len,True);
1908 memcpy(ptr,tmp,4);
1909
1910 SCVAL(ptr,smb_com,SMBtrans);
1911 SSVAL(ptr,smb_vwv1,len);
1912 SSVAL(ptr,smb_vwv11,len);
1913 SSVAL(ptr,smb_vwv12,70 + strlen(mailslot));
1914 SSVAL(ptr,smb_vwv13,3);
1915 SSVAL(ptr,smb_vwv14,1);
1916 SSVAL(ptr,smb_vwv15,1);
1917 SSVAL(ptr,smb_vwv16,2);
1918 p2 = smb_buf(ptr);
1919 safe_strcpy_base(p2, mailslot, dgram->data, sizeof(dgram->data));
1920 p2 = skip_string(ptr,MAX_DGRAM_SIZE,p2);
1921
1922 if (((p2+len) > dgram->data+sizeof(dgram->data)) || ((p2+len) < p2)) {
1923 DEBUG(0, ("send_mailslot: Cannot write beyond end of packet\n"));
1924 return False;
1925 } else {
1926 memcpy(p2,buf,len);
1927 p2 += len;
1928 }
1929
1930 dgram->datasize = PTR_DIFF(p2,ptr+4); /* +4 for tcp length. */
1931
1932 p.ip = dest_ip;
1933 p.port = dest_port;
1934 p.fd = find_subnet_mailslot_fd_for_address( src_ip );
1935 p.timestamp = time(NULL);
1936 p.packet_type = DGRAM_PACKET;
1937
1938 DEBUG(4,("send_mailslot: Sending to mailslot %s from %s IP %s ", mailslot,
1939 nmb_namestr(&dgram->source_name), inet_ntoa(src_ip)));
1940 DEBUG(4,("to %s IP %s\n", nmb_namestr(&dgram->dest_name), inet_ntoa(dest_ip)));
1941
1942 debug_browse_data(buf, len);
1943
1944 if(loopback_this_packet) {
1945 struct packet_struct *lo_packet = NULL;
1946 DEBUG(5,("send_mailslot: sending packet to ourselves.\n"));
1947 if((lo_packet = copy_packet(&p)) == NULL)
1948 return False;
1949 queue_packet(lo_packet);
1950 return True;
1951 } else {
1952 return(send_packet(&p));
1953 }
1954 }