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