extern int DEBUGLEVEL;
-BOOL passive = False;
-
int Protocol = PROTOCOL_COREPLUS;
/* a default finfo structure to ensure all fields are sensible */
file_info def_finfo = {-1,0,0,0,0,0,0,""};
/* the client file descriptor */
-int Client = -1;
-
-/* the last IP received from */
-struct in_addr lastip;
-
-/* the last port received from */
-int lastport=0;
+extern int Client;
/* this is used by the chaining code */
int chain_size = 0;
fstring global_myworkgroup = "";
char **my_netbios_names;
-int smb_read_error = 0;
-
static char *filename_dos(char *path,char *buf);
return "/tmp";
}
-
-
-/****************************************************************************
-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
+determine whether we are in the specified group
****************************************************************************/
-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)
+BOOL in_group(gid_t group, gid_t current_gid, int ngroups, gid_t *groups)
{
- 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);
+ int i;
- *ctok=ictok;
- s=last_ptr;
+ if (group == current_gid) return(True);
- if (!(ret=iret=malloc(ictok*sizeof(char *)))) return NULL;
-
- while(ictok--) {
- *iret++=s;
- while(*s++);
- while(!*s) s++;
- }
+ for (i=0;i<ngroups;i++)
+ if (group == groups[i])
+ return(True);
- return ret;
+ return(False);
}
-/* ************************************************************************* **
- * Duplicate a block of memory.
- * ************************************************************************* **
- */
-void *mem_dup( void *from, int size )
- {
- void *tmp;
-
- tmp = malloc( size );
- if( NULL != tmp )
- (void)memcpy( tmp, from, size );
- return( tmp );
- } /* mem_dup */
-
/****************************************************************************
-prompte a dptr (to make it recently used)
+gets either a hex number (0xNNN) or decimal integer (NNN).
****************************************************************************/
-void array_promote(char *array,int elsize,int element)
+uint32 get_number(const char *tmp)
{
- 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);
+ if (strnequal(tmp, "0x", 2))
+ {
+ return strtoul(tmp, (char**)NULL, 16);
+ }
+ else
+ {
+ return strtoul(tmp, (char**)NULL, 10);
+ }
}
-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
-#ifdef SO_SNDTIMEO
- {"SO_SNDTIMEO", SOL_SOCKET, SO_SNDTIMEO, 0, OPT_INT},
-#endif
-#ifdef SO_RCVTIMEO
- {"SO_RCVTIMEO", SOL_SOCKET, SO_RCVTIMEO, 0, OPT_INT},
-#endif
- {NULL,0,0,0,0}};
-
-
-
/****************************************************************************
-set user socket options
+like atoi but gets the value up to the separater character
****************************************************************************/
-void set_socket_options(int fd, char *options)
+char *Atoic(char *p, int *n, char *c)
{
- fstring tok;
-
- while (next_token(&options,tok," \t,"))
- {
- int ret=0,i;
- int value = 1;
- char *p;
- BOOL got_value = False;
-
- if ((p = strchr(tok,'=')))
+ if (!isdigit(*p))
{
- *p = 0;
- value = atoi(p+1);
- got_value = True;
+ DEBUG(5, ("Atoic: malformed number\n"));
+ return NULL;
}
- for (i=0;socket_options[i].name;i++)
- if (strequal(socket_options[i].name,tok))
- break;
+ (*n) = (int)get_number(p);
- if (!socket_options[i].name)
+ if (strnequal(p, "0x", 2))
{
- DEBUG(0,("Unknown socket option %s\n",tok));
- continue;
+ p += 2;
}
- switch (socket_options[i].opttype)
+ while ((*p) && isdigit(*p))
{
- 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;
+ p++;
}
-
- if (ret != 0)
- DEBUG(0,("Failed to set socket option %s\n",tok));
- }
-}
-
+ if (strchr(c, *p) == NULL)
+ {
+ DEBUG(5, ("Atoic: no separator characters (%s) not found\n", c));
+ return NULL;
+ }
-/****************************************************************************
- close the socket communication
-****************************************************************************/
-void close_sockets(void )
-{
-#ifdef WITH_SSL
- sslutil_disconnect(Client);
-#endif /* WITH_SSL */
-
- close(Client);
- Client = 0;
+ return p;
}
-/****************************************************************************
-determine whether we are in the specified group
-****************************************************************************/
-BOOL in_group(gid_t group, int current_gid, int ngroups, GID_T *groups)
+uint32 *add_num_to_list(uint32 **num, int *count, int val)
{
- int i;
-
- if (group == current_gid) return(True);
-
- for (i=0;i<ngroups;i++)
- if (group == groups[i])
- return(True);
+ (*num) = Realloc((*num), ((*count)+1) * sizeof(uint32));
+ if ((*num) == NULL)
+ {
+ return NULL;
+ }
+ (*num)[(*count)] = val;
+ (*count)++;
- return(False);
+ return (*num);
}
-/****************************************************************************
-this is a safer strcpy(), meant to prevent core dumps when nasty things happen
-****************************************************************************/
-char *StrCpy(char *dest,char *src)
+/*************************************************************************
+ reads a list of numbers
+ *************************************************************************/
+char *get_numlist(char *p, uint32 **num, int *count)
{
- char *d = dest;
+ int val;
-#if AJT
- /* I don't want to get lazy with these ... */
- if (!dest || !src) {
- DEBUG(0,("ERROR: NULL StrCpy() called!\n"));
- ajt_panic();
- }
-#endif
+ if (num == NULL || count == NULL)
+ {
+ return NULL;
+ }
- if (!dest) return(NULL);
- if (!src) {
- *dest = 0;
- return(dest);
- }
- while ((*d++ = *src++)) ;
- return(dest);
-}
+ (*count) = 0;
+ (*num ) = NULL;
-/****************************************************************************
-line strncpy but always null terminates. Make sure there is room!
-****************************************************************************/
-char *StrnCpy(char *dest,char *src,int n)
-{
- char *d = dest;
- if (!dest) return(NULL);
- if (!src) {
- *dest = 0;
- return(dest);
- }
- while (n-- && (*d++ = *src++)) ;
- *d = 0;
- return(dest);
-}
+ while ((p = Atoic(p, &val, ":,")) != NULL && (*p) != ':')
+ {
+ if (add_num_to_list(num, count, val) == NULL)
+ {
+ return NULL;
+ }
+ p++;
+ }
+ return p;
+}
/*******************************************************************
copy an IP address from one buffer to another
}
+#define TRUNCATE_NETBIOS_NAME 1
+
+/*******************************************************************
+ convert, possibly using a stupid microsoft-ism which has destroyed
+ the transport independence of netbios (for CIFS vendors that usually
+ use the Win95-type methods, not for NT to NT communication, which uses
+ DCE/RPC and therefore full-length unicode strings...) a dns name into
+ a netbios name.
+
+ the netbios name (NOT necessarily null-terminated) is truncated to 15
+ characters.
+
+ ******************************************************************/
+char *dns_to_netbios_name(char *dns_name)
+{
+ static char netbios_name[16];
+ int i;
+ StrnCpy(netbios_name, dns_name, 15);
+ netbios_name[15] = 0;
+
+#ifdef TRUNCATE_NETBIOS_NAME
+ /* ok. this is because of a stupid microsoft-ism. if the called host
+ name contains a '.', microsoft clients expect you to truncate the
+ netbios name up to and including the '.' this even applies, by
+ mistake, to workgroup (domain) names, which is _really_ daft.
+ */
+ for (i = 15; i >= 0; i--)
+ {
+ if (netbios_name[i] == '.')
+ {
+ netbios_name[i] = 0;
+ break;
+ }
+ }
+#endif /* TRUNCATE_NETBIOS_NAME */
+
+ return netbios_name;
+}
+
+
/****************************************************************************
interpret the weird netbios "name". Return the name type
****************************************************************************/
/* Safely copy the input string, In, into buf[]. */
(void)memset( buf, 0, 20 );
- if( '*' == In[0] )
+ if (strcmp(In,"*") == 0)
buf[0] = '*';
else
(void)slprintf( buf, sizeof(buf) - 1, "%-15.15s%c", In, name_type );
/*******************************************************************
check if a file exists
********************************************************************/
-BOOL file_exist(char *fname,struct stat *sbuf)
+BOOL file_exist(char *fname,SMB_STRUCT_STAT *sbuf)
{
- struct stat st;
+ SMB_STRUCT_STAT st;
if (!sbuf) sbuf = &st;
if (sys_stat(fname,sbuf) != 0)
return(S_ISREG(sbuf->st_mode));
}
+/*******************************************************************
+ rename a unix file
+********************************************************************/
+int file_rename(char *from, char *to)
+{
+ int rcode = rename (from, to);
+
+ if (errno == EXDEV)
+ {
+ /* Rename across filesystems needed. */
+ rcode = copy_reg (from, to);
+ }
+ return rcode;
+}
+
/*******************************************************************
check a files mod time
********************************************************************/
time_t file_modtime(char *fname)
{
- struct stat st;
+ SMB_STRUCT_STAT st;
if (sys_stat(fname,&st) != 0)
return(0);
/*******************************************************************
check if a directory exists
********************************************************************/
-BOOL directory_exist(char *dname,struct stat *st)
+BOOL directory_exist(char *dname,SMB_STRUCT_STAT *st)
{
- struct stat st2;
+ SMB_STRUCT_STAT st2;
BOOL ret;
if (!st) st = &st2;
/*******************************************************************
returns the size in bytes of the named file
********************************************************************/
-uint32 file_size(char *file_name)
+SMB_OFF_T file_size(char *file_name)
{
- struct stat buf;
+ SMB_STRUCT_STAT buf;
buf.st_size = 0;
- sys_stat(file_name,&buf);
+ if(sys_stat(file_name,&buf) != 0)
+ return (SMB_OFF_T)-1;
return(buf.st_size);
}
/*******************************************************************
return a string representing an attribute for a file
********************************************************************/
-char *attrib_string(int mode)
+char *attrib_string(uint16 mode)
{
static fstring attrstr;
return(attrstr);
}
-
-/*******************************************************************
- case insensitive string compararison
-********************************************************************/
-int StrCaseCmp(char *s, char *t)
+/****************************************************************************
+ make a file into unix format
+****************************************************************************/
+void unix_format(char *fname)
{
- /* compare until we run out of string, either t or s, or find a difference */
- /* We *must* use toupper rather than tolower here due to the
- asynchronous upper to lower mapping.
- */
-#if !defined(KANJI_WIN95_COMPATIBILITY)
- /*
- * For completeness we should put in equivalent code for code pages
- * 949 (Korean hangul) and 950 (Big5 Traditional Chinese) here - but
- * doubt anyone wants Samba to behave differently from Win95 and WinNT
- * here. They both treat full width ascii characters as case senstive
- * filenames (ie. they don't do the work we do here).
- * JRA.
- */
-
- if(lp_client_code_page() == KANJI_CODEPAGE)
- {
- /* Win95 treats full width ascii characters as case sensitive. */
- int diff;
- for (;;)
- {
- if (!*s || !*t)
- return toupper (*s) - toupper (*t);
- else if (is_sj_alph (*s) && is_sj_alph (*t))
- {
- diff = sj_toupper2 (*(s+1)) - sj_toupper2 (*(t+1));
- if (diff)
- return diff;
- s += 2;
- t += 2;
- }
- else if (is_shift_jis (*s) && is_shift_jis (*t))
- {
- diff = ((int) (unsigned char) *s) - ((int) (unsigned char) *t);
- if (diff)
- return diff;
- diff = ((int) (unsigned char) *(s+1)) - ((int) (unsigned char) *(t+1));
- if (diff)
- return diff;
- s += 2;
- t += 2;
- }
- else if (is_shift_jis (*s))
- return 1;
- else if (is_shift_jis (*t))
- return -1;
- else
- {
- diff = toupper (*s) - toupper (*t);
- if (diff)
- return diff;
- s++;
- t++;
- }
- }
- }
- else
-#endif /* KANJI_WIN95_COMPATIBILITY */
- {
- while (*s && *t && toupper(*s) == toupper(*t))
- {
- s++;
- t++;
- }
+ string_replace(fname,'\\','/');
+}
- return(toupper(*s) - toupper(*t));
- }
+/****************************************************************************
+ make a file into dos format
+****************************************************************************/
+void dos_format(char *fname)
+{
+ string_replace(fname,'/','\\');
}
/*******************************************************************
- case insensitive string compararison, length limited
+ show a smb message structure
********************************************************************/
-int StrnCaseCmp(char *s, char *t, int n)
+void show_msg(char *buf)
{
- /* compare until we run out of string, either t or s, or chars */
- /* We *must* use toupper rather than tolower here due to the
- asynchronous upper to lower mapping.
- */
-#if !defined(KANJI_WIN95_COMPATIBILITY)
- /*
- * For completeness we should put in equivalent code for code pages
- * 949 (Korean hangul) and 950 (Big5 Traditional Chinese) here - but
- * doubt anyone wants Samba to behave differently from Win95 and WinNT
- * here. They both treat full width ascii characters as case senstive
- * filenames (ie. they don't do the work we do here).
- * JRA.
- */
+ int i;
+ int bcc=0;
- if(lp_client_code_page() == KANJI_CODEPAGE)
- {
- /* Win95 treats full width ascii characters as case sensitive. */
- int diff;
- for (;n > 0;)
- {
- if (!*s || !*t)
- return toupper (*s) - toupper (*t);
- else if (is_sj_alph (*s) && is_sj_alph (*t))
- {
- diff = sj_toupper2 (*(s+1)) - sj_toupper2 (*(t+1));
- if (diff)
- return diff;
- s += 2;
- t += 2;
- n -= 2;
- }
- else if (is_shift_jis (*s) && is_shift_jis (*t))
- {
- diff = ((int) (unsigned char) *s) - ((int) (unsigned char) *t);
- if (diff)
- return diff;
- diff = ((int) (unsigned char) *(s+1)) - ((int) (unsigned char) *(t+1));
- if (diff)
- return diff;
- s += 2;
- t += 2;
- n -= 2;
- }
- else if (is_shift_jis (*s))
- return 1;
- else if (is_shift_jis (*t))
- return -1;
- else
- {
- diff = toupper (*s) - toupper (*t);
- if (diff)
- return diff;
- s++;
- t++;
- n--;
- }
- }
- return 0;
- }
- else
-#endif /* KANJI_WIN95_COMPATIBILITY */
- {
- while (n && *s && *t && toupper(*s) == toupper(*t))
- {
- s++;
- t++;
- n--;
- }
+ if (DEBUGLEVEL < 5) return;
- /* not run out of chars - strings are different lengths */
- if (n)
- return(toupper(*s) - toupper(*t));
+ 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)));
- /* identical up to where we run out of chars,
- and strings are same length */
- return(0);
- }
-}
+ 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)));
+ }
-/*******************************************************************
- compare 2 strings
-********************************************************************/
-BOOL strequal(char *s1, char *s2)
-{
- if (s1 == s2) return(True);
- if (!s1 || !s2) return(False);
-
- return(StrCaseCmp(s1,s2)==0);
-}
+ bcc = (int)SVAL(buf,smb_vwv+2*(CVAL(buf,smb_wct)));
+
+ DEBUG(5,("smb_bcc=%d\n",bcc));
+
+ if (DEBUGLEVEL < 10) return;
+
+ if (DEBUGLEVEL < 50)
+ {
+ bcc = MIN(bcc, 512);
+ }
+ dump_data(10, smb_buf(buf), bcc);
+}
/*******************************************************************
- compare 2 strings up to and including the nth char.
- ******************************************************************/
-BOOL strnequal(char *s1,char *s2,int n)
+ return the length of an smb packet
+********************************************************************/
+int smb_len(char *buf)
{
- if (s1 == s2) return(True);
- if (!s1 || !s2 || !n) return(False);
-
- return(StrnCaseCmp(s1,s2,n)==0);
+ return( PVAL(buf,3) | (PVAL(buf,2)<<8) | ((PVAL(buf,1)&1)<<16) );
}
/*******************************************************************
- compare 2 strings (case sensitive)
+ set the length of an smb packet
********************************************************************/
-BOOL strcsequal(char *s1,char *s2)
+void _smb_setlen(char *buf,int len)
{
- if (s1 == s2) return(True);
- if (!s1 || !s2) return(False);
-
- return(strcmp(s1,s2)==0);
+ buf[0] = 0;
+ buf[1] = (len&0x10000)>>16;
+ buf[2] = (len&0xFF00)>>8;
+ buf[3] = len&0xFF;
}
-
/*******************************************************************
- convert a string to lower case
+ set the length and marker of an smb packet
********************************************************************/
-void strlower(char *s)
-{
- while (*s)
- {
-#if !defined(KANJI_WIN95_COMPATIBILITY)
- /*
- * For completeness we should put in equivalent code for code pages
- * 949 (Korean hangul) and 950 (Big5 Traditional Chinese) here - but
- * doubt anyone wants Samba to behave differently from Win95 and WinNT
- * here. They both treat full width ascii characters as case senstive
- * filenames (ie. they don't do the work we do here).
- * JRA.
- */
-
- if(lp_client_code_page() == KANJI_CODEPAGE)
- {
- /* Win95 treats full width ascii characters as case sensitive. */
- if (is_shift_jis (*s))
- {
- if (is_sj_upper (s[0], s[1]))
- s[1] = sj_tolower2 (s[1]);
- s += 2;
- }
- else if (is_kana (*s))
- {
- s++;
- }
- else
- {
- if (isupper(*s))
- *s = tolower(*s);
- s++;
- }
- }
- else
-#endif /* KANJI_WIN95_COMPATIBILITY */
- {
- int skip = skip_multibyte_char( *s );
- if( skip != 0 )
- s += skip;
- else
- {
- if (isupper(*s))
- *s = tolower(*s);
- s++;
- }
- }
- }
-}
-
-/*******************************************************************
- convert a string to upper case
-********************************************************************/
-void strupper(char *s)
-{
- while (*s)
- {
-#if !defined(KANJI_WIN95_COMPATIBILITY)
- /*
- * For completeness we should put in equivalent code for code pages
- * 949 (Korean hangul) and 950 (Big5 Traditional Chinese) here - but
- * doubt anyone wants Samba to behave differently from Win95 and WinNT
- * here. They both treat full width ascii characters as case senstive
- * filenames (ie. they don't do the work we do here).
- * JRA.
- */
-
- if(lp_client_code_page() == KANJI_CODEPAGE)
- {
- /* Win95 treats full width ascii characters as case sensitive. */
- if (is_shift_jis (*s))
- {
- if (is_sj_lower (s[0], s[1]))
- s[1] = sj_toupper2 (s[1]);
- s += 2;
- }
- else if (is_kana (*s))
- {
- s++;
- }
- else
- {
- if (islower(*s))
- *s = toupper(*s);
- s++;
- }
- }
- else
-#endif /* KANJI_WIN95_COMPATIBILITY */
- {
- int skip = skip_multibyte_char( *s );
- if( skip != 0 )
- s += skip;
- else
- {
- if (islower(*s))
- *s = toupper(*s);
- s++;
- }
- }
- }
-}
-
-/*******************************************************************
- 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)
-{
- int skip;
- while (*s)
- {
- skip = skip_multibyte_char( *s );
- if( skip != 0 )
- s += skip;
- else
- {
- if (oldc == *s)
- *s = newc;
- s++;
- }
- }
-}
-
-/****************************************************************************
- make a file into unix format
-****************************************************************************/
-void unix_format(char *fname)
-{
- pstring namecopy;
- string_replace(fname,'\\','/');
-
- if (*fname == '/')
- {
- pstrcpy(namecopy,fname);
- pstrcpy(fname,".");
- pstrcat(fname,namecopy);
- }
-}
-
-/****************************************************************************
- make a file into dos format
-****************************************************************************/
-void dos_format(char *fname)
-{
- 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;
-
- if (DEBUGLEVEL < 50)
- {
- bcc = MIN(bcc, 512);
- }
-
- dump_data(10, smb_buf(buf), bcc);
-}
-/*******************************************************************
- return the length of an smb packet
-********************************************************************/
-int smb_len(char *buf)
-{
- return( PVAL(buf,3) | (PVAL(buf,2)<<8) | ((PVAL(buf,1)&1)<<16) );
-}
-
-/*******************************************************************
- set the length of an smb packet
-********************************************************************/
-void _smb_setlen(char *buf,int len)
-{
- buf[0] = 0;
- buf[1] = (len&0x10000)>>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)
+void smb_setlen(char *buf,int len)
{
_smb_setlen(buf,len);
/*******************************************************************
return the number of smb words
********************************************************************/
-int smb_numwords(char *buf)
+static int smb_numwords(char *buf)
{
return (CVAL(buf,smb_wct));
}
/*******************************************************************
return a pointer to the smb_buf data area
********************************************************************/
-int smb_buf_ofs(char *buf)
+static int smb_buf_ofs(char *buf)
{
return (smb_size + CVAL(buf,smb_wct)*2);
}
}
-/*******************************************************************
-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.
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)
- pstrcpy(LastDir,path);
- return(res);
-}
-
-/* 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(sys_getwd(str));
-
- /* init the cache */
- if (!getwd_cache_init)
- {
- getwd_cache_init = True;
- for (i=0;i<MAX_GETWDCACHE;i++)
- {
- string_init(&ino_list[i].text,"");
- ino_list[i].valid = False;
- }
- }
-
- /* Get the inode of the current directory, if this doesn't work we're
- in trouble :-) */
-
- if (stat(".",&st) == -1)
- {
- DEBUG(0,("Very strange, couldn't stat \".\"\n"));
- return(sys_getwd(str));
- }
-
-
- for (i=0; i<MAX_GETWDCACHE; i++)
- if (ino_list[i].valid)
- {
-
- /* If we have found an entry with a matching inode and dev number
- then find the inode number for the directory in the cached string.
- If this agrees with that returned by the stat for the current
- directory then all is o.k. (but make sure it is a directory all
- the same...) */
-
- if (st.st_ino == ino_list[i].inode &&
- st.st_dev == ino_list[i].dev)
- {
- if (stat(ino_list[i].text,&st2) == 0)
- {
- if (st.st_ino == st2.st_ino &&
- st.st_dev == st2.st_dev &&
- (st2.st_mode & S_IFMT) == S_IFDIR)
- {
- pstrcpy (str, ino_list[i].text);
-
- /* promote it for future use */
- array_promote((char *)&ino_list[0],sizeof(ino_list[0]),i);
- return (str);
- }
- else
- {
- /* If the inode is different then something's changed,
- scrub the entry and start from scratch. */
- ino_list[i].valid = False;
- }
- }
- }
- }
-
-
- /* We don't have the information to hand so rely on traditional methods.
- The very slow getcwd, which spawns a process on some systems, or the
- not quite so bad getwd. */
-
- if (!sys_getwd(s))
- {
- DEBUG(0,("Getwd failed, errno %s\n",strerror(errno)));
- return (NULL);
- }
-
- pstrcpy(str,s);
-
- DEBUG(5,("GetWd %s, inode %d, dev %x\n",s,(int)st.st_ino,(int)st.st_dev));
-
- /* add it to the cache */
- i = MAX_GETWDCACHE - 1;
- string_set(&ino_list[i].text,s);
- ino_list[i].dev = st.st_dev;
- ino_list[i].inode = st.st_ino;
- ino_list[i].valid = True;
-
- /* put it at the top of the list */
- array_promote((char *)&ino_list[0],sizeof(ino_list[0]),i);
-
- return (str);
-}
-
-
-
/*******************************************************************
reduce a file name, removing .. elements and checking that
it is below dir in the heirachy. This uses GetWd() and so must be run
widelinks are allowed if widelinks is true
********************************************************************/
+
BOOL reduce_name(char *s,char *dir,BOOL widelinks)
{
#ifndef REDUCE_PATHS
if (!p)
return(True);
- if (!GetWd(wd))
+ if (!dos_GetWd(wd))
{
DEBUG(0,("couldn't getwd for %s %s\n",s,dir));
return(False);
}
- if (ChDir(dir) != 0)
+ if (dos_ChDir(dir) != 0)
{
DEBUG(0,("couldn't chdir to %s\n",dir));
return(False);
}
- if (!GetWd(dir2))
+ if (!dos_GetWd(dir2))
{
DEBUG(0,("couldn't getwd for %s\n",dir));
- ChDir(wd);
+ dos_ChDir(wd);
return(False);
}
*p = '/';
}
- if (ChDir(base_name) != 0)
+ if (dos_ChDir(base_name) != 0)
{
- ChDir(wd);
+ dos_ChDir(wd);
DEBUG(3,("couldn't chdir for %s %s basename=%s\n",s,dir,base_name));
return(False);
}
- if (!GetWd(newname))
+ if (!dos_GetWd(newname))
{
- ChDir(wd);
+ dos_ChDir(wd);
DEBUG(2,("couldn't get wd for %s %s\n",s,dir2));
return(False);
}
}
{
- int l = strlen(dir2);
+ size_t l = strlen(dir2);
if (dir2[l-1] == '/')
l--;
if (strncmp(newname,dir2,l) != 0)
{
- ChDir(wd);
+ dos_ChDir(wd);
DEBUG(2,("Bad access attempt? s=%s dir=%s newname=%s l=%d\n",s,dir2,newname,l));
return(False);
}
pstrcpy(s,newname);
}
- ChDir(wd);
+ dos_ChDir(wd);
if (strlen(s) == 0)
pstrcpy(s,"./");
}
}
+/****************************************************************************
+parse out a directory name from a path name. Assumes dos style filenames.
+****************************************************************************/
+static void dirname_dos(char *path,char *buf)
+{
+ split_at_last_component(path, buf, '\\', NULL);
+}
+
+
/****************************************************************************
expand a wildcard expression, replacing *s with ?s
****************************************************************************/
}
+
/****************************************************************************
-does a string have any uppercase chars in it?
+ make a dir struct
****************************************************************************/
-BOOL strhasupper(char *s)
-{
- while (*s)
- {
-#if !defined(KANJI_WIN95_COMPATIBILITY)
- /*
- * For completeness we should put in equivalent code for code pages
- * 949 (Korean hangul) and 950 (Big5 Traditional Chinese) here - but
- * doubt anyone wants Samba to behave differently from Win95 and WinNT
- * here. They both treat full width ascii characters as case senstive
- * filenames (ie. they don't do the work we do here).
- * JRA.
- */
+void make_dir_struct(char *buf,char *mask,char *fname,SMB_OFF_T size,int mode,time_t date)
+{
+ char *p;
+ pstring mask2;
- if(lp_client_code_page() == KANJI_CODEPAGE)
+ pstrcpy(mask2,mask);
+
+ if ((mode & aDIR) != 0)
+ size = 0;
+
+ memset(buf+1,' ',11);
+ if ((p = strchr(mask2,'.')) != NULL)
{
- /* Win95 treats full width ascii characters as case sensitive. */
- if (is_shift_jis (*s))
- s += 2;
- else if (is_kana (*s))
- s++;
- else
- {
- if (isupper(*s))
- return(True);
- s++;
- }
- }
- else
-#endif /* KANJI_WIN95_COMPATIBILITY */
- {
- int skip = skip_multibyte_char( *s );
- if( skip != 0 )
- s += skip;
- else {
- if (isupper(*s))
- return(True);
- s++;
- }
- }
- }
- return(False);
-}
-
-/****************************************************************************
-does a string have any lowercase chars in it?
-****************************************************************************/
-BOOL strhaslower(char *s)
-{
- while (*s)
- {
-#if !defined(KANJI_WIN95_COMPATIBILITY)
- /*
- * For completeness we should put in equivalent code for code pages
- * 949 (Korean hangul) and 950 (Big5 Traditional Chinese) here - but
- * doubt anyone wants Samba to behave differently from Win95 and WinNT
- * here. They both treat full width ascii characters as case senstive
- * filenames (ie. they don't do the work we do here).
- * JRA.
- */
-
- if(lp_client_code_page() == KANJI_CODEPAGE)
- {
- /* Win95 treats full width ascii characters as case sensitive. */
- if (is_shift_jis (*s))
- {
- if (is_sj_upper (s[0], s[1]))
- return(True);
- if (is_sj_lower (s[0], s[1]))
- return (True);
- s += 2;
- }
- else if (is_kana (*s))
- {
- s++;
- }
- else
- {
- if (islower(*s))
- return(True);
- s++;
- }
- }
- else
-#endif /* KANJI_WIN95_COMPATIBILITY */
- {
- int skip = skip_multibyte_char( *s );
- if( skip != 0 )
- s += skip;
- else {
- if (islower(*s))
- return(True);
- s++;
- }
- }
- }
- return(False);
-}
-
-/****************************************************************************
-find the number of chars in a string
-****************************************************************************/
-int count_chars(char *s,char c)
-{
- int count=0;
-
-#if !defined(KANJI_WIN95_COMPATIBILITY)
- /*
- * For completeness we should put in equivalent code for code pages
- * 949 (Korean hangul) and 950 (Big5 Traditional Chinese) here - but
- * doubt anyone wants Samba to behave differently from Win95 and WinNT
- * here. They both treat full width ascii characters as case senstive
- * filenames (ie. they don't do the work we do here).
- * JRA.
- */
-
- if(lp_client_code_page() == KANJI_CODEPAGE)
- {
- /* Win95 treats full width ascii characters as case sensitive. */
- while (*s)
- {
- if (is_shift_jis (*s))
- s += 2;
- else
- {
- if (*s == c)
- count++;
- s++;
- }
- }
- }
- else
-#endif /* KANJI_WIN95_COMPATIBILITY */
- {
- while (*s)
- {
- int skip = skip_multibyte_char( *s );
- if( skip != 0 )
- s += skip;
- else {
- 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;
-
- pstrcpy(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 = '.';
+ *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));
CVAL(buf,21) = mode;
put_dos_date(buf,22,date);
SSVAL(buf,26,size & 0xFFFF);
- SSVAL(buf,28,size >> 16);
+ SSVAL(buf,28,(size >> 16)&0xFFFF);
StrnCpy(buf+30,fname,12);
if (!case_sensitive)
strupper(buf+30);
/* 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);
+ fd = sys_open("/dev/null",O_RDWR,0);
+ if (fd < 0) fd = sys_open("/dev/null",O_WRONLY,0);
if (fd < 0) {
DEBUG(0,("Can't open /dev/null\n"));
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));
- if(ret <= 0)
- DEBUG(0,("write_socket: Error writing %d bytes to socket %d: ERRNO = %s\n",
- len, fd, strerror(errno) ));
-
- return(ret);
-}
-
-/****************************************************************************
-read from a socket
-****************************************************************************/
-int read_udp_socket(int fd,char *buf,int len)
-{
- int ret;
- struct sockaddr_in sock;
- int socklen;
-
- socklen = sizeof(sock);
- bzero((char *)&sock,socklen);
- bzero((char *)&lastip,sizeof(lastip));
- ret = recvfrom(fd,buf,len,0,(struct sockaddr *)&sock,&socklen);
- if (ret <= 0) {
- DEBUG(2,("read socket failed. ERRNO=%s\n",strerror(errno)));
- return(0);
- }
-
- lastip = sock.sin_addr;
- lastport = ntohs(sock.sin_port);
-
- DEBUG(10,("read_udp_socket: lastip %s lastport %d read: %d\n",
- inet_ntoa(lastip), lastport, ret));
-
- return(ret);
-}
-
-/****************************************************************************
-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)
-{
- fd_set fds;
- int selrtn;
- int readret;
- int nread = 0;
- struct timeval timeout;
-
- /* just checking .... */
- if (maxcnt <= 0) return(0);
-
- smb_read_error = 0;
-
- /* Blocking read */
- if (time_out <= 0) {
- if (mincnt == 0) mincnt = maxcnt;
-
- while (nread < mincnt) {
-#ifdef WITH_SSL
- if(fd == sslFd){
- readret = SSL_read(ssl, buf + nread, maxcnt - nread);
- }else{
- readret = read(fd, buf + nread, maxcnt - nread);
- }
-#else /* WITH_SSL */
- readret = read(fd, buf + nread, maxcnt - nread);
-#endif /* WITH_SSL */
-
- if (readret == 0) {
- smb_read_error = READ_EOF;
- return -1;
- }
-
- if (readret == -1) {
- smb_read_error = READ_ERROR;
- return -1;
- }
- nread += readret;
- }
- 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);
-
- for (nread=0; nread<mincnt; )
- {
- FD_ZERO(&fds);
- FD_SET(fd,&fds);
-
- selrtn = sys_select(&fds,&timeout);
-
- /* Check if error */
- if(selrtn == -1) {
- /* something is wrong. Maybe the socket is dead? */
- smb_read_error = READ_ERROR;
- return -1;
- }
-
- /* Did we timeout ? */
- if (selrtn == 0) {
- smb_read_error = READ_TIMEOUT;
- return -1;
- }
-
-#ifdef WITH_SSL
- if(fd == sslFd){
- readret = SSL_read(ssl, buf + nread, maxcnt - nread);
- }else{
- readret = read(fd, buf + nread, maxcnt - nread);
- }
-#else /* WITH_SSL */
- readret = read(fd, buf+nread, maxcnt-nread);
-#endif /* WITH_SSL */
-
- if (readret == 0) {
- /* we got EOF on the file descriptor */
- smb_read_error = READ_EOF;
- return -1;
- }
-
- if (readret == -1) {
- /* the descriptor is probably dead */
- smb_read_error = READ_ERROR;
- return -1;
- }
-
- nread += readret;
- }
-
- /* 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)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;
-
- smb_read_error = 0;
-
- while (total < N)
- {
-#ifdef WITH_SSL
- if(fd == sslFd){
- ret = SSL_read(ssl, buffer + total, N - total);
- }else{
- ret = read(fd,buffer + total,N - total);
- }
-#else /* WITH_SSL */
- ret = read(fd,buffer + total,N - total);
-#endif /* WITH_SSL */
-
- if (ret == 0)
- {
- smb_read_error = READ_EOF;
- return 0;
- }
- if (ret == -1)
- {
- smb_read_error = READ_ERROR;
- return -1;
- }
- 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)
- {
-#ifdef WITH_SSL
- if(fd == sslFd){
- ret = SSL_write(ssl,buffer + total,N - total);
- }else{
- ret = write(fd,buffer + total,N - total);
- }
-#else /* WITH_SSL */
- ret = write(fd,buffer + total,N - total);
-#endif /* WITH_SSL */
-
- if (ret == -1) return -1;
- if (ret == 0) return total;
-
- total += ret;
- }
- return total;
-}
/****************************************************************************
transfer some data between two fd's
****************************************************************************/
-int transfer_file(int infd,int outfd,int n,char *header,int headlen,int align)
+SMB_OFF_T transfer_file(int infd,int outfd,SMB_OFF_T n,char *header,int headlen,int align)
{
static char *buf=NULL;
static int size=0;
char *buf1,*abuf;
- int total = 0;
+ SMB_OFF_T total = 0;
- DEBUG(4,("transfer_file %d (head=%d) called\n",n,headlen));
+ DEBUG(4,("transfer_file n=%.0f (head=%d) called\n",(double)n,headlen));
if (size == 0) {
size = lp_readsize();
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;
- }
+ {
+ int s = (int)MIN(n,(SMB_OFF_T)size);
+ int ret,ret2=0;
- if (s > ret)
- ret += read(infd,buf1+ret,s-ret);
+ ret = 0;
- 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;
+ if (header && (headlen >= MIN(s,1024))) {
+ buf1 = header;
+ s = headlen;
+ ret = headlen;
+ headlen = 0;
+ header = NULL;
+ } else {
+ buf1 = abuf;
}
- return(total);
-}
-
-/****************************************************************************
-read 4 bytes of a smb packet and return the smb length of the packet
-store the result in the buffer
-This version of the function will return a length of zero on receiving
-a keepalive packet.
-****************************************************************************/
-static int read_smb_length_return_keepalive(int fd,char *inbuf,int timeout)
-{
- int len=0, msg_type;
- BOOL ok=False;
-
- while (!ok)
+ if (header && headlen > 0)
{
- if (timeout > 0)
- ok = (read_with_timeout(fd,inbuf,4,4,timeout) == 4);
- else
- ok = (read_data(fd,inbuf,4) == 4);
-
- if (!ok)
- return(-1);
-
- len = smb_len(inbuf);
- msg_type = CVAL(inbuf,0);
-
- if (msg_type == 0x85)
- DEBUG(5,("Got keepalive packet\n"));
- }
-
- DEBUG(10,("got smb length of %d\n",len));
-
- return(len);
-}
-
-/****************************************************************************
-read 4 bytes of a smb packet and return the smb length of the packet
-store the result in the buffer. This version of the function will
-never return a session keepalive (length of zero).
-****************************************************************************/
-int read_smb_length(int fd,char *inbuf,int timeout)
-{
- int len;
-
- for(;;)
- {
- len = read_smb_length_return_keepalive(fd, inbuf, timeout);
-
- if(len < 0)
- return len;
-
- /* Ignore session keepalives. */
- if(CVAL(inbuf,0) != 0x85)
- break;
- }
-
- return len;
-}
-
-/****************************************************************************
- read an smb from a fd. Note that the buffer *MUST* be of size
- BUFFER_SIZE+SAFETY_MARGIN.
- The timeout is in milli seconds.
-
- This function will return on a
- receipt of a session keepalive packet.
-****************************************************************************/
-BOOL receive_smb(int fd,char *buffer, int timeout)
-{
- int len,ret;
-
- smb_read_error = 0;
-
- bzero(buffer,smb_size + 100);
-
- len = read_smb_length_return_keepalive(fd,buffer,timeout);
- if (len < 0)
- return(False);
-
- if (len > BUFFER_SIZE) {
- DEBUG(0,("Invalid packet length! (%d bytes).\n",len));
- if (len > BUFFER_SIZE + (SAFETY_MARGIN/2))
- exit(1);
- }
-
- if(len > 0) {
- ret = read_data(fd,buffer+4,len);
- if (ret != len) {
- smb_read_error = READ_ERROR;
- return False;
+ ret = MIN(headlen,size);
+ memcpy(buf1,header,ret);
+ headlen -= ret;
+ header += ret;
+ if (headlen <= 0) header = NULL;
}
- }
- return(True);
-}
-
-/****************************************************************************
- read an smb from a fd ignoring all keepalive packets. Note that the buffer
- *MUST* be of size BUFFER_SIZE+SAFETY_MARGIN.
- The timeout is in milli seconds
-
- This is exactly the same as receive_smb except that it never returns
- a session keepalive packet (just as receive_smb used to do).
- receive_smb was changed to return keepalives as the oplock processing means this call
- should never go into a blocking read.
-****************************************************************************/
-
-BOOL client_receive_smb(int fd,char *buffer, int timeout)
-{
- BOOL ret;
-
- for(;;)
- {
- ret = receive_smb(fd, buffer, timeout);
-
- if(ret == False)
- return ret;
-
- /* Ignore session keepalive packets. */
- if(CVAL(buffer,0) != 0x85)
- break;
- }
- return ret;
-}
-
-/****************************************************************************
- read a message from a udp fd.
-The timeout is in milli seconds
-****************************************************************************/
-BOOL receive_local_message(int fd, char *buffer, int buffer_len, int timeout)
-{
- struct sockaddr_in from;
- int fromlen = sizeof(from);
- int32 msg_len = 0;
-
- smb_read_error = 0;
-
- if(timeout != 0)
- {
- struct timeval to;
- fd_set fds;
- int selrtn;
-
- FD_ZERO(&fds);
- FD_SET(fd,&fds);
- to.tv_sec = timeout / 1000;
- to.tv_usec = (timeout % 1000) * 1000;
+ if (s > ret)
+ ret += read(infd,buf1+ret,s-ret);
- selrtn = sys_select(&fds,&to);
-
- /* Check if error */
- if(selrtn == -1)
- {
- /* something is wrong. Maybe the socket is dead? */
- smb_read_error = READ_ERROR;
- return False;
- }
-
- /* Did we timeout ? */
- if (selrtn == 0)
+ if (ret > 0)
{
- smb_read_error = READ_TIMEOUT;
- return False;
+ 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;
}
-
- /*
- * Read a loopback udp message.
- */
- msg_len = recvfrom(fd, &buffer[UDP_CMD_HEADER_LEN],
- buffer_len - UDP_CMD_HEADER_LEN, 0,
- (struct sockaddr *)&from, &fromlen);
-
- if(msg_len < 0)
- {
- DEBUG(0,("receive_local_message. Error in recvfrom. (%s).\n",strerror(errno)));
- return False;
- }
-
- /* Validate message length. */
- if(msg_len > (buffer_len - UDP_CMD_HEADER_LEN))
- {
- DEBUG(0,("receive_local_message: invalid msg_len (%d) max can be %d\n",
- msg_len,
- buffer_len - UDP_CMD_HEADER_LEN));
- return False;
- }
-
- /* Validate message from address (must be localhost). */
- if(from.sin_addr.s_addr != htonl(INADDR_LOOPBACK))
- {
- DEBUG(0,("receive_local_message: invalid 'from' address \
-(was %x should be 127.0.0.1\n", from.sin_addr.s_addr));
- return False;
- }
-
- /* Setup the message header */
- SIVAL(buffer,UDP_CMD_LEN_OFFSET,msg_len);
- SSVAL(buffer,UDP_CMD_PORT_OFFSET,ntohs(from.sin_port));
-
- return True;
-}
-
-/****************************************************************************
- structure to hold a linked list of local messages.
- for processing.
-****************************************************************************/
-
-typedef struct {
- ubi_slNode msg_next;
- char *msg_buf;
- int msg_len;
-} pending_message_list;
-
-static ubi_slList smb_oplock_queue = { NULL, (ubi_slNodePtr)&smb_oplock_queue, 0};
-
-/****************************************************************************
- Function to push a message onto the tail of a linked list of smb messages ready
- for processing.
-****************************************************************************/
-
-static BOOL push_local_message(ubi_slList *list_head, char *buf, int msg_len)
-{
- pending_message_list *msg = (pending_message_list *)
- malloc(sizeof(pending_message_list));
-
- if(msg == NULL)
- {
- DEBUG(0,("push_local_message: malloc fail (1)\n"));
- return False;
- }
-
- msg->msg_buf = (char *)malloc(msg_len);
- if(msg->msg_buf == NULL)
- {
- DEBUG(0,("push_local_message: malloc fail (2)\n"));
- free((char *)msg);
- return False;
- }
-
- memcpy(msg->msg_buf, buf, msg_len);
- msg->msg_len = msg_len;
-
- ubi_slAddTail( list_head, msg);
-
- return True;
-}
-
-/****************************************************************************
- Function to push a smb message onto a linked list of local smb messages ready
- for processing.
-****************************************************************************/
-
-BOOL push_oplock_pending_smb_message(char *buf, int msg_len)
-{
- return push_local_message(&smb_oplock_queue, buf, msg_len);
-}
-
-/****************************************************************************
- Do a select on an two fd's - with timeout.
-
- If a local udp message has been pushed onto the
- queue (this can only happen during oplock break
- processing) return this first.
-
- If a pending smb message has been pushed onto the
- queue (this can only happen during oplock break
- processing) return this next.
-
- If the first smbfd is ready then read an smb from it.
- if the second (loopback UDP) fd is ready then read a message
- from it and setup the buffer header to identify the length
- and from address.
- Returns False on timeout or error.
- Else returns True.
-
-The timeout is in milli seconds
-****************************************************************************/
-BOOL receive_message_or_smb(int smbfd, int oplock_fd,
- char *buffer, int buffer_len,
- int timeout, BOOL *got_smb)
-{
- fd_set fds;
- int selrtn;
- struct timeval to;
-
- smb_read_error = 0;
-
- *got_smb = False;
-
- /*
- * Check to see if we already have a message on the smb queue.
- * If so - copy and return it.
- */
-
- if(ubi_slCount(&smb_oplock_queue) != 0)
- {
- pending_message_list *msg = (pending_message_list *)ubi_slRemHead(&smb_oplock_queue);
- memcpy(buffer, msg->msg_buf, MIN(buffer_len, msg->msg_len));
-
- /* Free the message we just copied. */
- free((char *)msg->msg_buf);
- free((char *)msg);
- *got_smb = True;
-
- DEBUG(5,("receive_message_or_smb: returning queued smb message.\n"));
- return True;
- }
-
- FD_ZERO(&fds);
- FD_SET(smbfd,&fds);
- FD_SET(oplock_fd,&fds);
-
- to.tv_sec = timeout / 1000;
- to.tv_usec = (timeout % 1000) * 1000;
-
- selrtn = sys_select(&fds,timeout>0?&to:NULL);
-
- /* Check if error */
- if(selrtn == -1) {
- /* something is wrong. Maybe the socket is dead? */
- smb_read_error = READ_ERROR;
- return False;
- }
-
- /* Did we timeout ? */
- if (selrtn == 0) {
- smb_read_error = READ_TIMEOUT;
- return False;
- }
-
- if (FD_ISSET(smbfd,&fds))
- {
- *got_smb = True;
- return receive_smb(smbfd, buffer, 0);
- }
- else
- {
- return receive_local_message(oplock_fd, buffer, buffer_len, 0);
- }
+ return(total);
}
-/****************************************************************************
- 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)
+static char *name_ptr(char *buf,int ofs)
{
unsigned char c = *(unsigned char *)(buf+ofs);
/****************************************************************************
return the total storage length of a mangled name
****************************************************************************/
-int name_len( char *s )
- {
- int len;
-
- /* If the two high bits of the byte are set, return 2. */
- if( 0xC0 == (*(unsigned char *)s & 0xC0) )
- return(2);
-
- /* Add up the length bytes. */
- for( len = 1; (*s); s += (*s) + 1 )
- {
- len += *s + 1;
- }
-
- return( len );
- } /* name_len */
-
-/****************************************************************************
-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)
+int name_len(char *s1)
{
- BOOL ret;
- int out_fd;
- struct sockaddr_in sock_out;
-
- if (passive)
- return(True);
+ /* NOTE: this argument _must_ be unsigned */
+ unsigned char *s = (unsigned char *)s1;
+ int len;
- /* create a socket to write to */
- out_fd = socket(AF_INET, type, 0);
- if (out_fd == -1)
- {
- DEBUG(0,("socket failed"));
- return False;
- }
+ /* If the two high bits of the byte are set, return 2. */
+ if (0xC0 == (*s & 0xC0))
+ return(2);
- /* 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);
+ /* Add up the length bytes. */
+ for (len = 1; (*s); s += (*s) + 1) {
+ len += *s + 1;
+ SMB_ASSERT(len < 80);
+ }
- if (!ret)
- DEBUG(0,("Packet send to %s(%d) failed ERRNO=%s\n",
- inet_ntoa(ip),port,strerror(errno)));
+ return(len);
+} /* name_len */
- 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);
- if ((*dest) == NULL) {
- DEBUG(0,("Out of memory in string_init\n"));
- return False;
- }
-
- pstrcpy(*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);
+ struct timeval tval,t1,t2;
+ fd_set fds;
- if (!*pattern) return(False);
+ 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(0,&fds,&tval);
- 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);
+ GetTimeOfDay(&t2);
+ tdiff = TvalDiff(&t1,&t2);
+ }
}
+
/*********************************************************
* Recursive routine that is called by unix_mask_match.
* Does the actual matching. This is the 'original code'
setsid();
#elif defined(TIOCNOTTY)
{
- int i = open("/dev/tty", O_RDWR);
+ int i = sys_open("/dev/tty", O_RDWR, 0);
if (i != -1) {
ioctl(i, (int) TIOCNOTTY, (char *)0);
close(i);
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)
+int set_filelen(int fd, SMB_OFF_T len)
{
/* According to W. R. Stevens advanced UNIX prog. Pure 4.3 BSD cannot
extend a file with ftruncate. Provide alternate implementation
for this */
#ifdef HAVE_FTRUNCATE_EXTEND
- return ftruncate(fd, len);
+ return sys_ftruncate(fd, len);
#else
- struct stat st;
+ SMB_STRUCT_STAT st;
char c = 0;
- long currpos = lseek(fd, 0L, SEEK_CUR);
+ SMB_OFF_T currpos = sys_lseek(fd, (SMB_OFF_T)0, SEEK_CUR);
- if(currpos < 0)
+ if(currpos == -1)
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)
+ if(sys_fstat(fd, &st)<0)
return -1;
#ifdef S_ISFIFO
if(st.st_size == len)
return 0;
if(st.st_size > len)
- return ftruncate(fd, len);
+ return sys_ftruncate(fd, len);
- if(lseek(fd, len-1, SEEK_SET) != len -1)
+ if(sys_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);
+ if(sys_lseek(fd, currpos, SEEK_SET) != currpos)
+ return -1;
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
#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)
- pstrcpy(buf,path);
- else
- {
- *p = 0;
- pstrcpy(buf,path);
- *p = '\\';
- }
-
- return(buf);
-}
-
-
/****************************************************************************
parse out a filename from a path name. Assumes dos style filenames.
****************************************************************************/
/****************************************************************************
expand a pointer to be a particular size
****************************************************************************/
-void *Realloc(void *p,int size)
+void *Realloc(void *p,size_t size)
{
void *ret=NULL;
else
ret = (void *)realloc(p,size);
+#ifdef MEM_MAN
+ {
+ extern FILE *dbf;
+ smb_mem_write_info(ret, dbf);
+ }
+#endif
+
if (!ret)
DEBUG(0,("Memory allocation error: failed to expand to %d bytes\n",size));
}
-/****************************************************************************
- Signal handler for SIGPIPE (write on a disconnected socket)
-****************************************************************************/
-void Abort(void )
-{
- DEBUG(0,("Probably got SIGPIPE\nExiting\n"));
- exit(2);
-}
-
/****************************************************************************
get my own name and IP
****************************************************************************/
}
-/****************************************************************************
-open a socket of the specified type, port and address for incoming data
-****************************************************************************/
-int open_socket_in(int type, int port, int dlevel,uint32 socket_addr)
-{
- struct hostent *hp;
- struct sockaddr_in sock;
- pstring host_name;
- int res;
-
- /* get my host name */
- if (gethostname(host_name, MAXHOSTNAMELEN) == -1)
- { 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);
-
-#ifdef HAVE_SOCK_SIN_LEN
- sock.sin_len = sizeof(sock);
-#endif
- sock.sin_port = htons( port );
- sock.sin_family = hp->h_addrtype;
- sock.sin_addr.s_addr = socket_addr;
- 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 == SMB_PORT || port == NMB_PORT)
- DEBUG(dlevel,("bind failed on port %d socket_addr=%s (%s)\n",
- port,inet_ntoa(sock.sin_addr),strerror(errno)));
- close(res);
-
- if (dlevel > 0 && port < 1000)
- port = 7999;
-
- if (port >= 1000 && port < 9000)
- return(open_socket_in(type,port+1,dlevel,socket_addr));
- }
-
- 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 ,int timeout)
-{
- struct sockaddr_in sock_out;
- int res,ret;
- int connect_loop = 250; /* 250 milliseconds */
- int loops = (timeout * 1000) / connect_loop;
-
- /* 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;
-
- /* set it non-blocking */
- set_blocking(res,False);
-
- DEBUG(3,("Connecting to %s at port %d\n",inet_ntoa(*addr),port));
-
- /* and connect it to the destination */
-connect_again:
- ret = connect(res,(struct sockaddr *)&sock_out,sizeof(sock_out));
-
- /* Some systems return EAGAIN when they mean EINPROGRESS */
- if (ret < 0 && (errno == EINPROGRESS || errno == EALREADY ||
- errno == EAGAIN) && loops--) {
- msleep(connect_loop);
- goto connect_again;
- }
-
- if (ret < 0 && (errno == EINPROGRESS || errno == EALREADY ||
- errno == EAGAIN)) {
- DEBUG(1,("timeout connecting to %s:%d\n",inet_ntoa(*addr),port));
- close(res);
- return -1;
- }
-
-#ifdef EISCONN
- if (ret < 0 && errno == EISCONN) {
- errno = 0;
- ret = 0;
- }
-#endif
-
- if (ret < 0) {
- DEBUG(1,("error connecting to %s:%d (%s)\n",
- inet_ntoa(*addr),port,strerror(errno)));
- close(res);
- return -1;
- }
-
- /* set it blocking again */
- set_blocking(res,True);
-
- return res;
-}
-
-
/****************************************************************************
interpret a protocol description string, with a default
****************************************************************************/
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
/*******************************************************************
matchname - determine if host name matches IP address
******************************************************************/
-static BOOL matchname(char *remotehost,struct in_addr addr)
+BOOL matchname(char *remotehost,struct in_addr addr)
{
struct hostent *hp;
int i;
return False;
}
-/*******************************************************************
- Reset the 'done' variables so after a client process is created
- from a fork call these calls will be re-done. This should be
- expanded if more variables need reseting.
- ******************************************************************/
-
-static BOOL global_client_name_done = False;
-static BOOL global_client_addr_done = False;
-
-void reset_globals_after_fork(void)
-{
- global_client_name_done = False;
- global_client_addr_done = False;
-
- /*
- * Re-seed the random crypto generator, so all smbd's
- * started from the same parent won't generate the same
- * sequence.
- */
- {
- unsigned char dummy;
- generate_random_buffer( &dummy, 1, True);
- }
-}
-
-/*******************************************************************
- return the DNS name of the client
- ******************************************************************/
-char *client_name(int fd)
-{
- struct sockaddr sa;
- struct sockaddr_in *sockin = (struct sockaddr_in *) (&sa);
- int length = sizeof(sa);
- static pstring name_buf;
- struct hostent *hp;
- static int last_fd=-1;
-
- if (global_client_name_done && last_fd == fd)
- return name_buf;
-
- last_fd = fd;
- global_client_name_done = False;
-
- pstrcpy(name_buf,"UNKNOWN");
-
- if (fd == -1) {
- return name_buf;
- }
-
- if (getpeername(fd, &sa, &length) < 0) {
- DEBUG(0,("getpeername failed\n"));
- return name_buf;
- }
-
- /* Look up the remote host name. */
- if ((hp = gethostbyaddr((char *) &sockin->sin_addr,
- sizeof(sockin->sin_addr),
- AF_INET)) == 0) {
- DEBUG(1,("Gethostbyaddr failed for %s\n",client_addr(fd)));
- StrnCpy(name_buf,client_addr(fd),sizeof(name_buf) - 1);
- } else {
- StrnCpy(name_buf,(char *)hp->h_name,sizeof(name_buf) - 1);
- if (!matchname(name_buf, sockin->sin_addr)) {
- DEBUG(0,("Matchname failed on %s %s\n",name_buf,client_addr(fd)));
- pstrcpy(name_buf,"UNKNOWN");
- }
- }
- global_client_name_done = True;
- return name_buf;
-}
-
-/*******************************************************************
- return the IP addr of the client as a string
- ******************************************************************/
-char *client_addr(int fd)
-{
- struct sockaddr sa;
- struct sockaddr_in *sockin = (struct sockaddr_in *) (&sa);
- int length = sizeof(sa);
- static fstring addr_buf;
- static int last_fd = -1;
-
- if (global_client_addr_done && fd == last_fd)
- return addr_buf;
-
- last_fd = fd;
- global_client_addr_done = False;
-
- fstrcpy(addr_buf,"0.0.0.0");
-
- if (fd == -1) {
- return addr_buf;
- }
-
- if (getpeername(fd, &sa, &length) < 0) {
- DEBUG(0,("getpeername failed\n"));
- return addr_buf;
- }
-
- fstrcpy(addr_buf,(char *)inet_ntoa(sockin->sin_addr));
-
- global_client_addr_done = True;
- return addr_buf;
-}
#if (defined(HAVE_NETGROUP) && defined(WITH_AUTOMOUNT))
/******************************************************************
This is Luke's original function with the NIS lookup code
moved out to a separate function.
*******************************************************************/
-
-char *automount_server(char *user_name)
+static char *automount_server(char *user_name)
{
static pstring server_name;
Patch from jkf@soton.ac.uk
Added this to implement %p (NIS auto-map version of %H)
*******************************************************************/
-
-char *automount_path(char *user_name)
+static char *automount_path(char *user_name)
{
static pstring server_path;
{
char *p, *s, *home;
- for (s=str; (p=strchr(s, '%'));s=p) {
- switch (*(p+1)) {
- case 'H':
- if ((home = get_home_dir(conn->user))) {
- string_sub(p,"%H",home);
- } else {
- p += 2;
- }
- break;
-
- case 'P':
- string_sub(p,"%P",conn->connectpath);
- break;
-
- case 'S':
- string_sub(p,"%S",
- lp_servicename(SNUM(conn)));
- break;
-
- case 'g':
- string_sub(p,"%g",
- gidtoname(conn->gid));
- break;
- case 'u':
- string_sub(p,"%u",conn->user);
- break;
-
+ for (s=str; (p=strchr(s, '%'));s=p)
+ {
+ switch (*(p+1))
+ {
+ case 'H':
+ if ((home = get_home_dir(conn->user)) != NULL) {
+ string_sub(p,"%H",home);
+ } else {
+ p += 2;
+ }
+ break;
+
/* Patch from jkf@soton.ac.uk Left the %N (NIS
* server name) in standard_sub_basic as it is
* a feature for logon servers, hence uses the
* here as it is used instead of the default
* "path =" string in [homes] and so needs the
* service name, not the username. */
- case 'p':
- string_sub(p,"%p",
- automount_path(lp_servicename(SNUM(conn))));
- break;
- case '\0':
- p++;
- break; /* don't run off the end of the string
- */
-
- default: p+=2;
- break;
+ case 'p': string_sub(p,"%p", automount_path(lp_servicename(SNUM(conn)))); break;
+ case 'P': string_sub(p,"%P",conn->connectpath); break;
+ case 'S': string_sub(p,"%S", lp_servicename(SNUM(conn))); break;
+ case 'g': string_sub(p,"%g", gidtoname(conn->gid)); break;
+ case 'u': string_sub(p,"%u", conn->user); break;
+
+ case '\0': p++; break; /* don't run off the end of the string */
+ default : p+=2; break;
}
}
}
-/*******************************************************************
-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);
-}
-
/****************************************************************************
a wrapper for gethostbyname() that tries with all lower and all upper case
if the initial name fails
****************************************************************************/
-struct hostent *Get_Hostbyname(char *name)
+struct hostent *Get_Hostbyname(const char *name)
{
char *name2 = strdup(name);
struct hostent *ret;
/****************************************************************************
check if a process exists. Does this work on all unixes?
****************************************************************************/
+
BOOL process_exists(int pid)
{
return(kill(pid,0) == 0 || errno != ESRCH);
}
+/****************************************************************************
+Setup the groups a user belongs to.
+****************************************************************************/
+int get_unixgroups(char *user, uid_t uid, gid_t gid, int *p_ngroups, gid_t **p_groups)
+{
+ int i,ngroups;
+ gid_t grp = 0;
+ gid_t *groups = NULL;
+
+ if (-1 == initgroups(user,gid))
+ {
+ if (getuid() == 0)
+ {
+ DEBUG(0,("Unable to initgroups!\n"));
+ if (gid < 0 || gid > 16000 || uid < 0 || uid > 16000)
+ {
+ DEBUG(0,("This is probably a problem with the account %s\n", user));
+ }
+ }
+ return -1;
+ }
+
+ ngroups = sys_getgroups(0,&grp);
+ if (ngroups <= 0)
+ {
+ ngroups = 32;
+ }
+
+ if((groups = (gid_t *)malloc(sizeof(gid_t)*ngroups)) == NULL)
+ {
+ DEBUG(0,("get_unixgroups malloc fail !\n"));
+ return -1;
+ }
+
+ ngroups = sys_getgroups(ngroups,groups);
+
+ (*p_ngroups) = ngroups;
+ (*p_groups) = groups;
+
+ DEBUG( 3, ( "%s is in %d groups: ", user, ngroups ) );
+ for (i = 0; i < ngroups; i++ )
+ {
+ DEBUG( 3, ( "%s%d", (i ? ", " : ""), (int)groups[i] ) );
+ }
+ DEBUG( 3, ( "\n" ) );
+
+ return 0;
+}
+
/*******************************************************************
turn a uid into a user name
********************************************************************/
-char *uidtoname(int uid)
+char *uidtoname(uid_t uid)
{
static char name[40];
struct passwd *pass = getpwuid(uid);
if (pass) return(pass->pw_name);
- slprintf(name, sizeof(name) - 1, "%d",uid);
+ slprintf(name, sizeof(name) - 1, "%d",(int)uid);
return(name);
}
+
/*******************************************************************
turn a gid into a group name
********************************************************************/
-char *gidtoname(int gid)
+
+char *gidtoname(gid_t gid)
{
static char name[40];
struct group *grp = getgrgid(gid);
if (grp) return(grp->gr_name);
- slprintf(name,sizeof(name) - 1, "%d",gid);
+ slprintf(name,sizeof(name) - 1, "%d",(int)gid);
return(name);
}
-#if AJT
/*******************************************************************
-my own panic function - not suitable for general use
+turn a group name into a gid
+********************************************************************/
+
+BOOL nametogid(const char *name, gid_t *gid)
+{
+ struct group *grp = getgrnam(name);
+ if (grp)
+ {
+ *gid = grp->gr_gid;
+ return True;
+ }
+ else if (isdigit(name[0]))
+ {
+ *gid = (gid_t)get_number(name);
+ return True;
+ }
+ else
+ {
+ return False;
+ }
+}
+
+/*******************************************************************
+turn a user name into a uid
+********************************************************************/
+BOOL nametouid(const char *name, uid_t *uid)
+{
+ struct passwd *pass = Get_Pwnam(name, False);
+ if (pass)
+ {
+ *uid = pass->pw_uid;
+ return True;
+ }
+ else if (isdigit(name[0]))
+ {
+ *uid = (uid_t)get_number(name);
+ return True;
+ }
+ else
+ {
+ return False;
+ }
+}
+
+/*******************************************************************
+something really nasty happened - panic!
********************************************************************/
-void ajt_panic(void)
+void smb_panic(char *why)
{
- system("/usr/bin/X11/xedit -display :0 /tmp/ERROR_FAULT");
+ char *cmd = lp_panic_action();
+ if (cmd && *cmd) {
+ system(cmd);
+ }
+ DEBUG(0,("PANIC: %s\n", why));
+ dbgflush();
+ abort();
}
-#endif
/*******************************************************************
a readdir wrapper which just returns the file name
-also return the inode number if requested
********************************************************************/
-char *readdirname(void *p)
+char *readdirname(DIR *p)
{
struct dirent *ptr;
char *dname;
{
static pstring buf;
memcpy(buf, dname, NAMLEN(ptr)+1);
- unix_to_dos(buf, True);
dname = buf;
}
/****************************************************************************
routine to do file locking
****************************************************************************/
-BOOL fcntl_lock(int fd,int op,uint32 offset,uint32 count,int type)
+BOOL fcntl_lock(int fd, int op, SMB_OFF_T offset, SMB_OFF_T count, int type)
{
#if HAVE_FCNTL_LOCK
- struct flock lock;
+ SMB_STRUCT_FLOCK lock;
int ret;
- /*
- * FIXME.
- * NB - this code will need re-writing to cope with large (64bit)
- * lock requests. JRA.
- */
-
if(lp_ole_locking_compat()) {
- uint32 mask = 0xC0000000;
+ SMB_OFF_T mask2= ((SMB_OFF_T)0x3) << (SMB_OFF_T_BITS-4);
+ SMB_OFF_T mask = (mask2<<2);
/* make sure the count is reasonable, we might kill the lockd otherwise */
count &= ~mask;
still allows OLE2 apps to operate, but should stop lockd from
dieing */
if ((offset & mask) != 0)
- offset = (offset & ~mask) | ((offset & mask) >> 2);
+ offset = (offset & ~mask) | (((offset & mask) >> 2) & mask2);
} else {
- uint32 mask = ((unsigned)1<<31);
- int32 s_count = (int32) count; /* Signed count. */
- int32 s_offset = (int32)offset; /* Signed offset. */
+ SMB_OFF_T mask2 = ((SMB_OFF_T)0x4) << (SMB_OFF_T_BITS-4);
+ SMB_OFF_T mask = (mask2<<1);
+ SMB_OFF_T neg_mask = ~mask;
/* interpret negative counts as large numbers */
- if (s_count < 0)
- s_count &= ~mask;
+ if (count < 0)
+ count &= ~mask;
/* no negative offsets */
- if(s_offset < 0)
- s_offset &= ~mask;
+ if(offset < 0)
+ offset &= ~mask;
/* count + offset must be in range */
- while ((s_offset < 0 || (s_offset + s_count < 0)) && mask)
+ while ((offset < 0 || (offset + count < 0)) && mask)
{
- s_offset &= ~mask;
- mask = mask >> 1;
+ offset &= ~mask;
+ mask = ((mask >> 1) & neg_mask);
}
-
- offset = (uint32)s_offset;
- count = (uint32)s_count;
}
-
- DEBUG(8,("fcntl_lock %d %d %d %d %d\n",fd,op,(int)offset,(int)count,type));
+ DEBUG(8,("fcntl_lock %d %d %.0f %.0f %d\n",fd,op,(double)offset,(double)count,type));
lock.l_type = type;
lock.l_whence = SEEK_SET;
- lock.l_start = (int)offset;
- lock.l_len = (int)count;
+ lock.l_start = offset;
+ lock.l_len = count;
lock.l_pid = 0;
errno = 0;
ret = fcntl(fd,op,&lock);
+ if (errno == EFBIG)
+ {
+ if( DEBUGLVL( 0 ))
+ {
+ dbgtext("fcntl_lock: WARNING: lock request at offset %.0f, length %.0f returned\n", (double)offset,(double)count);
+ dbgtext("a 'file too large' error. This can happen when using 64 bit lock offsets\n");
+ dbgtext("on 32 bit NFS mounted file systems. Retrying with 32 bit truncated length.\n");
+ }
+ /* 32 bit NFS file system, retry with smaller offset */
+ errno = 0;
+ lock.l_len = count & 0xffffffff;
+ 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 (op == SMB_F_GETLK)
+ {
+ if ((ret != -1) &&
+ (lock.l_type != F_UNLCK) &&
+ (lock.l_pid != 0) &&
+ (lock.l_pid != getpid()))
{
- 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,(int)lock.l_pid));
- return(True);
- }
-
- /* it must be not locked or locked by me */
- return(False);
+ DEBUG(3,("fd %d is locked by pid %d\n",fd,(int)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);
- }
+ {
+ DEBUG(3,("lock failed at offset %.0f count %.0f op %d type %d (%s)\n",
+ (double)offset,(double)count,op,type,strerror(errno)));
- return(False);
+ /* 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(8,("Lock call successful\n"));
#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);
-}
-
/*******************************************************************
is the name specified one of my netbios names
returns true is it is equal, false otherwise
/*******************************************************************
-skip past some unicode strings in a buffer
-********************************************************************/
-char *skip_unicode_string(char *buf,int n)
-{
- while (n--)
- {
- while (*buf)
- buf += 2;
- buf += 2;
- }
- return(buf);
-}
-
-/*******************************************************************
-Return a ascii version of a unicode string
-Hack alert: uses fixed buffer(s) and only handles ascii strings
-********************************************************************/
-#define MAXUNI 1024
-char *unistrn2(uint16 *buf, int len)
-{
- static char lbufs[8][MAXUNI];
- static int nexti;
- char *lbuf = lbufs[nexti];
- char *p;
-
- nexti = (nexti+1)%8;
-
- DEBUG(10, ("unistrn2: "));
-
- for (p = lbuf; *buf && p-lbuf < MAXUNI-2 && len > 0; len--, p++, buf++)
- {
- DEBUG(10, ("%4x ", *buf));
- *p = *buf;
- }
-
- DEBUG(10,("\n"));
-
- *p = 0;
- return lbuf;
-}
-
-/*******************************************************************
-Return a ascii version of a unicode string
-Hack alert: uses fixed buffer(s) and only handles ascii strings
-********************************************************************/
-#define MAXUNI 1024
-char *unistr2(uint16 *buf)
-{
- static char lbufs[8][MAXUNI];
- static int nexti;
- char *lbuf = lbufs[nexti];
- char *p;
-
- nexti = (nexti+1)%8;
-
- DEBUG(10, ("unistr2: "));
-
- for (p = lbuf; *buf && p-lbuf < MAXUNI-2; p++, buf++)
- {
- DEBUG(10, ("%4x ", *buf));
- *p = *buf;
- }
-
- DEBUG(10,("\n"));
-
- *p = 0;
- return lbuf;
-}
-
-/*******************************************************************
-create a null-terminated unicode string from a null-terminated ascii string.
-return number of unicode chars copied, excluding the null character.
-
-only handles ascii strings
-********************************************************************/
-#define MAXUNI 1024
-int struni2(uint16 *p, char *buf)
-{
- int len = 0;
-
- if (p == NULL) return 0;
-
- DEBUG(10, ("struni2: "));
-
- if (buf != NULL)
- {
- for (; *buf && len < MAXUNI-2; len++, p++, buf++)
- {
- DEBUG(10, ("%2x ", *buf));
- *p = *buf;
- }
-
- DEBUG(10,("\n"));
- }
-
- *p = 0;
-
- return len;
-}
-
-/*******************************************************************
-Return a ascii version of a unicode string
-Hack alert: uses fixed buffer(s) and only handles ascii strings
+align a pointer to a multiple of 2 bytes
********************************************************************/
-#define MAXUNI 1024
-char *unistr(char *buf)
+char *align2(char *q, char *base)
{
- static char lbufs[8][MAXUNI];
- static int nexti;
- char *lbuf = lbufs[nexti];
- char *p;
-
- nexti = (nexti+1)%8;
-
- for (p = lbuf; *buf && p-lbuf < MAXUNI-2; p++, buf += 2)
+ if ((q - base) & 1)
{
- *p = *buf;
+ q++;
}
- *p = 0;
- return lbuf;
+ return q;
}
-/*******************************************************************
-strncpy for unicode strings
-********************************************************************/
-int unistrncpy(char *dst, char *src, int len)
+void out_ascii(FILE *f, unsigned char *buf,int len)
{
- int num_wchars = 0;
-
- while (*src && len > 0)
+ int i;
+ for (i=0;i<len;i++)
{
- *dst++ = *src++;
- *dst++ = *src++;
- len--;
- num_wchars++;
+ fprintf(f, "%c", isprint(buf[i])?buf[i]:'.');
}
- *dst++ = 0;
- *dst++ = 0;
-
- return num_wchars;
}
-
-/*******************************************************************
-strcpy for unicode strings. returns length (in num of wide chars)
-********************************************************************/
-int unistrcpy(char *dst, char *src)
+void out_data(FILE *f,char *buf1,int len, int per_line)
{
- int num_wchars = 0;
-
- while (*src)
+ unsigned char *buf = (unsigned char *)buf1;
+ int i=0;
+ if (len<=0)
{
- *dst++ = *src++;
- *dst++ = *src++;
- num_wchars++;
+ return;
}
- *dst++ = 0;
- *dst++ = 0;
-
- return num_wchars;
-}
-
-/*******************************************************************
-safe string copy into a known length string. maxlength does not
-include the terminating zero.
-********************************************************************/
-char *safe_strcpy(char *dest, char *src, int maxlength)
-{
- int len;
-
- if (!dest) {
- DEBUG(0,("ERROR: NULL dest in safe_strcpy\n"));
- return NULL;
- }
-
- if (!src) {
- *dest = 0;
- return dest;
- }
-
- len = strlen(src);
-
- if (len > maxlength) {
- DEBUG(0,("ERROR: string overflow by %d in safe_strcpy [%.50s]\n",
- len-maxlength, src));
- len = maxlength;
- }
-
- memcpy(dest, src, len);
- dest[len] = 0;
- return dest;
-}
-
-/*******************************************************************
-safe string cat into a string. maxlength does not
-include the terminating zero.
-********************************************************************/
-char *safe_strcat(char *dest, char *src, int maxlength)
-{
- int src_len, dest_len;
- if (!dest) {
- DEBUG(0,("ERROR: NULL dest in safe_strcat\n"));
- return NULL;
- }
-
- if (!src) {
- return dest;
- }
-
- src_len = strlen(src);
- dest_len = strlen(dest);
-
- if (src_len + dest_len > maxlength) {
- DEBUG(0,("ERROR: string overflow by %d in safe_strcat [%.50s]\n",
- src_len + dest_len - maxlength, src));
- src_len = maxlength - dest_len;
- }
-
- memcpy(&dest[dest_len], src, src_len);
- dest[dest_len + src_len] = 0;
- return dest;
-}
-
-/*******************************************************************
-align a pointer to a multiple of 4 bytes
-********************************************************************/
-char *align4(char *q, char *base)
-{
- if ((q - base) & 3)
+ fprintf(f, "[%03X] ",i);
+ for (i=0;i<len;)
{
- q += 4 - ((q - base) & 3);
+ fprintf(f, "%02X ",(int)buf[i]);
+ i++;
+ if (i%(per_line/2) == 0) fprintf(f, " ");
+ if (i%per_line == 0)
+ {
+ out_ascii(f,&buf[i-per_line ],per_line/2); fprintf(f, " ");
+ out_ascii(f,&buf[i-per_line/2],per_line/2); fprintf(f, "\n");
+ if (i<len) fprintf(f, "[%03X] ",i);
+ }
}
- return q;
-}
-
-/*******************************************************************
-align a pointer to a multiple of 2 bytes
-********************************************************************/
-char *align2(char *q, char *base)
-{
- if ((q - base) & 1)
+ if ((i%per_line) != 0)
{
- q++;
- }
- return q;
-}
+ int n;
-/*******************************************************************
-align a pointer to a multiple of align_offset bytes. looks like it
-will work for offsets of 0, 2 and 4...
-********************************************************************/
-char *align_offset(char *q, char *base, int align_offset_len)
-{
- int mod = ((q - base) & (align_offset_len-1));
- if (align_offset_len != 0 && mod != 0)
- {
- q += align_offset_len - mod;
+ n = per_line - (i%per_line);
+ fprintf(f, " ");
+ if (n>(per_line/2)) fprintf(f, " ");
+ while (n--)
+ {
+ fprintf(f, " ");
+ }
+ n = MIN(per_line/2,i%per_line);
+ out_ascii(f,&buf[i-(i%per_line)],n); fprintf(f, " ");
+ n = (i%per_line) - n;
+ if (n>0) out_ascii(f,&buf[i-n],n);
+ fprintf(f, "\n");
}
- return q;
}
void print_asc(int level, unsigned char *buf,int len)
return spaces;
}
-/*****************************************************************
- Convert a SID to an ascii string.
-*****************************************************************/
-
-char *sid_to_string(pstring sidstr_out, DOM_SID *sid)
+/*****************************************************************************
+ * Provide a checksum on a string
+ *
+ * Input: s - the null-terminated character string for which the checksum
+ * will be calculated.
+ *
+ * Output: The checksum value calculated for s.
+ *
+ * ****************************************************************************
+ */
+int str_checksum(const char *s)
{
- char subauth[16];
- int i;
- /* BIG NOTE: this function only does SIDS where the identauth is not >= 2^32 */
- uint32 ia = (sid->id_auth[5]) +
- (sid->id_auth[4] << 8 ) +
- (sid->id_auth[3] << 16) +
- (sid->id_auth[2] << 24);
-
- slprintf(sidstr_out, sizeof(pstring) - 1, "S-%d-%d", sid->sid_rev_num, ia);
+ int res = 0;
+ int c;
+ int i=0;
+
+ while(*s) {
+ c = *s;
+ res ^= (c << (i % 15)) ^ (c >> (15-(i%15)));
+ s++;
+ i++;
+ }
+ return(res);
+} /* str_checksum */
- for (i = 0; i < sid->num_auths; i++)
- {
- slprintf(subauth, sizeof(subauth)-1, "-%d", sid->sub_auths[i]);
- pstrcat(sidstr_out, subauth);
- }
- DEBUG(7,("sid_to_string returning %s\n", sidstr_out));
- return sidstr_out;
-}
/*****************************************************************
- Convert a string to a SID. Returns True on success, False on fail.
+zero a memory area then free it. Used to catch bugs faster
*****************************************************************/
-
-BOOL string_to_sid(DOM_SID *sidout, char *sidstr)
+void zero_free(void *p, size_t size)
{
- pstring tok;
- char *p = sidstr;
- /* BIG NOTE: this function only does SIDS where the identauth is not >= 2^32 */
- uint32 ia;
+ memset(p, 0, size);
+ free(p);
+}
- memset((char *)sidout, '\0', sizeof(DOM_SID));
- if(StrnCaseCmp( sidstr, "S-", 2)) {
- DEBUG(0,("string_to_sid: Sid %s does not start with 'S-'.\n", sidstr));
- return False;
- }
+/*****************************************************************
+set our open file limit to a requested max and return the limit
+*****************************************************************/
+int set_maxfiles(int requested_max)
+{
+#if (defined(HAVE_GETRLIMIT) && defined(RLIMIT_NOFILE))
+ struct rlimit rlp;
+ getrlimit(RLIMIT_NOFILE, &rlp);
+ /* Set the fd limit to be real_max_open_files + MAX_OPEN_FUDGEFACTOR to
+ * account for the extra fd we need
+ * as well as the log files and standard
+ * handles etc. */
+ rlp.rlim_cur = MIN(requested_max,rlp.rlim_max);
+ setrlimit(RLIMIT_NOFILE, &rlp);
+ getrlimit(RLIMIT_NOFILE, &rlp);
+ return rlp.rlim_cur;
+#else
+ /*
+ * No way to know - just guess...
+ */
+ return requested_max;
+#endif
+}
- p += 2;
- if(!next_token(&p, tok, "-")) {
- DEBUG(0,("string_to_sid: Sid %s is not in a valid format.\n", sidstr));
- return False;
- }
- /* Get the revision number. */
- sidout->sid_rev_num = atoi(tok);
+/*****************************************************************
+ splits out the last subkey of a key
+ *****************************************************************/
+void reg_get_subkey(char *full_keyname, char *key_name, char *subkey_name)
+{
+ split_at_last_component(full_keyname, key_name, '\\', subkey_name);
+}
- if(!next_token(&p, tok, "-")) {
- DEBUG(0,("string_to_sid: Sid %s is not in a valid format.\n", sidstr));
- return False;
- }
+/*****************************************************************
+ splits out the start of the key (HKLM or HKU) and the rest of the key
+ *****************************************************************/
+BOOL reg_split_key(char *full_keyname, uint32 *reg_type, char *key_name)
+{
+ pstring tmp;
- /* identauth in decimal should be < 2^32 */
- ia = atoi(tok);
+ if (!next_token(&full_keyname, tmp, "\\", sizeof(tmp)))
+ {
+ return False;
+ }
- /* NOTE - the ia value is in big-endian format. */
- sidout->id_auth[0] = 0;
- sidout->id_auth[1] = 0;
- sidout->id_auth[2] = (ia & 0xff000000) >> 24;
- sidout->id_auth[3] = (ia & 0x00ff0000) >> 16;
- sidout->id_auth[4] = (ia & 0x0000ff00) >> 8;
- sidout->id_auth[5] = (ia & 0x000000ff);
+ (*reg_type) = 0;
- sidout->num_auths = 0;
+ DEBUG(10, ("reg_split_key: hive %s\n", tmp));
- while(next_token(&p, tok, "-") && sidout->num_auths < MAXSUBAUTHS) {
- /*
- * NOTE - the subauths are in native machine-endian format. They
- * are converted to little-endian when linearized onto the wire.
- */
- sidout->sub_auths[sidout->num_auths++] = atoi(tok);
- }
+ if (strequal(tmp, "HKLM") || strequal(tmp, "HKEY_LOCAL_MACHINE"))
+ {
+ (*reg_type) = HKEY_LOCAL_MACHINE;
+ }
+ else if (strequal(tmp, "HKU") || strequal(tmp, "HKEY_USERS"))
+ {
+ (*reg_type) = HKEY_USERS;
+ }
+ else
+ {
+ DEBUG(10,("reg_split_key: unrecognised hive key %s\n", tmp));
+ return False;
+ }
+
+ if (next_token(NULL, tmp, "\n\r", sizeof(tmp)))
+ {
+ fstrcpy(key_name, tmp);
+ }
+ else
+ {
+ key_name[0] = 0;
+ }
- DEBUG(7,("string_to_sid: converted SID %s ok\n", sidstr));
+ DEBUG(10, ("reg_split_key: name %s\n", key_name));
- return True;
+ return True;
}
-/*****************************************************************************
- * Provide a checksum on a string
- *
- * Input: s - the nul-terminated character string for which the checksum
- * will be calculated.
- *
- * Output: The checksum value calculated for s.
- *
- * ****************************************************************************
- */
-int str_checksum(char *s)
+/****************************************************************************
+ become the specified uid - permanently !
+****************************************************************************/
+BOOL become_user_permanently(uid_t uid, gid_t gid)
{
- int res = 0;
- int c;
- int i=0;
+ /* now completely lose our privilages. This is a fairly paranoid
+ way of doing it, but it does work on all systems that I know of */
+
+#ifdef HAVE_SETRESUID
+ /*
+ * Firstly ensure all our uids are set to root.
+ */
+ setresgid(0,0,0);
+ setresuid(0,0,0);
+
+ /*
+ * Now ensure we change all our gids.
+ */
+ setresgid(gid,gid,gid);
- while(*s) {
- c = *s;
- res ^= (c << (i % 15)) ^ (c >> (15-(i%15)));
- s++;
- i++;
+ /*
+ * Now ensure all the uids are the user.
+ */
+ setresuid(uid,uid,uid);
+#else
+ /*
+ * Firstly ensure all our uids are set to root.
+ */
+ setuid(0);
+ seteuid(0);
+
+ /*
+ * Now ensure we change all our gids.
+ */
+ setgid(gid);
+ setegid(gid);
+
+ /*
+ * Now ensure all the uids are the user.
+ */
+ setuid(uid);
+ seteuid(uid);
+#endif
+
+ if (getuid() != uid || geteuid() != uid ||
+ getgid() != gid || getegid() != gid) {
+ /* We failed to lose our privilages. */
+ return False;
}
- return(res);
-} /* str_checksum */
+
+ return(True);
+}