source3/libsmb/nmblib.c

   1 /*
   2    Unix SMB/Netbios implementation.
   3    Version 1.9.
   4    NBT netbios library routines
   5    Copyright (C) Andrew Tridgell 1994-1998
   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 2 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, write to the Free Software
  19    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  20
  21 */
  22
  23 #include "includes.h"
  24
  25 extern int DEBUGLEVEL;
  26
  27 int num_good_sends = 0;
  28 int num_good_receives = 0;
  29
  30 static struct opcode_names {
  31         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 static char *lookup_opcode_name( int opcode )
  48 {
  49   struct opcode_names *op_namep;
  50   int i;
  51
  52   for(i = 0; nmb_header_opcode_names[i].nmb_opcode_name != 0; i++) {
  53     op_namep = &nmb_header_opcode_names[i];
  54     if(opcode == op_namep->opcode)
  55       return op_namep->nmb_opcode_name;
  56   }
  57   return "<unknown opcode>";
  58 }
  59
  60 /****************************************************************************
  61   print out a res_rec structure
  62   ****************************************************************************/
  63 static void debug_nmb_res_rec(struct res_rec *res, char *hdr)
  64 {
  65   int i, j;
  66
  67   DEBUGADD( 4, ( "    %s: nmb_name=%s rr_type=%d rr_class=%d ttl=%d\n",
  68                  hdr,
  69                  nmb_namestr(&res->rr_name),
  70                  res->rr_type,
  71                  res->rr_class,
  72                  res->ttl ) );
  73
  74   if( res->rdlength == 0 || res->rdata == NULL )
  75     return;
  76
  77   for (i = 0; i < res->rdlength; i+= 16)
  78     {
  79       DEBUGADD(4, ("    %s %3x char ", hdr, i));
  80
  81       for (j = 0; j < 16; j++)
  82         {
  83           unsigned char x = res->rdata[i+j];
  84           if (x < 32 || x > 127) x = '.';
  85
  86           if (i+j >= res->rdlength) break;
  87           DEBUGADD(4, ("%c", x));
  88         }
  89
  90       DEBUGADD(4, ("   hex "));
  91
  92       for (j = 0; j < 16; j++)
  93         {
  94           if (i+j >= res->rdlength) break;
  95           DEBUGADD(4, ("%02X", (unsigned char)res->rdata[i+j]));
  96         }
  97
  98       DEBUGADD(4, ("\n"));
  99     }
 100 }
 101
 102 /****************************************************************************
 103   process a nmb packet
 104   ****************************************************************************/
 105 void debug_nmb_packet(struct packet_struct *p)
 106 {
 107   struct nmb_packet *nmb = &p->packet.nmb;
 108
 109   if( DEBUGLVL( 4 ) )
 110     {
 111     dbgtext( "nmb packet from %s(%d) header: id=%d opcode=%s(%d) response=%s\n",
 112              inet_ntoa(p->ip), p->port,
 113              nmb->header.name_trn_id,
 114              lookup_opcode_name(nmb->header.opcode),
 115              nmb->header.opcode,
 116              BOOLSTR(nmb->header.response) );
 117     dbgtext( "    header: flags: bcast=%s rec_avail=%s rec_des=%s trunc=%s auth=%s\n",
 118              BOOLSTR(nmb->header.nm_flags.bcast),
 119              BOOLSTR(nmb->header.nm_flags.recursion_available),
 120              BOOLSTR(nmb->header.nm_flags.recursion_desired),
 121              BOOLSTR(nmb->header.nm_flags.trunc),
 122              BOOLSTR(nmb->header.nm_flags.authoritative) );
 123     dbgtext( "    header: rcode=%d qdcount=%d ancount=%d 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     {
 133       DEBUGADD( 4, ( "    question: q_name=%s q_type=%d q_class=%d\n",
 134                      nmb_namestr(&nmb->question.question_name),
 135                      nmb->question.question_type,
 136                      nmb->question.question_class) );
 137     }
 138
 139   if (nmb->answers && nmb->header.ancount)
 140     {
 141       debug_nmb_res_rec(nmb->answers,"answers");
 142     }
 143   if (nmb->nsrecs && nmb->header.nscount)
 144     {
 145       debug_nmb_res_rec(nmb->nsrecs,"nsrecs");
 146     }
 147   if (nmb->additional && nmb->header.arcount)
 148     {
 149       debug_nmb_res_rec(nmb->additional,"additional");
 150     }
 151 }
 152
 153 /*******************************************************************
 154   handle "compressed" name pointers
 155   ******************************************************************/
 156 static BOOL handle_name_ptrs(unsigned char *ubuf,int *offset,int length,
 157                              BOOL *got_pointer,int *ret)
 158 {
 159   int loop_count=0;
 160
 161   while ((ubuf[*offset] & 0xC0) == 0xC0) {
 162     if (!*got_pointer) (*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 static int parse_nmb_name(char *inbuf,int offset,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
 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==16) {
 216     /* parse out the name type,
 217        its always 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 /*******************************************************************
 263   put a compressed nmb name into a buffer. return the length of the
 264   compressed name
 265
 266   compressed names are really weird. The "compression" doubles the
 267   size. The idea is that it also means that compressed names conform
 268   to the doman name system. See RFC1002.
 269   ******************************************************************/
 270 static int put_nmb_name(char *buf,int offset,struct nmb_name *name)
 271 {
 272   int ret,m;
 273   fstring buf1;
 274   char *p;
 275
 276   if (strcmp(name->name,"*") == 0) {
 277     /* special case for wildcard name */
 278     memset(buf1,'\0',20);
 279     buf1[0] = '*';
 280     buf1[15] = name->name_type;
 281   } else {
 282     slprintf(buf1, sizeof(buf1) - 1,"%-15.15s%c",name->name,name->name_type);
 283   }
 284
 285   buf[offset] = 0x20;
 286
 287   ret = 34;
 288
 289   for (m=0;m<16;m++) {
 290     buf[offset+1+2*m] = 'A' + ((buf1[m]>>4)&0xF);
 291     buf[offset+2+2*m] = 'A' + (buf1[m]&0xF);
 292   }
 293   offset += 33;
 294
 295   buf[offset] = 0;
 296
 297   if (name->scope[0]) {
 298     /* XXXX this scope handling needs testing */
 299     ret += strlen(name->scope) + 1;
 300     pstrcpy(&buf[offset+1],name->scope);
 301
 302     p = &buf[offset+1];
 303     while ((p = strchr(p,'.'))) {
 304       buf[offset] = PTR_DIFF(p,&buf[offset]);
 305       offset += buf[offset];
 306       p = &buf[offset+1];
 307     }
 308     buf[offset] = strlen(&buf[offset+1]);
 309   }
 310
 311   return(ret);
 312 }
 313
 314 /*******************************************************************
 315   useful for debugging messages
 316   ******************************************************************/
 317 char *nmb_namestr(struct nmb_name *n)
 318 {
 319   static int i=0;
 320   static fstring ret[4];
 321   char *p = ret[i];
 322
 323   if (!n->scope[0])
 324     slprintf(p,sizeof(fstring)-1, "%s<%02x>",n->name,n->name_type);
 325   else
 326     slprintf(p,sizeof(fstring)-1, "%s<%02x>.%s",n->name,n->name_type,n->scope);
 327
 328   i = (i+1)%4;
 329   return(p);
 330 }
 331
 332 /*******************************************************************
 333   allocate and parse some resource records
 334   ******************************************************************/
 335 static BOOL parse_alloc_res_rec(char *inbuf,int *offset,int length,
 336                                 struct res_rec **recs, int count)
 337 {
 338   int i;
 339   *recs = (struct res_rec *)malloc(sizeof(**recs)*count);
 340   if (!*recs) return(False);
 341
 342   memset((char *)*recs,'\0',sizeof(**recs)*count);
 343
 344   for (i=0;i<count;i++) {
 345     int l = parse_nmb_name(inbuf,*offset,length,&(*recs)[i].rr_name);
 346     (*offset) += l;
 347     if (!l || (*offset)+10 > length) {
 348       free(*recs);
 349       *recs = NULL;
 350       return(False);
 351     }
 352     (*recs)[i].rr_type = RSVAL(inbuf,(*offset));
 353     (*recs)[i].rr_class = RSVAL(inbuf,(*offset)+2);
 354     (*recs)[i].ttl = RIVAL(inbuf,(*offset)+4);
 355     (*recs)[i].rdlength = RSVAL(inbuf,(*offset)+8);
 356     (*offset) += 10;
 357     if ((*recs)[i].rdlength>sizeof((*recs)[i].rdata) ||
 358         (*offset)+(*recs)[i].rdlength > length) {
 359       free(*recs);
 360       *recs = NULL;
 361       return(False);
 362     }
 363     memcpy((*recs)[i].rdata,inbuf+(*offset),(*recs)[i].rdlength);
 364     (*offset) += (*recs)[i].rdlength;
 365   }
 366   return(True);
 367 }
 368
 369 /*******************************************************************
 370   put a resource record into a packet
 371   ******************************************************************/
 372 static int put_res_rec(char *buf,int offset,struct res_rec *recs,int count)
 373 {
 374   int ret=0;
 375   int i;
 376
 377   for (i=0;i<count;i++) {
 378     int l = put_nmb_name(buf,offset,&recs[i].rr_name);
 379     offset += l;
 380     ret += l;
 381     RSSVAL(buf,offset,recs[i].rr_type);
 382     RSSVAL(buf,offset+2,recs[i].rr_class);
 383     RSIVAL(buf,offset+4,recs[i].ttl);
 384     RSSVAL(buf,offset+8,recs[i].rdlength);
 385     memcpy(buf+offset+10,recs[i].rdata,recs[i].rdlength);
 386     offset += 10+recs[i].rdlength;
 387     ret += 10+recs[i].rdlength;
 388   }
 389
 390   return(ret);
 391 }
 392
 393 /*******************************************************************
 394   put a compressed name pointer record into a packet
 395   ******************************************************************/
 396 static int put_compressed_name_ptr(unsigned char *buf,int offset,struct res_rec *rec,int ptr_offset)
 397 {
 398   int ret=0;
 399   buf[offset] = (0xC0 | ((ptr_offset >> 8) & 0xFF));
 400   buf[offset+1] = (ptr_offset & 0xFF);
 401   offset += 2;
 402   ret += 2;
 403   RSSVAL(buf,offset,rec->rr_type);
 404   RSSVAL(buf,offset+2,rec->rr_class);
 405   RSIVAL(buf,offset+4,rec->ttl);
 406   RSSVAL(buf,offset+8,rec->rdlength);
 407   memcpy(buf+offset+10,rec->rdata,rec->rdlength);
 408   offset += 10+rec->rdlength;
 409   ret += 10+rec->rdlength;
 410
 411   return(ret);
 412 }
 413
 414 /*******************************************************************
 415   parse a dgram packet. Return False if the packet can't be parsed
 416   or is invalid for some reason, True otherwise
 417
 418   this is documented in section 4.4.1 of RFC1002
 419   ******************************************************************/
 420 static BOOL parse_dgram(char *inbuf,int length,struct dgram_packet *dgram)
 421 {
 422   int offset;
 423   int flags;
 424
 425   memset((char *)dgram,'\0',sizeof(*dgram));
 426
 427   if (length < 14) return(False);
 428
 429   dgram->header.msg_type = CVAL(inbuf,0);
 430   flags = CVAL(inbuf,1);
 431   dgram->header.flags.node_type = (enum node_type)((flags>>2)&3);
 432   if (flags & 1) dgram->header.flags.more = True;
 433   if (flags & 2) dgram->header.flags.first = True;
 434   dgram->header.dgm_id = RSVAL(inbuf,2);
 435   putip((char *)&dgram->header.source_ip,inbuf+4);
 436   dgram->header.source_port = RSVAL(inbuf,8);
 437   dgram->header.dgm_length = RSVAL(inbuf,10);
 438   dgram->header.packet_offset = RSVAL(inbuf,12);
 439
 440   offset = 14;
 441
 442   if (dgram->header.msg_type == 0x10 ||
 443       dgram->header.msg_type == 0x11 ||
 444       dgram->header.msg_type == 0x12) {
 445     offset += parse_nmb_name(inbuf,offset,length,&dgram->source_name);
 446     offset += parse_nmb_name(inbuf,offset,length,&dgram->dest_name);
 447   }
 448
 449   if (offset >= length || (length-offset > sizeof(dgram->data)))
 450     return(False);
 451
 452   dgram->datasize = length-offset;
 453   memcpy(dgram->data,inbuf+offset,dgram->datasize);
 454
 455   return(True);
 456 }
 457
 458
 459 /*******************************************************************
 460   parse a nmb packet. Return False if the packet can't be parsed
 461   or is invalid for some reason, True otherwise
 462   ******************************************************************/
 463 static BOOL parse_nmb(char *inbuf,int length,struct nmb_packet *nmb)
 464 {
 465   int nm_flags,offset;
 466
 467   memset((char *)nmb,'\0',sizeof(*nmb));
 468
 469   if (length < 12) return(False);
 470
 471   /* parse the header */
 472   nmb->header.name_trn_id = RSVAL(inbuf,0);
 473
 474   DEBUG(10,("parse_nmb: packet id = %d\n", nmb->header.name_trn_id));
 475
 476   nmb->header.opcode = (CVAL(inbuf,2) >> 3) & 0xF;
 477   nmb->header.response = ((CVAL(inbuf,2)>>7)&1)?True:False;
 478   nm_flags = ((CVAL(inbuf,2) & 0x7) << 4) + (CVAL(inbuf,3)>>4);
 479   nmb->header.nm_flags.bcast = (nm_flags&1)?True:False;
 480   nmb->header.nm_flags.recursion_available = (nm_flags&8)?True:False;
 481   nmb->header.nm_flags.recursion_desired = (nm_flags&0x10)?True:False;
 482   nmb->header.nm_flags.trunc = (nm_flags&0x20)?True:False;
 483   nmb->header.nm_flags.authoritative = (nm_flags&0x40)?True:False;
 484   nmb->header.rcode = CVAL(inbuf,3) & 0xF;
 485   nmb->header.qdcount = RSVAL(inbuf,4);
 486   nmb->header.ancount = RSVAL(inbuf,6);
 487   nmb->header.nscount = RSVAL(inbuf,8);
 488   nmb->header.arcount = RSVAL(inbuf,10);
 489
 490   if (nmb->header.qdcount) {
 491     offset = parse_nmb_name(inbuf,12,length,&nmb->question.question_name);
 492     if (!offset) return(False);
 493
 494     if (length - (12+offset) < 4) return(False);
 495     nmb->question.question_type = RSVAL(inbuf,12+offset);
 496     nmb->question.question_class = RSVAL(inbuf,12+offset+2);
 497
 498     offset += 12+4;
 499   } else {
 500     offset = 12;
 501   }
 502
 503   /* and any resource records */
 504   if (nmb->header.ancount &&
 505       !parse_alloc_res_rec(inbuf,&offset,length,&nmb->answers,
 506                            nmb->header.ancount))
 507     return(False);
 508
 509   if (nmb->header.nscount &&
 510       !parse_alloc_res_rec(inbuf,&offset,length,&nmb->nsrecs,
 511                            nmb->header.nscount))
 512     return(False);
 513
 514   if (nmb->header.arcount &&
 515       !parse_alloc_res_rec(inbuf,&offset,length,&nmb->additional,
 516                            nmb->header.arcount))
 517     return(False);
 518
 519   return(True);
 520 }
 521
 522 /*******************************************************************
 523   'Copy constructor' for an nmb packet
 524   ******************************************************************/
 525 static struct packet_struct *copy_nmb_packet(struct packet_struct *packet)
 526 {
 527   struct nmb_packet *nmb;
 528   struct nmb_packet *copy_nmb;
 529   struct packet_struct *pkt_copy;
 530
 531   if(( pkt_copy = (struct packet_struct *)malloc(sizeof(*packet))) == NULL)
 532   {
 533     DEBUG(0,("copy_nmb_packet: malloc fail.\n"));
 534     return NULL;
 535   }
 536
 537   /* Structure copy of entire thing. */
 538
 539   *pkt_copy = *packet;
 540
 541   /* Ensure this copy is not locked. */
 542   pkt_copy->locked = False;
 543
 544   /* Ensure this copy has no resource records. */
 545   nmb = &packet->packet.nmb;
 546   copy_nmb = &pkt_copy->packet.nmb;
 547
 548   copy_nmb->answers = NULL;
 549   copy_nmb->nsrecs = NULL;
 550   copy_nmb->additional = NULL;
 551
 552   /* Now copy any resource records. */
 553
 554   if (nmb->answers)
 555   {
 556     if((copy_nmb->answers = (struct res_rec *)
 557                   malloc(nmb->header.ancount * sizeof(struct res_rec))) == NULL)
 558       goto free_and_exit;
 559     memcpy((char *)copy_nmb->answers, (char *)nmb->answers,
 560            nmb->header.ancount * sizeof(struct res_rec));
 561   }
 562   if (nmb->nsrecs)
 563   {
 564     if((copy_nmb->nsrecs = (struct res_rec *)
 565                   malloc(nmb->header.nscount * sizeof(struct res_rec))) == NULL)
 566       goto free_and_exit;
 567     memcpy((char *)copy_nmb->nsrecs, (char *)nmb->nsrecs,
 568            nmb->header.nscount * sizeof(struct res_rec));
 569   }
 570   if (nmb->additional)
 571   {
 572     if((copy_nmb->additional = (struct res_rec *)
 573                   malloc(nmb->header.arcount * sizeof(struct res_rec))) == NULL)
 574       goto free_and_exit;
 575     memcpy((char *)copy_nmb->additional, (char *)nmb->additional,
 576            nmb->header.arcount * sizeof(struct res_rec));
 577   }
 578
 579   return pkt_copy;
 580
 581 free_and_exit:
 582
 583   if(copy_nmb->answers) {
 584     free((char *)copy_nmb->answers);
 585     copy_nmb->answers = NULL;
 586   }
 587   if(copy_nmb->nsrecs) {
 588     free((char *)copy_nmb->nsrecs);
 589     copy_nmb->nsrecs = NULL;
 590   }
 591   if(copy_nmb->additional) {
 592     free((char *)copy_nmb->additional);
 593     copy_nmb->additional = NULL;
 594   }
 595   free((char *)pkt_copy);
 596
 597   DEBUG(0,("copy_nmb_packet: malloc fail in resource records.\n"));
 598   return NULL;
 599 }
 600
 601 /*******************************************************************
 602   'Copy constructor' for a dgram packet
 603   ******************************************************************/
 604 static struct packet_struct *copy_dgram_packet(struct packet_struct *packet)
 605 {
 606   struct packet_struct *pkt_copy;
 607
 608   if(( pkt_copy = (struct packet_struct *)malloc(sizeof(*packet))) == NULL)
 609   {
 610     DEBUG(0,("copy_dgram_packet: malloc fail.\n"));
 611     return NULL;
 612   }
 613
 614   /* Structure copy of entire thing. */
 615
 616   *pkt_copy = *packet;
 617
 618   /* Ensure this copy is not locked. */
 619   pkt_copy->locked = False;
 620
 621   /* There are no additional pointers in a dgram packet,
 622      we are finished. */
 623   return pkt_copy;
 624 }
 625
 626 /*******************************************************************
 627   'Copy constructor' for a generic packet
 628   ******************************************************************/
 629 struct packet_struct *copy_packet(struct packet_struct *packet)
 630 {
 631   if(packet->packet_type == NMB_PACKET)
 632     return copy_nmb_packet(packet);
 633   else if (packet->packet_type == DGRAM_PACKET)
 634     return copy_dgram_packet(packet);
 635   return NULL;
 636 }
 637
 638 /*******************************************************************
 639   free up any resources associated with an nmb packet
 640   ******************************************************************/
 641 static void free_nmb_packet(struct nmb_packet *nmb)
 642 {
 643   if (nmb->answers) {
 644     free(nmb->answers);
 645     nmb->answers = NULL;
 646   }
 647   if (nmb->nsrecs) {
 648     free(nmb->nsrecs);
 649     nmb->nsrecs = NULL;
 650   }
 651   if (nmb->additional) {
 652     free(nmb->additional);
 653     nmb->additional = NULL;
 654   }
 655 }
 656
 657 /*******************************************************************
 658   free up any resources associated with a dgram packet
 659   ******************************************************************/
 660 static void free_dgram_packet(struct dgram_packet *nmb)
 661 {
 662   /* We have nothing to do for a dgram packet. */
 663 }
 664
 665 /*******************************************************************
 666   free up any resources associated with a packet
 667   ******************************************************************/
 668 void free_packet(struct packet_struct *packet)
 669 {
 670   if (packet->locked)
 671     return;
 672   if (packet->packet_type == NMB_PACKET)
 673     free_nmb_packet(&packet->packet.nmb);
 674   else if (packet->packet_type == DGRAM_PACKET)
 675     free_dgram_packet(&packet->packet.dgram);
 676   ZERO_STRUCTPN(packet);
 677   free(packet);
 678 }
 679
 680 /*******************************************************************
 681   read a packet from a socket and parse it, returning a packet ready
 682   to be used or put on the queue. This assumes a UDP socket
 683   ******************************************************************/
 684 struct packet_struct *read_packet(int fd,enum packet_type packet_type)
 685 {
 686   extern struct in_addr lastip;
 687   extern int lastport;
 688   struct packet_struct *packet;
 689   char buf[MAX_DGRAM_SIZE];
 690   int length;
 691   BOOL ok=False;
 692
 693   length = read_udp_socket(fd,buf,sizeof(buf));
 694   if (length < MIN_DGRAM_SIZE) return(NULL);
 695
 696   packet = (struct packet_struct *)malloc(sizeof(*packet));
 697   if (!packet) return(NULL);
 698
 699   packet->next = NULL;
 700   packet->prev = NULL;
 701   packet->ip = lastip;
 702   packet->port = lastport;
 703   packet->fd = fd;
 704   packet->locked = False;
 705   packet->timestamp = time(NULL);
 706   packet->packet_type = packet_type;
 707   switch (packet_type)
 708     {
 709     case NMB_PACKET:
 710       ok = parse_nmb(buf,length,&packet->packet.nmb);
 711       break;
 712
 713     case DGRAM_PACKET:
 714       ok = parse_dgram(buf,length,&packet->packet.dgram);
 715       break;
 716     }
 717   if (!ok) {
 718     DEBUG(10,("read_packet: discarding packet id = %d\n",
 719                  packet->packet.nmb.header.name_trn_id));
 720     free_packet(packet);
 721     return(NULL);
 722   }
 723
 724   num_good_receives++;
 725
 726   DEBUG(5,("Received a packet of len %d from (%s) port %d\n",
 727             length, inet_ntoa(packet->ip), packet->port ) );
 728
 729   return(packet);
 730 }
 731
 732
 733 /*******************************************************************
 734   send a udp packet on a already open socket
 735   ******************************************************************/
 736 static BOOL send_udp(int fd,char *buf,int len,struct in_addr ip,int port)
 737 {
 738   BOOL ret;
 739   struct sockaddr_in sock_out;
 740
 741   /* set the address and port */
 742   memset((char *)&sock_out,'\0',sizeof(sock_out));
 743   putip((char *)&sock_out.sin_addr,(char *)&ip);
 744   sock_out.sin_port = htons( port );
 745   sock_out.sin_family = AF_INET;
 746
 747   DEBUG( 5, ( "Sending a packet of len %d to (%s) on port %d\n",
 748               len, inet_ntoa(ip), port ) );
 749
 750   ret = (sendto(fd,buf,len,0,(struct sockaddr *)&sock_out,
 751                 sizeof(sock_out)) >= 0);
 752
 753   if (!ret)
 754     DEBUG(0,("Packet send failed to %s(%d) ERRNO=%s\n",
 755              inet_ntoa(ip),port,strerror(errno)));
 756
 757   if (ret)
 758     num_good_sends++;
 759
 760   return(ret);
 761 }
 762
 763 /*******************************************************************
 764   build a dgram packet ready for sending
 765
 766   XXXX This currently doesn't handle packets too big for one
 767   datagram. It should split them and use the packet_offset, more and
 768   first flags to handle the fragmentation. Yuck.
 769   ******************************************************************/
 770 static int build_dgram(char *buf,struct packet_struct *p)
 771 {
 772   struct dgram_packet *dgram = &p->packet.dgram;
 773   unsigned char *ubuf = (unsigned char *)buf;
 774   int offset=0;
 775
 776   /* put in the header */
 777   ubuf[0] = dgram->header.msg_type;
 778   ubuf[1] = (((int)dgram->header.flags.node_type)<<2);
 779   if (dgram->header.flags.more) ubuf[1] |= 1;
 780   if (dgram->header.flags.first) ubuf[1] |= 2;
 781   RSSVAL(ubuf,2,dgram->header.dgm_id);
 782   putip(ubuf+4,(char *)&dgram->header.source_ip);
 783   RSSVAL(ubuf,8,dgram->header.source_port);
 784   RSSVAL(ubuf,12,dgram->header.packet_offset);
 785
 786   offset = 14;
 787
 788   if (dgram->header.msg_type == 0x10 ||
 789       dgram->header.msg_type == 0x11 ||
 790       dgram->header.msg_type == 0x12) {
 791     offset += put_nmb_name((char *)ubuf,offset,&dgram->source_name);
 792     offset += put_nmb_name((char *)ubuf,offset,&dgram->dest_name);
 793   }
 794
 795   memcpy(ubuf+offset,dgram->data,dgram->datasize);
 796   offset += dgram->datasize;
 797
 798   /* automatically set the dgm_length */
 799   dgram->header.dgm_length = offset;
 800   RSSVAL(ubuf,10,dgram->header.dgm_length);
 801
 802   return(offset);
 803 }
 804
 805 /*******************************************************************
 806   build a nmb name
 807  *******************************************************************/
 808 void make_nmb_name( struct nmb_name *n, const char *name, int type, const char *this_scope )
 809 {
 810         memset( (char *)n, '\0', sizeof(struct nmb_name) );
 811         StrnCpy( n->name, name, 15 );
 812         strupper( n->name );
 813         n->name_type = (unsigned int)type & 0xFF;
 814         StrnCpy( n->scope, this_scope, 63 );
 815         strupper( n->scope );
 816 }
 817
 818 /*******************************************************************
 819   Compare two nmb names
 820   ******************************************************************/
 821
 822 BOOL nmb_name_equal(struct nmb_name *n1, struct nmb_name *n2)
 823 {
 824   return ((n1->name_type == n2->name_type) &&
 825          strequal(n1->name ,n2->name ) &&
 826          strequal(n1->scope,n2->scope));
 827 }
 828
 829 /*******************************************************************
 830   build a nmb packet ready for sending
 831
 832   XXXX this currently relies on not being passed something that expands
 833   to a packet too big for the buffer. Eventually this should be
 834   changed to set the trunc bit so the receiver can request the rest
 835   via tcp (when that becomes supported)
 836   ******************************************************************/
 837 static int build_nmb(char *buf,struct packet_struct *p)
 838 {
 839   struct nmb_packet *nmb = &p->packet.nmb;
 840   unsigned char *ubuf = (unsigned char *)buf;
 841   int offset=0;
 842
 843   /* put in the header */
 844   RSSVAL(ubuf,offset,nmb->header.name_trn_id);
 845   ubuf[offset+2] = (nmb->header.opcode & 0xF) << 3;
 846   if (nmb->header.response) ubuf[offset+2] |= (1<<7);
 847   if (nmb->header.nm_flags.authoritative &&
 848       nmb->header.response) ubuf[offset+2] |= 0x4;
 849   if (nmb->header.nm_flags.trunc) ubuf[offset+2] |= 0x2;
 850   if (nmb->header.nm_flags.recursion_desired) ubuf[offset+2] |= 0x1;
 851   if (nmb->header.nm_flags.recursion_available &&
 852       nmb->header.response) ubuf[offset+3] |= 0x80;
 853   if (nmb->header.nm_flags.bcast) ubuf[offset+3] |= 0x10;
 854   ubuf[offset+3] |= (nmb->header.rcode & 0xF);
 855
 856   RSSVAL(ubuf,offset+4,nmb->header.qdcount);
 857   RSSVAL(ubuf,offset+6,nmb->header.ancount);
 858   RSSVAL(ubuf,offset+8,nmb->header.nscount);
 859   RSSVAL(ubuf,offset+10,nmb->header.arcount);
 860
 861   offset += 12;
 862   if (nmb->header.qdcount) {
 863     /* XXXX this doesn't handle a qdcount of > 1 */
 864     offset += put_nmb_name((char *)ubuf,offset,&nmb->question.question_name);
 865     RSSVAL(ubuf,offset,nmb->question.question_type);
 866     RSSVAL(ubuf,offset+2,nmb->question.question_class);
 867     offset += 4;
 868   }
 869
 870   if (nmb->header.ancount)
 871     offset += put_res_rec((char *)ubuf,offset,nmb->answers,
 872                           nmb->header.ancount);
 873
 874   if (nmb->header.nscount)
 875     offset += put_res_rec((char *)ubuf,offset,nmb->nsrecs,
 876                           nmb->header.nscount);
 877
 878   /*
 879    * The spec says we must put compressed name pointers
 880    * in the following outgoing packets :
 881    * NAME_REGISTRATION_REQUEST, NAME_REFRESH_REQUEST,
 882    * NAME_RELEASE_REQUEST.
 883    */
 884
 885   if((nmb->header.response == False) &&
 886      ((nmb->header.opcode == NMB_NAME_REG_OPCODE) ||
 887       (nmb->header.opcode == NMB_NAME_RELEASE_OPCODE) ||
 888       (nmb->header.opcode == NMB_NAME_REFRESH_OPCODE_8) ||
 889       (nmb->header.opcode == NMB_NAME_REFRESH_OPCODE_9) ||
 890       (nmb->header.opcode == NMB_NAME_MULTIHOMED_REG_OPCODE)) &&
 891      (nmb->header.arcount == 1)) {
 892
 893     offset += put_compressed_name_ptr(ubuf,offset,nmb->additional,12);
 894
 895   } else if (nmb->header.arcount) {
 896     offset += put_res_rec((char *)ubuf,offset,nmb->additional,
 897                           nmb->header.arcount);
 898   }
 899   return(offset);
 900 }
 901
 902
 903 /*******************************************************************
 904   send a packet_struct
 905   ******************************************************************/
 906 BOOL send_packet(struct packet_struct *p)
 907 {
 908   char buf[1024];
 909   int len=0;
 910
 911   memset(buf,'\0',sizeof(buf));
 912
 913   switch (p->packet_type)
 914     {
 915     case NMB_PACKET:
 916       len = build_nmb(buf,p);
 917       debug_nmb_packet(p);
 918       break;
 919
 920     case DGRAM_PACKET:
 921       len = build_dgram(buf,p);
 922       break;
 923     }
 924
 925   if (!len) return(False);
 926
 927   return(send_udp(p->fd,buf,len,p->ip,p->port));
 928 }
 929
 930 /****************************************************************************
 931   receive a packet with timeout on a open UDP filedescriptor
 932   The timeout is in milliseconds
 933   ***************************************************************************/
 934 struct packet_struct *receive_packet(int fd,enum packet_type type,int t)
 935 {
 936   fd_set fds;
 937   struct timeval timeout;
 938
 939   FD_ZERO(&fds);
 940   FD_SET(fd,&fds);
 941   timeout.tv_sec = t/1000;
 942   timeout.tv_usec = 1000*(t%1000);
 943
 944   sys_select(fd+1,&fds,&timeout);
 945
 946   if (FD_ISSET(fd,&fds))
 947     return(read_packet(fd,type));
 948
 949   return(NULL);
 950 }
 951
 952
 953 /****************************************************************************
 954 return the number of bits that match between two 4 character buffers
 955   ***************************************************************************/
 956 static int matching_bits(uchar *p1, uchar *p2)
 957 {
 958         int i, j, ret = 0;
 959         for (i=0; i<4; i++) {
 960                 if (p1[i] != p2[i]) break;
 961                 ret += 8;
 962         }
 963
 964         if (i==4) return ret;
 965
 966         for (j=0; j<8; j++) {
 967                 if ((p1[i] & (1<<(7-j))) != (p2[i] & (1<<(7-j)))) break;
 968                 ret++;
 969         }
 970
 971         return ret;
 972 }
 973
 974
 975 static uchar sort_ip[4];
 976
 977 /****************************************************************************
 978 compare two query reply records
 979   ***************************************************************************/
 980 static int name_query_comp(uchar *p1, uchar *p2)
 981 {
 982         return matching_bits(p2+2, sort_ip) - matching_bits(p1+2, sort_ip);
 983 }
 984
 985 /****************************************************************************
 986 sort a set of 6 byte name query response records so that the IPs that
 987 have the most leading bits in common with the specified address come first
 988   ***************************************************************************/
 989 void sort_query_replies(char *data, int n, struct in_addr ip)
 990 {
 991         if (n <= 1) return;
 992
 993         putip(sort_ip, (char *)&ip);
 994
 995         qsort(data, n, 6, QSORT_CAST name_query_comp);
 996 }