2 Unix SMB/Netbios implementation.
4 Samba utility functions
5 Copyright (C) Andrew Tridgell 1992-1997
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.
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.
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.
30 int Protocol = PROTOCOL_COREPLUS;
32 /* a default finfo structure to ensure all fields are sensible */
33 file_info def_finfo = {-1,0,0,0,0,0,0,""};
35 /* these are some file handles where debug info will be stored */
38 /* the client file descriptor */
41 /* the last IP received from */
42 struct in_addr lastip;
44 /* the last port received from */
47 /* this is used by the chaining code */
53 case handling on filenames
55 int case_default = CASE_LOWER;
60 /* the following control case operations - they are put here so the
61 client can link easily */
64 BOOL use_mangled_map = False;
65 BOOL short_case_preserve;
68 fstring remote_machine="";
69 fstring local_machine="";
70 fstring remote_arch="UNKNOWN";
71 fstring remote_proto="UNKNOWN";
72 pstring myhostname="";
73 pstring user_socket_options="";
74 pstring sesssetup_user="";
76 fstring myworkgroup = "";
78 int smb_read_error = 0;
80 static char *filename_dos(char *path,char *buf);
82 static BOOL stdout_logging = False;
85 /*******************************************************************
86 get ready for syslog stuff
87 ******************************************************************/
88 void setup_logging(char *pname,BOOL interactive)
92 char *p = strrchr(pname,'/');
94 openlog(pname, LOG_PID, LOG_DAEMON);
98 stdout_logging = True;
104 BOOL append_log=False;
107 /****************************************************************************
109 ****************************************************************************/
110 void reopen_logs(void)
117 strcpy(fname,debugf);
118 if (lp_loaded() && (*lp_logfile()))
119 strcpy(fname,lp_logfile());
121 if (!strcsequal(fname,debugf) || !dbf || !file_exist(debugf,NULL))
123 int oldumask = umask(022);
124 strcpy(debugf,fname);
125 if (dbf) fclose(dbf);
127 dbf = fopen(debugf,"a");
129 dbf = fopen(debugf,"w");
130 if (dbf) setbuf(dbf,NULL);
145 /*******************************************************************
146 check if the log has grown too big
147 ********************************************************************/
148 static void check_log_size(void)
150 static int debug_count=0;
154 if (debug_count++ < 100) return;
156 maxlog = lp_max_log_size() * 1024;
157 if (!dbf || maxlog <= 0) return;
159 if (fstat(fileno(dbf),&st) == 0 && st.st_size > maxlog) {
160 fclose(dbf); dbf = NULL;
162 if (dbf && file_size(debugf) > maxlog) {
164 fclose(dbf); dbf = NULL;
165 sprintf(name,"%s.old",debugf);
166 sys_rename(debugf,name);
174 /*******************************************************************
175 write an debug message on the debugfile. This is called by the DEBUG
177 ********************************************************************/
179 int Debug1(char *format_str, ...)
189 if (stdout_logging) {
191 va_start(ap, format_str);
194 format_str = va_arg(ap,char *);
196 vfprintf(dbf,format_str,ap);
202 if (!lp_syslog_only())
207 int oldumask = umask(022);
208 dbf = fopen(debugf,"w");
218 if (syslog_level < lp_syslog())
221 * map debug levels to syslog() priorities
222 * note that not all DEBUG(0, ...) calls are
225 static int priority_map[] = {
234 if (syslog_level >= sizeof(priority_map) / sizeof(priority_map[0]) ||
236 priority = LOG_DEBUG;
238 priority = priority_map[syslog_level];
241 va_start(ap, format_str);
244 format_str = va_arg(ap,char *);
246 vsprintf(msgbuf, format_str, ap);
250 syslog(priority, "%s", msgbuf);
255 if (!lp_syslog_only())
259 va_start(ap, format_str);
262 format_str = va_arg(ap,char *);
264 vfprintf(dbf,format_str,ap);
274 /****************************************************************************
275 find a suitable temporary directory. The result should be copied immediately
276 as it may be overwritten by a subsequent call
277 ****************************************************************************/
281 if ((p = getenv("TMPDIR"))) {
289 /****************************************************************************
290 determine if a file descriptor is in fact a socket
291 ****************************************************************************/
292 BOOL is_a_socket(int fd)
296 return(getsockopt(fd, SOL_SOCKET, SO_TYPE, (char *)&v, &l) == 0);
300 static char *last_ptr=NULL;
302 /****************************************************************************
303 Get the next token from a string, return False if none found
304 handles double-quotes.
305 Based on a routine by GJC@VILLAGE.COM.
306 Extensively modified by Andrew.Tridgell@anu.edu.au
307 ****************************************************************************/
308 BOOL next_token(char **ptr,char *buff,char *sep)
313 if (!ptr) ptr = &last_ptr;
314 if (!ptr) return(False);
318 /* default to simple separators */
319 if (!sep) sep = " \t\n\r";
321 /* find the first non sep char */
322 while(*s && strchr(sep,*s)) s++;
325 if (! *s) return(False);
327 /* copy over the token */
328 for (quoted = False; *s && (quoted || !strchr(sep,*s)); s++)
336 *ptr = (*s) ? s+1 : s;
343 /****************************************************************************
344 Convert list of tokens to array; dependent on above routine.
345 Uses last_ptr from above - bit of a hack.
346 ****************************************************************************/
347 char **toktocliplist(int *ctok, char *sep)
353 if (!sep) sep = " \t\n\r";
355 while(*s && strchr(sep,*s)) s++;
358 if (!*s) return(NULL);
362 while(*s && (!strchr(sep,*s))) s++;
363 while(*s && strchr(sep,*s)) *s++=0;
369 if (!(ret=iret=malloc(ictok*sizeof(char *)))) return NULL;
381 /*******************************************************************
382 safely copies memory, ensuring no overlap problems.
383 this is only used if the machine does not have it's own memmove().
384 this is not the fastest algorithm in town, but it will do for our
386 ********************************************************************/
387 void *MemMove(void *dest,void *src,int size)
391 if (dest==src || !size) return(dest);
393 d = (unsigned long)dest;
394 s = (unsigned long)src;
396 if ((d >= (s+size)) || (s >= (d+size))) {
398 memcpy(dest,src,size);
404 /* we can forward copy */
405 if (s-d >= sizeof(int) &&
406 !(s%sizeof(int)) && !(d%sizeof(int)) && !(size%sizeof(int))) {
407 /* do it all as words */
408 int *idest = (int *)dest;
409 int *isrc = (int *)src;
411 for (i=0;i<size;i++) idest[i] = isrc[i];
414 char *cdest = (char *)dest;
415 char *csrc = (char *)src;
416 for (i=0;i<size;i++) cdest[i] = csrc[i];
421 /* must backward copy */
422 if (d-s >= sizeof(int) &&
423 !(s%sizeof(int)) && !(d%sizeof(int)) && !(size%sizeof(int))) {
424 /* do it all as words */
425 int *idest = (int *)dest;
426 int *isrc = (int *)src;
428 for (i=size-1;i>=0;i--) idest[i] = isrc[i];
431 char *cdest = (char *)dest;
432 char *csrc = (char *)src;
433 for (i=size-1;i>=0;i--) cdest[i] = csrc[i];
441 /****************************************************************************
442 prompte a dptr (to make it recently used)
443 ****************************************************************************/
444 void array_promote(char *array,int elsize,int element)
450 p = (char *)malloc(elsize);
454 DEBUG(5,("Ahh! Can't malloc\n"));
457 memcpy(p,array + element * elsize, elsize);
458 memmove(array + elsize,array,elsize*element);
459 memcpy(array,p,elsize);
463 enum SOCK_OPT_TYPES {OPT_BOOL,OPT_INT,OPT_ON};
472 } socket_options[] = {
473 {"SO_KEEPALIVE", SOL_SOCKET, SO_KEEPALIVE, 0, OPT_BOOL},
474 {"SO_REUSEADDR", SOL_SOCKET, SO_REUSEADDR, 0, OPT_BOOL},
475 {"SO_BROADCAST", SOL_SOCKET, SO_BROADCAST, 0, OPT_BOOL},
477 {"TCP_NODELAY", IPPROTO_TCP, TCP_NODELAY, 0, OPT_BOOL},
479 #ifdef IPTOS_LOWDELAY
480 {"IPTOS_LOWDELAY", IPPROTO_IP, IP_TOS, IPTOS_LOWDELAY, OPT_ON},
482 #ifdef IPTOS_THROUGHPUT
483 {"IPTOS_THROUGHPUT", IPPROTO_IP, IP_TOS, IPTOS_THROUGHPUT, OPT_ON},
486 {"SO_SNDBUF", SOL_SOCKET, SO_SNDBUF, 0, OPT_INT},
489 {"SO_RCVBUF", SOL_SOCKET, SO_RCVBUF, 0, OPT_INT},
492 {"SO_SNDLOWAT", SOL_SOCKET, SO_SNDLOWAT, 0, OPT_INT},
495 {"SO_RCVLOWAT", SOL_SOCKET, SO_RCVLOWAT, 0, OPT_INT},
498 {"SO_SNDTIMEO", SOL_SOCKET, SO_SNDTIMEO, 0, OPT_INT},
501 {"SO_RCVTIMEO", SOL_SOCKET, SO_RCVTIMEO, 0, OPT_INT},
507 /****************************************************************************
508 set user socket options
509 ****************************************************************************/
510 void set_socket_options(int fd, char *options)
514 while (next_token(&options,tok," \t,"))
519 BOOL got_value = False;
521 if ((p = strchr(tok,'=')))
528 for (i=0;socket_options[i].name;i++)
529 if (strequal(socket_options[i].name,tok))
532 if (!socket_options[i].name)
534 DEBUG(0,("Unknown socket option %s\n",tok));
538 switch (socket_options[i].opttype)
542 ret = setsockopt(fd,socket_options[i].level,
543 socket_options[i].option,(char *)&value,sizeof(int));
548 DEBUG(0,("syntax error - %s does not take a value\n",tok));
551 int on = socket_options[i].value;
552 ret = setsockopt(fd,socket_options[i].level,
553 socket_options[i].option,(char *)&on,sizeof(int));
559 DEBUG(0,("Failed to set socket option %s\n",tok));
565 /****************************************************************************
566 close the socket communication
567 ****************************************************************************/
568 void close_sockets(void )
574 /****************************************************************************
575 determine whether we are in the specified group
576 ****************************************************************************/
577 BOOL in_group(gid_t group, int current_gid, int ngroups, int *groups)
581 if (group == current_gid) return(True);
583 for (i=0;i<ngroups;i++)
584 if (group == groups[i])
590 /****************************************************************************
591 this is a safer strcpy(), meant to prevent core dumps when nasty things happen
592 ****************************************************************************/
593 char *StrCpy(char *dest,char *src)
598 /* I don't want to get lazy with these ... */
600 DEBUG(0,("ERROR: NULL StrCpy() called!\n"));
605 if (!dest) return(NULL);
610 while ((*d++ = *src++)) ;
614 /****************************************************************************
615 line strncpy but always null terminates. Make sure there is room!
616 ****************************************************************************/
617 char *StrnCpy(char *dest,char *src,int n)
620 if (!dest) return(NULL);
625 while (n-- && (*d++ = *src++)) ;
631 /*******************************************************************
632 copy an IP address from one buffer to another
633 ********************************************************************/
634 void putip(void *dest,void *src)
640 /****************************************************************************
641 interpret the weird netbios "name". Return the name type
642 ****************************************************************************/
643 static int name_interpret(char *in,char *out)
646 int len = (*in++) / 2;
650 if (len > 30 || len<1) return(0);
654 if (in[0] < 'A' || in[0] > 'P' || in[1] < 'A' || in[1] > 'P') {
658 *out = ((in[0]-'A')<<4) + (in[1]-'A');
666 /* Handle any scope names */
669 *out++ = '.'; /* Scope names are separated by periods */
670 len = *(unsigned char *)in++;
671 StrnCpy(out, in, len);
680 /****************************************************************************
681 mangle a name into netbios format
682 ****************************************************************************/
683 int name_mangle(char *In,char *Out,char name_type)
687 char *in = (char *)&buf[0];
688 char *out = (char *)Out;
693 StrnCpy(name,In,sizeof(name)-1);
694 sprintf(buf,"%-15.15s%c",name,name_type);
697 memset(&buf[1],0,16);
702 char c = toupper(in[i]);
703 out[i*2] = (c>>4) + 'A';
704 out[i*2+1] = (c & 0xF) + 'A';
712 p = strchr(label, '.');
714 p = label + strlen(label);
716 memcpy(out, label, p - label);
718 label += p - label + (*p == '.');
721 return(name_len(Out));
725 /*******************************************************************
726 check if a file exists
727 ********************************************************************/
728 BOOL file_exist(char *fname,struct stat *sbuf)
731 if (!sbuf) sbuf = &st;
733 if (sys_stat(fname,sbuf) != 0)
736 return(S_ISREG(sbuf->st_mode));
739 /*******************************************************************
740 check a files mod time
741 ********************************************************************/
742 time_t file_modtime(char *fname)
746 if (sys_stat(fname,&st) != 0)
752 /*******************************************************************
753 check if a directory exists
754 ********************************************************************/
755 BOOL directory_exist(char *dname,struct stat *st)
760 if (sys_stat(dname,st) != 0)
763 return(S_ISDIR(st->st_mode));
766 /*******************************************************************
767 returns the size in bytes of the named file
768 ********************************************************************/
769 uint32 file_size(char *file_name)
773 sys_stat(file_name,&buf);
777 /*******************************************************************
778 return a string representing an attribute for a file
779 ********************************************************************/
780 char *attrib_string(int mode)
782 static char attrstr[10];
786 if (mode & aVOLID) strcat(attrstr,"V");
787 if (mode & aDIR) strcat(attrstr,"D");
788 if (mode & aARCH) strcat(attrstr,"A");
789 if (mode & aHIDDEN) strcat(attrstr,"H");
790 if (mode & aSYSTEM) strcat(attrstr,"S");
791 if (mode & aRONLY) strcat(attrstr,"R");
797 /*******************************************************************
798 case insensitive string compararison
799 ********************************************************************/
800 int StrCaseCmp(const char *s, const char *t)
802 /* compare until we run out of string, either t or s, or find a difference */
803 while (*s && *t && tolower(*s) == tolower(*t))
808 return(tolower(*s) - tolower(*t));
811 /*******************************************************************
812 case insensitive string compararison, length limited
813 ********************************************************************/
814 int StrnCaseCmp(const char *s, const char *t, int n)
816 /* compare until we run out of string, either t or s, or chars */
817 while (n-- && *s && *t && tolower(*s) == tolower(*t))
822 /* not run out of chars - strings are different lengths */
823 if (n) return(tolower(*s) - tolower(*t));
825 /* identical up to where we run out of chars, and strings are same length */
829 /*******************************************************************
831 ********************************************************************/
832 BOOL strequal(char *s1,char *s2)
834 if (s1 == s2) return(True);
835 if (!s1 || !s2) return(False);
837 return(StrCaseCmp(s1,s2)==0);
840 /*******************************************************************
841 compare 2 strings up to and including the nth char.
842 ******************************************************************/
843 BOOL strnequal(char *s1,char *s2,int n)
845 if (s1 == s2) return(True);
846 if (!s1 || !s2 || !n) return(False);
848 return(StrnCaseCmp(s1,s2,n)==0);
851 /*******************************************************************
852 compare 2 strings (case sensitive)
853 ********************************************************************/
854 BOOL strcsequal(char *s1,char *s2)
856 if (s1 == s2) return(True);
857 if (!s1 || !s2) return(False);
859 return(strcmp(s1,s2)==0);
863 /*******************************************************************
864 convert a string to lower case
865 ********************************************************************/
866 void strlower(char *s)
871 if (is_shift_jis (*s)) {
873 } else if (is_kana (*s)) {
888 /*******************************************************************
889 convert a string to upper case
890 ********************************************************************/
891 void strupper(char *s)
896 if (is_shift_jis (*s)) {
898 } else if (is_kana (*s)) {
913 /*******************************************************************
914 convert a string to "normal" form
915 ********************************************************************/
916 void strnorm(char *s)
918 if (case_default == CASE_UPPER)
924 /*******************************************************************
925 check if a string is in "normal" case
926 ********************************************************************/
927 BOOL strisnormal(char *s)
929 if (case_default == CASE_UPPER)
930 return(!strhaslower(s));
932 return(!strhasupper(s));
936 /****************************************************************************
938 ****************************************************************************/
939 void string_replace(char *s,char oldc,char newc)
944 if (is_shift_jis (*s)) {
946 } else if (is_kana (*s)) {
961 /****************************************************************************
962 make a file into unix format
963 ****************************************************************************/
964 void unix_format(char *fname)
967 string_replace(fname,'\\','/');
971 strcpy(namecopy,fname);
973 strcat(fname,namecopy);
977 /****************************************************************************
978 make a file into dos format
979 ****************************************************************************/
980 void dos_format(char *fname)
982 string_replace(fname,'/','\\');
986 /*******************************************************************
987 show a smb message structure
988 ********************************************************************/
989 void show_msg(char *buf)
996 DEBUG(5,("size=%d\nsmb_com=0x%x\nsmb_rcls=%d\nsmb_reh=%d\nsmb_err=%d\nsmb_flg=%d\nsmb_flg2=%d\n",
998 (int)CVAL(buf,smb_com),
999 (int)CVAL(buf,smb_rcls),
1000 (int)CVAL(buf,smb_reh),
1001 (int)SVAL(buf,smb_err),
1002 (int)CVAL(buf,smb_flg),
1003 (int)SVAL(buf,smb_flg2)));
1004 DEBUG(5,("smb_tid=%d\nsmb_pid=%d\nsmb_uid=%d\nsmb_mid=%d\nsmt_wct=%d\n",
1005 (int)SVAL(buf,smb_tid),
1006 (int)SVAL(buf,smb_pid),
1007 (int)SVAL(buf,smb_uid),
1008 (int)SVAL(buf,smb_mid),
1009 (int)CVAL(buf,smb_wct)));
1010 for (i=0;i<(int)CVAL(buf,smb_wct);i++)
1011 DEBUG(5,("smb_vwv[%d]=%d (0x%X)\n",i,
1012 SVAL(buf,smb_vwv+2*i),SVAL(buf,smb_vwv+2*i)));
1013 bcc = (int)SVAL(buf,smb_vwv+2*(CVAL(buf,smb_wct)));
1014 DEBUG(5,("smb_bcc=%d\n",bcc));
1015 if (DEBUGLEVEL < 10)
1017 for (i=0;i<MIN(bcc,128);i++)
1018 DEBUG(10,("%X ",CVAL(smb_buf(buf),i)));
1022 /*******************************************************************
1023 return the length of an smb packet
1024 ********************************************************************/
1025 int smb_len(char *buf)
1027 return( PVAL(buf,3) | (PVAL(buf,2)<<8) | ((PVAL(buf,1)&1)<<16) );
1030 /*******************************************************************
1031 set the length of an smb packet
1032 ********************************************************************/
1033 void _smb_setlen(char *buf,int len)
1036 buf[1] = (len&0x10000)>>16;
1037 buf[2] = (len&0xFF00)>>8;
1041 /*******************************************************************
1042 set the length and marker of an smb packet
1043 ********************************************************************/
1044 void smb_setlen(char *buf,int len)
1046 _smb_setlen(buf,len);
1054 /*******************************************************************
1055 setup the word count and byte count for a smb message
1056 ********************************************************************/
1057 int set_message(char *buf,int num_words,int num_bytes,BOOL zero)
1060 bzero(buf + smb_size,num_words*2 + num_bytes);
1061 CVAL(buf,smb_wct) = num_words;
1062 SSVAL(buf,smb_vwv + num_words*SIZEOFWORD,num_bytes);
1063 smb_setlen(buf,smb_size + num_words*2 + num_bytes - 4);
1064 return (smb_size + num_words*2 + num_bytes);
1067 /*******************************************************************
1068 return the number of smb words
1069 ********************************************************************/
1070 int smb_numwords(char *buf)
1072 return (CVAL(buf,smb_wct));
1075 /*******************************************************************
1076 return the size of the smb_buf region of a message
1077 ********************************************************************/
1078 int smb_buflen(char *buf)
1080 return(SVAL(buf,smb_vwv0 + smb_numwords(buf)*2));
1083 /*******************************************************************
1084 return a pointer to the smb_buf data area
1085 ********************************************************************/
1086 int smb_buf_ofs(char *buf)
1088 return (smb_size + CVAL(buf,smb_wct)*2);
1091 /*******************************************************************
1092 return a pointer to the smb_buf data area
1093 ********************************************************************/
1094 char *smb_buf(char *buf)
1096 return (buf + smb_buf_ofs(buf));
1099 /*******************************************************************
1100 return the SMB offset into an SMB buffer
1101 ********************************************************************/
1102 int smb_offset(char *p,char *buf)
1104 return(PTR_DIFF(p,buf+4) + chain_size);
1108 /*******************************************************************
1109 skip past some strings in a buffer
1110 ********************************************************************/
1111 char *skip_string(char *buf,int n)
1114 buf += strlen(buf) + 1;
1118 /*******************************************************************
1119 trim the specified elements off the front and back of a string
1120 ********************************************************************/
1121 BOOL trim_string(char *s,char *front,char *back)
1124 while (front && *front && strncmp(s,front,strlen(front)) == 0)
1130 if (!(*p = p[strlen(front)]))
1135 while (back && *back && strlen(s) >= strlen(back) &&
1136 (strncmp(s+strlen(s)-strlen(back),back,strlen(back))==0))
1139 s[strlen(s)-strlen(back)] = 0;
1145 /*******************************************************************
1146 reduce a file name, removing .. elements.
1147 ********************************************************************/
1148 void dos_clean_name(char *s)
1152 DEBUG(3,("dos_clean_name [%s]\n",s));
1154 /* remove any double slashes */
1155 string_sub(s, "\\\\", "\\");
1157 while ((p = strstr(s,"\\..\\")) != NULL)
1164 if ((p=strrchr(s,'\\')) != NULL)
1171 trim_string(s,NULL,"\\..");
1173 string_sub(s, "\\.\\", "\\");
1176 /*******************************************************************
1177 reduce a file name, removing .. elements.
1178 ********************************************************************/
1179 void unix_clean_name(char *s)
1183 DEBUG(3,("unix_clean_name [%s]\n",s));
1185 /* remove any double slashes */
1186 string_sub(s, "//","/");
1188 /* Remove leading ./ characters */
1189 if(strncmp(s, "./", 2) == 0) {
1190 trim_string(s, "./", NULL);
1195 while ((p = strstr(s,"/../")) != NULL)
1202 if ((p=strrchr(s,'/')) != NULL)
1209 trim_string(s,NULL,"/..");
1213 /*******************************************************************
1214 a wrapper for the normal chdir() function
1215 ********************************************************************/
1216 int ChDir(char *path)
1219 static pstring LastDir="";
1221 if (strcsequal(path,".")) return(0);
1223 if (*path == '/' && strcsequal(LastDir,path)) return(0);
1224 DEBUG(3,("chdir to %s\n",path));
1225 res = sys_chdir(path);
1227 strcpy(LastDir,path);
1232 /*******************************************************************
1233 return the absolute current directory path. A dumb version.
1234 ********************************************************************/
1235 static char *Dumb_GetWd(char *s)
1238 return ((char *)getcwd(s,sizeof(pstring)));
1240 return ((char *)getwd(s));
1245 /* number of list structures for a caching GetWd function. */
1246 #define MAX_GETWDCACHE (50)
1254 } ino_list[MAX_GETWDCACHE];
1256 BOOL use_getwd_cache=True;
1258 /*******************************************************************
1259 return the absolute current directory path
1260 ********************************************************************/
1261 char *GetWd(char *str)
1264 static BOOL getwd_cache_init = False;
1265 struct stat st, st2;
1270 if (!use_getwd_cache)
1271 return(Dumb_GetWd(str));
1273 /* init the cache */
1274 if (!getwd_cache_init)
1276 getwd_cache_init = True;
1277 for (i=0;i<MAX_GETWDCACHE;i++)
1279 string_init(&ino_list[i].text,"");
1280 ino_list[i].valid = False;
1284 /* Get the inode of the current directory, if this doesn't work we're
1287 if (stat(".",&st) == -1)
1289 DEBUG(0,("Very strange, couldn't stat \".\"\n"));
1290 return(Dumb_GetWd(str));
1294 for (i=0; i<MAX_GETWDCACHE; i++)
1295 if (ino_list[i].valid)
1298 /* If we have found an entry with a matching inode and dev number
1299 then find the inode number for the directory in the cached string.
1300 If this agrees with that returned by the stat for the current
1301 directory then all is o.k. (but make sure it is a directory all
1304 if (st.st_ino == ino_list[i].inode &&
1305 st.st_dev == ino_list[i].dev)
1307 if (stat(ino_list[i].text,&st2) == 0)
1309 if (st.st_ino == st2.st_ino &&
1310 st.st_dev == st2.st_dev &&
1311 (st2.st_mode & S_IFMT) == S_IFDIR)
1313 strcpy (str, ino_list[i].text);
1315 /* promote it for future use */
1316 array_promote((char *)&ino_list[0],sizeof(ino_list[0]),i);
1321 /* If the inode is different then something's changed,
1322 scrub the entry and start from scratch. */
1323 ino_list[i].valid = False;
1330 /* We don't have the information to hand so rely on traditional methods.
1331 The very slow getcwd, which spawns a process on some systems, or the
1332 not quite so bad getwd. */
1336 DEBUG(0,("Getwd failed, errno %d\n",errno));
1342 DEBUG(5,("GetWd %s, inode %d, dev %x\n",s,(int)st.st_ino,(int)st.st_dev));
1344 /* add it to the cache */
1345 i = MAX_GETWDCACHE - 1;
1346 string_set(&ino_list[i].text,s);
1347 ino_list[i].dev = st.st_dev;
1348 ino_list[i].inode = st.st_ino;
1349 ino_list[i].valid = True;
1351 /* put it at the top of the list */
1352 array_promote((char *)&ino_list[0],sizeof(ino_list[0]),i);
1359 /*******************************************************************
1360 reduce a file name, removing .. elements and checking that
1361 it is below dir in the heirachy. This uses GetWd() and so must be run
1362 on the system that has the referenced file system.
1364 widelinks are allowed if widelinks is true
1365 ********************************************************************/
1366 BOOL reduce_name(char *s,char *dir,BOOL widelinks)
1368 #ifndef REDUCE_PATHS
1376 BOOL relative = (*s != '/');
1378 *dir2 = *wd = *basename = *newname = 0;
1383 /* can't have a leading .. */
1384 if (strncmp(s,"..",2) == 0 && (s[2]==0 || s[2]=='/'))
1386 DEBUG(3,("Illegal file name? (%s)\n",s));
1396 DEBUG(3,("reduce_name [%s] [%s]\n",s,dir));
1398 /* remove any double slashes */
1399 string_sub(s,"//","/");
1402 p = strrchr(basename,'/');
1409 DEBUG(0,("couldn't getwd for %s %s\n",s,dir));
1413 if (ChDir(dir) != 0)
1415 DEBUG(0,("couldn't chdir to %s\n",dir));
1421 DEBUG(0,("couldn't getwd for %s\n",dir));
1427 if (p && (p != basename))
1430 if (strcmp(p+1,".")==0)
1432 if (strcmp(p+1,"..")==0)
1436 if (ChDir(basename) != 0)
1439 DEBUG(3,("couldn't chdir for %s %s basename=%s\n",s,dir,basename));
1443 if (!GetWd(newname))
1446 DEBUG(2,("couldn't get wd for %s %s\n",s,dir2));
1450 if (p && (p != basename))
1452 strcat(newname,"/");
1453 strcat(newname,p+1);
1457 int l = strlen(dir2);
1458 if (dir2[l-1] == '/')
1461 if (strncmp(newname,dir2,l) != 0)
1464 DEBUG(2,("Bad access attempt? s=%s dir=%s newname=%s l=%d\n",s,dir2,newname,l));
1470 if (newname[l] == '/')
1471 strcpy(s,newname + l + 1);
1473 strcpy(s,newname+l);
1484 DEBUG(3,("reduced to %s\n",s));
1489 /****************************************************************************
1491 ****************************************************************************/
1492 static void expand_one(char *Mask,int len)
1495 while ((p1 = strchr(Mask,'*')) != NULL)
1497 int lfill = (len+1) - strlen(Mask);
1498 int l1= (p1 - Mask);
1501 memset(tmp+l1,'?',lfill);
1502 strcpy(tmp + l1 + lfill,Mask + l1 + 1);
1507 /****************************************************************************
1508 expand a wildcard expression, replacing *s with ?s
1509 ****************************************************************************/
1510 void expand_mask(char *Mask,BOOL doext)
1515 BOOL hasdot = False;
1517 BOOL absolute = (*Mask == '\\');
1519 *mbeg = *mext = *dirpart = *filepart = 0;
1521 /* parse the directory and filename */
1522 if (strchr(Mask,'\\'))
1523 dirname_dos(Mask,dirpart);
1525 filename_dos(Mask,filepart);
1527 strcpy(mbeg,filepart);
1528 if ((p1 = strchr(mbeg,'.')) != NULL)
1538 if (strlen(mbeg) > 8)
1540 strcpy(mext,mbeg + 8);
1546 strcpy(mbeg,"????????");
1547 if ((*mext == 0) && doext && !hasdot)
1550 if (strequal(mbeg,"*") && *mext==0)
1558 strcpy(Mask,dirpart);
1559 if (*dirpart || absolute) strcat(Mask,"\\");
1564 DEBUG(6,("Mask expanded to [%s]\n",Mask));
1568 /****************************************************************************
1569 does a string have any uppercase chars in it?
1570 ****************************************************************************/
1571 BOOL strhasupper(char *s)
1576 if (is_shift_jis (*s)) {
1578 } else if (is_kana (*s)) {
1581 if (isupper(*s)) return(True);
1585 if (isupper(*s)) return(True);
1592 /****************************************************************************
1593 does a string have any lowercase chars in it?
1594 ****************************************************************************/
1595 BOOL strhaslower(char *s)
1600 if (is_shift_jis (*s)) {
1602 } else if (is_kana (*s)) {
1605 if (islower(*s)) return(True);
1609 if (islower(*s)) return(True);
1616 /****************************************************************************
1617 find the number of chars in a string
1618 ****************************************************************************/
1619 int count_chars(char *s,char c)
1632 /****************************************************************************
1634 ****************************************************************************/
1635 void make_dir_struct(char *buf,char *mask,char *fname,unsigned int size,int mode,time_t date)
1642 if ((mode & aDIR) != 0)
1645 memset(buf+1,' ',11);
1646 if ((p = strchr(mask2,'.')) != NULL)
1649 memcpy(buf+1,mask2,MIN(strlen(mask2),8));
1650 memcpy(buf+9,p+1,MIN(strlen(p+1),3));
1654 memcpy(buf+1,mask2,MIN(strlen(mask2),11));
1656 bzero(buf+21,DIR_STRUCT_SIZE-21);
1657 CVAL(buf,21) = mode;
1658 put_dos_date(buf,22,date);
1659 SSVAL(buf,26,size & 0xFFFF);
1660 SSVAL(buf,28,size >> 16);
1661 StrnCpy(buf+30,fname,12);
1662 if (!case_sensitive)
1664 DEBUG(8,("put name [%s] into dir struct\n",buf+30));
1668 /*******************************************************************
1669 close the low 3 fd's and open dev/null in their place
1670 ********************************************************************/
1671 void close_low_fds(void)
1675 close(0); close(1); close(2);
1676 /* try and use up these file descriptors, so silly
1677 library routines writing to stdout etc won't cause havoc */
1679 fd = open("/dev/null",O_RDWR,0);
1680 if (fd < 0) fd = open("/dev/null",O_WRONLY,0);
1682 DEBUG(0,("Can't open /dev/null\n"));
1686 DEBUG(0,("Didn't get file descriptor %d\n",i));
1692 /****************************************************************************
1693 Set a fd into blocking/nonblocking mode. Uses POSIX O_NONBLOCK if available,
1695 if SYSV use O_NDELAY
1697 ****************************************************************************/
1698 int set_blocking(int fd, int set)
1702 #define FLAG_TO_SET O_NONBLOCK
1705 #define FLAG_TO_SET O_NDELAY
1707 #define FLAG_TO_SET FNDELAY
1711 if((val = fcntl(fd, F_GETFL, 0)) == -1)
1713 if(set) /* Turn blocking on - ie. clear nonblock flag */
1714 val &= ~FLAG_TO_SET;
1717 return fcntl( fd, F_SETFL, val);
1722 /****************************************************************************
1724 ****************************************************************************/
1725 int write_socket(int fd,char *buf,int len)
1731 DEBUG(6,("write_socket(%d,%d)\n",fd,len));
1732 ret = write_data(fd,buf,len);
1734 DEBUG(6,("write_socket(%d,%d) wrote %d\n",fd,len,ret));
1738 /****************************************************************************
1740 ****************************************************************************/
1741 int read_udp_socket(int fd,char *buf,int len)
1744 struct sockaddr sock;
1747 socklen = sizeof(sock);
1748 bzero((char *)&sock,socklen);
1749 bzero((char *)&lastip,sizeof(lastip));
1750 ret = recvfrom(fd,buf,len,0,&sock,&socklen);
1752 DEBUG(2,("read socket failed. ERRNO=%d\n",errno));
1756 lastip = *(struct in_addr *) &sock.sa_data[2];
1757 lastport = ntohs(((struct sockaddr_in *)&sock)->sin_port);
1762 /****************************************************************************
1763 read data from a device with a timout in msec.
1764 mincount = if timeout, minimum to read before returning
1765 maxcount = number to be read.
1766 ****************************************************************************/
1767 int read_with_timeout(int fd,char *buf,int mincnt,int maxcnt,long time_out)
1773 struct timeval timeout;
1775 /* just checking .... */
1776 if (maxcnt <= 0) return(0);
1781 if (time_out <= 0) {
1782 if (mincnt == 0) mincnt = maxcnt;
1784 while (nread < mincnt) {
1785 readret = read(fd, buf + nread, maxcnt - nread);
1787 smb_read_error = READ_EOF;
1791 if (readret == -1) {
1792 smb_read_error = READ_ERROR;
1800 /* Most difficult - timeout read */
1801 /* If this is ever called on a disk file and
1802 mincnt is greater then the filesize then
1803 system performance will suffer severely as
1804 select always return true on disk files */
1806 /* Set initial timeout */
1807 timeout.tv_sec = time_out / 1000;
1808 timeout.tv_usec = 1000 * (time_out % 1000);
1810 for (nread=0; nread<mincnt; )
1815 selrtn = sys_select(&fds,&timeout);
1817 /* Check if error */
1819 /* something is wrong. Maybe the socket is dead? */
1820 smb_read_error = READ_ERROR;
1824 /* Did we timeout ? */
1826 smb_read_error = READ_TIMEOUT;
1830 readret = read(fd, buf+nread, maxcnt-nread);
1832 /* we got EOF on the file descriptor */
1833 smb_read_error = READ_EOF;
1837 if (readret == -1) {
1838 /* the descriptor is probably dead */
1839 smb_read_error = READ_ERROR;
1846 /* Return the number we got */
1850 /****************************************************************************
1851 read data from the client. Maxtime is in milliseconds
1852 ****************************************************************************/
1853 int read_max_udp(int fd,char *buffer,int bufsize,int maxtime)
1858 struct timeval timeout;
1863 timeout.tv_sec = maxtime / 1000;
1864 timeout.tv_usec = (maxtime % 1000) * 1000;
1866 selrtn = sys_select(&fds,maxtime>0?&timeout:NULL);
1868 if (!FD_ISSET(fd,&fds))
1871 nread = read_udp_socket(fd, buffer, bufsize);
1873 /* return the number got */
1877 /*******************************************************************
1878 find the difference in milliseconds between two struct timeval
1880 ********************************************************************/
1881 int TvalDiff(struct timeval *tvalold,struct timeval *tvalnew)
1883 return((tvalnew->tv_sec - tvalold->tv_sec)*1000 +
1884 ((int)tvalnew->tv_usec - (int)tvalold->tv_usec)/1000);
1887 /****************************************************************************
1888 send a keepalive packet (rfc1002)
1889 ****************************************************************************/
1890 BOOL send_keepalive(int client)
1892 unsigned char buf[4];
1895 buf[1] = buf[2] = buf[3] = 0;
1897 return(write_data(client,(char *)buf,4) == 4);
1902 /****************************************************************************
1903 read data from the client, reading exactly N bytes.
1904 ****************************************************************************/
1905 int read_data(int fd,char *buffer,int N)
1914 ret = read(fd,buffer + total,N - total);
1916 smb_read_error = READ_EOF;
1920 smb_read_error = READ_ERROR;
1929 /****************************************************************************
1931 ****************************************************************************/
1932 int write_data(int fd,char *buffer,int N)
1939 ret = write(fd,buffer + total,N - total);
1941 if (ret == -1) return -1;
1942 if (ret == 0) return total;
1950 /****************************************************************************
1951 transfer some data between two fd's
1952 ****************************************************************************/
1953 int transfer_file(int infd,int outfd,int n,char *header,int headlen,int align)
1955 static char *buf=NULL;
1960 DEBUG(4,("transfer_file %d (head=%d) called\n",n,headlen));
1963 size = lp_readsize();
1964 size = MAX(size,1024);
1967 while (!buf && size>0) {
1968 buf = (char *)Realloc(buf,size+8);
1969 if (!buf) size /= 2;
1973 DEBUG(0,("Can't allocate transfer buffer!\n"));
1977 abuf = buf + (align%8);
1984 int s = MIN(n,size);
1989 if (header && (headlen >= MIN(s,1024))) {
1999 if (header && headlen > 0)
2001 ret = MIN(headlen,size);
2002 memcpy(buf1,header,ret);
2005 if (headlen <= 0) header = NULL;
2009 ret += read(infd,buf1+ret,s-ret);
2013 ret2 = (outfd>=0?write_data(outfd,buf1,ret):ret);
2014 if (ret2 > 0) total += ret2;
2015 /* if we can't write then dump excess data */
2017 transfer_file(infd,-1,n-(ret+headlen),NULL,0,0);
2019 if (ret <= 0 || ret2 != ret)
2027 /****************************************************************************
2028 read 4 bytes of a smb packet and return the smb length of the packet
2029 possibly store the result in the buffer
2030 ****************************************************************************/
2031 int read_smb_length(int fd,char *inbuf,int timeout)
2035 int len=0, msg_type;
2046 ok = (read_with_timeout(fd,buffer,4,4,timeout) == 4);
2048 ok = (read_data(fd,buffer,4) == 4);
2053 len = smb_len(buffer);
2054 msg_type = CVAL(buffer,0);
2056 if (msg_type == 0x85)
2058 DEBUG(5,("Got keepalive packet\n"));
2063 DEBUG(10,("got smb length of %d\n",len));
2070 /****************************************************************************
2071 read an smb from a fd and return it's length
2072 The timeout is in milli seconds
2073 ****************************************************************************/
2074 BOOL receive_smb(int fd,char *buffer,int timeout)
2080 bzero(buffer,smb_size + 100);
2082 len = read_smb_length(fd,buffer,timeout);
2086 if (len > BUFFER_SIZE) {
2087 DEBUG(0,("Invalid packet length! (%d bytes).\n",len));
2088 if (len > BUFFER_SIZE + (SAFETY_MARGIN/2))
2092 ret = read_data(fd,buffer+4,len);
2094 smb_read_error = READ_ERROR;
2102 /****************************************************************************
2104 ****************************************************************************/
2105 BOOL send_smb(int fd,char *buffer)
2109 len = smb_len(buffer) + 4;
2111 while (nwritten < len)
2113 ret = write_socket(fd,buffer+nwritten,len - nwritten);
2116 DEBUG(0,("Error writing %d bytes to client. %d. Exiting\n",len,ret));
2128 /****************************************************************************
2129 find a pointer to a netbios name
2130 ****************************************************************************/
2131 char *name_ptr(char *buf,int ofs)
2133 unsigned char c = *(unsigned char *)(buf+ofs);
2135 if ((c & 0xC0) == 0xC0)
2139 memcpy(p,buf+ofs,2);
2142 DEBUG(5,("name ptr to pos %d from %d is %s\n",l,ofs,buf+l));
2149 /****************************************************************************
2150 extract a netbios name from a buf
2151 ****************************************************************************/
2152 int name_extract(char *buf,int ofs,char *name)
2154 char *p = name_ptr(buf,ofs);
2155 int d = PTR_DIFF(p,buf+ofs);
2157 if (d < -50 || d > 50) return(0);
2158 return(name_interpret(p,name));
2162 /****************************************************************************
2163 return the total storage length of a mangled name
2164 ****************************************************************************/
2165 int name_len(char *s)
2168 unsigned char c = *(unsigned char *)s;
2169 if ((c & 0xC0) == 0xC0)
2171 while (*s) s += (*s)+1;
2172 return(PTR_DIFF(s,s0)+1);
2175 /****************************************************************************
2176 send a single packet to a port on another machine
2177 ****************************************************************************/
2178 BOOL send_one_packet(char *buf,int len,struct in_addr ip,int port,int type)
2182 struct sockaddr_in sock_out;
2187 /* create a socket to write to */
2188 out_fd = socket(AF_INET, type, 0);
2191 DEBUG(0,("socket failed"));
2195 /* set the address and port */
2196 bzero((char *)&sock_out,sizeof(sock_out));
2197 putip((char *)&sock_out.sin_addr,(char *)&ip);
2198 sock_out.sin_port = htons( port );
2199 sock_out.sin_family = AF_INET;
2202 DEBUG(3,("sending a packet of len %d to (%s) on port %d of type %s\n",
2203 len,inet_ntoa(ip),port,type==SOCK_DGRAM?"DGRAM":"STREAM"));
2206 ret = (sendto(out_fd,buf,len,0,(struct sockaddr *)&sock_out,sizeof(sock_out)) >= 0);
2209 DEBUG(0,("Packet send to %s(%d) failed ERRNO=%d\n",
2210 inet_ntoa(ip),port,errno));
2216 /*******************************************************************
2217 sleep for a specified number of milliseconds
2218 ********************************************************************/
2222 struct timeval tval,t1,t2;
2229 tval.tv_sec = (t-tdiff)/1000;
2230 tval.tv_usec = 1000*((t-tdiff)%1000);
2234 sys_select(&fds,&tval);
2237 tdiff = TvalDiff(&t1,&t2);
2241 /****************************************************************************
2242 check if a string is part of a list
2243 ****************************************************************************/
2244 BOOL in_list(char *s,char *list,BOOL casesensitive)
2249 if (!list) return(False);
2251 while (next_token(&p,tok,LIST_SEP))
2253 if (casesensitive) {
2254 if (strcmp(tok,s) == 0)
2257 if (StrCaseCmp(tok,s) == 0)
2264 /* this is used to prevent lots of mallocs of size 1 */
2265 static char *null_string = NULL;
2267 /****************************************************************************
2268 set a string value, allocing the space for the string
2269 ****************************************************************************/
2270 BOOL string_init(char **dest,char *src)
2281 null_string = (char *)malloc(1);
2284 *dest = null_string;
2288 *dest = (char *)malloc(l+1);
2294 /****************************************************************************
2296 ****************************************************************************/
2297 void string_free(char **s)
2299 if (!s || !(*s)) return;
2300 if (*s == null_string)
2306 /****************************************************************************
2307 set a string value, allocing the space for the string, and deallocating any
2309 ****************************************************************************/
2310 BOOL string_set(char **dest,char *src)
2314 return(string_init(dest,src));
2317 /****************************************************************************
2318 substitute a string for a pattern in another string. Make sure there is
2321 This routine looks for pattern in s and replaces it with
2322 insert. It may do multiple replacements.
2324 return True if a substitution was done.
2325 ****************************************************************************/
2326 BOOL string_sub(char *s,char *pattern,char *insert)
2332 if (!insert || !pattern || !s) return(False);
2335 lp = strlen(pattern);
2336 li = strlen(insert);
2338 if (!*pattern) return(False);
2340 while (lp <= ls && (p = strstr(s,pattern)))
2343 memmove(p+li,p+lp,ls + 1 - (PTR_DIFF(p,s) + lp));
2344 memcpy(p,insert,li);
2353 /*********************************************************
2354 * Recursive routine that is called by mask_match.
2355 * Does the actual matching.
2356 *********************************************************/
2357 BOOL do_match(char *str, char *regexp, int case_sig)
2361 for( p = regexp; *p && *str; ) {
2368 /* Look for a character matching
2369 the one after the '*' */
2372 return True; /* Automatic match */
2374 while(*str && (case_sig ? (*p != *str) : (toupper(*p)!=toupper(*str))))
2376 if(do_match(str,p,case_sig))
2390 if(toupper(*str) != toupper(*p))
2400 if (!*p && str[0] == '.' && str[1] == 0)
2403 if (!*str && *p == '?')
2405 while (*p == '?') p++;
2409 if(!*str && (*p == '*' && p[1] == '\0'))
2415 /*********************************************************
2416 * Routine to match a given string with a regexp - uses
2417 * simplified regexp that takes * and ? only. Case can be
2418 * significant or not.
2419 *********************************************************/
2420 BOOL mask_match(char *str, char *regexp, int case_sig,BOOL trans2)
2424 fstring ebase,eext,sbase,sext;
2428 /* Make local copies of str and regexp */
2429 StrnCpy(p1,regexp,sizeof(pstring)-1);
2430 StrnCpy(p2,str,sizeof(pstring)-1);
2432 if (!strchr(p2,'.')) {
2437 if (!strchr(p1,'.')) {
2445 string_sub(p1,"*.*","*");
2446 string_sub(p1,".*","*");
2450 /* Remove any *? and ** as they are meaningless */
2451 for(p = p1; *p; p++)
2452 while( *p == '*' && (p[1] == '?' ||p[1] == '*'))
2453 (void)strcpy( &p[1], &p[2]);
2455 if (strequal(p1,"*")) return(True);
2457 DEBUG(5,("mask_match str=<%s> regexp=<%s>, case_sig = %d\n", p2, p1, case_sig));
2463 if ((p=strrchr(p1,'.'))) {
2472 if (!strequal(p2,".") && !strequal(p2,"..") && (p=strrchr(p2,'.'))) {
2482 matched = do_match(sbase,ebase,case_sig) &&
2483 (trans2 || do_match(sext,eext,case_sig));
2485 DEBUG(5,("mask_match returning %d\n", matched));
2492 /****************************************************************************
2493 become a daemon, discarding the controlling terminal
2494 ****************************************************************************/
2495 void become_daemon(void)
2497 #ifndef NO_FORK_DEBUG
2501 /* detach from the terminal */
2507 int i = open("/dev/tty", O_RDWR);
2510 ioctl(i, (int) TIOCNOTTY, (char *)0);
2520 /****************************************************************************
2521 put up a yes/no prompt
2522 ****************************************************************************/
2528 if (!fgets(ans,sizeof(ans)-1,stdin))
2531 if (*ans == 'y' || *ans == 'Y')
2537 /****************************************************************************
2538 read a line from a file with possible \ continuation chars.
2539 Blanks at the start or end of a line are stripped.
2540 The string will be allocated if s2 is NULL
2541 ****************************************************************************/
2542 char *fgets_slash(char *s2,int maxlen,FILE *f)
2547 BOOL start_of_line = True;
2554 maxlen = MIN(maxlen,8);
2555 s = (char *)Realloc(s,maxlen);
2558 if (!s || maxlen < 2) return(NULL);
2562 while (len < maxlen-1)
2570 while (len > 0 && s[len-1] == ' ')
2574 if (len > 0 && s[len-1] == '\\')
2577 start_of_line = True;
2582 if (len <= 0 && !s2)
2584 return(len>0?s:NULL);
2589 start_of_line = False;
2593 if (!s2 && len > maxlen-3)
2596 s = (char *)Realloc(s,maxlen);
2597 if (!s) return(NULL);
2605 /****************************************************************************
2606 set the length of a file from a filedescriptor.
2607 Returns 0 on success, -1 on failure.
2608 ****************************************************************************/
2609 int set_filelen(int fd, long len)
2611 /* According to W. R. Stevens advanced UNIX prog. Pure 4.3 BSD cannot
2612 extend a file with ftruncate. Provide alternate implementation
2615 #if FTRUNCATE_CAN_EXTEND
2616 return ftruncate(fd, len);
2620 long currpos = lseek(fd, 0L, SEEK_CUR);
2624 /* Do an fstat to see if the file is longer than
2625 the requested size (call ftruncate),
2626 or shorter, in which case seek to len - 1 and write 1
2628 if(fstat(fd, &st)<0)
2632 if (S_ISFIFO(st.st_mode)) return 0;
2635 if(st.st_size == len)
2637 if(st.st_size > len)
2638 return ftruncate(fd, len);
2640 if(lseek(fd, len-1, SEEK_SET) != len -1)
2642 if(write(fd, &c, 1)!=1)
2644 /* Seek to where we were */
2645 lseek(fd, currpos, SEEK_SET);
2651 /****************************************************************************
2652 return the byte checksum of some data
2653 ****************************************************************************/
2654 int byte_checksum(char *buf,int len)
2656 unsigned char *p = (unsigned char *)buf;
2666 /****************************************************************************
2667 this is a version of setbuffer() for those machines that only have setvbuf
2668 ****************************************************************************/
2669 void setbuffer(FILE *f,char *buf,int bufsize)
2671 setvbuf(f,buf,_IOFBF,bufsize);
2676 /****************************************************************************
2677 parse out a directory name from a path name. Assumes dos style filenames.
2678 ****************************************************************************/
2679 char *dirname_dos(char *path,char *buf)
2681 char *p = strrchr(path,'\\');
2696 /****************************************************************************
2697 parse out a filename from a path name. Assumes dos style filenames.
2698 ****************************************************************************/
2699 static char *filename_dos(char *path,char *buf)
2701 char *p = strrchr(path,'\\');
2713 /****************************************************************************
2714 expand a pointer to be a particular size
2715 ****************************************************************************/
2716 void *Realloc(void *p,int size)
2722 DEBUG(5,("Realloc asked for 0 bytes\n"));
2727 ret = (void *)malloc(size);
2729 ret = (void *)realloc(p,size);
2732 DEBUG(0,("Memory allocation error: failed to expand to %d bytes\n",size));
2738 /****************************************************************************
2740 ****************************************************************************/
2741 char *strdup(char *s)
2744 if (!s) return(NULL);
2745 ret = (char *)malloc(strlen(s)+1);
2746 if (!ret) return(NULL);
2753 /****************************************************************************
2754 Signal handler for SIGPIPE (write on a disconnected socket)
2755 ****************************************************************************/
2758 DEBUG(0,("Probably got SIGPIPE\nExiting\n"));
2762 /****************************************************************************
2763 get my own name and IP
2764 ****************************************************************************/
2765 BOOL get_myname(char *my_name,struct in_addr *ip)
2772 /* get my host name */
2773 if (gethostname(hostname, MAXHOSTNAMELEN) == -1)
2775 DEBUG(0,("gethostname failed\n"));
2780 if ((hp = Get_Hostbyname(hostname)) == 0)
2782 DEBUG(0,( "Get_Hostbyname: Unknown host %s.\n",hostname));
2788 /* split off any parts after an initial . */
2789 char *p = strchr(hostname,'.');
2792 strcpy(my_name,hostname);
2796 putip((char *)ip,(char *)hp->h_addr);
2802 /****************************************************************************
2803 true if two IP addresses are equal
2804 ****************************************************************************/
2805 BOOL ip_equal(struct in_addr ip1,struct in_addr ip2)
2808 a1 = ntohl(ip1.s_addr);
2809 a2 = ntohl(ip2.s_addr);
2814 /****************************************************************************
2815 open a socket of the specified type, port and address for incoming data
2816 ****************************************************************************/
2817 int open_socket_in(int type, int port, int dlevel,uint32 socket_addr)
2820 struct sockaddr_in sock;
2824 /* get my host name */
2825 if (gethostname(host_name, MAXHOSTNAMELEN) == -1)
2826 { DEBUG(0,("gethostname failed\n")); return -1; }
2829 if ((hp = Get_Hostbyname(host_name)) == 0)
2831 DEBUG(0,( "Get_Hostbyname: Unknown host. %s\n",host_name));
2835 bzero((char *)&sock,sizeof(sock));
2836 memcpy((char *)&sock.sin_addr,(char *)hp->h_addr, hp->h_length);
2837 #if defined(__FreeBSD__) || defined(NETBSD) /* XXX not the right ifdef */
2838 sock.sin_len = sizeof(sock);
2840 sock.sin_port = htons( port );
2841 sock.sin_family = hp->h_addrtype;
2842 sock.sin_addr.s_addr = socket_addr;
2843 res = socket(hp->h_addrtype, type, 0);
2845 { DEBUG(0,("socket failed\n")); return -1; }
2849 setsockopt(res,SOL_SOCKET,SO_REUSEADDR,(char *)&one,sizeof(one));
2852 /* now we've got a socket - we need to bind it */
2853 if (bind(res, (struct sockaddr * ) &sock,sizeof(sock)) < 0)
2856 if (port == SMB_PORT || port == NMB_PORT)
2857 DEBUG(dlevel,("bind failed on port %d socket_addr=%x (%s)\n",
2858 port,socket_addr,strerror(errno)));
2861 if (dlevel > 0 && port < 1000)
2864 if (port >= 1000 && port < 9000)
2865 return(open_socket_in(type,port+1,dlevel,socket_addr));
2870 DEBUG(3,("bind succeeded on port %d\n",port));
2876 /****************************************************************************
2877 create an outgoing socket
2878 **************************************************************************/
2879 int open_socket_out(int type, struct in_addr *addr, int port ,int timeout)
2881 struct sockaddr_in sock_out;
2883 int connect_loop = 250; /* 250 milliseconds */
2884 int loops = (timeout * 1000) / connect_loop;
2886 /* create a socket to write to */
2887 res = socket(PF_INET, type, 0);
2889 { DEBUG(0,("socket error\n")); return -1; }
2891 if (type != SOCK_STREAM) return(res);
2893 bzero((char *)&sock_out,sizeof(sock_out));
2894 putip((char *)&sock_out.sin_addr,(char *)addr);
2896 sock_out.sin_port = htons( port );
2897 sock_out.sin_family = PF_INET;
2899 /* set it non-blocking */
2900 set_blocking(res,0);
2902 DEBUG(3,("Connecting to %s at port %d\n",inet_ntoa(*addr),port));
2904 /* and connect it to the destination */
2906 ret = connect(res,(struct sockaddr *)&sock_out,sizeof(sock_out));
2908 /* Some systems return EAGAIN when they mean EINPROGRESS */
2909 if (ret < 0 && (errno == EINPROGRESS || errno == EALREADY ||
2910 errno == EAGAIN) && loops--) {
2911 msleep(connect_loop);
2915 if (ret < 0 && (errno == EINPROGRESS || errno == EALREADY)) {
2916 DEBUG(1,("timeout connecting to %s:%d\n",inet_ntoa(*addr),port));
2922 if (ret < 0 && errno == EISCONN) {
2929 DEBUG(1,("error connecting to %s:%d (%s)\n",
2930 inet_ntoa(*addr),port,strerror(errno)));
2934 /* set it blocking again */
2935 set_blocking(res,1);
2941 /****************************************************************************
2942 interpret a protocol description string, with a default
2943 ****************************************************************************/
2944 int interpret_protocol(char *str,int def)
2946 if (strequal(str,"NT1"))
2947 return(PROTOCOL_NT1);
2948 if (strequal(str,"LANMAN2"))
2949 return(PROTOCOL_LANMAN2);
2950 if (strequal(str,"LANMAN1"))
2951 return(PROTOCOL_LANMAN1);
2952 if (strequal(str,"CORE"))
2953 return(PROTOCOL_CORE);
2954 if (strequal(str,"COREPLUS"))
2955 return(PROTOCOL_COREPLUS);
2956 if (strequal(str,"CORE+"))
2957 return(PROTOCOL_COREPLUS);
2959 DEBUG(0,("Unrecognised protocol level %s\n",str));
2964 /****************************************************************************
2965 interpret a security level
2966 ****************************************************************************/
2967 int interpret_security(char *str,int def)
2969 if (strequal(str,"SERVER"))
2971 if (strequal(str,"USER"))
2973 if (strequal(str,"SHARE"))
2976 DEBUG(0,("Unrecognised security level %s\n",str));
2982 /****************************************************************************
2983 interpret an internet address or name into an IP address in 4 byte form
2984 ****************************************************************************/
2985 uint32 interpret_addr(char *str)
2990 BOOL pure_address = True;
2992 if (strcmp(str,"0.0.0.0") == 0) return(0);
2993 if (strcmp(str,"255.255.255.255") == 0) return(0xFFFFFFFF);
2995 for (i=0; pure_address && str[i]; i++)
2996 if (!(isdigit(str[i]) || str[i] == '.'))
2997 pure_address = False;
2999 /* if it's in the form of an IP address then get the lib to interpret it */
3001 res = inet_addr(str);
3003 /* otherwise assume it's a network name of some sort and use
3005 if ((hp = Get_Hostbyname(str)) == 0) {
3006 DEBUG(3,("Get_Hostbyname: Unknown host. %s\n",str));
3009 putip((char *)&res,(char *)hp->h_addr);
3012 if (res == (uint32)-1) return(0);
3017 /*******************************************************************
3018 a convenient addition to interpret_addr()
3019 ******************************************************************/
3020 struct in_addr *interpret_addr2(char *str)
3022 static struct in_addr ret;
3023 uint32 a = interpret_addr(str);
3028 /*******************************************************************
3029 check if an IP is the 0.0.0.0
3030 ******************************************************************/
3031 BOOL zero_ip(struct in_addr ip)
3034 putip((char *)&a,(char *)&ip);
3039 /* matchname - determine if host name matches IP address */
3040 static BOOL matchname(char *remotehost,struct in_addr addr)
3045 if ((hp = Get_Hostbyname(remotehost)) == 0) {
3046 DEBUG(0,("Get_Hostbyname(%s): lookup failure", remotehost));
3051 * Make sure that gethostbyname() returns the "correct" host name.
3052 * Unfortunately, gethostbyname("localhost") sometimes yields
3053 * "localhost.domain". Since the latter host name comes from the
3054 * local DNS, we just have to trust it (all bets are off if the local
3055 * DNS is perverted). We always check the address list, though.
3058 if (strcasecmp(remotehost, hp->h_name)
3059 && strcasecmp(remotehost, "localhost")) {
3060 DEBUG(0,("host name/name mismatch: %s != %s",
3061 remotehost, hp->h_name));
3065 /* Look up the host address in the address list we just got. */
3066 for (i = 0; hp->h_addr_list[i]; i++) {
3067 if (memcmp(hp->h_addr_list[i], (caddr_t) & addr, sizeof(addr)) == 0)
3072 * The host name does not map to the original host address. Perhaps
3073 * someone has compromised a name server. More likely someone botched
3074 * it, but that could be dangerous, too.
3077 DEBUG(0,("host name/address mismatch: %s != %s",
3078 inet_ntoa(addr), hp->h_name));
3082 /* return the DNS name of the client */
3083 char *client_name(void)
3087 struct sockaddr_in *sockin = (struct sockaddr_in *) (&sa);
3088 int length = sizeof(sa);
3089 static pstring name_buf;
3090 static BOOL done = False;
3096 strcpy(name_buf,"UNKNOWN");
3098 if (getpeername(Client, &sa, &length) < 0) {
3099 DEBUG(0,("getpeername failed\n"));
3103 /* Look up the remote host name. */
3104 if ((hp = gethostbyaddr((char *) &sockin->sin_addr,
3105 sizeof(sockin->sin_addr),
3107 DEBUG(1,("Gethostbyaddr failed for %s\n",client_addr()));
3108 StrnCpy(name_buf,client_addr(),sizeof(name_buf) - 1);
3110 StrnCpy(name_buf,(char *)hp->h_name,sizeof(name_buf) - 1);
3111 if (!matchname(name_buf, sockin->sin_addr)) {
3112 DEBUG(0,("Matchname failed on %s %s\n",name_buf,client_addr()));
3113 strcpy(name_buf,"UNKNOWN");
3120 /* return the IP addr of the client as a string */
3121 char *client_addr(void)
3125 struct sockaddr_in *sockin = (struct sockaddr_in *) (&sa);
3126 int length = sizeof(sa);
3127 static fstring addr_buf;
3128 static BOOL done = False;
3133 strcpy(addr_buf,"0.0.0.0");
3135 if (getpeername(Client, &sa, &length) < 0) {
3136 DEBUG(0,("getpeername failed\n"));
3140 strcpy(addr_buf,(char *)inet_ntoa(sockin->sin_addr));
3146 /*******************************************************************
3147 sub strings with useful parameters
3148 ********************************************************************/
3149 void standard_sub_basic(char *s)
3151 if (!strchr(s,'%')) return;
3153 string_sub(s,"%R",remote_proto);
3154 string_sub(s,"%a",remote_arch);
3155 string_sub(s,"%m",remote_machine);
3156 string_sub(s,"%L",local_machine);
3158 if (!strchr(s,'%')) return;
3160 string_sub(s,"%v",VERSION);
3161 string_sub(s,"%h",myhostname);
3162 string_sub(s,"%U",sesssetup_user);
3164 if (!strchr(s,'%')) return;
3166 string_sub(s,"%I",client_addr());
3168 string_sub(s,"%M",client_name());
3169 string_sub(s,"%T",timestring());
3171 if (!strchr(s,'%')) return;
3175 sprintf(pidstr,"%d",(int)getpid());
3176 string_sub(s,"%d",pidstr);
3179 if (!strchr(s,'%')) return;
3182 struct passwd *pass = Get_Pwnam(sesssetup_user,False);
3184 string_sub(s,"%G",gidtoname(pass->pw_gid));
3190 /*******************************************************************
3191 are two IPs on the same subnet?
3192 ********************************************************************/
3193 BOOL same_net(struct in_addr ip1,struct in_addr ip2,struct in_addr mask)
3195 uint32 net1,net2,nmask;
3197 nmask = ntohl(mask.s_addr);
3198 net1 = ntohl(ip1.s_addr);
3199 net2 = ntohl(ip2.s_addr);
3201 return((net1 & nmask) == (net2 & nmask));
3205 /*******************************************************************
3206 write a string in unicoode format
3207 ********************************************************************/
3208 int PutUniCode(char *dst,char *src)
3212 dst[ret++] = src[0];
3221 /****************************************************************************
3222 a wrapper for gethostbyname() that tries with all lower and all upper case
3223 if the initial name fails
3224 ****************************************************************************/
3225 struct hostent *Get_Hostbyname(char *name)
3227 char *name2 = strdup(name);
3228 struct hostent *ret;
3232 DEBUG(0,("Memory allocation error in Get_Hostbyname! panic\n"));
3236 if (!isalnum(*name2))
3242 ret = sys_gethostbyname(name2);
3249 /* try with all lowercase */
3251 ret = sys_gethostbyname(name2);
3258 /* try with all uppercase */
3260 ret = sys_gethostbyname(name2);
3267 /* nothing works :-( */
3273 /****************************************************************************
3274 check if a process exists. Does this work on all unixes?
3275 ****************************************************************************/
3276 BOOL process_exists(int pid)
3280 sprintf(s,"/proc/%d",pid);
3281 return(directory_exist(s,NULL));
3284 static BOOL tested=False;
3285 static BOOL ok=False;
3289 sprintf(s,"/proc/%05d",getpid());
3290 ok = file_exist(s,NULL);
3293 sprintf(s,"/proc/%05d",pid);
3294 return(file_exist(s,NULL));
3298 /* CGH 8/16/96 - added ESRCH test */
3299 return(pid == getpid() || kill(pid,0) == 0 || errno != ESRCH);
3304 /*******************************************************************
3305 turn a uid into a user name
3306 ********************************************************************/
3307 char *uidtoname(int uid)
3309 static char name[40];
3310 struct passwd *pass = getpwuid(uid);
3311 if (pass) return(pass->pw_name);
3312 sprintf(name,"%d",uid);
3316 /*******************************************************************
3317 turn a gid into a group name
3318 ********************************************************************/
3319 char *gidtoname(int gid)
3321 static char name[40];
3322 struct group *grp = getgrgid(gid);
3323 if (grp) return(grp->gr_name);
3324 sprintf(name,"%d",gid);
3328 /*******************************************************************
3330 ********************************************************************/
3331 void BlockSignals(BOOL block,int signum)
3334 int block_mask = sigmask(signum);
3335 static int oldmask = 0;
3337 oldmask = sigblock(block_mask);
3339 sigsetmask(oldmask);
3340 #elif defined(USE_SIGPROCMASK)
3343 sigaddset(&set,signum);
3344 sigprocmask(block?SIG_BLOCK:SIG_UNBLOCK,&set,NULL);
3349 /*******************************************************************
3350 my own panic function - not suitable for general use
3351 ********************************************************************/
3352 void ajt_panic(void)
3354 system("/usr/bin/X11/xedit -display ljus:0 /tmp/ERROR_FAULT");
3359 #define DIRECT direct
3361 #define DIRECT dirent
3364 /*******************************************************************
3365 a readdir wrapper which just returns the file name
3366 also return the inode number if requested
3367 ********************************************************************/
3368 char *readdirname(void *p)
3373 if (!p) return(NULL);
3375 ptr = (struct DIRECT *)readdir(p);
3376 if (!ptr) return(NULL);
3378 dname = ptr->d_name;
3383 unix_to_dos(buf, True);
3388 if (telldir(p) < 0) return(NULL);
3392 /* this handles a broken compiler setup, causing a mixture
3393 of BSD and SYSV headers and libraries */
3395 static BOOL broken_readdir = False;
3396 if (!broken_readdir && !(*(dname)) && strequal("..",dname-2))
3398 DEBUG(0,("Your readdir() is broken. You have somehow mixed SYSV and BSD headers and libraries\n"));
3399 broken_readdir = True;
3410 BOOL is_vetoed_name(char *name)
3412 char *namelist = lp_veto_files();
3413 char *nameptr = namelist;
3416 /* if we have no list it's obviously not vetoed */
3417 if((nameptr == NULL ) || (*nameptr == '\0'))
3420 /* if the name doesn't exist in the list, it's obviously ok too */
3421 if(strstr(namelist,name) == NULL )
3424 /* now, we need to find the names one by one and check them
3425 they can contain spaces and all sorts of stuff so we
3426 separate them with of all things '/' which can never be in a filename
3427 I could use "" but then I have to break them all out
3428 maybe such a routine exists somewhere?
3432 if ( *nameptr == '/' )
3437 if((name_end = strchr(nameptr,'/'))!=NULL)
3441 /* a match! it's veto'd */
3442 if(strcmp(name,nameptr) == 0)
3444 if(name_end == NULL)
3446 /* next segment please */
3447 nameptr = name_end + 1;
3452 BOOL is_vetoed_path(char *name)
3454 char *namelist = lp_veto_files();
3455 char *nameptr = namelist;
3460 /* if we have no list it's obviously not vetoed */
3461 if((nameptr == NULL ) || (*nameptr == '\0'))
3465 /* now, we need to find the names one by one and check them
3466 they can contain spaces and all sorts of stuff so we
3467 separate them with of all things '/' which can never be in a filename
3468 I could use "" but then I have to break them all out
3469 maybe such a routine exists somewhere?
3473 if ( *nameptr == '/' )
3478 if((name_end = strchr(nameptr,'/'))!=NULL)
3483 len = strlen(nameptr);
3485 /* If the name doesn't exist in the path, try the next name.. */
3486 while( sub && ((sub = strstr(sub,nameptr)) != NULL))
3488 /* Is it a whole component? */
3489 if(((sub == name) || (sub[-1] == '/'))
3490 && ((sub[len] == '\0') || (sub[len] == '/')))
3494 /* skip to the next component of the path */
3495 sub =strchr(sub,'/');
3497 if(name_end == NULL)
3499 /* next segment please */
3500 nameptr = name_end + 1;
3505 /****************************************************************************
3506 routine to do file locking
3507 ****************************************************************************/
3508 BOOL fcntl_lock(int fd,int op,uint32 offset,uint32 count,int type)
3515 uint32 mask = 0xC0000000;
3517 /* make sure the count is reasonable, we might kill the lockd otherwise */
3520 /* the offset is often strange - remove 2 of its bits if either of
3521 the top two bits are set. Shift the top ones by two bits. This
3522 still allows OLE2 apps to operate, but should stop lockd from
3524 if ((offset & mask) != 0)
3525 offset = (offset & ~mask) | ((offset & mask) >> 2);
3527 uint32 mask = ((unsigned)1<<31);
3529 /* interpret negative counts as large numbers */
3533 /* no negative offsets */
3536 /* count + offset must be in range */
3537 while ((offset < 0 || (offset + count < 0)) && mask)
3545 DEBUG(5,("fcntl_lock %d %d %d %d %d\n",fd,op,(int)offset,(int)count,type));
3548 lock.l_whence = SEEK_SET;
3549 lock.l_start = (int)offset;
3550 lock.l_len = (int)count;
3555 ret = fcntl(fd,op,&lock);
3558 DEBUG(3,("fcntl lock gave errno %d (%s)\n",errno,strerror(errno)));
3564 (lock.l_type != F_UNLCK) &&
3565 (lock.l_pid != 0) &&
3566 (lock.l_pid != getpid()))
3568 DEBUG(3,("fd %d is locked by pid %d\n",fd,lock.l_pid));
3572 /* it must be not locked or locked by me */
3576 /* a lock set or unset */
3579 DEBUG(3,("lock failed at offset %d count %d op %d type %d (%s)\n",
3580 offset,count,op,type,strerror(errno)));
3582 /* perhaps it doesn't support this sort of locking?? */
3583 if (errno == EINVAL)
3585 DEBUG(3,("locking not supported? returning True\n"));
3592 /* everything went OK */
3593 DEBUG(5,("Lock call successful\n"));
3601 /*******************************************************************
3602 lock a file - returning a open file descriptor or -1 on failure
3603 The timeout is in seconds. 0 means no timeout
3604 ********************************************************************/
3605 int file_lock(char *name,int timeout)
3607 int fd = open(name,O_RDWR|O_CREAT,0666);
3609 if (fd < 0) return(-1);
3612 if (timeout) t = time(NULL);
3613 while (!timeout || (time(NULL)-t < timeout)) {
3614 if (fcntl_lock(fd,F_SETLK,0,1,F_WRLCK)) return(fd);
3615 msleep(LOCK_RETRY_TIMEOUT);
3623 /*******************************************************************
3624 unlock a file locked by file_lock
3625 ********************************************************************/
3626 void file_unlock(int fd)
3630 fcntl_lock(fd,F_SETLK,0,1,F_UNLCK);