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