?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
pyldb: add tests for getting control results
[Samba.git] / source3 / libsmb / nmblib.c
blobae7ad996b387a4fbcd6250431ebfed63809c417d
1 /*
2 Unix SMB/CIFS implementation.
3 NBT netbios library routines
4 Copyright (C) Andrew Tridgell 1994-1998
5 Copyright (C) Jeremy Allison 2007
6
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
11
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
16
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>.
19
20 */
21
22 #include "includes.h"
23 #include "../lib/util/select.h"
24
25 static const struct opcode_names {
26 const char *nmb_opcode_name;
27 int opcode;
28 } nmb_header_opcode_names[] = {
29 {"Query", 0 },
30 {"Registration", 5 },
31 {"Release", 6 },
32 {"WACK", 7 },
33 {"Refresh", 8 },
34 {"Refresh(altcode)", 9 },
35 {"Multi-homed Registration", 15 },
36 {0, -1 }
37 };
38
39 /****************************************************************************
40 Lookup a nmb opcode name.
41 ****************************************************************************/
42
43 static const char *lookup_opcode_name( int opcode )
44 {
45 const struct opcode_names *op_namep;
46 int i;
47
48 for(i = 0; nmb_header_opcode_names[i].nmb_opcode_name != 0; i++) {
49 op_namep = &nmb_header_opcode_names[i];
50 if(opcode == op_namep->opcode)
51 return op_namep->nmb_opcode_name;
52 }
53 return "<unknown opcode>";
54 }
55
56 /****************************************************************************
57 Print out a res_rec structure.
58 ****************************************************************************/
59
60 static void debug_nmb_res_rec(struct res_rec *res, const char *hdr)
61 {
62 int i, j;
63
64 DEBUGADD( 4, ( " %s: nmb_name=%s rr_type=%d rr_class=%d ttl=%d\n",
65 hdr,
66 nmb_namestr(&res->rr_name),
67 res->rr_type,
68 res->rr_class,
69 res->ttl ) );
70
71 if( res->rdlength == 0 || res->rdata == NULL )
72 return;
73
74 for (i = 0; i < res->rdlength; i+= MAX_NETBIOSNAME_LEN) {
75 DEBUGADD(4, (" %s %3x char ", hdr, i));
76
77 for (j = 0; j < MAX_NETBIOSNAME_LEN; j++) {
78 unsigned char x = res->rdata[i+j];
79 if (x < 32 || x > 127)
80 x = '.';
81
82 if (i+j >= res->rdlength)
83 break;
84 DEBUGADD(4, ("%c", x));
85 }
86
87 DEBUGADD(4, (" hex "));
88
89 for (j = 0; j < MAX_NETBIOSNAME_LEN; j++) {
90 if (i+j >= res->rdlength)
91 break;
92 DEBUGADD(4, ("%02X", (unsigned char)res->rdata[i+j]));
93 }
94
95 DEBUGADD(4, ("\n"));
96 }
97 }
98
99 /****************************************************************************
100 Process a nmb packet.
101 ****************************************************************************/
102
103 void debug_nmb_packet(struct packet_struct *p)
104 {
105 struct nmb_packet *nmb = &p->packet.nmb;
106
107 if( DEBUGLVL( 4 ) ) {
108 dbgtext( "nmb packet from %s(%d) header: id=%d "
109 "opcode=%s(%d) response=%s\n",
110 inet_ntoa(p->ip), p->port,
111 nmb->header.name_trn_id,
112 lookup_opcode_name(nmb->header.opcode),
113 nmb->header.opcode,
114 BOOLSTR(nmb->header.response) );
115 dbgtext( " header: flags: bcast=%s rec_avail=%s "
116 "rec_des=%s trunc=%s auth=%s\n",
117 BOOLSTR(nmb->header.nm_flags.bcast),
118 BOOLSTR(nmb->header.nm_flags.recursion_available),
119 BOOLSTR(nmb->header.nm_flags.recursion_desired),
120 BOOLSTR(nmb->header.nm_flags.trunc),
121 BOOLSTR(nmb->header.nm_flags.authoritative) );
122 dbgtext( " header: rcode=%d qdcount=%d ancount=%d "
123 "nscount=%d arcount=%d\n",
124 nmb->header.rcode,
125 nmb->header.qdcount,
126 nmb->header.ancount,
127 nmb->header.nscount,
128 nmb->header.arcount );
129 }
130
131 if (nmb->header.qdcount) {
132 DEBUGADD( 4, ( " question: q_name=%s q_type=%d q_class=%d\n",
133 nmb_namestr(&nmb->question.question_name),
134 nmb->question.question_type,
135 nmb->question.question_class) );
136 }
137
138 if (nmb->answers && nmb->header.ancount) {
139 debug_nmb_res_rec(nmb->answers,"answers");
140 }
141 if (nmb->nsrecs && nmb->header.nscount) {
142 debug_nmb_res_rec(nmb->nsrecs,"nsrecs");
143 }
144 if (nmb->additional && nmb->header.arcount) {
145 debug_nmb_res_rec(nmb->additional,"additional");
146 }
147 }
148
149 /*******************************************************************
150 Handle "compressed" name pointers.
151 ******************************************************************/
152
153 static bool handle_name_ptrs(unsigned char *ubuf,int *offset,int length,
154 bool *got_pointer,int *ret)
155 {
156 int loop_count=0;
157
158 while ((ubuf[*offset] & 0xC0) == 0xC0) {
159 if (!*got_pointer)
160 (*ret) += 2;
161 (*got_pointer)=True;
162 (*offset) = ((ubuf[*offset] & ~0xC0)<<8) | ubuf[(*offset)+1];
163 if (loop_count++ == 10 ||
164 (*offset) < 0 || (*offset)>(length-2)) {
165 return False;
166 }
167 }
168 return True;
169 }
170
171 /*******************************************************************
172 Parse a nmb name from "compressed" format to something readable
173 return the space taken by the name, or 0 if the name is invalid
174 ******************************************************************/
175
176 static int parse_nmb_name(char *inbuf,int ofs,int length, struct nmb_name *name)
177 {
178 int m,n=0;
179 unsigned char *ubuf = (unsigned char *)inbuf;
180 int ret = 0;
181 bool got_pointer=False;
182 int loop_count=0;
183 int offset = ofs;
184
185 if (length - offset < 2)
186 return(0);
187
188 /* handle initial name pointers */
189 if (!handle_name_ptrs(ubuf,&offset,length,&got_pointer,&ret))
190 return(0);
191
192 m = ubuf[offset];
193
194 if (!m)
195 return(0);
196 if ((m & 0xC0) || offset+m+2 > length)
197 return(0);
198
199 memset((char *)name,'\0',sizeof(*name));
200
201 /* the "compressed" part */
202 if (!got_pointer)
203 ret += m + 2;
204 offset++;
205 while (m > 0) {
206 unsigned char c1,c2;
207 c1 = ubuf[offset++]-'A';
208 c2 = ubuf[offset++]-'A';
209 if ((c1 & 0xF0) || (c2 & 0xF0) || (n > sizeof(name->name)-1))
210 return(0);
211 name->name[n++] = (c1<<4) | c2;
212 m -= 2;
213 }
214 name->name[n] = 0;
215
216 if (n==MAX_NETBIOSNAME_LEN) {
217 /* parse out the name type, its always
218 * in the 16th byte of the name */
219 name->name_type = ((unsigned char)name->name[15]) & 0xff;
220
221 /* remove trailing spaces */
222 name->name[15] = 0;
223 n = 14;
224 while (n && name->name[n]==' ')
225 name->name[n--] = 0;
226 }
227
228 /* now the domain parts (if any) */
229 n = 0;
230 while (ubuf[offset]) {
231 /* we can have pointers within the domain part as well */
232 if (!handle_name_ptrs(ubuf,&offset,length,&got_pointer,&ret))
233 return(0);
234
235 m = ubuf[offset];
236 /*
237 * Don't allow null domain parts.
238 */
239 if (!m)
240 return(0);
241 if (!got_pointer)
242 ret += m+1;
243 if (n)
244 name->scope[n++] = '.';
245 if (m+2+offset>length || n+m+1>sizeof(name->scope))
246 return(0);
247 offset++;
248 while (m--)
249 name->scope[n++] = (char)ubuf[offset++];
250
251 /*
252 * Watch for malicious loops.
253 */
254 if (loop_count++ == 10)
255 return 0;
256 }
257 name->scope[n++] = 0;
258
259 return(ret);
260 }
261
262 /****************************************************************************
263 Put a netbios name, padding(s) and a name type into a 16 character buffer.
264 name is already in DOS charset.
265 [15 bytes name + padding][1 byte name type].
266 ****************************************************************************/
267
268 void put_name(char *dest, const char *name, int pad, unsigned int name_type)
269 {
270 size_t len = strlen(name);
271
272 memcpy(dest, name, (len < MAX_NETBIOSNAME_LEN) ?
273 len : MAX_NETBIOSNAME_LEN - 1);
274 if (len < MAX_NETBIOSNAME_LEN - 1) {
275 memset(dest + len, pad, MAX_NETBIOSNAME_LEN - 1 - len);
276 }
277 dest[MAX_NETBIOSNAME_LEN - 1] = name_type;
278 }
279
280 /*******************************************************************
281 Put a compressed nmb name into a buffer. Return the length of the
282 compressed name.
283
284 Compressed names are really weird. The "compression" doubles the
285 size. The idea is that it also means that compressed names conform
286 to the doman name system. See RFC1002.
287
288 If buf == NULL this is a length calculation.
289 ******************************************************************/
290
291 static int put_nmb_name(char *buf,int offset,struct nmb_name *name)
292 {
293 int ret,m;
294 nstring buf1;
295 char *p;
296
297 if (strcmp(name->name,"*") == 0) {
298 /* special case for wildcard name */
299 put_name(buf1, "*", '\0', name->name_type);
300 } else {
301 put_name(buf1, name->name, ' ', name->name_type);
302 }
303
304 if (buf) {
305 buf[offset] = 0x20;
306 }
307
308 ret = 34;
309
310 for (m=0;m<MAX_NETBIOSNAME_LEN;m++) {
311 if (buf) {
312 buf[offset+1+2*m] = 'A' + ((buf1[m]>>4)&0xF);
313 buf[offset+2+2*m] = 'A' + (buf1[m]&0xF);
314 }
315 }
316 offset += 33;
317
318 if (buf) {
319 buf[offset] = 0;
320 }
321
322 if (name->scope[0]) {
323 /* XXXX this scope handling needs testing */
324 ret += strlen(name->scope) + 1;
325 if (buf) {
326 safe_strcpy(&buf[offset+1],name->scope,
327 sizeof(name->scope));
328
329 p = &buf[offset+1];
330 while ((p = strchr_m(p,'.'))) {
331 buf[offset] = PTR_DIFF(p,&buf[offset+1]);
332 offset += (buf[offset] + 1);
333 p = &buf[offset+1];
334 }
335 buf[offset] = strlen(&buf[offset+1]);
336 }
337 }
338
339 return ret;
340 }
341
342 /*******************************************************************
343 Useful for debugging messages.
344 ******************************************************************/
345
346 char *nmb_namestr(const struct nmb_name *n)
347 {
348 fstring name;
349 char *result;
350
351 pull_ascii_fstring(name, n->name);
352 if (!n->scope[0])
353 result = talloc_asprintf(talloc_tos(), "%s<%02x>", name,
354 n->name_type);
355 else
356 result = talloc_asprintf(talloc_tos(), "%s<%02x>.%s", name,
357 n->name_type, n->scope);
358
359 SMB_ASSERT(result != NULL);
360 return result;
361 }
362
363 /*******************************************************************
364 Allocate and parse some resource records.
365 ******************************************************************/
366
367 static bool parse_alloc_res_rec(char *inbuf,int *offset,int length,
368 struct res_rec **recs, int count)
369 {
370 int i;
371
372 *recs = SMB_MALLOC_ARRAY(struct res_rec, count);
373 if (!*recs)
374 return(False);
375
376 memset((char *)*recs,'\0',sizeof(**recs)*count);
377
378 for (i=0;i<count;i++) {
379 int l = parse_nmb_name(inbuf,*offset,length,
380 &(*recs)[i].rr_name);
381 (*offset) += l;
382 if (!l || (*offset)+10 > length) {
383 SAFE_FREE(*recs);
384 return(False);
385 }
386 (*recs)[i].rr_type = RSVAL(inbuf,(*offset));
387 (*recs)[i].rr_class = RSVAL(inbuf,(*offset)+2);
388 (*recs)[i].ttl = RIVAL(inbuf,(*offset)+4);
389 (*recs)[i].rdlength = RSVAL(inbuf,(*offset)+8);
390 (*offset) += 10;
391 if ((*recs)[i].rdlength>sizeof((*recs)[i].rdata) ||
392 (*offset)+(*recs)[i].rdlength > length) {
393 SAFE_FREE(*recs);
394 return(False);
395 }
396 memcpy((*recs)[i].rdata,inbuf+(*offset),(*recs)[i].rdlength);
397 (*offset) += (*recs)[i].rdlength;
398 }
399 return(True);
400 }
401
402 /*******************************************************************
403 Put a resource record into a packet.
404 If buf == NULL this is a length calculation.
405 ******************************************************************/
406
407 static int put_res_rec(char *buf,int offset,struct res_rec *recs,int count)
408 {
409 int ret=0;
410 int i;
411
412 for (i=0;i<count;i++) {
413 int l = put_nmb_name(buf,offset,&recs[i].rr_name);
414 offset += l;
415 ret += l;
416 if (buf) {
417 RSSVAL(buf,offset,recs[i].rr_type);
418 RSSVAL(buf,offset+2,recs[i].rr_class);
419 RSIVAL(buf,offset+4,recs[i].ttl);
420 RSSVAL(buf,offset+8,recs[i].rdlength);
421 memcpy(buf+offset+10,recs[i].rdata,recs[i].rdlength);
422 }
423 offset += 10+recs[i].rdlength;
424 ret += 10+recs[i].rdlength;
425 }
426
427 return ret;
428 }
429
430 /*******************************************************************
431 Put a compressed name pointer record into a packet.
432 If buf == NULL this is a length calculation.
433 ******************************************************************/
434
435 static int put_compressed_name_ptr(unsigned char *buf,
436 int offset,
437 struct res_rec *rec,
438 int ptr_offset)
439 {
440 int ret=0;
441 if (buf) {
442 buf[offset] = (0xC0 | ((ptr_offset >> 8) & 0xFF));
443 buf[offset+1] = (ptr_offset & 0xFF);
444 }
445 offset += 2;
446 ret += 2;
447 if (buf) {
448 RSSVAL(buf,offset,rec->rr_type);
449 RSSVAL(buf,offset+2,rec->rr_class);
450 RSIVAL(buf,offset+4,rec->ttl);
451 RSSVAL(buf,offset+8,rec->rdlength);
452 memcpy(buf+offset+10,rec->rdata,rec->rdlength);
453 }
454 offset += 10+rec->rdlength;
455 ret += 10+rec->rdlength;
456
457 return ret;
458 }
459
460 /*******************************************************************
461 Parse a dgram packet. Return False if the packet can't be parsed
462 or is invalid for some reason, True otherwise.
463
464 This is documented in section 4.4.1 of RFC1002.
465 ******************************************************************/
466
467 static bool parse_dgram(char *inbuf,int length,struct dgram_packet *dgram)
468 {
469 int offset;
470 int flags;
471
472 memset((char *)dgram,'\0',sizeof(*dgram));
473
474 if (length < 14)
475 return(False);
476
477 dgram->header.msg_type = CVAL(inbuf,0);
478 flags = CVAL(inbuf,1);
479 dgram->header.flags.node_type = (enum node_type)((flags>>2)&3);
480 if (flags & 1)
481 dgram->header.flags.more = True;
482 if (flags & 2)
483 dgram->header.flags.first = True;
484 dgram->header.dgm_id = RSVAL(inbuf,2);
485 putip((char *)&dgram->header.source_ip,inbuf+4);
486 dgram->header.source_port = RSVAL(inbuf,8);
487 dgram->header.dgm_length = RSVAL(inbuf,10);
488 dgram->header.packet_offset = RSVAL(inbuf,12);
489
490 offset = 14;
491
492 if (dgram->header.msg_type == 0x10 ||
493 dgram->header.msg_type == 0x11 ||
494 dgram->header.msg_type == 0x12) {
495 offset += parse_nmb_name(inbuf,offset,length,
496 &dgram->source_name);
497 offset += parse_nmb_name(inbuf,offset,length,
498 &dgram->dest_name);
499 }
500
501 if (offset >= length || (length-offset > sizeof(dgram->data)))
502 return(False);
503
504 dgram->datasize = length-offset;
505 memcpy(dgram->data,inbuf+offset,dgram->datasize);
506
507 /* Paranioa. Ensure the last 2 bytes in the dgram buffer are
508 zero. This should be true anyway, just enforce it for
509 paranioa sake. JRA. */
510 SMB_ASSERT(dgram->datasize <= (sizeof(dgram->data)-2));
511 memset(&dgram->data[sizeof(dgram->data)-2], '\0', 2);
512
513 return(True);
514 }
515
516 /*******************************************************************
517 Parse a nmb packet. Return False if the packet can't be parsed
518 or is invalid for some reason, True otherwise.
519 ******************************************************************/
520
521 static bool parse_nmb(char *inbuf,int length,struct nmb_packet *nmb)
522 {
523 int nm_flags,offset;
524
525 memset((char *)nmb,'\0',sizeof(*nmb));
526
527 if (length < 12)
528 return(False);
529
530 /* parse the header */
531 nmb->header.name_trn_id = RSVAL(inbuf,0);
532
533 DEBUG(10,("parse_nmb: packet id = %d\n", nmb->header.name_trn_id));
534
535 nmb->header.opcode = (CVAL(inbuf,2) >> 3) & 0xF;
536 nmb->header.response = ((CVAL(inbuf,2)>>7)&1)?True:False;
537 nm_flags = ((CVAL(inbuf,2) & 0x7) << 4) + (CVAL(inbuf,3)>>4);
538 nmb->header.nm_flags.bcast = (nm_flags&1)?True:False;
539 nmb->header.nm_flags.recursion_available = (nm_flags&8)?True:False;
540 nmb->header.nm_flags.recursion_desired = (nm_flags&0x10)?True:False;
541 nmb->header.nm_flags.trunc = (nm_flags&0x20)?True:False;
542 nmb->header.nm_flags.authoritative = (nm_flags&0x40)?True:False;
543 nmb->header.rcode = CVAL(inbuf,3) & 0xF;
544 nmb->header.qdcount = RSVAL(inbuf,4);
545 nmb->header.ancount = RSVAL(inbuf,6);
546 nmb->header.nscount = RSVAL(inbuf,8);
547 nmb->header.arcount = RSVAL(inbuf,10);
548
549 if (nmb->header.qdcount) {
550 offset = parse_nmb_name(inbuf,12,length,
551 &nmb->question.question_name);
552 if (!offset)
553 return(False);
554
555 if (length - (12+offset) < 4)
556 return(False);
557 nmb->question.question_type = RSVAL(inbuf,12+offset);
558 nmb->question.question_class = RSVAL(inbuf,12+offset+2);
559
560 offset += 12+4;
561 } else {
562 offset = 12;
563 }
564
565 /* and any resource records */
566 if (nmb->header.ancount &&
567 !parse_alloc_res_rec(inbuf,&offset,length,&nmb->answers,
568 nmb->header.ancount))
569 return(False);
570
571 if (nmb->header.nscount &&
572 !parse_alloc_res_rec(inbuf,&offset,length,&nmb->nsrecs,
573 nmb->header.nscount))
574 return(False);
575
576 if (nmb->header.arcount &&
577 !parse_alloc_res_rec(inbuf,&offset,length,
578 &nmb->additional, nmb->header.arcount))
579 return(False);
580
581 return(True);
582 }
583
584 /*******************************************************************
585 'Copy constructor' for an nmb packet.
586 ******************************************************************/
587
588 static struct packet_struct *copy_nmb_packet(struct packet_struct *packet)
589 {
590 struct nmb_packet *nmb;
591 struct nmb_packet *copy_nmb;
592 struct packet_struct *pkt_copy;
593
594 if(( pkt_copy = SMB_MALLOC_P(struct packet_struct)) == NULL) {
595 DEBUG(0,("copy_nmb_packet: malloc fail.\n"));
596 return NULL;
597 }
598
599 /* Structure copy of entire thing. */
600
601 *pkt_copy = *packet;
602
603 /* Ensure this copy is not locked. */
604 pkt_copy->locked = False;
605 pkt_copy->recv_fd = -1;
606 pkt_copy->send_fd = -1;
607
608 /* Ensure this copy has no resource records. */
609 nmb = &packet->packet.nmb;
610 copy_nmb = &pkt_copy->packet.nmb;
611
612 copy_nmb->answers = NULL;
613 copy_nmb->nsrecs = NULL;
614 copy_nmb->additional = NULL;
615
616 /* Now copy any resource records. */
617
618 if (nmb->answers) {
619 if((copy_nmb->answers = SMB_MALLOC_ARRAY(
620 struct res_rec,nmb->header.ancount)) == NULL)
621 goto free_and_exit;
622 memcpy((char *)copy_nmb->answers, (char *)nmb->answers,
623 nmb->header.ancount * sizeof(struct res_rec));
624 }
625 if (nmb->nsrecs) {
626 if((copy_nmb->nsrecs = SMB_MALLOC_ARRAY(
627 struct res_rec, nmb->header.nscount)) == NULL)
628 goto free_and_exit;
629 memcpy((char *)copy_nmb->nsrecs, (char *)nmb->nsrecs,
630 nmb->header.nscount * sizeof(struct res_rec));
631 }
632 if (nmb->additional) {
633 if((copy_nmb->additional = SMB_MALLOC_ARRAY(
634 struct res_rec, nmb->header.arcount)) == NULL)
635 goto free_and_exit;
636 memcpy((char *)copy_nmb->additional, (char *)nmb->additional,
637 nmb->header.arcount * sizeof(struct res_rec));
638 }
639
640 return pkt_copy;
641
642 free_and_exit:
643
644 SAFE_FREE(copy_nmb->answers);
645 SAFE_FREE(copy_nmb->nsrecs);
646 SAFE_FREE(copy_nmb->additional);
647 SAFE_FREE(pkt_copy);
648
649 DEBUG(0,("copy_nmb_packet: malloc fail in resource records.\n"));
650 return NULL;
651 }
652
653 /*******************************************************************
654 'Copy constructor' for a dgram packet.
655 ******************************************************************/
656
657 static struct packet_struct *copy_dgram_packet(struct packet_struct *packet)
658 {
659 struct packet_struct *pkt_copy;
660
661 if(( pkt_copy = SMB_MALLOC_P(struct packet_struct)) == NULL) {
662 DEBUG(0,("copy_dgram_packet: malloc fail.\n"));
663 return NULL;
664 }
665
666 /* Structure copy of entire thing. */
667
668 *pkt_copy = *packet;
669
670 /* Ensure this copy is not locked. */
671 pkt_copy->locked = False;
672 pkt_copy->recv_fd = -1;
673 pkt_copy->send_fd = -1;
674
675 /* There are no additional pointers in a dgram packet,
676 we are finished. */
677 return pkt_copy;
678 }
679
680 /*******************************************************************
681 'Copy constructor' for a generic packet.
682 ******************************************************************/
683
684 struct packet_struct *copy_packet(struct packet_struct *packet)
685 {
686 if(packet->packet_type == NMB_PACKET)
687 return copy_nmb_packet(packet);
688 else if (packet->packet_type == DGRAM_PACKET)
689 return copy_dgram_packet(packet);
690 return NULL;
691 }
692
693 /*******************************************************************
694 Free up any resources associated with an nmb packet.
695 ******************************************************************/
696
697 static void free_nmb_packet(struct nmb_packet *nmb)
698 {
699 SAFE_FREE(nmb->answers);
700 SAFE_FREE(nmb->nsrecs);
701 SAFE_FREE(nmb->additional);
702 }
703
704 /*******************************************************************
705 Free up any resources associated with a dgram packet.
706 ******************************************************************/
707
708 static void free_dgram_packet(struct dgram_packet *nmb)
709 {
710 /* We have nothing to do for a dgram packet. */
711 }
712
713 /*******************************************************************
714 Free up any resources associated with a packet.
715 ******************************************************************/
716
717 void free_packet(struct packet_struct *packet)
718 {
719 if (packet->locked)
720 return;
721 if (packet->packet_type == NMB_PACKET)
722 free_nmb_packet(&packet->packet.nmb);
723 else if (packet->packet_type == DGRAM_PACKET)
724 free_dgram_packet(&packet->packet.dgram);
725 ZERO_STRUCTPN(packet);
726 SAFE_FREE(packet);
727 }
728
729 int packet_trn_id(struct packet_struct *p)
730 {
731 int result;
732 switch (p->packet_type) {
733 case NMB_PACKET:
734 result = p->packet.nmb.header.name_trn_id;
735 break;
736 case DGRAM_PACKET:
737 result = p->packet.dgram.header.dgm_id;
738 break;
739 default:
740 result = -1;
741 }
742 return result;
743 }
744
745 /*******************************************************************
746 Parse a packet buffer into a packet structure.
747 ******************************************************************/
748
749 struct packet_struct *parse_packet(char *buf,int length,
750 enum packet_type packet_type,
751 struct in_addr ip,
752 int port)
753 {
754 struct packet_struct *p;
755 bool ok=False;
756
757 p = SMB_MALLOC_P(struct packet_struct);
758 if (!p)
759 return(NULL);
760
761 ZERO_STRUCTP(p); /* initialize for possible padding */
762
763 p->next = NULL;
764 p->prev = NULL;
765 p->ip = ip;
766 p->port = port;
767 p->locked = False;
768 p->timestamp = time(NULL);
769 p->packet_type = packet_type;
770
771 switch (packet_type) {
772 case NMB_PACKET:
773 ok = parse_nmb(buf,length,&p->packet.nmb);
774 break;
775
776 case DGRAM_PACKET:
777 ok = parse_dgram(buf,length,&p->packet.dgram);
778 break;
779 }
780
781 if (!ok) {
782 free_packet(p);
783 return NULL;
784 }
785
786 return p;
787 }
788
789 /*******************************************************************
790 Read a packet from a socket and parse it, returning a packet ready
791 to be used or put on the queue. This assumes a UDP socket.
792 ******************************************************************/
793
794 struct packet_struct *read_packet(int fd,enum packet_type packet_type)
795 {
796 struct packet_struct *packet;
797 struct sockaddr_storage sa;
798 struct sockaddr_in *si = (struct sockaddr_in *)&sa;
799 char buf[MAX_DGRAM_SIZE];
800 int length;
801
802 length = read_udp_v4_socket(fd,buf,sizeof(buf),&sa);
803 if (length < MIN_DGRAM_SIZE || sa.ss_family != AF_INET) {
804 return NULL;
805 }
806
807 packet = parse_packet(buf,
808 length,
809 packet_type,
810 si->sin_addr,
811 ntohs(si->sin_port));
812 if (!packet)
813 return NULL;
814
815 packet->recv_fd = fd;
816 packet->send_fd = -1;
817
818 DEBUG(5,("Received a packet of len %d from (%s) port %d\n",
819 length, inet_ntoa(packet->ip), packet->port ) );
820
821 return(packet);
822 }
823
824 /*******************************************************************
825 Send a udp packet on a already open socket.
826 ******************************************************************/
827
828 static bool send_udp(int fd,char *buf,int len,struct in_addr ip,int port)
829 {
830 bool ret = False;
831 int i;
832 struct sockaddr_in sock_out;
833
834 /* set the address and port */
835 memset((char *)&sock_out,'\0',sizeof(sock_out));
836 putip((char *)&sock_out.sin_addr,(char *)&ip);
837 sock_out.sin_port = htons( port );
838 sock_out.sin_family = AF_INET;
839
840 DEBUG( 5, ( "Sending a packet of len %d to (%s) on port %d\n",
841 len, inet_ntoa(ip), port ) );
842
843 /*
844 * Patch to fix asynch error notifications from Linux kernel.
845 */
846
847 for (i = 0; i < 5; i++) {
848 ret = (sendto(fd,buf,len,0,(struct sockaddr *)&sock_out,
849 sizeof(sock_out)) >= 0);
850 if (ret || errno != ECONNREFUSED)
851 break;
852 }
853
854 if (!ret)
855 DEBUG(0,("Packet send failed to %s(%d) ERRNO=%s\n",
856 inet_ntoa(ip),port,strerror(errno)));
857
858 return(ret);
859 }
860
861 /*******************************************************************
862 Build a dgram packet ready for sending.
863 If buf == NULL this is a length calculation.
864 ******************************************************************/
865
866 static int build_dgram(char *buf, size_t len, struct dgram_packet *dgram)
867 {
868 unsigned char *ubuf = (unsigned char *)buf;
869 int offset=0;
870
871 /* put in the header */
872 if (buf) {
873 ubuf[0] = dgram->header.msg_type;
874 ubuf[1] = (((int)dgram->header.flags.node_type)<<2);
875 if (dgram->header.flags.more)
876 ubuf[1] |= 1;
877 if (dgram->header.flags.first)
878 ubuf[1] |= 2;
879 RSSVAL(ubuf,2,dgram->header.dgm_id);
880 putip(ubuf+4,(char *)&dgram->header.source_ip);
881 RSSVAL(ubuf,8,dgram->header.source_port);
882 RSSVAL(ubuf,12,dgram->header.packet_offset);
883 }
884
885 offset = 14;
886
887 if (dgram->header.msg_type == 0x10 ||
888 dgram->header.msg_type == 0x11 ||
889 dgram->header.msg_type == 0x12) {
890 offset += put_nmb_name((char *)ubuf,offset,&dgram->source_name);
891 offset += put_nmb_name((char *)ubuf,offset,&dgram->dest_name);
892 }
893
894 if (buf) {
895 memcpy(ubuf+offset,dgram->data,dgram->datasize);
896 }
897 offset += dgram->datasize;
898
899 /* automatically set the dgm_length
900 * NOTE: RFC1002 says the dgm_length does *not*
901 * include the fourteen-byte header. crh
902 */
903 dgram->header.dgm_length = (offset - 14);
904 if (buf) {
905 RSSVAL(ubuf,10,dgram->header.dgm_length);
906 }
907
908 return offset;
909 }
910
911 /*******************************************************************
912 Build a nmb name
913 *******************************************************************/
914
915 void make_nmb_name( struct nmb_name *n, const char *name, int type)
916 {
917 fstring unix_name;
918 memset( (char *)n, '\0', sizeof(struct nmb_name) );
919 fstrcpy(unix_name, name);
920 strupper_m(unix_name);
921 push_ascii(n->name, unix_name, sizeof(n->name), STR_TERMINATE);
922 n->name_type = (unsigned int)type & 0xFF;
923 push_ascii(n->scope, global_scope(), 64, STR_TERMINATE);
924 }
925
926 /*******************************************************************
927 Compare two nmb names
928 ******************************************************************/
929
930 bool nmb_name_equal(struct nmb_name *n1, struct nmb_name *n2)
931 {
932 return ((n1->name_type == n2->name_type) &&
933 strequal(n1->name ,n2->name ) &&
934 strequal(n1->scope,n2->scope));
935 }
936
937 /*******************************************************************
938 Build a nmb packet ready for sending.
939 If buf == NULL this is a length calculation.
940 ******************************************************************/
941
942 static int build_nmb(char *buf, size_t len, struct nmb_packet *nmb)
943 {
944 unsigned char *ubuf = (unsigned char *)buf;
945 int offset=0;
946
947 if (len && len < 12) {
948 return 0;
949 }
950
951 /* put in the header */
952 if (buf) {
953 RSSVAL(ubuf,offset,nmb->header.name_trn_id);
954 ubuf[offset+2] = (nmb->header.opcode & 0xF) << 3;
955 if (nmb->header.response)
956 ubuf[offset+2] |= (1<<7);
957 if (nmb->header.nm_flags.authoritative &&
958 nmb->header.response)
959 ubuf[offset+2] |= 0x4;
960 if (nmb->header.nm_flags.trunc)
961 ubuf[offset+2] |= 0x2;
962 if (nmb->header.nm_flags.recursion_desired)
963 ubuf[offset+2] |= 0x1;
964 if (nmb->header.nm_flags.recursion_available &&
965 nmb->header.response)
966 ubuf[offset+3] |= 0x80;
967 if (nmb->header.nm_flags.bcast)
968 ubuf[offset+3] |= 0x10;
969 ubuf[offset+3] |= (nmb->header.rcode & 0xF);
970
971 RSSVAL(ubuf,offset+4,nmb->header.qdcount);
972 RSSVAL(ubuf,offset+6,nmb->header.ancount);
973 RSSVAL(ubuf,offset+8,nmb->header.nscount);
974 RSSVAL(ubuf,offset+10,nmb->header.arcount);
975 }
976
977 offset += 12;
978 if (nmb->header.qdcount) {
979 /* XXXX this doesn't handle a qdcount of > 1 */
980 if (len) {
981 /* Length check. */
982 int extra = put_nmb_name(NULL,offset,
983 &nmb->question.question_name);
984 if (offset + extra > len) {
985 return 0;
986 }
987 }
988 offset += put_nmb_name((char *)ubuf,offset,
989 &nmb->question.question_name);
990 if (buf) {
991 RSSVAL(ubuf,offset,nmb->question.question_type);
992 RSSVAL(ubuf,offset+2,nmb->question.question_class);
993 }
994 offset += 4;
995 }
996
997 if (nmb->header.ancount) {
998 if (len) {
999 /* Length check. */
1000 int extra = put_res_rec(NULL,offset,nmb->answers,
1001 nmb->header.ancount);
1002 if (offset + extra > len) {
1003 return 0;
1004 }
1005 }
1006 offset += put_res_rec((char *)ubuf,offset,nmb->answers,
1007 nmb->header.ancount);
1008 }
1009
1010 if (nmb->header.nscount) {
1011 if (len) {
1012 /* Length check. */
1013 int extra = put_res_rec(NULL,offset,nmb->nsrecs,
1014 nmb->header.nscount);
1015 if (offset + extra > len) {
1016 return 0;
1017 }
1018 }
1019 offset += put_res_rec((char *)ubuf,offset,nmb->nsrecs,
1020 nmb->header.nscount);
1021 }
1022
1023 /*
1024 * The spec says we must put compressed name pointers
1025 * in the following outgoing packets :
1026 * NAME_REGISTRATION_REQUEST, NAME_REFRESH_REQUEST,
1027 * NAME_RELEASE_REQUEST.
1028 */
1029
1030 if((nmb->header.response == False) &&
1031 ((nmb->header.opcode == NMB_NAME_REG_OPCODE) ||
1032 (nmb->header.opcode == NMB_NAME_RELEASE_OPCODE) ||
1033 (nmb->header.opcode == NMB_NAME_REFRESH_OPCODE_8) ||
1034 (nmb->header.opcode == NMB_NAME_REFRESH_OPCODE_9) ||
1035 (nmb->header.opcode == NMB_NAME_MULTIHOMED_REG_OPCODE)) &&
1036 (nmb->header.arcount == 1)) {
1037
1038 if (len) {
1039 /* Length check. */
1040 int extra = put_compressed_name_ptr(NULL,offset,
1041 nmb->additional,12);
1042 if (offset + extra > len) {
1043 return 0;
1044 }
1045 }
1046 offset += put_compressed_name_ptr(ubuf,offset,
1047 nmb->additional,12);
1048 } else if (nmb->header.arcount) {
1049 if (len) {
1050 /* Length check. */
1051 int extra = put_res_rec(NULL,offset,nmb->additional,
1052 nmb->header.arcount);
1053 if (offset + extra > len) {
1054 return 0;
1055 }
1056 }
1057 offset += put_res_rec((char *)ubuf,offset,nmb->additional,
1058 nmb->header.arcount);
1059 }
1060 return offset;
1061 }
1062
1063 /*******************************************************************
1064 Linearise a packet.
1065 ******************************************************************/
1066
1067 int build_packet(char *buf, size_t buflen, struct packet_struct *p)
1068 {
1069 int len = 0;
1070
1071 switch (p->packet_type) {
1072 case NMB_PACKET:
1073 len = build_nmb(buf,buflen,&p->packet.nmb);
1074 break;
1075
1076 case DGRAM_PACKET:
1077 len = build_dgram(buf,buflen,&p->packet.dgram);
1078 break;
1079 }
1080
1081 return len;
1082 }
1083
1084 /*******************************************************************
1085 Send a packet_struct.
1086 ******************************************************************/
1087
1088 bool send_packet(struct packet_struct *p)
1089 {
1090 char buf[1024];
1091 int len=0;
1092
1093 memset(buf,'\0',sizeof(buf));
1094
1095 len = build_packet(buf, sizeof(buf), p);
1096
1097 if (!len)
1098 return(False);
1099
1100 return(send_udp(p->send_fd,buf,len,p->ip,p->port));
1101 }
1102
1103 /****************************************************************************
1104 Receive a packet with timeout on a open UDP filedescriptor.
1105 The timeout is in milliseconds
1106 ***************************************************************************/
1107
1108 struct packet_struct *receive_packet(int fd,enum packet_type type,int t)
1109 {
1110 fd_set fds;
1111 struct timeval timeout;
1112 int ret;
1113
1114 FD_ZERO(&fds);
1115 FD_SET(fd,&fds);
1116 timeout.tv_sec = t/1000;
1117 timeout.tv_usec = 1000*(t%1000);
1118
1119 if ((ret = sys_select_intr(fd+1,&fds,NULL,NULL,&timeout)) == -1) {
1120 /* errno should be EBADF or EINVAL. */
1121 DEBUG(0,("select returned -1, errno = %s (%d)\n",
1122 strerror(errno), errno));
1123 return NULL;
1124 }
1125
1126 if (ret == 0) /* timeout */
1127 return NULL;
1128
1129 if (FD_ISSET(fd,&fds))
1130 return(read_packet(fd,type));
1131
1132 return(NULL);
1133 }
1134
1135 /****************************************************************************
1136 Receive a UDP/138 packet either via UDP or from the unexpected packet
1137 queue. The packet must be a reply packet and have the specified mailslot name
1138 The timeout is in milliseconds.
1139 ***************************************************************************/
1140
1141 /****************************************************************************
1142 See if a datagram has the right mailslot name.
1143 ***************************************************************************/
1144
1145 bool match_mailslot_name(struct packet_struct *p, const char *mailslot_name)
1146 {
1147 struct dgram_packet *dgram = &p->packet.dgram;
1148 char *buf;
1149
1150 buf = &dgram->data[0];
1151 buf -= 4;
1152
1153 buf = smb_buf(buf);
1154
1155 if (memcmp(buf, mailslot_name, strlen(mailslot_name)+1) == 0) {
1156 return True;
1157 }
1158
1159 return False;
1160 }
1161
1162 /****************************************************************************
1163 Return the number of bits that match between two len character buffers
1164 ***************************************************************************/
1165
1166 int matching_len_bits(unsigned char *p1, unsigned char *p2, size_t len)
1167 {
1168 size_t i, j;
1169 int ret = 0;
1170 for (i=0; i<len; i++) {
1171 if (p1[i] != p2[i])
1172 break;
1173 ret += 8;
1174 }
1175
1176 if (i==len)
1177 return ret;
1178
1179 for (j=0; j<8; j++) {
1180 if ((p1[i] & (1<<(7-j))) != (p2[i] & (1<<(7-j))))
1181 break;
1182 ret++;
1183 }
1184
1185 return ret;
1186 }
1187
1188 static unsigned char sort_ip[4];
1189
1190 /****************************************************************************
1191 Compare two query reply records.
1192 ***************************************************************************/
1193
1194 static int name_query_comp(unsigned char *p1, unsigned char *p2)
1195 {
1196 return matching_len_bits(p2+2, sort_ip, 4) -
1197 matching_len_bits(p1+2, sort_ip, 4);
1198 }
1199
1200 /****************************************************************************
1201 Sort a set of 6 byte name query response records so that the IPs that
1202 have the most leading bits in common with the specified address come first.
1203 ***************************************************************************/
1204
1205 void sort_query_replies(char *data, int n, struct in_addr ip)
1206 {
1207 if (n <= 1)
1208 return;
1209
1210 putip(sort_ip, (char *)&ip);
1211
1212 /* TODO:
1213 this can't use TYPESAFE_QSORT() as the types are wrong.
1214 It should be fixed to use a real type instead of char*
1215 */
1216 qsort(data, n, 6, QSORT_CAST name_query_comp);
1217 }
1218
1219 /****************************************************************************
1220 Interpret the weird netbios "name" into a unix fstring. Return the name type.
1221 Returns -1 on error.
1222 ****************************************************************************/
1223
1224 static int name_interpret(unsigned char *buf, size_t buf_len,
1225 unsigned char *in, fstring name)
1226 {
1227 unsigned char *end_ptr = buf + buf_len;
1228 int ret;
1229 unsigned int len;
1230 fstring out_string;
1231 unsigned char *out = (unsigned char *)out_string;
1232
1233 *out=0;
1234
1235 if (in >= end_ptr) {
1236 return -1;
1237 }
1238 len = (*in++) / 2;
1239
1240 if (len<1) {
1241 return -1;
1242 }
1243
1244 while (len--) {
1245 if (&in[1] >= end_ptr) {
1246 return -1;
1247 }
1248 if (in[0] < 'A' || in[0] > 'P' || in[1] < 'A' || in[1] > 'P') {
1249 *out = 0;
1250 return(0);
1251 }
1252 *out = ((in[0]-'A')<<4) + (in[1]-'A');
1253 in += 2;
1254 out++;
1255 if (PTR_DIFF(out,out_string) >= sizeof(fstring)) {
1256 return -1;
1257 }
1258 }
1259 ret = out[-1];
1260 out[-1] = 0;
1261
1262 pull_ascii_fstring(name, out_string);
1263
1264 return(ret);
1265 }
1266
1267 /****************************************************************************
1268 Mangle a name into netbios format.
1269 Note: <Out> must be (33 + strlen(scope) + 2) bytes long, at minimum.
1270 ****************************************************************************/
1271
1272 char *name_mangle(TALLOC_CTX *mem_ctx, const char *In, char name_type)
1273 {
1274 int i;
1275 int len;
1276 nstring buf;
1277 char *result;
1278 char *p;
1279
1280 result = talloc_array(mem_ctx, char, 33 + strlen(global_scope()) + 2);
1281 if (result == NULL) {
1282 return NULL;
1283 }
1284 p = result;
1285
1286 /* Safely copy the input string, In, into buf[]. */
1287 if (strcmp(In,"*") == 0)
1288 put_name(buf, "*", '\0', 0x00);
1289 else {
1290 /* We use an fstring here as mb dos names can expend x3 when
1291 going to utf8. */
1292 fstring buf_unix;
1293 nstring buf_dos;
1294
1295 pull_ascii_fstring(buf_unix, In);
1296 strupper_m(buf_unix);
1297
1298 push_ascii_nstring(buf_dos, buf_unix);
1299 put_name(buf, buf_dos, ' ', name_type);
1300 }
1301
1302 /* Place the length of the first field into the output buffer. */
1303 p[0] = 32;
1304 p++;
1305
1306 /* Now convert the name to the rfc1001/1002 format. */
1307 for( i = 0; i < MAX_NETBIOSNAME_LEN; i++ ) {
1308 p[i*2] = ( (buf[i] >> 4) & 0x000F ) + 'A';
1309 p[(i*2)+1] = (buf[i] & 0x000F) + 'A';
1310 }
1311 p += 32;
1312 p[0] = '\0';
1313
1314 /* Add the scope string. */
1315 for( i = 0, len = 0; *(global_scope()) != '\0'; i++, len++ ) {
1316 switch( (global_scope())[i] ) {
1317 case '\0':
1318 p[0] = len;
1319 if( len > 0 )
1320 p[len+1] = 0;
1321 return result;
1322 case '.':
1323 p[0] = len;
1324 p += (len + 1);
1325 len = -1;
1326 break;
1327 default:
1328 p[len+1] = (global_scope())[i];
1329 break;
1330 }
1331 }
1332
1333 return result;
1334 }
1335
1336 /****************************************************************************
1337 Find a pointer to a netbios name.
1338 ****************************************************************************/
1339
1340 static unsigned char *name_ptr(unsigned char *buf, size_t buf_len, unsigned int ofs)
1341 {
1342 unsigned char c = 0;
1343
1344 if (ofs > buf_len || buf_len < 1) {
1345 return NULL;
1346 }
1347
1348 c = *(unsigned char *)(buf+ofs);
1349 if ((c & 0xC0) == 0xC0) {
1350 uint16 l = 0;
1351
1352 if (ofs > buf_len - 1) {
1353 return NULL;
1354 }
1355 l = RSVAL(buf, ofs) & 0x3FFF;
1356 if (l > buf_len) {
1357 return NULL;
1358 }
1359 DEBUG(5,("name ptr to pos %d from %d is %s\n",l,ofs,buf+l));
1360 return(buf + l);
1361 } else {
1362 return(buf+ofs);
1363 }
1364 }
1365
1366 /****************************************************************************
1367 Extract a netbios name from a buf (into a unix string) return name type.
1368 Returns -1 on error.
1369 ****************************************************************************/
1370
1371 int name_extract(unsigned char *buf, size_t buf_len, unsigned int ofs, fstring name)
1372 {
1373 unsigned char *p = name_ptr(buf,buf_len,ofs);
1374
1375 name[0] = '\0';
1376 if (p == NULL) {
1377 return -1;
1378 }
1379 return(name_interpret(buf,buf_len,p,name));
1380 }
1381
1382 /****************************************************************************
1383 Return the total storage length of a mangled name.
1384 Returns -1 on error.
1385 ****************************************************************************/
1386
1387 int name_len(unsigned char *s1, size_t buf_len)
1388 {
1389 /* NOTE: this argument _must_ be unsigned */
1390 unsigned char *s = (unsigned char *)s1;
1391 int len = 0;
1392
1393 if (buf_len < 1) {
1394 return -1;
1395 }
1396 /* If the two high bits of the byte are set, return 2. */
1397 if (0xC0 == (*s & 0xC0)) {
1398 if (buf_len < 2) {
1399 return -1;
1400 }
1401 return(2);
1402 }
1403
1404 /* Add up the length bytes. */
1405 for (len = 1; (*s); s += (*s) + 1) {
1406 len += *s + 1;
1407 if (len > buf_len) {
1408 return -1;
1409 }
1410 }
1411
1412 return(len);
1413 }
Samba GIT mirror