source: trunk/samba/source/nmbd/nmbd_packets.c @ 26

Last change on this file since 26 was 26, checked in by Paul Smedley, 14 years ago

Updated source to 3.0.25rc1

File size: 62.7 KB
Line 
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
26extern int ClientNMB;
27extern int ClientDGRAM;
28extern int global_nmb_port;
29
30extern int num_response_packets;
31
32extern struct in_addr loopback_ip;
33
34static void queue_packet(struct packet_struct *packet);
35
36BOOL 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
45static struct packet_struct *packet_queue = NULL;
46
47/***************************************************************************
48Utility function to find the specific fd to send a packet out on.
49**************************************************************************/
50
51static 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/***************************************************************************
63Utility function to find the specific fd to send a mailslot packet out on.
64**************************************************************************/
65
66static 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/***************************************************************************
78Get/Set problematic nb_flags as network byte order 16 bit int.
79**************************************************************************/
80
81uint16 get_nb_flags(char *buf)
82{
83        return ((((uint16)*buf)&0xFFFF) & NB_FLGMSK);
84}
85
86void set_nb_flags(char *buf, uint16 nb_flags)
87{
88        *buf++ = ((nb_flags & NB_FLGMSK) & 0xFF);
89        *buf = '\0';
90}
91
92/***************************************************************************
93Dumps out the browse packet data.
94**************************************************************************/
95
96static 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
132static uint16 name_trn_id=0;
133
134static 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
147static 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
179static 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
227static 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
275static 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
297static 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
319static 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
343static 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 \
360for 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
371static 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
395static 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
419static 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
448static 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. \
452This 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
462struct 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
507void 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                p->locked = False;
540                free_packet(p);
541                DEBUG(0,("Failed to allocate userdata structure!\n"));
542                return;
543        }
544        ZERO_STRUCTP(userdata);
545        userdata->userdata_len = strlen(tag) + 1;
546        strlcpy(userdata->data, tag, userdata->userdata_len);   
547
548        if ((rrec = make_response_record(unicast_subnet,
549                                         p,
550                                         resp_fn, timeout_fn,
551                                         NULL,
552                                         NULL,
553                                         userdata)) == NULL) {
554                p->locked = False;
555                free_packet(p);
556                return;
557        }
558
559        free(userdata);
560
561        /* we don't want to repeat refresh packets */
562        rrec->repeat_count = 0;
563}
564
565
566/****************************************************************************
567 Queue a multihomed register name packet to a given WINS server IP
568****************************************************************************/
569
570struct response_record *queue_register_multihomed_name( struct subnet_record *subrec,
571                                                        response_function resp_fn,
572                                                        timeout_response_function timeout_fn,
573                                                        register_name_success_function success_fn,
574                                                        register_name_fail_function fail_fn,
575                                                        struct userdata_struct *userdata,
576                                                        struct nmb_name *nmbname,
577                                                        uint16 nb_flags,
578                                                        struct in_addr register_ip,
579                                                        struct in_addr wins_ip)
580{
581        struct packet_struct *p;
582        struct response_record *rrec;
583        BOOL ret;
584       
585        /* Sanity check. */
586        if(subrec != unicast_subnet) {
587                DEBUG(0,("queue_register_multihomed_name: should only be done on \
588unicast subnet. subnet is %s\n.", subrec->subnet_name ));
589                return NULL;
590        }
591
592        if(assert_check_subnet(subrec))
593                return NULL;
594     
595        if ((p = create_and_init_netbios_packet(nmbname, False, True, wins_ip)) == NULL)
596                return NULL;
597
598        if (nb_flags & NB_GROUP)
599                ret = initiate_name_register_packet( p, nb_flags, &register_ip);
600        else
601                ret = initiate_multihomed_name_register_packet(p, nb_flags, &register_ip);
602
603        if (ret == False) { 
604                p->locked = False;
605                free_packet(p);
606                return NULL;
607        } 
608 
609        if ((rrec = make_response_record(subrec,    /* subnet record. */
610                                         p,                     /* packet we sent. */
611                                         resp_fn,               /* function to call on response. */
612                                         timeout_fn,            /* function to call on timeout. */
613                                         (success_function)success_fn, /* function to call on operation success. */
614                                         (fail_function)fail_fn,       /* function to call on operation fail. */
615                                         userdata)) == NULL) { 
616                p->locked = False;
617                free_packet(p);
618                return NULL;
619        } 
620       
621        return rrec;
622}
623
624/****************************************************************************
625 Queue a release name packet to the broadcast address of a subnet.
626****************************************************************************/
627
628struct response_record *queue_release_name( struct subnet_record *subrec,
629                                            response_function resp_fn,
630                                            timeout_response_function timeout_fn,
631                                            release_name_success_function success_fn,
632                                            release_name_fail_function fail_fn,
633                                            struct userdata_struct *userdata,
634                                            struct nmb_name *nmbname,
635                                            uint16 nb_flags,
636                                            struct in_addr release_ip,
637                                            struct in_addr dest_ip)
638{
639        struct packet_struct *p;
640        struct response_record *rrec;
641
642        if(assert_check_subnet(subrec))
643                return NULL;
644
645        if ((p = create_and_init_netbios_packet(nmbname, (subrec != unicast_subnet), False, dest_ip)) == NULL)
646                return NULL;
647
648        if(initiate_name_release_packet( p, nb_flags, &release_ip) == False) {
649                p->locked = False;
650                free_packet(p);
651                return NULL;
652        }
653
654        if((rrec = make_response_record(subrec,                /* subnet record. */
655                                        p,                     /* packet we sent. */
656                                        resp_fn,               /* function to call on response. */
657                                        timeout_fn,            /* function to call on timeout. */
658                                        (success_function)success_fn,            /* function to call on operation success. */
659                                        (fail_function)fail_fn,               /* function to call on operation fail. */
660                                        userdata)) == NULL)  {
661                p->locked = False;
662                free_packet(p);
663                return NULL;
664        }
665
666        /*
667         * For a broadcast release packet, only send once.
668         * This will cause us to remove the name asap. JRA.
669         */
670
671        if (subrec != unicast_subnet) {
672                rrec->repeat_count = 0;
673                rrec->repeat_time = 0;
674        }
675
676        return rrec;
677}
678
679/****************************************************************************
680 Queue a query name packet to the broadcast address of a subnet.
681****************************************************************************/
682 
683struct response_record *queue_query_name( struct subnet_record *subrec,
684                          response_function resp_fn,
685                          timeout_response_function timeout_fn,
686                          query_name_success_function success_fn,
687                          query_name_fail_function fail_fn,
688                          struct userdata_struct *userdata,
689                          struct nmb_name *nmbname)
690{
691        struct packet_struct *p;
692        struct response_record *rrec;
693        struct in_addr to_ip;
694
695        if(assert_check_subnet(subrec))
696                return NULL;
697
698        to_ip = subrec->bcast_ip;
699 
700        /* queries to the WINS server turn up here as queries to IP 0.0.0.0
701                        These need to be handled a bit differently */
702        if (subrec->type == UNICAST_SUBNET && is_zero_ip(to_ip)) {
703                /* What we really need to do is loop over each of our wins
704                 * servers and wins server tags here, but that just doesn't
705                 * fit our architecture at the moment (userdata may already
706                 * be used when we get here). For now we just query the first
707                 * active wins server on the first tag.
708                 */ 
709                char **tags = wins_srv_tags();
710                if (!tags) {
711                        return NULL;
712                }
713                to_ip = wins_srv_ip_tag(tags[0], to_ip);
714                wins_srv_tags_free(tags);
715        }
716
717        if(( p = create_and_init_netbios_packet(nmbname, 
718                                        (subrec != unicast_subnet), 
719                                        (subrec == unicast_subnet), 
720                                        to_ip)) == NULL)
721                return NULL;
722
723        if(lp_bind_interfaces_only()) {
724                int i;
725
726                DEBUG(10,("queue_query_name: bind_interfaces_only is set, looking for suitable source IP\n"));
727                for(i = 0; i < iface_count(); i++) {
728                        struct in_addr *ifip = iface_n_ip(i);
729
730                        if(ifip == NULL) {
731                                DEBUG(0,("queue_query_name: interface %d has NULL IP address !\n", i));
732                                continue;
733                        }
734
735                        if (ip_equal(*ifip,loopback_ip)) {
736                                DEBUG(5,("queue_query_name: ignoring loopback interface (%d)\n", i));
737                                continue;
738                        }
739
740                        DEBUG(10,("queue_query_name: using source IP %s\n",inet_ntoa(*ifip)));
741                                p->fd = find_subnet_fd_for_address( *ifip );
742                                break;
743                }
744        }
745
746        if(initiate_name_query_packet( p ) == False) {
747                p->locked = False;
748                free_packet(p);
749                return NULL;
750        }
751
752        if((rrec = make_response_record(subrec,                /* subnet record. */
753                                        p,                     /* packet we sent. */
754                                        resp_fn,               /* function to call on response. */
755                                        timeout_fn,            /* function to call on timeout. */
756                                        (success_function)success_fn,            /* function to call on operation success. */
757                                        (fail_function)fail_fn,               /* function to call on operation fail. */
758                                        userdata)) == NULL) {
759                p->locked = False;
760                free_packet(p);
761                return NULL;
762        }
763
764        return rrec;
765}
766
767/****************************************************************************
768 Queue a query name packet to a given address from the WINS subnet.
769****************************************************************************/
770 
771struct response_record *queue_query_name_from_wins_server( struct in_addr to_ip,
772                          response_function resp_fn,
773                          timeout_response_function timeout_fn,
774                          query_name_success_function success_fn,
775                          query_name_fail_function fail_fn,
776                          struct userdata_struct *userdata,
777                          struct nmb_name *nmbname)
778{
779        struct packet_struct *p;
780        struct response_record *rrec;
781
782        if ((p = create_and_init_netbios_packet(nmbname, False, False, to_ip)) == NULL)
783                return NULL;
784
785        if(initiate_name_query_packet_from_wins_server( p ) == False) {
786                p->locked = False;
787                free_packet(p);
788                return NULL;
789        }
790
791        if((rrec = make_response_record(wins_server_subnet,            /* subnet record. */
792                                                p,                     /* packet we sent. */
793                                                resp_fn,               /* function to call on response. */
794                                                timeout_fn,            /* function to call on timeout. */
795                                                (success_function)success_fn,            /* function to call on operation success. */
796                                                (fail_function)fail_fn,               /* function to call on operation fail. */
797                                                userdata)) == NULL) {
798                p->locked = False;
799                free_packet(p);
800                return NULL;
801        }
802
803        return rrec;
804}
805
806/****************************************************************************
807 Queue a node status packet to a given name and address.
808****************************************************************************/
809 
810struct response_record *queue_node_status( struct subnet_record *subrec,
811                          response_function resp_fn,
812                          timeout_response_function timeout_fn,
813                          node_status_success_function success_fn,
814                          node_status_fail_function fail_fn,
815                          struct userdata_struct *userdata,
816                          struct nmb_name *nmbname,
817                          struct in_addr send_ip)
818{
819        struct packet_struct *p;
820        struct response_record *rrec;
821
822        /* Sanity check. */
823        if(subrec != unicast_subnet) {
824                DEBUG(0,("queue_register_multihomed_name: should only be done on \
825unicast subnet. subnet is %s\n.", subrec->subnet_name ));
826                return NULL;
827        }
828
829        if(assert_check_subnet(subrec))
830                return NULL;
831
832        if(( p = create_and_init_netbios_packet(nmbname, False, False, send_ip)) == NULL)
833                return NULL;
834
835        if(initiate_node_status_packet(p) == False) {
836                p->locked = False;
837                free_packet(p);
838                return NULL;
839        } 
840
841        if((rrec = make_response_record(subrec,           /* subnet record. */
842                                        p,                     /* packet we sent. */
843                                        resp_fn,               /* function to call on response. */
844                                        timeout_fn,            /* function to call on timeout. */
845                                        (success_function)success_fn,            /* function to call on operation success. */
846                                        (fail_function)fail_fn,               /* function to call on operation fail. */
847                                        userdata)) == NULL) {
848                p->locked = False;
849                free_packet(p);
850                return NULL;
851        }
852
853        return rrec;
854}
855
856/****************************************************************************
857  Reply to a netbios name packet.  see rfc1002.txt
858****************************************************************************/
859
860void reply_netbios_packet(struct packet_struct *orig_packet,
861                          int rcode, enum netbios_reply_type_code rcv_code, int opcode,
862                          int ttl, char *data,int len)
863{
864        struct packet_struct packet;
865        struct nmb_packet *nmb = NULL;
866        struct res_rec answers;
867        struct nmb_packet *orig_nmb = &orig_packet->packet.nmb;
868        BOOL loopback_this_packet = False;
869        int rr_type = RR_TYPE_NB;
870        const char *packet_type = "unknown";
871 
872        /* Check if we are sending to or from ourselves. */
873        if(ismyip(orig_packet->ip) && (orig_packet->port == global_nmb_port))
874                loopback_this_packet = True;
875 
876        nmb = &packet.packet.nmb;
877
878        /* Do a partial copy of the packet. We clear the locked flag and
879                        the resource record pointers. */
880        packet = *orig_packet;   /* Full structure copy. */
881        packet.locked = False;
882        nmb->answers = NULL;
883        nmb->nsrecs = NULL;
884        nmb->additional = NULL;
885
886        switch (rcv_code) {
887                case NMB_STATUS:
888                        packet_type = "nmb_status";
889                        nmb->header.nm_flags.recursion_desired = False;
890                        nmb->header.nm_flags.recursion_available = False;
891                        rr_type = RR_TYPE_NBSTAT;
892                        break;
893                case NMB_QUERY:
894                        packet_type = "nmb_query";
895                        nmb->header.nm_flags.recursion_desired = True;
896                        nmb->header.nm_flags.recursion_available = True;
897                        if (rcode) {
898                                rr_type = RR_TYPE_NULL;
899                        }
900                        break;
901                case NMB_REG:
902                case NMB_REG_REFRESH:
903                        packet_type = "nmb_reg";
904                        nmb->header.nm_flags.recursion_desired = True;
905                        nmb->header.nm_flags.recursion_available = True;
906                        break;
907                case NMB_REL:
908                        packet_type = "nmb_rel";
909                        nmb->header.nm_flags.recursion_desired = False;
910                        nmb->header.nm_flags.recursion_available = False;
911                        break;
912                case NMB_WAIT_ACK:
913                        packet_type = "nmb_wack";
914                        nmb->header.nm_flags.recursion_desired = False;
915                        nmb->header.nm_flags.recursion_available = False;
916                        rr_type = RR_TYPE_NULL;
917                        break;
918                case WINS_REG:
919                        packet_type = "wins_reg";
920                        nmb->header.nm_flags.recursion_desired = True;
921                        nmb->header.nm_flags.recursion_available = True;
922                        break;
923                case WINS_QUERY:
924                        packet_type = "wins_query";
925                        nmb->header.nm_flags.recursion_desired = True;
926                        nmb->header.nm_flags.recursion_available = True;
927                        if (rcode) {
928                                rr_type = RR_TYPE_NULL;
929                        }
930                        break;
931                default:
932                        DEBUG(0,("reply_netbios_packet: Unknown packet type: %s %s to ip %s\n",
933                                packet_type, nmb_namestr(&orig_nmb->question.question_name),
934                                inet_ntoa(packet.ip)));
935                        return;
936        }
937
938        DEBUG(4,("reply_netbios_packet: sending a reply of packet type: %s %s to ip %s \
939for id %hu\n", packet_type, nmb_namestr(&orig_nmb->question.question_name),
940                        inet_ntoa(packet.ip), orig_nmb->header.name_trn_id));
941
942        nmb->header.name_trn_id = orig_nmb->header.name_trn_id;
943        nmb->header.opcode = opcode;
944        nmb->header.response = True;
945        nmb->header.nm_flags.bcast = False;
946        nmb->header.nm_flags.trunc = False;
947        nmb->header.nm_flags.authoritative = True;
948 
949        nmb->header.rcode = rcode;
950        nmb->header.qdcount = 0;
951        nmb->header.ancount = 1;
952        nmb->header.nscount = 0;
953        nmb->header.arcount = 0;
954 
955        memset((char*)&nmb->question,'\0',sizeof(nmb->question));
956 
957        nmb->answers = &answers;
958        memset((char*)nmb->answers,'\0',sizeof(*nmb->answers));
959 
960        nmb->answers->rr_name  = orig_nmb->question.question_name;
961        nmb->answers->rr_type  = rr_type;
962        nmb->answers->rr_class = RR_CLASS_IN;
963        nmb->answers->ttl      = ttl;
964 
965        if (data && len) {
966                nmb->answers->rdlength = len;
967                memcpy(nmb->answers->rdata, data, len);
968        }
969 
970        packet.packet_type = NMB_PACKET;
971        /* Ensure we send out on the same fd that the original
972                packet came in on to give the correct source IP address. */
973        packet.fd = orig_packet->fd;
974        packet.timestamp = time(NULL);
975
976        debug_nmb_packet(&packet);
977 
978        if(loopback_this_packet) {
979                struct packet_struct *lo_packet;
980                DEBUG(5,("reply_netbios_packet: sending packet to ourselves.\n"));
981                if((lo_packet = copy_packet(&packet)) == NULL)
982                        return;
983                queue_packet(lo_packet);
984        } else if (!send_packet(&packet)) {
985                DEBUG(0,("reply_netbios_packet: send_packet to IP %s port %d failed\n",
986                        inet_ntoa(packet.ip),packet.port));
987        }
988}
989
990/*******************************************************************
991  Queue a packet into a packet queue
992******************************************************************/
993
994static void queue_packet(struct packet_struct *packet)
995{
996        struct packet_struct *p;
997
998        if (!packet_queue) {
999                packet->prev = NULL;
1000                packet->next = NULL;
1001                packet_queue = packet;
1002                return;
1003        }
1004 
1005        /* find the bottom */
1006        for (p=packet_queue;p->next;p=p->next) 
1007                ;
1008
1009        p->next = packet;
1010        packet->next = NULL;
1011        packet->prev = p;
1012}
1013
1014/****************************************************************************
1015 Try and find a matching subnet record for a datagram port 138 packet.
1016****************************************************************************/
1017
1018static struct subnet_record *find_subnet_for_dgram_browse_packet(struct packet_struct *p)
1019{
1020        struct subnet_record *subrec;
1021
1022        /* Go through all the broadcast subnets and see if the mask matches. */
1023        for (subrec = FIRST_SUBNET; subrec ; subrec = NEXT_SUBNET_EXCLUDING_UNICAST(subrec)) {
1024                if(same_net(p->ip, subrec->bcast_ip, subrec->mask_ip))
1025                        return subrec;
1026        }
1027
1028        /* If the subnet record is the remote announce broadcast subnet,
1029                hack it here to be the first subnet. This is really gross and
1030                is needed due to people turning on port 137/138 broadcast
1031                forwarding on their routers. May fire and brimstone rain
1032                down upon them...
1033        */
1034
1035        return FIRST_SUBNET;
1036}
1037
1038/****************************************************************************
1039Dispatch a browse frame from port 138 to the correct processing function.
1040****************************************************************************/
1041
1042static void process_browse_packet(struct packet_struct *p, char *buf,int len)
1043{
1044        struct dgram_packet *dgram = &p->packet.dgram;
1045        int command = CVAL(buf,0);
1046        struct subnet_record *subrec = find_subnet_for_dgram_browse_packet(p);
1047        char scope[64];
1048        unstring src_name;
1049
1050        /* Drop the packet if it's a different NetBIOS scope, or the source is from one of our names. */
1051        pull_ascii(scope, dgram->dest_name.scope, 64, 64, STR_TERMINATE);
1052        if (!strequal(scope, global_scope())) {
1053                DEBUG(7,("process_browse_packet: Discarding datagram from IP %s. Scope (%s) \
1054mismatch with our scope (%s).\n", inet_ntoa(p->ip), scope, global_scope()));
1055                return;
1056        }
1057
1058        pull_ascii_nstring(src_name, sizeof(src_name), dgram->source_name.name);
1059        if (is_myname(src_name)) {
1060                DEBUG(0,("process_browse_packet: Discarding datagram from IP %s. Source name \
1061%s is one of our names !\n", inet_ntoa(p->ip), nmb_namestr(&dgram->source_name)));
1062                return;
1063        }
1064
1065        switch (command) {
1066                case ANN_HostAnnouncement:
1067                        debug_browse_data(buf, len);
1068                        process_host_announce(subrec, p, buf+1);
1069                        break;
1070                case ANN_DomainAnnouncement:
1071                        debug_browse_data(buf, len);
1072                        process_workgroup_announce(subrec, p, buf+1);
1073                        break;
1074                case ANN_LocalMasterAnnouncement:
1075                        debug_browse_data(buf, len);
1076                        process_local_master_announce(subrec, p, buf+1);
1077                        break;
1078                case ANN_AnnouncementRequest:
1079                        debug_browse_data(buf, len);
1080                        process_announce_request(subrec, p, buf+1);
1081                        break;
1082                case ANN_Election:
1083                        debug_browse_data(buf, len);
1084                        process_election(subrec, p, buf+1);
1085                        break;
1086                case ANN_GetBackupListReq:
1087                        debug_browse_data(buf, len);
1088                        process_get_backup_list_request(subrec, p, buf+1);
1089                        break;
1090                case ANN_GetBackupListResp:
1091                        debug_browse_data(buf, len);
1092                        /* We never send ANN_GetBackupListReq so we should never get these. */
1093                        DEBUG(0,("process_browse_packet: Discarding GetBackupListResponse \
1094packet from %s IP %s\n", nmb_namestr(&dgram->source_name), inet_ntoa(p->ip)));
1095                        break;
1096                case ANN_ResetBrowserState:
1097                        debug_browse_data(buf, len);
1098                        process_reset_browser(subrec, p, buf+1);
1099                        break;
1100                case ANN_MasterAnnouncement:
1101                        /* Master browser datagrams must be processed on the unicast subnet. */
1102                        subrec = unicast_subnet;
1103
1104                        debug_browse_data(buf, len);
1105                        process_master_browser_announce(subrec, p, buf+1);
1106                        break;
1107                case ANN_BecomeBackup:
1108                        /*
1109                         * We don't currently implement this. Log it just in case.
1110                         */
1111                        debug_browse_data(buf, len);
1112                        DEBUG(10,("process_browse_packet: On subnet %s ignoring browse packet \
1113command ANN_BecomeBackup from %s IP %s to %s\n", subrec->subnet_name, nmb_namestr(&dgram->source_name),
1114                                        inet_ntoa(p->ip), nmb_namestr(&dgram->dest_name)));
1115                        break;
1116                default:
1117                        debug_browse_data(buf, len);
1118                        DEBUG(0,("process_browse_packet: On subnet %s ignoring browse packet \
1119command code %d from %s IP %s to %s\n", subrec->subnet_name, command, nmb_namestr(&dgram->source_name),
1120                                inet_ntoa(p->ip), nmb_namestr(&dgram->dest_name)));
1121                        break;
1122        } 
1123}
1124
1125/****************************************************************************
1126 Dispatch a LanMan browse frame from port 138 to the correct processing function.
1127****************************************************************************/
1128
1129static void process_lanman_packet(struct packet_struct *p, char *buf,int len)
1130{
1131        struct dgram_packet *dgram = &p->packet.dgram;
1132        int command = SVAL(buf,0);
1133        struct subnet_record *subrec = find_subnet_for_dgram_browse_packet(p);
1134        char scope[64];
1135        unstring src_name;
1136
1137        /* Drop the packet if it's a different NetBIOS scope, or the source is from one of our names. */
1138
1139        pull_ascii(scope, dgram->dest_name.scope, 64, 64, STR_TERMINATE);
1140        if (!strequal(scope, global_scope())) {
1141                DEBUG(7,("process_lanman_packet: Discarding datagram from IP %s. Scope (%s) \
1142mismatch with our scope (%s).\n", inet_ntoa(p->ip), scope, global_scope()));
1143                return;
1144        }
1145
1146        pull_ascii_nstring(src_name, sizeof(src_name), dgram->source_name.name);
1147        if (is_myname(src_name)) {
1148                DEBUG(0,("process_lanman_packet: Discarding datagram from IP %s. Source name \
1149%s is one of our names !\n", inet_ntoa(p->ip), nmb_namestr(&dgram->source_name)));
1150                return;
1151        }
1152
1153        switch (command) {
1154                case ANN_HostAnnouncement:
1155                        debug_browse_data(buf, len);
1156                        process_lm_host_announce(subrec, p, buf+1, len > 1 ? len-1 : 0);
1157                        break;
1158                case ANN_AnnouncementRequest:
1159                        process_lm_announce_request(subrec, p, buf+1, len > 1 ? len-1 : 0);
1160                        break;
1161                default:
1162                        DEBUG(0,("process_lanman_packet: On subnet %s ignoring browse packet \
1163command code %d from %s IP %s to %s\n", subrec->subnet_name, command, nmb_namestr(&dgram->source_name),
1164                                inet_ntoa(p->ip), nmb_namestr(&dgram->dest_name)));
1165                        break;
1166        }
1167}
1168
1169/****************************************************************************
1170  Determine if a packet is for us on port 138. Note that to have any chance of
1171  being efficient we need to drop as many packets as possible at this
1172  stage as subsequent processing is expensive.
1173****************************************************************************/
1174
1175static BOOL listening(struct packet_struct *p,struct nmb_name *nbname)
1176{
1177        struct subnet_record *subrec = NULL;
1178
1179        for (subrec = FIRST_SUBNET; subrec ; subrec = NEXT_SUBNET_EXCLUDING_UNICAST(subrec)) {
1180                if(same_net(p->ip, subrec->bcast_ip, subrec->mask_ip))
1181                        break;
1182        }
1183
1184        if(subrec == NULL)
1185                subrec = unicast_subnet;
1186
1187        return (find_name_on_subnet(subrec, nbname, FIND_SELF_NAME) != NULL);
1188}
1189
1190/****************************************************************************
1191  Process udp 138 datagrams
1192****************************************************************************/
1193
1194static void process_dgram(struct packet_struct *p)
1195{
1196        char *buf;
1197        char *buf2;
1198        int len;
1199        struct dgram_packet *dgram = &p->packet.dgram;
1200
1201        /* If we aren't listening to the destination name then ignore the packet */
1202        if (!listening(p,&dgram->dest_name)) {
1203                        unexpected_packet(p);
1204                        DEBUG(5,("process_dgram: ignoring dgram packet sent to name %s from %s\n",
1205                                nmb_namestr(&dgram->dest_name), inet_ntoa(p->ip)));
1206                        return;
1207        }
1208
1209        if (dgram->header.msg_type != 0x10 && dgram->header.msg_type != 0x11 && dgram->header.msg_type != 0x12) {
1210                unexpected_packet(p);
1211                /* Don't process error packets etc yet */
1212                DEBUG(5,("process_dgram: ignoring dgram packet sent to name %s from IP %s as it is \
1213an error packet of type %x\n", nmb_namestr(&dgram->dest_name), inet_ntoa(p->ip), dgram->header.msg_type));
1214                return;
1215        }
1216
1217        /* Ensure we have a large enough packet before looking inside. */
1218        if (dgram->datasize < (smb_vwv12 - 2)) {
1219                /* That's the offset minus the 4 byte length + 2 bytes of offset. */
1220                DEBUG(0,("process_dgram: ignoring too short dgram packet (%u) sent to name %s from IP %s\n",
1221                        (unsigned int)dgram->datasize,
1222                        nmb_namestr(&dgram->dest_name),
1223                        inet_ntoa(p->ip) ));
1224                return;
1225        }
1226
1227        buf = &dgram->data[0];
1228        buf -= 4; /* XXXX for the pseudo tcp length - someday I need to get rid of this */
1229
1230        if (CVAL(buf,smb_com) != SMBtrans)
1231                return;
1232
1233        len = SVAL(buf,smb_vwv11);
1234        buf2 = smb_base(buf) + SVAL(buf,smb_vwv12);
1235
1236        if (len <= 0 || len > dgram->datasize) {
1237                DEBUG(0,("process_dgram: ignoring malformed1 (datasize = %d, len = %d) datagram \
1238packet sent to name %s from IP %s\n",
1239                        dgram->datasize,
1240                        len,
1241                        nmb_namestr(&dgram->dest_name),
1242                        inet_ntoa(p->ip) ));
1243                return;
1244        }
1245
1246        if (buf2 < dgram->data || (buf2 >= dgram->data + dgram->datasize)) {
1247                DEBUG(0,("process_dgram: ignoring malformed2 (datasize = %d, len=%d, off=%d) datagram \
1248packet sent to name %s from IP %s\n",
1249                        dgram->datasize,
1250                        len,
1251                        (int)PTR_DIFF(buf2, dgram->data),
1252                        nmb_namestr(&dgram->dest_name),
1253                        inet_ntoa(p->ip) ));
1254                return;
1255        }
1256
1257        if ((buf2 + len < dgram->data) || (buf2 + len > dgram->data + dgram->datasize)) {
1258                DEBUG(0,("process_dgram: ignoring malformed3 (datasize = %d, len=%d, off=%d) datagram \
1259packet sent to name %s from IP %s\n",
1260                        dgram->datasize,
1261                        len,
1262                        (int)PTR_DIFF(buf2, dgram->data),
1263                        nmb_namestr(&dgram->dest_name),
1264                        inet_ntoa(p->ip) ));
1265                return;
1266        }
1267
1268        DEBUG(4,("process_dgram: datagram from %s to %s IP %s for %s of type %d len=%d\n",
1269                nmb_namestr(&dgram->source_name),nmb_namestr(&dgram->dest_name),
1270                inet_ntoa(p->ip), smb_buf(buf),CVAL(buf2,0),len));
1271
1272        /* Datagram packet received for the browser mailslot */
1273        if (strequal(smb_buf(buf),BROWSE_MAILSLOT)) {
1274                process_browse_packet(p,buf2,len);
1275                return;
1276        }
1277
1278        /* Datagram packet received for the LAN Manager mailslot */
1279        if (strequal(smb_buf(buf),LANMAN_MAILSLOT)) {
1280                process_lanman_packet(p,buf2,len);
1281                return;
1282        }
1283
1284        /* Datagram packet received for the domain logon mailslot */
1285        if (strequal(smb_buf(buf),NET_LOGON_MAILSLOT)) {
1286                process_logon_packet(p,buf2,len,NET_LOGON_MAILSLOT);
1287                return;
1288        }
1289
1290        /* Datagram packet received for the NT domain logon mailslot */
1291        if (strequal(smb_buf(buf),NT_LOGON_MAILSLOT)) {
1292                process_logon_packet(p,buf2,len,NT_LOGON_MAILSLOT);
1293                return;
1294        }
1295
1296        unexpected_packet(p);
1297}
1298
1299/****************************************************************************
1300  Validate a response nmb packet.
1301****************************************************************************/
1302
1303static BOOL validate_nmb_response_packet( struct nmb_packet *nmb )
1304{
1305        BOOL ignore = False;
1306
1307        switch (nmb->header.opcode) {
1308                case NMB_NAME_REG_OPCODE:
1309                case NMB_NAME_REFRESH_OPCODE_8: /* ambiguity in rfc1002 about which is correct. */
1310                case NMB_NAME_REFRESH_OPCODE_9: /* WinNT uses 8 by default. */
1311                        if (nmb->header.ancount == 0) {
1312                                DEBUG(0,("validate_nmb_response_packet: Bad REG/REFRESH Packet. "));
1313                                ignore = True;
1314                        }
1315                        break;
1316
1317                case NMB_NAME_QUERY_OPCODE:
1318                        if ((nmb->header.ancount != 0) && (nmb->header.ancount != 1)) {
1319                                DEBUG(0,("validate_nmb_response_packet: Bad QUERY Packet. "));
1320                                ignore = True;
1321                        }
1322                        break;
1323
1324                case NMB_NAME_RELEASE_OPCODE:
1325                        if (nmb->header.ancount == 0) {
1326                                DEBUG(0,("validate_nmb_response_packet: Bad RELEASE Packet. "));
1327                                ignore = True;
1328                        }
1329                        break;
1330
1331                case NMB_WACK_OPCODE:
1332                        /* Check WACK response here. */
1333                        if (nmb->header.ancount != 1) {
1334                                DEBUG(0,("validate_nmb_response_packet: Bad WACK Packet. "));
1335                                ignore = True;
1336                        }
1337                        break;
1338                default:
1339                        DEBUG(0,("validate_nmb_response_packet: Ignoring packet with unknown opcode %d.\n",
1340                                        nmb->header.opcode));
1341                        return True;
1342        }
1343
1344        if(ignore)
1345                DEBUG(0,("Ignoring response packet with opcode %d.\n", nmb->header.opcode));
1346
1347        return ignore;
1348}
1349 
1350/****************************************************************************
1351  Validate a request nmb packet.
1352****************************************************************************/
1353
1354static BOOL validate_nmb_packet( struct nmb_packet *nmb )
1355{
1356        BOOL ignore = False;
1357
1358        switch (nmb->header.opcode) {
1359                case NMB_NAME_REG_OPCODE:
1360                case NMB_NAME_REFRESH_OPCODE_8: /* ambiguity in rfc1002 about which is correct. */
1361                case NMB_NAME_REFRESH_OPCODE_9: /* WinNT uses 8 by default. */
1362                case NMB_NAME_MULTIHOMED_REG_OPCODE:
1363                        if (nmb->header.qdcount==0 || nmb->header.arcount==0) {
1364                                DEBUG(0,("validate_nmb_packet: Bad REG/REFRESH Packet. "));
1365                                ignore = True;
1366                        }
1367                        break;
1368
1369                case NMB_NAME_QUERY_OPCODE:
1370                        if ((nmb->header.qdcount == 0) || ((nmb->question.question_type != QUESTION_TYPE_NB_QUERY) &&
1371                                        (nmb->question.question_type != QUESTION_TYPE_NB_STATUS))) {
1372                                DEBUG(0,("validate_nmb_packet: Bad QUERY Packet. "));
1373                                ignore = True;
1374                        }
1375                        break;
1376
1377                case NMB_NAME_RELEASE_OPCODE:
1378                        if (nmb->header.qdcount==0 || nmb->header.arcount==0) {
1379                                DEBUG(0,("validate_nmb_packet: Bad RELEASE Packet. "));
1380                                ignore = True;
1381                        }
1382                        break;
1383                default:
1384                        DEBUG(0,("validate_nmb_packet: Ignoring packet with unknown opcode %d.\n",
1385                                nmb->header.opcode));
1386                        return True;
1387        }
1388
1389        if(ignore)
1390                DEBUG(0,("validate_nmb_packet: Ignoring request packet with opcode %d.\n", nmb->header.opcode));
1391
1392        return ignore;
1393}
1394
1395/****************************************************************************
1396  Find a subnet (and potentially a response record) for a packet.
1397****************************************************************************/
1398
1399static struct subnet_record *find_subnet_for_nmb_packet( struct packet_struct *p,
1400                                                         struct response_record **pprrec)
1401{
1402        struct nmb_packet *nmb = &p->packet.nmb;
1403        struct response_record *rrec = NULL;
1404        struct subnet_record *subrec = NULL;
1405
1406        if(pprrec != NULL)
1407                *pprrec = NULL;
1408
1409        if(nmb->header.response) {
1410                /* It's a response packet. Find a record for it or it's an error. */
1411
1412                rrec = find_response_record( &subrec, nmb->header.name_trn_id);
1413                if(rrec == NULL) {
1414                        DEBUG(3,("find_subnet_for_nmb_packet: response record not found for response id %hu\n",
1415                                nmb->header.name_trn_id));
1416                        unexpected_packet(p);
1417                        return NULL;
1418                }
1419
1420                if(subrec == NULL) {
1421                        DEBUG(0,("find_subnet_for_nmb_packet: subnet record not found for response id %hu\n",
1422                                nmb->header.name_trn_id));
1423                        return NULL;
1424                }
1425
1426                if(pprrec != NULL)
1427                        *pprrec = rrec;
1428                return subrec;
1429        }
1430
1431        /* Try and see what subnet this packet belongs to. */
1432
1433        /* WINS server ? */
1434        if(packet_is_for_wins_server(p))
1435                return wins_server_subnet;
1436
1437        /* If it wasn't a broadcast packet then send to the UNICAST subnet. */
1438        if(nmb->header.nm_flags.bcast == False)
1439                return unicast_subnet;
1440
1441        /* Go through all the broadcast subnets and see if the mask matches. */
1442        for (subrec = FIRST_SUBNET; subrec ; subrec = NEXT_SUBNET_EXCLUDING_UNICAST(subrec)) {
1443                if(same_net(p->ip, subrec->bcast_ip, subrec->mask_ip))
1444                        return subrec;
1445        }
1446
1447        /* If none match it must have been a directed broadcast - assign the remote_broadcast_subnet. */
1448        return remote_broadcast_subnet;
1449}
1450
1451/****************************************************************************
1452  Process a nmb request packet - validate the packet and route it.
1453****************************************************************************/
1454
1455static void process_nmb_request(struct packet_struct *p)
1456{
1457        struct nmb_packet *nmb = &p->packet.nmb;
1458        struct subnet_record *subrec = NULL;
1459
1460        debug_nmb_packet(p);
1461
1462        /* Ensure we have a good packet. */
1463        if(validate_nmb_packet(nmb))
1464                return;
1465
1466        /* Allocate a subnet to this packet - if we cannot - fail. */
1467        if((subrec = find_subnet_for_nmb_packet(p, NULL))==NULL)
1468                return;
1469
1470        switch (nmb->header.opcode) {
1471                case NMB_NAME_REG_OPCODE:
1472                        if(subrec == wins_server_subnet)
1473                                wins_process_name_registration_request(subrec, p);
1474                        else
1475                                process_name_registration_request(subrec, p);
1476                        break;
1477
1478                case NMB_NAME_REFRESH_OPCODE_8: /* ambiguity in rfc1002 about which is correct. */
1479                case NMB_NAME_REFRESH_OPCODE_9:
1480                        if(subrec == wins_server_subnet)
1481                                wins_process_name_refresh_request(subrec, p);
1482                        else
1483                                process_name_refresh_request(subrec, p);
1484                        break;
1485
1486                case NMB_NAME_MULTIHOMED_REG_OPCODE:
1487                        if(subrec == wins_server_subnet) {
1488                                wins_process_multihomed_name_registration_request(subrec, p);
1489                        } else {
1490                                DEBUG(0,("process_nmb_request: Multihomed registration request must be \
1491directed at a WINS server.\n"));
1492                        }
1493                        break;
1494
1495                case NMB_NAME_QUERY_OPCODE:
1496                        switch (nmb->question.question_type) {
1497                                case QUESTION_TYPE_NB_QUERY:
1498                                        if(subrec == wins_server_subnet)
1499                                                wins_process_name_query_request(subrec, p);
1500                                        else
1501                                                process_name_query_request(subrec, p);
1502                                        break;
1503                                case QUESTION_TYPE_NB_STATUS:
1504                                        if(subrec == wins_server_subnet) {
1505                                                DEBUG(0,("process_nmb_request: NB_STATUS request directed at WINS server is \
1506not allowed.\n"));
1507                                                break;
1508                                        } else {
1509                                                process_node_status_request(subrec, p);
1510                                        }
1511                                        break;
1512                        }
1513                        break;
1514     
1515                case NMB_NAME_RELEASE_OPCODE:
1516                        if(subrec == wins_server_subnet)
1517                                wins_process_name_release_request(subrec, p);
1518                        else
1519                                process_name_release_request(subrec, p);
1520                        break;
1521        }
1522}
1523
1524/****************************************************************************
1525  Process a nmb response packet - validate the packet and route it.
1526  to either the WINS server or a normal response.
1527****************************************************************************/
1528
1529static void process_nmb_response(struct packet_struct *p)
1530{
1531        struct nmb_packet *nmb = &p->packet.nmb;
1532        struct subnet_record *subrec = NULL;
1533        struct response_record *rrec = NULL;
1534
1535        debug_nmb_packet(p);
1536
1537        if(validate_nmb_response_packet(nmb))
1538                return;
1539
1540        if((subrec = find_subnet_for_nmb_packet(p, &rrec))==NULL)
1541                return;
1542
1543        if(rrec == NULL) {
1544                DEBUG(0,("process_nmb_response: response packet received but no response record \
1545found for id = %hu. Ignoring packet.\n", nmb->header.name_trn_id));
1546                return;
1547        }
1548
1549        /* Increment the number of responses received for this record. */
1550        rrec->num_msgs++;
1551        /* Ensure we don't re-send the request. */
1552        rrec->repeat_count = 0;
1553 
1554        /* Call the response received function for this packet. */
1555        (*rrec->resp_fn)(subrec, rrec, p);
1556}
1557
1558/*******************************************************************
1559  Run elements off the packet queue till its empty
1560******************************************************************/
1561
1562void run_packet_queue(void)
1563{
1564        struct packet_struct *p;
1565
1566        while ((p = packet_queue)) {
1567                packet_queue = p->next;
1568                if (packet_queue)
1569                        packet_queue->prev = NULL;
1570                p->next = p->prev = NULL;
1571
1572                switch (p->packet_type) {
1573                        case NMB_PACKET:
1574                                if(p->packet.nmb.header.response)
1575                                        process_nmb_response(p);
1576                                else
1577                                        process_nmb_request(p);
1578                                break;
1579
1580                        case DGRAM_PACKET:
1581                                process_dgram(p);
1582                                break;
1583                }
1584                free_packet(p);
1585        }
1586} 
1587
1588/*******************************************************************
1589 Retransmit or timeout elements from all the outgoing subnet response
1590 record queues. NOTE that this code must also check the WINS server
1591 subnet for response records to timeout as the WINS server code
1592 can send requests to check if a client still owns a name.
1593 (Patch from Andrey Alekseyev <fetch@muffin.arcadia.spb.ru>).
1594******************************************************************/
1595
1596void retransmit_or_expire_response_records(time_t t)
1597{
1598        struct subnet_record *subrec;
1599
1600        for (subrec = FIRST_SUBNET; subrec; subrec = get_next_subnet_maybe_unicast_or_wins_server(subrec)) {
1601                struct response_record *rrec, *nextrrec;
1602
1603                for (rrec = subrec->responselist; rrec; rrec = nextrrec) {
1604                        nextrrec = rrec->next;
1605   
1606                        if (rrec->repeat_time <= t) {
1607                                if (rrec->repeat_count > 0) {
1608                                        /* Resend while we have a non-zero repeat_count. */
1609                                        if(!send_packet(rrec->packet)) {
1610                                                DEBUG(0,("retransmit_or_expire_response_records: Failed to resend packet id %hu \
1611to IP %s on subnet %s\n", rrec->response_id, inet_ntoa(rrec->packet->ip), subrec->subnet_name));
1612                                        }
1613                                        rrec->repeat_time = t + rrec->repeat_interval;
1614                                        rrec->repeat_count--;
1615                                } else {
1616                                        DEBUG(4,("retransmit_or_expire_response_records: timeout for packet id %hu to IP %s \
1617on subnet %s\n", rrec->response_id, inet_ntoa(rrec->packet->ip), subrec->subnet_name));
1618
1619                                        /*
1620                                         * Check the flag in this record to prevent recursion if we end
1621                                         * up in this function again via the timeout function call.
1622                                         */
1623
1624                                        if(!rrec->in_expiration_processing) {
1625
1626                                                /*
1627                                                 * Set the recursion protection flag in this record.
1628                                                 */
1629
1630                                                rrec->in_expiration_processing = True;
1631
1632                                                /* Call the timeout function. This will deal with removing the
1633                                                                timed out packet. */
1634                                                if(rrec->timeout_fn) {
1635                                                        (*rrec->timeout_fn)(subrec, rrec);
1636                                                } else {
1637                                                        /* We must remove the record ourself if there is
1638                                                                        no timeout function. */
1639                                                        remove_response_record(subrec, rrec);
1640                                                }
1641                                        } /* !rrec->in_expitation_processing */
1642                                } /* rrec->repeat_count > 0 */
1643                        } /* rrec->repeat_time <= t */
1644                } /* end for rrec */
1645        } /* end for subnet */
1646}
1647
1648/****************************************************************************
1649  Create an fd_set containing all the sockets in the subnet structures,
1650  plus the broadcast sockets.
1651***************************************************************************/
1652
1653static BOOL create_listen_fdset(fd_set **ppset, int **psock_array, int *listen_number, int *maxfd)
1654{
1655        int *sock_array = NULL;
1656        struct subnet_record *subrec = NULL;
1657        int count = 0;
1658        int num = 0;
1659        fd_set *pset = SMB_MALLOC_P(fd_set);
1660
1661        if(pset == NULL) {
1662                DEBUG(0,("create_listen_fdset: malloc fail !\n"));
1663                return True;
1664        }
1665
1666        /* Check that we can add all the fd's we need. */
1667        for (subrec = FIRST_SUBNET; subrec; subrec = NEXT_SUBNET_EXCLUDING_UNICAST(subrec))
1668                count++;
1669
1670        if((count*2) + 2 > FD_SETSIZE) {
1671                DEBUG(0,("create_listen_fdset: Too many file descriptors needed (%d). We can \
1672only use %d.\n", (count*2) + 2, FD_SETSIZE));
1673                SAFE_FREE(pset);
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                SAFE_FREE(pset);
1680                return True;
1681        }
1682
1683        FD_ZERO(pset);
1684
1685        /* Add in the broadcast socket on 137. */
1686        FD_SET(ClientNMB,pset);
1687        sock_array[num++] = ClientNMB;
1688        *maxfd = MAX( *maxfd, ClientNMB);
1689
1690        /* Add in the 137 sockets on all the interfaces. */
1691        for (subrec = FIRST_SUBNET; subrec; subrec = NEXT_SUBNET_EXCLUDING_UNICAST(subrec)) {
1692                FD_SET(subrec->nmb_sock,pset);
1693                sock_array[num++] = subrec->nmb_sock;
1694                *maxfd = MAX( *maxfd, subrec->nmb_sock);
1695        }
1696
1697        /* Add in the broadcast socket on 138. */
1698        FD_SET(ClientDGRAM,pset);
1699        sock_array[num++] = ClientDGRAM;
1700        *maxfd = MAX( *maxfd, ClientDGRAM);
1701
1702        /* Add in the 138 sockets on all the interfaces. */
1703        for (subrec = FIRST_SUBNET; subrec; subrec = NEXT_SUBNET_EXCLUDING_UNICAST(subrec)) {
1704                FD_SET(subrec->dgram_sock,pset);
1705                sock_array[num++] = subrec->dgram_sock;
1706                *maxfd = MAX( *maxfd, subrec->dgram_sock);
1707        }
1708
1709        *listen_number = (count*2) + 2;
1710
1711        SAFE_FREE(*ppset);
1712        SAFE_FREE(*psock_array);
1713
1714        *ppset = pset;
1715        *psock_array = sock_array;
1716 
1717        return False;
1718}
1719
1720/****************************************************************************
1721  Listens for NMB or DGRAM packets, and queues them.
1722  return True if the socket is dead
1723***************************************************************************/
1724
1725BOOL listen_for_packets(BOOL run_election)
1726{
1727        static fd_set *listen_set = NULL;
1728        static int listen_number = 0;
1729        static int *sock_array = NULL;
1730        int i;
1731        static int maxfd = 0;
1732
1733        fd_set fds;
1734        int selrtn;
1735        struct timeval timeout;
1736#ifndef SYNC_DNS
1737        int dns_fd;
1738#endif
1739
1740        if(listen_set == NULL || rescan_listen_set) {
1741                if(create_listen_fdset(&listen_set, &sock_array, &listen_number, &maxfd)) {
1742                        DEBUG(0,("listen_for_packets: Fatal error. unable to create listen set. Exiting.\n"));
1743                        return True;
1744                }
1745                rescan_listen_set = False;
1746        }
1747
1748        memcpy((char *)&fds, (char *)listen_set, sizeof(fd_set));
1749
1750#ifndef SYNC_DNS
1751        dns_fd = asyncdns_fd();
1752        if (dns_fd != -1) {
1753                FD_SET(dns_fd, &fds);
1754                maxfd = MAX( maxfd, dns_fd);
1755        }
1756#endif
1757
1758        /*
1759         * During elections and when expecting a netbios response packet we
1760         * need to send election packets at tighter intervals.
1761         * Ideally it needs to be the interval (in ms) between time now and
1762         * the time we are expecting the next netbios packet.
1763         */
1764
1765        timeout.tv_sec = (run_election||num_response_packets) ? 1 : NMBD_SELECT_LOOP;
1766        timeout.tv_usec = 0;
1767
1768        /* Prepare for the select - allow certain signals. */
1769
1770        BlockSignals(False, SIGTERM);
1771
1772        selrtn = sys_select(maxfd+1,&fds,NULL,NULL,&timeout);
1773
1774        /* We can only take signals when we are in the select - block them again here. */
1775
1776        BlockSignals(True, SIGTERM);
1777
1778        if(selrtn == -1) {
1779                return False;
1780        }
1781
1782#ifndef SYNC_DNS
1783        if (dns_fd != -1 && FD_ISSET(dns_fd,&fds)) {
1784                run_dns_queue();
1785        }
1786#endif
1787
1788        for(i = 0; i < listen_number; i++) {
1789                if (i < (listen_number/2)) {
1790                        /* Processing a 137 socket. */
1791                        if (FD_ISSET(sock_array[i],&fds)) {
1792                                struct packet_struct *packet = read_packet(sock_array[i], NMB_PACKET);
1793                                if (packet) {
1794                                        /*
1795                                         * If we got a packet on the broadcast socket and interfaces
1796                                         * only is set then check it came from one of our local nets.
1797                                         */
1798                                        if(lp_bind_interfaces_only() && (sock_array[i] == ClientNMB) && 
1799                                                                (!is_local_net(packet->ip))) {
1800                                                DEBUG(7,("discarding nmb packet sent to broadcast socket from %s:%d\n",
1801                                                        inet_ntoa(packet->ip),packet->port));     
1802                                                free_packet(packet);
1803                                        } else if ((ip_equal(loopback_ip, packet->ip) || 
1804                                                                ismyip(packet->ip)) && packet->port == global_nmb_port &&
1805                                                                packet->packet.nmb.header.nm_flags.bcast) {
1806                                                DEBUG(7,("discarding own bcast packet from %s:%d\n",
1807                                                        inet_ntoa(packet->ip),packet->port));     
1808                                                free_packet(packet);
1809                                        } else {
1810                                                /* Save the file descriptor this packet came in on. */
1811                                                packet->fd = sock_array[i];
1812                                                queue_packet(packet);
1813                                        }
1814                                }
1815                        }
1816                } else {
1817                        /* Processing a 138 socket. */
1818                                if (FD_ISSET(sock_array[i],&fds)) {
1819                                struct packet_struct *packet = read_packet(sock_array[i], DGRAM_PACKET);
1820                                if (packet) {
1821                                        /*
1822                                         * If we got a packet on the broadcast socket and interfaces
1823                                         * only is set then check it came from one of our local nets.
1824                                         */
1825                                        if(lp_bind_interfaces_only() && (sock_array[i] == ClientDGRAM) && 
1826                                                                (!is_local_net(packet->ip))) {
1827                                                DEBUG(7,("discarding dgram packet sent to broadcast socket from %s:%d\n",
1828                                                inet_ntoa(packet->ip),packet->port));     
1829                                                free_packet(packet);
1830                                        } else if ((ip_equal(loopback_ip, packet->ip) || 
1831                                                        ismyip(packet->ip)) && packet->port == DGRAM_PORT) {
1832                                                DEBUG(7,("discarding own dgram packet from %s:%d\n",
1833                                                        inet_ntoa(packet->ip),packet->port));     
1834                                                free_packet(packet);
1835                                        } else {
1836                                                /* Save the file descriptor this packet came in on. */
1837                                                packet->fd = sock_array[i];
1838                                                queue_packet(packet);
1839                                        }
1840                                }
1841                        }
1842                } /* end processing 138 socket. */
1843        } /* end for */
1844        return False;
1845}
1846
1847/****************************************************************************
1848  Construct and send a netbios DGRAM.
1849**************************************************************************/
1850
1851BOOL send_mailslot(BOOL unique, const char *mailslot,char *buf, size_t len,
1852                   const char *srcname, int src_type,
1853                   const char *dstname, int dest_type,
1854                   struct in_addr dest_ip,struct in_addr src_ip,
1855                   int dest_port)
1856{
1857        BOOL loopback_this_packet = False;
1858        struct packet_struct p;
1859        struct dgram_packet *dgram = &p.packet.dgram;
1860        char *ptr,*p2;
1861        char tmp[4];
1862
1863        memset((char *)&p,'\0',sizeof(p));
1864
1865        if(ismyip(dest_ip) && (dest_port == DGRAM_PORT)) /* Only if to DGRAM_PORT */
1866                loopback_this_packet = True;
1867
1868        /* generate_name_trn_id(); */ /* Not used, so gone, RJS */
1869
1870        /* DIRECT GROUP or UNIQUE datagram. */
1871        dgram->header.msg_type = unique ? 0x10 : 0x11; 
1872        dgram->header.flags.node_type = M_NODE;
1873        dgram->header.flags.first = True;
1874        dgram->header.flags.more = False;
1875        dgram->header.dgm_id = generate_name_trn_id();
1876        dgram->header.source_ip = src_ip;
1877        dgram->header.source_port = DGRAM_PORT;
1878        dgram->header.dgm_length = 0; /* Let build_dgram() handle this. */
1879        dgram->header.packet_offset = 0;
1880 
1881        make_nmb_name(&dgram->source_name,srcname,src_type);
1882        make_nmb_name(&dgram->dest_name,dstname,dest_type);
1883
1884        ptr = &dgram->data[0];
1885
1886        /* Setup the smb part. */
1887        ptr -= 4; /* XXX Ugliness because of handling of tcp SMB length. */
1888        memcpy(tmp,ptr,4);
1889        set_message(ptr,17,strlen(mailslot) + 1 + len,True);
1890        memcpy(ptr,tmp,4);
1891
1892        SCVAL(ptr,smb_com,SMBtrans);
1893        SSVAL(ptr,smb_vwv1,len);
1894        SSVAL(ptr,smb_vwv11,len);
1895        SSVAL(ptr,smb_vwv12,70 + strlen(mailslot));
1896        SSVAL(ptr,smb_vwv13,3);
1897        SSVAL(ptr,smb_vwv14,1);
1898        SSVAL(ptr,smb_vwv15,1);
1899        SSVAL(ptr,smb_vwv16,2);
1900        p2 = smb_buf(ptr);
1901        safe_strcpy_base(p2, mailslot, dgram->data, sizeof(dgram->data));
1902        p2 = skip_string(ptr,MAX_DGRAM_SIZE,p2);
1903 
1904        if (((p2+len) > dgram->data+sizeof(dgram->data)) || ((p2+len) < p2)) {
1905                DEBUG(0, ("send_mailslot: Cannot write beyond end of packet\n"));
1906                return False;
1907        } else {
1908                memcpy(p2,buf,len);
1909                p2 += len;
1910        }
1911
1912        dgram->datasize = PTR_DIFF(p2,ptr+4); /* +4 for tcp length. */
1913
1914        p.ip = dest_ip;
1915        p.port = dest_port;
1916        p.fd = find_subnet_mailslot_fd_for_address( src_ip );
1917        p.timestamp = time(NULL);
1918        p.packet_type = DGRAM_PACKET;
1919
1920        DEBUG(4,("send_mailslot: Sending to mailslot %s from %s IP %s ", mailslot,
1921                        nmb_namestr(&dgram->source_name), inet_ntoa(src_ip)));
1922        DEBUG(4,("to %s IP %s\n", nmb_namestr(&dgram->dest_name), inet_ntoa(dest_ip)));
1923
1924        debug_browse_data(buf, len);
1925
1926        if(loopback_this_packet) {
1927                struct packet_struct *lo_packet = NULL;
1928                DEBUG(5,("send_mailslot: sending packet to ourselves.\n"));
1929                if((lo_packet = copy_packet(&p)) == NULL)
1930                        return False;
1931                queue_packet(lo_packet);
1932                return True;
1933        } else {
1934                return(send_packet(&p));
1935        }
1936}
Note: See TracBrowser for help on using the repository browser.