Adding upstream version 2:4.17.12+dfsg.upstream/2%4.17.12+dfsgupstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 538 insertions, 0 deletions

diff --git a/source3/libsmb/libsmb_stat.c b/source3/libsmb/libsmb_stat.c
new file mode 100644
index 0000000..aa0b2db
--- /dev/null
+++ b/source3/libsmb/libsmb_stat.c
@@ -0,0 +1,538 @@
+/*
+   Unix SMB/Netbios implementation.
+   SMB client library implementation
+   Copyright (C) Andrew Tridgell 1998
+   Copyright (C) Richard Sharpe 2000, 2002
+   Copyright (C) John Terpstra 2000
+   Copyright (C) Tom Jansen (Ninja ISD) 2002
+   Copyright (C) Derrell Lipman 2003-2008
+   Copyright (C) Jeremy Allison 2007, 2008
+
+   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 3 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, see <http://www.gnu.org/licenses/>.
+*/
+
+#include "includes.h"
+#include "libsmb/libsmb.h"
+#include "libsmbclient.h"
+#include "libsmb_internal.h"
+#include "../libcli/smb/smbXcli_base.h"
+#include "lib/util/time.h"
+
+/*
+ * Generate an inode number from file name for those things that need it
+ */
+
+static ino_t generate_inode(const char *name)
+{
+	if (name == NULL) {
+		return (ino_t)-1;
+	}
+	return (ino_t)str_checksum(name);
+}
+
+/*
+ * Routine to put basic stat info into a stat structure ... Used by stat and
+ * fstat below.
+ */
+
+void setup_stat(struct stat *st,
+		const char *fname,
+		off_t size,
+		int attr,
+		ino_t ino,
+		dev_t dev,
+		struct timespec access_time_ts,
+		struct timespec change_time_ts,
+		struct timespec write_time_ts)
+{
+	st->st_mode = 0;
+
+	if (IS_DOS_DIR(attr)) {
+		st->st_mode = SMBC_DIR_MODE;
+	} else {
+		st->st_mode = SMBC_FILE_MODE;
+	}
+
+	if (IS_DOS_ARCHIVE(attr)) {
+		st->st_mode |= S_IXUSR;
+	}
+	if (IS_DOS_SYSTEM(attr)) {
+		st->st_mode |= S_IXGRP;
+	}
+	if (IS_DOS_HIDDEN(attr)) {
+		st->st_mode |= S_IXOTH;
+	}
+	if (!IS_DOS_READONLY(attr)) {
+		st->st_mode |= S_IWUSR;
+	}
+
+	st->st_size = size;
+#ifdef HAVE_STAT_ST_BLKSIZE
+	st->st_blksize = 512;
+#endif
+#ifdef HAVE_STAT_ST_BLOCKS
+	st->st_blocks = (size+511)/512;
+#endif
+#ifdef HAVE_STRUCT_STAT_ST_RDEV
+	st->st_rdev = 0;
+#endif
+	st->st_uid = getuid();
+	st->st_gid = getgid();
+
+	if (IS_DOS_DIR(attr)) {
+		st->st_nlink = 2;
+	} else {
+		st->st_nlink = 1;
+	}
+
+	if (ino != 0) {
+		st->st_ino = ino;
+	} else {
+		st->st_ino = generate_inode(fname);
+	}
+
+	st->st_dev = dev;
+
+	st->st_atime = access_time_ts.tv_sec;
+	set_atimensec(st, access_time_ts.tv_nsec);
+
+	st->st_ctime = change_time_ts.tv_sec;
+	set_ctimensec(st, change_time_ts.tv_nsec);
+
+	st->st_mtime = write_time_ts.tv_sec;
+	set_mtimensec(st, write_time_ts.tv_nsec);
+}
+
+void setup_stat_from_stat_ex(const struct stat_ex *stex,
+			     const char *fname,
+			     struct stat *st)
+{
+	st->st_atime = stex->st_ex_atime.tv_sec;
+	set_atimensec(st, stex->st_ex_atime.tv_nsec);
+
+	st->st_ctime = stex->st_ex_ctime.tv_sec;
+	set_ctimensec(st, stex->st_ex_ctime.tv_nsec);
+
+	st->st_mtime = stex->st_ex_mtime.tv_sec;
+	set_mtimensec(st, stex->st_ex_mtime.tv_nsec);
+
+	st->st_mode = stex->st_ex_mode;
+	st->st_size = stex->st_ex_size;
+#ifdef HAVE_STAT_ST_BLKSIZE
+	st->st_blksize = 512;
+#endif
+#ifdef HAVE_STAT_ST_BLOCKS
+	st->st_blocks = (st->st_size + 511) / 512;
+#endif
+#ifdef HAVE_STRUCT_STAT_ST_RDEV
+	st->st_rdev = 0;
+#endif
+	st->st_uid = stex->st_ex_uid;
+	st->st_gid = stex->st_ex_gid;
+
+	st->st_nlink = stex->st_ex_nlink;
+
+	if (stex->st_ex_ino == 0) {
+		st->st_ino = 0;
+		if (fname != NULL) {
+			st->st_ino = generate_inode(fname);
+		}
+	} else {
+		st->st_ino = stex->st_ex_ino;
+	}
+
+	st->st_dev = stex->st_ex_dev;
+
+}
+
+/*
+ * Routine to stat a file given a name
+ */
+
+int
+SMBC_stat_ctx(SMBCCTX *context,
+              const char *fname,
+              struct stat *st)
+{
+	SMBCSRV *srv = NULL;
+	char *server = NULL;
+	char *share = NULL;
+	char *user = NULL;
+	char *password = NULL;
+	char *workgroup = NULL;
+	char *path = NULL;
+	uint16_t port = 0;
+	NTSTATUS status;
+	TALLOC_CTX *frame = talloc_stackframe();
+
+	if (!context || !context->internal->initialized) {
+		errno = EINVAL;  /* Best I can think of ... */
+		TALLOC_FREE(frame);
+		return -1;
+	}
+
+	if (!fname) {
+		errno = EINVAL;
+		TALLOC_FREE(frame);
+		return -1;
+	}
+
+	DEBUG(4, ("smbc_stat(%s)\n", fname));
+
+	if (SMBC_parse_path(frame,
+                            context,
+                            fname,
+                            &workgroup,
+                            &server,
+                            &port,
+                            &share,
+                            &path,
+                            &user,
+                            &password,
+                            NULL)) {
+		errno = EINVAL;
+		TALLOC_FREE(frame);
+                return -1;
+        }
+
+	if (!user || user[0] == (char)0) {
+		user = talloc_strdup(frame, smbc_getUser(context));
+		if (!user) {
+			errno = ENOMEM;
+			TALLOC_FREE(frame);
+			return -1;
+		}
+	}
+
+	srv = SMBC_server(frame, context, True,
+                          server, port, share, &workgroup, &user, &password);
+	if (!srv) {
+		TALLOC_FREE(frame);
+		return -1;  /* errno set by SMBC_server */
+	}
+
+	status = SMBC_getatr(context, srv, path, st);
+	if (!NT_STATUS_IS_OK(status)) {
+		TALLOC_FREE(frame);
+		errno = cli_status_to_errno(status);
+		return -1;
+	}
+
+	TALLOC_FREE(frame);
+	return 0;
+}
+
+/*
+ * Routine to stat a file given an fd
+ */
+
+int
+SMBC_fstat_ctx(SMBCCTX *context,
+               SMBCFILE *file,
+               struct stat *st)
+{
+	struct timespec change_time_ts;
+        struct timespec access_time_ts;
+        struct timespec write_time_ts;
+	off_t size;
+	uint32_t attr;
+	char *server = NULL;
+	char *share = NULL;
+	char *user = NULL;
+	char *password = NULL;
+	char *path = NULL;
+        char *targetpath = NULL;
+	struct cli_state *targetcli = NULL;
+	SMB_INO_T ino = 0;
+	uint16_t port = 0;
+	struct cli_credentials *creds = NULL;
+	TALLOC_CTX *frame = talloc_stackframe();
+	NTSTATUS status;
+
+	if (!context || !context->internal->initialized) {
+		errno = EINVAL;
+		TALLOC_FREE(frame);
+		return -1;
+	}
+
+	if (!SMBC_dlist_contains(context->internal->files, file)) {
+		errno = EBADF;
+		TALLOC_FREE(frame);
+		return -1;
+	}
+
+	if (!file->file) {
+		TALLOC_FREE(frame);
+		return smbc_getFunctionFstatdir(context)(context, file, st);
+	}
+
+	/*d_printf(">>>fstat: parsing %s\n", file->fname);*/
+	if (SMBC_parse_path(frame,
+                            context,
+                            file->fname,
+                            NULL,
+                            &server,
+                            &port,
+                            &share,
+                            &path,
+                            &user,
+                            &password,
+                            NULL)) {
+                errno = EINVAL;
+		TALLOC_FREE(frame);
+                return -1;
+        }
+
+	creds = context->internal->creds;
+
+	/*d_printf(">>>fstat: resolving %s\n", path);*/
+	status = cli_resolve_path(frame, "",
+				  creds,
+				  file->srv->cli, path,
+				  &targetcli, &targetpath);
+	if (!NT_STATUS_IS_OK(status)) {
+		d_printf("Could not resolve %s\n", path);
+                errno = ENOENT;
+		TALLOC_FREE(frame);
+		return -1;
+	}
+	/*d_printf(">>>fstat: resolved path as %s\n", targetpath);*/
+
+	if (!NT_STATUS_IS_OK(cli_qfileinfo_basic(
+				     targetcli, file->cli_fd, &attr, &size,
+				     NULL,
+				     &access_time_ts,
+				     &write_time_ts,
+				     &change_time_ts,
+				     &ino))) {
+		errno = EINVAL;
+		TALLOC_FREE(frame);
+		return -1;
+	}
+
+	setup_stat(st,
+		path,
+		size,
+		attr,
+		ino,
+		file->srv->dev,
+		access_time_ts,
+		change_time_ts,
+		write_time_ts);
+
+	TALLOC_FREE(frame);
+	return 0;
+}
+
+
+/*
+ * Routine to obtain file system information given a path
+ */
+int
+SMBC_statvfs_ctx(SMBCCTX *context,
+                 char *path,
+                 struct statvfs *st)
+{
+        int             ret;
+        bool            bIsDir;
+        struct stat     statbuf;
+        SMBCFILE *      pFile;
+	TALLOC_CTX *frame = talloc_stackframe();
+
+        /* Determine if the provided path is a file or a folder */
+        if (SMBC_stat_ctx(context, path, &statbuf) < 0) {
+		TALLOC_FREE(frame);
+                return -1;
+        }
+
+        /* Is it a file or a directory?  */
+        if (S_ISDIR(statbuf.st_mode)) {
+                /* It's a directory. */
+                if ((pFile = SMBC_opendir_ctx(context, path)) == NULL) {
+			TALLOC_FREE(frame);
+                        return -1;
+                }
+                bIsDir = true;
+        } else if (S_ISREG(statbuf.st_mode)) {
+                /* It's a file. */
+                if ((pFile = SMBC_open_ctx(context, path,
+                                           O_RDONLY, 0)) == NULL) {
+			TALLOC_FREE(frame);
+                        return -1;
+                }
+                bIsDir = false;
+        } else {
+                /* It's neither a file nor a directory. Not supported. */
+		TALLOC_FREE(frame);
+                errno = ENOSYS;
+                return -1;
+        }
+
+        /* Now we have an open file handle, so just use SMBC_fstatvfs */
+        ret = SMBC_fstatvfs_ctx(context, pFile, st);
+
+        /* Close the file or directory */
+        if (bIsDir) {
+                SMBC_closedir_ctx(context, pFile);
+        } else {
+                SMBC_close_ctx(context, pFile);
+        }
+
+	TALLOC_FREE(frame);
+        return ret;
+}
+
+
+/*
+ * Routine to obtain file system information given an fd
+ */
+
+int
+SMBC_fstatvfs_ctx(SMBCCTX *context,
+                  SMBCFILE *file,
+                  struct statvfs *st)
+{
+        unsigned long flags = 0;
+	uint32_t fs_attrs = 0;
+	struct cli_state *cli = file->srv->cli;
+	struct smbXcli_tcon *tcon;
+	TALLOC_CTX *frame = talloc_stackframe();
+
+	if (smbXcli_conn_protocol(cli->conn) >= PROTOCOL_SMB2_02) {
+		tcon = cli->smb2.tcon;
+	} else {
+		tcon = cli->smb1.tcon;
+	}
+
+        /* Initialize all fields (at least until we actually use them) */
+	ZERO_STRUCTP(st);
+
+        /*
+         * The state of each flag is such that the same bits are unset as
+         * would typically be unset on a local file system on a POSIX OS. Thus
+         * the bit is on, for example, only for case-insensitive file systems
+         * since most POSIX file systems are case sensitive and fstatvfs()
+         * would typically return zero in these bits on such a local file
+         * system.
+         */
+
+        /* See if the server has UNIX CIFS support */
+        if (! SERVER_HAS_UNIX_CIFS(cli)) {
+                uint64_t total_allocation_units;
+                uint64_t caller_allocation_units;
+                uint64_t actual_allocation_units;
+                uint64_t sectors_per_allocation_unit;
+                uint64_t bytes_per_sector;
+		NTSTATUS status;
+
+                /* Nope. If size data is available... */
+		status = cli_get_fs_full_size_info(cli,
+						   &total_allocation_units,
+						   &caller_allocation_units,
+						   &actual_allocation_units,
+						   &sectors_per_allocation_unit,
+						   &bytes_per_sector);
+		if (NT_STATUS_IS_OK(status)) {
+
+                        /* ... then provide it */
+                        st->f_bsize =
+                                (unsigned long) bytes_per_sector;
+#ifdef HAVE_FRSIZE
+                        st->f_frsize =
+                                (unsigned long) sectors_per_allocation_unit;
+#endif
+                        st->f_blocks =
+                                (fsblkcnt_t) total_allocation_units;
+                        st->f_bfree =
+                                (fsblkcnt_t) actual_allocation_units;
+                        st->f_bavail =
+                                (fsblkcnt_t) caller_allocation_units;
+                }
+
+                flags |= SMBC_VFS_FEATURE_NO_UNIXCIFS;
+        } else {
+                uint32_t optimal_transfer_size;
+                uint32_t block_size;
+                uint64_t total_blocks;
+                uint64_t blocks_available;
+                uint64_t user_blocks_available;
+                uint64_t total_file_nodes;
+                uint64_t free_file_nodes;
+                uint64_t fs_identifier;
+		NTSTATUS status;
+
+                /* Has UNIXCIFS. If POSIX filesystem info is available... */
+		status = cli_get_posix_fs_info(cli,
+					       &optimal_transfer_size,
+					       &block_size,
+					       &total_blocks,
+					       &blocks_available,
+					       &user_blocks_available,
+					       &total_file_nodes,
+					       &free_file_nodes,
+					       &fs_identifier);
+		if (NT_STATUS_IS_OK(status)) {
+
+                        /* ... then what's provided here takes precedence. */
+                        st->f_bsize =
+                                (unsigned long) block_size;
+                        st->f_blocks =
+                                (fsblkcnt_t) total_blocks;
+                        st->f_bfree =
+                                (fsblkcnt_t) blocks_available;
+                        st->f_bavail =
+                                (fsblkcnt_t) user_blocks_available;
+                        st->f_files =
+                                (fsfilcnt_t) total_file_nodes;
+                        st->f_ffree =
+                                (fsfilcnt_t) free_file_nodes;
+#ifdef HAVE_FSID_INT
+                        st->f_fsid =
+                                (unsigned long) fs_identifier;
+#endif
+                }
+        }
+
+        /* See if the share is case sensitive */
+        if (!NT_STATUS_IS_OK(cli_get_fs_attr_info(cli, &fs_attrs))) {
+                /*
+                 * We can't determine the case sensitivity of
+                 * the share. We have no choice but to use the
+                 * user-specified case sensitivity setting.
+                 */
+                if (! smbc_getOptionCaseSensitive(context)) {
+                        flags |= SMBC_VFS_FEATURE_CASE_INSENSITIVE;
+                }
+        } else {
+                if (! (fs_attrs & FILE_CASE_SENSITIVE_SEARCH)) {
+                        flags |= SMBC_VFS_FEATURE_CASE_INSENSITIVE;
+                }
+        }
+
+        /* See if DFS is supported */
+	if (smbXcli_conn_dfs_supported(cli->conn) &&
+	    smbXcli_tcon_is_dfs_share(tcon))
+	{
+                flags |= SMBC_VFS_FEATURE_DFS;
+        }
+
+#if defined(HAVE_STATVFS_F_FLAG)
+        st->f_flag = flags;
+#elif defined(HAVE_STATVFS_F_FLAGS)
+        st->f_flags = flags;
+#endif
+
+	TALLOC_FREE(frame);
+        return 0;
+}