source3/lib/util.c

   1 /*
   2    Unix SMB/Netbios implementation.
   3    Version 1.9.
   4    Samba utility functions
   5    Copyright (C) Andrew Tridgell 1992-1995
   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 #include "includes.h"
  23
  24 pstring scope = "";
  25
  26 int DEBUGLEVEL = 1;
  27
  28 BOOL passive = False;
  29
  30 int Protocol = PROTOCOL_COREPLUS;
  31
  32 /* a default finfo structure to ensure all fields are sensible */
  33 file_info def_finfo = {-1,0,0,0,0,0,0,""};
  34
  35 /* these are some file handles where debug info will be stored */
  36 FILE *dbf = NULL;
  37
  38 /* the client file descriptor */
  39 int Client = -1;
  40
  41 /* info on the client */
  42 struct from_host Client_info=
  43 {"UNKNOWN","0.0.0.0",NULL};
  44
  45 /* the last IP received from */
  46 struct in_addr lastip;
  47
  48 /* the last port received from */
  49 int lastport=0;
  50
  51 int trans_num = 0;
  52
  53 /*
  54    case handling on filenames
  55 */
  56 int case_default = CASE_LOWER;
  57
  58 pstring debugf = "/tmp/log.samba";
  59 int syslog_level;
  60
  61 /* the following control case operations - they are put here so the
  62    client can link easily */
  63 BOOL case_sensitive;
  64 BOOL case_preserve;
  65 BOOL use_mangled_map = False;
  66 BOOL short_case_preserve;
  67 BOOL case_mangle;
  68
  69 fstring remote_machine="";
  70 fstring local_machine="";
  71 fstring remote_arch="UNKNOWN";
  72 fstring remote_proto="UNKNOWN";
  73 pstring myhostname="";
  74 pstring user_socket_options="";
  75 pstring sesssetup_user="";
  76
  77
  78 static char *filename_dos(char *path,char *buf);
  79
  80 static BOOL stdout_logging = False;
  81
  82
  83 /*******************************************************************
  84   get ready for syslog stuff
  85   ******************************************************************/
  86 void setup_logging(char *pname,BOOL interactive)
  87 {
  88 #ifdef SYSLOG
  89   if (!interactive) {
  90     char *p = strrchr(pname,'/');
  91     if (p) pname = p+1;
  92     openlog(pname, LOG_PID, LOG_DAEMON);
  93   }
  94 #endif
  95   if (interactive) {
  96     stdout_logging = True;
  97     dbf = stdout;
  98   }
  99 }
 100
 101
 102 BOOL append_log=False;
 103
 104
 105 /****************************************************************************
 106 reopen the log files
 107 ****************************************************************************/
 108 void reopen_logs(void)
 109 {
 110   extern FILE *dbf;
 111   pstring fname;
 112
 113   if (DEBUGLEVEL > 0)
 114     {
 115       strcpy(fname,debugf);
 116       if (lp_loaded() && (*lp_logfile()))
 117         strcpy(fname,lp_logfile());
 118
 119       if (!strcsequal(fname,debugf) || !dbf || !file_exist(debugf,NULL))
 120         {
 121           strcpy(debugf,fname);
 122           if (dbf) fclose(dbf);
 123           if (append_log)
 124             dbf = fopen(debugf,"a");
 125           else
 126             dbf = fopen(debugf,"w");
 127           if (dbf) setbuf(dbf,NULL);
 128         }
 129     }
 130   else
 131     {
 132       if (dbf)
 133         {
 134           fclose(dbf);
 135           dbf = NULL;
 136         }
 137     }
 138 }
 139
 140
 141 /*******************************************************************
 142 check if the log has grown too big
 143 ********************************************************************/
 144 static void check_log_size(void)
 145 {
 146   static int debug_count=0;
 147   int maxlog;
 148   struct stat st;
 149
 150   if (debug_count++ < 100) return;
 151
 152   maxlog = lp_max_log_size() * 1024;
 153   if (!dbf || maxlog <= 0) return;
 154
 155   if (fstat(fileno(dbf),&st) == 0 && st.st_size > maxlog) {
 156     fclose(dbf); dbf = NULL;
 157     reopen_logs();
 158     if (dbf && file_size(debugf) > maxlog) {
 159       pstring name;
 160       fclose(dbf); dbf = NULL;
 161       sprintf(name,"%s.old",debugf);
 162       sys_rename(debugf,name);
 163       reopen_logs();
 164     }
 165   }
 166   debug_count=0;
 167 }
 168
 169
 170 /*******************************************************************
 171 write an debug message on the debugfile. This is called by the DEBUG
 172 macro
 173 ********************************************************************/
 174 #ifdef __STDC__
 175  int Debug1(char *format_str, ...)
 176 {
 177 #else
 178  int Debug1(va_alist)
 179 va_dcl
 180 {
 181   char *format_str;
 182 #endif
 183   va_list ap;
 184
 185   if (stdout_logging) {
 186 #ifdef __STDC__
 187     va_start(ap, format_str);
 188 #else
 189     va_start(ap);
 190     format_str = va_arg(ap,char *);
 191 #endif
 192     vfprintf(dbf,format_str,ap);
 193     va_end(ap);
 194     return(0);
 195   }
 196
 197 #ifdef SYSLOG
 198   if (!lp_syslog_only())
 199 #endif
 200     {
 201       if (!dbf)
 202         {
 203           dbf = fopen(debugf,"w");
 204           if (dbf)
 205             setbuf(dbf,NULL);
 206           else
 207             return(0);
 208         }
 209     }
 210
 211 #ifdef SYSLOG
 212   if (syslog_level < lp_syslog())
 213     {
 214       /*
 215        * map debug levels to syslog() priorities
 216        * note that not all DEBUG(0, ...) calls are
 217        * necessarily errors
 218        */
 219       static int priority_map[] = {
 220         LOG_ERR,     /* 0 */
 221         LOG_WARNING, /* 1 */
 222         LOG_NOTICE,  /* 2 */
 223         LOG_INFO,    /* 3 */
 224       };
 225       int priority;
 226       pstring msgbuf;
 227
 228       if (syslog_level >= sizeof(priority_map) / sizeof(priority_map[0]) ||
 229           syslog_level < 0)
 230         priority = LOG_DEBUG;
 231       else
 232         priority = priority_map[syslog_level];
 233
 234 #ifdef __STDC__
 235       va_start(ap, format_str);
 236 #else
 237       va_start(ap);
 238       format_str = va_arg(ap,char *);
 239 #endif
 240       vsprintf(msgbuf, format_str, ap);
 241       va_end(ap);
 242
 243       msgbuf[255] = '\0';
 244       syslog(priority, "%s", msgbuf);
 245     }
 246 #endif
 247
 248 #ifdef SYSLOG
 249   if (!lp_syslog_only())
 250 #endif
 251     {
 252 #ifdef __STDC__
 253       va_start(ap, format_str);
 254 #else
 255       va_start(ap);
 256       format_str = va_arg(ap,char *);
 257 #endif
 258       vfprintf(dbf,format_str,ap);
 259       va_end(ap);
 260       fflush(dbf);
 261     }
 262
 263   check_log_size();
 264
 265   return(0);
 266 }
 267
 268 /****************************************************************************
 269 determine if a file descriptor is in fact a socket
 270 ****************************************************************************/
 271 BOOL is_a_socket(int fd)
 272 {
 273   int v,l;
 274   l = sizeof(int);
 275   return(getsockopt(fd, SOL_SOCKET, SO_TYPE, (char *)&v, &l) == 0);
 276 }
 277
 278
 279 static char *last_ptr=NULL;
 280
 281 /****************************************************************************
 282   Get the next token from a string, return False if none found
 283   handles double-quotes.
 284 Based on a routine by GJC@VILLAGE.COM.
 285 Extensively modified by Andrew.Tridgell@anu.edu.au
 286 ****************************************************************************/
 287 BOOL next_token(char **ptr,char *buff,char *sep)
 288 {
 289   char *s;
 290   BOOL quoted;
 291
 292   if (!ptr) ptr = &last_ptr;
 293   if (!ptr) return(False);
 294
 295   s = *ptr;
 296
 297   /* default to simple separators */
 298   if (!sep) sep = " \t\n\r";
 299
 300   /* find the first non sep char */
 301   while(*s && strchr(sep,*s)) s++;
 302
 303   /* nothing left? */
 304   if (! *s) return(False);
 305
 306   /* copy over the token */
 307   for (quoted = False; *s && (quoted || !strchr(sep,*s)); s++)
 308     {
 309       if (*s == '\"')
 310         quoted = !quoted;
 311       else
 312         *buff++ = *s;
 313     }
 314
 315   *ptr = (*s) ? s+1 : s;
 316   *buff = 0;
 317   last_ptr = *ptr;
 318
 319   return(True);
 320 }
 321
 322 /****************************************************************************
 323 Convert list of tokens to array; dependent on above routine.
 324 Uses last_ptr from above - bit of a hack.
 325 ****************************************************************************/
 326 char **toktocliplist(int *ctok, char *sep)
 327 {
 328   char *s=last_ptr;
 329   int ictok=0;
 330   char **ret, **iret;
 331
 332   if (!sep) sep = " \t\n\r";
 333
 334   while(*s && strchr(sep,*s)) s++;
 335
 336   /* nothing left? */
 337   if (!*s) return(NULL);
 338
 339   do {
 340     ictok++;
 341     while(*s && (!strchr(sep,*s))) s++;
 342     while(*s && strchr(sep,*s)) *s++=0;
 343   } while(*s);
 344
 345   *ctok=ictok;
 346   s=last_ptr;
 347
 348   if (!(ret=iret=malloc(ictok*sizeof(char *)))) return NULL;
 349
 350   while(ictok--) {
 351     *iret++=s;
 352     while(*s++);
 353     while(!*s) s++;
 354   }
 355
 356   return ret;
 357 }
 358
 359 #ifndef HAVE_MEMMOVE
 360 /*******************************************************************
 361 safely copies memory, ensuring no overlap problems.
 362 this is only used if the machine does not have it's own memmove().
 363 this is not the fastest algorithm in town, but it will do for our
 364 needs.
 365 ********************************************************************/
 366 void *MemMove(void *dest,void *src,int size)
 367 {
 368   unsigned long d,s;
 369   int i;
 370   if (dest==src || !size) return(dest);
 371
 372   d = (unsigned long)dest;
 373   s = (unsigned long)src;
 374
 375   if ((d >= (s+size)) || (s >= (d+size))) {
 376     /* no overlap */
 377     memcpy(dest,src,size);
 378     return(dest);
 379   }
 380
 381   if (d < s)
 382     {
 383       /* we can forward copy */
 384       if (s-d >= sizeof(int) &&
 385           !(s%sizeof(int)) && !(d%sizeof(int)) && !(size%sizeof(int))) {
 386         /* do it all as words */
 387         int *idest = (int *)dest;
 388         int *isrc = (int *)src;
 389         size /= sizeof(int);
 390         for (i=0;i<size;i++) idest[i] = isrc[i];
 391       } else {
 392         /* simplest */
 393         char *cdest = (char *)dest;
 394         char *csrc = (char *)src;
 395         for (i=0;i<size;i++) cdest[i] = csrc[i];
 396       }
 397     }
 398   else
 399     {
 400       /* must backward copy */
 401       if (d-s >= sizeof(int) &&
 402           !(s%sizeof(int)) && !(d%sizeof(int)) && !(size%sizeof(int))) {
 403         /* do it all as words */
 404         int *idest = (int *)dest;
 405         int *isrc = (int *)src;
 406         size /= sizeof(int);
 407         for (i=size-1;i>=0;i--) idest[i] = isrc[i];
 408       } else {
 409         /* simplest */
 410         char *cdest = (char *)dest;
 411         char *csrc = (char *)src;
 412         for (i=size-1;i>=0;i--) cdest[i] = csrc[i];
 413       }
 414     }
 415   return(dest);
 416 }
 417 #endif
 418
 419
 420 /****************************************************************************
 421 prompte a dptr (to make it recently used)
 422 ****************************************************************************/
 423 void array_promote(char *array,int elsize,int element)
 424 {
 425   char *p;
 426   if (element == 0)
 427     return;
 428
 429   p = (char *)malloc(elsize);
 430
 431   if (!p)
 432     {
 433       DEBUG(5,("Ahh! Can't malloc\n"));
 434       return;
 435     }
 436   memcpy(p,array + element * elsize, elsize);
 437   memmove(array + elsize,array,elsize*element);
 438   memcpy(array,p,elsize);
 439   free(p);
 440 }
 441
 442 enum SOCK_OPT_TYPES {OPT_BOOL,OPT_INT,OPT_ON};
 443
 444 struct
 445 {
 446   char *name;
 447   int level;
 448   int option;
 449   int value;
 450   int opttype;
 451 } socket_options[] = {
 452   {"SO_KEEPALIVE",      SOL_SOCKET,    SO_KEEPALIVE,    0,                 OPT_BOOL},
 453   {"SO_REUSEADDR",      SOL_SOCKET,    SO_REUSEADDR,    0,                 OPT_BOOL},
 454   {"SO_BROADCAST",      SOL_SOCKET,    SO_BROADCAST,    0,                 OPT_BOOL},
 455 #ifdef TCP_NODELAY
 456   {"TCP_NODELAY",       IPPROTO_TCP,   TCP_NODELAY,     0,                 OPT_BOOL},
 457 #endif
 458 #ifdef IPTOS_LOWDELAY
 459   {"IPTOS_LOWDELAY",    IPPROTO_IP,    IP_TOS,          IPTOS_LOWDELAY,    OPT_ON},
 460 #endif
 461 #ifdef IPTOS_THROUGHPUT
 462   {"IPTOS_THROUGHPUT",  IPPROTO_IP,    IP_TOS,          IPTOS_THROUGHPUT,  OPT_ON},
 463 #endif
 464 #ifdef SO_SNDBUF
 465   {"SO_SNDBUF",         SOL_SOCKET,    SO_SNDBUF,       0,                 OPT_INT},
 466 #endif
 467 #ifdef SO_RCVBUF
 468   {"SO_RCVBUF",         SOL_SOCKET,    SO_RCVBUF,       0,                 OPT_INT},
 469 #endif
 470 #ifdef SO_SNDLOWAT
 471   {"SO_SNDLOWAT",       SOL_SOCKET,    SO_SNDLOWAT,     0,                 OPT_INT},
 472 #endif
 473 #ifdef SO_RCVLOWAT
 474   {"SO_RCVLOWAT",       SOL_SOCKET,    SO_RCVLOWAT,     0,                 OPT_INT},
 475 #endif
 476   {NULL,0,0,0,0}};
 477
 478
 479
 480 /****************************************************************************
 481 set user socket options
 482 ****************************************************************************/
 483 void set_socket_options(int fd, char *options)
 484 {
 485   string tok;
 486
 487   while (next_token(&options,tok," \t,"))
 488     {
 489       int ret=0,i;
 490       int value = 1;
 491       char *p;
 492       BOOL got_value = False;
 493
 494       if ((p = strchr(tok,'=')))
 495         {
 496           *p = 0;
 497           value = atoi(p+1);
 498           got_value = True;
 499         }
 500
 501       for (i=0;socket_options[i].name;i++)
 502         if (strequal(socket_options[i].name,tok))
 503           break;
 504
 505       if (!socket_options[i].name)
 506         {
 507           DEBUG(0,("Unknown socket option %s\n",tok));
 508           continue;
 509         }
 510
 511       switch (socket_options[i].opttype)
 512         {
 513         case OPT_BOOL:
 514         case OPT_INT:
 515           ret = setsockopt(fd,socket_options[i].level,
 516                            socket_options[i].option,(char *)&value,sizeof(int));
 517           break;
 518
 519         case OPT_ON:
 520           if (got_value)
 521             DEBUG(0,("syntax error - %s does not take a value\n",tok));
 522
 523           {
 524             int on = socket_options[i].value;
 525             ret = setsockopt(fd,socket_options[i].level,
 526                              socket_options[i].option,(char *)&on,sizeof(int));
 527           }
 528           break;
 529         }
 530
 531       if (ret != 0)
 532         DEBUG(0,("Failed to set socket option %s\n",tok));
 533     }
 534 }
 535
 536
 537
 538 /****************************************************************************
 539   close the socket communication
 540 ****************************************************************************/
 541 void close_sockets(void )
 542 {
 543   close(Client);
 544   Client = 0;
 545 }
 546
 547 /****************************************************************************
 548 determine whether we are in the specified group
 549 ****************************************************************************/
 550 BOOL in_group(gid_t group, int current_gid, int ngroups, int *groups)
 551 {
 552   int i;
 553
 554   if (group == current_gid) return(True);
 555
 556   for (i=0;i<ngroups;i++)
 557     if (group == groups[i])
 558       return(True);
 559
 560   return(False);
 561 }
 562
 563 /****************************************************************************
 564 this is a safer strcpy(), meant to prevent core dumps when nasty things happen
 565 ****************************************************************************/
 566 char *StrCpy(char *dest,char *src)
 567 {
 568   char *d = dest;
 569
 570 #if AJT
 571   /* I don't want to get lazy with these ... */
 572   if (!dest || !src) {
 573     DEBUG(0,("ERROR: NULL StrCpy() called!\n"));
 574     ajt_panic();
 575   }
 576 #endif
 577
 578   if (!dest) return(NULL);
 579   if (!src) {
 580     *dest = 0;
 581     return(dest);
 582   }
 583   while ((*d++ = *src++)) ;
 584   return(dest);
 585 }
 586
 587 /****************************************************************************
 588 line strncpy but always null terminates. Make sure there is room!
 589 ****************************************************************************/
 590 char *StrnCpy(char *dest,const char *src,int n)
 591 {
 592   char *d = dest;
 593   if (!dest) return(NULL);
 594   if (!src) {
 595     *dest = 0;
 596     return(dest);
 597   }
 598   while (n-- && (*d++ = *src++)) ;
 599   *d = 0;
 600   return(dest);
 601 }
 602
 603
 604 /*******************************************************************
 605 copy an IP address from one buffer to another
 606 ********************************************************************/
 607 void putip(void *dest,void *src)
 608 {
 609   memcpy(dest,src,4);
 610 }
 611
 612
 613 /****************************************************************************
 614 interpret the weird netbios "name". Return the name type
 615 ****************************************************************************/
 616 static int name_interpret(char *in,char *out)
 617 {
 618   int ret;
 619   int len = (*in++) / 2;
 620
 621   *out=0;
 622
 623   if (len > 30 || len<1) return(0);
 624
 625   while (len--)
 626     {
 627       if (in[0] < 'A' || in[0] > 'P' || in[1] < 'A' || in[1] > 'P') {
 628         *out = 0;
 629         return(0);
 630       }
 631       *out = ((in[0]-'A')<<4) + (in[1]-'A');
 632       in += 2;
 633       out++;
 634     }
 635   *out = 0;
 636   ret = out[-1];
 637
 638 #ifdef NETBIOS_SCOPE
 639   /* Handle any scope names */
 640   while(*in)
 641     {
 642       *out++ = '.'; /* Scope names are separated by periods */
 643       len = *(unsigned char *)in++;
 644       StrnCpy(out, in, len);
 645       out += len;
 646       *out=0;
 647       in += len;
 648     }
 649 #endif
 650   return(ret);
 651 }
 652
 653 /****************************************************************************
 654 mangle a name into netbios format
 655 ****************************************************************************/
 656 int name_mangle(char *In,char *Out,char name_type)
 657 {
 658   fstring name;
 659   char buf[20];
 660   char *in = (char *)&buf[0];
 661   char *out = (char *)Out;
 662   char *p, *label;
 663   int i;
 664
 665   if (In[0] != '*') {
 666     StrnCpy(name,In,sizeof(name)-1);
 667     sprintf(buf,"%-15.15s%c",name,name_type);
 668   } else {
 669     buf[0]='*';
 670     memset(&buf[1],0,16);
 671   }
 672
 673   *out++ = 32;
 674   for (i=0;i<16;i++) {
 675     char c = toupper(in[i]);
 676     out[i*2] = (c>>4) + 'A';
 677     out[i*2+1] = (c & 0xF) + 'A';
 678   }
 679   out[32]=0;
 680   out += 32;
 681
 682   label = scope;
 683   while (*label)
 684     {
 685       p = strchr(label, '.');
 686       if (p == 0)
 687         p = label + strlen(label);
 688       *out++ = p - label;
 689       memcpy(out, label, p - label);
 690       out += p - label;
 691       label += p - label + (*p == '.');
 692     }
 693   *out = 0;
 694   return(name_len(Out));
 695 }
 696
 697
 698 /*******************************************************************
 699   check if a file exists
 700 ********************************************************************/
 701 BOOL file_exist(char *fname,struct stat *sbuf)
 702 {
 703   struct stat st;
 704   if (!sbuf) sbuf = &st;
 705
 706   if (sys_stat(fname,sbuf) != 0)
 707     return(False);
 708
 709   return(S_ISREG(sbuf->st_mode));
 710 }
 711
 712 /*******************************************************************
 713 check a files mod time
 714 ********************************************************************/
 715 time_t file_modtime(char *fname)
 716 {
 717   struct stat st;
 718
 719   if (sys_stat(fname,&st) != 0)
 720     return(0);
 721
 722   return(st.st_mtime);
 723 }
 724
 725 /*******************************************************************
 726   check if a directory exists
 727 ********************************************************************/
 728 BOOL directory_exist(char *dname,struct stat *st)
 729 {
 730   struct stat st2;
 731   if (!st) st = &st2;
 732
 733   if (sys_stat(dname,st) != 0)
 734     return(False);
 735
 736   return(S_ISDIR(st->st_mode));
 737 }
 738
 739 /*******************************************************************
 740 returns the size in bytes of the named file
 741 ********************************************************************/
 742 uint32 file_size(char *file_name)
 743 {
 744   struct stat buf;
 745   buf.st_size = 0;
 746   sys_stat(file_name,&buf);
 747   return(buf.st_size);
 748 }
 749
 750 /*******************************************************************
 751 return a string representing an attribute for a file
 752 ********************************************************************/
 753 char *attrib_string(int mode)
 754 {
 755   static char attrstr[10];
 756
 757   attrstr[0] = 0;
 758
 759   if (mode & aVOLID) strcat(attrstr,"V");
 760   if (mode & aDIR) strcat(attrstr,"D");
 761   if (mode & aARCH) strcat(attrstr,"A");
 762   if (mode & aHIDDEN) strcat(attrstr,"H");
 763   if (mode & aSYSTEM) strcat(attrstr,"S");
 764   if (mode & aRONLY) strcat(attrstr,"R");
 765
 766   return(attrstr);
 767 }
 768
 769
 770 /*******************************************************************
 771   case insensitive string compararison
 772 ********************************************************************/
 773 int StrCaseCmp(char *s, char *t)
 774 {
 775   for (; tolower(*s) == tolower(*t); ++s, ++t)
 776     if (!*s) return 0;
 777
 778   return tolower(*s) - tolower(*t);
 779 }
 780
 781 /*******************************************************************
 782   case insensitive string compararison, length limited
 783 ********************************************************************/
 784 int StrnCaseCmp(char *s, char *t, int n)
 785 {
 786   while (n-- && *s && *t) {
 787     if (tolower(*s) != tolower(*t)) return(tolower(*s) - tolower(*t));
 788     s++; t++;
 789   }
 790   if (n) return(tolower(*s) - tolower(*t));
 791
 792   return(0);
 793 }
 794
 795 /*******************************************************************
 796   compare 2 strings
 797 ********************************************************************/
 798 BOOL strequal(char *s1,char *s2)
 799 {
 800   if (s1 == s2) return(True);
 801   if (!s1 || !s2) return(False);
 802
 803   return(StrCaseCmp(s1,s2)==0);
 804 }
 805
 806 /*******************************************************************
 807   compare 2 strings up to and including the nth char.
 808   ******************************************************************/
 809 BOOL strnequal(char *s1,char *s2,int n)
 810 {
 811   if (s1 == s2) return(True);
 812   if (!s1 || !s2 || !n) return(False);
 813
 814   return(StrnCaseCmp(s1,s2,n)==0);
 815 }
 816
 817 /*******************************************************************
 818   compare 2 strings (case sensitive)
 819 ********************************************************************/
 820 BOOL strcsequal(char *s1,char *s2)
 821 {
 822   if (s1 == s2) return(True);
 823   if (!s1 || !s2) return(False);
 824
 825   return(strcmp(s1,s2)==0);
 826 }
 827
 828
 829 /*******************************************************************
 830   convert a string to lower case
 831 ********************************************************************/
 832 void strlower(char *s)
 833 {
 834   while (*s)
 835     {
 836 #ifdef KANJI
 837         if (is_shift_jis (*s)) {
 838             s += 2;
 839         } else if (is_kana (*s)) {
 840             s++;
 841         } else {
 842             if (isupper(*s))
 843                 *s = tolower(*s);
 844             s++;
 845         }
 846 #else
 847       if (isupper(*s))
 848           *s = tolower(*s);
 849       s++;
 850 #endif /* KANJI */
 851     }
 852 }
 853
 854 /*******************************************************************
 855   convert a string to upper case
 856 ********************************************************************/
 857 void strupper(char *s)
 858 {
 859   while (*s)
 860     {
 861 #ifdef KANJI
 862         if (is_shift_jis (*s)) {
 863             s += 2;
 864         } else if (is_kana (*s)) {
 865             s++;
 866         } else {
 867             if (islower(*s))
 868                 *s = toupper(*s);
 869             s++;
 870         }
 871 #else
 872       if (islower(*s))
 873         *s = toupper(*s);
 874       s++;
 875 #endif
 876     }
 877 }
 878
 879 /*******************************************************************
 880   convert a string to "normal" form
 881 ********************************************************************/
 882 void strnorm(char *s)
 883 {
 884   if (case_default == CASE_UPPER)
 885     strupper(s);
 886   else
 887     strlower(s);
 888 }
 889
 890 /*******************************************************************
 891 check if a string is in "normal" case
 892 ********************************************************************/
 893 BOOL strisnormal(char *s)
 894 {
 895   if (case_default == CASE_UPPER)
 896     return(!strhaslower(s));
 897
 898   return(!strhasupper(s));
 899 }
 900
 901
 902 /****************************************************************************
 903   string replace
 904 ****************************************************************************/
 905 void string_replace(char *s,char oldc,char newc)
 906 {
 907   while (*s)
 908     {
 909 #ifdef KANJI
 910         if (is_shift_jis (*s)) {
 911             s += 2;
 912         } else if (is_kana (*s)) {
 913             s++;
 914         } else {
 915             if (oldc == *s)
 916                 *s = newc;
 917             s++;
 918         }
 919 #else
 920       if (oldc == *s)
 921         *s = newc;
 922       s++;
 923 #endif /* KANJI */
 924     }
 925 }
 926
 927 /****************************************************************************
 928   make a file into unix format
 929 ****************************************************************************/
 930 void unix_format(char *fname)
 931 {
 932   pstring namecopy;
 933   string_replace(fname,'\\','/');
 934 #ifndef KANJI
 935   dos2unix_format(fname, True);
 936 #endif /* KANJI */
 937
 938   if (*fname == '/')
 939     {
 940       strcpy(namecopy,fname);
 941       strcpy(fname,".");
 942       strcat(fname,namecopy);
 943     }
 944 }
 945
 946 /****************************************************************************
 947   make a file into dos format
 948 ****************************************************************************/
 949 void dos_format(char *fname)
 950 {
 951 #ifndef KANJI
 952   unix2dos_format(fname, True);
 953 #endif /* KANJI */
 954   string_replace(fname,'/','\\');
 955 }
 956
 957
 958 /*******************************************************************
 959   show a smb message structure
 960 ********************************************************************/
 961 void show_msg(char *buf)
 962 {
 963   int i;
 964   int bcc=0;
 965   if (DEBUGLEVEL < 5)
 966     return;
 967
 968   DEBUG(5,("size=%d\nsmb_com=0x%x\nsmb_rcls=%d\nsmb_reh=%d\nsmb_err=%d\nsmb_flg=%d\nsmb_flg2=%d\n",
 969           smb_len(buf),
 970           (int)CVAL(buf,smb_com),
 971           (int)CVAL(buf,smb_rcls),
 972           (int)CVAL(buf,smb_reh),
 973           (int)SVAL(buf,smb_err),
 974           (int)CVAL(buf,smb_flg),
 975           (int)SVAL(buf,smb_flg2)));
 976   DEBUG(5,("smb_tid=%d\nsmb_pid=%d\nsmb_uid=%d\nsmb_mid=%d\nsmt_wct=%d\n",
 977           (int)SVAL(buf,smb_tid),
 978           (int)SVAL(buf,smb_pid),
 979           (int)SVAL(buf,smb_uid),
 980           (int)SVAL(buf,smb_mid),
 981           (int)CVAL(buf,smb_wct)));
 982   for (i=0;i<(int)CVAL(buf,smb_wct);i++)
 983     DEBUG(5,("smb_vwv[%d]=%d (0x%X)\n",i,
 984           SVAL(buf,smb_vwv+2*i),SVAL(buf,smb_vwv+2*i)));
 985   bcc = (int)SVAL(buf,smb_vwv+2*(CVAL(buf,smb_wct)));
 986   DEBUG(5,("smb_bcc=%d\n",bcc));
 987   if (DEBUGLEVEL < 10)
 988     return;
 989   for (i=0;i<MIN(bcc,128);i++)
 990     DEBUG(10,("%X ",CVAL(smb_buf(buf),i)));
 991   DEBUG(10,("\n"));
 992 }
 993
 994 /*******************************************************************
 995   return the length of an smb packet
 996 ********************************************************************/
 997 int smb_len(char *buf)
 998 {
 999   return( PVAL(buf,3) | (PVAL(buf,2)<<8) | ((PVAL(buf,1)&1)<<16) );
1000 }
1001
1002 /*******************************************************************
1003   set the length of an smb packet
1004 ********************************************************************/
1005 void _smb_setlen(char *buf,int len)
1006 {
1007   buf[0] = 0;
1008   buf[1] = (len&0x10000)>>16;
1009   buf[2] = (len&0xFF00)>>8;
1010   buf[3] = len&0xFF;
1011 }
1012
1013 /*******************************************************************
1014   set the length and marker of an smb packet
1015 ********************************************************************/
1016 void smb_setlen(char *buf,int len)
1017 {
1018   _smb_setlen(buf,len);
1019
1020   CVAL(buf,4) = 0xFF;
1021   CVAL(buf,5) = 'S';
1022   CVAL(buf,6) = 'M';
1023   CVAL(buf,7) = 'B';
1024 }
1025
1026 /*******************************************************************
1027   setup the word count and byte count for a smb message
1028 ********************************************************************/
1029 int set_message(char *buf,int num_words,int num_bytes,BOOL zero)
1030 {
1031   if (zero)
1032     bzero(buf + smb_size,num_words*2 + num_bytes);
1033   CVAL(buf,smb_wct) = num_words;
1034   SSVAL(buf,smb_vwv + num_words*SIZEOFWORD,num_bytes);
1035   smb_setlen(buf,smb_size + num_words*2 + num_bytes - 4);
1036   return (smb_size + num_words*2 + num_bytes);
1037 }
1038
1039 /*******************************************************************
1040 return the number of smb words
1041 ********************************************************************/
1042 int smb_numwords(char *buf)
1043 {
1044   return (CVAL(buf,smb_wct));
1045 }
1046
1047 /*******************************************************************
1048 return the size of the smb_buf region of a message
1049 ********************************************************************/
1050 int smb_buflen(char *buf)
1051 {
1052   return(SVAL(buf,smb_vwv0 + smb_numwords(buf)*2));
1053 }
1054
1055 /*******************************************************************
1056   return a pointer to the smb_buf data area
1057 ********************************************************************/
1058 int smb_buf_ofs(char *buf)
1059 {
1060   return (smb_size + CVAL(buf,smb_wct)*2);
1061 }
1062
1063 /*******************************************************************
1064   return a pointer to the smb_buf data area
1065 ********************************************************************/
1066 char *smb_buf(char *buf)
1067 {
1068   return (buf + smb_buf_ofs(buf));
1069 }
1070
1071 /*******************************************************************
1072 return the SMB offset into an SMB buffer
1073 ********************************************************************/
1074 int smb_offset(char *p,char *buf)
1075 {
1076   return(PTR_DIFF(p,buf+4));
1077 }
1078
1079
1080 /*******************************************************************
1081 skip past some strings in a buffer
1082 ********************************************************************/
1083 char *skip_string(char *buf,int n)
1084 {
1085   while (n--)
1086     buf += strlen(buf) + 1;
1087   return(buf);
1088 }
1089
1090 /*******************************************************************
1091 trim the specified elements off the front and back of a string
1092 ********************************************************************/
1093 BOOL trim_string(char *s,char *front,char *back)
1094 {
1095   BOOL ret = False;
1096   while (front && *front && strncmp(s,front,strlen(front)) == 0)
1097     {
1098       char *p = s;
1099       ret = True;
1100       while (1)
1101         {
1102           if (!(*p = p[strlen(front)]))
1103             break;
1104           p++;
1105         }
1106     }
1107   while (back && *back && strlen(s) >= strlen(back) &&
1108          (strncmp(s+strlen(s)-strlen(back),back,strlen(back))==0))
1109     {
1110       ret = True;
1111       s[strlen(s)-strlen(back)] = 0;
1112     }
1113   return(ret);
1114 }
1115
1116
1117 /*******************************************************************
1118 reduce a file name, removing .. elements.
1119 ********************************************************************/
1120 void dos_clean_name(char *s)
1121 {
1122   char *p=NULL;
1123
1124   DEBUG(3,("dos_clean_name [%s]\n",s));
1125
1126   /* remove any double slashes */
1127   string_sub(s, "\\\\", "\\");
1128
1129   while ((p = strstr(s,"\\..\\")) != NULL)
1130     {
1131       pstring s1;
1132
1133       *p = 0;
1134       strcpy(s1,p+3);
1135
1136       if ((p=strrchr(s,'\\')) != NULL)
1137         *p = 0;
1138       else
1139         *s = 0;
1140       strcat(s,s1);
1141     }
1142
1143   trim_string(s,NULL,"\\..");
1144
1145   string_sub(s, "\\.\\", "\\");
1146 }
1147
1148 /*******************************************************************
1149 reduce a file name, removing .. elements.
1150 ********************************************************************/
1151 void unix_clean_name(char *s)
1152 {
1153   char *p=NULL;
1154
1155   DEBUG(3,("unix_clean_name [%s]\n",s));
1156
1157   /* remove any double slashes */
1158   string_sub(s, "//","/");
1159
1160   while ((p = strstr(s,"/../")) != NULL)
1161     {
1162       pstring s1;
1163
1164       *p = 0;
1165       strcpy(s1,p+3);
1166
1167       if ((p=strrchr(s,'/')) != NULL)
1168         *p = 0;
1169       else
1170         *s = 0;
1171       strcat(s,s1);
1172     }
1173
1174   trim_string(s,NULL,"/..");
1175 }
1176
1177
1178 /*******************************************************************
1179 a wrapper for the normal chdir() function
1180 ********************************************************************/
1181 int ChDir(char *path)
1182 {
1183   int res;
1184   static pstring LastDir="";
1185
1186   if (strcsequal(path,".")) return(0);
1187
1188   if (*path == '/' && strcsequal(LastDir,path)) return(0);
1189   DEBUG(3,("chdir to %s\n",path));
1190   res = sys_chdir(path);
1191   if (!res)
1192     strcpy(LastDir,path);
1193   return(res);
1194 }
1195
1196
1197 /*******************************************************************
1198   return the absolute current directory path. A dumb version.
1199 ********************************************************************/
1200 static char *Dumb_GetWd(char *s)
1201 {
1202 #ifdef USE_GETCWD
1203     return ((char *)getcwd(s,sizeof(pstring)));
1204 #else
1205     return ((char *)getwd(s));
1206 #endif
1207 }
1208
1209
1210 /* number of list structures for a caching GetWd function. */
1211 #define MAX_GETWDCACHE (50)
1212
1213 struct
1214 {
1215   ino_t inode;
1216   dev_t dev;
1217   char *text;
1218   BOOL valid;
1219 } ino_list[MAX_GETWDCACHE];
1220
1221 BOOL use_getwd_cache=True;
1222
1223 /*******************************************************************
1224   return the absolute current directory path
1225 ********************************************************************/
1226 char *GetWd(char *str)
1227 {
1228   pstring s;
1229   static BOOL getwd_cache_init = False;
1230   struct stat st, st2;
1231   int i;
1232
1233   *s = 0;
1234
1235   if (!use_getwd_cache)
1236     return(Dumb_GetWd(str));
1237
1238   /* init the cache */
1239   if (!getwd_cache_init)
1240     {
1241       getwd_cache_init = True;
1242       for (i=0;i<MAX_GETWDCACHE;i++)
1243         {
1244           string_init(&ino_list[i].text,"");
1245           ino_list[i].valid = False;
1246         }
1247     }
1248
1249   /*  Get the inode of the current directory, if this doesn't work we're
1250       in trouble :-) */
1251
1252   if (stat(".",&st) == -1)
1253     {
1254       DEBUG(0,("Very strange, couldn't stat \".\"\n"));
1255       return(Dumb_GetWd(str));
1256     }
1257
1258
1259   for (i=0; i<MAX_GETWDCACHE; i++)
1260     if (ino_list[i].valid)
1261       {
1262
1263         /*  If we have found an entry with a matching inode and dev number
1264             then find the inode number for the directory in the cached string.
1265             If this agrees with that returned by the stat for the current
1266             directory then all is o.k. (but make sure it is a directory all
1267             the same...) */
1268
1269         if (st.st_ino == ino_list[i].inode &&
1270             st.st_dev == ino_list[i].dev)
1271           {
1272             if (stat(ino_list[i].text,&st2) == 0)
1273               {
1274                 if (st.st_ino == st2.st_ino &&
1275                     st.st_dev == st2.st_dev &&
1276                     (st2.st_mode & S_IFMT) == S_IFDIR)
1277                   {
1278                     strcpy (str, ino_list[i].text);
1279
1280                     /* promote it for future use */
1281                     array_promote((char *)&ino_list[0],sizeof(ino_list[0]),i);
1282                     return (str);
1283                   }
1284                 else
1285                   {
1286                     /*  If the inode is different then something's changed,
1287                         scrub the entry and start from scratch. */
1288                     ino_list[i].valid = False;
1289                   }
1290               }
1291           }
1292       }
1293
1294
1295   /*  We don't have the information to hand so rely on traditional methods.
1296       The very slow getcwd, which spawns a process on some systems, or the
1297       not quite so bad getwd. */
1298
1299   if (!Dumb_GetWd(s))
1300     {
1301       DEBUG(0,("Getwd failed, errno %d\n",errno));
1302       return (NULL);
1303     }
1304
1305   strcpy(str,s);
1306
1307   DEBUG(5,("GetWd %s, inode %d, dev %x\n",s,(int)st.st_ino,(int)st.st_dev));
1308
1309   /* add it to the cache */
1310   i = MAX_GETWDCACHE - 1;
1311   string_set(&ino_list[i].text,s);
1312   ino_list[i].dev = st.st_dev;
1313   ino_list[i].inode = st.st_ino;
1314   ino_list[i].valid = True;
1315
1316   /* put it at the top of the list */
1317   array_promote((char *)&ino_list[0],sizeof(ino_list[0]),i);
1318
1319   return (str);
1320 }
1321
1322
1323
1324 /*******************************************************************
1325 reduce a file name, removing .. elements and checking that
1326 it is below dir in the heirachy. This uses GetWd() and so must be run
1327 on the system that has the referenced file system.
1328
1329 widelinks are allowed if widelinks is true
1330 ********************************************************************/
1331 BOOL reduce_name(char *s,char *dir,BOOL widelinks)
1332 {
1333 #ifndef REDUCE_PATHS
1334   return True;
1335 #else
1336   pstring dir2;
1337   pstring wd;
1338   pstring basename;
1339   pstring newname;
1340   char *p=NULL;
1341   BOOL relative = (*s != '/');
1342
1343   *dir2 = *wd = *basename = *newname = 0;
1344
1345   if (widelinks)
1346     {
1347       unix_clean_name(s);
1348       /* can't have a leading .. */
1349       if (strncmp(s,"..",2) == 0 && (s[2]==0 || s[2]=='/'))
1350         {
1351           DEBUG(3,("Illegal file name? (%s)\n",s));
1352           return(False);
1353         }
1354       return(True);
1355     }
1356
1357   DEBUG(3,("reduce_name [%s] [%s]\n",s,dir));
1358
1359   /* remove any double slashes */
1360   string_sub(s,"//","/");
1361
1362   strcpy(basename,s);
1363   p = strrchr(basename,'/');
1364
1365   if (!p)
1366     return(True);
1367
1368   if (!GetWd(wd))
1369     {
1370       DEBUG(0,("couldn't getwd for %s %s\n",s,dir));
1371       return(False);
1372     }
1373
1374   if (ChDir(dir) != 0)
1375     {
1376       DEBUG(0,("couldn't chdir to %s\n",dir));
1377       return(False);
1378     }
1379
1380   if (!GetWd(dir2))
1381     {
1382       DEBUG(0,("couldn't getwd for %s\n",dir));
1383       ChDir(wd);
1384       return(False);
1385     }
1386
1387
1388     if (p && (p != basename))
1389       {
1390         *p = 0;
1391         if (strcmp(p+1,".")==0)
1392           p[1]=0;
1393         if (strcmp(p+1,"..")==0)
1394           *p = '/';
1395       }
1396
1397   if (ChDir(basename) != 0)
1398     {
1399       ChDir(wd);
1400       DEBUG(3,("couldn't chdir for %s %s basename=%s\n",s,dir,basename));
1401       return(False);
1402     }
1403
1404   if (!GetWd(newname))
1405     {
1406       ChDir(wd);
1407       DEBUG(2,("couldn't get wd for %s %s\n",s,dir2));
1408       return(False);
1409     }
1410
1411   if (p && (p != basename))
1412     {
1413       strcat(newname,"/");
1414       strcat(newname,p+1);
1415     }
1416
1417   {
1418     int l = strlen(dir2);
1419     if (dir2[l-1] == '/')
1420       l--;
1421
1422     if (strncmp(newname,dir2,l) != 0)
1423       {
1424         ChDir(wd);
1425         DEBUG(2,("Bad access attempt? s=%s dir=%s newname=%s l=%d\n",s,dir2,newname,l));
1426         return(False);
1427       }
1428
1429     if (relative)
1430       {
1431         if (newname[l] == '/')
1432           strcpy(s,newname + l + 1);
1433         else
1434           strcpy(s,newname+l);
1435       }
1436     else
1437       strcpy(s,newname);
1438   }
1439
1440   ChDir(wd);
1441
1442   if (strlen(s) == 0)
1443     strcpy(s,"./");
1444
1445   DEBUG(3,("reduced to %s\n",s));
1446   return(True);
1447 #endif
1448 }
1449
1450 /****************************************************************************
1451 expand some *s
1452 ****************************************************************************/
1453 static void expand_one(char *Mask,int len)
1454 {
1455   char *p1;
1456   while ((p1 = strchr(Mask,'*')) != NULL)
1457     {
1458       int lfill = (len+1) - strlen(Mask);
1459       int l1= (p1 - Mask);
1460       pstring tmp;
1461       strcpy(tmp,Mask);
1462       memset(tmp+l1,'?',lfill);
1463       strcpy(tmp + l1 + lfill,Mask + l1 + 1);
1464       strcpy(Mask,tmp);
1465     }
1466 }
1467
1468 /****************************************************************************
1469 expand a wildcard expression, replacing *s with ?s
1470 ****************************************************************************/
1471 void expand_mask(char *Mask,BOOL doext)
1472 {
1473   pstring mbeg,mext;
1474   pstring dirpart;
1475   pstring filepart;
1476   BOOL hasdot = False;
1477   char *p1;
1478   BOOL absolute = (*Mask == '\\');
1479
1480   *mbeg = *mext = *dirpart = *filepart = 0;
1481
1482   /* parse the directory and filename */
1483   if (strchr(Mask,'\\'))
1484     dirname_dos(Mask,dirpart);
1485
1486   filename_dos(Mask,filepart);
1487
1488   strcpy(mbeg,filepart);
1489   if ((p1 = strchr(mbeg,'.')) != NULL)
1490     {
1491       hasdot = True;
1492       *p1 = 0;
1493       p1++;
1494       strcpy(mext,p1);
1495     }
1496   else
1497     {
1498       strcpy(mext,"");
1499       if (strlen(mbeg) > 8)
1500         {
1501           strcpy(mext,mbeg + 8);
1502           mbeg[8] = 0;
1503         }
1504     }
1505
1506   if (*mbeg == 0)
1507     strcpy(mbeg,"????????");
1508   if ((*mext == 0) && doext && !hasdot)
1509     strcpy(mext,"???");
1510
1511   if (strequal(mbeg,"*") && *mext==0)
1512     strcpy(mext,"*");
1513
1514   /* expand *'s */
1515   expand_one(mbeg,8);
1516   if (*mext)
1517     expand_one(mext,3);
1518
1519   strcpy(Mask,dirpart);
1520   if (*dirpart || absolute) strcat(Mask,"\\");
1521   strcat(Mask,mbeg);
1522   strcat(Mask,".");
1523   strcat(Mask,mext);
1524
1525   DEBUG(6,("Mask expanded to [%s]\n",Mask));
1526 }
1527
1528
1529 /****************************************************************************
1530 does a string have any uppercase chars in it?
1531 ****************************************************************************/
1532 BOOL strhasupper(char *s)
1533 {
1534   while (*s)
1535     {
1536 #ifdef KANJI
1537         if (is_shift_jis (*s)) {
1538             s += 2;
1539         } else if (is_kana (*s)) {
1540             s++;
1541         } else {
1542             if (isupper(*s)) return(True);
1543             s++;
1544         }
1545 #else
1546       if (isupper(*s)) return(True);
1547       s++;
1548 #endif /* KANJI */
1549     }
1550   return(False);
1551 }
1552
1553 /****************************************************************************
1554 does a string have any lowercase chars in it?
1555 ****************************************************************************/
1556 BOOL strhaslower(char *s)
1557 {
1558   while (*s)
1559     {
1560 #ifdef KANJI
1561         if (is_shift_jis (*s)) {
1562             s += 2;
1563         } else if (is_kana (*s)) {
1564             s++;
1565         } else {
1566             if (islower(*s)) return(True);
1567             s++;
1568         }
1569 #else
1570       if (islower(*s)) return(True);
1571       s++;
1572 #endif /* KANJI */
1573     }
1574   return(False);
1575 }
1576
1577 /****************************************************************************
1578 find the number of chars in a string
1579 ****************************************************************************/
1580 int count_chars(char *s,char c)
1581 {
1582   int count=0;
1583   while (*s)
1584     {
1585       if (*s == c)
1586         count++;
1587       s++;
1588     }
1589   return(count);
1590 }
1591
1592
1593 /****************************************************************************
1594   make a dir struct
1595 ****************************************************************************/
1596 void make_dir_struct(char *buf,char *mask,char *fname,unsigned int size,int mode,time_t date)
1597 {
1598   char *p;
1599   pstring mask2;
1600
1601   strcpy(mask2,mask);
1602
1603   if ((mode & aDIR) != 0)
1604     size = 0;
1605
1606   memset(buf+1,' ',11);
1607   if ((p = strchr(mask2,'.')) != NULL)
1608     {
1609       *p = 0;
1610       memcpy(buf+1,mask2,MIN(strlen(mask2),8));
1611       memcpy(buf+9,p+1,MIN(strlen(p+1),3));
1612       *p = '.';
1613     }
1614   else
1615     memcpy(buf+1,mask2,MIN(strlen(mask2),11));
1616
1617   bzero(buf+21,DIR_STRUCT_SIZE-21);
1618   CVAL(buf,21) = mode;
1619   put_dos_date(buf,22,date);
1620   SSVAL(buf,26,size & 0xFFFF);
1621   SSVAL(buf,28,size >> 16);
1622   StrnCpy(buf+30,fname,12);
1623   if (!case_sensitive)
1624     strupper(buf+30);
1625   DEBUG(8,("put name [%s] into dir struct\n",buf+30));
1626 }
1627
1628
1629 /*******************************************************************
1630 close the low 3 fd's and open dev/null in their place
1631 ********************************************************************/
1632 void close_low_fds(void)
1633 {
1634   int fd;
1635   int i;
1636   close(0); close(1); close(2);
1637   /* try and use up these file descriptors, so silly
1638      library routines writing to stdout etc won't cause havoc */
1639   for (i=0;i<3;i++) {
1640     fd = open("/dev/null",O_RDWR,0);
1641     if (fd < 0) fd = open("/dev/null",O_WRONLY,0);
1642     if (fd < 0) {
1643       DEBUG(0,("Can't open /dev/null\n"));
1644       return;
1645     }
1646     if (fd != i) {
1647       DEBUG(0,("Didn't get file descriptor %d\n",i));
1648       return;
1649     }
1650   }
1651 }
1652
1653
1654 /****************************************************************************
1655 write to a socket
1656 ****************************************************************************/
1657 int write_socket(int fd,char *buf,int len)
1658 {
1659   int ret=0;
1660
1661   if (passive)
1662     return(len);
1663   DEBUG(6,("write_socket(%d,%d)\n",fd,len));
1664   ret = write_data(fd,buf,len);
1665
1666   DEBUG(6,("write_socket(%d,%d) wrote %d\n",fd,len,ret));
1667   return(ret);
1668 }
1669
1670 /****************************************************************************
1671 read from a socket
1672 ****************************************************************************/
1673 int read_udp_socket(int fd,char *buf,int len)
1674 {
1675   int ret;
1676   struct sockaddr sock;
1677   int socklen;
1678
1679   socklen = sizeof(sock);
1680   bzero((char *)&sock,socklen);
1681   bzero((char *)&lastip,sizeof(lastip));
1682   ret = recvfrom(fd,buf,len,0,&sock,&socklen);
1683   if (ret <= 0) {
1684     DEBUG(2,("read socket failed. ERRNO=%d\n",errno));
1685     return(0);
1686   }
1687
1688   lastip = *(struct in_addr *) &sock.sa_data[2];
1689   lastport = ntohs(((struct sockaddr_in *)&sock)->sin_port);
1690
1691   return(ret);
1692 }
1693
1694 /****************************************************************************
1695 Set a fd into blocking/nonblocking mode. Uses POSIX O_NONBLOCK if available,
1696 else
1697 if SYSV use O_NDELAY
1698 if BSD use FNDELAY
1699 ****************************************************************************/
1700 int set_blocking(int fd, BOOL set)
1701 {
1702 int val;
1703 #ifdef O_NONBLOCK
1704 #define FLAG_TO_SET O_NONBLOCK
1705 #else
1706 #ifdef SYSV
1707 #define FLAG_TO_SET O_NDELAY
1708 #else /* BSD */
1709 #define FLAG_TO_SET FNDELAY
1710 #endif
1711 #endif
1712
1713   if((val = fcntl(fd, F_GETFL, 0))==-1)
1714         return -1;
1715   if(set) /* Turn blocking on - ie. clear nonblock flag */
1716         val &= ~FLAG_TO_SET;
1717   else
1718     val |= FLAG_TO_SET;
1719   return fcntl( fd, F_SETFL, val);
1720 #undef FLAG_TO_SET
1721 }
1722
1723
1724 /****************************************************************************
1725 Calculate the difference in timeout values. Return 1 if val1 > val2,
1726 0 if val1 == val2, -1 if val1 < val2. Stores result in retval. retval
1727 may be == val1 or val2
1728 ****************************************************************************/
1729 static int tval_sub( struct timeval *retval, struct timeval *val1, struct timeval *val2)
1730 {
1731   int usecdiff = val1->tv_usec - val2->tv_usec;
1732   int secdiff = val1->tv_sec - val2->tv_sec;
1733   if(usecdiff < 0) {
1734     usecdiff = 1000000 + usecdiff;
1735     secdiff--;
1736   }
1737   retval->tv_sec = secdiff;
1738   retval->tv_usec = usecdiff;
1739   if(secdiff < 0)
1740     return -1;
1741   if(secdiff > 0)
1742     return 1;
1743   return (usecdiff < 0 ) ? -1 : ((usecdiff > 0 ) ? 1 : 0);
1744 }
1745
1746 /****************************************************************************
1747 read data from a device with a timout in msec.
1748 mincount = if timeout, minimum to read before returning
1749 maxcount = number to be read.
1750 ****************************************************************************/
1751 int read_with_timeout(int fd,char *buf,int mincnt,int maxcnt,long time_out,BOOL exact)
1752 {
1753   fd_set fds;
1754   int selrtn;
1755   int readret;
1756   int nread = 0;
1757   struct timeval timeout, tval1, tval2, tvaldiff;
1758   int error_limit = 5;
1759
1760   /* just checking .... */
1761   if (maxcnt <= 0) return(0);
1762
1763   if(time_out == -2)
1764     time_out = DEFAULT_PIPE_TIMEOUT;
1765
1766   /* Blocking read */
1767   if(time_out < 0) {
1768     if (mincnt == 0) mincnt = maxcnt;
1769
1770     while (nread < mincnt)
1771       {
1772         readret = read(fd, buf + nread, maxcnt - nread);
1773         if (readret <= 0) return(nread);
1774         nread += readret;
1775       }
1776     return(nread);
1777   }
1778
1779   /* Non blocking read */
1780   if(time_out == 0) {
1781     set_blocking(fd, False);
1782     nread = read_data(fd, buf, mincnt);
1783     if (nread < maxcnt)
1784       nread += read(fd,buf+nread,maxcnt-nread);
1785     if(nread == -1 && errno == EWOULDBLOCK)
1786       nread = 0;
1787     set_blocking(fd,True);
1788     return nread;
1789   }
1790
1791   /* Most difficult - timeout read */
1792   /* If this is ever called on a disk file and
1793          mincnt is greater then the filesize then
1794          system performance will suffer severely as
1795          select always return true on disk files */
1796
1797   /* Set initial timeout */
1798   timeout.tv_sec = time_out / 1000;
1799   timeout.tv_usec = 1000 * (time_out % 1000);
1800
1801   /* As most UNIXes don't modify the value of timeout
1802      when they return from select we need to get the timeofday (in usec)
1803      now, and also after the select returns so we know
1804      how much time has elapsed */
1805
1806   if (exact)
1807     GetTimeOfDay( &tval1);
1808   nread = 0; /* Number of bytes we have read */
1809
1810   for(;;)
1811     {
1812       FD_ZERO(&fds);
1813       FD_SET(fd,&fds);
1814
1815       selrtn = sys_select(&fds,&timeout);
1816
1817       /* Check if error */
1818       if(selrtn == -1) {
1819         return -1;
1820       }
1821
1822       /* Did we timeout ? */
1823       if (selrtn == 0) {
1824         if (nread < mincnt) return -1;
1825         break; /* Yes */
1826       }
1827
1828       readret = read(fd, buf+nread, maxcnt-nread);
1829       if (readret == 0 && nread < mincnt) {
1830         /* error_limit should not really be needed, but some systems
1831            do strange things ...  I don't want to just continue
1832            indefinately in case we get an infinite loop */
1833         if (error_limit--) continue;
1834         return(-1);
1835       }
1836
1837       if (readret < 0) {
1838         /* force a particular error number for
1839            portability */
1840         DEBUG(5,("read gave error %s\n",strerror(errno)));
1841         return -1;
1842       }
1843
1844       nread += readret;
1845
1846       /* If we have read more than mincnt then return */
1847       if (nread >= mincnt)
1848         break;
1849
1850       /* We need to do another select - but first reduce the
1851          time_out by the amount of time already elapsed - if
1852          this is less than zero then return */
1853       if (exact) {
1854         GetTimeOfDay(&tval2);
1855         (void)tval_sub( &tvaldiff, &tval2, &tval1);
1856
1857         if (tval_sub(&timeout, &timeout, &tvaldiff) <= 0)
1858           break; /* We timed out */
1859       }
1860
1861       /* Save the time of day as we need to do the select
1862          again (saves a system call) */
1863       tval1 = tval2;
1864     }
1865
1866   /* Return the number we got */
1867   return(nread);
1868 }
1869
1870 /****************************************************************************
1871 read data from the client. Maxtime is in milliseconds
1872 ****************************************************************************/
1873 int read_max_udp(int fd,char *buffer,int bufsize,int maxtime)
1874 {
1875   fd_set fds;
1876   int selrtn;
1877   int nread;
1878   struct timeval timeout;
1879
1880   FD_ZERO(&fds);
1881   FD_SET(fd,&fds);
1882
1883   timeout.tv_sec = maxtime / 1000;
1884   timeout.tv_usec = (maxtime % 1000) * 1000;
1885
1886   selrtn = sys_select(&fds,maxtime>0?&timeout:NULL);
1887
1888   if (!FD_ISSET(fd,&fds))
1889     return 0;
1890
1891   nread = read_udp_socket(fd, buffer, bufsize);
1892
1893   /* return the number got */
1894   return(nread);
1895 }
1896
1897 /*******************************************************************
1898 find the difference in milliseconds between two struct timeval
1899 values
1900 ********************************************************************/
1901 int TvalDiff(struct timeval *tvalold,struct timeval *tvalnew)
1902 {
1903   return((tvalnew->tv_sec - tvalold->tv_sec)*1000 +
1904          ((int)tvalnew->tv_usec - (int)tvalold->tv_usec)/1000);
1905 }
1906
1907 /****************************************************************************
1908 send a keepalive packet (rfc1002)
1909 ****************************************************************************/
1910 BOOL send_keepalive(int client)
1911 {
1912   unsigned char buf[4];
1913
1914   buf[0] = 0x85;
1915   buf[1] = buf[2] = buf[3] = 0;
1916
1917   return(write_data(client,(char *)buf,4) == 4);
1918 }
1919
1920
1921
1922 /****************************************************************************
1923   read data from the client, reading exactly N bytes.
1924 ****************************************************************************/
1925 int read_data(int fd,char *buffer,int N)
1926 {
1927   int  ret;
1928   int total=0;
1929
1930   while (total < N)
1931     {
1932       ret = read(fd,buffer + total,N - total);
1933
1934       if (ret <= 0)
1935         return total;
1936       total += ret;
1937     }
1938   return total;
1939 }
1940
1941
1942 /****************************************************************************
1943   write data to a fd
1944 ****************************************************************************/
1945 int write_data(int fd,char *buffer,int N)
1946 {
1947   int total=0;
1948   int ret;
1949
1950   while (total < N)
1951     {
1952       ret = write(fd,buffer + total,N - total);
1953
1954       if (ret <= 0)
1955         return total;
1956
1957       total += ret;
1958     }
1959   return total;
1960 }
1961
1962
1963 /****************************************************************************
1964 transfer some data between two fd's
1965 ****************************************************************************/
1966 int transfer_file(int infd,int outfd,int n,char *header,int headlen,int align)
1967 {
1968   static char *buf=NULL;
1969   static int size=0;
1970   char *buf1,*abuf;
1971   int total = 0;
1972
1973   DEBUG(4,("transfer_file %d  (head=%d) called\n",n,headlen));
1974
1975   if (size == 0) {
1976     size = lp_readsize();
1977     size = MAX(size,1024);
1978   }
1979
1980   while (!buf && size>0) {
1981     buf = (char *)Realloc(buf,size+8);
1982     if (!buf) size /= 2;
1983   }
1984
1985   if (!buf) {
1986     DEBUG(0,("Can't allocate transfer buffer!\n"));
1987     exit(1);
1988   }
1989
1990   abuf = buf + (align%8);
1991
1992   if (header)
1993     n += headlen;
1994
1995   while (n > 0)
1996     {
1997       int s = MIN(n,size);
1998       int ret,ret2=0;
1999
2000       ret = 0;
2001
2002       if (header && (headlen >= MIN(s,1024))) {
2003         buf1 = header;
2004         s = headlen;
2005         ret = headlen;
2006         headlen = 0;
2007         header = NULL;
2008       } else {
2009         buf1 = abuf;
2010       }
2011
2012       if (header && headlen > 0)
2013         {
2014           ret = MIN(headlen,size);
2015           memcpy(buf1,header,ret);
2016           headlen -= ret;
2017           header += ret;
2018           if (headlen <= 0) header = NULL;
2019         }
2020
2021       if (s > ret)
2022         ret += read(infd,buf1+ret,s-ret);
2023
2024       if (ret > 0)
2025         {
2026           ret2 = (outfd>=0?write_data(outfd,buf1,ret):ret);
2027           if (ret2 > 0) total += ret2;
2028           /* if we can't write then dump excess data */
2029           if (ret2 != ret)
2030             transfer_file(infd,-1,n-(ret+headlen),NULL,0,0);
2031         }
2032       if (ret <= 0 || ret2 != ret)
2033         return(total);
2034       n -= ret;
2035     }
2036   return(total);
2037 }
2038
2039
2040 /****************************************************************************
2041 read 4 bytes of a smb packet and return the smb length of the packet
2042 possibly store the result in the buffer
2043 ****************************************************************************/
2044 int read_smb_length(int fd,char *inbuf,int timeout)
2045 {
2046   char *buffer;
2047   char buf[4];
2048   int len=0, msg_type;
2049   BOOL ok=False;
2050
2051   if (inbuf)
2052     buffer = inbuf;
2053   else
2054     buffer = buf;
2055
2056   while (!ok)
2057     {
2058       if (timeout > 0)
2059         ok = (read_with_timeout(fd,buffer,4,4,timeout,False) == 4);
2060       else
2061         ok = (read_data(fd,buffer,4) == 4);
2062
2063       if (!ok)
2064         {
2065           if (timeout>0)
2066             {
2067               DEBUG(10,("select timeout (%d)\n", timeout));
2068               return(-1);
2069             }
2070           else
2071             {
2072               DEBUG(6,("couldn't read from client\n"));
2073               exit(1);
2074             }
2075         }
2076
2077       len = smb_len(buffer);
2078       msg_type = CVAL(buffer,0);
2079
2080       if (msg_type == 0x85)
2081         {
2082           DEBUG(5,("Got keepalive packet\n"));
2083           ok = False;
2084         }
2085     }
2086
2087   DEBUG(10,("got smb length of %d\n",len));
2088
2089   return(len);
2090 }
2091
2092
2093
2094 /****************************************************************************
2095   read an smb from a fd and return it's length
2096 The timeout is in milli seconds
2097 ****************************************************************************/
2098 BOOL receive_smb(int fd,char *buffer,int timeout)
2099 {
2100   int len,ret;
2101
2102   bzero(buffer,smb_size + 100);
2103
2104   len = read_smb_length(fd,buffer,timeout);
2105   if (len == -1)
2106     return(False);
2107
2108   if (len > BUFFER_SIZE) {
2109     DEBUG(0,("Invalid packet length! (%d bytes).\n",len));
2110     if (len > BUFFER_SIZE + (SAFETY_MARGIN/2))
2111       exit(1);
2112   }
2113
2114   ret = read_data(fd,buffer+4,len);
2115   if (ret != len) {
2116     DEBUG(0,("ERROR: Invalid SMB length. Expected %d got %d\n",len,ret));
2117     return False;
2118   }
2119
2120   return(True);
2121 }
2122
2123
2124 /****************************************************************************
2125   send an smb to a fd
2126 ****************************************************************************/
2127 BOOL send_smb(int fd,char *buffer)
2128 {
2129   int len;
2130   int ret,nwritten=0;
2131   len = smb_len(buffer) + 4;
2132
2133   while (nwritten < len)
2134     {
2135       ret = write_socket(fd,buffer+nwritten,len - nwritten);
2136       if (ret <= 0)
2137         {
2138           DEBUG(0,("Error writing %d bytes to client. %d. Exiting\n",len,ret));
2139           close_sockets();
2140           exit(1);
2141         }
2142       nwritten += ret;
2143     }
2144
2145
2146   return True;
2147 }
2148
2149
2150 /****************************************************************************
2151 find a pointer to a netbios name
2152 ****************************************************************************/
2153 char *name_ptr(char *buf,int ofs)
2154 {
2155   unsigned char c = *(unsigned char *)(buf+ofs);
2156
2157   if ((c & 0xC0) == 0xC0)
2158     {
2159       uint16 l;
2160       char p[2];
2161       memcpy(p,buf+ofs,2);
2162       p[0] &= ~0xC0;
2163       l = RSVAL(p,0);
2164       DEBUG(5,("name ptr to pos %d from %d is %s\n",l,ofs,buf+l));
2165       return(buf + l);
2166     }
2167   else
2168     return(buf+ofs);
2169 }
2170
2171 /****************************************************************************
2172 extract a netbios name from a buf
2173 ****************************************************************************/
2174 int name_extract(char *buf,int ofs,char *name)
2175 {
2176   char *p = name_ptr(buf,ofs);
2177   int d = PTR_DIFF(p,buf+ofs);
2178   strcpy(name,"");
2179   if (d < -50 || d > 50) return(0);
2180   return(name_interpret(p,name));
2181 }
2182
2183
2184 /****************************************************************************
2185 return the total storage length of a mangled name
2186 ****************************************************************************/
2187 int name_len(char *s)
2188 {
2189   char *s0=s;
2190   unsigned char c = *(unsigned char *)s;
2191   if ((c & 0xC0) == 0xC0)
2192     return(2);
2193   while (*s) s += (*s)+1;
2194   return(PTR_DIFF(s,s0)+1);
2195 }
2196
2197 /****************************************************************************
2198 send a single packet to a port on another machine
2199 ****************************************************************************/
2200 BOOL send_one_packet(char *buf,int len,struct in_addr ip,int port,int type)
2201 {
2202   BOOL ret;
2203   int out_fd;
2204   struct sockaddr_in sock_out;
2205
2206   if (passive)
2207     return(True);
2208
2209   /* create a socket to write to */
2210   out_fd = socket(AF_INET, type, 0);
2211   if (out_fd == -1)
2212     {
2213       DEBUG(0,("socket failed"));
2214       return False;
2215     }
2216
2217   /* set the address and port */
2218   bzero((char *)&sock_out,sizeof(sock_out));
2219   putip((char *)&sock_out.sin_addr,(char *)&ip);
2220   sock_out.sin_port = htons( port );
2221   sock_out.sin_family = AF_INET;
2222
2223   if (DEBUGLEVEL > 0)
2224     DEBUG(3,("sending a packet of len %d to (%s) on port %d of type %s\n",
2225              len,inet_ntoa(ip),port,type==SOCK_DGRAM?"DGRAM":"STREAM"));
2226
2227   /* send it */
2228   ret = (sendto(out_fd,buf,len,0,(struct sockaddr *)&sock_out,sizeof(sock_out)) >= 0);
2229
2230   if (!ret)
2231     DEBUG(0,("Packet send to %s(%d) failed ERRNO=%d\n",
2232              inet_ntoa(ip),port,errno));
2233
2234   close(out_fd);
2235   return(ret);
2236 }
2237
2238 /*******************************************************************
2239 sleep for a specified number of milliseconds
2240 ********************************************************************/
2241 void msleep(int t)
2242 {
2243   int tdiff=0;
2244   struct timeval tval,t1,t2;
2245   fd_set fds;
2246
2247   GetTimeOfDay(&t1);
2248   GetTimeOfDay(&t2);
2249
2250   while (tdiff < t) {
2251     tval.tv_sec = (t-tdiff)/1000;
2252     tval.tv_usec = 1000*((t-tdiff)%1000);
2253
2254     FD_ZERO(&fds);
2255     errno = 0;
2256     sys_select(&fds,&tval);
2257
2258     GetTimeOfDay(&t2);
2259     tdiff = TvalDiff(&t1,&t2);
2260   }
2261 }
2262
2263 /****************************************************************************
2264 check if a string is part of a list
2265 ****************************************************************************/
2266 BOOL in_list(char *s,char *list,BOOL casesensitive)
2267 {
2268   pstring tok;
2269   char *p=list;
2270
2271   if (!list) return(False);
2272
2273   while (next_token(&p,tok,LIST_SEP))
2274     {
2275       if (casesensitive) {
2276         if (strcmp(tok,s) == 0)
2277           return(True);
2278       } else {
2279         if (StrCaseCmp(tok,s) == 0)
2280           return(True);
2281       }
2282     }
2283   return(False);
2284 }
2285
2286 /* this is used to prevent lots of mallocs of size 1 */
2287 static char *null_string = NULL;
2288
2289 /****************************************************************************
2290 set a string value, allocing the space for the string
2291 ****************************************************************************/
2292 BOOL string_init(char **dest,char *src)
2293 {
2294   int l;
2295   if (!src)
2296     src = "";
2297
2298   l = strlen(src);
2299
2300   if (l == 0)
2301     {
2302       if (!null_string)
2303         null_string = (char *)malloc(1);
2304
2305       *null_string = 0;
2306       *dest = null_string;
2307     }
2308   else
2309     {
2310       *dest = (char *)malloc(l+1);
2311       strcpy(*dest,src);
2312     }
2313   return(True);
2314 }
2315
2316 /****************************************************************************
2317 free a string value
2318 ****************************************************************************/
2319 void string_free(char **s)
2320 {
2321   if (!s || !(*s)) return;
2322   if (*s == null_string)
2323     *s = NULL;
2324   if (*s) free(*s);
2325   *s = NULL;
2326 }
2327
2328 /****************************************************************************
2329 set a string value, allocing the space for the string, and deallocating any
2330 existing space
2331 ****************************************************************************/
2332 BOOL string_set(char **dest,char *src)
2333 {
2334   string_free(dest);
2335
2336   return(string_init(dest,src));
2337 }
2338
2339 /****************************************************************************
2340 substitute a string for a pattern in another string. Make sure there is
2341 enough room!
2342
2343 This routine looks for pattern in s and replaces it with
2344 insert. It may do multiple replacements.
2345
2346 return True if a substitution was done.
2347 ****************************************************************************/
2348 BOOL string_sub(char *s,char *pattern,char *insert)
2349 {
2350   BOOL ret = False;
2351   char *p;
2352   int ls,lp,li;
2353
2354   if (!insert || !pattern || !s) return(False);
2355
2356   ls = strlen(s);
2357   lp = strlen(pattern);
2358   li = strlen(insert);
2359
2360   if (!*pattern) return(False);
2361
2362   while (lp <= ls && (p = strstr(s,pattern)))
2363     {
2364       ret = True;
2365       memmove(p+li,p+lp,ls + 1 - (PTR_DIFF(p,s) + lp));
2366       memcpy(p,insert,li);
2367       s = p + li;
2368       ls = strlen(s);
2369     }
2370   return(ret);
2371 }
2372
2373
2374
2375 /*********************************************************
2376 * Recursive routine that is called by mask_match.
2377 * Does the actual matching.
2378 *********************************************************/
2379 BOOL do_match(char *str, char *regexp, int case_sig)
2380 {
2381   char *p;
2382
2383   for( p = regexp; *p && *str; ) {
2384     switch(*p) {
2385     case '?':
2386       str++; p++;
2387       break;
2388
2389     case '*':
2390       /* Look for a character matching
2391          the one after the '*' */
2392       p++;
2393       if(!*p)
2394         return True; /* Automatic match */
2395       while(*str) {
2396         while(*str && (case_sig ? (*p != *str) : (toupper(*p)!=toupper(*str))))
2397           str++;
2398         if(do_match(str,p,case_sig))
2399           return True;
2400         if(!*str)
2401           return False;
2402         else
2403           str++;
2404       }
2405       return False;
2406
2407     default:
2408       if(case_sig) {
2409         if(*str != *p)
2410           return False;
2411       } else {
2412         if(toupper(*str) != toupper(*p))
2413           return False;
2414       }
2415       str++, p++;
2416       break;
2417     }
2418   }
2419   if(!*p && !*str)
2420     return True;
2421
2422   if (!*p && str[0] == '.' && str[1] == 0)
2423     return(True);
2424
2425   if (!*str && *p == '?')
2426     {
2427       while (*p == '?') p++;
2428       return(!*p);
2429     }
2430
2431   if(!*str && (*p == '*' && p[1] == '\0'))
2432     return True;
2433   return False;
2434 }
2435
2436
2437 /*********************************************************
2438 * Routine to match a given string with a regexp - uses
2439 * simplified regexp that takes * and ? only. Case can be
2440 * significant or not.
2441 *********************************************************/
2442 BOOL mask_match(char *str, char *regexp, int case_sig,BOOL trans2)
2443 {
2444   char *p;
2445   pstring p1, p2;
2446   fstring ebase,eext,sbase,sext;
2447
2448   BOOL matched;
2449
2450   /* Make local copies of str and regexp */
2451   StrnCpy(p1,regexp,sizeof(pstring)-1);
2452   StrnCpy(p2,str,sizeof(pstring)-1);
2453
2454   if (!strchr(p2,'.')) {
2455     strcat(p2,".");
2456   }
2457
2458 /*
2459   if (!strchr(p1,'.')) {
2460     strcat(p1,".");
2461   }
2462 */
2463
2464 #if 0
2465   if (strchr(p1,'.'))
2466     {
2467       string_sub(p1,"*.*","*");
2468       string_sub(p1,".*","*");
2469     }
2470 #endif
2471
2472   /* Remove any *? and ** as they are meaningless */
2473   for(p = p1; *p; p++)
2474     while( *p == '*' && (p[1] == '?' ||p[1] == '*'))
2475       (void)strcpy( &p[1], &p[2]);
2476
2477   if (strequal(p1,"*")) return(True);
2478
2479   DEBUG(5,("mask_match str=<%s> regexp=<%s>, case_sig = %d\n", p2, p1, case_sig));
2480
2481   if (trans2) {
2482     strcpy(ebase,p1);
2483     strcpy(sbase,p2);
2484   } else {
2485     if ((p=strrchr(p1,'.'))) {
2486       *p = 0;
2487       strcpy(ebase,p1);
2488       strcpy(eext,p+1);
2489     } else {
2490       strcpy(ebase,p1);
2491       eext[0] = 0;
2492     }
2493
2494   if (!strequal(p2,".") && !strequal(p2,"..") && (p=strrchr(p2,'.'))) {
2495     *p = 0;
2496     strcpy(sbase,p2);
2497     strcpy(sext,p+1);
2498   } else {
2499     strcpy(sbase,p2);
2500     strcpy(sext,"");
2501   }
2502   }
2503
2504   matched = do_match(sbase,ebase,case_sig) &&
2505     (trans2 || do_match(sext,eext,case_sig));
2506
2507   DEBUG(5,("mask_match returning %d\n", matched));
2508
2509   return matched;
2510 }
2511
2512
2513
2514 /****************************************************************************
2515 become a daemon, discarding the controlling terminal
2516 ****************************************************************************/
2517 void become_daemon(void)
2518 {
2519 #ifndef NO_FORK_DEBUG
2520   if (fork())
2521     exit(0);
2522
2523   /* detach from the terminal */
2524 #ifdef USE_SETSID
2525   setsid();
2526 #else
2527 #ifdef TIOCNOTTY
2528   {
2529     int i = open("/dev/tty", O_RDWR);
2530     if (i >= 0)
2531       {
2532         ioctl(i, (int) TIOCNOTTY, (char *)0);
2533         close(i);
2534       }
2535   }
2536 #endif
2537 #endif
2538 #endif
2539 }
2540
2541
2542 /****************************************************************************
2543 put up a yes/no prompt
2544 ****************************************************************************/
2545 BOOL yesno(char *p)
2546 {
2547   pstring ans;
2548   printf("%s",p);
2549
2550   if (!fgets(ans,sizeof(ans)-1,stdin))
2551     return(False);
2552
2553   if (*ans == 'y' || *ans == 'Y')
2554     return(True);
2555
2556   return(False);
2557 }
2558
2559 /****************************************************************************
2560 read a line from a file with possible \ continuation chars.
2561 Blanks at the start or end of a line are stripped.
2562 The string will be allocated if s2 is NULL
2563 ****************************************************************************/
2564 char *fgets_slash(char *s2,int maxlen,FILE *f)
2565 {
2566   char *s=s2;
2567   int len = 0;
2568   int c;
2569   BOOL start_of_line = True;
2570
2571   if (feof(f))
2572     return(NULL);
2573
2574   if (!s2)
2575     {
2576       maxlen = MIN(maxlen,8);
2577       s = (char *)Realloc(s,maxlen);
2578     }
2579
2580   if (!s || maxlen < 2) return(NULL);
2581
2582   *s = 0;
2583
2584   while (len < maxlen-1)
2585     {
2586       c = getc(f);
2587       switch (c)
2588         {
2589         case '\r':
2590           break;
2591         case '\n':
2592           while (len > 0 && s[len-1] == ' ')
2593             {
2594               s[--len] = 0;
2595             }
2596           if (len > 0 && s[len-1] == '\\')
2597             {
2598               s[--len] = 0;
2599               start_of_line = True;
2600               break;
2601             }
2602           return(s);
2603         case EOF:
2604           if (len <= 0 && !s2)
2605             free(s);
2606           return(len>0?s:NULL);
2607         case ' ':
2608           if (start_of_line)
2609             break;
2610         default:
2611           start_of_line = False;
2612           s[len++] = c;
2613           s[len] = 0;
2614         }
2615       if (!s2 && len > maxlen-3)
2616         {
2617           maxlen *= 2;
2618           s = (char *)Realloc(s,maxlen);
2619           if (!s) return(NULL);
2620         }
2621     }
2622   return(s);
2623 }
2624
2625
2626
2627 /****************************************************************************
2628 set the length of a file from a filedescriptor.
2629 Returns 0 on success, -1 on failure.
2630 ****************************************************************************/
2631 int set_filelen(int fd, long len)
2632 {
2633 /* According to W. R. Stevens advanced UNIX prog. Pure 4.3 BSD cannot
2634    extend a file with ftruncate. Provide alternate implementation
2635    for this */
2636
2637 #if FTRUNCATE_CAN_EXTEND
2638   return ftruncate(fd, len);
2639 #else
2640   struct stat st;
2641   char c = 0;
2642   long currpos = lseek(fd, 0L, SEEK_CUR);
2643
2644   if(currpos < 0)
2645     return -1;
2646   /* Do an fstat to see if the file is longer than
2647      the requested size (call ftruncate),
2648      or shorter, in which case seek to len - 1 and write 1
2649      byte of zero */
2650   if(fstat(fd, &st)<0)
2651     return -1;
2652
2653 #ifdef S_ISFIFO
2654   if (S_ISFIFO(st.st_mode)) return 0;
2655 #endif
2656
2657   if(st.st_size == len)
2658     return 0;
2659   if(st.st_size > len)
2660     return ftruncate(fd, len);
2661
2662   if(lseek(fd, len-1, SEEK_SET) != len -1)
2663     return -1;
2664   if(write(fd, &c, 1)!=1)
2665     return -1;
2666   /* Seek to where we were */
2667   lseek(fd, currpos, SEEK_SET);
2668   return 0;
2669 #endif
2670 }
2671
2672
2673 /****************************************************************************
2674 return the byte checksum of some data
2675 ****************************************************************************/
2676 int byte_checksum(char *buf,int len)
2677 {
2678   unsigned char *p = (unsigned char *)buf;
2679   int ret = 0;
2680   while (len--)
2681     ret += *p++;
2682   return(ret);
2683 }
2684
2685
2686
2687 #ifdef HPUX
2688 /****************************************************************************
2689 this is a version of setbuffer() for those machines that only have setvbuf
2690 ****************************************************************************/
2691  void setbuffer(FILE *f,char *buf,int bufsize)
2692 {
2693   setvbuf(f,buf,_IOFBF,bufsize);
2694 }
2695 #endif
2696
2697
2698 /****************************************************************************
2699 parse out a directory name from a path name. Assumes dos style filenames.
2700 ****************************************************************************/
2701 char *dirname_dos(char *path,char *buf)
2702 {
2703   char *p = strrchr(path,'\\');
2704
2705   if (!p)
2706     strcpy(buf,path);
2707   else
2708     {
2709       *p = 0;
2710       strcpy(buf,path);
2711       *p = '\\';
2712     }
2713
2714   return(buf);
2715 }
2716
2717
2718 /****************************************************************************
2719 parse out a filename from a path name. Assumes dos style filenames.
2720 ****************************************************************************/
2721 static char *filename_dos(char *path,char *buf)
2722 {
2723   char *p = strrchr(path,'\\');
2724
2725   if (!p)
2726     strcpy(buf,path);
2727   else
2728     strcpy(buf,p+1);
2729
2730   return(buf);
2731 }
2732
2733
2734
2735 /****************************************************************************
2736 expand a pointer to be a particular size
2737 ****************************************************************************/
2738 void *Realloc(void *p,int size)
2739 {
2740   void *ret=NULL;
2741
2742   if (size == 0) {
2743     if (p) free(p);
2744     DEBUG(5,("Realloc asked for 0 bytes\n"));
2745     return NULL;
2746   }
2747
2748   if (!p)
2749     ret = (void *)malloc(size);
2750   else
2751     ret = (void *)realloc(p,size);
2752
2753   if (!ret)
2754     DEBUG(0,("Memory allocation error: failed to expand to %d bytes\n",size));
2755
2756   return(ret);
2757 }
2758
2759 #ifdef NOSTRDUP
2760 /****************************************************************************
2761 duplicate a string
2762 ****************************************************************************/
2763  char *strdup(char *s)
2764 {
2765   char *ret = NULL;
2766   if (!s) return(NULL);
2767   ret = (char *)malloc(strlen(s)+1);
2768   if (!ret) return(NULL);
2769   strcpy(ret,s);
2770   return(ret);
2771 }
2772 #endif
2773
2774
2775 /****************************************************************************
2776   Signal handler for SIGPIPE (write on a disconnected socket)
2777 ****************************************************************************/
2778 void Abort(void )
2779 {
2780   DEBUG(0,("Probably got SIGPIPE\nExiting\n"));
2781   exit(2);
2782 }
2783
2784 /****************************************************************************
2785 get my own name and IP
2786 ****************************************************************************/
2787 BOOL get_myname(char *myname,struct in_addr *ip)
2788 {
2789   struct hostent *hp;
2790   pstring hostname;
2791
2792   *hostname = 0;
2793
2794   /* get my host name */
2795   if (gethostname(hostname, MAXHOSTNAMELEN) == -1)
2796     {
2797       DEBUG(0,("gethostname failed\n"));
2798       return False;
2799     }
2800
2801   /* get host info */
2802   if ((hp = Get_Hostbyname(hostname)) == 0)
2803     {
2804       DEBUG(0,( "Get_Hostbyname: Unknown host %s.\n",hostname));
2805       return False;
2806     }
2807
2808   if (myname)
2809     {
2810       /* split off any parts after an initial . */
2811       char *p = strchr(hostname,'.');
2812       if (p) *p = 0;
2813
2814       strcpy(myname,hostname);
2815     }
2816
2817   if (ip)
2818     putip((char *)ip,(char *)hp->h_addr);
2819
2820   return(True);
2821 }
2822
2823
2824 /****************************************************************************
2825 true if two IP addresses are equal
2826 ****************************************************************************/
2827 BOOL ip_equal(struct in_addr ip1,struct in_addr ip2)
2828 {
2829   unsigned long a1,a2;
2830   a1 = ntohl(ip1.s_addr);
2831   a2 = ntohl(ip2.s_addr);
2832   return(a1 == a2);
2833 }
2834
2835
2836 /****************************************************************************
2837 open a socket of the specified type, port and address for incoming data
2838 ****************************************************************************/
2839 int open_socket_in(int type, int port, int dlevel)
2840 {
2841   struct hostent *hp;
2842   struct sockaddr_in sock;
2843   pstring host_name;
2844   int res;
2845
2846   /* get my host name */
2847   if (gethostname(host_name, MAXHOSTNAMELEN) == -1)
2848     { DEBUG(0,("gethostname failed\n")); return -1; }
2849
2850   /* get host info */
2851   if ((hp = Get_Hostbyname(host_name)) == 0)
2852     {
2853       DEBUG(0,( "Get_Hostbyname: Unknown host. %s\n",host_name));
2854       return -1;
2855     }
2856
2857   bzero((char *)&sock,sizeof(sock));
2858   memcpy((char *)&sock.sin_addr,(char *)hp->h_addr, hp->h_length);
2859 #if defined(__FreeBSD__) || defined(NETBSD) /* XXX not the right ifdef */
2860   sock.sin_len = sizeof(sock);
2861 #endif
2862   sock.sin_port = htons( port );
2863   sock.sin_family = hp->h_addrtype;
2864   sock.sin_addr.s_addr = INADDR_ANY;
2865   res = socket(hp->h_addrtype, type, 0);
2866   if (res == -1)
2867     { DEBUG(0,("socket failed\n")); return -1; }
2868
2869   {
2870     int one=1;
2871     setsockopt(res,SOL_SOCKET,SO_REUSEADDR,(char *)&one,sizeof(one));
2872   }
2873
2874   /* now we've got a socket - we need to bind it */
2875   if (bind(res, (struct sockaddr * ) &sock,sizeof(sock)) < 0)
2876     {
2877       if (port) {
2878         if (port == SMB_PORT || port == NMB_PORT)
2879           DEBUG(dlevel,("bind failed on port %d (%s)\n",
2880                         port,strerror(errno)));
2881         close(res);
2882
2883         if (dlevel > 0 && port < 1000)
2884           port = 7999;
2885
2886         if (port >= 1000 && port < 9000)
2887           return(open_socket_in(type,port+1,dlevel));
2888       }
2889
2890       return(-1);
2891     }
2892   DEBUG(3,("bind succeeded on port %d\n",port));
2893
2894   return res;
2895 }
2896
2897
2898 /****************************************************************************
2899   create an outgoing socket
2900   **************************************************************************/
2901 int open_socket_out(int type, struct in_addr *addr, int port )
2902 {
2903   struct sockaddr_in sock_out;
2904   int res;
2905
2906   /* create a socket to write to */
2907   res = socket(PF_INET, type, 0);
2908   if (res == -1)
2909     { DEBUG(0,("socket error\n")); return -1; }
2910
2911   if (type != SOCK_STREAM) return(res);
2912
2913   bzero((char *)&sock_out,sizeof(sock_out));
2914   putip((char *)&sock_out.sin_addr,(char *)addr);
2915
2916   sock_out.sin_port = htons( port );
2917   sock_out.sin_family = PF_INET;
2918
2919   DEBUG(3,("Connecting to %s at port %d\n",inet_ntoa(*addr),port));
2920
2921   /* and connect it to the destination */
2922   if (connect(res,(struct sockaddr *)&sock_out,sizeof(sock_out))<0) {
2923     DEBUG(0,("connect error: %s\n",strerror(errno)));
2924     close(res);
2925     return(-1);
2926   }
2927
2928   return res;
2929 }
2930
2931
2932 /****************************************************************************
2933 interpret a protocol description string, with a default
2934 ****************************************************************************/
2935 int interpret_protocol(char *str,int def)
2936 {
2937   if (strequal(str,"NT1"))
2938     return(PROTOCOL_NT1);
2939   if (strequal(str,"LANMAN2"))
2940     return(PROTOCOL_LANMAN2);
2941   if (strequal(str,"LANMAN1"))
2942     return(PROTOCOL_LANMAN1);
2943   if (strequal(str,"CORE"))
2944     return(PROTOCOL_CORE);
2945   if (strequal(str,"COREPLUS"))
2946     return(PROTOCOL_COREPLUS);
2947   if (strequal(str,"CORE+"))
2948     return(PROTOCOL_COREPLUS);
2949
2950   DEBUG(0,("Unrecognised protocol level %s\n",str));
2951
2952   return(def);
2953 }
2954
2955 /****************************************************************************
2956 interpret a security level
2957 ****************************************************************************/
2958 int interpret_security(char *str,int def)
2959 {
2960   if (strequal(str,"SERVER"))
2961     return(SEC_SERVER);
2962   if (strequal(str,"USER"))
2963     return(SEC_USER);
2964   if (strequal(str,"SHARE"))
2965     return(SEC_SHARE);
2966
2967   DEBUG(0,("Unrecognised security level %s\n",str));
2968
2969   return(def);
2970 }
2971
2972
2973 /****************************************************************************
2974 interpret an internet address or name into an IP address in 4 byte form
2975 ****************************************************************************/
2976 unsigned long interpret_addr(char *str)
2977 {
2978   struct hostent *hp;
2979   unsigned long res;
2980
2981   if (strcmp(str,"0.0.0.0") == 0) return(0);
2982   if (strcmp(str,"255.255.255.255") == 0) return(0xFFFFFFFF);
2983
2984   /* if it's in the form of an IP address then get the lib to interpret it */
2985   if (isdigit(str[0])) {
2986     res = inet_addr(str);
2987   } else {
2988     /* otherwise assume it's a network name of some sort and use Get_Hostbyname */
2989     if ((hp = Get_Hostbyname(str)) == 0) {
2990       DEBUG(3,("Get_Hostbyname: Unknown host. %s\n",str));
2991       return 0;
2992     }
2993     putip((char *)&res,(char *)hp->h_addr);
2994   }
2995
2996   if (res == (unsigned long)-1) return(0);
2997
2998   return(res);
2999 }
3000
3001 /*******************************************************************
3002   a convenient addition to interpret_addr()
3003   ******************************************************************/
3004 struct in_addr *interpret_addr2(char *str)
3005 {
3006   static struct in_addr ret;
3007   unsigned long a = interpret_addr(str);
3008   ret.s_addr = a;
3009   return(&ret);
3010 }
3011
3012 /*******************************************************************
3013   check if an IP is the 0.0.0.0
3014   ******************************************************************/
3015 BOOL zero_ip(struct in_addr ip)
3016 {
3017   unsigned long a;
3018   putip((char *)&a,(char *)&ip);
3019   return(a == 0);
3020 }
3021
3022 /*******************************************************************
3023 sub strings with useful parameters
3024 ********************************************************************/
3025 void standard_sub_basic(char *s)
3026 {
3027   if (!strchr(s,'%')) return;
3028
3029   string_sub(s,"%R",remote_proto);
3030   string_sub(s,"%a",remote_arch);
3031   string_sub(s,"%m",remote_machine);
3032   string_sub(s,"%L",local_machine);
3033
3034   if (!strchr(s,'%')) return;
3035
3036   string_sub(s,"%v",VERSION);
3037   string_sub(s,"%h",myhostname);
3038   string_sub(s,"%U",sesssetup_user);
3039
3040   if (!strchr(s,'%')) return;
3041
3042   string_sub(s,"%I",Client_info.addr);
3043   string_sub(s,"%M",Client_info.name);
3044   string_sub(s,"%T",timestring());
3045
3046   if (!strchr(s,'%')) return;
3047
3048   {
3049     char pidstr[10];
3050     sprintf(pidstr,"%d",(int)getpid());
3051     string_sub(s,"%d",pidstr);
3052   }
3053
3054   if (!strchr(s,'%')) return;
3055
3056   {
3057     struct passwd *pass = Get_Pwnam(sesssetup_user,False);
3058     if (pass) {
3059       string_sub(s,"%G",gidtoname(pass->pw_gid));
3060     }
3061   }
3062 }
3063
3064
3065 /*******************************************************************
3066 are two IPs on the same subnet?
3067 ********************************************************************/
3068 BOOL same_net(struct in_addr ip1,struct in_addr ip2,struct in_addr mask)
3069 {
3070   unsigned long net1,net2,nmask;
3071
3072   nmask = ntohl(mask.s_addr);
3073   net1  = ntohl(ip1.s_addr);
3074   net2  = ntohl(ip2.s_addr);
3075
3076   return((net1 & nmask) == (net2 & nmask));
3077 }
3078
3079
3080 /*******************************************************************
3081 write a string in unicoode format
3082 ********************************************************************/
3083 int PutUniCode(char *dst,char *src)
3084 {
3085   int ret = 0;
3086   while (*src) {
3087     dst[ret++] = src[0];
3088     dst[ret++] = 0;
3089     src++;
3090   }
3091   dst[ret++]=0;
3092   dst[ret++]=0;
3093   return(ret);
3094 }
3095
3096 /****************************************************************************
3097 a wrapper for gethostbyname() that tries with all lower and all upper case
3098 if the initial name fails
3099 ****************************************************************************/
3100 struct hostent *Get_Hostbyname(char *name)
3101 {
3102   char *name2 = strdup(name);
3103   struct hostent *ret;
3104
3105   if (!name2)
3106     {
3107       DEBUG(0,("Memory allocation error in Get_Hostbyname! panic\n"));
3108       exit(0);
3109     }
3110
3111   if (!isalnum(*name2))
3112     {
3113       free(name2);
3114       return(NULL);
3115     }
3116
3117   ret = gethostbyname(name2);
3118   if (ret != NULL)
3119     {
3120       free(name2);
3121       return(ret);
3122     }
3123
3124   /* try with all lowercase */
3125   strlower(name2);
3126   ret = gethostbyname(name2);
3127   if (ret != NULL)
3128     {
3129       free(name2);
3130       return(ret);
3131     }
3132
3133   /* try with all uppercase */
3134   strupper(name2);
3135   ret = gethostbyname(name2);
3136   if (ret != NULL)
3137     {
3138       free(name2);
3139       return(ret);
3140     }
3141
3142   /* nothing works :-( */
3143   free(name2);
3144   return(NULL);
3145 }
3146
3147
3148 /****************************************************************************
3149 check if a process exists. Does this work on all unixes?
3150 ****************************************************************************/
3151 BOOL process_exists(int pid)
3152 {
3153 #ifdef LINUX
3154   fstring s;
3155   sprintf(s,"/proc/%d",pid);
3156   return(directory_exist(s,NULL));
3157 #else
3158   {
3159     static BOOL tested=False;
3160     static BOOL ok=False;
3161     fstring s;
3162     if (!tested) {
3163       tested = True;
3164       sprintf(s,"/proc/%05d",getpid());
3165       ok = file_exist(s,NULL);
3166     }
3167     if (ok) {
3168       sprintf(s,"/proc/%05d",pid);
3169       return(file_exist(s,NULL));
3170     }
3171   }
3172
3173   /* a best guess for non root access */
3174   if (geteuid() != 0) return(True);
3175
3176   /* otherwise use kill */
3177   return(pid == getpid() || kill(pid,0) == 0);
3178 #endif
3179 }
3180
3181
3182 /*******************************************************************
3183 turn a uid into a user name
3184 ********************************************************************/
3185 char *uidtoname(int uid)
3186 {
3187   static char name[40];
3188   struct passwd *pass = getpwuid(uid);
3189   if (pass) return(pass->pw_name);
3190   sprintf(name,"%d",uid);
3191   return(name);
3192 }
3193
3194 /*******************************************************************
3195 turn a gid into a group name
3196 ********************************************************************/
3197 char *gidtoname(int gid)
3198 {
3199   static char name[40];
3200   struct group *grp = getgrgid(gid);
3201   if (grp) return(grp->gr_name);
3202   sprintf(name,"%d",gid);
3203   return(name);
3204 }
3205
3206 /*******************************************************************
3207 block sigs
3208 ********************************************************************/
3209 void BlockSignals(BOOL block)
3210 {
3211 #ifdef USE_SIGBLOCK
3212   int block_mask = (sigmask(SIGTERM)|sigmask(SIGQUIT)|sigmask(SIGSEGV)
3213                     |sigmask(SIGCHLD)|sigmask(SIGQUIT)|sigmask(SIGBUS)|
3214                     sigmask(SIGINT));
3215   if (block)
3216     sigblock(block_mask);
3217   else
3218     sigunblock(block_mask);
3219 #endif
3220 }
3221
3222 #if AJT
3223 /*******************************************************************
3224 my own panic function - not suitable for general use
3225 ********************************************************************/
3226 void ajt_panic(void)
3227 {
3228   system("/usr/bin/X11/xedit -display :0 /tmp/ERROR_FAULT");
3229 }
3230 #endif
3231
3232 #ifdef USE_DIRECT
3233 #define DIRECT direct
3234 #else
3235 #define DIRECT dirent
3236 #endif
3237
3238 /*******************************************************************
3239 a readdir wrapper which just returns the file name
3240 also return the inode number if requested
3241 ********************************************************************/
3242 char *readdirname(void *p)
3243 {
3244   struct DIRECT *ptr;
3245   char *dname;
3246
3247   if (!p) return(NULL);
3248
3249   ptr = (struct DIRECT *)readdir(p);
3250   if (!ptr) return(NULL);
3251
3252   dname = ptr->d_name;
3253
3254 #ifdef KANJI
3255   {
3256     static pstring buf;
3257     strcpy(buf, dname);
3258     unix_to_dos(buf, True);
3259     dname = buf;
3260   }
3261 #endif
3262
3263 #ifdef NEXT2
3264   if (telldir(p) < 0) return(NULL);
3265 #endif
3266
3267 #ifdef SUNOS5
3268   /* this handles a broken compiler setup, causing a mixture
3269    of BSD and SYSV headers and libraries */
3270   {
3271     static BOOL broken_readdir = False;
3272     if (!broken_readdir && !(*(dname)) && strequal("..",dname-2))
3273       {
3274         DEBUG(0,("Your readdir() is broken. You have somehow mixed SYSV and BSD headers and libraries\n"));
3275         broken_readdir = True;
3276       }
3277     if (broken_readdir)
3278       return(dname-2);
3279   }
3280 #endif
3281
3282   return(dname);
3283 }
3284
3285
3286