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