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

Restructuring of vfs layer to include a "this" pointer - can be an fsp or

Browse Source 
a conn struct depending on the call.
We need this to have a clean NT ACL call interface.
This will break any existing VFS libraries (that's why this is pre-release
code).
Andrew gets credit for this one :-) :-).

In addition - added Herb's WITH_PROFILE changes - Herb - please examine
the changes I've made to the smbd/reply.c code you added. The original
code was very ugly and I have replaced it with a
START_PROFILE(x)/END_PROFILE(x) pair using the preprocessor.
Please check this compiles ok with the --with-profile switch.
Jeremy.
(This used to be commit b07611f815)
This commit is contained in:
Jeremy Allison 2000-10-06 03:21:49 +00:00
parent 56d514235e
commit 636f146abf
22 changed files with 838 additions and 516 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
source3/include/includes.h
View File

@ -637,6 +637,9 @@ extern int errno;
#ifdef WITH_PROFILE
#include "profile.h"
#else
#define START_PROFILE(x)
#define END_PROFILE(x)
#endif
#ifndef MAXCODEPAGELINES

290
source3/include/profile.h
View File

@ -1,3 +1,5 @@
#ifndef _PROFILE_H_
#define _PROFILE_H_
/*
Unix SMB/Netbios implementation.
Version 1.9.
@ -25,14 +27,300 @@
#define PROF_SHMEM_KEY ((key_t)0x07021999)
#define PROF_SHM_MAGIC 0x6349985
#define PROF_SHM_VERSION 1
#define PROF_SHM_VERSION 2
/* time values in the following structure are in milliseconds */
struct profile_struct {
int prof_shm_magic;
int prof_shm_version;
/* general counters */
unsigned smb_count; /* how many SMB packets we have processed */
unsigned uid_changes; /* how many times we change our effective uid */
/* system call counters */
unsigned syscall_opendir_count;
unsigned syscall_opendir_time;
unsigned syscall_readdir_count;
unsigned syscall_readdir_time;
unsigned syscall_mkdir_count;
unsigned syscall_mkdir_time;
unsigned syscall_rmdir_count;
unsigned syscall_rmdir_time;
unsigned syscall_closedir_count;
unsigned syscall_closedir_time;
unsigned syscall_open_count;
unsigned syscall_open_time;
unsigned syscall_close_count;
unsigned syscall_close_time;
unsigned syscall_read_count;
unsigned syscall_read_time;
unsigned syscall_read_bytes; /* bytes read with read syscall */
unsigned syscall_write_count;
unsigned syscall_write_time;
unsigned syscall_write_bytes; /* bytes written with write syscall */
unsigned syscall_lseek_count;
unsigned syscall_lseek_time;
unsigned syscall_rename_count;
unsigned syscall_rename_time;
unsigned syscall_fsync_count;
unsigned syscall_fsync_time;
unsigned syscall_stat_count;
unsigned syscall_stat_time;
unsigned syscall_fstat_count;
unsigned syscall_fstat_time;
unsigned syscall_lstat_count;
unsigned syscall_lstat_time;
unsigned syscall_unlink_count;
unsigned syscall_unlink_time;
unsigned syscall_chmod_count;
unsigned syscall_chmod_time;
unsigned syscall_chown_count;
unsigned syscall_chown_time;
unsigned syscall_chdir_count;
unsigned syscall_chdir_time;
unsigned syscall_getwd_count;
unsigned syscall_getwd_time;
unsigned syscall_utime_count;
unsigned syscall_utime_time;
unsigned syscall_ftruncate_count;
unsigned syscall_ftruncate_time;
unsigned syscall_fcntl_lock_count;
unsigned syscall_fcntl_lock_time;
/* stat cache counters */
unsigned statcache_lookups;
unsigned statcache_misses;
unsigned statcache_hits;
/* write cache counters */
unsigned writecache_read_hits;
unsigned writecache_abutted_writes;
unsigned writecache_total_writes;
unsigned writecache_non_oplock_writes;
unsigned writecache_direct_writes;
unsigned writecache_init_writes;
unsigned writecache_flushed_writes[NUM_FLUSH_REASONS];
unsigned writecache_num_perfect_writes;
unsigned writecache_num_write_caches;
unsigned writecache_allocated_write_caches;
/* counters for individual SMB types */
unsigned SMBmkdir_count; /* create directory */
unsigned SMBmkdir_time;
unsigned SMBrmdir_count; /* delete directory */
unsigned SMBrmdir_time;
unsigned SMBopen_count; /* open file */
unsigned SMBopen_time;
unsigned SMBcreate_count; /* create file */
unsigned SMBcreate_time;
unsigned SMBclose_count; /* close file */
unsigned SMBclose_time;
unsigned SMBflush_count; /* flush file */
unsigned SMBflush_time;
unsigned SMBunlink_count; /* delete file */
unsigned SMBunlink_time;
unsigned SMBmv_count; /* rename file */
unsigned SMBmv_time;
unsigned SMBgetatr_count; /* get file attributes */
unsigned SMBgetatr_time;
unsigned SMBsetatr_count; /* set file attributes */
unsigned SMBsetatr_time;
unsigned SMBread_count; /* read from file */
unsigned SMBread_time;
unsigned SMBwrite_count; /* write to file */
unsigned SMBwrite_time;
unsigned SMBlock_count; /* lock byte range */
unsigned SMBlock_time;
unsigned SMBunlock_count; /* unlock byte range */
unsigned SMBunlock_time;
unsigned SMBctemp_count; /* create temporary file */
unsigned SMBctemp_time;
/* SMBmknew stats are currently combined with SMBcreate */
unsigned SMBmknew_count; /* make new file */
unsigned SMBmknew_time;
unsigned SMBchkpth_count; /* check directory path */
unsigned SMBchkpth_time;
unsigned SMBexit_count; /* process exit */
unsigned SMBexit_time;
unsigned SMBlseek_count; /* seek */
unsigned SMBlseek_time;
unsigned SMBlockread_count; /* Lock a range and read */
unsigned SMBlockread_time;
unsigned SMBwriteunlock_count; /* Unlock a range then write */
unsigned SMBwriteunlock_time;
unsigned SMBreadbraw_count; /* read a block of data with no smb header */
unsigned SMBreadbraw_time;
unsigned SMBreadBmpx_count; /* read block multiplexed */
unsigned SMBreadBmpx_time;
unsigned SMBreadBs_count; /* read block (secondary response) */
unsigned SMBreadBs_time;
unsigned SMBwritebraw_count; /* write a block of data with no smb header */
unsigned SMBwritebraw_time;
unsigned SMBwriteBmpx_count; /* write block multiplexed */
unsigned SMBwriteBmpx_time;
unsigned SMBwriteBs_count; /* write block (secondary request) */
unsigned SMBwriteBs_time;
unsigned SMBwritec_count; /* secondary write request */
unsigned SMBwritec_time;
unsigned SMBsetattrE_count; /* set file attributes expanded */
unsigned SMBsetattrE_time;
unsigned SMBgetattrE_count; /* get file attributes expanded */
unsigned SMBgetattrE_time;
unsigned SMBlockingX_count; /* lock/unlock byte ranges and X */
unsigned SMBlockingX_time;
unsigned SMBtrans_count; /* transaction - name, bytes in/out */
unsigned SMBtrans_time;
unsigned SMBtranss_count; /* transaction (secondary request/response) */
unsigned SMBtranss_time;
unsigned SMBioctl_count; /* IOCTL */
unsigned SMBioctl_time;
unsigned SMBioctls_count; /* IOCTL (secondary request/response) */
unsigned SMBioctls_time;
unsigned SMBcopy_count; /* copy */
unsigned SMBcopy_time;
unsigned SMBmove_count; /* move */
unsigned SMBmove_time;
unsigned SMBecho_count; /* echo */
unsigned SMBecho_time;
unsigned SMBwriteclose_count; /* write a file then close it */
unsigned SMBwriteclose_time;
unsigned SMBopenX_count; /* open and X */
unsigned SMBopenX_time;
unsigned SMBreadX_count; /* read and X */
unsigned SMBreadX_time;
unsigned SMBwriteX_count; /* write and X */
unsigned SMBwriteX_time;
unsigned SMBtrans2_count; /* TRANS2 protocol set */
unsigned SMBtrans2_time;
unsigned SMBtranss2_count; /* TRANS2 protocol set, secondary command */
unsigned SMBtranss2_time;
unsigned SMBfindclose_count; /* Terminate a TRANSACT2_FINDFIRST */
unsigned SMBfindclose_time;
unsigned SMBfindnclose_count; /* Terminate a TRANSACT2_FINDNOTIFYFIRST */
unsigned SMBfindnclose_time;
unsigned SMBtcon_count; /* tree connect */
unsigned SMBtcon_time;
unsigned SMBtdis_count; /* tree disconnect */
unsigned SMBtdis_time;
unsigned SMBnegprot_count; /* negotiate protocol */
unsigned SMBnegprot_time;
unsigned SMBsesssetupX_count; /* Session Set Up & X (including User Logon) */
unsigned SMBsesssetupX_time;
unsigned SMBulogoffX_count; /* user logoff */
unsigned SMBulogoffX_time;
unsigned SMBtconX_count; /* tree connect and X*/
unsigned SMBtconX_time;
unsigned SMBdskattr_count; /* get disk attributes */
unsigned SMBdskattr_time;
unsigned SMBsearch_count; /* search directory */
unsigned SMBsearch_time;
/* SBMffirst stats combined with SMBsearch */
unsigned SMBffirst_count; /* find first */
unsigned SMBffirst_time;
/* SBMfunique stats combined with SMBsearch */
unsigned SMBfunique_count; /* find unique */
unsigned SMBfunique_time;
unsigned SMBfclose_count; /* find close */
unsigned SMBfclose_time;
unsigned SMBnttrans_count; /* NT transact */
unsigned SMBnttrans_time;
unsigned SMBnttranss_count; /* NT transact secondary */
unsigned SMBnttranss_time;
unsigned SMBntcreateX_count; /* NT create and X */
unsigned SMBntcreateX_time;
unsigned SMBntcancel_count; /* NT cancel */
unsigned SMBntcancel_time;
unsigned SMBsplopen_count; /* open print spool file */
unsigned SMBsplopen_time;
unsigned SMBsplwr_count; /* write to print spool file */
unsigned SMBsplwr_time;
unsigned SMBsplclose_count; /* close print spool file */
unsigned SMBsplclose_time;
unsigned SMBsplretq_count; /* return print queue */
unsigned SMBsplretq_time;
unsigned SMBsends_count; /* send single block message */
unsigned SMBsends_time;
unsigned SMBsendb_count; /* send broadcast message */
unsigned SMBsendb_time;
unsigned SMBfwdname_count; /* forward user name */
unsigned SMBfwdname_time;
unsigned SMBcancelf_count; /* cancel forward */
unsigned SMBcancelf_time;
unsigned SMBgetmac_count; /* get machine name */
unsigned SMBgetmac_time;
unsigned SMBsendstrt_count; /* send start of multi-block message */
unsigned SMBsendstrt_time;
unsigned SMBsendend_count; /* send end of multi-block message */
unsigned SMBsendend_time;
unsigned SMBsendtxt_count; /* send text of multi-block message */
unsigned SMBsendtxt_time;
unsigned SMBinvalid_count; /* invalid command */
unsigned SMBinvalid_time;
/* Pathworks setdir command */
unsigned pathworks_setdir_count;
unsigned pathworks_setdir_time;
/* These are the TRANS2 sub commands */
unsigned Trans2_open_count;
unsigned Trans2_open_time;
unsigned Trans2_findfirst_count;
unsigned Trans2_findfirst_time;
unsigned Trans2_findnext_count;
unsigned Trans2_findnext_time;
unsigned Trans2_qfsinfo_count;
unsigned Trans2_qfsinfo_time;
unsigned Trans2_setfsinfo_count;
unsigned Trans2_setfsinfo_time;
unsigned Trans2_qpathinfo_count;
unsigned Trans2_qpathinfo_time;
unsigned Trans2_setpathinfo_count;
unsigned Trans2_setpathinfo_time;
unsigned Trans2_qfileinfo_count;
unsigned Trans2_qfileinfo_time;
unsigned Trans2_setfileinfo_count;
unsigned Trans2_setfileinfo_time;
unsigned Trans2_fsctl_count;
unsigned Trans2_fsctl_time;
unsigned Trans2_ioctl_count;
unsigned Trans2_ioctl_time;
unsigned Trans2_findnotifyfirst_count;
unsigned Trans2_findnotifyfirst_time;
unsigned Trans2_findnotifynext_count;
unsigned Trans2_findnotifynext_time;
unsigned Trans2_mkdir_count;
unsigned Trans2_mkdir_time;
unsigned Trans2_session_setup_count;
unsigned Trans2_session_setup_time;
unsigned Trans2_get_dfs_referral_count;
unsigned Trans2_get_dfs_referral_time;
unsigned Trans2_report_dfs_inconsistancy_count;
unsigned Trans2_report_dfs_inconsistancy_time;
/* These are the NT transact sub commands. */
unsigned NT_transact_create_count;
unsigned NT_transact_create_time;
unsigned NT_transact_ioctl_count;
unsigned NT_transact_ioctl_time;
unsigned NT_transact_set_security_desc_count;
unsigned NT_transact_set_security_desc_time;
unsigned NT_transact_notify_change_count;
unsigned NT_transact_notify_change_time;
unsigned NT_transact_rename_count;
unsigned NT_transact_rename_time;
unsigned NT_transact_query_security_desc_count;
unsigned NT_transact_query_security_desc_time;
};
extern struct profile_struct *profile_p;
#define INC_PROFILE_COUNT(x) if (profile_p) profile_p->x++
#define DEC_PROFILE_COUNT(x) if (profile_p) profile_p->x--
#define ADD_PROFILE_COUNT(x,y) if (profile_p) profile_p->x += (y)
#define START_PROFILE(x) \
struct timeval starttime; \
struct timeval endtime; \
GetTimeOfDay(&starttime); \
INC_PROFILE_COUNT(x##_count)
#define END_PROFILE(y) \
GetTimeOfDay(&endtime); \
ADD_PROFILE_COUNT((y##_time),TvalDiff(&starttime,&endtime))
#endif

55
source3/include/proto.h
View File

@ -3833,44 +3833,43 @@ BOOL set_nt_acl(files_struct *fsp, uint32 security_info_sent, SEC_DESC *psd);
/*The following definitions come from smbd/vfs-wrap.c */
int vfswrap_dummy_connect(struct vfs_connection_struct *conn, char *service,
char *user);
int vfswrap_dummy_connect(connection_struct *conn, char *service, char *user);
void vfswrap_dummy_disconnect(void);
SMB_BIG_UINT vfswrap_disk_free(char *path, BOOL small_query, SMB_BIG_UINT *bsize,
SMB_BIG_UINT vfswrap_disk_free(connection_struct *conn, char *path, BOOL small_query, SMB_BIG_UINT *bsize,
SMB_BIG_UINT *dfree, SMB_BIG_UINT *dsize);
DIR *vfswrap_opendir(char *fname);
struct dirent *vfswrap_readdir(DIR *dirp);
int vfswrap_mkdir(char *path, mode_t mode);
int vfswrap_rmdir(char *path);
int vfswrap_closedir(DIR *dirp);
int vfswrap_open(char *fname, int flags, mode_t mode);
int vfswrap_close(int fd);
ssize_t vfswrap_read(int fd, char *data, size_t n);
ssize_t vfswrap_write(int fd, char *data, size_t n);
SMB_OFF_T vfswrap_lseek(int filedes, SMB_OFF_T offset, int whence);
int vfswrap_rename(char *old, char *new);
int vfswrap_fsync(int fd);
int vfswrap_stat(char *fname, SMB_STRUCT_STAT *sbuf);
int vfswrap_fstat(int fd, SMB_STRUCT_STAT *sbuf);
int vfswrap_lstat(char *path,
SMB_STRUCT_STAT *sbuf);
int vfswrap_unlink(char *path);
int vfswrap_chmod(char *path, mode_t mode);
int vfswrap_chown(char *path, uid_t uid, gid_t gid);
int vfswrap_chdir(char *path);
char *vfswrap_getwd(char *path);
int vfswrap_utime(char *path, struct utimbuf *times);
int vfswrap_ftruncate(int fd, SMB_OFF_T offset);
BOOL vfswrap_lock(int fd, int op, SMB_OFF_T offset, SMB_OFF_T count, int type);
DIR *vfswrap_opendir(connection_struct *conn, char *fname);
struct dirent *vfswrap_readdir(connection_struct *conn, DIR *dirp);
int vfswrap_mkdir(connection_struct *conn, char *path, mode_t mode);
int vfswrap_rmdir(connection_struct *conn, char *path);
int vfswrap_closedir(connection_struct *conn, DIR *dirp);
int vfswrap_open(connection_struct *conn, char *fname, int flags, mode_t mode);
int vfswrap_close(files_struct *fsp, int fd);
ssize_t vfswrap_read(files_struct *fsp, int fd, char *data, size_t n);
ssize_t vfswrap_write(files_struct *fsp, int fd, char *data, size_t n);
SMB_OFF_T vfswrap_lseek(files_struct *fsp, int filedes, SMB_OFF_T offset, int whence);
int vfswrap_rename(connection_struct *conn, char *old, char *new);
int vfswrap_fsync(files_struct *fsp, int fd);
int vfswrap_stat(connection_struct *conn, char *fname, SMB_STRUCT_STAT *sbuf);
int vfswrap_fstat(files_struct *fsp, int fd, SMB_STRUCT_STAT *sbuf);
int vfswrap_lstat(connection_struct *conn, char *path, SMB_STRUCT_STAT *sbuf);
int vfswrap_unlink(connection_struct *conn, char *path);
int vfswrap_chmod(connection_struct *conn, char *path, mode_t mode);
int vfswrap_chown(connection_struct *conn, char *path, uid_t uid, gid_t gid);
int vfswrap_chdir(connection_struct *conn, char *path);
char *vfswrap_getwd(connection_struct *conn, char *path);
int vfswrap_utime(connection_struct *conn, char *path, struct utimbuf *times);
int vfswrap_ftruncate(files_struct *fsp, int fd, SMB_OFF_T offset);
BOOL vfswrap_lock(files_struct *fsp, int fd, int op, SMB_OFF_T offset, SMB_OFF_T count, int type);
/*The following definitions come from smbd/vfs.c */
int vfs_init_default(connection_struct *conn);
BOOL vfs_init_custom(connection_struct *conn);
int vfs_stat(connection_struct *conn, char *fname, SMB_STRUCT_STAT *st);
int vfs_fstat(connection_struct *conn, int fd, SMB_STRUCT_STAT *st);
int vfs_fstat(files_struct *fsp, int fd, SMB_STRUCT_STAT *st);
BOOL vfs_directory_exist(connection_struct *conn, char *dname, SMB_STRUCT_STAT *st);
int vfs_mkdir(connection_struct *conn, char *fname, mode_t mode);
int vfs_rmdir(connection_struct *conn, char *fname);
int vfs_unlink(connection_struct *conn, char *fname);
int vfs_chmod(connection_struct *conn, char *fname,mode_t mode);
int vfs_chown(connection_struct *conn, char *fname, uid_t uid, gid_t gid);

3
source3/include/smb.h
View File

@ -580,7 +580,8 @@ typedef struct connection_struct
char *origpath;
struct vfs_ops vfs_ops; /* Filesystem operations */
struct vfs_connection_struct *vfs_conn; /* VFS specific connection stuff */
/* Handle on dlopen() call */
void *dl_handle;
char *user; /* name of user who *opened* this connection */
uid_t uid; /* uid of user who *opened* this connection */

257
source3/include/vfs.h
View File

@ -22,246 +22,65 @@
#ifndef _VFS_H
#define _VFS_H
/* Types used in the definition of VFS operations. These are included
here so the vfs.h file can be included by VFS modules without
having to pull in unnecessary amounts of other stuff. Note to VFS
writers: you must include config.h before including this file.
The following type definitions reference the HAVE_* symbols which
are defined in config.h */
#ifndef SMB_OFF_T
# ifdef HAVE_OFF64_T
# define SMB_OFF_T off64_t
# else
# define SMB_OFF_T off_t
# endif
#endif
#ifndef SMB_STRUCT_STAT
# if defined(HAVE_STAT64) && defined(HAVE_OFF64_T)
# define SMB_STRUCT_STAT struct stat64
# else
# define SMB_STRUCT_STAT struct stat
# endif
#endif
#ifndef _BOOL
typedef int BOOL;
#endif
#ifndef _PSTRING
#define PSTRING_LEN 1024
#define FSTRING_LEN 128
typedef char pstring[PSTRING_LEN];
typedef char fstring[FSTRING_LEN];
#define _PSTRING
#endif
#if defined(HAVE_LONGLONG)
#define SMB_BIG_UINT unsigned long long
#else
#define SMB_BIG_UINT unsigned long
#endif
#ifndef MAXSUBAUTHS
#define MAXSUBAUTHS 15 /* max sub authorities in a SID */
#endif
#ifndef uint8
#define uint8 unsigned char
#endif
#if !defined(uint32) && !defined(HAVE_UINT32_FROM_RPC_RPC_H)
#if (SIZEOF_INT == 4)
#define uint32 unsigned int
#elif (SIZEOF_LONG == 4)
#define uint32 unsigned long
#elif (SIZEOF_SHORT == 4)
#define uint32 unsigned short
#endif
#endif
#ifndef _DOM_SID
/* DOM_SID - security id */
typedef struct sid_info
{
uint8 sid_rev_num; /* SID revision number */
uint8 num_auths; /* number of sub-authorities */
uint8 id_auth[6]; /* Identifier Authority */
/*
* Note that the values in these uint32's are in *native* byteorder,
* not neccessarily little-endian...... JRA.
*/
uint32 sub_auths[MAXSUBAUTHS]; /* pointer to sub-authorities. */
} DOM_SID;
#define _DOM_SID
#endif
#ifndef _SEC_ACCESS
/* SEC_ACCESS */
typedef struct security_info_info
{
uint32 mask;
} SEC_ACCESS;
#define _SEC_ACCESS
#endif
#ifndef _SEC_ACE
/* SEC_ACE */
typedef struct security_ace_info
{
uint8 type; /* xxxx_xxxx_ACE_TYPE - e.g allowed / denied etc */
uint8 flags; /* xxxx_INHERIT_xxxx - e.g OBJECT_INHERIT_ACE */
uint16 size;
SEC_ACCESS info;
DOM_SID sid;
} SEC_ACE;
#define _SEC_ACE
#endif
#ifndef ACL_REVISION
#define ACL_REVISION 0x3
#endif
#ifndef _SEC_ACL
/* SEC_ACL */
typedef struct security_acl_info
{
uint16 revision; /* 0x0003 */
uint16 size; /* size in bytes of the entire ACL structure */
uint32 num_aces; /* number of Access Control Entries */
SEC_ACE *ace;
} SEC_ACL;
#define _SEC_ACL
#endif
#ifndef SEC_DESC_REVISION
#define SEC_DESC_REVISION 0x1
#endif
#ifndef _SEC_DESC
/* SEC_DESC */
typedef struct security_descriptor_info
{
uint16 revision; /* 0x0001 */
uint16 type; /* SEC_DESC_xxxx flags */
uint32 off_owner_sid; /* offset to owner sid */
uint32 off_grp_sid ; /* offset to group sid */
uint32 off_sacl ; /* offset to system list of permissions */
uint32 off_dacl ; /* offset to list of permissions */
SEC_ACL *dacl; /* user ACL */
SEC_ACL *sacl; /* system ACL */
DOM_SID *owner_sid;
DOM_SID *grp_sid;
} SEC_DESC;
#define _SEC_DESC
#endif
/*
* The complete list of SIDS belonging to this user.
* Created when a vuid is registered.
*/
#ifndef _NT_USER_TOKEN
typedef struct _nt_user_token {
size_t num_sids;
DOM_SID *user_sids;
} NT_USER_TOKEN;
#define _NT_USER_TOKEN
#endif
/* Avoid conflict with an AIX include file */
#ifdef vfs_ops
#undef vfs_ops
#endif
/* Information from the connection_struct passed to the vfs layer */
struct vfs_connection_struct {
/* Connection information */
BOOL printer;
BOOL ipc;
BOOL read_only;
BOOL admin_user;
/* Handle on dlopen() call */
void *dl_handle;
/* Paths */
pstring dirpath;
pstring connectpath;
pstring origpath;
pstring service;
/* Information on user who *opened* this connection */
pstring user;
uid_t uid;
gid_t gid;
int ngroups;
gid_t *groups;
NT_USER_TOKEN *nt_user_token;
};
/*
* As we're now (thanks Andrew ! :-) using file_structs and connection
* structs in the vfs - then anyone writing a vfs must include includes.h...
*/
/* VFS operations structure */
struct connection_struct;
struct files_struct;
struct security_descriptor_info;
struct vfs_ops {
/* Disk operations */
int (*connect)(struct vfs_connection_struct *conn, char *service, char *user);
void (*disconnect)(void);
SMB_BIG_UINT (*disk_free)(char *path, BOOL small_query, SMB_BIG_UINT *bsize,
int (*connect)(struct connection_struct *conn, char *service, char *user);
void (*disconnect)(struct connection_struct *conn);
SMB_BIG_UINT (*disk_free)(struct connection_struct *conn, char *path, BOOL small_query, SMB_BIG_UINT *bsize,
SMB_BIG_UINT *dfree, SMB_BIG_UINT *dsize);
/* Directory operations */
DIR *(*opendir)(char *fname);
struct dirent *(*readdir)(DIR *dirp);
int (*mkdir)(char *path, mode_t mode);
int (*rmdir)(char *path);
int (*closedir)(DIR *dir);
DIR *(*opendir)(struct connection_struct *conn, char *fname);
struct dirent *(*readdir)(struct connection_struct *conn, DIR *dirp);
int (*mkdir)(struct connection_struct *conn, char *path, mode_t mode);
int (*rmdir)(struct connection_struct *conn, char *path);
int (*closedir)(struct connection_struct *conn, DIR *dir);
/* File operations */
int (*open)(char *fname, int flags, mode_t mode);
int (*close)(int fd);
ssize_t (*read)(int fd, char *data, size_t n);
ssize_t (*write)(int fd, char *data, size_t n);
SMB_OFF_T (*lseek)(int filedes, SMB_OFF_T offset, int whence);
int (*rename)(char *old, char *new);
int (*fsync)(int fd);
int (*stat)(char *fname, SMB_STRUCT_STAT *sbuf);
int (*fstat)(int fd, SMB_STRUCT_STAT *sbuf);
int (*lstat)(char *path, SMB_STRUCT_STAT *sbuf);
int (*unlink)(char *path);
int (*chmod)(char *path, mode_t mode);
int (*chown)(char *path, uid_t uid, gid_t gid);
int (*chdir)(char *path);
char *(*getwd)(char *buf);
int (*utime)(char *path, struct utimbuf *times);
int (*ftruncate)(int fd, SMB_OFF_T offset);
BOOL (*lock)(int fd, int op, SMB_OFF_T offset, SMB_OFF_T count, int type);
int (*open)(struct connection_struct *conn, char *fname, int flags, mode_t mode);
int (*close)(struct files_struct *fsp, int fd);
ssize_t (*read)(struct files_struct *fsp, int fd, char *data, size_t n);
ssize_t (*write)(struct files_struct *fsp, int fd, char *data, size_t n);
SMB_OFF_T (*lseek)(struct files_struct *fsp, int filedes, SMB_OFF_T offset, int whence);
int (*rename)(struct connection_struct *conn, char *old, char *new);
int (*fsync)(struct files_struct *fsp, int fd);
int (*stat)(struct connection_struct *conn, char *fname, SMB_STRUCT_STAT *sbuf);
int (*fstat)(struct files_struct *fsp, int fd, SMB_STRUCT_STAT *sbuf);
int (*lstat)(struct connection_struct *conn, char *path, SMB_STRUCT_STAT *sbuf);
int (*unlink)(struct connection_struct *conn, char *path);
int (*chmod)(struct connection_struct *conn, char *path, mode_t mode);
int (*chown)(struct connection_struct *conn, char *path, uid_t uid, gid_t gid);
int (*chdir)(struct connection_struct *conn, char *path);
char *(*getwd)(struct connection_struct *conn, char *buf);
int (*utime)(struct connection_struct *conn, char *path, struct utimbuf *times);
int (*ftruncate)(struct files_struct *fsp, int fd, SMB_OFF_T offset);
BOOL (*lock)(struct files_struct *fsp, int fd, int op, SMB_OFF_T offset, SMB_OFF_T count, int type);
size_t (*fget_nt_acl)(int fd, SEC_DESC **ppdesc);
size_t (*get_nt_acl)(char *name, SEC_DESC **ppdesc);
BOOL (*fset_nt_acl)(int fd, uint32 security_info_sent, SEC_DESC *psd);
BOOL (*set_nt_acl)(char *name, uint32 security_info_sent, SEC_DESC *psd);
size_t (*fget_nt_acl)(struct files_struct *fsp, int fd, struct security_descriptor_info **ppdesc);
size_t (*get_nt_acl)(struct connection_struct *conn, char *name, struct security_descriptor_info **ppdesc);
BOOL (*fset_nt_acl)(struct files_struct *fsp, int fd, uint32 security_info_sent, struct security_descriptor_info *psd);
BOOL (*set_nt_acl)(struct connection_struct *conn, char *name, uint32 security_info_sent, struct security_descriptor_info *psd);
};
struct vfs_options {

12
source3/locking/posix.c
View File

@ -204,7 +204,7 @@ int fd_close_posix(struct connection_struct *conn, files_struct *fsp)
/*
* No POSIX to worry about, just close.
*/
ret = conn->vfs_ops.close(fsp->fd);
ret = conn->vfs_ops.close(fsp,fsp->fd);
fsp->fd = -1;
return ret;
}
@ -259,7 +259,7 @@ int fd_close_posix(struct connection_struct *conn, files_struct *fsp)
DEBUG(10,("fd_close_posix: doing close on %u fd's.\n", (unsigned int)count ));
for(i = 0; i < count; i++) {
if (conn->vfs_ops.close(fd_array[i]) == -1) {
if (conn->vfs_ops.close(fsp,fd_array[i]) == -1) {
saved_errno = errno;
}
}
@ -279,7 +279,7 @@ int fd_close_posix(struct connection_struct *conn, files_struct *fsp)
* Finally close the fd associated with this fsp.
*/
ret = conn->vfs_ops.close(fsp->fd);
ret = conn->vfs_ops.close(fsp,fsp->fd);
if (saved_errno != 0) {
errno = saved_errno;
@ -688,7 +688,7 @@ static BOOL posix_fcntl_lock(files_struct *fsp, int op, SMB_OFF_T offset, SMB_OF
DEBUG(8,("posix_fcntl_lock %d %d %.0f %.0f %d\n",fsp->fd,op,(double)offset,(double)count,type));
ret = conn->vfs_ops.lock(fsp->fd,op,offset,count,type);
ret = conn->vfs_ops.lock(fsp,fsp->fd,op,offset,count,type);
if (!ret && (errno == EFBIG)) {
if( DEBUGLVL( 0 )) {
@ -699,7 +699,7 @@ static BOOL posix_fcntl_lock(files_struct *fsp, int op, SMB_OFF_T offset, SMB_OF
/* 32 bit NFS file system, retry with smaller offset */
errno = 0;
count &= 0x7fffffff;
ret = conn->vfs_ops.lock(fsp->fd,op,offset,count,type);
ret = conn->vfs_ops.lock(fsp,fsp->fd,op,offset,count,type);
}
/* A lock query - just return. */
@ -727,7 +727,7 @@ static BOOL posix_fcntl_lock(files_struct *fsp, int op, SMB_OFF_T offset, SMB_OF
count = (orig_count & 0x7FFFFFFF);
offset = (SMB_OFF_T)map_lock_offset(off_high, off_low);
ret = conn->vfs_ops.lock(fsp->fd,op,offset,count,type);
ret = conn->vfs_ops.lock(fsp,fsp->fd,op,offset,count,type);
if (!ret) {
if (errno == EINVAL) {
DEBUG(3,("posix_fcntl_lock: locking not supported? returning True\n"));

8
source3/printing/printfsp.c
View File

@ -50,10 +50,6 @@ files_struct *print_fsp_open(connection_struct *conn,char *jobname)
/* setup a full fsp */
fsp->print_jobid = jobid;
fsp->fd = print_job_fd(jobid);
conn->vfs_ops.fstat(fsp->fd, &sbuf);
fsp->mode = sbuf.st_mode;
fsp->inode = sbuf.st_ino;
fsp->dev = sbuf.st_dev;
GetTimeOfDay(&fsp->open_time);
fsp->vuid = current_user.vuid;
fsp->size = 0;
@ -73,6 +69,10 @@ files_struct *print_fsp_open(connection_struct *conn,char *jobname)
string_set(&fsp->fsp_name,print_job_fname(jobid));
fsp->wbmpx_ptr = NULL;
fsp->wcp = NULL;
conn->vfs_ops.fstat(fsp,fsp->fd, &sbuf);
fsp->mode = sbuf.st_mode;
fsp->inode = sbuf.st_ino;
fsp->dev = sbuf.st_dev;
conn->num_files_open++;

2
source3/smbd/close.c
View File

@ -146,7 +146,7 @@ static int close_normal_file(files_struct *fsp, BOOL normal_close)
if (normal_close && delete_on_close) {
DEBUG(5,("close_file: file %s. Delete on close was set - deleting file.\n",
fsp->fsp_name));
if(fsp->conn->vfs_ops.unlink(dos_to_unix(fsp->fsp_name, False)) != 0) {
if(fsp->conn->vfs_ops.unlink(conn,dos_to_unix(fsp->fsp_name, False)) != 0) {
/*
* This call can potentially fail as another smbd may have
* had the file open with delete on close set and deleted

14
source3/smbd/conn.c
View File

@ -170,19 +170,11 @@ void conn_free(connection_struct *conn)
/* Free vfs_connection_struct */
#ifdef HAVE_LIBDL
if (conn->vfs_conn != NULL) {
if (conn->dl_handle != NULL) {
/* Close dlopen() handle */
if (conn->vfs_conn->dl_handle) {
dlclose(conn->vfs_conn->dl_handle);
}
#endif /* HAVE_LIBDL */
if (conn->vfs_conn->groups != NULL) {
free(conn->vfs_conn->groups);
}
delete_nt_token(&conn->vfs_conn->nt_user_token);
free(conn->vfs_conn);
dlclose(conn->dl_handle);
}
#endif /* HAVE_LIBDL */
DLIST_REMOVE(Connections, conn);

8
source3/smbd/dir.c
View File

@ -627,7 +627,7 @@ BOOL get_dir_entry(connection_struct *conn,char *mask,int dirtype,char *fname,
pstrcpy(pathreal,path);
pstrcat(path,fname);
pstrcat(pathreal,dname);
if (conn->vfs_ops.stat(dos_to_unix(pathreal, False), &sbuf) != 0)
if (conn->vfs_ops.stat(conn,dos_to_unix(pathreal, False), &sbuf) != 0)
{
DEBUG(5,("Couldn't stat 1 [%s]. Error = %s\n",path, strerror(errno) ));
continue;
@ -673,13 +673,13 @@ void *OpenDir(connection_struct *conn, char *name, BOOL use_veto)
{
Dir *dirp;
char *n;
DIR *p = conn->vfs_ops.opendir(dos_to_unix(name,False));
DIR *p = conn->vfs_ops.opendir(conn,dos_to_unix(name,False));
int used=0;
if (!p) return(NULL);
dirp = (Dir *)malloc(sizeof(Dir));
if (!dirp) {
conn->vfs_ops.closedir(p);
conn->vfs_ops.closedir(conn,p);
return(NULL);
}
dirp->pos = dirp->numentries = dirp->mallocsize = 0;
@ -714,7 +714,7 @@ void *OpenDir(connection_struct *conn, char *name, BOOL use_veto)
dirp->numentries++;
}
conn->vfs_ops.closedir(p);
conn->vfs_ops.closedir(conn,p);
return((void *)dirp);
}

4
source3/smbd/dosmode.c
View File

@ -243,7 +243,7 @@ int file_utime(connection_struct *conn, char *fname, struct utimbuf *times)
errno = 0;
if(conn->vfs_ops.utime(dos_to_unix(fname, False), times) == 0)
if(conn->vfs_ops.utime(conn,dos_to_unix(fname, False), times) == 0)
return 0;
if((errno != EPERM) && (errno != EACCES))
@ -271,7 +271,7 @@ int file_utime(connection_struct *conn, char *fname, struct utimbuf *times)
current_user.ngroups,current_user.groups)))) {
/* We are allowed to become root and change the filetime. */
become_root();
ret = conn->vfs_ops.utime(dos_to_unix(fname, False), times);
ret = conn->vfs_ops.utime(conn,dos_to_unix(fname, False), times);
unbecome_root();
}
}

8
source3/smbd/fileio.c
View File

@ -38,7 +38,7 @@ SMB_OFF_T seek_file(files_struct *fsp,SMB_OFF_T pos)
if (fsp->print_file && lp_postscript(fsp->conn->service))
offset = 3;
seek_ret = fsp->conn->vfs_ops.lseek(fsp->fd,pos+offset,SEEK_SET);
seek_ret = fsp->conn->vfs_ops.lseek(fsp,fsp->fd,pos+offset,SEEK_SET);
/*
* We want to maintain the fiction that we can seek
@ -117,7 +117,7 @@ ssize_t read_file(files_struct *fsp,char *data,SMB_OFF_T pos,size_t n)
}
if (n > 0) {
readret = fsp->conn->vfs_ops.read(fsp->fd,data,n);
readret = fsp->conn->vfs_ops.read(fsp,fsp->fd,data,n);
if (readret == -1)
return -1;
if (readret > 0) ret += readret;
@ -164,7 +164,7 @@ ssize_t write_file(files_struct *fsp, char *data, SMB_OFF_T pos, size_t n)
SMB_STRUCT_STAT st;
fsp->modified = True;
if (fsp->conn->vfs_ops.fstat(fsp->fd,&st) == 0) {
if (fsp->conn->vfs_ops.fstat(fsp,fsp->fd,&st) == 0) {
int dosmode = dos_mode(fsp->conn,fsp->fsp_name,&st);
if (MAP_ARCHIVE(fsp->conn) && !IS_DOS_ARCHIVE(dosmode)) {
file_chmod(fsp->conn,fsp->fsp_name,dosmode | aARCH,&st);
@ -683,7 +683,7 @@ void sync_file(connection_struct *conn, files_struct *fsp)
{
if(lp_strict_sync(SNUM(conn)) && fsp->fd != -1) {
flush_write_cache(fsp, SYNC_FLUSH);
conn->vfs_ops.fsync(fsp->fd);
conn->vfs_ops.fsync(fsp,fsp->fd);
}
}
#undef OLD_NTDOMAIN

6
source3/smbd/filename.c
View File

@ -211,7 +211,7 @@ BOOL unix_convert(char *name,connection_struct *conn,char *saved_last_component,
* stat the name - if it exists then we are all done!
*/
if (conn->vfs_ops.stat(dos_to_unix(name,False),&st) == 0) {
if (conn->vfs_ops.stat(conn,dos_to_unix(name,False),&st) == 0) {
stat_cache_add(orig_path, name);
DEBUG(5,("conversion finished %s -> %s\n",orig_path, name));
if(pst)
@ -277,7 +277,7 @@ BOOL unix_convert(char *name,connection_struct *conn,char *saved_last_component,
* Check if the name exists up to this point.
*/
if (conn->vfs_ops.stat(dos_to_unix(name,False), &st) == 0) {
if (conn->vfs_ops.stat(conn,dos_to_unix(name,False), &st) == 0) {
/*
* It exists. it must either be a directory or this must be
* the last part of the path for it to be OK.
@ -429,7 +429,7 @@ BOOL check_name(char *name,connection_struct *conn)
if (!lp_symlinks(SNUM(conn)))
{
SMB_STRUCT_STAT statbuf;
if ( (conn->vfs_ops.lstat(dos_to_unix(name,False),&statbuf) != -1) &&
if ( (conn->vfs_ops.lstat(conn,dos_to_unix(name,False),&statbuf) != -1) &&
(S_ISLNK(statbuf.st_mode)) )
{
DEBUG(3,("check_name: denied: file path name %s is a symlink\n",name));

10
source3/smbd/nttrans.c
View File

@ -892,13 +892,13 @@ int reply_ntcreate_and_X(connection_struct *conn,
}
if(fsp->is_directory) {
if(conn->vfs_ops.stat(dos_to_unix(fsp->fsp_name, False), &sbuf) != 0) {
if(conn->vfs_ops.stat(conn,dos_to_unix(fsp->fsp_name, False), &sbuf) != 0) {
close_file(fsp,True);
restore_case_semantics(file_attributes);
return(ERROR(ERRDOS,ERRnoaccess));
}
} else {
if (conn->vfs_ops.fstat(fsp->fd,&sbuf) != 0) {
if (conn->vfs_ops.fstat(fsp,fsp->fd,&sbuf) != 0) {
close_file(fsp,False);
restore_case_semantics(file_attributes);
return(ERROR(ERRDOS,ERRnoaccess));
@ -1223,7 +1223,7 @@ static int call_nt_transact_create(connection_struct *conn,
return(UNIXERROR(ERRDOS,ERRnoaccess));
}
if(conn->vfs_ops.stat(dos_to_unix(fsp->fsp_name, False),
if(conn->vfs_ops.stat(conn,dos_to_unix(fsp->fsp_name, False),
&sbuf) != 0) {
close_file(fsp,True);
restore_case_semantics(file_attributes);
@ -1293,13 +1293,13 @@ static int call_nt_transact_create(connection_struct *conn,
}
if(fsp->is_directory) {
if(conn->vfs_ops.stat(dos_to_unix(fsp->fsp_name,False), &sbuf) != 0) {
if(conn->vfs_ops.stat(conn,dos_to_unix(fsp->fsp_name,False), &sbuf) != 0) {
close_file(fsp,True);
restore_case_semantics(file_attributes);
return(ERROR(ERRDOS,ERRnoaccess));
}
} else {
if (!fsp->stat_open && conn->vfs_ops.fstat(fsp->fd,&sbuf) != 0) {
if (!fsp->stat_open && conn->vfs_ops.fstat(fsp,fsp->fd,&sbuf) != 0) {
close_file(fsp,False);
restore_case_semantics(file_attributes);
return(ERROR(ERRDOS,ERRnoaccess));

14
source3/smbd/open.c
View File

@ -41,13 +41,13 @@ static int fd_open(struct connection_struct *conn, char *fname,
flags |= O_NONBLOCK;
#endif
fd = conn->vfs_ops.open(dos_to_unix(fname,False),flags,mode);
fd = conn->vfs_ops.open(conn,dos_to_unix(fname,False),flags,mode);
/* Fix for files ending in '.' */
if((fd == -1) && (errno == ENOENT) &&
(strchr(fname,'.')==NULL)) {
pstrcat(fname,".");
fd = conn->vfs_ops.open(dos_to_unix(fname,False),flags,mode);
fd = conn->vfs_ops.open(conn,dos_to_unix(fname,False),flags,mode);
}
DEBUG(10,("fd_open: name %s, mode = %d, fd = %d. %s\n", fname, (int)mode, fd,
@ -138,7 +138,7 @@ static BOOL open_file(files_struct *fsp,connection_struct *conn,
return False;
}
if (conn->vfs_ops.fstat(fsp->fd, &sbuf) == -1) {
if (conn->vfs_ops.fstat(fsp,fsp->fd, &sbuf) == -1) {
DEBUG(0,("Error doing fstat on open file %s (%s)\n", fname,strerror(errno) ));
fd_close(conn, fsp);
return False;
@ -213,7 +213,7 @@ static int truncate_unless_locked(struct connection_struct *conn, files_struct *
unix_ERR_code = ERRlock;
return -1;
} else {
return conn->vfs_ops.ftruncate(fsp->fd,0);
return conn->vfs_ops.ftruncate(fsp,fsp->fd,0);
}
}
@ -792,7 +792,7 @@ files_struct *open_file_stat(connection_struct *conn,
if(!fsp)
return NULL;
if(conn->vfs_ops.stat(dos_to_unix(fname, False), pst) < 0) {
if(conn->vfs_ops.stat(conn,dos_to_unix(fname, False), pst) < 0) {
DEBUG(0,("open_file_stat: unable to stat name = %s. Error was %s\n",
fname, strerror(errno) ));
file_free(fsp);
@ -862,7 +862,7 @@ files_struct *open_directory(connection_struct *conn,
if(!fsp)
return NULL;
if(conn->vfs_ops.stat(dos_to_unix(fname, False), &st) == 0) {
if(conn->vfs_ops.stat(conn,dos_to_unix(fname, False), &st) == 0) {
got_stat = True;
}
@ -983,7 +983,7 @@ BOOL check_file_sharing(connection_struct *conn,char *fname, BOOL rename_op)
SMB_DEV_T dev;
SMB_INO_T inode;
if (conn->vfs_ops.stat(dos_to_unix(fname,False),&sbuf) == -1)
if (conn->vfs_ops.stat(conn,dos_to_unix(fname,False),&sbuf) == -1)
return(True);
dev = sbuf.st_dev;

456
source3/smbd/reply.c
View File

File diff suppressed because it is too large Load Diff

44
source3/smbd/service.c
View File

@ -481,46 +481,6 @@ connection_struct *make_connection(char *service,char *user,char *password, int
conn->nt_user_token = create_nt_token(conn->uid, conn->gid, conn->ngroups, conn->groups);
/*
* Now initialize the vfs layer.
*/
conn->vfs_conn = (struct vfs_connection_struct *)
malloc(sizeof(struct vfs_connection_struct));
if (conn->vfs_conn == NULL) {
DEBUG(0, ("No memory to create vfs_connection_struct"));
return NULL;
}
ZERO_STRUCTP(conn->vfs_conn);
/* Copy across relevant data from connection struct */
conn->vfs_conn->printer = conn->printer;
conn->vfs_conn->ipc = conn->ipc;
conn->vfs_conn->read_only = conn->read_only;
conn->vfs_conn->admin_user = conn->admin_user;
pstrcpy(conn->vfs_conn->dirpath, conn->dirpath);
pstrcpy(conn->vfs_conn->connectpath, conn->connectpath);
pstrcpy(conn->vfs_conn->origpath, conn->origpath);
pstrcpy(conn->vfs_conn->service, service);
pstrcpy(conn->vfs_conn->user, conn->user);
conn->vfs_conn->uid = conn->uid;
conn->vfs_conn->gid = conn->gid;
conn->vfs_conn->ngroups = conn->ngroups;
if (conn->vfs_conn->ngroups != 0) {
conn->vfs_conn->groups = (gid_t *)memdup(conn->groups,
conn->ngroups * sizeof(gid_t));
} else {
conn->vfs_conn->groups = NULL;
}
conn->vfs_conn->nt_user_token = dup_nt_token(conn->nt_user_token);
/* Initialise VFS function pointers */
if (*lp_vfsobj(SNUM(conn))) {
@ -646,7 +606,7 @@ connection_struct *make_connection(char *service,char *user,char *password, int
/* Invoke VFS make connection hook */
if (conn->vfs_ops.connect) {
if (conn->vfs_ops.connect(conn->vfs_conn, service, user) < 0)
if (conn->vfs_ops.connect(conn, service, user) < 0)
return NULL;
}
@ -671,7 +631,7 @@ void close_cnum(connection_struct *conn, uint16 vuid)
/* Call VFS disconnect hook */
conn->vfs_ops.disconnect();
conn->vfs_ops.disconnect(conn);
}

2
source3/smbd/statcache.c
View File

@ -214,7 +214,7 @@ BOOL stat_cache_lookup(connection_struct *conn, char *name, char *dirpath,
scp = (stat_cache_entry *)(hash_elem->value);
global_stat_cache_hits++;
trans_name = scp->names+scp->name_len+1;
if(conn->vfs_ops.stat(dos_to_unix(trans_name,False), pst) != 0) {
if(conn->vfs_ops.stat(conn,dos_to_unix(trans_name,False), pst) != 0) {
/* Discard this entry - it doesn't exist in the filesystem. */
hash_remove(&stat_cache, hash_elem);
return False;

28
source3/smbd/trans2.c
View File

@ -251,7 +251,7 @@ static int call_trans2open(connection_struct *conn, char *inbuf, char *outbuf,
return(UNIXERROR(ERRDOS,ERRnoaccess));
}
if (fsp->conn->vfs_ops.fstat(fsp->fd,&sbuf) != 0) {
if (fsp->conn->vfs_ops.fstat(fsp,fsp->fd,&sbuf) != 0) {
close_file(fsp,False);
return(UNIXERROR(ERRDOS,ERRnoaccess));
}
@ -407,7 +407,7 @@ static BOOL get_lanman2_dir_entry(connection_struct *conn,
if(needslash)
pstrcat(pathreal,"/");
pstrcat(pathreal,dname);
if (conn->vfs_ops.stat(dos_to_unix(pathreal,False),&sbuf) != 0)
if (conn->vfs_ops.stat(conn,dos_to_unix(pathreal,False),&sbuf) != 0)
{
/* Needed to show the msdfs symlinks as directories */
if(!lp_host_msdfs() || !lp_msdfs_root(SNUM(conn))
@ -1112,7 +1112,7 @@ static int call_trans2qfsinfo(connection_struct *conn,
DEBUG(3,("call_trans2qfsinfo: level = %d\n", info_level));
if(conn->vfs_ops.stat(".",&st)!=0) {
if(conn->vfs_ops.stat(conn,".",&st)!=0) {
DEBUG(2,("call_trans2qfsinfo: stat of . failed (%s)\n", strerror(errno)));
return (ERROR(ERRSRV,ERRinvdevice));
}
@ -1126,7 +1126,7 @@ static int call_trans2qfsinfo(connection_struct *conn,
{
SMB_BIG_UINT dfree,dsize,bsize;
data_len = 18;
conn->vfs_ops.disk_free(".",False,&bsize,&dfree,&dsize);
conn->vfs_ops.disk_free(conn,".",False,&bsize,&dfree,&dsize);
SIVAL(pdata,l1_idFileSystem,st.st_dev);
SIVAL(pdata,l1_cSectorUnit,bsize/512);
SIVAL(pdata,l1_cUnit,dsize);
@ -1208,7 +1208,7 @@ static int call_trans2qfsinfo(connection_struct *conn,
{
SMB_BIG_UINT dfree,dsize,bsize;
data_len = 24;
conn->vfs_ops.disk_free(".",False,&bsize,&dfree,&dsize);
conn->vfs_ops.disk_free(conn,".",False,&bsize,&dfree,&dsize);
SBIG_UINT(pdata,0,dsize);
SBIG_UINT(pdata,8,dfree);
SIVAL(pdata,16,bsize/512);
@ -1308,7 +1308,7 @@ static int call_trans2qfilepathinfo(connection_struct *conn,
fname = fsp->fsp_name;
unix_convert(fname,conn,0,&bad_path,&sbuf);
if (!check_name(fname,conn) ||
(!VALID_STAT(sbuf) && conn->vfs_ops.stat(dos_to_unix(fname,False),&sbuf))) {
(!VALID_STAT(sbuf) && conn->vfs_ops.stat(conn,dos_to_unix(fname,False),&sbuf))) {
DEBUG(3,("fileinfo of %s failed (%s)\n",fname,strerror(errno)));
if((errno == ENOENT) && bad_path)
{
@ -1328,11 +1328,11 @@ static int call_trans2qfilepathinfo(connection_struct *conn,
CHECK_ERROR(fsp);
fname = fsp->fsp_name;
if (fsp->conn->vfs_ops.fstat(fsp->fd,&sbuf) != 0) {
if (fsp->conn->vfs_ops.fstat(fsp,fsp->fd,&sbuf) != 0) {
DEBUG(3,("fstat of fnum %d failed (%s)\n",fsp->fnum, strerror(errno)));
return(UNIXERROR(ERRDOS,ERRbadfid));
}
if((pos = fsp->conn->vfs_ops.lseek(fsp->fd,0,SEEK_CUR)) == -1)
if((pos = fsp->conn->vfs_ops.lseek(fsp,fsp->fd,0,SEEK_CUR)) == -1)
return(UNIXERROR(ERRDOS,ERRnoaccess));
delete_pending = fsp->delete_on_close;
@ -1350,7 +1350,7 @@ static int call_trans2qfilepathinfo(connection_struct *conn,
unix_convert(fname,conn,0,&bad_path,&sbuf);
if (!check_name(fname,conn) ||
(!VALID_STAT(sbuf) && conn->vfs_ops.stat(dos_to_unix(fname,False),&sbuf))) {
(!VALID_STAT(sbuf) && conn->vfs_ops.stat(conn,dos_to_unix(fname,False),&sbuf))) {
DEBUG(3,("fileinfo of %s failed (%s)\n",fname,strerror(errno)));
if((errno == ENOENT) && bad_path)
{
@ -1590,7 +1590,7 @@ static int call_trans2setfilepathinfo(connection_struct *conn,
fname = fsp->fsp_name;
unix_convert(fname,conn,0,&bad_path,&st);
if (!check_name(fname,conn) ||
(!VALID_STAT(st) && conn->vfs_ops.stat(dos_to_unix(fname,False),&st))) {
(!VALID_STAT(st) && conn->vfs_ops.stat(conn,dos_to_unix(fname,False),&st))) {
DEBUG(3,("fileinfo of %s failed (%s)\n",fname,strerror(errno)));
if((errno == ENOENT) && bad_path)
{
@ -1609,7 +1609,7 @@ static int call_trans2setfilepathinfo(connection_struct *conn,
fname = fsp->fsp_name;
fd = fsp->fd;
if (fsp->conn->vfs_ops.fstat(fd,&st) != 0) {
if (fsp->conn->vfs_ops.fstat(fsp,fd,&st) != 0) {
DEBUG(3,("fstat of fnum %d failed (%s)\n",fsp->fnum, strerror(errno)));
return(UNIXERROR(ERRDOS,ERRbadfid));
}
@ -1630,7 +1630,7 @@ static int call_trans2setfilepathinfo(connection_struct *conn,
return(UNIXERROR(ERRDOS,ERRbadpath));
}
if(!VALID_STAT(st) && conn->vfs_ops.stat(dos_to_unix(fname,False),&st)!=0) {
if(!VALID_STAT(st) && conn->vfs_ops.stat(conn,dos_to_unix(fname,False),&st)!=0) {
DEBUG(3,("stat of %s failed (%s)\n", fname, strerror(errno)));
if((errno == ENOENT) && bad_path)
{
@ -1974,11 +1974,11 @@ dev = %x, inode = %.0f\n", iterate_fsp->fnum, (unsigned int)dev, (double)inode))
fname, (double)size ));
if (fd == -1) {
fd = conn->vfs_ops.open(dos_to_unix(fname,False),O_RDWR,0);
fd = conn->vfs_ops.open(conn,dos_to_unix(fname,False),O_RDWR,0);
if (fd == -1)
return(UNIXERROR(ERRDOS,ERRbadpath));
set_filelen(fd, size); /* tpot vfs */
conn->vfs_ops.close(fd);
conn->vfs_ops.close(fsp,fd);
} else {
set_filelen(fd, size); /* tpot vfs */
}

16
source3/smbd/unix_acls.c
View File

@ -357,16 +357,16 @@ size_t get_nt_acl(files_struct *fsp, SEC_DESC **ppdesc)
*/
if ((fsp->is_directory || fsp->fd == -1) && fsp->conn->vfs_ops.get_nt_acl)
return fsp->conn->vfs_ops.get_nt_acl(dos_to_unix(fsp->fsp_name, False), ppdesc);
return fsp->conn->vfs_ops.get_nt_acl(fsp->conn,dos_to_unix(fsp->fsp_name, False), ppdesc);
else if (fsp->conn->vfs_ops.fget_nt_acl)
return fsp->conn->vfs_ops.fget_nt_acl(fsp->fd, ppdesc);
return fsp->conn->vfs_ops.fget_nt_acl(fsp,fsp->fd, ppdesc);
if(fsp->is_directory || fsp->fd == -1) {
if(vfs_stat(fsp->conn,fsp->fsp_name, &sbuf) != 0) {
return 0;
}
} else {
if(fsp->conn->vfs_ops.fstat(fsp->fd,&sbuf) != 0) {
if(fsp->conn->vfs_ops.fstat(fsp,fsp->fd,&sbuf) != 0) {
return 0;
}
}
@ -467,9 +467,9 @@ BOOL set_nt_acl(files_struct *fsp, uint32 security_info_sent, SEC_DESC *psd)
*/
if ((fsp->is_directory || fsp->fd == -1) && fsp->conn->vfs_ops.set_nt_acl)
return fsp->conn->vfs_ops.set_nt_acl(dos_to_unix(fsp->fsp_name, False), security_info_sent, psd);
return fsp->conn->vfs_ops.set_nt_acl(conn,dos_to_unix(fsp->fsp_name, False), security_info_sent, psd);
else if (fsp->conn->vfs_ops.fset_nt_acl)
return fsp->conn->vfs_ops.fset_nt_acl(fsp->fd, security_info_sent, psd);
return fsp->conn->vfs_ops.fset_nt_acl(fsp,fsp->fd, security_info_sent, psd);
/*
* Get the current state of the file.
@ -479,7 +479,7 @@ BOOL set_nt_acl(files_struct *fsp, uint32 security_info_sent, SEC_DESC *psd)
if(vfs_stat(fsp->conn,fsp->fsp_name, &sbuf) != 0)
return False;
} else {
if(conn->vfs_ops.fstat(fsp->fd,&sbuf) != 0)
if(conn->vfs_ops.fstat(fsp,fsp->fd,&sbuf) != 0)
return False;
}
@ -524,7 +524,7 @@ BOOL set_nt_acl(files_struct *fsp, uint32 security_info_sent, SEC_DESC *psd)
if(fsp->fd == -1)
ret = vfs_stat(fsp->conn, fsp->fsp_name, &sbuf);
else
ret = conn->vfs_ops.fstat(fsp->fd,&sbuf);
ret = conn->vfs_ops.fstat(fsp,fsp->fd,&sbuf);
if(ret != 0)
return False;
@ -570,7 +570,7 @@ BOOL set_nt_acl(files_struct *fsp, uint32 security_info_sent, SEC_DESC *psd)
DEBUG(3,("call_nt_transact_set_security_desc: chmod %s. perms = 0%o.\n",
fsp->fsp_name, (unsigned int)perms ));
if(conn->vfs_ops.chmod(dos_to_unix(fsp->fsp_name, False), perms) == -1) {
if(conn->vfs_ops.chmod(conn,dos_to_unix(fsp->fsp_name, False), perms) == -1) {
DEBUG(3,("call_nt_transact_set_security_desc: chmod %s, 0%o failed. Error = %s.\n",
fsp->fsp_name, (unsigned int)perms, strerror(errno) ));
return False;

52
source3/smbd/vfs-wrap.c
View File

@ -29,8 +29,7 @@
is sure to try and execute them. These stubs are used to prevent
this possibility. */
int vfswrap_dummy_connect(struct vfs_connection_struct *conn, char *service,
char *user)
int vfswrap_dummy_connect(connection_struct *conn, char *service, char *user)
{
return 0; /* Return >= 0 for success */
}
@ -41,7 +40,7 @@ void vfswrap_dummy_disconnect(void)
/* Disk operations */
SMB_BIG_UINT vfswrap_disk_free(char *path, BOOL small_query, SMB_BIG_UINT *bsize,
SMB_BIG_UINT vfswrap_disk_free(connection_struct *conn, char *path, BOOL small_query, SMB_BIG_UINT *bsize,
SMB_BIG_UINT *dfree, SMB_BIG_UINT *dsize)
{
SMB_BIG_UINT result;
@ -60,7 +59,7 @@ SMB_BIG_UINT vfswrap_disk_free(char *path, BOOL small_query, SMB_BIG_UINT *bsize
/* Directory operations */
DIR *vfswrap_opendir(char *fname)
DIR *vfswrap_opendir(connection_struct *conn, char *fname)
{
DIR *result;
@ -74,7 +73,7 @@ DIR *vfswrap_opendir(char *fname)
return result;
}
struct dirent *vfswrap_readdir(DIR *dirp)
struct dirent *vfswrap_readdir(connection_struct *conn, DIR *dirp)
{
struct dirent *result;
@ -88,7 +87,7 @@ struct dirent *vfswrap_readdir(DIR *dirp)
return result;
}
int vfswrap_mkdir(char *path, mode_t mode)
int vfswrap_mkdir(connection_struct *conn, char *path, mode_t mode)
{
int result;
@ -102,7 +101,7 @@ int vfswrap_mkdir(char *path, mode_t mode)
return result;
}
int vfswrap_rmdir(char *path)
int vfswrap_rmdir(connection_struct *conn, char *path)
{
int result;
@ -116,7 +115,7 @@ int vfswrap_rmdir(char *path)
return result;
}
int vfswrap_closedir(DIR *dirp)
int vfswrap_closedir(connection_struct *conn, DIR *dirp)
{
int result;
@ -132,7 +131,7 @@ int vfswrap_closedir(DIR *dirp)
/* File operations */
int vfswrap_open(char *fname, int flags, mode_t mode)
int vfswrap_open(connection_struct *conn, char *fname, int flags, mode_t mode)
{
int result;
@ -146,7 +145,7 @@ int vfswrap_open(char *fname, int flags, mode_t mode)
return result;
}
int vfswrap_close(int fd)
int vfswrap_close(files_struct *fsp, int fd)
{
int result;
@ -154,7 +153,7 @@ int vfswrap_close(int fd)
return result;
}
ssize_t vfswrap_read(int fd, char *data, size_t n)
ssize_t vfswrap_read(files_struct *fsp, int fd, char *data, size_t n)
{
ssize_t result;
@ -168,7 +167,7 @@ ssize_t vfswrap_read(int fd, char *data, size_t n)
return result;
}
ssize_t vfswrap_write(int fd, char *data, size_t n)
ssize_t vfswrap_write(files_struct *fsp, int fd, char *data, size_t n)
{
ssize_t result;
@ -182,7 +181,7 @@ ssize_t vfswrap_write(int fd, char *data, size_t n)
return result;
}
SMB_OFF_T vfswrap_lseek(int filedes, SMB_OFF_T offset, int whence)
SMB_OFF_T vfswrap_lseek(files_struct *fsp, int filedes, SMB_OFF_T offset, int whence)
{
SMB_OFF_T result;
@ -190,7 +189,7 @@ SMB_OFF_T vfswrap_lseek(int filedes, SMB_OFF_T offset, int whence)
return result;
}
int vfswrap_rename(char *old, char *new)
int vfswrap_rename(connection_struct *conn, char *old, char *new)
{
int result;
@ -204,7 +203,7 @@ int vfswrap_rename(char *old, char *new)
return result;
}
int vfswrap_fsync(int fd)
int vfswrap_fsync(files_struct *fsp, int fd)
{
#ifdef HAVE_FSYNC
return fsync(fd);
@ -213,7 +212,7 @@ int vfswrap_fsync(int fd)
#endif
}
int vfswrap_stat(char *fname, SMB_STRUCT_STAT *sbuf)
int vfswrap_stat(connection_struct *conn, char *fname, SMB_STRUCT_STAT *sbuf)
{
int result;
@ -227,7 +226,7 @@ int vfswrap_stat(char *fname, SMB_STRUCT_STAT *sbuf)
return result;
}
int vfswrap_fstat(int fd, SMB_STRUCT_STAT *sbuf)
int vfswrap_fstat(files_struct *fsp, int fd, SMB_STRUCT_STAT *sbuf)
{
int result;
@ -241,8 +240,7 @@ int vfswrap_fstat(int fd, SMB_STRUCT_STAT *sbuf)
return result;
}
int vfswrap_lstat(char *path,
SMB_STRUCT_STAT *sbuf)
int vfswrap_lstat(connection_struct *conn, char *path, SMB_STRUCT_STAT *sbuf)
{
int result;
@ -256,7 +254,7 @@ int vfswrap_lstat(char *path,
return result;
}
int vfswrap_unlink(char *path)
int vfswrap_unlink(connection_struct *conn, char *path)
{
int result;
@ -270,7 +268,7 @@ int vfswrap_unlink(char *path)
return result;
}
int vfswrap_chmod(char *path, mode_t mode)
int vfswrap_chmod(connection_struct *conn, char *path, mode_t mode)
{
int result;
@ -284,7 +282,7 @@ int vfswrap_chmod(char *path, mode_t mode)
return result;
}
int vfswrap_chown(char *path, uid_t uid, gid_t gid)
int vfswrap_chown(connection_struct *conn, char *path, uid_t uid, gid_t gid)
{
int result;
@ -298,7 +296,7 @@ int vfswrap_chown(char *path, uid_t uid, gid_t gid)
return result;
}
int vfswrap_chdir(char *path)
int vfswrap_chdir(connection_struct *conn, char *path)
{
#ifdef VFS_CHECK_NULL
if (path == NULL) {
@ -309,7 +307,7 @@ int vfswrap_chdir(char *path)
return chdir(path);
}
char *vfswrap_getwd(char *path)
char *vfswrap_getwd(connection_struct *conn, char *path)
{
#ifdef VFS_CHECK_NULL
if (path == NULL) {
@ -320,7 +318,7 @@ char *vfswrap_getwd(char *path)
return sys_getwd(path);
}
int vfswrap_utime(char *path, struct utimbuf *times)
int vfswrap_utime(connection_struct *conn, char *path, struct utimbuf *times)
{
int result;
@ -334,7 +332,7 @@ int vfswrap_utime(char *path, struct utimbuf *times)
return result;
}
int vfswrap_ftruncate(int fd, SMB_OFF_T offset)
int vfswrap_ftruncate(files_struct *fsp, int fd, SMB_OFF_T offset)
{
int result;
@ -342,7 +340,7 @@ int vfswrap_ftruncate(int fd, SMB_OFF_T offset)
return result;
}
BOOL vfswrap_lock(int fd, int op, SMB_OFF_T offset, SMB_OFF_T count, int type)
BOOL vfswrap_lock(files_struct *fsp, int fd, int op, SMB_OFF_T offset, SMB_OFF_T count, int type)
{
return fcntl_lock(fd, op, offset, count,type);
}

62
source3/smbd/vfs.c
View File

@ -83,7 +83,7 @@ int vfs_init_default(connection_struct *conn)
{
DEBUG(3, ("Initialising default vfs hooks\n"));
memcpy(&conn->vfs_ops, &default_vfs_ops, sizeof(conn->vfs_ops));
memcpy(&conn->vfs_ops, &default_vfs_ops, sizeof(struct vfs_ops));
return True;
}
@ -94,7 +94,6 @@ int vfs_init_default(connection_struct *conn)
#ifdef HAVE_LIBDL
BOOL vfs_init_custom(connection_struct *conn)
{
void *handle;
struct vfs_ops *ops, *(*fptr)(struct vfs_options *options);
DEBUG(3, ("Initialising custom vfs hooks from %s\n",
@ -102,19 +101,15 @@ BOOL vfs_init_custom(connection_struct *conn)
/* Open object file */
handle = dlopen(lp_vfsobj(SNUM(conn)), RTLD_NOW | RTLD_GLOBAL);
conn->vfs_conn->dl_handle = handle;
if (!handle) {
DEBUG(0, ("Error opening %s: %s\n", lp_vfsobj(SNUM(conn)),
dlerror()));
return False;
if ((conn->dl_handle = dlopen(lp_vfsobj(SNUM(conn)), RTLD_NOW | RTLD_GLOBAL)) == NULL) {
DEBUG(0, ("Error opening %s: %s\n", lp_vfsobj(SNUM(conn)), dlerror()));
return False;
}
/* Get handle on vfs_init() symbol */
fptr = (struct vfs_ops *(*)(struct vfs_options *))
dlsym(handle, "vfs_init");
dlsym(conn->dl_handle, "vfs_init");
if (fptr == NULL) {
DEBUG(0, ("No vfs_init() symbol found in %s\n",
@ -133,7 +128,7 @@ BOOL vfs_init_custom(connection_struct *conn)
There's probably a neater way to do this then a whole bunch of
if statements. */
memcpy(&conn->vfs_ops, ops, sizeof(conn->vfs_ops));
memcpy(&conn->vfs_ops, ops, sizeof(struct vfs_ops));
if (conn->vfs_ops.connect == NULL) {
conn->vfs_ops.connect = default_vfs_ops.connect;
@ -265,16 +260,16 @@ BOOL vfs_init_custom(connection_struct *conn)
int vfs_stat(connection_struct *conn, char *fname, SMB_STRUCT_STAT *st)
{
return(conn->vfs_ops.stat(dos_to_unix(fname,False),st));
return(conn->vfs_ops.stat(conn, dos_to_unix(fname,False),st));
}
/*******************************************************************
vfs fstat wrapper that calls dos_to_unix.
********************************************************************/
int vfs_fstat(connection_struct *conn, int fd, SMB_STRUCT_STAT *st)
int vfs_fstat(files_struct *fsp, int fd, SMB_STRUCT_STAT *st)
{
return(conn->vfs_ops.fstat(fd,st));
return(fsp->conn->vfs_ops.fstat(fsp,fd,st));
}
/*******************************************************************
@ -310,7 +305,7 @@ int vfs_mkdir(connection_struct *conn, char *fname, mode_t mode)
SMB_STRUCT_STAT sbuf;
pstrcpy(name,dos_to_unix(fname,False)); /* paranoia copy */
if(!(ret=conn->vfs_ops.mkdir(name,mode))) {
if(!(ret=conn->vfs_ops.mkdir(conn,name,mode))) {
/*
* Check if high bits should have been set,
* then (if bits are missing): add them.
@ -323,13 +318,22 @@ int vfs_mkdir(connection_struct *conn, char *fname, mode_t mode)
return ret;
}
/*******************************************************************
vfs rmdir wrapper that calls dos_to_unix.
********************************************************************/
int vfs_rmdir(connection_struct *conn, char *fname)
{
return(conn->vfs_ops.rmdir(conn,dos_to_unix(fname,False)));
}
/*******************************************************************
vfs Unlink wrapper that calls dos_to_unix.
********************************************************************/
int vfs_unlink(connection_struct *conn, char *fname)
{
return(conn->vfs_ops.unlink(dos_to_unix(fname,False)));
return(conn->vfs_ops.unlink(conn,dos_to_unix(fname,False)));
}
/*******************************************************************
@ -338,7 +342,7 @@ int vfs_unlink(connection_struct *conn, char *fname)
int vfs_chmod(connection_struct *conn, char *fname,mode_t mode)
{
return(conn->vfs_ops.chmod(dos_to_unix(fname,False), mode));
return(conn->vfs_ops.chmod(conn,dos_to_unix(fname,False), mode));
}
/*******************************************************************
@ -347,7 +351,7 @@ int vfs_chmod(connection_struct *conn, char *fname,mode_t mode)
int vfs_chown(connection_struct *conn, char *fname, uid_t uid, gid_t gid)
{
return(conn->vfs_ops.chown(dos_to_unix(fname,False), uid, gid));
return(conn->vfs_ops.chown(conn,dos_to_unix(fname,False), uid, gid));
}
/*******************************************************************
@ -356,7 +360,7 @@ int vfs_chown(connection_struct *conn, char *fname, uid_t uid, gid_t gid)
int vfs_chdir(connection_struct *conn, char *fname)
{
return(conn->vfs_ops.chdir(dos_to_unix(fname,False)));
return(conn->vfs_ops.chdir(conn,dos_to_unix(fname,False)));
}
/*******************************************************************
@ -366,7 +370,7 @@ int vfs_chdir(connection_struct *conn, char *fname)
char *vfs_getwd(connection_struct *conn, char *unix_path)
{
char *wd;
wd = conn->vfs_ops.getwd(unix_path);
wd = conn->vfs_ops.getwd(conn,unix_path);
if (wd)
unix_to_dos(wd, True);
return wd;
@ -400,7 +404,7 @@ ssize_t vfs_write_data(files_struct *fsp,char *buffer,size_t N)
while (total < N)
{
ret = fsp->conn->vfs_ops.write(fsp->fd,buffer + total,N - total);
ret = fsp->conn->vfs_ops.write(fsp,fsp->fd,buffer + total,N - total);
if (ret == -1) return -1;
if (ret == 0) return total;
@ -477,16 +481,14 @@ SMB_OFF_T vfs_transfer_file(int in_fd, files_struct *in_fsp,
if (s > ret) {
ret += in_fsp ?
in_fsp->conn->vfs_ops.read(in_fsp->fd,buf1+ret,s-ret) : read(in_fd,buf1+ret,s-ret);
in_fsp->conn->vfs_ops.read(in_fsp,in_fsp->fd,buf1+ret,s-ret) : read(in_fd,buf1+ret,s-ret);
}
if (ret > 0)
{
if (out_fsp) {
ret2 = out_fsp->conn->vfs_ops.write(out_fsp->fd,buf1,ret);
} else {
ret2= (out_fd != -1) ? write_data(out_fd,buf1,ret) : ret;
}
if (ret > 0) {
if (out_fsp)
ret2 = out_fsp->conn->vfs_ops.write(out_fsp,out_fsp->fd,buf1,ret);
else
ret2= (out_fd != -1) ? write_data(out_fd,buf1,ret) : ret;
}
if (ret2 > 0) total += ret2;
@ -513,7 +515,7 @@ char *vfs_readdirname(connection_struct *conn, void *p)
if (!p)
return(NULL);
ptr = (struct dirent *)conn->vfs_ops.readdir(p);
ptr = (struct dirent *)conn->vfs_ops.readdir(conn,p);
if (!ptr)
return(NULL);