sin/samba-mirror
1
0
Fork 0
mirror of https://github.com/samba-team/samba.git synced 2024-12-22 13:34:15 +03:00
Code

r3441: some include file cleanups and general housekeeping

Browse Source
This commit is contained in:
Andrew Tridgell 2004-11-01 20:21:54 +00:00 committed by Gerald (Jerry) Carter
parent 05dd840b6f
commit 73ea8ee6c2
26 changed files with 147 additions and 650 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

91
source/client/client.c
View File

@ -325,6 +325,29 @@ static int cmd_cd(const char **cmd_ptr)
}
BOOL mask_match(struct smbcli_state *c, const char *string, char *pattern,
BOOL is_case_sensitive)
{
fstring p2, s2;
if (strcmp(string,"..") == 0)
string = ".";
if (strcmp(pattern,".") == 0)
return False;
if (is_case_sensitive)
return ms_fnmatch(pattern, string,
c->transport->negotiate.protocol) == 0;
fstrcpy(p2, pattern);
fstrcpy(s2, string);
strlower(p2);
strlower(s2);
return ms_fnmatch(p2, s2, c->transport->negotiate.protocol) == 0;
}
/*******************************************************************
decide if a file should be operated on
********************************************************************/
@ -714,16 +737,16 @@ static int do_get(char *rname, const char *lname, BOOL reget)
handle = fileno(stdout);
} else {
if (reget) {
handle = sys_open(lname, O_WRONLY|O_CREAT, 0644);
handle = open(lname, O_WRONLY|O_CREAT, 0644);
if (handle >= 0) {
start = sys_lseek(handle, 0, SEEK_END);
start = lseek(handle, 0, SEEK_END);
if (start == -1) {
d_printf("Error seeking local file\n");
return 1;
}
}
} else {
handle = sys_open(lname, O_WRONLY|O_CREAT|O_TRUNC, 0644);
handle = open(lname, O_WRONLY|O_CREAT|O_TRUNC, 0644);
}
newhandle = True;
}
@ -832,6 +855,22 @@ static int cmd_get(const char **cmd_ptr)
return do_get(rname, lname, False);
}
/****************************************************************************
Put up a yes/no prompt.
****************************************************************************/
static BOOL yesno(char *p)
{
pstring ans;
printf("%s",p);
if (!fgets(ans,sizeof(ans)-1,stdin))
return(False);
if (*ans == 'y' || *ans == 'Y')
return(True);
return(False);
}
/****************************************************************************
do a mget operation on one file
@ -1251,7 +1290,7 @@ static int cmd_put(const char **cmd_ptr)
dos_clean_name(rname);
{
SMB_STRUCT_STAT st;
struct stat st;
/* allow '-' to represent stdin
jdblair, 24.jun.98 */
if (!file_exist(lname,&st) &&
@ -1319,6 +1358,44 @@ static int cmd_select(const char **cmd_ptr)
return 0;
}
/*******************************************************************
A readdir wrapper which just returns the file name.
********************************************************************/
static const char *readdirname(DIR *p)
{
struct dirent *ptr;
char *dname;
if (!p)
return(NULL);
ptr = (struct smb_dirent *)readdir(p);
if (!ptr)
return(NULL);
dname = ptr->d_name;
#ifdef NEXT2
if (telldir(p) < 0)
return(NULL);
#endif
#ifdef HAVE_BROKEN_READDIR
/* using /usr/ucb/cc is BAD */
dname = dname - 2;
#endif
{
static pstring buf;
int len = NAMLEN(ptr);
memcpy(buf, dname, len);
buf[len] = 0;
dname = buf;
}
return(dname);
}
/****************************************************************************
Recursive file matching function act as find
match must be always set to True when calling this function
@ -1982,10 +2059,10 @@ static int cmd_newer(const char **cmd_ptr)
{
fstring buf;
BOOL ok;
SMB_STRUCT_STAT sbuf;
struct stat sbuf;
ok = next_token(cmd_ptr,buf,NULL,sizeof(buf));
if (ok && (sys_stat(buf,&sbuf) == 0)) {
if (ok && (stat(buf,&sbuf) == 0)) {
newer_than = sbuf.st_mtime;
DEBUG(1,("Getting files newer than %s",
asctime(localtime(&newer_than))));
@ -2141,7 +2218,7 @@ static int cmd_reput(const char **cmd_ptr)
pstring remote_name;
fstring buf;
char *p = buf;
SMB_STRUCT_STAT st;
struct stat st;
pstrcpy(remote_name, cur_dir);
pstrcat(remote_name, "\\");

12
source/client/clitar.c
View File

@ -434,7 +434,7 @@ Write two zero blocks at end of file
****************************************************************************/
static void dotareof(int f)
{
SMB_STRUCT_STAT stbuf;
struct stat stbuf;
/* Two zero blocks at end of file, write out full buffer */
if (dry_run)
@ -443,7 +443,7 @@ static void dotareof(int f)
(void) dozerobuf(f, TBLOCK);
(void) dozerobuf(f, TBLOCK);
if (sys_fstat(f, &stbuf) == -1)
if (fstat(f, &stbuf) == -1)
{
DEBUG(0, ("Couldn't stat file handle\n"));
return;
@ -1721,10 +1721,10 @@ int tar_parseargs(int argc, char *argv[], const char *Optarg, int Optind)
DEBUG(0,("Option N must be followed by valid file name\n"));
return 0;
} else {
SMB_STRUCT_STAT stbuf;
struct stat stbuf;
extern time_t newer_than;
if (sys_stat(argv[Optind], &stbuf) == 0) {
if (stat(argv[Optind], &stbuf) == 0) {
newer_than = stbuf.st_mtime;
DEBUG(1,("Getting files newer than %s",
asctime(localtime(&newer_than))));
@ -1879,8 +1879,8 @@ int tar_parseargs(int argc, char *argv[], const char *Optarg, int Optind)
}
tarhandle=-1;
} else
if ((tar_type=='x' && (tarhandle = sys_open(argv[Optind], O_RDONLY, 0)) == -1)
|| (tar_type=='c' && (tarhandle=sys_creat(argv[Optind], 0644)) < 0))
if ((tar_type=='x' && (tarhandle = open(argv[Optind], O_RDONLY, 0)) == -1)
|| (tar_type=='c' && (tarhandle=creat(argv[Optind], 0644)) < 0))
{
DEBUG(0,("Error opening local file %s - %s\n",
argv[Optind], strerror(errno)));

2
source/client/smbmount.c
View File

@ -552,7 +552,7 @@ static void get_password_file(void)
sscanf(p, "%d", &fd);
close_it = False;
} else if ((p = getenv("PASSWD_FILE")) != NULL) {
fd = sys_open(p, O_RDONLY, 0);
fd = open(p, O_RDONLY, 0);
pstrcpy(spec, p);
if (fd < 0) {
fprintf(stderr, "Error opening PASSWD_FILE %s: %s\n",

166
source/include/includes.h
View File

@ -474,121 +474,10 @@ typedef int socklen_t;
#define UINT16_MAX 65535
#endif
/*
* Types for devices, inodes and offsets.
*/
#ifndef SMB_DEV_T
# if defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(HAVE_DEV64_T)
# define SMB_DEV_T dev64_t
# else
# define SMB_DEV_T dev_t
# endif
#endif
/*
* Setup the correctly sized inode type.
*/
#ifndef SMB_INO_T
# if defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(HAVE_INO64_T)
# define SMB_INO_T ino64_t
# else
# define SMB_INO_T ino_t
# endif
#endif
#ifndef LARGE_SMB_INO_T
# if (defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(HAVE_INO64_T)) || (defined(SIZEOF_INO_T) && (SIZEOF_INO_T == 8))
# define LARGE_SMB_INO_T 1
# endif
#endif
#ifdef LARGE_SMB_INO_T
#define SINO_T(p, ofs, v) (SIVAL(p,ofs,(v)&0xFFFFFFFF), SIVAL(p,(ofs)+4,(v)>>32))
#else
#define SINO_T(p, ofs, v) (SIVAL(p,ofs,v),SIVAL(p,(ofs)+4,0))
#endif
#ifndef SMB_OFF_T
# if defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(HAVE_OFF64_T)
# define SMB_OFF_T off64_t
# else
# define SMB_OFF_T off_t
# endif
#endif
/*
* Set the define that tells us if we can do 64 bit
* NT SMB calls.
*/
#ifndef LARGE_SMB_OFF_T
# if (defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(HAVE_OFF64_T)) || (defined(SIZEOF_OFF_T) && (SIZEOF_OFF_T == 8))
# define LARGE_SMB_OFF_T 1
# endif
#endif
/*
* Type for stat structure.
*/
#ifndef SMB_STRUCT_STAT
# if defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(HAVE_STAT64) && defined(HAVE_OFF64_T)
# define SMB_STRUCT_STAT struct stat64
# else
# define SMB_STRUCT_STAT struct stat
# endif
#endif
/*
* Type for dirent structure.
*/
#ifndef SMB_STRUCT_DIRENT
# if defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(HAVE_STRUCT_DIRENT64)
# define smb_dirent dirent64
# else
# define smb_dirent dirent
# endif
#endif
/*
* Defines for 64 bit fcntl locks.
*/
#ifndef SMB_STRUCT_FLOCK
# if defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(HAVE_STRUCT_FLOCK64) && defined(HAVE_OFF64_T)
# define SMB_STRUCT_FLOCK struct flock64
# else
# define SMB_STRUCT_FLOCK struct flock
# endif
#endif
#ifndef SMB_F_SETLKW
# if defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(HAVE_STRUCT_FLOCK64) && defined(HAVE_OFF64_T)
# define SMB_F_SETLKW F_SETLKW64
# else
# define SMB_F_SETLKW F_SETLKW
# endif
#endif
#ifndef SMB_F_SETLK
# if defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(HAVE_STRUCT_FLOCK64) && defined(HAVE_OFF64_T)
# define SMB_F_SETLK F_SETLK64
# else
# define SMB_F_SETLK F_SETLK
# endif
#endif
#ifndef SMB_F_GETLK
# if defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(HAVE_STRUCT_FLOCK64) && defined(HAVE_OFF64_T)
# define SMB_F_GETLK F_GETLK64
# else
# define SMB_F_GETLK F_GETLK
# endif
#endif
#ifndef MIN
#define MIN(a,b) ((a)<(b)?(a):(b))
#endif
@ -970,55 +859,12 @@ int vasprintf(char **ptr, const char *format, va_list ap);
#define LOG_DEBUG 7 /* debug-level messages */
#endif
/* NetBSD doesn't have these */
#ifndef SHM_R
#define SHM_R 0400
#endif
#ifndef SHM_W
#define SHM_W 0200
#endif
#if HAVE_KERNEL_SHARE_MODES
#ifndef LOCK_MAND
#define LOCK_MAND 32 /* This is a mandatory flock */
#define LOCK_READ 64 /* ... Which allows concurrent read operations */
#define LOCK_WRITE 128 /* ... Which allows concurrent write operations */
#define LOCK_RW 192 /* ... Which allows concurrent read & write ops */
#endif
#endif
extern int DEBUGLEVEL;
#define MAX_SEC_CTX_DEPTH 8 /* Maximum number of security contexts */
#ifdef GLIBC_HACK_FCNTL64
/* this is a gross hack. 64 bit locking is completely screwed up on
i386 Linux in glibc 2.1.95 (which ships with RedHat 7.0). This hack
"fixes" the problem with the current 2.4.0test kernels
*/
#define fcntl fcntl64
#undef F_SETLKW
#undef F_SETLK
#define F_SETLK 13
#define F_SETLKW 14
#endif
/* Needed for sys_dlopen/sys_dlsym/sys_dlclose */
#ifndef RTLD_GLOBAL
#define RTLD_GLOBAL 0
#endif
#ifndef RTLD_LAZY
#define RTLD_LAZY 0
#endif
#ifndef RTLD_NOW
#define RTLD_NOW 0
#endif
/* needed for some systems without iconv. Doesn't really matter
what error code we use */
#ifndef EILSEQ
@ -1026,9 +872,6 @@ extern int DEBUGLEVEL;
#endif
/* add varargs prototypes with printf checking */
int fdprintf(int , const char *, ...) PRINTF_ATTRIBUTE(2,3);
int d_printf(const char *, ...) PRINTF_ATTRIBUTE(1,2);
int d_fprintf(FILE *f, const char *, ...) PRINTF_ATTRIBUTE(2,3);
#ifndef HAVE_SNPRINTF_DECL
int snprintf(char *,size_t ,const char *, ...) PRINTF_ATTRIBUTE(3,4);
#endif
@ -1036,19 +879,10 @@ int snprintf(char *,size_t ,const char *, ...) PRINTF_ATTRIBUTE(3,4);
int asprintf(char **,const char *, ...) PRINTF_ATTRIBUTE(2,3);
#endif
void sys_adminlog(int priority, const char *format_str, ...) PRINTF_ATTRIBUTE(2,3);
int pstr_sprintf(pstring s, const char *fmt, ...) PRINTF_ATTRIBUTE(2,3);
int fstr_sprintf(fstring s, const char *fmt, ...) PRINTF_ATTRIBUTE(2,3);
int d_vfprintf(FILE *f, const char *format, va_list ap) PRINTF_ATTRIBUTE(2,0);
int smb_xvasprintf(char **ptr, const char *format, va_list ap) PRINTF_ATTRIBUTE(2,0);
/* we used to use these fns, but now we have good replacements
for snprintf and vsnprintf */
#define slprintf snprintf
#define vslprintf vsnprintf
/* we need to use __va_copy() on some platforms */

22
source/include/rewrite.h
View File

@ -82,28 +82,6 @@ typedef int BOOL;
#define LEVEL_II_OPLOCK_BREAK_CMD 0x3
#define ASYNC_LEVEL_II_OPLOCK_BREAK_CMD 0x4
/*
* Capabilities abstracted for different systems.
*/
#define KERNEL_OPLOCK_CAPABILITY 0x1
/*
* Oplock break command code sent via the kernel interface (if it exists).
*
* Form of this is :
*
* 0 2 2+devsize 2+devsize+inodesize
* +----+--------+--------+----------+
* | cmd| dev | inode | fileid |
* +----+--------+--------+----------+
*/
#define KERNEL_OPLOCK_BREAK_DEV_OFFSET 2
#define KERNEL_OPLOCK_BREAK_INODE_OFFSET (KERNEL_OPLOCK_BREAK_DEV_OFFSET + sizeof(SMB_DEV_T))
#define KERNEL_OPLOCK_BREAK_FILEID_OFFSET (KERNEL_OPLOCK_BREAK_INODE_OFFSET + sizeof(SMB_INO_T))
#define KERNEL_OPLOCK_BREAK_MSG_LEN (KERNEL_OPLOCK_BREAK_FILEID_OFFSET + sizeof(unsigned long))
#define CMD_REPLY 0x8000
#include "smb_macros.h"

2
source/lib/cmdline/popt_common.c
View File

@ -175,7 +175,7 @@ static void get_password_file(struct cmdline_auth_info *a)
sscanf(p, "%d", &fd);
close_it = False;
} else if ((p = getenv("PASSWD_FILE")) != NULL) {
fd = sys_open(p, O_RDONLY, 0);
fd = open(p, O_RDONLY, 0);
pstrcpy(spec, p);
if (fd < 0) {
fprintf(stderr, "Error opening PASSWD_FILE %s: %s\n",

6
source/lib/dprintf.c
View File

@ -31,7 +31,7 @@
#include "includes.h"
int d_vfprintf(FILE *f, const char *format, va_list ap)
int d_vfprintf(FILE *f, const char *format, va_list ap) _PRINTF_ATTRIBUTE(2,0)
{
char *p, *p2;
int ret, maxlen, clen;
@ -77,7 +77,7 @@ again:
}
int d_fprintf(FILE *f, const char *format, ...)
int d_fprintf(FILE *f, const char *format, ...) _PRINTF_ATTRIBUTE(2,3)
{
int ret;
va_list ap;
@ -91,7 +91,7 @@ again:
static FILE *outfile;
int d_printf(const char *format, ...)
int d_printf(const char *format, ...) _PRINTF_ATTRIBUTE(1,2)
{
int ret;
va_list ap;

4
source/lib/genrand.c
View File

@ -118,7 +118,7 @@ static void do_filehash(const char *fname, unsigned char *the_hash)
unsigned char tmp_md4[16];
int fd, n;
fd = sys_open(fname,O_RDONLY,0);
fd = open(fname,O_RDONLY,0);
if (fd == -1)
return;
@ -152,7 +152,7 @@ static int do_reseed(BOOL use_fd, int fd)
if (fd != -1)
return fd;
fd = sys_open( "/dev/urandom", O_RDONLY,0);
fd = open( "/dev/urandom", O_RDONLY,0);
if(fd >= 0)
return fd;
}

8
source/lib/pidfile.c
View File

@ -37,7 +37,7 @@ pid_t pidfile_pid(const char *name)
slprintf(pidFile, sizeof(pidFile)-1, "%s/%s.pid", lp_piddir(), name);
fd = sys_open(pidFile, O_NONBLOCK | O_RDONLY, 0644);
fd = open(pidFile, O_NONBLOCK | O_RDONLY, 0644);
if (fd == -1) {
return 0;
}
@ -54,7 +54,7 @@ pid_t pidfile_pid(const char *name)
goto noproc;
}
if (fcntl_lock(fd,SMB_F_SETLK,0,1,F_RDLCK)) {
if (fcntl_lock(fd,F_SETLK,0,1,F_RDLCK)) {
/* we could get the lock - it can't be a Samba process */
goto noproc;
}
@ -85,14 +85,14 @@ void pidfile_create(const char *name)
exit(1);
}
fd = sys_open(pidFile, O_NONBLOCK | O_CREAT | O_WRONLY | O_EXCL, 0644);
fd = open(pidFile, O_NONBLOCK | O_CREAT | O_WRONLY | O_EXCL, 0644);
if (fd == -1) {
DEBUG(0,("ERROR: can't open %s: Error was %s\n", pidFile,
strerror(errno)));
exit(1);
}
if (fcntl_lock(fd,SMB_F_SETLK,0,1,F_WRLCK)==False) {
if (fcntl_lock(fd,F_SETLK,0,1,F_WRLCK)==False) {
DEBUG(0,("ERROR: %s : fcntl lock of file %s failed. Error was %s\n",
name, pidFile, strerror(errno)));
exit(1);

2
source/lib/replace.c
View File

@ -27,7 +27,7 @@
/*******************************************************************
ftruncate for operating systems that don't have it
********************************************************************/
int ftruncate(int f,SMB_OFF_T l)
int ftruncate(int f,off_t l)
{
struct flock fl;

2
source/lib/signal.c
View File

@ -27,7 +27,7 @@
static void sig_cld(int signum)
{
while (sys_waitpid((pid_t)-1,(int *)NULL, WNOHANG) > 0)
while (waitpid((pid_t)-1,(int *)NULL, WNOHANG) > 0)
;
/*

187
source/lib/system.c
View File

@ -128,193 +128,6 @@ ssize_t sys_sendto(int s, const void *msg, size_t len, int flags, const struct
return ret;
}
/*******************************************************************
A recvfrom wrapper that will deal with EINTR.
********************************************************************/
ssize_t sys_recvfrom(int s, void *buf, size_t len, int flags, struct sockaddr *from, socklen_t *fromlen)
{
ssize_t ret;
do {
ret = recvfrom(s, buf, len, flags, from, fromlen);
} while (ret == -1 && errno == EINTR);
return ret;
}
/*******************************************************************
A fcntl wrapper that will deal with EINTR.
********************************************************************/
int sys_fcntl_ptr(int fd, int cmd, void *arg)
{
int ret;
do {
ret = fcntl(fd, cmd, arg);
} while (ret == -1 && errno == EINTR);
return ret;
}
/*******************************************************************
A fcntl wrapper that will deal with EINTR.
********************************************************************/
int sys_fcntl_long(int fd, int cmd, long arg)
{
int ret;
do {
ret = fcntl(fd, cmd, arg);
} while (ret == -1 && errno == EINTR);
return ret;
}
/*******************************************************************
A stat() wrapper that will deal with 64 bit filesizes.
********************************************************************/
int sys_stat(const char *fname,SMB_STRUCT_STAT *sbuf)
{
int ret;
#if defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(HAVE_OFF64_T) && defined(HAVE_STAT64)
ret = stat64(fname, sbuf);
#else
ret = stat(fname, sbuf);
#endif
/* we always want directories to appear zero size */
if (ret == 0 && S_ISDIR(sbuf->st_mode)) sbuf->st_size = 0;
return ret;
}
/*******************************************************************
An fstat() wrapper that will deal with 64 bit filesizes.
********************************************************************/
int sys_fstat(int fd,SMB_STRUCT_STAT *sbuf)
{
int ret;
#if defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(HAVE_OFF64_T) && defined(HAVE_FSTAT64)
ret = fstat64(fd, sbuf);
#else
ret = fstat(fd, sbuf);
#endif
/* we always want directories to appear zero size */
if (ret == 0 && S_ISDIR(sbuf->st_mode)) sbuf->st_size = 0;
return ret;
}
/*******************************************************************
An lstat() wrapper that will deal with 64 bit filesizes.
********************************************************************/
int sys_lstat(const char *fname,SMB_STRUCT_STAT *sbuf)
{
int ret;
#if defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(HAVE_OFF64_T) && defined(HAVE_LSTAT64)
ret = lstat64(fname, sbuf);
#else
ret = lstat(fname, sbuf);
#endif
/* we always want directories to appear zero size */
if (ret == 0 && S_ISDIR(sbuf->st_mode)) sbuf->st_size = 0;
return ret;
}
/*******************************************************************
An ftruncate() wrapper that will deal with 64 bit filesizes.
********************************************************************/
int sys_ftruncate(int fd, SMB_OFF_T offset)
{
#if defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(HAVE_OFF64_T) && defined(HAVE_FTRUNCATE64)
return ftruncate64(fd, offset);
#else
return ftruncate(fd, offset);
#endif
}
/*******************************************************************
An lseek() wrapper that will deal with 64 bit filesizes.
********************************************************************/
SMB_OFF_T sys_lseek(int fd, SMB_OFF_T offset, int whence)
{
#if defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(HAVE_OFF64_T) && defined(HAVE_LSEEK64)
return lseek64(fd, offset, whence);
#else
return lseek(fd, offset, whence);
#endif
}
/*******************************************************************
A creat() wrapper that will deal with 64 bit filesizes.
********************************************************************/
int sys_creat(const char *path, mode_t mode)
{
#if defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && 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_EXPLICIT_LARGEFILE_SUPPORT) && 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_EXPLICIT_LARGEFILE_SUPPORT) && defined(HAVE_FOPEN64)
return fopen64(path, type);
#else
return fopen(path, type);
#endif
}
/*******************************************************************
A readdir wrapper that will deal with 64 bit filesizes.
********************************************************************/
struct smb_dirent *sys_readdir(DIR *dirp)
{
#if defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(HAVE_READDIR64)
return readdir64(dirp);
#else
return readdir(dirp);
#endif
}
/*******************************************************************
The wait() calls vary between systems
********************************************************************/
int sys_waitpid(pid_t pid,int *status,int options)
{
#ifdef HAVE_WAITPID
return waitpid(pid,status,options);
#else /* HAVE_WAITPID */
return wait4(pid, status, options, NULL);
#endif /* HAVE_WAITPID */
}
/*******************************************************************
System wrapper for getwd

42
source/lib/util.c
View File

@ -40,13 +40,13 @@ const char *tmpdir(void)
/*******************************************************************
Check if a file exists - call vfs_file_exist for samba files.
********************************************************************/
BOOL file_exist(const char *fname,SMB_STRUCT_STAT *sbuf)
BOOL file_exist(const char *fname, struct stat *sbuf)
{
SMB_STRUCT_STAT st;
struct stat st;
if (!sbuf)
sbuf = &st;
if (sys_stat(fname,sbuf) != 0)
if (stat(fname,sbuf) != 0)
return(False);
return((S_ISREG(sbuf->st_mode)) || (S_ISFIFO(sbuf->st_mode)));
@ -58,9 +58,9 @@ BOOL file_exist(const char *fname,SMB_STRUCT_STAT *sbuf)
time_t file_modtime(const char *fname)
{
SMB_STRUCT_STAT st;
struct stat st;
if (sys_stat(fname,&st) != 0)
if (stat(fname,&st) != 0)
return(0);
return(st.st_mtime);
@ -70,15 +70,15 @@ time_t file_modtime(const char *fname)
Check if a directory exists.
********************************************************************/
BOOL directory_exist(const char *dname,SMB_STRUCT_STAT *st)
BOOL directory_exist(const char *dname,struct stat *st)
{
SMB_STRUCT_STAT st2;
struct stat st2;
BOOL ret;
if (!st)
st = &st2;
if (sys_stat(dname,st) != 0)
if (stat(dname,st) != 0)
return(False);
ret = S_ISDIR(st->st_mode);
@ -90,12 +90,12 @@ BOOL directory_exist(const char *dname,SMB_STRUCT_STAT *st)
/*******************************************************************
Returns the size in bytes of the named file.
********************************************************************/
SMB_OFF_T get_file_size(char *file_name)
off_t get_file_size(char *file_name)
{
SMB_STRUCT_STAT buf;
struct stat buf;
buf.st_size = 0;
if(sys_stat(file_name,&buf) != 0)
return (SMB_OFF_T)-1;
if(stat(file_name,&buf) != 0)
return (off_t)-1;
return(buf.st_size);
}
@ -120,9 +120,9 @@ void close_low_fds(BOOL stderr_too)
if (i == 2 && !stderr_too)
continue;
fd = sys_open("/dev/null",O_RDWR,0);
fd = open("/dev/null",O_RDWR,0);
if (fd < 0)
fd = sys_open("/dev/null",O_WRONLY,0);
fd = open("/dev/null",O_WRONLY,0);
if (fd < 0) {
DEBUG(0,("Can't open /dev/null\n"));
return;
@ -155,13 +155,13 @@ int set_blocking(int fd, BOOL set)
#endif
#endif
if((val = sys_fcntl_long(fd, F_GETFL, 0)) == -1)
if((val = fcntl(fd, F_GETFL, 0)) == -1)
return -1;
if(set) /* Turn blocking on - ie. clear nonblock flag */
val &= ~FLAG_TO_SET;
else
val |= FLAG_TO_SET;
return sys_fcntl_long( fd, F_SETFL, val);
return fcntl( fd, F_SETFL, val);
#undef FLAG_TO_SET
}
@ -198,7 +198,7 @@ void become_daemon(BOOL Fork)
setsid();
#elif defined(TIOCNOTTY)
{
int i = sys_open("/dev/tty", O_RDWR, 0);
int i = open("/dev/tty", O_RDWR, 0);
if (i != -1) {
ioctl(i, (int) TIOCNOTTY, (char *)0);
close(i);
@ -509,9 +509,9 @@ BOOL process_exists(pid_t pid)
is dealt with in posix.c
****************************************************************************/
BOOL fcntl_lock(int fd, int op, SMB_OFF_T offset, SMB_OFF_T count, int type)
BOOL fcntl_lock(int fd, int op, off_t offset, off_t count, int type)
{
SMB_STRUCT_FLOCK lock;
struct flock lock;
int ret;
DEBUG(8,("fcntl_lock %d %d %.0f %.0f %d\n",fd,op,(double)offset,(double)count,type));
@ -522,13 +522,13 @@ BOOL fcntl_lock(int fd, int op, SMB_OFF_T offset, SMB_OFF_T count, int type)
lock.l_len = count;
lock.l_pid = 0;
ret = sys_fcntl_ptr(fd,op,&lock);
ret = fcntl(fd,op,&lock);
if (ret == -1 && errno != 0)
DEBUG(3,("fcntl_lock: fcntl lock gave errno %d (%s)\n",errno,strerror(errno)));
/* a lock query */
if (op == SMB_F_GETLK) {
if (op == F_GETLK) {
if ((ret != -1) &&
(lock.l_type != F_UNLCK) &&
(lock.l_pid != 0) &&

94
source/lib/util_file.c
View File

@ -20,96 +20,6 @@
#include "includes.h"
static int gotalarm;
/***************************************************************
Signal function to tell us we timed out.
****************************************************************/
static void gotalarm_sig(void)
{
gotalarm = 1;
}
/***************************************************************
Lock or unlock a fd for a known lock type. Abandon after waitsecs
seconds.
****************************************************************/
BOOL do_file_lock(int fd, int waitsecs, int type)
{
SMB_STRUCT_FLOCK lock;
int ret;
void (*oldsig_handler)(int);
gotalarm = 0;
oldsig_handler = CatchSignal(SIGALRM, SIGNAL_CAST gotalarm_sig);
lock.l_type = type;
lock.l_whence = SEEK_SET;
lock.l_start = 0;
lock.l_len = 1;
lock.l_pid = 0;
alarm(waitsecs);
/* Note we must *NOT* use sys_fcntl here ! JRA */
ret = fcntl(fd, SMB_F_SETLKW, &lock);
alarm(0);
CatchSignal(SIGALRM, SIGNAL_CAST oldsig_handler);
if (gotalarm) {
DEBUG(0, ("do_file_lock: failed to %s file.\n",
type == F_UNLCK ? "unlock" : "lock"));
return False;
}
return (ret == 0);
}
/***************************************************************
Lock an fd. Abandon after waitsecs seconds.
****************************************************************/
BOOL file_lock(int fd, int type, int secs, int *plock_depth)
{
if (fd < 0)
return False;
(*plock_depth)++;
if ((*plock_depth) == 0)
{
if (!do_file_lock(fd, secs, type)) {
DEBUG(10,("file_lock: locking file failed, error = %s.\n",
strerror(errno)));
return False;
}
}
return True;
}
/***************************************************************
Unlock an fd. Abandon after waitsecs seconds.
****************************************************************/
BOOL file_unlock(int fd, int *plock_depth)
{
BOOL ret=True;
if(*plock_depth == 1)
ret = do_file_lock(fd, 5, F_UNLCK);
(*plock_depth)--;
if(!ret)
DEBUG(10,("file_unlock: unlocking file failed, error = %s.\n",
strerror(errno)));
return ret;
}
/*************************************************************************
gets a line out of a file.
line is of format "xxxx:xxxxxx:xxxxx:".
@ -280,10 +190,10 @@ load a file into memory from a fd.
char *fd_load(int fd, size_t *size)
{
SMB_STRUCT_STAT sbuf;
struct stat sbuf;
char *p;
if (sys_fstat(fd, &sbuf) != 0) return NULL;
if (fstat(fd, &sbuf) != 0) return NULL;
p = (char *)malloc(sbuf.st_size+1);
if (!p) return NULL;

2
source/lib/util_sock.c
View File

@ -162,7 +162,7 @@ ssize_t read_udp_socket(int fd, char *buf, size_t len,
struct sockaddr_in sock;
socklen_t socklen = sizeof(sock);
ret = (ssize_t)sys_recvfrom(fd,buf,len, 0, (struct sockaddr *)&sock, &socklen);
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;

4
source/lib/xfile.c
View File

@ -109,7 +109,7 @@ XFILE *x_fopen(const char *fname, int flags, mode_t mode)
ret->open_flags = flags;
ret->fd = sys_open(fname, flags, mode);
ret->fd = open(fname, flags, mode);
if (ret->fd == -1) {
SAFE_FREE(ret);
return NULL;
@ -379,5 +379,5 @@ off_t x_tseek(XFILE *f, off_t offset, int whence)
}
f->flags &= ~X_FLAG_EOF;
return (off_t)sys_lseek(f->fd, offset, whence);
return lseek(f->fd, offset, whence);
}

6
source/libcli/clifile.c
View File

@ -429,7 +429,7 @@ NTSTATUS smbcli_unlock(struct smbcli_tree *tree, int fnum, uint32_t offset, uint
Lock a file with 64 bit offsets.
****************************************************************************/
NTSTATUS smbcli_lock64(struct smbcli_tree *tree, int fnum,
SMB_OFF_T offset, SMB_OFF_T len, int timeout,
off_t offset, off_t len, int timeout,
enum brl_type lock_type)
{
union smb_lock parms;
@ -464,8 +464,8 @@ NTSTATUS smbcli_lock64(struct smbcli_tree *tree, int fnum,
/****************************************************************************
Unlock a file with 64 bit offsets.
****************************************************************************/
NTSTATUS smbcli_unlock64(struct smbcli_tree *tree, int fnum, SMB_OFF_T offset,
SMB_OFF_T len)
NTSTATUS smbcli_unlock64(struct smbcli_tree *tree, int fnum, off_t offset,
off_t len)
{
union smb_lock parms;
struct smb_lock_entry lock[1];

4
source/libcli/clitrans2.c
View File

@ -67,7 +67,7 @@ send a qpathinfo call with the SMB_QUERY_FILE_ALL_INFO info level
NTSTATUS smbcli_qpathinfo2(struct smbcli_tree *tree, const char *fname,
time_t *c_time, time_t *a_time, time_t *m_time,
time_t *w_time, size_t *size, uint16_t *mode,
SMB_INO_T *ino)
ino_t *ino)
{
union smb_fileinfo parms;
TALLOC_CTX *mem_ctx;
@ -143,7 +143,7 @@ send a qfileinfo call
NTSTATUS smbcli_qfileinfo(struct smbcli_tree *tree, int fnum,
uint16_t *mode, size_t *size,
time_t *c_time, time_t *a_time, time_t *m_time,
time_t *w_time, SMB_INO_T *ino)
time_t *w_time, ino_t *ino)
{
union smb_fileinfo parms;
TALLOC_CTX *mem_ctx;

1
source/libcli/config.m4
View File

@ -34,7 +34,6 @@ SMB_SUBSYSTEM(LIBCLI_UTILS,[],
libcli/util/doserr.o
libcli/util/errormap.o
libcli/util/clierror.o
libcli/util/cliutil.o
libcli/util/nterr.o
libcli/util/smbdes.o
libcli/util/smbencrypt.o

109
source/libcli/util/cliutil.c
View File

@ -1,109 +0,0 @@
/*
Unix SMB/CIFS implementation.
client utility routines
Copyright (C) Andrew Tridgell 2001
Copyright (C) James Myers 2003 <myersjj@samba.org>
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/
#include "includes.h"
#include "libcli/raw/libcliraw.h"
/*******************************************************************
Functions nicked from lib/util.c needed by client.
*******************************************************************/
/*******************************************************************
A wrapper that handles case sensitivity and the special handling
of the ".." name.
*******************************************************************/
BOOL mask_match(struct smbcli_state *cli, const char *string, char *pattern, BOOL is_case_sensitive)
{
fstring p2, s2;
if (strcmp(string,"..") == 0)
string = ".";
if (strcmp(pattern,".") == 0)
return False;
if (is_case_sensitive)
return ms_fnmatch(pattern, string,
cli->transport->negotiate.protocol) == 0;
fstrcpy(p2, pattern);
fstrcpy(s2, string);
strlower(p2);
strlower(s2);
return ms_fnmatch(p2, s2, cli->transport->negotiate.protocol) == 0;
}
/****************************************************************************
Put up a yes/no prompt.
****************************************************************************/
BOOL yesno(char *p)
{
pstring ans;
printf("%s",p);
if (!fgets(ans,sizeof(ans)-1,stdin))
return(False);
if (*ans == 'y' || *ans == 'Y')
return(True);
return(False);
}
/*******************************************************************
A readdir wrapper which just returns the file name.
********************************************************************/
const char *readdirname(DIR *p)
{
struct smb_dirent *ptr;
char *dname;
if (!p)
return(NULL);
ptr = (struct smb_dirent *)sys_readdir(p);
if (!ptr)
return(NULL);
dname = ptr->d_name;
#ifdef NEXT2
if (telldir(p) < 0)
return(NULL);
#endif
#ifdef HAVE_BROKEN_READDIR
/* using /usr/ucb/cc is BAD */
dname = dname - 2;
#endif
{
static pstring buf;
int len = NAMLEN(ptr);
memcpy(buf, dname, len);
buf[len] = 0;
dname = buf;
}
return(dname);
}

2
source/ntvfs/nbench/vfs_nbench.c
View File

@ -102,7 +102,7 @@ static NTSTATUS nbench_connect(struct ntvfs_module_context *ntvfs,
}
asprintf(&logname, "/tmp/nbenchlog%d.%u", ntvfs->depth, getpid());
nprivates->log_fd = sys_open(logname, O_WRONLY|O_CREAT|O_APPEND, 0644);
nprivates->log_fd = open(logname, O_WRONLY|O_CREAT|O_APPEND, 0644);
free(logname);
if (nprivates->log_fd == -1) {

2
source/ntvfs/ntvfs_dfs.c
View File

@ -92,7 +92,7 @@ struct ntvfs_ops *ntvfs_backend_byname(const char *name, enum ntvfs_type type)
int ntvfs_interface_version(struct ntvfs_critical_sizes *sizes)
{
sizes->sizeof_ntvfs_ops = sizeof(struct ntvfs_ops);
sizes->sizeof_SMB_OFF_T = sizeof(SMB_OFF_T);
sizes->sizeof_off_t = sizeof(off_t);
sizes->sizeof_tcon_context = sizeof(struct tcon_context);
return NTVFS_INTERFACE_VERSION;

2
source/smb_server/reply.c
View File

@ -682,7 +682,7 @@ void reply_readbraw(struct smbsrv_request *req)
/* the 64 bit variant */
if (req->in.wct == 10) {
uint32_t offset_high = IVAL(req->in.vwv, VWV(8));
io.readbraw.in.offset |= (((SMB_OFF_T)offset_high) << 32);
io.readbraw.in.offset |= (((off_t)offset_high) << 32);
}
/* before calling the backend we setup the raw buffer. This

2
source/torture/gentest.c
View File

@ -504,7 +504,7 @@ static uint16_t gen_pid(void)
/*
generate a lock count
*/
static SMB_OFF_T gen_lock_count(void)
static off_t gen_lock_count(void)
{
return gen_int_range(0, 3);
}

14
source/torture/locktest2.c
View File

@ -133,17 +133,6 @@ static BOOL try_unlock(struct smbcli_state *c, int fstype,
return False;
}
static void print_brl(SMB_DEV_T dev, SMB_INO_T ino, int pid,
enum brl_type lock_type,
br_off start, br_off size)
{
printf("%6d %05x:%05x %s %.0f:%.0f(%.0f)\n",
(int)pid, (int)dev, (int)ino,
lock_type==READ_LOCK?"R":"W",
(double)start, (double)start+size-1,(double)size);
}
/*****************************************************
return a connection to a server
*******************************************************/
@ -256,7 +245,6 @@ static BOOL test_one(struct smbcli_state *cli[NSERVERS][NCONNECTIONS],
op==READ_LOCK?"READ_LOCK":"WRITE_LOCK",
ret[0], ret[1]);
}
if (showall) brl_forall(print_brl);
if (ret[0] != ret[1]) return False;
} else if (r2 < LOCK_PCT+UNLOCK_PCT) {
/* unset a lock */
@ -271,7 +259,6 @@ static BOOL test_one(struct smbcli_state *cli[NSERVERS][NCONNECTIONS],
start, start+len-1, len,
ret[0], ret[1]);
}
if (showall) brl_forall(print_brl);
if (!hide_unlock_fails && ret[0] != ret[1]) return False;
} else {
/* reopen the file */
@ -287,7 +274,6 @@ static BOOL test_one(struct smbcli_state *cli[NSERVERS][NCONNECTIONS],
if (showall) {
printf("reopen conn=%u fstype=%u f=%u\n",
conn, fstype, f);
brl_forall(print_brl);
}
}
return True;

9
source/torture/torture_util.c
View File

@ -167,6 +167,15 @@ void *shm_setup(int size)
int shmid;
void *ret;
/* NetBSD doesn't have these */
#ifndef SHM_R
#define SHM_R 0400
#endif
#ifndef SHM_W
#define SHM_W 0200
#endif
shmid = shmget(IPC_PRIVATE, size, SHM_R | SHM_W);
if (shmid == -1) {
printf("can't get shared memory\n");