?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
r148: Ensure we do not dereference a null pointer when we return the user
[Samba/gebeck_regimport.git] / source3 / nmbd / nmbd_packets.c
blobd8b50a1b2e9a83a223acfcb233c8071f756b77ad
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 = (struct packet_struct *)malloc(sizeof(*packet))) == 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 = (struct res_rec *)malloc(sizeof(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 *)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 const char *packet_type = "unknown";
868
869 /* Check if we are sending to or from ourselves. */
870 if(ismyip(orig_packet->ip) && (orig_packet->port == global_nmb_port))
871 loopback_this_packet = True;
872
873 nmb = &packet.packet.nmb;
874
875 /* Do a partial copy of the packet. We clear the locked flag and
876 the resource record pointers. */
877 packet = *orig_packet; /* Full structure copy. */
878 packet.locked = False;
879 nmb->answers = NULL;
880 nmb->nsrecs = NULL;
881 nmb->additional = NULL;
882
883 switch (rcv_code) {
884 case NMB_STATUS:
885 packet_type = "nmb_status";
886 nmb->header.nm_flags.recursion_desired = False;
887 nmb->header.nm_flags.recursion_available = False;
888 break;
889 case NMB_QUERY:
890 packet_type = "nmb_query";
891 nmb->header.nm_flags.recursion_desired = True;
892 nmb->header.nm_flags.recursion_available = True;
893 break;
894 case NMB_REG:
895 case NMB_REG_REFRESH:
896 packet_type = "nmb_reg";
897 nmb->header.nm_flags.recursion_desired = True;
898 nmb->header.nm_flags.recursion_available = True;
899 break;
900 case NMB_REL:
901 packet_type = "nmb_rel";
902 nmb->header.nm_flags.recursion_desired = False;
903 nmb->header.nm_flags.recursion_available = False;
904 break;
905 case NMB_WAIT_ACK:
906 packet_type = "nmb_wack";
907 nmb->header.nm_flags.recursion_desired = False;
908 nmb->header.nm_flags.recursion_available = False;
909 break;
910 case WINS_REG:
911 packet_type = "wins_reg";
912 nmb->header.nm_flags.recursion_desired = True;
913 nmb->header.nm_flags.recursion_available = True;
914 break;
915 case WINS_QUERY:
916 packet_type = "wins_query";
917 nmb->header.nm_flags.recursion_desired = True;
918 nmb->header.nm_flags.recursion_available = True;
919 break;
920 default:
921 DEBUG(0,("reply_netbios_packet: Unknown packet type: %s %s to ip %s\n",
922 packet_type, nmb_namestr(&orig_nmb->question.question_name),
923 inet_ntoa(packet.ip)));
924 return;
925 }
926
927 DEBUG(4,("reply_netbios_packet: sending a reply of packet type: %s %s to ip %s \
928 for id %hu\n", packet_type, nmb_namestr(&orig_nmb->question.question_name),
929 inet_ntoa(packet.ip), orig_nmb->header.name_trn_id));
930
931 nmb->header.name_trn_id = orig_nmb->header.name_trn_id;
932 nmb->header.opcode = opcode;
933 nmb->header.response = True;
934 nmb->header.nm_flags.bcast = False;
935 nmb->header.nm_flags.trunc = False;
936 nmb->header.nm_flags.authoritative = True;
937
938 nmb->header.rcode = rcode;
939 nmb->header.qdcount = 0;
940 nmb->header.ancount = 1;
941 nmb->header.nscount = 0;
942 nmb->header.arcount = 0;
943
944 memset((char*)&nmb->question,'\0',sizeof(nmb->question));
945
946 nmb->answers = &answers;
947 memset((char*)nmb->answers,'\0',sizeof(*nmb->answers));
948
949 nmb->answers->rr_name = orig_nmb->question.question_name;
950 nmb->answers->rr_type = orig_nmb->question.question_type;
951 nmb->answers->rr_class = orig_nmb->question.question_class;
952 nmb->answers->ttl = ttl;
953
954 if (data && len) {
955 nmb->answers->rdlength = len;
956 memcpy(nmb->answers->rdata, data, len);
957 }
958
959 packet.packet_type = NMB_PACKET;
960 /* Ensure we send out on the same fd that the original
961 packet came in on to give the correct source IP address. */
962 packet.fd = orig_packet->fd;
963 packet.timestamp = time(NULL);
964
965 debug_nmb_packet(&packet);
966
967 if(loopback_this_packet) {
968 struct packet_struct *lo_packet;
969 DEBUG(5,("reply_netbios_packet: sending packet to ourselves.\n"));
970 if((lo_packet = copy_packet(&packet)) == NULL)
971 return;
972 queue_packet(lo_packet);
973 } else if (!send_packet(&packet)) {
974 DEBUG(0,("reply_netbios_packet: send_packet to IP %s port %d failed\n",
975 inet_ntoa(packet.ip),packet.port));
976 }
977 }
978
979 /*******************************************************************
980 Queue a packet into a packet queue
981 ******************************************************************/
982
983 static void queue_packet(struct packet_struct *packet)
984 {
985 struct packet_struct *p;
986
987 if (!packet_queue) {
988 packet->prev = NULL;
989 packet->next = NULL;
990 packet_queue = packet;
991 return;
992 }
993
994 /* find the bottom */
995 for (p=packet_queue;p->next;p=p->next)
996 ;
997
998 p->next = packet;
999 packet->next = NULL;
1000 packet->prev = p;
1001 }
1002
1003 /****************************************************************************
1004 Try and find a matching subnet record for a datagram port 138 packet.
1005 ****************************************************************************/
1006
1007 static struct subnet_record *find_subnet_for_dgram_browse_packet(struct packet_struct *p)
1008 {
1009 struct subnet_record *subrec;
1010
1011 /* Go through all the broadcast subnets and see if the mask matches. */
1012 for (subrec = FIRST_SUBNET; subrec ; subrec = NEXT_SUBNET_EXCLUDING_UNICAST(subrec)) {
1013 if(same_net(p->ip, subrec->bcast_ip, subrec->mask_ip))
1014 return subrec;
1015 }
1016
1017 /* If the subnet record is the remote announce broadcast subnet,
1018 hack it here to be the first subnet. This is really gross and
1019 is needed due to people turning on port 137/138 broadcast
1020 forwarding on their routers. May fire and brimstone rain
1021 down upon them...
1022 */
1023
1024 return FIRST_SUBNET;
1025 }
1026
1027 /****************************************************************************
1028 Dispatch a browse frame from port 138 to the correct processing function.
1029 ****************************************************************************/
1030
1031 static void process_browse_packet(struct packet_struct *p, char *buf,int len)
1032 {
1033 struct dgram_packet *dgram = &p->packet.dgram;
1034 int command = CVAL(buf,0);
1035 struct subnet_record *subrec = find_subnet_for_dgram_browse_packet(p);
1036 char scope[64];
1037 unstring src_name;
1038
1039 /* Drop the packet if it's a different NetBIOS scope, or the source is from one of our names. */
1040 pull_ascii(scope, dgram->dest_name.scope, 64, 64, STR_TERMINATE);
1041 if (!strequal(scope, global_scope())) {
1042 DEBUG(7,("process_browse_packet: Discarding datagram from IP %s. Scope (%s) \
1043 mismatch with our scope (%s).\n", inet_ntoa(p->ip), scope, global_scope()));
1044 return;
1045 }
1046
1047 pull_ascii_nstring(src_name, sizeof(src_name), dgram->source_name.name);
1048 if (is_myname(src_name)) {
1049 DEBUG(0,("process_browse_packet: Discarding datagram from IP %s. Source name \
1050 %s is one of our names !\n", inet_ntoa(p->ip), nmb_namestr(&dgram->source_name)));
1051 return;
1052 }
1053
1054 switch (command) {
1055 case ANN_HostAnnouncement:
1056 debug_browse_data(buf, len);
1057 process_host_announce(subrec, p, buf+1);
1058 break;
1059 case ANN_DomainAnnouncement:
1060 debug_browse_data(buf, len);
1061 process_workgroup_announce(subrec, p, buf+1);
1062 break;
1063 case ANN_LocalMasterAnnouncement:
1064 debug_browse_data(buf, len);
1065 process_local_master_announce(subrec, p, buf+1);
1066 break;
1067 case ANN_AnnouncementRequest:
1068 debug_browse_data(buf, len);
1069 process_announce_request(subrec, p, buf+1);
1070 break;
1071 case ANN_Election:
1072 debug_browse_data(buf, len);
1073 process_election(subrec, p, buf+1);
1074 break;
1075 case ANN_GetBackupListReq:
1076 debug_browse_data(buf, len);
1077 process_get_backup_list_request(subrec, p, buf+1);
1078 break;
1079 case ANN_GetBackupListResp:
1080 debug_browse_data(buf, len);
1081 /* We never send ANN_GetBackupListReq so we should never get these. */
1082 DEBUG(0,("process_browse_packet: Discarding GetBackupListResponse \
1083 packet from %s IP %s\n", nmb_namestr(&dgram->source_name), inet_ntoa(p->ip)));
1084 break;
1085 case ANN_ResetBrowserState:
1086 debug_browse_data(buf, len);
1087 process_reset_browser(subrec, p, buf+1);
1088 break;
1089 case ANN_MasterAnnouncement:
1090 /* Master browser datagrams must be processed on the unicast subnet. */
1091 subrec = unicast_subnet;
1092
1093 debug_browse_data(buf, len);
1094 process_master_browser_announce(subrec, p, buf+1);
1095 break;
1096 case ANN_BecomeBackup:
1097 /*
1098 * We don't currently implement this. Log it just in case.
1099 */
1100 debug_browse_data(buf, len);
1101 DEBUG(10,("process_browse_packet: On subnet %s ignoring browse packet \
1102 command ANN_BecomeBackup from %s IP %s to %s\n", subrec->subnet_name, nmb_namestr(&dgram->source_name),
1103 inet_ntoa(p->ip), nmb_namestr(&dgram->dest_name)));
1104 break;
1105 default:
1106 debug_browse_data(buf, len);
1107 DEBUG(0,("process_browse_packet: On subnet %s ignoring browse packet \
1108 command code %d from %s IP %s to %s\n", subrec->subnet_name, command, nmb_namestr(&dgram->source_name),
1109 inet_ntoa(p->ip), nmb_namestr(&dgram->dest_name)));
1110 break;
1111 }
1112 }
1113
1114 /****************************************************************************
1115 Dispatch a LanMan browse frame from port 138 to the correct processing function.
1116 ****************************************************************************/
1117
1118 static void process_lanman_packet(struct packet_struct *p, char *buf,int len)
1119 {
1120 struct dgram_packet *dgram = &p->packet.dgram;
1121 int command = SVAL(buf,0);
1122 struct subnet_record *subrec = find_subnet_for_dgram_browse_packet(p);
1123 char scope[64];
1124 unstring src_name;
1125
1126 /* Drop the packet if it's a different NetBIOS scope, or the source is from one of our names. */
1127
1128 pull_ascii(scope, dgram->dest_name.scope, 64, 64, STR_TERMINATE);
1129 if (!strequal(scope, global_scope())) {
1130 DEBUG(7,("process_lanman_packet: Discarding datagram from IP %s. Scope (%s) \
1131 mismatch with our scope (%s).\n", inet_ntoa(p->ip), scope, global_scope()));
1132 return;
1133 }
1134
1135 pull_ascii_nstring(src_name, sizeof(src_name), dgram->source_name.name);
1136 if (is_myname(src_name)) {
1137 DEBUG(0,("process_lanman_packet: Discarding datagram from IP %s. Source name \
1138 %s is one of our names !\n", inet_ntoa(p->ip), nmb_namestr(&dgram->source_name)));
1139 return;
1140 }
1141
1142 switch (command) {
1143 case ANN_HostAnnouncement:
1144 debug_browse_data(buf, len);
1145 process_lm_host_announce(subrec, p, buf+1);
1146 break;
1147 case ANN_AnnouncementRequest:
1148 process_lm_announce_request(subrec, p, buf+1);
1149 break;
1150 default:
1151 DEBUG(0,("process_lanman_packet: On subnet %s ignoring browse packet \
1152 command code %d from %s IP %s to %s\n", subrec->subnet_name, command, nmb_namestr(&dgram->source_name),
1153 inet_ntoa(p->ip), nmb_namestr(&dgram->dest_name)));
1154 break;
1155 }
1156 }
1157
1158 /****************************************************************************
1159 Determine if a packet is for us on port 138. Note that to have any chance of
1160 being efficient we need to drop as many packets as possible at this
1161 stage as subsequent processing is expensive.
1162 ****************************************************************************/
1163
1164 static BOOL listening(struct packet_struct *p,struct nmb_name *nbname)
1165 {
1166 struct subnet_record *subrec = NULL;
1167
1168 for (subrec = FIRST_SUBNET; subrec ; subrec = NEXT_SUBNET_EXCLUDING_UNICAST(subrec)) {
1169 if(same_net(p->ip, subrec->bcast_ip, subrec->mask_ip))
1170 break;
1171 }
1172
1173 if(subrec == NULL)
1174 subrec = unicast_subnet;
1175
1176 return (find_name_on_subnet(subrec, nbname, FIND_SELF_NAME) != NULL);
1177 }
1178
1179 /****************************************************************************
1180 Process udp 138 datagrams
1181 ****************************************************************************/
1182
1183 static void process_dgram(struct packet_struct *p)
1184 {
1185 char *buf;
1186 char *buf2;
1187 int len;
1188 struct dgram_packet *dgram = &p->packet.dgram;
1189
1190 /* If we aren't listening to the destination name then ignore the packet */
1191 if (!listening(p,&dgram->dest_name)) {
1192 unexpected_packet(p);
1193 DEBUG(5,("process_dgram: ignoring dgram packet sent to name %s from %s\n",
1194 nmb_namestr(&dgram->dest_name), inet_ntoa(p->ip)));
1195 return;
1196 }
1197
1198 if (dgram->header.msg_type != 0x10 && dgram->header.msg_type != 0x11 && dgram->header.msg_type != 0x12) {
1199 unexpected_packet(p);
1200 /* Don't process error packets etc yet */
1201 DEBUG(5,("process_dgram: ignoring dgram packet sent to name %s from IP %s as it is \
1202 an error packet of type %x\n", nmb_namestr(&dgram->dest_name), inet_ntoa(p->ip), dgram->header.msg_type));
1203 return;
1204 }
1205
1206 buf = &dgram->data[0];
1207 buf -= 4; /* XXXX for the pseudo tcp length - someday I need to get rid of this */
1208
1209 if (CVAL(buf,smb_com) != SMBtrans)
1210 return;
1211
1212 len = SVAL(buf,smb_vwv11);
1213 buf2 = smb_base(buf) + SVAL(buf,smb_vwv12);
1214
1215 if (len <= 0)
1216 return;
1217
1218 if (buf2 + len > buf + sizeof(dgram->data)) {
1219 DEBUG(2,("process_dgram: datagram from %s to %s IP %s for %s len=%d too long.\n",
1220 nmb_namestr(&dgram->source_name),nmb_namestr(&dgram->dest_name),
1221 inet_ntoa(p->ip), smb_buf(buf),len));
1222 len = (buf + sizeof(dgram->data)) - buf;
1223 }
1224
1225 DEBUG(4,("process_dgram: datagram from %s to %s IP %s for %s of type %d len=%d\n",
1226 nmb_namestr(&dgram->source_name),nmb_namestr(&dgram->dest_name),
1227 inet_ntoa(p->ip), smb_buf(buf),CVAL(buf2,0),len));
1228
1229 /* Datagram packet received for the browser mailslot */
1230 if (strequal(smb_buf(buf),BROWSE_MAILSLOT)) {
1231 process_browse_packet(p,buf2,len);
1232 return;
1233 }
1234
1235 /* Datagram packet received for the LAN Manager mailslot */
1236 if (strequal(smb_buf(buf),LANMAN_MAILSLOT)) {
1237 process_lanman_packet(p,buf2,len);
1238 return;
1239 }
1240
1241 /* Datagram packet received for the domain logon mailslot */
1242 if (strequal(smb_buf(buf),NET_LOGON_MAILSLOT)) {
1243 process_logon_packet(p,buf2,len,NET_LOGON_MAILSLOT);
1244 return;
1245 }
1246
1247 /* Datagram packet received for the NT domain logon mailslot */
1248 if (strequal(smb_buf(buf),NT_LOGON_MAILSLOT)) {
1249 process_logon_packet(p,buf2,len,NT_LOGON_MAILSLOT);
1250 return;
1251 }
1252
1253 unexpected_packet(p);
1254 }
1255
1256 /****************************************************************************
1257 Validate a response nmb packet.
1258 ****************************************************************************/
1259
1260 static BOOL validate_nmb_response_packet( struct nmb_packet *nmb )
1261 {
1262 BOOL ignore = False;
1263
1264 switch (nmb->header.opcode) {
1265 case NMB_NAME_REG_OPCODE:
1266 case NMB_NAME_REFRESH_OPCODE_8: /* ambiguity in rfc1002 about which is correct. */
1267 case NMB_NAME_REFRESH_OPCODE_9: /* WinNT uses 8 by default. */
1268 if (nmb->header.ancount == 0) {
1269 DEBUG(0,("validate_nmb_response_packet: Bad REG/REFRESH Packet. "));
1270 ignore = True;
1271 }
1272 break;
1273
1274 case NMB_NAME_QUERY_OPCODE:
1275 if ((nmb->header.ancount != 0) && (nmb->header.ancount != 1)) {
1276 DEBUG(0,("validate_nmb_response_packet: Bad QUERY Packet. "));
1277 ignore = True;
1278 }
1279 break;
1280
1281 case NMB_NAME_RELEASE_OPCODE:
1282 if (nmb->header.ancount == 0) {
1283 DEBUG(0,("validate_nmb_response_packet: Bad RELEASE Packet. "));
1284 ignore = True;
1285 }
1286 break;
1287
1288 case NMB_WACK_OPCODE:
1289 /* Check WACK response here. */
1290 if (nmb->header.ancount != 1) {
1291 DEBUG(0,("validate_nmb_response_packet: Bad WACK Packet. "));
1292 ignore = True;
1293 }
1294 break;
1295 default:
1296 DEBUG(0,("validate_nmb_response_packet: Ignoring packet with unknown opcode %d.\n",
1297 nmb->header.opcode));
1298 return True;
1299 }
1300
1301 if(ignore)
1302 DEBUG(0,("Ignoring response packet with opcode %d.\n", nmb->header.opcode));
1303
1304 return ignore;
1305 }
1306
1307 /****************************************************************************
1308 Validate a request nmb packet.
1309 ****************************************************************************/
1310
1311 static BOOL validate_nmb_packet( struct nmb_packet *nmb )
1312 {
1313 BOOL ignore = False;
1314
1315 switch (nmb->header.opcode) {
1316 case NMB_NAME_REG_OPCODE:
1317 case NMB_NAME_REFRESH_OPCODE_8: /* ambiguity in rfc1002 about which is correct. */
1318 case NMB_NAME_REFRESH_OPCODE_9: /* WinNT uses 8 by default. */
1319 case NMB_NAME_MULTIHOMED_REG_OPCODE:
1320 if (nmb->header.qdcount==0 || nmb->header.arcount==0) {
1321 DEBUG(0,("validate_nmb_packet: Bad REG/REFRESH Packet. "));
1322 ignore = True;
1323 }
1324 break;
1325
1326 case NMB_NAME_QUERY_OPCODE:
1327 if ((nmb->header.qdcount == 0) || ((nmb->question.question_type != QUESTION_TYPE_NB_QUERY) &&
1328 (nmb->question.question_type != QUESTION_TYPE_NB_STATUS))) {
1329 DEBUG(0,("validate_nmb_packet: Bad QUERY Packet. "));
1330 ignore = True;
1331 }
1332 break;
1333
1334 case NMB_NAME_RELEASE_OPCODE:
1335 if (nmb->header.qdcount==0 || nmb->header.arcount==0) {
1336 DEBUG(0,("validate_nmb_packet: Bad RELEASE Packet. "));
1337 ignore = True;
1338 }
1339 break;
1340 default:
1341 DEBUG(0,("validate_nmb_packet: Ignoring packet with unknown opcode %d.\n",
1342 nmb->header.opcode));
1343 return True;
1344 }
1345
1346 if(ignore)
1347 DEBUG(0,("validate_nmb_packet: Ignoring request packet with opcode %d.\n", nmb->header.opcode));
1348
1349 return ignore;
1350 }
1351
1352 /****************************************************************************
1353 Find a subnet (and potentially a response record) for a packet.
1354 ****************************************************************************/
1355
1356 static struct subnet_record *find_subnet_for_nmb_packet( struct packet_struct *p,
1357 struct response_record **pprrec)
1358 {
1359 struct nmb_packet *nmb = &p->packet.nmb;
1360 struct response_record *rrec = NULL;
1361 struct subnet_record *subrec = NULL;
1362
1363 if(pprrec != NULL)
1364 *pprrec = NULL;
1365
1366 if(nmb->header.response) {
1367 /* It's a response packet. Find a record for it or it's an error. */
1368
1369 rrec = find_response_record( &subrec, nmb->header.name_trn_id);
1370 if(rrec == NULL) {
1371 DEBUG(3,("find_subnet_for_nmb_packet: response record not found for response id %hu\n",
1372 nmb->header.name_trn_id));
1373 unexpected_packet(p);
1374 return NULL;
1375 }
1376
1377 if(subrec == NULL) {
1378 DEBUG(0,("find_subnet_for_nmb_packet: subnet record not found for response id %hu\n",
1379 nmb->header.name_trn_id));
1380 return NULL;
1381 }
1382
1383 if(pprrec != NULL)
1384 *pprrec = rrec;
1385 return subrec;
1386 }
1387
1388 /* Try and see what subnet this packet belongs to. */
1389
1390 /* WINS server ? */
1391 if(packet_is_for_wins_server(p))
1392 return wins_server_subnet;
1393
1394 /* If it wasn't a broadcast packet then send to the UNICAST subnet. */
1395 if(nmb->header.nm_flags.bcast == False)
1396 return unicast_subnet;
1397
1398 /* Go through all the broadcast subnets and see if the mask matches. */
1399 for (subrec = FIRST_SUBNET; subrec ; subrec = NEXT_SUBNET_EXCLUDING_UNICAST(subrec)) {
1400 if(same_net(p->ip, subrec->bcast_ip, subrec->mask_ip))
1401 return subrec;
1402 }
1403
1404 /* If none match it must have been a directed broadcast - assign the remote_broadcast_subnet. */
1405 return remote_broadcast_subnet;
1406 }
1407
1408 /****************************************************************************
1409 Process a nmb request packet - validate the packet and route it.
1410 ****************************************************************************/
1411
1412 static void process_nmb_request(struct packet_struct *p)
1413 {
1414 struct nmb_packet *nmb = &p->packet.nmb;
1415 struct subnet_record *subrec = NULL;
1416
1417 debug_nmb_packet(p);
1418
1419 /* Ensure we have a good packet. */
1420 if(validate_nmb_packet(nmb))
1421 return;
1422
1423 /* Allocate a subnet to this packet - if we cannot - fail. */
1424 if((subrec = find_subnet_for_nmb_packet(p, NULL))==NULL)
1425 return;
1426
1427 switch (nmb->header.opcode) {
1428 case NMB_NAME_REG_OPCODE:
1429 if(subrec == wins_server_subnet)
1430 wins_process_name_registration_request(subrec, p);
1431 else
1432 process_name_registration_request(subrec, p);
1433 break;
1434
1435 case NMB_NAME_REFRESH_OPCODE_8: /* ambiguity in rfc1002 about which is correct. */
1436 case NMB_NAME_REFRESH_OPCODE_9:
1437 if(subrec == wins_server_subnet)
1438 wins_process_name_refresh_request(subrec, p);
1439 else
1440 process_name_refresh_request(subrec, p);
1441 break;
1442
1443 case NMB_NAME_MULTIHOMED_REG_OPCODE:
1444 if(subrec == wins_server_subnet) {
1445 wins_process_multihomed_name_registration_request(subrec, p);
1446 } else {
1447 DEBUG(0,("process_nmb_request: Multihomed registration request must be \
1448 directed at a WINS server.\n"));
1449 }
1450 break;
1451
1452 case NMB_NAME_QUERY_OPCODE:
1453 switch (nmb->question.question_type) {
1454 case QUESTION_TYPE_NB_QUERY:
1455 if(subrec == wins_server_subnet)
1456 wins_process_name_query_request(subrec, p);
1457 else
1458 process_name_query_request(subrec, p);
1459 break;
1460 case QUESTION_TYPE_NB_STATUS:
1461 if(subrec == wins_server_subnet) {
1462 DEBUG(0,("process_nmb_request: NB_STATUS request directed at WINS server is \
1463 not allowed.\n"));
1464 break;
1465 } else {
1466 process_node_status_request(subrec, p);
1467 }
1468 break;
1469 }
1470 break;
1471
1472 case NMB_NAME_RELEASE_OPCODE:
1473 if(subrec == wins_server_subnet)
1474 wins_process_name_release_request(subrec, p);
1475 else
1476 process_name_release_request(subrec, p);
1477 break;
1478 }
1479 }
1480
1481 /****************************************************************************
1482 Process a nmb response packet - validate the packet and route it.
1483 to either the WINS server or a normal response.
1484 ****************************************************************************/
1485
1486 static void process_nmb_response(struct packet_struct *p)
1487 {
1488 struct nmb_packet *nmb = &p->packet.nmb;
1489 struct subnet_record *subrec = NULL;
1490 struct response_record *rrec = NULL;
1491
1492 debug_nmb_packet(p);
1493
1494 if(validate_nmb_response_packet(nmb))
1495 return;
1496
1497 if((subrec = find_subnet_for_nmb_packet(p, &rrec))==NULL)
1498 return;
1499
1500 if(rrec == NULL) {
1501 DEBUG(0,("process_nmb_response: response packet received but no response record \
1502 found for id = %hu. Ignoring packet.\n", nmb->header.name_trn_id));
1503 return;
1504 }
1505
1506 /* Increment the number of responses received for this record. */
1507 rrec->num_msgs++;
1508 /* Ensure we don't re-send the request. */
1509 rrec->repeat_count = 0;
1510
1511 /* Call the response received function for this packet. */
1512 (*rrec->resp_fn)(subrec, rrec, p);
1513 }
1514
1515 /*******************************************************************
1516 Run elements off the packet queue till its empty
1517 ******************************************************************/
1518
1519 void run_packet_queue(void)
1520 {
1521 struct packet_struct *p;
1522
1523 while ((p = packet_queue)) {
1524 packet_queue = p->next;
1525 if (packet_queue)
1526 packet_queue->prev = NULL;
1527 p->next = p->prev = NULL;
1528
1529 switch (p->packet_type) {
1530 case NMB_PACKET:
1531 if(p->packet.nmb.header.response)
1532 process_nmb_response(p);
1533 else
1534 process_nmb_request(p);
1535 break;
1536
1537 case DGRAM_PACKET:
1538 process_dgram(p);
1539 break;
1540 }
1541 free_packet(p);
1542 }
1543 }
1544
1545 /*******************************************************************
1546 Retransmit or timeout elements from all the outgoing subnet response
1547 record queues. NOTE that this code must also check the WINS server
1548 subnet for response records to timeout as the WINS server code
1549 can send requests to check if a client still owns a name.
1550 (Patch from Andrey Alekseyev <fetch@muffin.arcadia.spb.ru>).
1551 ******************************************************************/
1552
1553 void retransmit_or_expire_response_records(time_t t)
1554 {
1555 struct subnet_record *subrec;
1556
1557 for (subrec = FIRST_SUBNET; subrec; subrec = get_next_subnet_maybe_unicast_or_wins_server(subrec)) {
1558 struct response_record *rrec, *nextrrec;
1559
1560 for (rrec = subrec->responselist; rrec; rrec = nextrrec) {
1561 nextrrec = rrec->next;
1562
1563 if (rrec->repeat_time <= t) {
1564 if (rrec->repeat_count > 0) {
1565 /* Resend while we have a non-zero repeat_count. */
1566 if(!send_packet(rrec->packet)) {
1567 DEBUG(0,("retransmit_or_expire_response_records: Failed to resend packet id %hu \
1568 to IP %s on subnet %s\n", rrec->response_id, inet_ntoa(rrec->packet->ip), subrec->subnet_name));
1569 }
1570 rrec->repeat_time = t + rrec->repeat_interval;
1571 rrec->repeat_count--;
1572 } else {
1573 DEBUG(4,("retransmit_or_expire_response_records: timeout for packet id %hu to IP %s \
1574 on subnet %s\n", rrec->response_id, inet_ntoa(rrec->packet->ip), subrec->subnet_name));
1575
1576 /*
1577 * Check the flag in this record to prevent recursion if we end
1578 * up in this function again via the timeout function call.
1579 */
1580
1581 if(!rrec->in_expiration_processing) {
1582
1583 /*
1584 * Set the recursion protection flag in this record.
1585 */
1586
1587 rrec->in_expiration_processing = True;
1588
1589 /* Call the timeout function. This will deal with removing the
1590 timed out packet. */
1591 if(rrec->timeout_fn) {
1592 (*rrec->timeout_fn)(subrec, rrec);
1593 } else {
1594 /* We must remove the record ourself if there is
1595 no timeout function. */
1596 remove_response_record(subrec, rrec);
1597 }
1598 } /* !rrec->in_expitation_processing */
1599 } /* rrec->repeat_count > 0 */
1600 } /* rrec->repeat_time <= t */
1601 } /* end for rrec */
1602 } /* end for subnet */
1603 }
1604
1605 /****************************************************************************
1606 Create an fd_set containing all the sockets in the subnet structures,
1607 plus the broadcast sockets.
1608 ***************************************************************************/
1609
1610 static BOOL create_listen_fdset(fd_set **ppset, int **psock_array, int *listen_number)
1611 {
1612 int *sock_array = NULL;
1613 struct subnet_record *subrec = NULL;
1614 int count = 0;
1615 int num = 0;
1616 fd_set *pset = (fd_set *)malloc(sizeof(fd_set));
1617
1618 if(pset == NULL) {
1619 DEBUG(0,("create_listen_fdset: malloc fail !\n"));
1620 return True;
1621 }
1622
1623 /* Check that we can add all the fd's we need. */
1624 for (subrec = FIRST_SUBNET; subrec; subrec = NEXT_SUBNET_EXCLUDING_UNICAST(subrec))
1625 count++;
1626
1627 if((count*2) + 2 > FD_SETSIZE) {
1628 DEBUG(0,("create_listen_fdset: Too many file descriptors needed (%d). We can \
1629 only use %d.\n", (count*2) + 2, FD_SETSIZE));
1630 return True;
1631 }
1632
1633 if((sock_array = (int *)malloc(((count*2) + 2)*sizeof(int))) == NULL) {
1634 DEBUG(0,("create_listen_fdset: malloc fail for socket array.\n"));
1635 return True;
1636 }
1637
1638 FD_ZERO(pset);
1639
1640 /* Add in the broadcast socket on 137. */
1641 FD_SET(ClientNMB,pset);
1642 sock_array[num++] = ClientNMB;
1643
1644 /* Add in the 137 sockets on all the interfaces. */
1645 for (subrec = FIRST_SUBNET; subrec; subrec = NEXT_SUBNET_EXCLUDING_UNICAST(subrec)) {
1646 FD_SET(subrec->nmb_sock,pset);
1647 sock_array[num++] = subrec->nmb_sock;
1648 }
1649
1650 /* Add in the broadcast socket on 138. */
1651 FD_SET(ClientDGRAM,pset);
1652 sock_array[num++] = ClientDGRAM;
1653
1654 /* Add in the 138 sockets on all the interfaces. */
1655 for (subrec = FIRST_SUBNET; subrec; subrec = NEXT_SUBNET_EXCLUDING_UNICAST(subrec)) {
1656 FD_SET(subrec->dgram_sock,pset);
1657 sock_array[num++] = subrec->dgram_sock;
1658 }
1659
1660 *listen_number = (count*2) + 2;
1661
1662 SAFE_FREE(*ppset);
1663 SAFE_FREE(*psock_array);
1664
1665 *ppset = pset;
1666 *psock_array = sock_array;
1667
1668 return False;
1669 }
1670
1671 /****************************************************************************
1672 Listens for NMB or DGRAM packets, and queues them.
1673 return True if the socket is dead
1674 ***************************************************************************/
1675
1676 BOOL listen_for_packets(BOOL run_election)
1677 {
1678 static fd_set *listen_set = NULL;
1679 static int listen_number = 0;
1680 static int *sock_array = NULL;
1681 int i;
1682
1683 fd_set fds;
1684 int selrtn;
1685 struct timeval timeout;
1686 #ifndef SYNC_DNS
1687 int dns_fd;
1688 #endif
1689
1690 if(listen_set == NULL || rescan_listen_set) {
1691 if(create_listen_fdset(&listen_set, &sock_array, &listen_number)) {
1692 DEBUG(0,("listen_for_packets: Fatal error. unable to create listen set. Exiting.\n"));
1693 return True;
1694 }
1695 rescan_listen_set = False;
1696 }
1697
1698 memcpy((char *)&fds, (char *)listen_set, sizeof(fd_set));
1699
1700 #ifndef SYNC_DNS
1701 dns_fd = asyncdns_fd();
1702 if (dns_fd != -1) {
1703 FD_SET(dns_fd, &fds);
1704 }
1705 #endif
1706
1707 /*
1708 * During elections and when expecting a netbios response packet we
1709 * need to send election packets at tighter intervals.
1710 * Ideally it needs to be the interval (in ms) between time now and
1711 * the time we are expecting the next netbios packet.
1712 */
1713
1714 timeout.tv_sec = (run_election||num_response_packets) ? 1 : NMBD_SELECT_LOOP;
1715 timeout.tv_usec = 0;
1716
1717 /* Prepare for the select - allow certain signals. */
1718
1719 BlockSignals(False, SIGTERM);
1720
1721 selrtn = sys_select(FD_SETSIZE,&fds,NULL,NULL,&timeout);
1722
1723 /* We can only take signals when we are in the select - block them again here. */
1724
1725 BlockSignals(True, SIGTERM);
1726
1727 if(selrtn == -1) {
1728 return False;
1729 }
1730
1731 #ifndef SYNC_DNS
1732 if (dns_fd != -1 && FD_ISSET(dns_fd,&fds)) {
1733 run_dns_queue();
1734 }
1735 #endif
1736
1737 for(i = 0; i < listen_number; i++) {
1738 if (i < (listen_number/2)) {
1739 /* Processing a 137 socket. */
1740 if (FD_ISSET(sock_array[i],&fds)) {
1741 struct packet_struct *packet = read_packet(sock_array[i], NMB_PACKET);
1742 if (packet) {
1743 /*
1744 * If we got a packet on the broadcast socket and interfaces
1745 * only is set then check it came from one of our local nets.
1746 */
1747 if(lp_bind_interfaces_only() && (sock_array[i] == ClientNMB) &&
1748 (!is_local_net(packet->ip))) {
1749 DEBUG(7,("discarding nmb packet sent to broadcast socket from %s:%d\n",
1750 inet_ntoa(packet->ip),packet->port));
1751 free_packet(packet);
1752 } else if ((ip_equal(loopback_ip, packet->ip) ||
1753 ismyip(packet->ip)) && packet->port == global_nmb_port &&
1754 packet->packet.nmb.header.nm_flags.bcast) {
1755 DEBUG(7,("discarding own bcast packet from %s:%d\n",
1756 inet_ntoa(packet->ip),packet->port));
1757 free_packet(packet);
1758 } else {
1759 /* Save the file descriptor this packet came in on. */
1760 packet->fd = sock_array[i];
1761 queue_packet(packet);
1762 }
1763 }
1764 }
1765 } else {
1766 /* Processing a 138 socket. */
1767 if (FD_ISSET(sock_array[i],&fds)) {
1768 struct packet_struct *packet = read_packet(sock_array[i], DGRAM_PACKET);
1769 if (packet) {
1770 /*
1771 * If we got a packet on the broadcast socket and interfaces
1772 * only is set then check it came from one of our local nets.
1773 */
1774 if(lp_bind_interfaces_only() && (sock_array[i] == ClientDGRAM) &&
1775 (!is_local_net(packet->ip))) {
1776 DEBUG(7,("discarding dgram packet sent to broadcast socket from %s:%d\n",
1777 inet_ntoa(packet->ip),packet->port));
1778 free_packet(packet);
1779 } else if ((ip_equal(loopback_ip, packet->ip) ||
1780 ismyip(packet->ip)) && packet->port == DGRAM_PORT) {
1781 DEBUG(7,("discarding own dgram packet from %s:%d\n",
1782 inet_ntoa(packet->ip),packet->port));
1783 free_packet(packet);
1784 } else {
1785 /* Save the file descriptor this packet came in on. */
1786 packet->fd = sock_array[i];
1787 queue_packet(packet);
1788 }
1789 }
1790 }
1791 } /* end processing 138 socket. */
1792 } /* end for */
1793 return False;
1794 }
1795
1796 /****************************************************************************
1797 Construct and send a netbios DGRAM.
1798 **************************************************************************/
1799
1800 BOOL send_mailslot(BOOL unique, const char *mailslot,char *buf, size_t len,
1801 const char *srcname, int src_type,
1802 const char *dstname, int dest_type,
1803 struct in_addr dest_ip,struct in_addr src_ip,
1804 int dest_port)
1805 {
1806 BOOL loopback_this_packet = False;
1807 struct packet_struct p;
1808 struct dgram_packet *dgram = &p.packet.dgram;
1809 char *ptr,*p2;
1810 char tmp[4];
1811
1812 memset((char *)&p,'\0',sizeof(p));
1813
1814 if(ismyip(dest_ip) && (dest_port == DGRAM_PORT)) /* Only if to DGRAM_PORT */
1815 loopback_this_packet = True;
1816
1817 /* generate_name_trn_id(); */ /* Not used, so gone, RJS */
1818
1819 /* DIRECT GROUP or UNIQUE datagram. */
1820 dgram->header.msg_type = unique ? 0x10 : 0x11;
1821 dgram->header.flags.node_type = M_NODE;
1822 dgram->header.flags.first = True;
1823 dgram->header.flags.more = False;
1824 dgram->header.dgm_id = generate_name_trn_id();
1825 dgram->header.source_ip = src_ip;
1826 dgram->header.source_port = DGRAM_PORT;
1827 dgram->header.dgm_length = 0; /* Let build_dgram() handle this. */
1828 dgram->header.packet_offset = 0;
1829
1830 make_nmb_name(&dgram->source_name,srcname,src_type);
1831 make_nmb_name(&dgram->dest_name,dstname,dest_type);
1832
1833 ptr = &dgram->data[0];
1834
1835 /* Setup the smb part. */
1836 ptr -= 4; /* XXX Ugliness because of handling of tcp SMB length. */
1837 memcpy(tmp,ptr,4);
1838 set_message(ptr,17,strlen(mailslot) + 1 + len,True);
1839 memcpy(ptr,tmp,4);
1840
1841 SCVAL(ptr,smb_com,SMBtrans);
1842 SSVAL(ptr,smb_vwv1,len);
1843 SSVAL(ptr,smb_vwv11,len);
1844 SSVAL(ptr,smb_vwv12,70 + strlen(mailslot));
1845 SSVAL(ptr,smb_vwv13,3);
1846 SSVAL(ptr,smb_vwv14,1);
1847 SSVAL(ptr,smb_vwv15,1);
1848 SSVAL(ptr,smb_vwv16,2);
1849 p2 = smb_buf(ptr);
1850 safe_strcpy_base(p2, mailslot, dgram->data, sizeof(dgram->data));
1851 p2 = skip_string(p2,1);
1852
1853 if (((p2+len) > dgram->data+sizeof(dgram->data)) || ((p2+len) < p2)) {
1854 DEBUG(0, ("send_mailslot: Cannot write beyond end of packet\n"));
1855 return False;
1856 } else {
1857 memcpy(p2,buf,len);
1858 p2 += len;
1859 }
1860
1861 dgram->datasize = PTR_DIFF(p2,ptr+4); /* +4 for tcp length. */
1862
1863 p.ip = dest_ip;
1864 p.port = dest_port;
1865 p.fd = find_subnet_mailslot_fd_for_address( src_ip );
1866 p.timestamp = time(NULL);
1867 p.packet_type = DGRAM_PACKET;
1868
1869 DEBUG(4,("send_mailslot: Sending to mailslot %s from %s IP %s ", mailslot,
1870 nmb_namestr(&dgram->source_name), inet_ntoa(src_ip)));
1871 DEBUG(4,("to %s IP %s\n", nmb_namestr(&dgram->dest_name), inet_ntoa(dest_ip)));
1872
1873 debug_browse_data(buf, len);
1874
1875 if(loopback_this_packet) {
1876 struct packet_struct *lo_packet = NULL;
1877 DEBUG(5,("send_mailslot: sending packet to ourselves.\n"));
1878 if((lo_packet = copy_packet(&p)) == NULL)
1879 return False;
1880 queue_packet(lo_packet);
1881 return True;
1882 } else {
1883 return(send_packet(&p));
1884 }
1885 }
reg import