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