1
0
mirror of https://github.com/samba-team/samba.git synced 2024-12-24 21:34:56 +03:00
samba-mirror/source3/libsmb/libsmb_stat.c
Volker Lendecke 49ca690b4b Introduce "struct stat_ex" as a replacement for SMB_STRUCT_STAT
This patch introduces

struct stat_ex {
        dev_t           st_ex_dev;
        ino_t           st_ex_ino;
        mode_t          st_ex_mode;
        nlink_t         st_ex_nlink;
        uid_t           st_ex_uid;
        gid_t           st_ex_gid;
        dev_t           st_ex_rdev;
        off_t           st_ex_size;
        struct timespec st_ex_atime;
        struct timespec st_ex_mtime;
        struct timespec st_ex_ctime;
        struct timespec st_ex_btime; /* birthtime */
        blksize_t       st_ex_blksize;
        blkcnt_t        st_ex_blocks;
};
typedef struct stat_ex SMB_STRUCT_STAT;

It is really large because due to the friendly libc headers playing macro
tricks with fields like st_ino, so I renamed them to st_ex_xxx.

Why this change? To support birthtime, we already have quite a few #ifdef's at
places where it does not really belong. With a stat struct that we control, we
can consolidate the nanosecond timestamps and the birthtime deep in the VFS
stat calls.

At this moment it is triggered by a request to support the birthtime field for
GPFS. GPFS does not extend the system level struct stat, but instead has a
separate call that gets us the additional information beyond posix. Without
being able to do that within the VFS stat calls, that support would have to be
scattered around the main smbd code.

It will very likely break all the onefs modules, but I think the changes will
be reasonably easy to do.
2009-05-26 17:48:23 +02:00

485 lines
14 KiB
C

/*
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 "libsmbclient.h"
#include "libsmb_internal.h"
/*
* Generate an inode number from file name for those things that need it
*/
static ino_t
generate_inode(SMBCCTX *context,
const char *name)
{
if (!context || !context->internal->initialized) {
errno = EINVAL;
return -1;
}
if (!*name) return 2; /* FIXME, why 2 ??? */
return (ino_t)str_checksum(name);
}
/*
* Routine to put basic stat info into a stat structure ... Used by stat and
* fstat below.
*/
static int
setup_stat(SMBCCTX *context,
struct stat *st,
char *fname,
SMB_OFF_T size,
int mode)
{
TALLOC_CTX *frame = talloc_stackframe();
st->st_mode = 0;
if (IS_DOS_DIR(mode)) {
st->st_mode = SMBC_DIR_MODE;
} else {
st->st_mode = SMBC_FILE_MODE;
}
if (IS_DOS_ARCHIVE(mode)) st->st_mode |= S_IXUSR;
if (IS_DOS_SYSTEM(mode)) st->st_mode |= S_IXGRP;
if (IS_DOS_HIDDEN(mode)) st->st_mode |= S_IXOTH;
if (!IS_DOS_READONLY(mode)) 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(mode)) {
st->st_nlink = 2;
} else {
st->st_nlink = 1;
}
if (st->st_ino == 0) {
st->st_ino = generate_inode(context, fname);
}
TALLOC_FREE(frame);
return True; /* FIXME: Is this needed ? */
}
/*
* 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;
struct timespec write_time_ts;
struct timespec access_time_ts;
struct timespec change_time_ts;
SMB_OFF_T size = 0;
uint16 mode = 0;
SMB_INO_T ino = 0;
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,
&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, share, &workgroup, &user, &password);
if (!srv) {
TALLOC_FREE(frame);
return -1; /* errno set by SMBC_server */
}
if (!SMBC_getatr(context, srv, path, &mode, &size,
NULL,
&access_time_ts,
&write_time_ts,
&change_time_ts,
&ino)) {
errno = SMBC_errno(context, srv->cli);
TALLOC_FREE(frame);
return -1;
}
st->st_ino = ino;
setup_stat(context, st, (char *) fname, size, mode);
st->st_atime = convert_timespec_to_time_t(access_time_ts);
st->st_ctime = convert_timespec_to_time_t(change_time_ts);
st->st_mtime = convert_timespec_to_time_t(write_time_ts);
st->st_dev = srv->dev;
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;
SMB_OFF_T size;
uint16 mode;
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;
TALLOC_CTX *frame = talloc_stackframe();
if (!context || !context->internal->initialized) {
errno = EINVAL;
TALLOC_FREE(frame);
return -1;
}
if (!file || !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,
&share,
&path,
&user,
&password,
NULL)) {
errno = EINVAL;
TALLOC_FREE(frame);
return -1;
}
/*d_printf(">>>fstat: resolving %s\n", path);*/
if (!cli_resolve_path(frame, "", context->internal->auth_info,
file->srv->cli, path,
&targetcli, &targetpath)) {
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 (!cli_qfileinfo(targetcli, file->cli_fd, &mode, &size,
NULL,
&access_time_ts,
&write_time_ts,
&change_time_ts,
&ino)) {
time_t change_time, access_time, write_time;
if (!NT_STATUS_IS_OK(cli_getattrE(targetcli, file->cli_fd, &mode, &size,
&change_time, &access_time, &write_time))) {
errno = EINVAL;
TALLOC_FREE(frame);
return -1;
}
change_time_ts = convert_time_t_to_timespec(change_time);
access_time_ts = convert_time_t_to_timespec(access_time);
write_time_ts = convert_time_t_to_timespec(write_time);
}
st->st_ino = ino;
setup_stat(context, st, file->fname, size, mode);
st->st_atime = convert_timespec_to_time_t(access_time_ts);
st->st_ctime = convert_timespec_to_time_t(change_time_ts);
st->st_mtime = convert_timespec_to_time_t(write_time_ts);
st->st_dev = file->srv->dev;
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;
/* Determine if the provided path is a file or a folder */
if (SMBC_stat_ctx(context, path, &statbuf) < 0) {
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) {
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) {
return -1;
}
bIsDir = false;
} else {
/* It's neither a file nor a directory. Not supported. */
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);
}
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 fs_attrs = 0;
struct cli_state *cli = file->srv->cli;
/* Initialize all fields (at least until we actually use them) */
memset(st, 0, sizeof(*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;
/* Nope. If size data is available... */
if (cli_get_fs_full_size_info(cli,
&total_allocation_units,
&caller_allocation_units,
&actual_allocation_units,
&sectors_per_allocation_unit,
&bytes_per_sector)) {
/* ... then provide it */
st->f_bsize =
(unsigned long) bytes_per_sector;
#if 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;
}
flags |= SMBC_VFS_FEATURE_NO_UNIXCIFS;
} else {
uint32 optimal_transfer_size;
uint32 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;
/* Has UNIXCIFS. If POSIX filesystem info is available... */
if (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)) {
/* ... 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;
#if HAVE_FSID_INT
st->f_fsid =
(unsigned long) fs_identifier;
#endif
}
}
/* See if the share is case sensitive */
if (!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 ((cli->capabilities & CAP_DFS) && cli->dfsroot) {
flags |= SMBC_VFS_FEATURE_DFS;
}
#if HAVE_STATVFS_F_FLAG
st->f_flag = flags;
#elif HAVE_STATVFS_F_FLAGS
st->f_flags = flags;
#endif
return 0;
}