if(!strcmp(lname,"-")) {
handle = fileno(stdout);
} else {
- handle = open(lname,O_WRONLY|O_CREAT|O_TRUNC,0644);
+ handle = sys_open(lname,O_WRONLY|O_CREAT|O_TRUNC,0644);
newhandle = True;
}
if (handle < 0) {
f = stdin;
/* size of file is not known */
} else {
- f = fopen(lname,"r");
+ f = sys_fopen(lname,"r");
}
if (!f) {
"/bin/ls %s > %s",p,tmpname);
system(cmd);
- f = fopen(tmpname,"r");
+ f = sys_fopen(tmpname,"r");
if (!f) continue;
while (!feof(f)) {
sscanf(p, "%d", &fd);
close_it = False;
} else if ((p = getenv("PASSWD_FILE")) != NULL) {
- fd = open(p, O_RDONLY);
+ fd = sys_open(p, O_RDONLY, 0);
pstrcpy(spec, p);
if (fd < 0) {
fprintf(stderr, "Error opening PASSWD_FILE %s: %s\n",
clipn = 0;
buf[MAXPATHLEN] = '\0'; /* guarantee null-termination */
- if ((inclusion = fopen(filename, "r")) == NULL) {
+ if ((inclusion = sys_fopen(filename, "r")) == NULL) {
/* XXX It would be better to include a reason for failure, but without
* autoconf, it's hard to use strerror, sys_errlist, etc.
*/
}
tarhandle=-1;
} else
- if ((tar_type=='x' && (tarhandle = open(argv[Optind], O_RDONLY)) == -1)
- || (tar_type=='c' && (tarhandle=creat(argv[Optind], 0644)) < 0))
+ if ((tar_type=='x' && (tarhandle = sys_open(argv[Optind], O_RDONLY, 0)) == -1)
+ || (tar_type=='c' && (tarhandle=sys_creat(argv[Optind], 0644)) < 0))
{
DEBUG(0,("Error opening local file %s - %s\n",
argv[Optind], strerror(errno)));
fi
done
-for ac_func in setuidx setgroups mktime rename ftruncate stat64 fstat64 lstat64
+for ac_func in setuidx setgroups mktime rename ftruncate stat64 fstat64 lstat64 fopen64
do
echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
echo "configure:3776: checking for $ac_func" >&5
fi
done
-for ac_func in srandom random srand rand setenv
+for ac_func in srandom random srand rand setenv mmap64
do
echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
echo "configure:3941: checking for $ac_func" >&5
AC_CHECK_FUNCS(memmove vsnprintf snprintf setsid glob strpbrk pipe crypt16 getauthuid)
AC_CHECK_FUNCS(strftime sigprocmask sigblock sigaction innetgr)
AC_CHECK_FUNCS(initgroups select rdchk getgrnam pathconf putprpwnam)
-AC_CHECK_FUNCS(setuidx setgroups mktime rename ftruncate stat64 fstat64 lstat64)
+AC_CHECK_FUNCS(setuidx setgroups mktime rename ftruncate stat64 fstat64 lstat64 fopen64)
AC_CHECK_FUNCS(set_auth_parameters atexit grantpt getspnam dup2 lseek64 ftruncate64)
AC_CHECK_FUNCS(fseek64 ftell64 bigcrypt getprpwnam setluid yp_get_default_domain getpwanam)
-AC_CHECK_FUNCS(srandom random srand rand setenv)
+AC_CHECK_FUNCS(srandom random srand rand setenv mmap64)
# syscall() is needed for smbwrapper.
AC_CHECK_FUNCS(syscall)
*************************************************************************/
BOOL iterate_getuseraliasnam(char *user_name, LOCAL_GRP **alss, int *num_alss)
{
- LOCAL_GRP *als;
+ LOCAL_GRP *als = NULL;
LOCAL_GRP_MEMBER *mem = NULL;
int num_mem = 0;
void *fp = NULL;
DEBUG(10, ("search for useralias by name: %s\n", user_name));
- if (user_name == NULL || als == NULL || num_alss == NULL)
+ if (user_name == NULL || alss == NULL || num_alss == NULL)
{
return False;
}
*************************************************************************/
BOOL enumdomaliases(LOCAL_GRP **alss, int *num_alss)
{
- LOCAL_GRP *als;
+ LOCAL_GRP *als = NULL;
void *fp = NULL;
DEBUG(10, ("enum user aliases\n"));
- if (als == NULL || num_alss == NULL)
+ if (alss == NULL || num_alss == NULL)
{
return False;
}
pstring linebuf;
char *p;
- size_t linebuf_len;
aldb_init_als(&al_buf);
/*
* Scan the file, a line at a time and check if the name matches.
*/
- while ((linebuf_len = getfileline(vp, linebuf, sizeof(linebuf))) > 0)
+ while (getfileline(vp, linebuf, sizeof(linebuf)) > 0)
{
/* get alias name */
uint8 type;
BOOL found = False;
- if (isdigit(name))
+ if (isdigit(name[0]))
{
uint32 rid = get_number(name);
sid_copy(&sid, &global_sam_sid);
pstring linebuf;
char *p;
- size_t linebuf_len;
gpdb_init_grp(&gp_buf);
/*
* Scan the file, a line at a time and check if the name matches.
*/
- while ((linebuf_len = getfileline(vp, linebuf, sizeof(linebuf))) > 0)
+ while (getfileline(vp, linebuf, sizeof(linebuf)) > 0)
{
/* get group name */
/* Define if you have the execl function. */
#undef HAVE_EXECL
+/* Define if you have the fopen64 function. */
+#undef HAVE_FOPEN64
+
/* Define if you have the fseek64 function. */
#undef HAVE_FSEEK64
/* Define if you have the mktime function. */
#undef HAVE_MKTIME
+/* Define if you have the mmap64 function. */
+#undef HAVE_MMAP64
+
/* Define if you have the open64 function. */
#undef HAVE_OPEN64
SMB_OFF_T sys_lseek(int fd, SMB_OFF_T offset, int whence);
int sys_fseek(FILE *fp, SMB_OFF_T offset, int whence);
SMB_OFF_T sys_ftell(FILE *fp);
+int sys_creat(const char *path, mode_t mode);
+int sys_open(const char *path, int oflag, mode_t mode);
+FILE *sys_fopen(const char *path, const char *type);
+void *sys_mmap(void *addr, size_t len, int prot, int flags, int fd, SMB_OFF_T offset);
int dos_unlink(char *fname);
int dos_open(char *fname,int flags,mode_t mode);
DIR *dos_opendir(char *dname);
/*The following definitions come from lib/util_str.c */
void set_first_token(char *ptr);
-BOOL next_token(char **ptr,char *buff,char *sep, int bufsize);
+BOOL next_token(char **ptr,char *buff,char *sep, size_t bufsize);
char **toktocliplist(int *ctok, char *sep);
int StrCaseCmp(const char *s, const char *t);
-int StrnCaseCmp(char *s, char *t, int n);
+int StrnCaseCmp(const char *s, const char *t, size_t n);
BOOL strequal(const char *s1, const char *s2);
-BOOL strnequal(char *s1,char *s2,int n);
-BOOL strcsequal(char *s1,char *s2);
+BOOL strnequal(const char *s1,const char *s2,size_t n);
+BOOL strcsequal(const char *s1,const char *s2);
void strlower(char *s);
void strupper(char *s);
void strnorm(char *s);
BOOL strisnormal(char *s);
void string_replace(char *s,char oldc,char newc);
-char *skip_string(char *buf,int n);
-size_t str_charnum(char *s);
-BOOL trim_string(char *s,char *front,char *back);
-BOOL strhasupper(char *s);
-BOOL strhaslower(char *s);
-int count_chars(char *s,char c);
-char *safe_strcpy(char *dest,const char *src, int maxlength);
-char *safe_strcat(char *dest, char *src, int maxlength);
-char *StrCpy(char *dest,char *src);
-char *StrnCpy(char *dest,const char *src,int n);
-char *strncpyn(char *dest, const char *src,int n, char c);
-int strhex_to_str(char *p, int len, const char *strhex);
+char *skip_string(const char *buf,size_t n);
+size_t str_charnum(const char *s);
+BOOL trim_string(char *s,const char *front,const char *back);
+BOOL strhasupper(const char *s);
+BOOL strhaslower(const char *s);
+size_t count_chars(const char *s,char c);
+char *safe_strcpy(char *dest,const char *src, size_t maxlength);
+char *safe_strcat(char *dest, const char *src, size_t maxlength);
+char *StrCpy(char *dest,const char *src);
+char *StrnCpy(char *dest,const char *src,size_t n);
+char *strncpyn(char *dest, const char *src,size_t n, char c);
+size_t strhex_to_str(char *p, size_t len, const char *strhex);
BOOL in_list(char *s,char *list,BOOL casesensitive);
-BOOL string_init(char **dest,char *src);
+BOOL string_init(char **dest,const char *src);
void string_free(char **s);
-BOOL string_set(char **dest,char *src);
-BOOL string_sub(char *s,char *pattern,char *insert);
+BOOL string_set(char **dest,const char *src);
+BOOL string_sub(char *s,const char *pattern,const char *insert);
void split_at_last_component(char *path, char *front, char sep, char *back);
/*The following definitions come from lib/util_unistr.c */
struct smb_passwd *pwdb_sam_to_smb(struct sam_passwd *user);
struct sam_passwd *pwdb_smb_to_sam(struct smb_passwd *user);
char *pwdb_encode_acct_ctrl(uint16 acct_ctrl, size_t length);
-uint16 pwdb_decode_acct_ctrl(char *p);
-time_t pwdb_get_last_set_time(char *p);
+uint16 pwdb_decode_acct_ctrl(const char *p);
+time_t pwdb_get_last_set_time(const char *p);
void pwdb_set_logon_time(char *p, int max_len, time_t t);
void pwdb_set_logoff_time(char *p, int max_len, time_t t);
void pwdb_set_kickoff_time(char *p, int max_len, time_t t);
is held in little endian format.
*/
- if((fp = fopen( codepage_file_name, "r")) == NULL)
+ if((fp = sys_fopen( codepage_file_name, "r")) == NULL)
{
DEBUG(0,("load_client_codepage: cannot open file %s. Error was %s\n",
codepage_file_name, strerror(errno)));
if( dbf )
(void)fclose( dbf );
if( append_log )
- dbf = fopen( debugf, "a" );
+ dbf = sys_fopen( debugf, "a" );
else
- dbf = fopen( debugf, "w" );
+ dbf = sys_fopen( debugf, "w" );
/* Fix from klausr@ITAP.Physik.Uni-Stuttgart.De
* to fix problem where smbd's that generate less
* than 100 messages keep growing the log.
mode_t oldumask = umask( 022 );
if( append_log )
- dbf = fopen( debugf, "a" );
+ dbf = sys_fopen( debugf, "a" );
else
- dbf = fopen( debugf, "w" );
+ dbf = sys_fopen( debugf, "w" );
(void)umask( oldumask );
if( dbf )
{
unsigned char tmp_md4[16];
int fd, n;
- fd = open(fname,O_RDONLY);
+ fd = sys_open(fname,O_RDONLY,0);
if (fd == -1) return;
while ((n = read(fd, (char *)buf, sizeof(buf))) > 0) {
memset(md4_inbuf, '\0', sizeof(md4_inbuf));
- fd = open( "/dev/random", O_RDONLY);
+ fd = sys_open( "/dev/random", O_RDONLY,0);
if(fd >= 0) {
/*
* We can use /dev/random !
* charcnv.c.
*/
-static int skip_non_multibyte_char(char);
+static size_t skip_non_multibyte_char(char);
static BOOL not_multibyte_char_1(char);
char *(*_dos_to_unix)(char *, BOOL) = dos2unix_format;
char *(*_unix_to_dos)(char *, BOOL) = unix2dos_format;
-int (*_skip_multibyte_char)(char) = skip_non_multibyte_char;
+size_t (*_skip_multibyte_char)(char) = skip_non_multibyte_char;
BOOL (*is_multibyte_char_1)(char) = not_multibyte_char_1;
#else /* KANJI */
*/
static char *sj_to_sj(char *from, BOOL overwrite);
-static int skip_kanji_multibyte_char(char);
+static size_t skip_kanji_multibyte_char(char);
static BOOL is_kanji_multibyte_char_1(char);
char *(*_dos_to_unix)(char *, BOOL) = sj_to_sj;
char *(*_unix_to_dos)(char *, BOOL) = sj_to_sj;
-int (*_skip_multibyte_char)(char) = skip_kanji_multibyte_char;
+size_t (*_skip_multibyte_char)(char) = skip_kanji_multibyte_char;
int (*is_multibyte_char_1)(char) = is_kanji_multibyte_char_1;
#endif /* KANJI */
Kanji multibyte char skip function.
*******************************************************************/
-static int skip_kanji_multibyte_char(char c)
+static size_t skip_kanji_multibyte_char(char c)
{
if(is_shift_jis(c)) {
return 2;
Generic multibyte char skip function.
*******************************************************************/
-static int skip_generic_multibyte_char(char c)
+static size_t skip_generic_multibyte_char(char c)
{
if( (*is_multibyte_char_1)(c)) {
return 2;
Non multibyte char function.
*******************************************************************/
-static int skip_non_multibyte_char(char c)
+static size_t skip_non_multibyte_char(char c)
{
return 0;
}
slprintf(pidFile, sizeof(pidFile)-1, "%s/%s.pid", lp_lockdir(), name);
- f = fopen(pidFile, "r");
+ f = sys_fopen(pidFile, "r");
if (!f) {
return 0;
}
exit(1);
}
- fd = open(pidFile, O_NONBLOCK | O_CREAT | O_WRONLY, 0644);
+ fd = sys_open(pidFile, O_NONBLOCK | O_CREAT | O_WRONLY, 0644);
if (fd < 0) {
DEBUG(0,("ERROR: can't open %s: Error was %s\n", pidFile,
strerror(errno)));
flags = O_RDWR;
}
/* now create the file */
- fd = open(outfile,flags,mode);
+ fd = sys_open(outfile,flags,mode);
if (fd == -1) return False;
#endif
}
+/*******************************************************************
+ A creat() wrapper that will deal with 64 bit filesizes.
+********************************************************************/
+
+int sys_creat(const char *path, mode_t mode)
+{
+#if defined(HAVE_CREAT64)
+ return creat64(path, mode);
+#else
+ /*
+ * If creat64 isn't defined then ensure we call a potential open64.
+ * JRA.
+ */
+ return sys_open(path, O_WRONLY | O_CREAT | O_TRUNC, mode);
+#endif
+}
+
+/*******************************************************************
+ An open() wrapper that will deal with 64 bit filesizes.
+********************************************************************/
+
+int sys_open(const char *path, int oflag, mode_t mode)
+{
+#if defined(HAVE_OPEN64)
+ return open64(path, oflag, mode);
+#else
+ return open(path, oflag, mode);
+#endif
+}
+
+/*******************************************************************
+ An fopen() wrapper that will deal with 64 bit filesizes.
+********************************************************************/
+
+FILE *sys_fopen(const char *path, const char *type)
+{
+#if defined(HAVE_FOPEN64)
+ return fopen64(path, type);
+#else
+ return fopen(path, type);
+#endif
+}
+
+/*******************************************************************
+ An mmap() wrapper that will deal with 64 bit filesizes.
+********************************************************************/
+
+void *sys_mmap(void *addr, size_t len, int prot, int flags, int fd, SMB_OFF_T offset)
+{
+#if defined(LARGE_SMB_OFF_T) && defined(HAVE_MMAP64)
+ return mmap64(addr, len, prot, flags, fd, offset);
+#else
+ return mmap(addr, len, prot, flags, fd, offset);
+#endif
+}
+
/*******************************************************************
just a unlink wrapper that calls dos_to_unix.
********************************************************************/
********************************************************************/
int dos_open(char *fname,int flags,mode_t mode)
{
- return(open(dos_to_unix(fname,False),flags,mode));
+ return(sys_open(dos_to_unix(fname,False),flags,mode));
}
if (unlink (dest) && errno != ENOENT)
return 1;
- if((ifd = open (source, O_RDONLY, 0)) < 0)
+ if((ifd = sys_open (source, O_RDONLY, 0)) < 0)
return 1;
- if((ofd = open (dest, O_WRONLY | O_CREAT | O_TRUNC, 0600)) < 0 )
+ if((ofd = sys_open (dest, O_WRONLY | O_CREAT | O_TRUNC, 0600)) < 0 )
{
close (ifd);
return 1;
return True;
}
- f = fopen(mapfile,"r");
+ f = sys_fopen(mapfile,"r");
if (!f) {
DEBUG(0,("can't open username map %s\n",mapfile));
return False;
/* 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;
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);
}
DEBUG(10, ("startfilepwent: opening file %s\n", pfile));
- fp = fopen(pfile, update ? "r+b" : "rb");
+ fp = sys_fopen(pfile, update ? "r+b" : "rb");
if (fp == NULL) {
DEBUG(0, ("startfilepwent: unable to open file %s\n", pfile));
Based on a routine by GJC@VILLAGE.COM.
Extensively modified by Andrew.Tridgell@anu.edu.au
****************************************************************************/
-BOOL next_token(char **ptr,char *buff,char *sep, int bufsize)
+BOOL next_token(char **ptr,char *buff,char *sep, size_t bufsize)
{
char *s;
BOOL quoted;
- int len=1;
+ size_t len=1;
if (!ptr) ptr = &last_ptr;
if (!ptr) return(False);
/*******************************************************************
case insensitive string compararison, length limited
********************************************************************/
-int StrnCaseCmp(char *s, char *t, int n)
+int StrnCaseCmp(const char *s, const char *t, size_t n)
{
/* compare until we run out of string, either t or s, or chars */
/* We *must* use toupper rather than tolower here due to the
/*******************************************************************
compare 2 strings up to and including the nth char.
******************************************************************/
-BOOL strnequal(char *s1,char *s2,int n)
+BOOL strnequal(const char *s1,const char *s2,size_t n)
{
if (s1 == s2) return(True);
if (!s1 || !s2 || !n) return(False);
/*******************************************************************
compare 2 strings (case sensitive)
********************************************************************/
-BOOL strcsequal(char *s1,char *s2)
+BOOL strcsequal(const char *s1,const char *s2)
{
if (s1 == s2) return(True);
if (!s1 || !s2) return(False);
else
#endif /* KANJI_WIN95_COMPATIBILITY */
{
- int skip = skip_multibyte_char( *s );
+ size_t skip = skip_multibyte_char( *s );
if( skip != 0 )
s += skip;
else
else
#endif /* KANJI_WIN95_COMPATIBILITY */
{
- int skip = skip_multibyte_char( *s );
+ size_t skip = skip_multibyte_char( *s );
if( skip != 0 )
s += skip;
else
****************************************************************************/
void string_replace(char *s,char oldc,char newc)
{
- int skip;
+ size_t skip;
while (*s)
{
skip = skip_multibyte_char( *s );
/*******************************************************************
skip past some strings in a buffer
********************************************************************/
-char *skip_string(char *buf,int n)
+char *skip_string(const char *buf,size_t n)
{
while (n--)
buf += strlen(buf) + 1;
- return(buf);
+ return((char *)buf);
}
/*******************************************************************
16.oct.98, jdblair@cobaltnet.com.
********************************************************************/
-size_t str_charnum(char *s)
+size_t str_charnum(const char *s)
{
size_t len = 0;
trim the specified elements off the front and back of a string
********************************************************************/
-BOOL trim_string(char *s,char *front,char *back)
+BOOL trim_string(char *s,const char *front,const char *back)
{
BOOL ret = False;
size_t front_len = (front && *front) ? strlen(front) : 0;
/****************************************************************************
does a string have any uppercase chars in it?
****************************************************************************/
-BOOL strhasupper(char *s)
+BOOL strhasupper(const char *s)
{
while (*s)
{
else
#endif /* KANJI_WIN95_COMPATIBILITY */
{
- int skip = skip_multibyte_char( *s );
+ size_t skip = skip_multibyte_char( *s );
if( skip != 0 )
s += skip;
else {
/****************************************************************************
does a string have any lowercase chars in it?
****************************************************************************/
-BOOL strhaslower(char *s)
+BOOL strhaslower(const char *s)
{
while (*s)
{
else
#endif /* KANJI_WIN95_COMPATIBILITY */
{
- int skip = skip_multibyte_char( *s );
+ size_t skip = skip_multibyte_char( *s );
if( skip != 0 )
s += skip;
else {
/****************************************************************************
find the number of chars in a string
****************************************************************************/
-int count_chars(char *s,char c)
+size_t count_chars(const char *s,char c)
{
- int count=0;
+ size_t count=0;
#if !defined(KANJI_WIN95_COMPATIBILITY)
/*
{
while (*s)
{
- int skip = skip_multibyte_char( *s );
+ size_t skip = skip_multibyte_char( *s );
if( skip != 0 )
s += skip;
else {
safe string copy into a known length string. maxlength does not
include the terminating zero.
********************************************************************/
-char *safe_strcpy(char *dest,const char *src, int maxlength)
+char *safe_strcpy(char *dest,const char *src, size_t maxlength)
{
- int len;
+ size_t len;
if (!dest) {
DEBUG(0,("ERROR: NULL dest in safe_strcpy\n"));
safe string cat into a string. maxlength does not
include the terminating zero.
********************************************************************/
-char *safe_strcat(char *dest, char *src, int maxlength)
+char *safe_strcat(char *dest, const char *src, size_t maxlength)
{
- int src_len, dest_len;
+ size_t src_len, dest_len;
if (!dest) {
DEBUG(0,("ERROR: NULL dest in safe_strcat\n"));
/****************************************************************************
this is a safer strcpy(), meant to prevent core dumps when nasty things happen
****************************************************************************/
-char *StrCpy(char *dest,char *src)
+char *StrCpy(char *dest,const char *src)
{
char *d = dest;
/****************************************************************************
like strncpy but always null terminates. Make sure there is room!
****************************************************************************/
-char *StrnCpy(char *dest,const char *src,int n)
+char *StrnCpy(char *dest,const char *src,size_t n)
{
char *d = dest;
if (!dest) return(NULL);
like strncpy but copies up to the character marker. always null terminates.
returns a pointer to the character marker in the source string (src).
****************************************************************************/
-char *strncpyn(char *dest, const char *src,int n, char c)
+char *strncpyn(char *dest, const char *src,size_t n, char c)
{
char *p;
- int str_len;
+ size_t str_len;
p = strchr(src, c);
if (p == NULL)
valid examples: "0A5D15"; "0x15, 0x49, 0xa2"; "59\ta9\te3\n"
**************************************************************/
-int strhex_to_str(char *p, int len, const char *strhex)
+size_t strhex_to_str(char *p, size_t len, const char *strhex)
{
- int i;
- int num_chars = 0;
+ size_t i;
+ size_t num_chars = 0;
unsigned char lonybble, hinybble;
char *hexchars = "0123456789ABCDEF";
char *p1 = NULL, *p2 = NULL;
/****************************************************************************
set a string value, allocing the space for the string
****************************************************************************/
-BOOL string_init(char **dest,char *src)
+BOOL string_init(char **dest,const char *src)
{
- int l;
+ size_t l;
if (!src)
src = "";
set a string value, allocing the space for the string, and deallocating any
existing space
****************************************************************************/
-BOOL string_set(char **dest,char *src)
+BOOL string_set(char **dest,const char *src)
{
string_free(dest);
return True if a substitution was done.
****************************************************************************/
-BOOL string_sub(char *s,char *pattern,char *insert)
+BOOL string_sub(char *s,const char *pattern,const char *insert)
{
BOOL ret = False;
char *p;
- int ls,lp,li;
+ size_t ls,lp,li;
if (!insert || !pattern || !s) return(False);
FILE *startlmhosts(char *fname)
{
- FILE *fp = fopen(fname,"r");
+ FILE *fp = sys_fopen(fname,"r");
if (!fp) {
DEBUG(4,("startlmhosts: Can't open lmhosts file %s. Error was %s\n",
fname, strerror(errno)));
{
SMB_STRUCT_STAT dummy_stat;
- fd = (int)open(fname,read_only?O_RDONLY:(O_RDWR|O_CREAT),
- SHARE_FILE_MODE);
+ fd = sys_open(fname,read_only?O_RDONLY:(O_RDWR|O_CREAT), SHARE_FILE_MODE);
if(fd < 0)
{
pstrcat(lname,"/");
pstrcat(lname,s);
- fd = open(lname,read_only?O_RDONLY:O_RDWR,0);
+ fd = sys_open(lname,read_only?O_RDONLY:O_RDWR,0);
if (fd < 0) {
continue;
}
SMB_OFF_T free_slot = -1;
SMB_OFF_T erased_slot;
- smb_shm_processes_fd = open(processreg_file,
+ smb_shm_processes_fd = sys_open(processreg_file,
read_only?O_RDONLY:(O_RDWR|O_CREAT),
SHM_FILE_MODE);
BOOL found = False;
- smb_shm_processes_fd = open(processreg_file, O_RDWR);
+ smb_shm_processes_fd = sys_open(processreg_file, O_RDWR, 0);
if ( smb_shm_processes_fd < 0 )
{
DEBUG(0,("ERROR smb_shm_unregister_process : processreg_file open failed with code %s\n",strerror(errno)));
DEBUG(5,("smb_shm_open : using shmem file %s to be of size %.0f\n",
file_name,(double)size));
- smb_shm_fd = open(file_name, read_only?O_RDONLY:(O_RDWR|O_CREAT),
+ smb_shm_fd = sys_open(file_name, read_only?O_RDONLY:(O_RDWR|O_CREAT),
SHM_FILE_MODE);
if ( smb_shm_fd < 0 )
size = filesize;
}
- smb_shm_header_p = (struct SmbShmHeader *)mmap(NULL, size,
+ smb_shm_header_p = (struct SmbShmHeader *)sys_mmap(NULL, size,
read_only?PROT_READ: (PROT_READ | PROT_WRITE),
- MAP_FILE | MAP_SHARED, smb_shm_fd, 0);
+ MAP_FILE | MAP_SHARED, smb_shm_fd, (SMB_OFF_T)0);
/*
* WARNING, smb_shm_header_p can be different for different
pstrcat(fname,"/");
pstrcat(fname,"namelist.debug");
- fp = fopen(fname,"w");
+ fp = sys_fopen(fname,"w");
if (!fp)
{
pstrcpy(fnamenew,fname);
pstrcat(fnamenew,".");
- fp = fopen(fnamenew,"w");
+ fp = sys_fopen(fnamenew,"w");
if (!fp)
{
DEBUG(2,("Initiating browse sync for %s to %s(%s)\n",
work->work_group, name, inet_ntoa(ip)));
- fp = fopen(s->fname,"w");
+ fp = sys_fopen(s->fname,"w");
if (!fp) _exit(1);
sync_child(name, nm_type, work->work_group, ip, local, servers,
char *ptr;
int count=0;
- f = fopen(s->fname,"r");
+ f = sys_fopen(s->fname,"r");
if (!f) return;
pstrcat(fname,"/");
pstrcat(fname,WINS_LIST);
- if((fp = fopen(fname,"r")) == NULL)
+ if((fp = sys_fopen(fname,"r")) == NULL)
{
DEBUG(2,("initialise_wins: Can't open wins database file %s. Error was %s\n",
fname, strerror(errno) ));
string_sub(fname,"//", "/");
slprintf(fnamenew,sizeof(fnamenew),"%s.%u", fname, (unsigned int)getpid());
- if((fp = fopen(fnamenew,"w")) == NULL)
+ if((fp = sys_fopen(fnamenew,"w")) == NULL)
{
DEBUG(0,("wins_write_database: Can't open %s. Error was %s\n", fnamenew, strerror(errno)));
if (background) {
return( NULL );
}
- OpenedFile = fopen( FileName, "r" );
+ OpenedFile = sys_fopen( FileName, "r" );
if( NULL == OpenedFile )
{
DEBUG( lvl,
15 lines, which is more important.
**********************************************************/
-uint16 pwdb_decode_acct_ctrl(char *p)
+uint16 pwdb_decode_acct_ctrl(const char *p)
{
uint16 acct_ctrl = 0;
BOOL finished = False;
gets password-database-format time from a string.
********************************************************************/
-static time_t get_time_from_string(char *p)
+static time_t get_time_from_string(const char *p)
{
int i;
* read into a time_t as the seconds since
* 1970 that the password was last changed.
*/
- return (time_t)strtol((char *)p, NULL, 16);
+ return (time_t)strtol(p, NULL, 16);
}
return (time_t)-1;
}
gets password last set time
********************************************************************/
-time_t pwdb_get_last_set_time(char *p)
+time_t pwdb_get_last_set_time(const char *p)
{
- if (*p && StrnCaseCmp((char *)p, "LCT-", 4))
+ if (*p && StrnCaseCmp(p, "LCT-", 4))
{
return get_time_from_string(p + 4);
}
* As 256 is shorter than a pstring we don't need to check
* length here - if this ever changes....
*/
- p = strncpyn(user_name, linebuf, sizeof(user_name), ':');
+ p = (unsigned char *)strncpyn(user_name, linebuf, sizeof(user_name), ':');
/* Go past ':' */
p++;
/* Get smb uid. */
- p = Atoic((char *) p, &uidval, ":");
+ p = (unsigned char *)Atoic((char *) p, &uidval, ":");
pw_buf.smb_name = user_name;
pw_buf.smb_userid = uidval;
if (*p == ':')
{
p++;
- pw_buf.pass_last_set_time = pwdb_get_last_set_time(p);
+ pw_buf.pass_last_set_time = pwdb_get_last_set_time((char *)p);
}
}
else
}
DEBUG(10, ("mod_smbfilepwd_entry: opening file %s\n", pfile));
- fp = fopen(pfile, "r+");
+ fp = sys_fopen(pfile, "r+");
if (fp == NULL) {
DEBUG(0, ("mod_smbfilepwd_entry: unable to open file %s\n", pfile));
FILE *fp;
slprintf(msg_str,msg_str_len-1,
"smbpasswd file did not exist - attempting to create it.\n");
- fp = fopen(lp_smb_passwd_file(), "w");
+ fp = sys_fopen(lp_smb_passwd_file(), "w");
if (fp) {
fprintf(fp, "# Samba SMB password file\n");
fclose(fp);
get_trust_account_file_name( domain, name, mac_file);
- if((mach_passwd_fp = fopen(mac_file, "r+b")) == NULL) {
+ if((mach_passwd_fp = sys_fopen(mac_file, "r+b")) == NULL) {
if(errno == ENOENT && update) {
- mach_passwd_fp = fopen(mac_file, "w+b");
+ mach_passwd_fp = sys_fopen(mac_file, "w+b");
}
if(mach_passwd_fp == NULL) {
static pstring user_name;
struct passwd *pwfile;
pstring linebuf;
- unsigned char *p;
+ char *p;
int uidval;
- size_t linebuf_len;
if (vp == NULL)
{
/*
* Scan the file, a line at a time.
*/
- while ((linebuf_len = getfileline(vp, linebuf, sizeof(linebuf))) > 0)
+ while (getfileline(vp, linebuf, sizeof(linebuf)) > 0)
{
/*
* The line we have should be of the form :-
*name = 0;
*comment = 0;
- if ((pfile = fopen(psz, "r")) == NULL)
+ if ((pfile = sys_fopen(psz, "r")) == NULL)
{
DEBUG(0,( "Unable to open qconfig file %s for read!\n", psz));
return;
DEBUG(0,(" Unable to allocate memory for printer %s\n",pszPrintername));
return(False);
}
- if ((pfile = fopen(psz, "r")) == NULL)
+ if ((pfile = sys_fopen(psz, "r")) == NULL)
{
DEBUG(0,( "Unable to open qconfig file %s for read!\n", psz));
free(pName);
return(ScanQconfig(psz,pszPrintername));
#endif
- if ((pfile = fopen(psz, "r")) == NULL)
+ if ((pfile = sys_fopen(psz, "r")) == NULL)
{
DEBUG(0,( "Unable to open printcap file %s for read!\n", psz));
return(False);
}
#endif
- if ((pfile = fopen(psz, "r")) == NULL)
+ if ((pfile = sys_fopen(psz, "r")) == NULL)
{
DEBUG(0,( "Unable to open printcap file %s for read!\n", psz));
return;
lpq_cache_reset[snum] = False;
- f = fopen(outfile,"r");
+ f = sys_fopen(outfile,"r");
if (!f) {
return(0);
}
else if (sid_equal(&dom_sid, &usr_sid))
{
DOMAIN_GRP *mem_grp = NULL;
- BOOL ret;
DEBUG(5,("lookup on Domain SID\n"));
become_root(True);
- ret = getusergroupsnam(sam_pass->smb_name, &mem_grp, &num_rids);
+ getusergroupsnam(sam_pass->smb_name, &mem_grp, &num_rids);
unbecome_root(True);
num_rids = MIN(num_rids, MAX_SAM_ENTRIES);
if (status == 0x0)
{
DOMAIN_GRP *mem_grp = NULL;
- BOOL ret;
become_root(True);
- ret = getusergroupsnam(sam_pass->smb_name, &mem_grp, &num_groups);
+ getusergroupsnam(sam_pass->smb_name, &mem_grp, &num_groups);
unbecome_root(True);
gids = NULL;
DOM_SID global_sid_S_1_3_2; /* Creator owner server */
DOM_SID global_sid_S_1_3_3; /* Creator group server */
-extern pstring global_myworkgroup;
+extern fstring global_myworkgroup;
/* extern fstring global_member_dom_name; */
static struct sid_name_map_info
pstrcat(sid_file, "MACHINE.SID");
- if ((fd = open(sid_file, O_RDWR | O_CREAT, 0644)) == -1) {
+ if ((fd = sys_open(sid_file, O_RDWR | O_CREAT, 0644)) == -1) {
DEBUG(0,("unable to open or create file %s. Error was %s\n",
sid_file, strerror(errno) ));
return False;
if (rm -f $FNAME && touch $FNAME); then
rm $FNAME
- if [ x$GROFF = x ] ; then
+ if [ "x$GROFF" = x ] ; then
cp $s $m # Copy raw nroff
else
echo "\t$FNAME" # groff'ing can be slow, give the user
#endif /* !HAVE_GRANTPT */
#if defined(HAVE_GRANTPT)
- if ((master = open("/dev/ptmx", O_RDWR)) >= 1) {
+ if ((master = sys_open("/dev/ptmx", O_RDWR, 0)) >= 1) {
grantpt(master);
unlockpt(master);
*slave = ptsname(master);
DEBUG(3,("pty: try to open %s, line was %s\n", dpname, line ) );
line[8] = dpname[3];
line[9] = dpname[4];
- if ((master = open(line, O_RDWR)) >= 0) {
+ if ((master = sys_open(line, O_RDWR, 0)) >= 0) {
DEBUG(3,("pty: opened %s\n", line ) );
line[5] = 't';
*slave = line;
}
/* Open slave pty and acquire as new controlling terminal. */
- if ((slave = open(slavedev, O_RDWR)) < 0) {
+ if ((slave = sys_open(slavedev, O_RDWR, 0)) < 0) {
DEBUG(3,("More weirdness, could not open %s\n",
slavedev));
return(False);
pstrcat(fname,name);
pstrcat(fname,".LCK");
- fd = open(fname,O_RDWR);
+ fd = sys_open(fname,O_RDWR,0);
if (fd == -1) {
DEBUG(2,("Couldn't open lock file %s (%s)\n",fname,strerror(errno)));
return(False);
pstrcat(fname,".LCK");
if (!file_exist(fname,NULL)) {
- fd = open(fname,O_RDWR|O_CREAT|O_EXCL, 0644);
+ fd = sys_open(fname,O_RDWR|O_CREAT|O_EXCL, 0644);
}
if (fd == -1) {
- fd = open(fname,O_RDWR);
+ fd = sys_open(fname,O_RDWR,0);
}
if (fd == -1) {
* Load the file.
*/
- fp = fopen(map_file,"r");
+ fp = sys_fopen(map_file,"r");
if (!fp)
{
DEBUG(0,("load_name_map: can't open name map %s. Error was %s\n",
{
fstrcpy(ntname, gmep->grp.nt_domain);
}
- DEBUG(7,("map_sid_to_ntname: Mapping unix group %s to nt group \%s\%s\n",
+ DEBUG(7,("map_sid_to_ntname: Mapping unix group %s to nt group \\%s\\%s\n",
gmep->grp.unix_name,
gmep->grp.nt_domain, gmep->grp.nt_name ));
return True;
pstring fname;
pstrcpy(fname,lp_driverfile());
- f=fopen(fname,"r");
+ f=sys_fopen(fname,"r");
if (!f) {
DEBUG(3,("fill_printq_info: Can't open %s - %s\n",fname,strerror(errno)));
desc->errcode=NERR_notsupported;
pstrcpy(fname,lp_driverfile());
DEBUG(4,("In get_printerdrivernumber: %s\n",fname));
- f=fopen(fname,"r");
+ f=sys_fopen(fname,"r");
if (!f) {
DEBUG(3,("get_printerdrivernumber: Can't open %s - %s\n",fname,strerror(errno)));
return(0);
pstrcat(fname,"/");
pstrcat(fname,SERVER_LIST);
- f = fopen(fname,"r");
+ f = sys_fopen(fname,"r");
if (!f) {
DEBUG(4,("Can't open %s - %s\n",fname,strerror(errno)));
slprintf(s,sizeof(s)-1, "%s/msg.XXXXXX",tmpdir());
fstrcpy(name,(char *)mktemp(s));
- fd = open(name,O_WRONLY|O_CREAT|O_TRUNC|O_EXCL,0600);
+ fd = sys_open(name,O_WRONLY|O_CREAT|O_TRUNC|O_EXCL,0600);
if (fd == -1) {
DEBUG(1,("can't open message file %s\n",name));
return;
if (!fsp->can_write) {
fsp->mmap_size = file_size(fsp->fsp_name);
if (fsp->mmap_size < MAX_MMAP_SIZE) {
- fsp->mmap_ptr = (char *)mmap(NULL,fsp->mmap_size,
- PROT_READ,MAP_SHARED,fsp->fd_ptr->fd,0);
+ fsp->mmap_ptr = (char *)sys_mmap(NULL,fsp->mmap_size,
+ PROT_READ,MAP_SHARED,fsp->fd_ptr->fd,(SMB_OFF_T)0);
if (fsp->mmap_ptr == (char *)-1 || !fsp->mmap_ptr) {
DEBUG(3,("Failed to mmap() %s - %s\n",
return;
}
- if((fd = open(tmpname, O_RDWR|O_CREAT|O_TRUNC|O_EXCL, 0600)) < 0) {
+ if((fd = sys_open(tmpname, O_RDWR|O_CREAT|O_TRUNC|O_EXCL, 0600)) < 0) {
DEBUG(0,("check_kernel_oplocks: Unable to open temp test file %s. Error was %s\n",
tmpname, strerror(errno) ));
unlink( tmpname );
int plus_allowed = 1;
char *file_host;
char *file_user;
- FILE *fp = fopen(equiv_file, "r");
+ FILE *fp = sys_fopen(equiv_file, "r");
DEBUG(5, ("check_user_equiv %s %s %s\n", user, remote, equiv_file));
if (! fp) return False;
while(fgets(buf, sizeof(buf), fp))
if ( devno != devno_cached ) {
devno_cached = devno ;
#if defined(SUNOS5)
- if ((fd = fopen(MNTTAB, "r")) == NULL)
+ if ((fd = sys_fopen(MNTTAB, "r")) == NULL)
return(False) ;
found = False ;
#if defined(SUNOS5)
DEBUG(5,("disk_quotas: looking for quotas file \"%s\"\n", name));
- if((file=open(name, O_RDONLY))<0) {
+ if((file=sys_open(name, O_RDONLY,0))<0) {
setuid(user_id); /* Restore the original UID status */
seteuid(euser_id);
return(False);
fstrcpy(name,(char *)mktemp(s));
/* note zero permissions! don't change this */
- fd = open(name,O_RDWR|O_CREAT|O_TRUNC|O_EXCL,0);
+ fd = sys_open(name,O_RDWR|O_CREAT|O_TRUNC|O_EXCL,0);
if (fd == -1) goto failed;
unlink(name);
dbf = stderr;
if ((p=smbw_getshared("LOGFILE"))) {
- dbf = fopen(p, "a");
+ dbf = sys_fopen(p, "a");
}
smbw_file_bmap = bitmap_allocate(SMBW_MAX_OPEN);
return(-1);
}
- inf_file=fopen(argv[1],"r");
+ inf_file=sys_fopen(argv[1],"r");
if (!inf_file)
{
fprintf(stderr,"Description file not found, bye\n");
exit(1);
}
- if((fp = fopen(input_file, "r")) == NULL)
+ if((fp = sys_fopen(input_file, "r")) == NULL)
{
fprintf(stderr, "%s: cannot open file %s for input.\n", prog_name, input_file);
exit(1);
}
/* Now write out the output_buf. */
- if((fp = fopen(output_file, "w"))==NULL)
+ if((fp = sys_fopen(output_file, "w"))==NULL)
{
fprintf(stderr, "%s: Cannot open output file %s. Error was %s.\n",
prog_name, output_file, strerror(errno));
is held in little endian format.
*/
- if((fp = fopen( input_file, "r")) == NULL)
+ if((fp = sys_fopen( input_file, "r")) == NULL)
{
fprintf(stderr, "%s: cannot open file %s. Error was %s\n",
prog_name, input_file, strerror(errno));
fclose(fp);
/* Now dump the codepage into an ascii file. */
- if((fp = fopen(output_file, "w")) == NULL)
+ if((fp = sys_fopen(output_file, "w")) == NULL)
{
fprintf(stderr, "%s: cannot open file %s. Error was %s\n",
prog_name, output_file, strerror(errno));
trim_string(fname,"","/");
pstrcat(fname,"/STATUS..LCK");
- f = fopen(fname,"r");
+ f = sys_fopen(fname,"r");
if (!f) {
printf("Couldn't open status file %s\n",fname);
if (!lp_status(-1))
printf("Usage: testprns printername [printcapfile]\n");
else
{
- dbf = fopen("test.log", "w");
+ dbf = sys_fopen("test.log", "w");
if (dbf == NULL) {
printf("Unable to open logfile.\n");
} else {
cgi_setup_error("404 File Not Found","",
"The requested file was not found");
}
- fd = open(file,O_RDONLY);
+ fd = sys_open(file,O_RDONLY,0);
if (fd == -1) {
cgi_setup_error("404 File Not Found","",
"The requested file was not found");
inetd_server = True;
#if CGI_LOGGING
- f = fopen("/tmp/cgi.log", "a");
+ f = sys_fopen("/tmp/cgi.log", "a");
if (f) fprintf(f,"\n[Date: %s %s (%s)]\n",
http_timestring(time(NULL)),
client_name(1), client_addr(1));
pstrcat(fname,"/STATUS..LCK");
- f = fopen(fname,"r");
+ f = sys_fopen(fname,"r");
if (f) {
while (!feof(f)) {
if (fread(&crec,sizeof(crec),1,f) != 1) break;
printf("<p>\n");
- f = fopen(fname,"r");
+ f = sys_fopen(fname,"r");
if (!f) {
printf("Couldn't open status file %s\n",fname);
if (!lp_status(-1))
****************************************************************************/
static int include_html(char *fname)
{
- FILE *f = fopen(fname,"r");
+ FILE *f = sys_fopen(fname,"r");
char buf[1024];
int ret;
{
FILE *f;
- f = fopen(servicesf,"w");
+ f = sys_fopen(servicesf,"w");
if (!f) {
printf("failed to open %s for writing\n", servicesf);
return 0;
/* just in case it goes wild ... */
alarm(300);
- dbf = fopen("/dev/null", "w");
+ dbf = sys_fopen("/dev/null", "w");
if (!dbf) dbf = stderr;
git.samba.org / tprouty / samba.git / commitdiff