Start of merge to 2_2_RELEASE branch for release.

Jeremy.

1 files changed, 171 insertions, 200 deletions

diff --git a/source/smbd/vfs-wrap.c b/source/smbd/vfs-wrap.c
index 1fa9e72fcc3..4545671de94 100644
--- a/source/smbd/vfs-wrap.c
+++ b/source/smbd/vfs-wrap.c
@@ -21,15 +21,11 @@
 
 #include "includes.h"
 
-/* Check for NULL pointer parameters in vfswrap_* functions */
-
-#define VFS_CHECK_NULL
-
 /* We don't want to have NULL function pointers lying around.  Someone
    is sure to try and execute them.  These stubs are used to prevent
    this possibility. */
 
-int vfswrap_dummy_connect(connection_struct *conn, char *service, char *user)
+int vfswrap_dummy_connect(connection_struct *conn, const char *service, const char *user)
 {
     return 0;    /* Return >= 0 for success */
 }
@@ -40,37 +36,23 @@ void vfswrap_dummy_disconnect(connection_struct *conn)
 
 /* Disk operations */
 
-SMB_BIG_UINT vfswrap_disk_free(connection_struct *conn, char *path, BOOL small_query, SMB_BIG_UINT *bsize, 
+SMB_BIG_UINT vfswrap_disk_free(connection_struct *conn, const char *path, BOOL small_query, SMB_BIG_UINT *bsize, 
 			       SMB_BIG_UINT *dfree, SMB_BIG_UINT *dsize)
 {
     SMB_BIG_UINT result;
 
-#ifdef VFS_CHECK_NULL
-    if ((path == NULL) || (bsize == NULL) || (dfree == NULL) ||
-	(dsize == NULL)) {
-	
-	smb_panic("NULL pointer passed to vfswrap_disk_free() function\n");
-    }
-#endif
-
     result = sys_disk_free(path, small_query, bsize, dfree, dsize);
     return result;
 }
     
 /* Directory operations */
 
-DIR *vfswrap_opendir(connection_struct *conn, char *fname)
+DIR *vfswrap_opendir(connection_struct *conn, const char *fname)
 {
     DIR *result;
 
     START_PROFILE(syscall_opendir);
 
-#ifdef VFS_CHECK_NULL
-    if (fname == NULL) {
-	smb_panic("NULL pointer passed to vfswrap_opendir()\n");
-    }
-#endif
-
     result = opendir(fname);
     END_PROFILE(syscall_opendir);
     return result;
@@ -82,32 +64,24 @@ struct dirent *vfswrap_readdir(connection_struct *conn, DIR *dirp)
 
     START_PROFILE(syscall_readdir);
 
-#ifdef VFS_CHECK_NULL
-    if (dirp == NULL) {
-	smb_panic("NULL pointer passed to vfswrap_readdir()\n");
-    }
-#endif
-
     result = readdir(dirp);
     END_PROFILE(syscall_readdir);
     return result;
 }
 
-int vfswrap_mkdir(connection_struct *conn, char *path, mode_t mode)
+int vfswrap_mkdir(connection_struct *conn, const char *path, mode_t mode)
 {
-    int result;
+	int result;
+	BOOL has_dacl = False;
 
-    START_PROFILE(syscall_mkdir);
+	START_PROFILE(syscall_mkdir);
 
-#ifdef VFS_CHECK_NULL
-    if (path == NULL) {
-	smb_panic("NULL pointer passed to vfswrap_mkdir()\n");
-    }
-#endif
+	if (lp_inherit_acls(SNUM(conn)) && (has_dacl = directory_has_default_acl(conn, parent_dirname(path))))
+		mode = 0777;
 
-    result = mkdir(path, mode);
+	result = mkdir(path, mode);
 
-	if (result == 0) {
+	if (result == 0 && !has_dacl) {
 		/*
 		 * We need to do this as the default behavior of POSIX ACLs	
 		 * is to set the mask to be the requested group permission
@@ -122,22 +96,16 @@ int vfswrap_mkdir(connection_struct *conn, char *path, mode_t mode)
 		}
 	}
 
-    END_PROFILE(syscall_mkdir);
-    return result;
+	END_PROFILE(syscall_mkdir);
+	return result;
 }
 
-int vfswrap_rmdir(connection_struct *conn, char *path)
+int vfswrap_rmdir(connection_struct *conn, const char *path)
 {
     int result;
 
     START_PROFILE(syscall_rmdir);
 
-#ifdef VFS_CHECK_NULL
-    if (path == NULL) {
-	smb_panic("NULL pointer passed to vfswrap_rmdir()\n");
-    }
-#endif
-
     result = rmdir(path);
     END_PROFILE(syscall_rmdir);
     return result;
@@ -149,12 +117,6 @@ int vfswrap_closedir(connection_struct *conn, DIR *dirp)
 
     START_PROFILE(syscall_closedir);
 
-#ifdef VFS_CHECK_NULL
-    if (dirp == NULL) {
-	smb_panic("NULL pointer passed to vfswrap_closedir()\n");
-    }
-#endif
-
     result = closedir(dirp);
     END_PROFILE(syscall_closedir);
     return result;
@@ -162,21 +124,15 @@ int vfswrap_closedir(connection_struct *conn, DIR *dirp)
 
 /* File operations */
     
-int vfswrap_open(connection_struct *conn, char *fname, int flags, mode_t mode)
+int vfswrap_open(connection_struct *conn, const char *fname, int flags, mode_t mode)
 {
-    int result;
-
-    START_PROFILE(syscall_open);
+	int result;
 
-#ifdef VFS_CHECK_NULL
-    if (fname == NULL) {
-	smb_panic("NULL pointer passed to vfswrap_open()\n");
-    }
-#endif
+	START_PROFILE(syscall_open);
 
-    result = sys_open(fname, flags, mode);
-    END_PROFILE(syscall_open);
-    return result;
+	result = sys_open(fname, flags, mode);
+	END_PROFILE(syscall_open);
+	return result;
 }
 
 int vfswrap_close(files_struct *fsp, int fd)
@@ -196,13 +152,7 @@ ssize_t vfswrap_read(files_struct *fsp, int fd, void *data, size_t n)
 
     START_PROFILE_BYTES(syscall_read, n);
 
-#ifdef VFS_CHECK_NULL
-    if (data == NULL) {
-	smb_panic("NULL pointer passed to vfswrap_read()\n");
-    }
-#endif
-
-    result = read(fd, data, n);
+    result = sys_read(fd, data, n);
     END_PROFILE(syscall_read);
     return result;
 }
@@ -213,26 +163,35 @@ ssize_t vfswrap_write(files_struct *fsp, int fd, const void *data, size_t n)
 
     START_PROFILE_BYTES(syscall_write, n);
 
-#ifdef VFS_CHECK_NULL
-    if (data == NULL) {
-	smb_panic("NULL pointer passed to vfswrap_write()\n");
-    }
-#endif
-
-    result = write(fd, data, n);
+    result = sys_write(fd, data, n);
     END_PROFILE(syscall_write);
     return result;
 }
 
 SMB_OFF_T vfswrap_lseek(files_struct *fsp, int filedes, SMB_OFF_T offset, int whence)
 {
-    SMB_OFF_T result;
+	SMB_OFF_T result = 0;
 
-    START_PROFILE(syscall_lseek);
+	START_PROFILE(syscall_lseek);
 
-    result = sys_lseek(filedes, offset, whence);
-    END_PROFILE(syscall_lseek);
-    return result;
+	/* Cope with 'stat' file opens. */
+	if (filedes != -1)
+		result = sys_lseek(filedes, offset, whence);
+
+	/*
+	 * We want to maintain the fiction that we can seek
+	 * on a fifo for file system purposes. This allows
+	 * people to set up UNIX fifo's that feed data to Windows
+	 * applications. JRA.
+	 */
+
+	if((result == -1) && (errno == ESPIPE)) {
+		result = 0;
+		errno = 0;
+	}
+
+	END_PROFILE(syscall_lseek);
+	return result;
 }
 
 /*********************************************************
@@ -240,7 +199,7 @@ SMB_OFF_T vfswrap_lseek(files_struct *fsp, int filedes, SMB_OFF_T offset, int wh
  <warrenb@hpcvscdp.cv.hp.com>
 **********************************************************/
 
-static int copy_reg(char *source, const char *dest)
+static int copy_reg(const char *source, const char *dest)
 {
 	SMB_STRUCT_STAT source_stats;
 	int ifd;
@@ -314,18 +273,11 @@ static int copy_reg(char *source, const char *dest)
 	return 0;
 }
 
-int vfswrap_rename(connection_struct *conn, char *oldname, char *newname)
+int vfswrap_rename(connection_struct *conn, const char *oldname, const char *newname)
 {
 	int result;
 
 	START_PROFILE(syscall_rename);
-
-#ifdef VFS_CHECK_NULL
-	if ((oldname == NULL) || (newname == NULL)) {
-		smb_panic("NULL pointer passed to vfswrap_rename()\n");
-	}
-#endif
-
 	result = rename(oldname, newname);
 	if (errno == EXDEV) {
 		/* Rename across filesystems needed. */
@@ -341,7 +293,6 @@ int vfswrap_fsync(files_struct *fsp, int fd)
     int result;
 
     START_PROFILE(syscall_fsync);
-
     result = fsync(fd);
     END_PROFILE(syscall_fsync);
     return result;
@@ -350,18 +301,11 @@ int vfswrap_fsync(files_struct *fsp, int fd)
 #endif
 }
 
-int vfswrap_stat(connection_struct *conn, char *fname, SMB_STRUCT_STAT *sbuf)
+int vfswrap_stat(connection_struct *conn, const char *fname, SMB_STRUCT_STAT *sbuf)
 {
     int result;
 
     START_PROFILE(syscall_stat);
-
-#ifdef VFS_CHECK_NULL
-    if ((fname == NULL) || (sbuf == NULL)) {
-	smb_panic("NULL pointer passed to vfswrap_stat()\n");
-    }
-#endif
-
     result = sys_stat(fname, sbuf);
     END_PROFILE(syscall_stat);
     return result;
@@ -372,64 +316,37 @@ int vfswrap_fstat(files_struct *fsp, int fd, SMB_STRUCT_STAT *sbuf)
     int result;
 
     START_PROFILE(syscall_fstat);
-
-#ifdef VFS_CHECK_NULL
-    if (sbuf == NULL) {
-	smb_panic("NULL pointer passed to vfswrap_fstat()\n");
-    }
-#endif
-
     result = sys_fstat(fd, sbuf);
     END_PROFILE(syscall_fstat);
     return result;
 }
 
-int vfswrap_lstat(connection_struct *conn, char *path, SMB_STRUCT_STAT *sbuf)
+int vfswrap_lstat(connection_struct *conn, const char *path, SMB_STRUCT_STAT *sbuf)
 {
     int result;
 
     START_PROFILE(syscall_lstat);
-
-#ifdef VFS_CHECK_NULL
-    if ((path == NULL) || (sbuf == NULL)) {
-	smb_panic("NULL pointer passed to vfswrap_lstat()\n");
-    }
-#endif
-
     result = sys_lstat(path, sbuf);
     END_PROFILE(syscall_lstat);
     return result;
 }
 
-int vfswrap_unlink(connection_struct *conn, char *path)
+int vfswrap_unlink(connection_struct *conn, const char *path)
 {
     int result;
 
     START_PROFILE(syscall_unlink);
-
-#ifdef VFS_CHECK_NULL
-    if (path == NULL) {
-	smb_panic("NULL pointer passed to vfswrap_unlink()\n");
-    }
-#endif
-
     result = unlink(path);
     END_PROFILE(syscall_unlink);
     return result;
 }
 
-int vfswrap_chmod(connection_struct *conn, char *path, mode_t mode)
+int vfswrap_chmod(connection_struct *conn, const char *path, mode_t mode)
 {
     int result;
 
     START_PROFILE(syscall_chmod);
 
-#ifdef VFS_CHECK_NULL
-    if (path == NULL) {
-	smb_panic("NULL pointer passed to vfswrap_chmod()\n");
-    }
-#endif
-
 	/*
 	 * We need to do this due to the fact that the default POSIX ACL
 	 * chmod modifies the ACL *mask* for the group owner, not the
@@ -454,10 +371,10 @@ int vfswrap_chmod(connection_struct *conn, char *path, mode_t mode)
 
 int vfswrap_fchmod(files_struct *fsp, int fd, mode_t mode)
 {
-    int result;
+	int result;
 	struct vfs_ops *vfs_ops = &fsp->conn->vfs_ops;
 	
-    START_PROFILE(syscall_fchmod);
+	START_PROFILE(syscall_fchmod);
 
 	/*
 	 * We need to do this due to the fact that the default POSIX ACL
@@ -475,23 +392,16 @@ int vfswrap_fchmod(files_struct *fsp, int fd, mode_t mode)
 		errno = saved_errno;
 	}
 
-    result = fchmod(fd, mode);
-    END_PROFILE(syscall_fchmod);
-    return result;
+	result = fchmod(fd, mode);
+	END_PROFILE(syscall_fchmod);
+	return result;
 }
 
-int vfswrap_chown(connection_struct *conn, char *path, uid_t uid, gid_t gid)
+int vfswrap_chown(connection_struct *conn, const char *path, uid_t uid, gid_t gid)
 {
     int result;
 
     START_PROFILE(syscall_chown);
-
-#ifdef VFS_CHECK_NULL
-    if (path == NULL) {
-	smb_panic("NULL pointer passed to vfswrap_chown()\n");
-    }
-#endif
-
     result = sys_chown(path, uid, gid);
     END_PROFILE(syscall_chown);
     return result;
@@ -508,18 +418,11 @@ int vfswrap_fchown(files_struct *fsp, int fd, uid_t uid, gid_t gid)
     return result;
 }
 
-int vfswrap_chdir(connection_struct *conn, char *path)
+int vfswrap_chdir(connection_struct *conn, const char *path)
 {
     int result;
 
     START_PROFILE(syscall_chdir);
-
-#ifdef VFS_CHECK_NULL
-    if (path == NULL) {
-	smb_panic("NULL pointer passed to vfswrap_chdir()\n");
-    }
-#endif
-
     result = chdir(path);
     END_PROFILE(syscall_chdir);
     return result;
@@ -530,30 +433,16 @@ char *vfswrap_getwd(connection_struct *conn, char *path)
     char *result;
 
     START_PROFILE(syscall_getwd);
-
-#ifdef VFS_CHECK_NULL
-    if (path == NULL) {
-	smb_panic("NULL pointer passed to vfswrap_getwd()\n");
-    }
-#endif
-
     result = sys_getwd(path);
     END_PROFILE(syscall_getwd);
     return result;
 }
 
-int vfswrap_utime(connection_struct *conn, char *path, struct utimbuf *times)
+int vfswrap_utime(connection_struct *conn, const char *path, struct utimbuf *times)
 {
     int result;
 
     START_PROFILE(syscall_utime);
-
-#ifdef VFS_CHECK_NULL
-    if ((path == NULL) || (times == NULL)) {
-	smb_panic("NULL pointer passed to vfswrap_utime()\n");
-    }
-#endif
-
     result = utime(path, times);
     END_PROFILE(syscall_utime);
     return result;
@@ -696,7 +585,6 @@ BOOL vfswrap_lock(files_struct *fsp, int fd, int op, SMB_OFF_T offset, SMB_OFF_T
     BOOL result;
 
     START_PROFILE(syscall_fcntl_lock);
-
     result =  fcntl_lock(fd, op, offset, count,type);
     END_PROFILE(syscall_fcntl_lock);
     return result;
@@ -707,12 +595,6 @@ int vfswrap_symlink(connection_struct *conn, const char *oldpath, const char *ne
     int result;
 
     START_PROFILE(syscall_symlink);
-
-#ifdef VFS_CHECK_NULL
-    if ((oldpath == NULL) || (newpath == NULL))
-		smb_panic("NULL pointer passed to vfswrap_symlink()\n");
-#endif
-
     result = sys_symlink(oldpath, newpath);
     END_PROFILE(syscall_symlink);
     return result;
@@ -723,12 +605,6 @@ int vfswrap_readlink(connection_struct *conn, const char *path, char *buf, size_
     int result;
 
     START_PROFILE(syscall_readlink);
-
-#ifdef VFS_CHECK_NULL
-    if ((path == NULL) || (buf == NULL))
-		smb_panic("NULL pointer passed to vfswrap_readlink()\n");
-#endif
-
     result = sys_readlink(path, buf, bufsiz);
     END_PROFILE(syscall_readlink);
     return result;
@@ -739,11 +615,6 @@ int vfswrap_link(connection_struct *conn, const char *oldpath, const char *newpa
 	int result;
 
 	START_PROFILE(syscall_link);
-
-#ifdef VFS_CHECK_NULL
-	if ((oldpath == NULL) || (newpath == NULL))
-                smb_panic("NULL pointer passed to vfswrap_link()\n");
-#endif
 	result = sys_link(oldpath, newpath);
 	END_PROFILE(syscall_link);
 	return result;
@@ -754,11 +625,6 @@ int vfswrap_mknod(connection_struct *conn, const char *pathname, mode_t mode, SM
 	int result;
 
 	START_PROFILE(syscall_mknod);
-
-#ifdef VFS_CHECK_NULL
-	if (pathname == NULL)
-                smb_panic("NULL pointer passed to vfswrap_mknod()\n");
-#endif
 	result = sys_mknod(pathname, mode, dev);
 	END_PROFILE(syscall_mknod);
 	return result;
@@ -769,11 +635,6 @@ char *vfswrap_realpath(connection_struct *conn, const char *path, char *resolved
 	char *result;
 
 	START_PROFILE(syscall_realpath);
-
-#ifdef VFS_CHECK_NULL
-	if ((path == NULL) || (resolved_path == NULL))
-                smb_panic("NULL pointer passed to vfswrap_realpath()\n");
-#endif
 	result = sys_realpath(path, resolved_path);
 	END_PROFILE(syscall_realpath);
 	return result;
@@ -789,7 +650,7 @@ size_t vfswrap_fget_nt_acl(files_struct *fsp, int fd, SEC_DESC **ppdesc)
 	return result;
 }
 
-size_t vfswrap_get_nt_acl(files_struct *fsp, char *name, SEC_DESC **ppdesc)
+size_t vfswrap_get_nt_acl(files_struct *fsp, const char *name, SEC_DESC **ppdesc)
 {
 	size_t result;
 
@@ -809,7 +670,7 @@ BOOL vfswrap_fset_nt_acl(files_struct *fsp, int fd, uint32 security_info_sent, S
 	return result;
 }
 
-BOOL vfswrap_set_nt_acl(files_struct *fsp, char *name, uint32 security_info_sent, SEC_DESC *psd)
+BOOL vfswrap_set_nt_acl(files_struct *fsp, const char *name, uint32 security_info_sent, SEC_DESC *psd)
 {
 	BOOL result;
 
@@ -819,12 +680,12 @@ BOOL vfswrap_set_nt_acl(files_struct *fsp, char *name, uint32 security_info_sent
 	return result;
 }
 
-int vfswrap_chmod_acl(connection_struct *conn, char *name, mode_t mode)
+int vfswrap_chmod_acl(connection_struct *conn, const char *name, mode_t mode)
 {
 	int result;
 
 	START_PROFILE(chmod_acl);
-	result = chmod_acl(name, mode);
+	result = chmod_acl(conn, name, mode);
 	END_PROFILE(chmod_acl);
 	return result;
 }
@@ -834,7 +695,117 @@ int vfswrap_fchmod_acl(files_struct *fsp, int fd, mode_t mode)
 	int result;
 
 	START_PROFILE(fchmod_acl);
-	result = fchmod_acl(fd, mode);
+	result = fchmod_acl(fsp, fd, mode);
 	END_PROFILE(fchmod_acl);
 	return result;
 }
+
+int vfswrap_sys_acl_get_entry(struct connection_struct *conn, SMB_ACL_T theacl, int entry_id, SMB_ACL_ENTRY_T *entry_p)
+{
+	return sys_acl_get_entry(theacl, entry_id, entry_p);
+}
+
+int vfswrap_sys_acl_get_tag_type(struct connection_struct *conn, SMB_ACL_ENTRY_T entry_d, SMB_ACL_TAG_T *tag_type_p)
+{
+	return sys_acl_get_tag_type(entry_d, tag_type_p);
+}
+
+int vfswrap_sys_acl_get_permset(struct connection_struct *conn, SMB_ACL_ENTRY_T entry_d, SMB_ACL_PERMSET_T *permset_p)
+{
+	return sys_acl_get_permset(entry_d, permset_p);
+}
+
+void * vfswrap_sys_acl_get_qualifier(struct connection_struct *conn, SMB_ACL_ENTRY_T entry_d)
+{
+	return sys_acl_get_qualifier(entry_d);
+}
+
+SMB_ACL_T vfswrap_sys_acl_get_file(struct connection_struct *conn, const char *path_p, SMB_ACL_TYPE_T type)
+{
+	return sys_acl_get_file(path_p, type);
+}
+
+SMB_ACL_T vfswrap_sys_acl_get_fd(struct files_struct *fsp, int fd)
+{
+	return sys_acl_get_fd(fd);
+}
+
+int vfswrap_sys_acl_clear_perms(struct connection_struct *conn, SMB_ACL_PERMSET_T permset)
+{
+	return sys_acl_clear_perms(permset);
+}
+
+int vfswrap_sys_acl_add_perm(struct connection_struct *conn, SMB_ACL_PERMSET_T permset, SMB_ACL_PERM_T perm)
+{
+	return sys_acl_add_perm(permset, perm);
+}
+
+char * vfswrap_sys_acl_to_text(struct connection_struct *conn, SMB_ACL_T theacl, ssize_t *plen)
+{
+	return sys_acl_to_text(theacl, plen);
+}
+
+SMB_ACL_T vfswrap_sys_acl_init(struct connection_struct *conn, int count)
+{
+	return sys_acl_init(count);
+}
+
+int vfswrap_sys_acl_create_entry(struct connection_struct *conn, SMB_ACL_T *pacl, SMB_ACL_ENTRY_T *pentry)
+{
+	return sys_acl_create_entry(pacl, pentry);
+}
+
+int vfswrap_sys_acl_set_tag_type(struct connection_struct *conn, SMB_ACL_ENTRY_T entry, SMB_ACL_TAG_T tagtype)
+{
+	return sys_acl_set_tag_type(entry, tagtype);
+}
+
+int vfswrap_sys_acl_set_qualifier(struct connection_struct *conn, SMB_ACL_ENTRY_T entry, void *qual)
+{
+	return sys_acl_set_qualifier(entry, qual);
+}
+
+int vfswrap_sys_acl_set_permset(struct connection_struct *conn, SMB_ACL_ENTRY_T entry, SMB_ACL_PERMSET_T permset)
+{
+	return sys_acl_set_permset(entry, permset);
+}
+
+int vfswrap_sys_acl_valid(struct connection_struct *conn, SMB_ACL_T theacl )
+{
+	return sys_acl_valid(theacl );
+}
+
+int vfswrap_sys_acl_set_file(struct connection_struct *conn, const char *name, SMB_ACL_TYPE_T acltype, SMB_ACL_T theacl)
+{
+	return sys_acl_set_file(name, acltype, theacl);
+}
+
+int vfswrap_sys_acl_set_fd(struct files_struct *fsp, int fd, SMB_ACL_T theacl)
+{
+	return sys_acl_set_fd(fd, theacl);
+}
+
+int vfswrap_sys_acl_delete_def_file(struct connection_struct *conn, const char *path)
+{
+	return sys_acl_delete_def_file(path);
+}
+
+int vfswrap_sys_acl_get_perm(struct connection_struct *conn, SMB_ACL_PERMSET_T permset, SMB_ACL_PERM_T perm)
+{
+	return sys_acl_get_perm(permset, perm);
+}
+
+int vfswrap_sys_acl_free_text(struct connection_struct *conn, char *text)
+{
+	return sys_acl_free_text(text);
+}
+
+int vfswrap_sys_acl_free_acl(struct connection_struct *conn, SMB_ACL_T posix_acl)
+{
+	return sys_acl_free_acl(posix_acl);
+}
+
+int vfswrap_sys_acl_free_qualifier(struct connection_struct *conn, void *qualifier, SMB_ACL_TAG_T tagtype)
+{
+	return sys_acl_free_qualifier(qualifier, tagtype);
+}