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