/* Unix SMB/Netbios implementation. Version 1.9. Samba utility functions Copyright (C) Andrew Tridgell 1992-1995 This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ #include "includes.h" #include "loadparm.h" pstring scope = ""; int DEBUGLEVEL = 1; BOOL passive = False; int Protocol = PROTOCOL_COREPLUS; int serverzone=0; /* a default finfo structure to ensure all fields are sensible */ file_info def_finfo = {-1,0,0,0,0,0,0,""}; /* these are some file handles where debug info will be stored */ FILE *dbf = NULL; /* the client file descriptor */ int Client = -1; /* info on the client */ struct from_host Client_info= {"UNKNOWN","0.0.0.0",NULL}; /* the last IP received from */ struct in_addr lastip; /* the last port received from */ int lastport=0; /* my IP, the broadcast IP and the Netmask */ struct in_addr myip; struct in_addr bcast_ip; struct in_addr Netmask; int trans_num = 0; /* case handling on filenames */ int case_default = CASE_LOWER; /* size of reads during a direct file to file transfer */ int ReadSize = 16*1024; pstring debugf = "/tmp/log.samba"; int syslog_level; /* the following control case operations - they are put here so the client can link easily */ BOOL case_sensitive; BOOL case_preserve; BOOL use_mangled_map = False; BOOL short_case_preserve; BOOL case_mangle; fstring remote_machine=""; fstring local_machine=""; fstring remote_arch="UNKNOWN"; fstring remote_proto="UNKNOWN"; pstring myhostname=""; pstring user_socket_options=""; pstring sesssetup_user=""; static char *filename_dos(char *path,char *buf); static BOOL stdout_logging = False; /******************************************************************* get ready for syslog stuff ******************************************************************/ void setup_logging(char *pname,BOOL interactive) { #ifdef SYSLOG if (!interactive) { char *p = strrchr(pname,'/'); if (p) pname = p+1; openlog(pname, LOG_PID, LOG_DAEMON); } #endif if (interactive) { stdout_logging = True; dbf = stdout; } } BOOL append_log=False; /**************************************************************************** reopen the log files ****************************************************************************/ void reopen_logs(void) { extern FILE *dbf; pstring fname; if (DEBUGLEVEL > 0) { strcpy(fname,debugf); if (lp_loaded() && (*lp_logfile())) strcpy(fname,lp_logfile()); if (!strcsequal(fname,debugf) || !dbf || !file_exist(debugf,NULL)) { strcpy(debugf,fname); if (dbf) fclose(dbf); if (append_log) dbf = fopen(debugf,"a"); else dbf = fopen(debugf,"w"); if (dbf) setbuf(dbf,NULL); } } else { if (dbf) { fclose(dbf); dbf = NULL; } } } /******************************************************************* write an debug message on the debugfile. This is called by the DEBUG macro ********************************************************************/ #ifdef __STDC__ int Debug1(char *format_str, ...) { #else int Debug1(va_alist) va_dcl { char *format_str; #endif va_list ap; #ifdef __STDC__ va_start(ap, format_str); #else va_start(ap); format_str = va_arg(ap,char *); #endif if (stdout_logging) { vfprintf(dbf,format_str,ap); va_end(ap); return(0); } { static int debug_count=0; debug_count++; if (debug_count == 100) { int maxlog = lp_max_log_size() * 1024; if (dbf && maxlog > 0) { struct stat st; if (fstat(fileno(dbf),&st) == 0 && st.st_size > maxlog) { fclose(dbf); dbf = NULL; reopen_logs(); if (dbf && file_size(debugf) > maxlog) { pstring name; fclose(dbf); dbf = NULL; sprintf(name,"%s.old",debugf); sys_rename(debugf,name); reopen_logs(); } } } debug_count=0; } } #ifdef SYSLOG if (!lp_syslog_only()) #endif { if (!dbf) { dbf = fopen(debugf,"w"); if (dbf) setbuf(dbf,NULL); else return(0); } } #ifdef SYSLOG if (syslog_level < lp_syslog()) { /* * map debug levels to syslog() priorities * note that not all DEBUG(0, ...) calls are * necessarily errors */ static int priority_map[] = { LOG_ERR, /* 0 */ LOG_WARNING, /* 1 */ LOG_NOTICE, /* 2 */ LOG_INFO, /* 3 */ }; int priority; pstring msgbuf; if (syslog_level >= sizeof(priority_map) / sizeof(priority_map[0]) || syslog_level < 0) priority = LOG_DEBUG; else priority = priority_map[syslog_level]; vsprintf(msgbuf, format_str, ap); msgbuf[255] = '\0'; syslog(priority, "%s", msgbuf); } #endif #ifdef SYSLOG if (!lp_syslog_only()) #endif { vfprintf(dbf,format_str,ap); fflush(dbf); } va_end(ap); return(0); } /**************************************************************************** routine to do file locking ****************************************************************************/ BOOL fcntl_lock(int fd,int op,uint32 offset,uint32 count,int type) { #if HAVE_FCNTL_LOCK struct flock lock; int ret; #if 1 uint32 mask = 0xC0000000; /* make sure the count is reasonable, we might kill the lockd otherwise */ count &= ~mask; /* the offset is often strange - remove 2 of its bits if either of the top two bits are set. Shift the top ones by two bits. This still allows OLE2 apps to operate, but should stop lockd from dieing */ if ((offset & mask) != 0) offset = (offset & ~mask) | ((offset & mask) >> 2); #else unsigned long mask = ((unsigned)1<<31); /* interpret negative counts as large numbers */ if (count < 0) count &= ~mask; /* no negative offsets */ offset &= ~mask; /* count + offset must be in range */ while ((offset < 0 || (offset + count < 0)) && mask) { offset &= ~mask; mask = mask >> 1; } #endif DEBUG(5,("fcntl_lock %d %d %d %d %d\n",fd,op,(int)offset,(int)count,type)); lock.l_type = type; lock.l_whence = SEEK_SET; lock.l_start = (int)offset; lock.l_len = (int)count; lock.l_pid = 0; errno = 0; ret = fcntl(fd,op,&lock); if (errno != 0) DEBUG(3,("fcntl lock gave errno %d (%s)\n",errno,strerror(errno))); /* a lock query */ if (op == F_GETLK) { if ((ret != -1) && (lock.l_type != F_UNLCK) && (lock.l_pid != 0) && (lock.l_pid != getpid())) { DEBUG(3,("fd %d is locked by pid %d\n",fd,lock.l_pid)); return(True); } /* it must be not locked or locked by me */ return(False); } /* a lock set or unset */ if (ret == -1) { DEBUG(3,("lock failed at offset %d count %d op %d type %d (%s)\n", offset,count,op,type,strerror(errno))); /* perhaps it doesn't support this sort of locking?? */ if (errno == EINVAL) { DEBUG(3,("locking not supported? returning True\n")); return(True); } return(False); } /* everything went OK */ DEBUG(5,("Lock call successful\n")); return(True); #else return(False); #endif } /******************************************************************* lock a file - returning a open file descriptor or -1 on failure The timeout is in seconds. 0 means no timeout ********************************************************************/ int file_lock(char *name,int timeout) { int fd = open(name,O_RDWR|O_CREAT,0666); time_t t=0; if (fd < 0) return(-1); #if HAVE_FCNTL_LOCK if (timeout) t = time(NULL); while (!timeout || (time(NULL)-t < timeout)) { if (fcntl_lock(fd,F_SETLK,0,1,F_WRLCK)) return(fd); msleep(LOCK_RETRY_TIMEOUT); } return(-1); #else return(fd); #endif } /******************************************************************* unlock a file locked by file_lock ********************************************************************/ void file_unlock(int fd) { if (fd<0) return; #if HAVE_FCNTL_LOCK fcntl_lock(fd,F_SETLK,0,1,F_UNLCK); #endif close(fd); } /******************************************************************* a gettimeofday wrapper ********************************************************************/ void GetTimeOfDay(struct timeval *tval) { #ifdef GETTIMEOFDAY1 gettimeofday(tval); #else gettimeofday(tval,NULL); #endif } int extra_time_offset = 0; static int timediff = 0; /******************************************************************* init the time differences ********************************************************************/ void TimeInit(void) { struct tm tm_utc,tm_local; time_t t; t = time(NULL); tm_utc = *(gmtime(&t)); tm_local = *(localtime(&t)); #ifdef HAVE_GMTOFF timediff = -tm_local.tm_gmtoff; #else timediff = mktime(&tm_utc) - mktime(&tm_local); #endif if (serverzone == 0) { serverzone = timediff - DSTDiff(t); DEBUG(4,("Serverzone is %d\n",serverzone)); } } /******************************************************************* return the DST offset for a particular time We keep a table of DST offsets to prevent calling localtime() on each call of this function. This saves a LOT of time on many unixes. ********************************************************************/ int DSTDiff(time_t t) { static struct dst_table {time_t start,end; BOOL is_dst;} *dst_table = NULL; static int table_size = 0; int i; BOOL is_dst = False; if (t == 0) t = time(NULL); #ifndef NO_ISDST for (i=0;i= dst_table[i].start && t <= dst_table[i].end) break; if (itm_isdst?True:False);; dst_table[i].start = dst_table[i].end = t; /* no entry will cover more than 6 months */ low = t - 3*30*24*60*60; high = t + 3*30*24*60*60; /* widen the new entry using two bisection searches */ while (low+60*60 < dst_table[i].start) { t = low + (dst_table[i].start-low)/2; if ((localtime(&t)->tm_isdst?True:False) == is_dst) dst_table[i].start = t; else low = t; } while (high-60*60 > dst_table[i].end) { t = high + (high-dst_table[i].end)/2; if ((localtime(&t)->tm_isdst?True:False) == is_dst) dst_table[i].end = t; else high = t; } /* DEBUG(1,("Added DST entry from %s ", asctime(localtime(&dst_table[i].start)))); DEBUG(1,("to %s (%d)\n",asctime(localtime(&dst_table[i].end)), dst_table[i].is_dst)); */ } #endif return((is_dst?60*60:0) - (extra_time_offset*60)); } /**************************************************************************** return the difference between local and GMT time ****************************************************************************/ int TimeDiff(time_t t) { static BOOL initialised = False; if (!initialised) {initialised=True; TimeInit();} return(timediff - DSTDiff(t)); } /**************************************************************************** try to optimise the localtime call, it can be quite expenive on some machines timemul is normally LOCAL_TO_GMT, GMT_TO_LOCAL or 0 ****************************************************************************/ struct tm *LocalTime(time_t *t,int timemul) { time_t t2 = *t; if (timemul) t2 += timemul * TimeDiff(t2); return(gmtime(&t2)); } /**************************************************************************** determine if a file descriptor is in fact a socket ****************************************************************************/ BOOL is_a_socket(int fd) { int v,l; l = sizeof(int); return(getsockopt(fd, SOL_SOCKET, SO_TYPE, (char *)&v, &l) == 0); } static char *last_ptr=NULL; /**************************************************************************** Get the next token from a string, return False if none found handles double-quotes. Based on a routine by GJC@VILLAGE.COM. Extensively modified by Andrew.Tridgell@anu.edu.au ****************************************************************************/ BOOL next_token(char **ptr,char *buff,char *sep) { char *s; BOOL quoted; if (!ptr) ptr = &last_ptr; if (!ptr) return(False); s = *ptr; /* default to simple separators */ if (!sep) sep = " \t\n\r"; /* find the first non sep char */ while(*s && strchr(sep,*s)) s++; /* nothing left? */ if (! *s) return(False); /* copy over the token */ for (quoted = False; *s && (quoted || !strchr(sep,*s)); s++) { if (*s == '\"') quoted = !quoted; else *buff++ = *s; } *ptr = (*s) ? s+1 : s; *buff = 0; last_ptr = *ptr; return(True); } /**************************************************************************** Convert list of tokens to array; dependent on above routine. Uses last_ptr from above - bit of a hack. ****************************************************************************/ char **toktocliplist(int *ctok, char *sep) { char *s=last_ptr; int ictok=0; char **ret, **iret; if (!sep) sep = " \t\n\r"; while(*s && strchr(sep,*s)) s++; /* nothing left? */ if (!*s) return(NULL); do { ictok++; while(*s && (!strchr(sep,*s))) s++; while(*s && strchr(sep,*s)) *s++=0; } while(*s); *ctok=ictok; s=last_ptr; if (!(ret=iret=malloc(ictok*sizeof(char *)))) return NULL; while(ictok--) { *iret++=s; while(*s++); while(!*s) s++; } return ret; } #ifndef HAVE_MEMMOVE /******************************************************************* safely copies memory, ensuring no overlap problems. this is only used if the machine does not have it's own memmove(). this is not the fastest algorithm in town, but it will do for our needs. ********************************************************************/ void *MemMove(void *dest,void *src,int size) { unsigned long d,s; int i; if (dest==src || !size) return(dest); d = (unsigned long)dest; s = (unsigned long)src; if ((d >= (s+size)) || (s >= (d+size))) { /* no overlap */ memcpy(dest,src,size); return(dest); } if (d < s) { /* we can forward copy */ if (s-d >= sizeof(int) && !(s%sizeof(int)) && !(d%sizeof(int)) && !(size%sizeof(int))) { /* do it all as words */ int *idest = (int *)dest; int *isrc = (int *)src; size /= sizeof(int); for (i=0;i= sizeof(int) && !(s%sizeof(int)) && !(d%sizeof(int)) && !(size%sizeof(int))) { /* do it all as words */ int *idest = (int *)dest; int *isrc = (int *)src; size /= sizeof(int); for (i=size-1;i>=0;i--) idest[i] = isrc[i]; } else { /* simplest */ char *cdest = (char *)dest; char *csrc = (char *)src; for (i=size-1;i>=0;i--) cdest[i] = csrc[i]; } } return(dest); } #endif /**************************************************************************** prompte a dptr (to make it recently used) ****************************************************************************/ void array_promote(char *array,int elsize,int element) { char *p; if (element == 0) return; p = (char *)malloc(elsize); if (!p) { DEBUG(5,("Ahh! Can't malloc\n")); return; } memcpy(p,array + element * elsize, elsize); memmove(array + elsize,array,elsize*element); memcpy(array,p,elsize); free(p); } enum SOCK_OPT_TYPES {OPT_BOOL,OPT_INT,OPT_ON}; struct { char *name; int level; int option; int value; int opttype; } socket_options[] = { {"SO_KEEPALIVE", SOL_SOCKET, SO_KEEPALIVE, 0, OPT_BOOL}, {"SO_REUSEADDR", SOL_SOCKET, SO_REUSEADDR, 0, OPT_BOOL}, {"SO_BROADCAST", SOL_SOCKET, SO_BROADCAST, 0, OPT_BOOL}, #ifdef TCP_NODELAY {"TCP_NODELAY", IPPROTO_TCP, TCP_NODELAY, 0, OPT_BOOL}, #endif #ifdef IPTOS_LOWDELAY {"IPTOS_LOWDELAY", IPPROTO_IP, IP_TOS, IPTOS_LOWDELAY, OPT_ON}, #endif #ifdef IPTOS_THROUGHPUT {"IPTOS_THROUGHPUT", IPPROTO_IP, IP_TOS, IPTOS_THROUGHPUT, OPT_ON}, #endif #ifdef SO_SNDBUF {"SO_SNDBUF", SOL_SOCKET, SO_SNDBUF, 0, OPT_INT}, #endif #ifdef SO_RCVBUF {"SO_RCVBUF", SOL_SOCKET, SO_RCVBUF, 0, OPT_INT}, #endif #ifdef SO_SNDLOWAT {"SO_SNDLOWAT", SOL_SOCKET, SO_SNDLOWAT, 0, OPT_INT}, #endif #ifdef SO_RCVLOWAT {"SO_RCVLOWAT", SOL_SOCKET, SO_RCVLOWAT, 0, OPT_INT}, #endif {NULL,0,0,0,0}}; /**************************************************************************** set user socket options ****************************************************************************/ void set_socket_options(int fd, char *options) { string tok; while (next_token(&options,tok," \t,")) { int ret=0,i; int value = 1; char *p; BOOL got_value = False; if ((p = strchr(tok,'='))) { *p = 0; value = atoi(p+1); got_value = True; } for (i=0;socket_options[i].name;i++) if (strequal(socket_options[i].name,tok)) break; if (!socket_options[i].name) { DEBUG(0,("Unknown socket option %s\n",tok)); continue; } switch (socket_options[i].opttype) { case OPT_BOOL: case OPT_INT: ret = setsockopt(fd,socket_options[i].level, socket_options[i].option,(char *)&value,sizeof(int)); break; case OPT_ON: if (got_value) DEBUG(0,("syntax error - %s does not take a value\n",tok)); { int on = socket_options[i].value; ret = setsockopt(fd,socket_options[i].level, socket_options[i].option,(char *)&on,sizeof(int)); } break; } if (ret != 0) DEBUG(0,("Failed to set socket option %s\n",tok)); } } /**************************************************************************** close the socket communication ****************************************************************************/ void close_sockets(void ) { close(Client); Client = 0; } /**************************************************************************** return the date and time as a string ****************************************************************************/ char *timestring(void ) { static char TimeBuf[100]; time_t t; t = time(NULL); #ifdef NO_STRFTIME strcpy(TimeBuf, asctime(LocalTime(&t,GMT_TO_LOCAL))); #elif defined(CLIX) || defined(CONVEX) strftime(TimeBuf,100,"%m/%d/%y %I:%M:%S %p",LocalTime(&t,GMT_TO_LOCAL)); #elif defined(AMPM) strftime(TimeBuf,100,"%D %r",LocalTime(&t,GMT_TO_LOCAL)); #elif defined(TZ_TIME) { strftime(TimeBuf,100,"%D:%T",LocalTime(&t,0)); sprintf(TimeBuf+strlen(TimeBuf)," %+03d%02d", -TimeDiff(t)/(60*60),-(TimeDiff(t)/60)%60); } #else strftime(TimeBuf,100,"%D %T",LocalTime(&t,GMT_TO_LOCAL)); #endif return(TimeBuf); } /**************************************************************************** determine whether we are in the specified group ****************************************************************************/ BOOL in_group(gid_t group, int current_gid, int ngroups, int *groups) { int i; if (group == current_gid) return(True); for (i=0;i 30 || len<1) return(0); while (len--) { if (in[0] < 'A' || in[0] > 'P' || in[1] < 'A' || in[1] > 'P') { *out = 0; return(0); } *out = ((in[0]-'A')<<4) + (in[1]-'A'); in += 2; out++; } *out = 0; ret = out[-1]; #ifdef NETBIOS_SCOPE /* Handle any scope names */ while(*in) { *out++ = '.'; /* Scope names are separated by periods */ len = *(unsigned char *)in++; StrnCpy(out, in, len); out += len; *out=0; in += len; } #endif return(ret); } /**************************************************************************** mangle a name into netbios format ****************************************************************************/ int name_mangle(char *In,char *Out,char name_type) { fstring name; char buf[20]; char *in = (char *)&buf[0]; char *out = (char *)Out; char *p, *label; int i; if (In[0] != '*') { StrnCpy(name,In,sizeof(name)-1); sprintf(buf,"%-15.15s%c",name,name_type); } else { buf[0]='*'; memset(&buf[1],0,16); } *out++ = 32; for (i=0;i<16;i++) { char c = toupper(in[i]); out[i*2] = (c>>4) + 'A'; out[i*2+1] = (c & 0xF) + 'A'; } out[32]=0; out += 32; label = scope; while (*label) { p = strchr(label, '.'); if (p == 0) p = label + strlen(label); *out++ = p - label; memcpy(out, label, p - label); out += p - label; label += p - label + (*p == '.'); } *out = 0; return(name_len(Out)); } /******************************************************************* check if a file exists ********************************************************************/ BOOL file_exist(char *fname,struct stat *sbuf) { struct stat st; if (!sbuf) sbuf = &st; if (sys_stat(fname,sbuf) != 0) return(False); return(S_ISREG(sbuf->st_mode)); } /******************************************************************* check a files mod time ********************************************************************/ time_t file_modtime(char *fname) { struct stat st; if (sys_stat(fname,&st) != 0) return(0); return(st.st_mtime); } /******************************************************************* check if a directory exists ********************************************************************/ BOOL directory_exist(char *dname,struct stat *st) { struct stat st2; if (!st) st = &st2; if (sys_stat(dname,st) != 0) return(False); return(S_ISDIR(st->st_mode)); } /******************************************************************* returns the size in bytes of the named file ********************************************************************/ uint32 file_size(char *file_name) { struct stat buf; buf.st_size = 0; sys_stat(file_name,&buf); return(buf.st_size); } /**************************************************************************** check if it's a null mtime ****************************************************************************/ static BOOL null_mtime(time_t mtime) { if (mtime == 0 || mtime == 0xFFFFFFFF) return(True); return(False); } /******************************************************************* create a 16 bit dos packed date ********************************************************************/ static uint16 make_dos_date1(time_t unixdate,struct tm *t) { uint16 ret=0; ret = (((unsigned)(t->tm_mon+1)) >> 3) | ((t->tm_year-80) << 1); ret = ((ret&0xFF)<<8) | (t->tm_mday | (((t->tm_mon+1) & 0x7) << 5)); return(ret); } /******************************************************************* create a 16 bit dos packed time ********************************************************************/ static uint16 make_dos_time1(time_t unixdate,struct tm *t) { uint16 ret=0; ret = ((((unsigned)t->tm_min >> 3)&0x7) | (((unsigned)t->tm_hour) << 3)); ret = ((ret&0xFF)<<8) | ((t->tm_sec/2) | ((t->tm_min & 0x7) << 5)); return(ret); } /******************************************************************* create a 32 bit dos packed date/time from some parameters This takes a GMT time and returns a packed localtime structure ********************************************************************/ static uint32 make_dos_date(time_t unixdate) { struct tm *t; uint32 ret=0; t = LocalTime(&unixdate,GMT_TO_LOCAL); ret = make_dos_date1(unixdate,t); ret = ((ret&0xFFFF)<<16) | make_dos_time1(unixdate,t); return(ret); } /******************************************************************* put a dos date into a buffer (time/date format) This takes GMT time and puts local time in the buffer ********************************************************************/ void put_dos_date(char *buf,int offset,time_t unixdate) { uint32 x = make_dos_date(unixdate); SIVAL(buf,offset,x); } /******************************************************************* put a dos date into a buffer (date/time format) This takes GMT time and puts local time in the buffer ********************************************************************/ void put_dos_date2(char *buf,int offset,time_t unixdate) { uint32 x = make_dos_date(unixdate); x = ((x&0xFFFF)<<16) | ((x&0xFFFF0000)>>16); SIVAL(buf,offset,x); } /******************************************************************* put a dos 32 bit "unix like" date into a buffer. This routine takes GMT and converts it to LOCAL time before putting it (most SMBs assume localtime for this sort of date) ********************************************************************/ void put_dos_date3(char *buf,int offset,time_t unixdate) { if (!null_mtime(unixdate)) unixdate += GMT_TO_LOCAL*TimeDiff(unixdate); SIVAL(buf,offset,unixdate); } /******************************************************************* interpret a 32 bit dos packed date/time to some parameters ********************************************************************/ static void interpret_dos_date(uint32 date,int *year,int *month,int *day,int *hour,int *minute,int *second) { uint32 p0,p1,p2,p3; p0=date&0xFF; p1=((date&0xFF00)>>8)&0xFF; p2=((date&0xFF0000)>>16)&0xFF; p3=((date&0xFF000000)>>24)&0xFF; *second = 2*(p0 & 0x1F); *minute = ((p0>>5)&0xFF) + ((p1&0x7)<<3); *hour = (p1>>3)&0xFF; *day = (p2&0x1F); *month = ((p2>>5)&0xFF) + ((p3&0x1)<<3) - 1; *year = ((p3>>1)&0xFF) + 80; } /******************************************************************* create a unix date (int GMT) from a dos date (which is actually in localtime) ********************************************************************/ time_t make_unix_date(void *date_ptr) { uint32 dos_date=0; struct tm t; time_t ret; dos_date = IVAL(date_ptr,0); if (dos_date == 0) return(0); interpret_dos_date(dos_date,&t.tm_year,&t.tm_mon, &t.tm_mday,&t.tm_hour,&t.tm_min,&t.tm_sec); t.tm_wday = 1; t.tm_yday = 1; t.tm_isdst = -1; /* mktime() also does the local to GMT time conversion for us. XXXXX Do all unixes do this the same?? */ ret = mktime(&t); return(ret); } /******************************************************************* like make_unix_date() but the words are reversed ********************************************************************/ time_t make_unix_date2(void *date_ptr) { uint32 x,x2; x = IVAL(date_ptr,0); x2 = ((x&0xFFFF)<<16) | ((x&0xFFFF0000)>>16); SIVAL(&x,0,x2); return(make_unix_date((void *)&x)); } /******************************************************************* create a unix GMT date from a dos date in 32 bit "unix like" format these generally arrive as localtimes, with corresponding DST ********************************************************************/ time_t make_unix_date3(void *date_ptr) { time_t t = IVAL(date_ptr,0); if (!null_mtime(t)) t += LOCAL_TO_GMT*TimeDiff(t); return(t); } /******************************************************************* return a string representing an attribute for a file ********************************************************************/ char *attrib_string(int mode) { static char attrstr[10]; attrstr[0] = 0; if (mode & aVOLID) strcat(attrstr,"V"); if (mode & aDIR) strcat(attrstr,"D"); if (mode & aARCH) strcat(attrstr,"A"); if (mode & aHIDDEN) strcat(attrstr,"H"); if (mode & aSYSTEM) strcat(attrstr,"S"); if (mode & aRONLY) strcat(attrstr,"R"); return(attrstr); } /******************************************************************* case insensitive string compararison ********************************************************************/ int StrCaseCmp(char *s, char *t) { for (; tolower(*s) == tolower(*t); ++s, ++t) if (!*s) return 0; return tolower(*s) - tolower(*t); } /******************************************************************* case insensitive string compararison, length limited ********************************************************************/ int StrnCaseCmp(char *s, char *t, int n) { while (n-- && *s && *t) { if (tolower(*s) != tolower(*t)) return(tolower(*s) - tolower(*t)); s++; t++; } if (n) return(tolower(*s) - tolower(*t)); return(0); } /******************************************************************* compare 2 strings ********************************************************************/ BOOL strequal(char *s1,char *s2) { if (s1 == s2) return(True); if (!s1 || !s2) return(False); return(StrCaseCmp(s1,s2)==0); } /******************************************************************* compare 2 strings up to and including the nth char. ******************************************************************/ BOOL strnequal(char *s1,char *s2,int n) { if (s1 == s2) return(True); if (!s1 || !s2 || !n) return(False); return(StrnCaseCmp(s1,s2,n)==0); } /******************************************************************* compare 2 strings (case sensitive) ********************************************************************/ BOOL strcsequal(char *s1,char *s2) { if (s1 == s2) return(True); if (!s1 || !s2) return(False); return(strcmp(s1,s2)==0); } /******************************************************************* convert a string to lower case ********************************************************************/ void strlower(char *s) { while (*s) { #ifdef KANJI if (is_shift_jis (*s)) { s += 2; } else if (is_kana (*s)) { s++; } else { if (isupper(*s)) *s = tolower(*s); s++; } #else if (isupper(*s)) *s = tolower(*s); s++; #endif /* KANJI */ } } /******************************************************************* convert a string to upper case ********************************************************************/ void strupper(char *s) { while (*s) { #ifdef KANJI if (is_shift_jis (*s)) { s += 2; } else if (is_kana (*s)) { s++; } else { if (islower(*s)) *s = toupper(*s); s++; } #else if (islower(*s)) *s = toupper(*s); s++; #endif } } /******************************************************************* convert a string to "normal" form ********************************************************************/ void strnorm(char *s) { if (case_default == CASE_UPPER) strupper(s); else strlower(s); } /******************************************************************* check if a string is in "normal" case ********************************************************************/ BOOL strisnormal(char *s) { if (case_default == CASE_UPPER) return(!strhaslower(s)); return(!strhasupper(s)); } /**************************************************************************** string replace ****************************************************************************/ void string_replace(char *s,char oldc,char newc) { while (*s) { #ifdef KANJI if (is_shift_jis (*s)) { s += 2; } else if (is_kana (*s)) { s++; } else { if (oldc == *s) *s = newc; s++; } #else if (oldc == *s) *s = newc; s++; #endif /* KANJI */ } } /**************************************************************************** make a file into unix format ****************************************************************************/ void unix_format(char *fname) { pstring namecopy; string_replace(fname,'\\','/'); #ifndef KANJI dos2unix_format(fname, True); #endif /* KANJI */ if (*fname == '/') { strcpy(namecopy,fname); strcpy(fname,"."); strcat(fname,namecopy); } } /**************************************************************************** make a file into dos format ****************************************************************************/ void dos_format(char *fname) { #ifndef KANJI unix2dos_format(fname, True); #endif /* KANJI */ string_replace(fname,'/','\\'); } /******************************************************************* show a smb message structure ********************************************************************/ void show_msg(char *buf) { int i; int bcc=0; if (DEBUGLEVEL < 5) return; DEBUG(5,("size=%d\nsmb_com=0x%x\nsmb_rcls=%d\nsmb_reh=%d\nsmb_err=%d\nsmb_flg=%d\nsmb_flg2=%d\n", smb_len(buf), (int)CVAL(buf,smb_com), (int)CVAL(buf,smb_rcls), (int)CVAL(buf,smb_reh), (int)SVAL(buf,smb_err), (int)CVAL(buf,smb_flg), (int)SVAL(buf,smb_flg2))); DEBUG(5,("smb_tid=%d\nsmb_pid=%d\nsmb_uid=%d\nsmb_mid=%d\nsmt_wct=%d\n", (int)SVAL(buf,smb_tid), (int)SVAL(buf,smb_pid), (int)SVAL(buf,smb_uid), (int)SVAL(buf,smb_mid), (int)CVAL(buf,smb_wct))); for (i=0;i<(int)CVAL(buf,smb_wct);i++) DEBUG(5,("smb_vwv[%d]=%d (0x%X)\n",i, SVAL(buf,smb_vwv+2*i),SVAL(buf,smb_vwv+2*i))); bcc = (int)SVAL(buf,smb_vwv+2*(CVAL(buf,smb_wct))); DEBUG(5,("smb_bcc=%d\n",bcc)); if (DEBUGLEVEL < 10) return; for (i=0;i>16; buf[2] = (len&0xFF00)>>8; buf[3] = len&0xFF; } /******************************************************************* set the length and marker of an smb packet ********************************************************************/ void smb_setlen(char *buf,int len) { _smb_setlen(buf,len); CVAL(buf,4) = 0xFF; CVAL(buf,5) = 'S'; CVAL(buf,6) = 'M'; CVAL(buf,7) = 'B'; } /******************************************************************* setup the word count and byte count for a smb message ********************************************************************/ int set_message(char *buf,int num_words,int num_bytes,BOOL zero) { if (zero) bzero(buf + smb_size,num_words*2 + num_bytes); CVAL(buf,smb_wct) = num_words; SSVAL(buf,smb_vwv + num_words*SIZEOFWORD,num_bytes); smb_setlen(buf,smb_size + num_words*2 + num_bytes - 4); return (smb_size + num_words*2 + num_bytes); } /******************************************************************* return the number of smb words ********************************************************************/ int smb_numwords(char *buf) { return (CVAL(buf,smb_wct)); } /******************************************************************* return the size of the smb_buf region of a message ********************************************************************/ int smb_buflen(char *buf) { return(SVAL(buf,smb_vwv0 + smb_numwords(buf)*2)); } /******************************************************************* return a pointer to the smb_buf data area ********************************************************************/ int smb_buf_ofs(char *buf) { return (smb_size + CVAL(buf,smb_wct)*2); } /******************************************************************* return a pointer to the smb_buf data area ********************************************************************/ char *smb_buf(char *buf) { return (buf + smb_buf_ofs(buf)); } /******************************************************************* return the SMB offset into an SMB buffer ********************************************************************/ int smb_offset(char *p,char *buf) { return(PTR_DIFF(p,buf+4)); } /******************************************************************* skip past some strings in a buffer ********************************************************************/ char *skip_string(char *buf,int n) { while (n--) buf += strlen(buf) + 1; return(buf); } /******************************************************************* trim the specified elements off the front and back of a string ********************************************************************/ BOOL trim_string(char *s,char *front,char *back) { BOOL ret = False; while (front && *front && strncmp(s,front,strlen(front)) == 0) { char *p = s; ret = True; while (1) { if (!(*p = p[strlen(front)])) break; p++; } } while (back && *back && strlen(s) >= strlen(back) && (strncmp(s+strlen(s)-strlen(back),back,strlen(back))==0)) { ret = True; s[strlen(s)-strlen(back)] = 0; } return(ret); } /******************************************************************* reduce a file name, removing .. elements. ********************************************************************/ void dos_clean_name(char *s) { char *p=NULL; DEBUG(3,("dos_clean_name [%s]\n",s)); /* remove any double slashes */ string_sub(s, "\\\\", "\\"); while ((p = strstr(s,"\\..\\")) != NULL) { pstring s1; *p = 0; strcpy(s1,p+3); if ((p=strrchr(s,'\\')) != NULL) *p = 0; else *s = 0; strcat(s,s1); } trim_string(s,NULL,"\\.."); string_sub(s, "\\.\\", "\\"); } /******************************************************************* reduce a file name, removing .. elements. ********************************************************************/ void unix_clean_name(char *s) { char *p=NULL; DEBUG(3,("unix_clean_name [%s]\n",s)); /* remove any double slashes */ string_sub(s, "//","/"); while ((p = strstr(s,"/../")) != NULL) { pstring s1; *p = 0; strcpy(s1,p+3); if ((p=strrchr(s,'/')) != NULL) *p = 0; else *s = 0; strcat(s,s1); } trim_string(s,NULL,"/.."); } /******************************************************************* a wrapper for the normal chdir() function ********************************************************************/ int ChDir(char *path) { int res; static pstring LastDir=""; if (strcsequal(path,".")) return(0); if (*path == '/' && strcsequal(LastDir,path)) return(0); DEBUG(3,("chdir to %s\n",path)); res = sys_chdir(path); if (!res) strcpy(LastDir,path); return(res); } /******************************************************************* return the absolute current directory path. A dumb version. ********************************************************************/ static char *Dumb_GetWd(char *s) { #ifdef USE_GETCWD return ((char *)getcwd(s,sizeof(pstring))); #else return ((char *)getwd(s)); #endif } /* number of list structures for a caching GetWd function. */ #define MAX_GETWDCACHE (50) struct { ino_t inode; dev_t dev; char *text; BOOL valid; } ino_list[MAX_GETWDCACHE]; BOOL use_getwd_cache=True; /******************************************************************* return the absolute current directory path ********************************************************************/ char *GetWd(char *str) { pstring s; static BOOL getwd_cache_init = False; struct stat st, st2; int i; *s = 0; if (!use_getwd_cache) return(Dumb_GetWd(str)); /* init the cache */ if (!getwd_cache_init) { getwd_cache_init = True; for (i=0;i 8) { strcpy(mext,mbeg + 8); mbeg[8] = 0; } } if (*mbeg == 0) strcpy(mbeg,"????????"); if ((*mext == 0) && doext && !hasdot) strcpy(mext,"???"); if (strequal(mbeg,"*") && *mext==0) strcpy(mext,"*"); /* expand *'s */ expand_one(mbeg,8); if (*mext) expand_one(mext,3); strcpy(Mask,dirpart); if (*dirpart || absolute) strcat(Mask,"\\"); strcat(Mask,mbeg); strcat(Mask,"."); strcat(Mask,mext); DEBUG(6,("Mask expanded to [%s]\n",Mask)); } /**************************************************************************** does a string have any uppercase chars in it? ****************************************************************************/ BOOL strhasupper(char *s) { while (*s) { #ifdef KANJI if (is_shift_jis (*s)) { s += 2; } else if (is_kana (*s)) { s++; } else { if (isupper(*s)) return(True); s++; } #else if (isupper(*s)) return(True); s++; #endif /* KANJI */ } return(False); } /**************************************************************************** does a string have any lowercase chars in it? ****************************************************************************/ BOOL strhaslower(char *s) { while (*s) { #ifdef KANJI if (is_shift_jis (*s)) { s += 2; } else if (is_kana (*s)) { s++; } else { if (islower(*s)) return(True); s++; } #else if (islower(*s)) return(True); s++; #endif /* KANJI */ } return(False); } /**************************************************************************** find the number of chars in a string ****************************************************************************/ int count_chars(char *s,char c) { int count=0; while (*s) { if (*s == c) count++; s++; } return(count); } /**************************************************************************** make a dir struct ****************************************************************************/ void make_dir_struct(char *buf,char *mask,char *fname,unsigned int size,int mode,time_t date) { char *p; pstring mask2; strcpy(mask2,mask); if ((mode & aDIR) != 0) size = 0; memset(buf+1,' ',11); if ((p = strchr(mask2,'.')) != NULL) { *p = 0; memcpy(buf+1,mask2,MIN(strlen(mask2),8)); memcpy(buf+9,p+1,MIN(strlen(p+1),3)); *p = '.'; } else memcpy(buf+1,mask2,MIN(strlen(mask2),11)); bzero(buf+21,DIR_STRUCT_SIZE-21); CVAL(buf,21) = mode; put_dos_date(buf,22,date); SSVAL(buf,26,size & 0xFFFF); SSVAL(buf,28,size >> 16); StrnCpy(buf+30,fname,12); if (!case_sensitive) strupper(buf+30); DEBUG(8,("put name [%s] into dir struct\n",buf+30)); } /******************************************************************* close the low 3 fd's and open dev/null in their place ********************************************************************/ void close_low_fds(void) { int fd; int i; close(0); close(1); close(2); /* try and use up these file descriptors, so silly library routines writing to stdout etc won't cause havoc */ for (i=0;i<3;i++) { fd = open("/dev/null",O_RDWR,0); if (fd < 0) fd = open("/dev/null",O_WRONLY,0); if (fd < 0) { DEBUG(0,("Can't open /dev/null\n")); return; } if (fd != i) { DEBUG(0,("Didn't get file descriptor %d\n",i)); return; } } } /**************************************************************************** write to a socket ****************************************************************************/ int write_socket(int fd,char *buf,int len) { int ret=0; if (passive) return(len); DEBUG(6,("write_socket(%d,%d)\n",fd,len)); ret = write_data(fd,buf,len); DEBUG(6,("write_socket(%d,%d) wrote %d\n",fd,len,ret)); return(ret); } /**************************************************************************** read from a socket ****************************************************************************/ int read_udp_socket(int fd,char *buf,int len) { int ret; struct sockaddr sock; int socklen; socklen = sizeof(sock); bzero((char *)&sock,socklen); bzero((char *)&lastip,sizeof(lastip)); ret = recvfrom(fd,buf,len,0,&sock,&socklen); if (ret <= 0) { DEBUG(2,("read socket failed. ERRNO=%d\n",errno)); return(0); } lastip = *(struct in_addr *) &sock.sa_data[2]; lastport = ntohs(((struct sockaddr_in *)&sock)->sin_port); return(ret); } /**************************************************************************** Set a fd into blocking/nonblocking mode. Uses POSIX O_NONBLOCK if available, else if SYSV use O_NDELAY if BSD use FNDELAY ****************************************************************************/ int set_blocking(int fd, BOOL set) { int val; #ifdef O_NONBLOCK #define FLAG_TO_SET O_NONBLOCK #else #ifdef SYSV #define FLAG_TO_SET O_NDELAY #else /* BSD */ #define FLAG_TO_SET FNDELAY #endif #endif if((val = fcntl(fd, F_GETFL, 0))==-1) return -1; if(set) /* Turn blocking on - ie. clear nonblock flag */ val &= ~FLAG_TO_SET; else val |= FLAG_TO_SET; return fcntl( fd, F_SETFL, val); #undef FLAG_TO_SET } /**************************************************************************** Calculate the difference in timeout values. Return 1 if val1 > val2, 0 if val1 == val2, -1 if val1 < val2. Stores result in retval. retval may be == val1 or val2 ****************************************************************************/ static int tval_sub( struct timeval *retval, struct timeval *val1, struct timeval *val2) { int usecdiff = val1->tv_usec - val2->tv_usec; int secdiff = val1->tv_sec - val2->tv_sec; if(usecdiff < 0) { usecdiff = 1000000 + usecdiff; secdiff--; } retval->tv_sec = secdiff; retval->tv_usec = usecdiff; if(secdiff < 0) return -1; if(secdiff > 0) return 1; return (usecdiff < 0 ) ? -1 : ((usecdiff > 0 ) ? 1 : 0); } /**************************************************************************** read data from a device with a timout in msec. mincount = if timeout, minimum to read before returning maxcount = number to be read. ****************************************************************************/ int read_with_timeout(int fd,char *buf,int mincnt,int maxcnt,long time_out,BOOL exact) { fd_set fds; int selrtn; int readret; int nread = 0; struct timeval timeout, tval1, tval2, tvaldiff; int error_limit = 5; /* just checking .... */ if (maxcnt <= 0) return(0); if(time_out == -2) time_out = DEFAULT_PIPE_TIMEOUT; /* Blocking read */ if(time_out < 0) { if (mincnt == 0) mincnt = maxcnt; while (nread < mincnt) { readret = read(fd, buf + nread, maxcnt - nread); if (readret <= 0) return(nread); nread += readret; } return(nread); } /* Non blocking read */ if(time_out == 0) { set_blocking(fd, False); nread = read_data(fd, buf, mincnt); if (nread < maxcnt) nread += read(fd,buf+nread,maxcnt-nread); if(nread == -1 && errno == EWOULDBLOCK) nread = 0; set_blocking(fd,True); return nread; } /* Most difficult - timeout read */ /* If this is ever called on a disk file and mincnt is greater then the filesize then system performance will suffer severely as select always return true on disk files */ /* Set initial timeout */ timeout.tv_sec = time_out / 1000; timeout.tv_usec = 1000 * (time_out % 1000); /* As most UNIXes don't modify the value of timeout when they return from select we need to get the timeofday (in usec) now, and also after the select returns so we know how much time has elapsed */ if (exact) GetTimeOfDay( &tval1); nread = 0; /* Number of bytes we have read */ for(;;) { FD_ZERO(&fds); FD_SET(fd,&fds); selrtn = sys_select(&fds,&timeout); /* Check if error */ if(selrtn == -1) { errno = EBADF; return -1; } /* Did we timeout ? */ if (selrtn == 0) { if (nread < mincnt) return -1; break; /* Yes */ } readret = read(fd, buf+nread, maxcnt-nread); if (readret == 0 && nread < mincnt) { /* error_limit should not really be needed, but some systems do strange things ... I don't want to just continue indefinately in case we get an infinite loop */ if (error_limit--) continue; return(-1); } if (readret < 0) { /* force a particular error number for portability */ DEBUG(5,("read gave error %s\n",strerror(errno))); errno = EBADF; return -1; } nread += readret; /* If we have read more than mincnt then return */ if (nread >= mincnt) break; /* We need to do another select - but first reduce the time_out by the amount of time already elapsed - if this is less than zero then return */ if (exact) { GetTimeOfDay(&tval2); (void)tval_sub( &tvaldiff, &tval2, &tval1); if (tval_sub(&timeout, &timeout, &tvaldiff) <= 0) break; /* We timed out */ } /* Save the time of day as we need to do the select again (saves a system call) */ tval1 = tval2; } /* Return the number we got */ return(nread); } /**************************************************************************** read data from the client. Maxtime is in milliseconds ****************************************************************************/ int read_max_udp(int fd,char *buffer,int bufsize,int maxtime) { fd_set fds; int selrtn; int nread; struct timeval timeout; FD_ZERO(&fds); FD_SET(fd,&fds); timeout.tv_sec = maxtime / 1000; timeout.tv_usec = (maxtime % 1000) * 1000; selrtn = sys_select(&fds,maxtime>0?&timeout:NULL); if (!FD_ISSET(fd,&fds)) return 0; nread = read_udp_socket(fd, buffer, bufsize); /* return the number got */ return(nread); } /******************************************************************* find the difference in milliseconds between two struct timeval values ********************************************************************/ int TvalDiff(struct timeval *tvalold,struct timeval *tvalnew) { return((tvalnew->tv_sec - tvalold->tv_sec)*1000 + ((int)tvalnew->tv_usec - (int)tvalold->tv_usec)/1000); } /**************************************************************************** send a keepalive packet (rfc1002) ****************************************************************************/ BOOL send_keepalive(int client) { unsigned char buf[4]; buf[0] = 0x85; buf[1] = buf[2] = buf[3] = 0; return(write_data(client,(char *)buf,4) == 4); } /**************************************************************************** read data from the client, reading exactly N bytes. ****************************************************************************/ int read_data(int fd,char *buffer,int N) { int ret; int total=0; while (total < N) { ret = read(fd,buffer + total,N - total); /* this is for portability */ if (ret < 0) errno = EBADF; if (ret <= 0) return total; total += ret; } return total; } /**************************************************************************** write data to a fd ****************************************************************************/ int write_data(int fd,char *buffer,int N) { int total=0; int ret; while (total < N) { ret = write(fd,buffer + total,N - total); if (ret <= 0) return total; total += ret; } return total; } /* variables used by the read prediction module */ int rp_fd = -1; int rp_offset = 0; int rp_length = 0; int rp_alloced = 0; int rp_predict_fd = -1; int rp_predict_offset = 0; int rp_predict_length = 0; int rp_timeout = 5; time_t rp_time = 0; char *rp_buffer = NULL; BOOL predict_skip=False; time_t smb_last_time=(time_t)0; /**************************************************************************** handle read prediction on a file ****************************************************************************/ int read_predict(int fd,int offset,char *buf,char **ptr,int num) { int ret = 0; int possible = rp_length - (offset - rp_offset); possible = MIN(possible,num); /* give data if possible */ if (fd == rp_fd && offset >= rp_offset && possible>0 && smb_last_time-rp_time < rp_timeout) { ret = possible; if (buf) memcpy(buf,rp_buffer + (offset-rp_offset),possible); else *ptr = rp_buffer + (offset-rp_offset); DEBUG(5,("read-prediction gave %d bytes of %d\n",ret,num)); } if (ret == num) { predict_skip = True; } else { predict_skip = False; /* prepare the next prediction */ rp_predict_fd = fd; rp_predict_offset = offset + num; rp_predict_length = num; } if (ret < 0) ret = 0; return(ret); } /**************************************************************************** pre-read some data ****************************************************************************/ void do_read_prediction() { if (predict_skip) return; if (rp_predict_fd == -1) return; rp_fd = rp_predict_fd; rp_offset = rp_predict_offset; rp_length = 0; rp_predict_fd = -1; rp_predict_length = MIN(rp_predict_length,2*ReadSize); rp_predict_length = MAX(rp_predict_length,1024); rp_offset = (rp_offset/1024)*1024; rp_predict_length = (rp_predict_length/1024)*1024; if (rp_predict_length > rp_alloced) { rp_buffer = Realloc(rp_buffer,rp_predict_length); rp_alloced = rp_predict_length; if (!rp_buffer) { DEBUG(0,("can't allocate read-prediction buffer\n")); rp_predict_fd = -1; rp_fd = -1; rp_alloced = 0; return; } } if (lseek(rp_fd,rp_offset,SEEK_SET) != rp_offset) { rp_fd = -1; rp_predict_fd = -1; return; } rp_length = read(rp_fd,rp_buffer,rp_predict_length); rp_time = time(NULL); if (rp_length < 0) rp_length = 0; } /**************************************************************************** invalidate read-prediction on a fd ****************************************************************************/ void invalidate_read_prediction(int fd) { if (rp_fd == fd) rp_fd = -1; if (rp_predict_fd == fd) rp_predict_fd = -1; } /**************************************************************************** transfer some data between two fd's ****************************************************************************/ int transfer_file(int infd,int outfd,int n,char *header,int headlen,int align) { static char *buf=NULL; char *buf1,*abuf; static int size = 0; int total = 0; DEBUG(4,("transfer_file %d (head=%d) called\n",n,headlen)); if ((size < ReadSize) && buf) { free(buf); buf = NULL; } size = MAX(ReadSize,1024); while (!buf && size>0) { buf = (char *)Realloc(buf,size+8); if (!buf) size /= 2; } if (!buf) { DEBUG(0,("Can't allocate transfer buffer!\n")); exit(1); } abuf = buf + (align%8); if (header) n += headlen; while (n > 0) { int s = MIN(n,size); int ret,ret2=0; ret = 0; if (header && (headlen >= MIN(s,1024))) { buf1 = header; s = headlen; ret = headlen; headlen = 0; header = NULL; } else { buf1 = abuf; } if (header && headlen > 0) { ret = MIN(headlen,size); memcpy(buf1,header,ret); headlen -= ret; header += ret; if (headlen <= 0) header = NULL; } if (s > ret) ret += read(infd,buf1+ret,s-ret); if (ret > 0) { ret2 = (outfd>=0?write_data(outfd,buf1,ret):ret); if (ret2 > 0) total += ret2; /* if we can't write then dump excess data */ if (ret2 != ret) transfer_file(infd,-1,n-(ret+headlen),NULL,0,0); } if (ret <= 0 || ret2 != ret) return(total); n -= ret; } return(total); } /**************************************************************************** read 4 bytes of a smb packet and return the smb length of the packet possibly store the result in the buffer ****************************************************************************/ int read_smb_length(int fd,char *inbuf,int timeout) { char *buffer; char buf[4]; int len=0, msg_type; BOOL ok=False; if (inbuf) buffer = inbuf; else buffer = buf; while (!ok) { if (timeout > 0) ok = (read_with_timeout(fd,buffer,4,4,timeout,False) == 4); else ok = (read_data(fd,buffer,4) == 4); if (!ok) { if (timeout>0) { DEBUG(10,("select timeout (%d)\n", timeout)); return(-1); } else { DEBUG(6,("couldn't read from client\n")); exit(1); } } len = smb_len(buffer); msg_type = CVAL(buffer,0); if (msg_type == 0x85) { DEBUG(5,( "Got keepalive packet\n")); ok = False; } } DEBUG(10,("got smb length of %d\n",len)); return(len); } /**************************************************************************** read an smb from a fd and return it's length The timeout is in milli seconds ****************************************************************************/ BOOL receive_smb(int fd,char *buffer,int timeout) { int len; BOOL ok; bzero(buffer,smb_size + 100); len = read_smb_length(fd,buffer,timeout); if (len == -1) return(False); if (len > BUFFER_SIZE) { DEBUG(0,("Invalid packet length! (%d bytes)\n",len)); if (len > BUFFER_SIZE + (SAFETY_MARGIN/2)) exit(1); } ok = (read_data(fd,buffer+4,len) == len); if (!ok) { close_sockets(); exit(1); } return(True); } /**************************************************************************** send an smb to a fd ****************************************************************************/ BOOL send_smb(int fd,char *buffer) { int len; int ret,nwritten=0; len = smb_len(buffer) + 4; while (nwritten < len) { ret = write_socket(fd,buffer+nwritten,len - nwritten); if (ret <= 0) { DEBUG(0,("Error writing %d bytes to client. %d. Exiting\n",len,ret)); close_sockets(); exit(1); } nwritten += ret; } return True; } /**************************************************************************** find a pointer to a netbios name ****************************************************************************/ char *name_ptr(char *buf,int ofs) { unsigned char c = *(unsigned char *)(buf+ofs); if ((c & 0xC0) == 0xC0) { uint16 l; char p[2]; memcpy(p,buf+ofs,2); p[0] &= ~0xC0; l = RSVAL(p,0); DEBUG(5,("name ptr to pos %d from %d is %s\n",l,ofs,buf+l)); return(buf + l); } else return(buf+ofs); } /**************************************************************************** extract a netbios name from a buf ****************************************************************************/ int name_extract(char *buf,int ofs,char *name) { char *p = name_ptr(buf,ofs); int d = PTR_DIFF(p,buf+ofs); strcpy(name,""); if (d < -50 || d > 50) return(0); return(name_interpret(p,name)); } /**************************************************************************** return the total storage length of a mangled name ****************************************************************************/ int name_len(char *s) { char *s0=s; unsigned char c = *(unsigned char *)s; if ((c & 0xC0) == 0xC0) return(2); while (*s) s += (*s)+1; return(PTR_DIFF(s,s0)+1); } /**************************************************************************** send a single packet to a port on another machine ****************************************************************************/ BOOL send_one_packet(char *buf,int len,struct in_addr ip,int port,int type) { BOOL ret; int out_fd; struct sockaddr_in sock_out; if (passive) return(True); /* create a socket to write to */ out_fd = socket(AF_INET, type, 0); if (out_fd == -1) { DEBUG(0,("socket failed")); return False; } /* set the address and port */ bzero((char *)&sock_out,sizeof(sock_out)); putip((char *)&sock_out.sin_addr,(char *)&ip); sock_out.sin_port = htons( port ); sock_out.sin_family = AF_INET; if (DEBUGLEVEL > 0) DEBUG(3,("sending a packet of len %d to (%s) on port %d of type %s\n", len,inet_ntoa(ip),port,type==SOCK_DGRAM?"DGRAM":"STREAM")); /* send it */ ret = (sendto(out_fd,buf,len,0,(struct sockaddr *)&sock_out,sizeof(sock_out)) >= 0); if (!ret) DEBUG(0,("Packet send to %s(%d) failed ERRNO=%d\n", inet_ntoa(ip),port,errno)); close(out_fd); return(ret); } /******************************************************************* sleep for a specified number of milliseconds ********************************************************************/ void msleep(int t) { int tdiff=0; struct timeval tval,t1,t2; fd_set fds; GetTimeOfDay(&t1); GetTimeOfDay(&t2); while (tdiff < t) { tval.tv_sec = (t-tdiff)/1000; tval.tv_usec = 1000*((t-tdiff)%1000); FD_ZERO(&fds); errno = 0; sys_select(&fds,&tval); GetTimeOfDay(&t2); tdiff = TvalDiff(&t1,&t2); } } /**************************************************************************** check if a string is part of a list ****************************************************************************/ BOOL in_list(char *s,char *list,BOOL casesensitive) { pstring tok; char *p=list; if (!list) return(False); while (next_token(&p,tok,LIST_SEP)) { if (casesensitive) { if (strcmp(tok,s) == 0) return(True); } else { if (StrCaseCmp(tok,s) == 0) return(True); } } return(False); } /* this is used to prevent lots of mallocs of size 1 */ static char *null_string = NULL; /**************************************************************************** set a string value, allocing the space for the string ****************************************************************************/ BOOL string_init(char **dest,char *src) { int l; if (!src) src = ""; l = strlen(src); if (l == 0) { if (!null_string) null_string = (char *)malloc(1); *null_string = 0; *dest = null_string; } else { *dest = (char *)malloc(l+1); strcpy(*dest,src); } return(True); } /**************************************************************************** free a string value ****************************************************************************/ void string_free(char **s) { if (!s || !(*s)) return; if (*s == null_string) *s = NULL; if (*s) free(*s); *s = NULL; } /**************************************************************************** set a string value, allocing the space for the string, and deallocating any existing space ****************************************************************************/ BOOL string_set(char **dest,char *src) { string_free(dest); return(string_init(dest,src)); } /**************************************************************************** substitute a string for a pattern in another string. Make sure there is enough room! This routine looks for pattern in s and replaces it with insert. It may do multiple replacements. return True if a substitution was done. ****************************************************************************/ BOOL string_sub(char *s,char *pattern,char *insert) { BOOL ret = False; char *p; int ls,lp,li; if (!insert || !pattern || !s) return(False); ls = strlen(s); lp = strlen(pattern); li = strlen(insert); if (!*pattern) return(False); while (lp <= ls && (p = strstr(s,pattern))) { ret = True; memmove(p+li,p+lp,ls + 1 - (PTR_DIFF(p,s) + lp)); memcpy(p,insert,li); s = p + li; ls = strlen(s); } return(ret); } /********************************************************* * Recursive routine that is called by mask_match. * Does the actual matching. *********************************************************/ BOOL do_match(char *str, char *regexp, int case_sig) { char *p; for( p = regexp; *p && *str; ) { switch(*p) { case '?': str++; p++; break; case '*': /* Look for a character matching the one after the '*' */ p++; if(!*p) return True; /* Automatic match */ while(*str) { while(*str && (case_sig ? (*p != *str) : (toupper(*p)!=toupper(*str)))) str++; if(do_match(str,p,case_sig)) return True; if(!*str) return False; else str++; } return False; default: if(case_sig) { if(*str != *p) return False; } else { if(toupper(*str) != toupper(*p)) return False; } str++, p++; break; } } if(!*p && !*str) return True; if (!*p && str[0] == '.' && str[1] == 0) return(True); if (!*str && *p == '?') { while (*p == '?') p++; return(!*p); } if(!*str && (*p == '*' && p[1] == '\0')) return True; return False; } /********************************************************* * Routine to match a given string with a regexp - uses * simplified regexp that takes * and ? only. Case can be * significant or not. *********************************************************/ BOOL mask_match(char *str, char *regexp, int case_sig,BOOL trans2) { char *p; pstring p1, p2; fstring ebase,eext,sbase,sext; BOOL matched; /* Make local copies of str and regexp */ StrnCpy(p1,regexp,sizeof(pstring)-1); StrnCpy(p2,str,sizeof(pstring)-1); if (!strchr(p2,'.')) { strcat(p2,"."); } /* if (!strchr(p1,'.')) { strcat(p1,"."); } */ #if 0 if (strchr(p1,'.')) { string_sub(p1,"*.*","*"); string_sub(p1,".*","*"); } #endif /* Remove any *? and ** as they are meaningless */ for(p = p1; *p; p++) while( *p == '*' && (p[1] == '?' ||p[1] == '*')) (void)strcpy( &p[1], &p[2]); if (strequal(p1,"*")) return(True); DEBUG(5,("mask_match str=<%s> regexp=<%s>, case_sig = %d\n", p2, p1, case_sig)); if (trans2) { strcpy(ebase,p1); strcpy(sbase,p2); } else { if ((p=strrchr(p1,'.'))) { *p = 0; strcpy(ebase,p1); strcpy(eext,p+1); } else { strcpy(ebase,p1); eext[0] = 0; } if (!strequal(p2,".") && !strequal(p2,"..") && (p=strrchr(p2,'.'))) { *p = 0; strcpy(sbase,p2); strcpy(sext,p+1); } else { strcpy(sbase,p2); strcpy(sext,""); } } matched = do_match(sbase,ebase,case_sig) && (trans2 || do_match(sext,eext,case_sig)); DEBUG(5,("mask_match returning %d\n", matched)); return matched; } /**************************************************************************** become a daemon, discarding the controlling terminal ****************************************************************************/ void become_daemon(void) { #ifndef NO_FORK_DEBUG if (fork()) exit(0); /* detach from the terminal */ #ifdef USE_SETSID setsid(); #else #ifdef TIOCNOTTY { int i = open("/dev/tty", O_RDWR); if (i >= 0) { ioctl(i, (int) TIOCNOTTY, (char *)0); close(i); } } #endif #endif #endif } /**************************************************************************** calculate the default netmask for an address ****************************************************************************/ static void default_netmask(struct in_addr *inm, struct in_addr *iad) { unsigned long ad = ntohl(iad->s_addr); unsigned long nm; /* ** Guess a netmask based on the class of the IP address given. */ if ( (ad & 0x80000000) == 0 ) { /* class A address */ nm = 0xFF000000; } else if ( (ad & 0xC0000000) == 0x80000000 ) { /* class B address */ nm = 0xFFFF0000; } else if ( (ad & 0xE0000000) == 0xC0000000 ) { /* class C address */ nm = 0xFFFFFF00; } else { /* class D or E; netmask doesn't make much sense - guess 4 bits */ nm = 0xFFFFFFF0; } inm->s_addr = htonl(nm); } /**************************************************************************** get the broadcast address for our address (troyer@saifr00.ateng.az.honeywell.com) ****************************************************************************/ void get_broadcast(struct in_addr *if_ipaddr, struct in_addr *if_bcast, struct in_addr *if_nmask) { BOOL found = False; #ifndef NO_GET_BROADCAST int sock = -1; /* AF_INET raw socket desc */ char buff[1024]; struct ifreq *ifr=NULL; int i; #if defined(EVEREST) int n_interfaces; struct ifconf ifc; struct ifreq *ifreqs; #elif defined(USE_IFREQ) struct ifreq ifreq; struct strioctl strioctl; struct ifconf *ifc; #else struct ifconf ifc; #endif #endif /* get a default netmask and broadcast */ default_netmask(if_nmask, if_ipaddr); #ifndef NO_GET_BROADCAST /* Create a socket to the INET kernel. */ #if USE_SOCKRAW if ((sock = socket(AF_INET, SOCK_RAW, PF_INET )) < 0) #else if ((sock = socket(AF_INET, SOCK_DGRAM, 0 )) < 0) #endif { DEBUG(0,( "Unable to open socket to get broadcast address\n")); return; } /* Get a list of the configured interfaces */ #ifdef EVEREST /* This is part of SCO Openserver 5: The ioctls are no longer part if the lower level STREAMS interface glue. They are now real ioctl calls */ if (ioctl(sock, SIOCGIFANUM, &n_interfaces) < 0) { DEBUG(0,( "SIOCGIFANUM: %s\n", strerror(errno))); } else { DEBUG(0,( "number of interfaces returned is: %d\n", n_interfaces)); ifc.ifc_len = sizeof(struct ifreq) * n_interfaces; ifc.ifc_buf = (caddr_t) alloca(ifc.ifc_len); if (ioctl(sock, SIOCGIFCONF, &ifc) < 0) DEBUG(0, ( "SIOCGIFCONF: %s\n", strerror(errno))); else { ifr = ifc.ifc_req; for (i = 0; i < n_interfaces; ++i) { if (if_ipaddr->s_addr == ((struct sockaddr_in *) &ifr[i].ifr_addr)->sin_addr.s_addr) { found = True; break; } } } } #elif defined(USE_IFREQ) ifc = (struct ifconf *)buff; ifc->ifc_len = BUFSIZ - sizeof(struct ifconf); strioctl.ic_cmd = SIOCGIFCONF; strioctl.ic_dp = (char *)ifc; strioctl.ic_len = sizeof(buff); if (ioctl(sock, I_STR, &strioctl) < 0) { DEBUG(0,( "I_STR/SIOCGIFCONF: %s\n", strerror(errno))); } else { ifr = (struct ifreq *)ifc->ifc_req; /* Loop through interfaces, looking for given IP address */ for (i = ifc->ifc_len / sizeof(struct ifreq); --i >= 0; ifr++) { if (if_ipaddr->s_addr == (*(struct sockaddr_in *) &ifr->ifr_addr).sin_addr.s_addr) { found = True; break; } } } #elif defined(__FreeBSD__) || defined(NETBSD) ifc.ifc_len = sizeof(buff); ifc.ifc_buf = buff; if (ioctl(sock, SIOCGIFCONF, &ifc) < 0) { DEBUG(0,("SIOCGIFCONF: %s\n", strerror(errno))); } else { ifr = ifc.ifc_req; /* Loop through interfaces, looking for given IP address */ i = ifc.ifc_len; while (i > 0) { if (if_ipaddr->s_addr == (*(struct sockaddr_in *) &ifr->ifr_addr).sin_addr.s_addr) { found = True; break; } i -= ifr->ifr_addr.sa_len + IFNAMSIZ; ifr = (struct ifreq*) ((char*) ifr + ifr->ifr_addr.sa_len + IFNAMSIZ); } } #else ifc.ifc_len = sizeof(buff); ifc.ifc_buf = buff; if (ioctl(sock, SIOCGIFCONF, &ifc) < 0) { DEBUG(0,("SIOCGIFCONF: %s\n", strerror(errno))); } else { ifr = ifc.ifc_req; /* Loop through interfaces, looking for given IP address */ for (i = ifc.ifc_len / sizeof(struct ifreq); --i >= 0; ifr++) { #ifdef BSDI if (ioctl(sock, SIOCGIFADDR, ifr) < 0) break; #endif if (if_ipaddr->s_addr == (*(struct sockaddr_in *) &ifr->ifr_addr).sin_addr.s_addr) { found = True; break; } } } #endif if (!found) { DEBUG(0,("No interface found for address %s\n", inet_ntoa(*if_ipaddr))); } else { /* Get the netmask address from the kernel */ #ifdef USE_IFREQ ifreq = *ifr; strioctl.ic_cmd = SIOCGIFNETMASK; strioctl.ic_dp = (char *)&ifreq; strioctl.ic_len = sizeof(struct ifreq); if (ioctl(sock, I_STR, &strioctl) < 0) DEBUG(0,("Failed I_STR/SIOCGIFNETMASK: %s\n", strerror(errno))); else *if_nmask = ((struct sockaddr_in *)&ifreq.ifr_addr)->sin_addr; #else if (ioctl(sock, SIOCGIFNETMASK, ifr) < 0) DEBUG(0,("SIOCGIFNETMASK failed\n")); else *if_nmask = ((struct sockaddr_in *)&ifr->ifr_addr)->sin_addr; #endif DEBUG(2,("Netmask for %s = %s\n", ifr->ifr_name, inet_ntoa(*if_nmask))); } /* Close up shop */ (void) close(sock); #endif /* sanity check on the netmask */ { unsigned long nm = ntohl(if_nmask->s_addr); if ((nm >> 24) != 0xFF) { DEBUG(0,("Impossible netmask %s - using defaults\n",inet_ntoa(*if_nmask))); default_netmask(if_nmask, if_ipaddr); } } /* derive the broadcast assuming a 1's broadcast, as this is what all MS operating systems do, we have to comply even if the unix box is setup differently */ { unsigned long ad = ntohl(if_ipaddr->s_addr); unsigned long nm = ntohl(if_nmask->s_addr); unsigned long bc = (ad & nm) | (0xffffffff & ~nm); if_bcast->s_addr = htonl(bc); } DEBUG(2,("Derived broadcast address %s\n", inet_ntoa(*if_bcast))); } /* get_broadcast */ /**************************************************************************** put up a yes/no prompt ****************************************************************************/ BOOL yesno(char *p) { pstring ans; printf("%s",p); if (!fgets(ans,sizeof(ans)-1,stdin)) return(False); if (*ans == 'y' || *ans == 'Y') return(True); return(False); } /**************************************************************************** read a line from a file with possible \ continuation chars. Blanks at the start or end of a line are stripped. The string will be allocated if s2 is NULL ****************************************************************************/ char *fgets_slash(char *s2,int maxlen,FILE *f) { char *s=s2; int len = 0; int c; BOOL start_of_line = True; if (feof(f)) return(NULL); if (!s2) { maxlen = MIN(maxlen,8); s = (char *)Realloc(s,maxlen); } if (!s || maxlen < 2) return(NULL); *s = 0; while (len < maxlen-1) { c = getc(f); switch (c) { case '\r': break; case '\n': while (len > 0 && s[len-1] == ' ') { s[--len] = 0; } if (len > 0 && s[len-1] == '\\') { s[--len] = 0; start_of_line = True; break; } return(s); case EOF: if (len <= 0 && !s2) free(s); return(len>0?s:NULL); case ' ': if (start_of_line) break; default: start_of_line = False; s[len++] = c; s[len] = 0; } if (!s2 && len > maxlen-3) { maxlen *= 2; s = (char *)Realloc(s,maxlen); if (!s) return(NULL); } } return(s); } /**************************************************************************** set the length of a file from a filedescriptor. Returns 0 on success, -1 on failure. ****************************************************************************/ int set_filelen(int fd, long len) { /* According to W. R. Stevens advanced UNIX prog. Pure 4.3 BSD cannot extend a file with ftruncate. Provide alternate implementation for this */ #if FTRUNCATE_CAN_EXTEND return ftruncate(fd, len); #else struct stat st; char c = 0; long currpos = lseek(fd, 0L, SEEK_CUR); if(currpos < 0) return -1; /* Do an fstat to see if the file is longer than the requested size (call ftruncate), or shorter, in which case seek to len - 1 and write 1 byte of zero */ if(fstat(fd, &st)<0) return -1; #ifdef S_ISFIFO if (S_ISFIFO(st.st_mode)) return 0; #endif if(st.st_size == len) return 0; if(st.st_size > len) return ftruncate(fd, len); if(lseek(fd, len-1, SEEK_SET) != len -1) return -1; if(write(fd, &c, 1)!=1) return -1; /* Seek to where we were */ lseek(fd, currpos, SEEK_SET); return 0; #endif } /**************************************************************************** return the byte checksum of some data ****************************************************************************/ int byte_checksum(char *buf,int len) { unsigned char *p = (unsigned char *)buf; int ret = 0; while (len--) ret += *p++; return(ret); } #ifdef HPUX /**************************************************************************** this is a version of setbuffer() for those machines that only have setvbuf ****************************************************************************/ void setbuffer(FILE *f,char *buf,int bufsize) { setvbuf(f,buf,_IOFBF,bufsize); } #endif /**************************************************************************** parse out a directory name from a path name. Assumes dos style filenames. ****************************************************************************/ char *dirname_dos(char *path,char *buf) { char *p = strrchr(path,'\\'); if (!p) strcpy(buf,path); else { *p = 0; strcpy(buf,path); *p = '\\'; } return(buf); } /**************************************************************************** parse out a filename from a path name. Assumes dos style filenames. ****************************************************************************/ static char *filename_dos(char *path,char *buf) { char *p = strrchr(path,'\\'); if (!p) strcpy(buf,path); else strcpy(buf,p+1); return(buf); } /**************************************************************************** expand a pointer to be a particular size ****************************************************************************/ void *Realloc(void *p,int size) { void *ret=NULL; if (!p) ret = (void *)malloc(size); else ret = (void *)realloc(p,size); if (!ret) DEBUG(0,("Memory allocation error: failed to expand to %d bytes\n",size)); return(ret); } /**************************************************************************** set the time on a file ****************************************************************************/ BOOL set_filetime(char *fname,time_t mtime) { struct utimbuf times; if (null_mtime(mtime)) return(True); times.modtime = times.actime = mtime; if (sys_utime(fname,×)) { DEBUG(4,("set_filetime(%s) failed: %s\n",fname,strerror(errno))); } return(True); } #ifdef NOSTRDUP /**************************************************************************** duplicate a string ****************************************************************************/ char *strdup(char *s) { char *ret = NULL; if (!s) return(NULL); ret = (char *)malloc(strlen(s)+1); if (!ret) return(NULL); strcpy(ret,s); return(ret); } #endif /**************************************************************************** Signal handler for SIGPIPE (write on a disconnected socket) ****************************************************************************/ void Abort(void ) { DEBUG(0,("Probably got SIGPIPE\nExiting\n")); exit(2); } #ifdef REPLACE_STRLEN /**************************************************************************** a replacement strlen() that returns int for solaris ****************************************************************************/ int Strlen(char *s) { int ret=0; if (!s) return(0); while (*s++) ret++; return(ret); } #endif /**************************************************************************** return a time at the start of the current month ****************************************************************************/ time_t start_of_month(void) { time_t t = time(NULL); struct tm *t2; t2 = gmtime(&t); t2->tm_mday = 1; t2->tm_hour = 0; t2->tm_min = 0; t2->tm_sec = 0; return(mktime(t2)); } /******************************************************************* check for a sane unix date ********************************************************************/ BOOL sane_unix_date(time_t unixdate) { struct tm t,today; time_t t_today = time(NULL); t = *(LocalTime(&unixdate,LOCAL_TO_GMT)); today = *(LocalTime(&t_today,LOCAL_TO_GMT)); if (t.tm_year < 80) return(False); if (t.tm_year > today.tm_year) return(False); if (t.tm_year == today.tm_year && t.tm_mon > today.tm_mon) return(False); if (t.tm_year == today.tm_year && t.tm_mon == today.tm_mon && t.tm_mday > (today.tm_mday+1)) return(False); return(True); } #ifdef NO_FTRUNCATE /******************************************************************* ftruncate for operating systems that don't have it ********************************************************************/ int ftruncate(int f,long l) { struct flock fl; fl.l_whence = 0; fl.l_len = 0; fl.l_start = l; fl.l_type = F_WRLCK; return fcntl(f, F_FREESP, &fl); } #endif /**************************************************************************** get my own name and IP ****************************************************************************/ BOOL get_myname(char *myname,struct in_addr *ip) { struct hostent *hp; pstring hostname; *hostname = 0; /* get my host name */ if (gethostname(hostname, MAXHOSTNAMELEN) == -1) { DEBUG(0,("gethostname failed\n")); return False; } /* get host info */ if ((hp = Get_Hostbyname(hostname)) == 0) { DEBUG(0,( "Get_Hostbyname: Unknown host %s.\n",hostname)); return False; } if (myname) { /* split off any parts after an initial . */ char *p = strchr(hostname,'.'); if (p) *p = 0; strcpy(myname,hostname); } if (ip) putip((char *)ip,(char *)hp->h_addr); return(True); } /**************************************************************************** true if two IP addresses are equal ****************************************************************************/ BOOL ip_equal(struct in_addr ip1,struct in_addr ip2) { unsigned long a1,a2; a1 = ntohl(ip1.s_addr); a2 = ntohl(ip2.s_addr); return(a1 == a2); } /**************************************************************************** open a socket of the specified type, port and address for incoming data ****************************************************************************/ int open_socket_in(int type, int port, int dlevel) { struct hostent *hp; struct sockaddr_in sock; pstring host_name; int res; /* get my host name */ #ifdef MAXHOSTNAMELEN if (gethostname(host_name, MAXHOSTNAMELEN) == -1) #else if (gethostname(host_name, sizeof(host_name)) == -1) #endif { DEBUG(0,("gethostname failed\n")); return -1; } /* get host info */ if ((hp = Get_Hostbyname(host_name)) == 0) { DEBUG(0,( "Get_Hostbyname: Unknown host. %s\n",host_name)); return -1; } bzero((char *)&sock,sizeof(sock)); memcpy((char *)&sock.sin_addr,(char *)hp->h_addr, hp->h_length); #if defined(__FreeBSD__) || defined(NETBSD) /* XXX not the right ifdef */ sock.sin_len = sizeof(sock); #endif sock.sin_port = htons( port ); sock.sin_family = hp->h_addrtype; sock.sin_addr.s_addr = INADDR_ANY; res = socket(hp->h_addrtype, type, 0); if (res == -1) { DEBUG(0,("socket failed\n")); return -1; } { int one=1; setsockopt(res,SOL_SOCKET,SO_REUSEADDR,(char *)&one,sizeof(one)); } /* now we've got a socket - we need to bind it */ if (bind(res, (struct sockaddr * ) &sock,sizeof(sock)) < 0) { if (port) { if (port == 139 || port == 137) DEBUG(dlevel,("bind failed on port %d (%s)\n", port,strerror(errno))); close(res); if (dlevel > 0 && port < 1000) port = 7999; if (port >= 1000 && port < 9000) return(open_socket_in(type,port+1,dlevel)); } return(-1); } DEBUG(3,("bind succeeded on port %d\n",port)); return res; } /**************************************************************************** create an outgoing socket **************************************************************************/ int open_socket_out(int type, struct in_addr *addr, int port ) { struct sockaddr_in sock_out; int res; /* create a socket to write to */ res = socket(PF_INET, type, 0); if (res == -1) { DEBUG(0,("socket error\n")); return -1; } if (type != SOCK_STREAM) return(res); bzero((char *)&sock_out,sizeof(sock_out)); putip((char *)&sock_out.sin_addr,(char *)addr); sock_out.sin_port = htons( port ); sock_out.sin_family = PF_INET; DEBUG(3,("Connecting to %s at port %d\n",inet_ntoa(*addr),port)); /* and connect it to the destination */ if (connect(res,(struct sockaddr *)&sock_out,sizeof(sock_out))<0) { DEBUG(0,("connect error: %s\n",strerror(errno))); close(res); return(-1); } return res; } /**************************************************************************** interpret a protocol description string, with a default ****************************************************************************/ int interpret_protocol(char *str,int def) { if (strequal(str,"NT1")) return(PROTOCOL_NT1); if (strequal(str,"LANMAN2")) return(PROTOCOL_LANMAN2); if (strequal(str,"LANMAN1")) return(PROTOCOL_LANMAN1); if (strequal(str,"CORE")) return(PROTOCOL_CORE); if (strequal(str,"COREPLUS")) return(PROTOCOL_COREPLUS); if (strequal(str,"CORE+")) return(PROTOCOL_COREPLUS); DEBUG(0,("Unrecognised protocol level %s\n",str)); return(def); } /**************************************************************************** interpret a security level ****************************************************************************/ int interpret_security(char *str,int def) { if (strequal(str,"SERVER")) return(SEC_SERVER); if (strequal(str,"USER")) return(SEC_USER); if (strequal(str,"SHARE")) return(SEC_SHARE); DEBUG(0,("Unrecognised security level %s\n",str)); return(def); } /**************************************************************************** interpret an internet address or name into an IP address in 4 byte form ****************************************************************************/ unsigned long interpret_addr(char *str) { struct hostent *hp; unsigned long res; if (strcmp(str,"0.0.0.0") == 0) return(0); if (strcmp(str,"255.255.255.255") == 0) return(0xFFFFFFFF); /* if it's in the form of an IP address then get the lib to interpret it */ if (isdigit(str[0])) { res = inet_addr(str); } else { /* otherwise assume it's a network name of some sort and use Get_Hostbyname */ if ((hp = Get_Hostbyname(str)) == 0) { DEBUG(3,("Get_Hostbyname: Unknown host. %s\n",str)); return 0; } putip((char *)&res,(char *)hp->h_addr); } if (res == (unsigned long)-1) return(0); return(res); } /******************************************************************* a convenient addition to interpret_addr() ******************************************************************/ struct in_addr *interpret_addr2(char *str) { static struct in_addr ret; unsigned long a = interpret_addr(str); putip((char *)&ret,(char *)&a); return(&ret); } /******************************************************************* check if an IP is the 0.0.0.0 ******************************************************************/ BOOL zero_ip(struct in_addr ip) { unsigned long a; putip((char *)&a,(char *)&ip); return(a == 0); } #define TIME_FIXUP_CONSTANT (369.0*365.25*24*60*60-(3.0*24*60*60+6.0*60*60)) /**************************************************************************** interpret an 8 byte "filetime" structure to a time_t It's originally in "100ns units since jan 1st 1601" It appears to be kludge-GMT (at least for file listings). This means its the GMT you get by taking a localtime and adding the serverzone. This is NOT the same as GMT in some cases. This routine converts this to real GMT. ****************************************************************************/ time_t interpret_long_date(char *p) { double d; time_t ret; uint32 tlow,thigh; tlow = IVAL(p,0); thigh = IVAL(p,4); if (thigh == 0) return(0); d = ((double)thigh)*4.0*(double)(1<<30); d += (tlow&0xFFF00000); d *= 1.0e-7; /* now adjust by 369 years to make the secs since 1970 */ d -= TIME_FIXUP_CONSTANT; if (d>=MAXINT) return(0); ret = (time_t)(d+0.5); /* this takes us from kludge-GMT to real GMT */ ret += TimeDiff(ret) - serverzone; return(ret); } /**************************************************************************** put a 8 byte filetime from a time_t This takes real GMT as input and converts to kludge-GMT ****************************************************************************/ void put_long_date(char *p,time_t t) { uint32 tlow,thigh; double d; if (t==0) { SIVAL(p,0,0); SIVAL(p,4,0); return; } /* this converts GMT to kludge-GMT */ t -= TimeDiff(t) - serverzone; d = (double) (t); d += TIME_FIXUP_CONSTANT; d *= 1.0e7; thigh = (uint32)(d * (1.0/(4.0*(double)(1<<30)))); tlow = (uint32)(d - ((double)thigh)*4.0*(double)(1<<30)); SIVAL(p,0,tlow); SIVAL(p,4,thigh); } /******************************************************************* sub strings with useful parameters ********************************************************************/ void standard_sub_basic(char *s) { if (!strchr(s,'%')) return; string_sub(s,"%R",remote_proto); string_sub(s,"%a",remote_arch); string_sub(s,"%m",remote_machine); string_sub(s,"%L",local_machine); if (!strchr(s,'%')) return; string_sub(s,"%v",VERSION); string_sub(s,"%h",myhostname); string_sub(s,"%U",sesssetup_user); if (!strchr(s,'%')) return; string_sub(s,"%I",Client_info.addr); string_sub(s,"%M",Client_info.name); string_sub(s,"%T",timestring()); if (!strchr(s,'%')) return; { char pidstr[10]; sprintf(pidstr,"%d",(int)getpid()); string_sub(s,"%d",pidstr); } if (!strchr(s,'%')) return; { struct passwd *pass = Get_Pwnam(sesssetup_user,False); if (pass) { string_sub(s,"%G",gidtoname(pass->pw_gid)); } } } /******************************************************************* write a string in unicoode format ********************************************************************/ int PutUniCode(char *dst,char *src) { int ret = 0; while (*src) { dst[ret++] = src[0]; dst[ret++] = 0; src++; } dst[ret++]=0; dst[ret++]=0; return(ret); } pstring smbrun_path = SMBRUN; /**************************************************************************** run a command via system() using smbrun ****************************************************************************/ int smbrun(char *cmd,char *outfile) { int ret; pstring syscmd; if (!file_exist(smbrun_path,NULL)) { DEBUG(0,("SMBRUN ERROR: Can't find %s. Installation problem?\n",smbrun_path)); return(1); } sprintf(syscmd,"%s \"(%s 2>&1) > %s\"", smbrun_path,cmd, outfile?outfile:"/dev/null"); DEBUG(5,("smbrun - running %s ",syscmd)); ret = system(syscmd); DEBUG(5,("gave %d\n",ret)); return(ret); } /**************************************************************************** a wrapper for gethostbyname() that tries with all lower and all upper case if the initial name fails ****************************************************************************/ struct hostent *Get_Hostbyname(char *name) { char *name2 = strdup(name); struct hostent *ret; if (!name2) { DEBUG(0,("Memory allocation error in Get_Hostbyname! panic\n")); exit(0); } if (!isalnum(*name2)) { free(name2); return(NULL); } ret = gethostbyname(name2); if (ret != NULL) { free(name2); return(ret); } /* try with all lowercase */ strlower(name2); ret = gethostbyname(name2); if (ret != NULL) { free(name2); return(ret); } /* try with all uppercase */ strupper(name2); ret = gethostbyname(name2); if (ret != NULL) { free(name2); return(ret); } /* nothing works :-( */ free(name2); return(NULL); } /**************************************************************************** check if a process exists. Does this work on all unixes? ****************************************************************************/ BOOL process_exists(int pid) { #ifdef LINUX fstring s; sprintf(s,"/proc/%d",pid); return(directory_exist(s,NULL)); #else { static BOOL tested=False; static BOOL ok=False; fstring s; if (!tested) { tested = True; sprintf(s,"/proc/%05d",getpid()); ok = file_exist(s,NULL); } if (ok) { sprintf(s,"/proc/%05d",pid); return(file_exist(s,NULL)); } } /* a best guess for non root access */ if (geteuid() != 0) return(True); /* otherwise use kill */ return(pid == getpid() || kill(pid,0) == 0); #endif } /******************************************************************* turn a uid into a user name ********************************************************************/ char *uidtoname(int uid) { static char name[40]; struct passwd *pass = getpwuid(uid); if (pass) return(pass->pw_name); sprintf(name,"%d",uid); return(name); } /******************************************************************* turn a gid into a group name ********************************************************************/ char *gidtoname(int gid) { static char name[40]; struct group *grp = getgrgid(gid); if (grp) return(grp->gr_name); sprintf(name,"%d",gid); return(name); } /******************************************************************* block sigs ********************************************************************/ void BlockSignals(BOOL block) { #ifdef USE_SIGBLOCK int block_mask = (sigmask(SIGTERM)|sigmask(SIGQUIT)|sigmask(SIGSEGV) |sigmask(SIGCHLD)|sigmask(SIGQUIT)|sigmask(SIGBUS)| sigmask(SIGINT)); if (block) sigblock(block_mask); else sigunblock(block_mask); #endif } #if AJT /******************************************************************* my own panic function - not suitable for general use ********************************************************************/ void ajt_panic(void) { pstring cmd = "/usr/bin/X11/xedit -display :0 /tmp/ERROR_FAULT &"; smbrun(cmd,NULL); } #endif #ifdef USE_DIRECT #define DIRECT direct #else #define DIRECT dirent #endif /******************************************************************* a readdir wrapper which just returns the file name also return the inode number if requested ********************************************************************/ char *readdirname(void *p) { struct DIRECT *ptr; char *dname; if (!p) return(NULL); ptr = (struct DIRECT *)readdir(p); if (!ptr) return(NULL); dname = ptr->d_name; #ifdef KANJI { static pstring buf; strcpy(buf, dname); unix_to_dos(buf, True); dname = buf; } #endif #ifdef NEXT2 if (telldir(p) < 0) return(NULL); #endif #ifdef SUNOS5 /* this handles a broken compiler setup, causing a mixture of BSD and SYSV headers and libraries */ { static BOOL broken_readdir = False; if (!broken_readdir && !(*(dname)) && strequal("..",dname-2)) { DEBUG(0,("Your readdir() is broken. You have somehow mixed SYSV and BSD headers and libraries\n")); broken_readdir = True; } if (broken_readdir) return(dname-2); } #endif return(dname); } #if (defined(SecureWare) && defined(SCO)) /* This is needed due to needing the nap() function but we don't want to include the Xenix libraries since that will break other things... BTW: system call # 0x0c28 is the same as calling nap() */ long nap(long milliseconds) { return syscall(0x0c28, milliseconds); } #endif #ifdef NO_INITGROUPS #include #include #include #ifndef NULL #define NULL (void *)0 #endif /**************************************************************************** some systems don't have an initgroups call ****************************************************************************/ int initgroups(char *name,gid_t id) { #ifdef NO_SETGROUPS /* yikes! no SETGROUPS or INITGROUPS? how can this work? */ return(0); #else gid_t grouplst[NGROUPS_MAX]; int i,j; struct group *g; char *gr; grouplst[0] = id; i = 1; while (i < NGROUPS_MAX && ((g = (struct group *)getgrent()) != (struct group *)NULL)) { if (g->gr_gid == id) continue; j = 0; gr = g->gr_mem[0]; while (gr && (*gr != (char)NULL)) { if (strcmp(name,gr) == 0) { grouplst[i] = g->gr_gid; i++; gr = (char *)NULL; break; } gr = g->gr_mem[++j]; } } endgrent(); return(setgroups(i,grouplst)); #endif } #endif #if WRAP_MALLOC /* undo the wrapping temporarily */ #undef malloc #undef realloc #undef free /**************************************************************************** wrapper for malloc() to catch memory errors ****************************************************************************/ void *malloc_wrapped(int size,char *file,int line) { #ifdef xx_old_malloc void *res = xx_old_malloc(size); #else void *res = malloc(size); #endif DEBUG(3,("Malloc called from %s(%d) with size=%d gave ptr=0x%X\n", file,line, size,(unsigned int)res)); return(res); } /**************************************************************************** wrapper for realloc() to catch memory errors ****************************************************************************/ void *realloc_wrapped(void *ptr,int size,char *file,int line) { #ifdef xx_old_realloc void *res = xx_old_realloc(ptr,size); #else void *res = realloc(ptr,size); #endif DEBUG(3,("Realloc\n")); DEBUG(3,("free called from %s(%d) with ptr=0x%X\n", file,line, (unsigned int)ptr)); DEBUG(3,("Malloc called from %s(%d) with size=%d gave ptr=0x%X\n", file,line, size,(unsigned int)res)); return(res); } /**************************************************************************** wrapper for free() to catch memory errors ****************************************************************************/ void free_wrapped(void *ptr,char *file,int line) { #ifdef xx_old_free xx_old_free(ptr); #else free(ptr); #endif DEBUG(3,("free called from %s(%d) with ptr=0x%X\n", file,line,(unsigned int)ptr)); return; } /* and re-do the define for spots lower in this file */ #define malloc(size) malloc_wrapped(size,__FILE__,__LINE__) #define realloc(ptr,size) realloc_wrapped(ptr,size,__FILE__,__LINE__) #define free(ptr) free_wrapped(ptr,__FILE__,__LINE__) #endif #ifdef REPLACE_STRSTR /**************************************************************************** Mips version of strstr doesn't seem to work correctly. There is a #define in includes.h to redirect calls to this function. ****************************************************************************/ char *Strstr(char *s, char *p) { int len = strlen(p); while ( *s != '\0' ) { if ( strncmp(s, p, len) == 0 ) return s; s++; } return NULL; } #endif /* REPLACE_STRSTR */ #ifdef REPLACE_MKTIME /******************************************************************* a mktime() replacement for those who don't have it - contributed by C.A. Lademann ********************************************************************/ #define MINUTE 60 #define HOUR 60*MINUTE #define DAY 24*HOUR #define YEAR 365*DAY time_t Mktime(struct tm *t) { struct tm *u; time_t epoch = 0; int mon [] = { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 }, y, m, i; if(t->tm_year < 70) return((time_t)-1); epoch = (t->tm_year - 70) * YEAR + (t->tm_year / 4 - 70 / 4 - t->tm_year / 100) * DAY; y = t->tm_year; m = 0; for(i = 0; i < t->tm_mon; i++) { epoch += mon [m] * DAY; if(m == 1 && y % 4 == 0 && (y % 100 != 0 || y % 400 == 0)) epoch += DAY; if(++m > 11) { m = 0; y++; } } epoch += (t->tm_mday - 1) * DAY; epoch += t->tm_hour * HOUR + t->tm_min * MINUTE + t->tm_sec; if((u = localtime(&epoch)) != NULL) { t->tm_sec = u->tm_sec; t->tm_min = u->tm_min; t->tm_hour = u->tm_hour; t->tm_mday = u->tm_mday; t->tm_mon = u->tm_mon; t->tm_year = u->tm_year; t->tm_wday = u->tm_wday; t->tm_yday = u->tm_yday; t->tm_isdst = u->tm_isdst; #ifndef NO_TM_NAME memcpy(t->tm_name, u->tm_name, LTZNMAX); #endif } return(epoch); } #endif /* REPLACE_MKTIME */ #ifdef REPLACE_RENAME /* Rename a file. (from libiberty in GNU binutils) */ int rename (zfrom, zto) const char *zfrom; const char *zto; { if (link (zfrom, zto) < 0) { if (errno != EEXIST) return -1; if (unlink (zto) < 0 || link (zfrom, zto) < 0) return -1; } return unlink (zfrom); } #endif #ifdef REPLACE_INNETGR /* * Search for a match in a netgroup. This replaces it on broken systems. */ int InNetGr(group, host, user, dom) char *group, *host, *user, *dom; { char *hst, *usr, *dm; setnetgrent(group); while (getnetgrent(&hst, &usr, &dm)) if (((host == 0) || (hst == 0) || !strcmp(host, hst)) && ((user == 0) || (usr == 0) || !strcmp(user, usr)) && ((dom == 0) || (dm == 0) || !strcmp(dom, dm))) { endnetgrent(); return (1); } endnetgrent(); return (0); } #endif #if WRAP_MEMCPY #undef memcpy /******************************************************************* a wrapper around memcpy for diagnostic purposes ********************************************************************/ void *memcpy_wrapped(void *d,void *s,int l,char *fname,int line) { if (l>64 && (((int)d)%4) != (((int)s)%4)) DEBUG(4,("Misaligned memcpy(0x%X,0x%X,%d) at %s(%d)\n",d,s,l,fname,line)); #ifdef xx_old_memcpy return(xx_old_memcpy(d,s,l)); #else return(memcpy(d,s,l)); #endif } #define memcpy(d,s,l) memcpy_wrapped(d,s,l,__FILE__,__LINE__) #endif