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