smbd/vfs.c

ソースコードを見る。

データ構造
struct	vfs_init_function_entry
関数
static struct vfs_init_function_entry *	vfs_find_backend_entry (const char *name)
NTSTATUS	smb_register_vfs (int version, const char *name, vfs_op_tuple *vfs_op_tuples)
static void	vfs_init_default (connection_struct *conn)
static void	vfs_set_operation (struct vfs_ops *vfs, vfs_op_type which, struct vfs_handle_struct *handle, void *op)
BOOL	vfs_init_custom (connection_struct *conn, const char *vfs_object)
void *	vfs_add_fsp_extension_notype (vfs_handle_struct *handle, files_struct *fsp, size_t ext_size)
void	vfs_remove_fsp_extension (vfs_handle_struct *handle, files_struct *fsp)
void *	vfs_fetch_fsp_extension (vfs_handle_struct *handle, files_struct *fsp)
BOOL	smbd_vfs_init (connection_struct *conn)
BOOL	vfs_directory_exist (connection_struct *conn, const char *dname, SMB_STRUCT_STAT *st)
BOOL	vfs_object_exist (connection_struct *conn, const char *fname, SMB_STRUCT_STAT *sbuf)
BOOL	vfs_file_exist (connection_struct *conn, const char *fname, SMB_STRUCT_STAT *sbuf)
ssize_t	vfs_read_data (files_struct *fsp, char *buf, size_t byte_count)
ssize_t	vfs_pread_data (files_struct *fsp, char *buf, size_t byte_count, SMB_OFF_T offset)
ssize_t	vfs_write_data (files_struct *fsp, const char *buffer, size_t N)
ssize_t	vfs_pwrite_data (files_struct *fsp, const char *buffer, size_t N, SMB_OFF_T offset)
int	vfs_allocate_file_space (files_struct *fsp, SMB_BIG_UINT len)
int	vfs_set_filelen (files_struct *fsp, SMB_OFF_T len)
int	vfs_fill_sparse (files_struct *fsp, SMB_OFF_T len)
static ssize_t	read_fn (int fd, void *buf, size_t len)
static ssize_t	write_fn (int fd, const void *buf, size_t len)
SMB_OFF_T	vfs_transfer_file (files_struct *in, files_struct *out, SMB_OFF_T n)
char *	vfs_readdirname (connection_struct *conn, void *p)
int	vfs_ChDir (connection_struct *conn, const char *path)
static void	array_promote (char *array, int elsize, int element)
char *	vfs_GetWd (connection_struct *conn, char *path)
NTSTATUS	reduce_name (connection_struct *conn, const pstring fname)
変数
	static_decl_vfs
static struct vfs_init_function_entry *	backends = NULL
static char *	sparse_buf
static files_struct *	in_fsp
static files_struct *	out_fsp
struct {
SMB_DEV_T   dev
SMB_INO_T   inode
char *   dos_path
BOOL   valid
}	ino_list [MAX_GETWDCACHE]
BOOL	use_getwd_cache

---

関数

static struct vfs_init_function_entry* vfs_find_backend_entry

(

const char *

name

)

[static]

vfs.c の 45 行で定義されています。

参照先 backends・vfs_init_function_entry::name・vfs_init_function_entry::next.

参照元 smb_register_vfs()・vfs_init_custom().

{
        struct vfs_init_function_entry *entry = backends;
 
        while(entry) {
                if (strcmp(entry->name, name)==0) return entry;
                entry = entry->next;
        }

        return NULL;
}

NTSTATUS smb_register_vfs	(	int	version,
		const char *	name,
		vfs_op_tuple *	vfs_op_tuples
	)

vfs.c の 57 行で定義されています。

参照先 backends・vfs_init_function_entry::name・smb_xstrdup()・vfs_find_backend_entry()・vfs_init_function_entry::vfs_op_tuples.

参照元 vfs_afsacl_init()・vfs_aixacl2_init()・vfs_aixacl_init()・vfs_audit_init()・vfs_cacheprime_init()・vfs_cap_init()・vfs_catia_init()・vfs_commit_init()・vfs_default_init()・vfs_default_quota_init()・vfs_expand_msdfs_init()・vfs_extd_audit_init()・vfs_fake_perms_init()・vfs_full_audit_init()・vfs_gpfs_init()・vfs_hpuxacl_init()・vfs_irixacl_init()・vfs_netatalk_init()・vfs_notify_fam_init()・vfs_posixacl_init()・vfs_prealloc_init()・vfs_readahead_init()・vfs_readonly_init()・vfs_recycle_init()・vfs_shadow_copy_init()・vfs_solarisacl_init()・vfs_tru64acl_init().

{
        struct vfs_init_function_entry *entry = backends;

        if ((version != SMB_VFS_INTERFACE_VERSION)) {
                DEBUG(0, ("Failed to register vfs module.\n"
                          "The module was compiled against SMB_VFS_INTERFACE_VERSION %d,\n"
                          "current SMB_VFS_INTERFACE_VERSION is %d.\n"
                          "Please recompile against the current Samba Version!\n",  
                          version, SMB_VFS_INTERFACE_VERSION));
                return NT_STATUS_OBJECT_TYPE_MISMATCH;
        }

        if (!name || !name[0] || !vfs_op_tuples) {
                DEBUG(0,("smb_register_vfs() called with NULL pointer or empty name!\n"));
                return NT_STATUS_INVALID_PARAMETER;
        }

        if (vfs_find_backend_entry(name)) {
                DEBUG(0,("VFS module %s already loaded!\n", name));
                return NT_STATUS_OBJECT_NAME_COLLISION;
        }

        entry = SMB_XMALLOC_P(struct vfs_init_function_entry);
        entry->name = smb_xstrdup(name);
        entry->vfs_op_tuples = vfs_op_tuples;

        DLIST_ADD(backends, entry);
        DEBUG(5, ("Successfully added vfs backend '%s'\n", name));
        return NT_STATUS_OK;
}

static void vfs_init_default

(

connection_struct *

conn

)

[static]

vfs.c の 93 行で定義されています。

参照先 vfs_init_custom().

参照元 smbd_vfs_init().

{
        DEBUG(3, ("Initialising default vfs hooks\n"));
        vfs_init_custom(conn, DEFAULT_VFS_MODULE_NAME);
}

static void vfs_set_operation	(	struct vfs_ops *	vfs,
		vfs_op_type	which,
		struct vfs_handle_struct *	handle,
		void *	op
	)			[inline, static]

vfs.c の 103 行で定義されています。

参照先 handle・vfs_ops::handles・vfs_ops::ops.

参照元 vfs_init_custom().

{
        ((struct vfs_handle_struct **)&vfs->handles)[which] = handle;
        ((void **)(void *)&vfs->ops)[which] = op;
}

BOOL vfs_init_custom	(	connection_struct *	conn,
		const char *	vfs_object
	)

vfs.c の 110 行で定義されています。

参照先 backends・handle・connection_struct::mem_ctx・vfs_op_tuple::op・smb_probe_module()・SMB_VFS_LAYER_OPAQUE・smb_xstrdup()・strchr_m()・talloc_strdup()・trim_char()・vfs_op_tuple::type・type・connection_struct::vfs・vfs_find_backend_entry()・connection_struct::vfs_handles・vfs_init_function_entry::vfs_op_tuples・connection_struct::vfs_opaque・vfs_set_operation().

参照元 cmd_load_module()・smbd_vfs_init()・vfs_init_default().

{
        vfs_op_tuple *ops;
        char *module_name = NULL;
        char *module_param = NULL, *p;
        int i;
        vfs_handle_struct *handle;
        struct vfs_init_function_entry *entry;
        
        if (!conn||!vfs_object||!vfs_object[0]) {
                DEBUG(0,("vfs_init_custon() called with NULL pointer or emtpy vfs_object!\n"));
                return False;
        }

        if(!backends) {
                static_init_vfs;
        }

        DEBUG(3, ("Initialising custom vfs hooks from [%s]\n", vfs_object));

        module_name = smb_xstrdup(vfs_object);

        p = strchr_m(module_name, ':');

        if (p) {
                *p = 0;
                module_param = p+1;
                trim_char(module_param, ' ', ' ');
        }

        trim_char(module_name, ' ', ' ');

        /* First, try to load the module with the new module system */
        if((entry = vfs_find_backend_entry(module_name)) || 
           (NT_STATUS_IS_OK(smb_probe_module("vfs", module_name)) && 
                (entry = vfs_find_backend_entry(module_name)))) {

                DEBUGADD(5,("Successfully loaded vfs module [%s] with the new modules system\n", vfs_object));
                
                if ((ops = entry->vfs_op_tuples) == NULL) {
                        DEBUG(0, ("entry->vfs_op_tuples==NULL for [%s] failed\n", vfs_object));
                        SAFE_FREE(module_name);
                        return False;
                }
        } else {
                DEBUG(0,("Can't find a vfs module [%s]\n",vfs_object));
                SAFE_FREE(module_name);
                return False;
        }

        handle = TALLOC_ZERO_P(conn->mem_ctx,vfs_handle_struct);
        if (!handle) {
                DEBUG(0,("TALLOC_ZERO() failed!\n"));
                SAFE_FREE(module_name);
                return False;
        }
        memcpy(&handle->vfs_next, &conn->vfs, sizeof(struct vfs_ops));
        handle->conn = conn;
        if (module_param) {
                handle->param = talloc_strdup(conn->mem_ctx, module_param);
        }
        DLIST_ADD(conn->vfs_handles, handle);

        for(i=0; ops[i].op != NULL; i++) {
                DEBUG(5, ("Checking operation #%d (type %d, layer %d)\n", i, ops[i].type, ops[i].layer));
                if(ops[i].layer == SMB_VFS_LAYER_OPAQUE) {
                        /* If this operation was already made opaque by different module, it
                         * will be overridden here.
                         */
                        DEBUGADD(5, ("Making operation type %d opaque [module %s]\n", ops[i].type, vfs_object));
                        vfs_set_operation(&conn->vfs_opaque, ops[i].type, handle, ops[i].op);
                }
                /* Change current VFS disposition*/
                DEBUGADD(5, ("Accepting operation type %d from module %s\n", ops[i].type, vfs_object));
                vfs_set_operation(&conn->vfs, ops[i].type, handle, ops[i].op);
        }

        SAFE_FREE(module_name);
        return True;
}

void* vfs_add_fsp_extension_notype	(	vfs_handle_struct *	handle,
		files_struct *	fsp,
		size_t	ext_size
	)

vfs.c の 199 行で定義されています。

参照先 handle・vfs_fsp_data::next・vfs_fsp_data::owner・files_struct::vfs_extension・vfs_fetch_fsp_extension().

{
        struct vfs_fsp_data *ext;
        void * ext_data;

        /* Prevent VFS modules adding multiple extensions. */
        if ((ext_data = vfs_fetch_fsp_extension(handle, fsp))) {
                return ext_data;
        }

        ext = (struct vfs_fsp_data *)TALLOC_ZERO(
                handle->conn->mem_ctx, sizeof(struct vfs_fsp_data) + ext_size);
        if (ext == NULL) {
                return NULL;
        }

        ext->owner = handle;
        ext->next = fsp->vfs_extension;
        fsp->vfs_extension = ext;
        return EXT_DATA_AREA(ext);
}

void vfs_remove_fsp_extension	(	vfs_handle_struct *	handle,
		files_struct *	fsp
	)

vfs.c の 221 行で定義されています。

参照先 handle・vfs_fsp_data::next・vfs_fsp_data::owner・files_struct::vfs_extension.

{
        struct vfs_fsp_data *curr;
        struct vfs_fsp_data *prev;

        for (curr = fsp->vfs_extension, prev = NULL;
             curr;
             prev = curr, curr = curr->next) {
                if (curr->owner == handle) {
                    if (prev) {
                            prev->next = curr->next;
                    } else {
                            fsp->vfs_extension = curr->next;
                    }
                    TALLOC_FREE(curr);
                    return;
                }
        }
}

void* vfs_fetch_fsp_extension	(	vfs_handle_struct *	handle,
		files_struct *	fsp
	)

vfs.c の 241 行で定義されています。

参照先 handle・vfs_fsp_data::next・vfs_fsp_data::owner・files_struct::vfs_extension.

参照元 vfs_add_fsp_extension_notype().

{
        struct vfs_fsp_data *head;

        for (head = fsp->vfs_extension; head; head = head->next) {
                if (head->owner == handle) {
                        return EXT_DATA_AREA(head);
                }
        }

        return NULL;
}

BOOL smbd_vfs_init

(

connection_struct *

conn

)

vfs.c の 260 行で定義されています。

参照先 vfs_init_custom()・vfs_init_default().

参照元 create_conn_struct()・get_nt_acl_no_snum()・main().

{
        const char **vfs_objects;
        unsigned int i = 0;
        int j = 0;
        
        /* Normal share - initialise with disk access functions */
        vfs_init_default(conn);
        vfs_objects = lp_vfs_objects(SNUM(conn));

        /* Override VFS functions if 'vfs object' was not specified*/
        if (!vfs_objects || !vfs_objects[0])
                return True;
        
        for (i=0; vfs_objects[i] ;) {
                i++;
        }

        for (j=i-1; j >= 0; j--) {
                if (!vfs_init_custom(conn, vfs_objects[j])) {
                        DEBUG(0, ("smbd_vfs_init: vfs_init_custom failed for %s\n", vfs_objects[j]));
                        return False;
                }
        }
        return True;
}

BOOL vfs_directory_exist	(	connection_struct *	conn,
		const char *	dname,
		SMB_STRUCT_STAT *	st
	)

vfs.c の 291 行で定義されています。

参照先 errno.

参照元 reply_setdir().

{
        SMB_STRUCT_STAT st2;
        BOOL ret;

        if (!st)
                st = &st2;

        if (SMB_VFS_STAT(conn,dname,st) != 0)
                return(False);

        ret = S_ISDIR(st->st_mode);
        if(!ret)
                errno = ENOTDIR;

        return ret;
}

BOOL vfs_object_exist	(	connection_struct *	conn,
		const char *	fname,
		SMB_STRUCT_STAT *	sbuf
	)

vfs.c の 313 行で定義されています。

参照元 rename_internals()・rename_internals_fsp().

{
        SMB_STRUCT_STAT st;

        if (!sbuf)
                sbuf = &st;

        ZERO_STRUCTP(sbuf);

        if (SMB_VFS_STAT(conn,fname,sbuf) == -1)
                return(False);
        return True;
}

BOOL vfs_file_exist	(	connection_struct *	conn,
		const char *	fname,
		SMB_STRUCT_STAT *	sbuf
	)

vfs.c の 331 行で定義されています。

参照元 copy_file()・get_correct_cversion()・rename_internals().

{
        SMB_STRUCT_STAT st;

        if (!sbuf)
                sbuf = &st;

        ZERO_STRUCTP(sbuf);

        if (SMB_VFS_STAT(conn,fname,sbuf) == -1)
                return False;
        return(S_ISREG(sbuf->st_mode));
}

ssize_t vfs_read_data	(	files_struct *	fsp,
		char *	buf,
		size_t	byte_count
	)

vfs.c の 349 行で定義されています。

参照先 errno・fd_handle::fd・files_struct::fh・total.

参照元 get_file_version().

{
        size_t total=0;

        while (total < byte_count)
        {
                ssize_t ret = SMB_VFS_READ(fsp, fsp->fh->fd, buf + total,
                                        byte_count - total);

                if (ret == 0) return total;
                if (ret == -1) {
                        if (errno == EINTR)
                                continue;
                        else
                                return -1;
                }
                total += ret;
        }
        return (ssize_t)total;
}

ssize_t vfs_pread_data	(	files_struct *	fsp,
		char *	buf,
		size_t	byte_count,
		SMB_OFF_T	offset
	)

vfs.c の 370 行で定義されています。

参照先 errno・fd_handle::fd・files_struct::fh・total.

{
        size_t total=0;

        while (total < byte_count)
        {
                ssize_t ret = SMB_VFS_PREAD(fsp, fsp->fh->fd, buf + total,
                                        byte_count - total, offset + total);

                if (ret == 0) return total;
                if (ret == -1) {
                        if (errno == EINTR)
                                continue;
                        else
                                return -1;
                }
                total += ret;
        }
        return (ssize_t)total;
}

ssize_t vfs_write_data	(	files_struct *	fsp,
		const char *	buffer,
		size_t	N
	)

vfs.c の 396 行で定義されています。

参照先 fd_handle::fd・files_struct::fh・total.

参照元 real_write_file().

{
        size_t total=0;
        ssize_t ret;

        while (total < N) {
                ret = SMB_VFS_WRITE(fsp,fsp->fh->fd,buffer + total,N - total);

                if (ret == -1)
                        return -1;
                if (ret == 0)
                        return total;

                total += ret;
        }
        return (ssize_t)total;
}

ssize_t vfs_pwrite_data	(	files_struct *	fsp,
		const char *	buffer,
		size_t	N,
		SMB_OFF_T	offset
	)

vfs.c の 414 行で定義されています。

参照先 fd_handle::fd・files_struct::fh・total.

参照元 real_write_file().

{
        size_t total=0;
        ssize_t ret;

        while (total < N) {
                ret = SMB_VFS_PWRITE(fsp, fsp->fh->fd, buffer + total,
                                N - total, offset + total);

                if (ret == -1)
                        return -1;
                if (ret == 0)
                        return total;

                total += ret;
        }
        return (ssize_t)total;
}

int vfs_allocate_file_space	(	files_struct *	fsp,
		SMB_BIG_UINT	len
	)

vfs.c の 439 行で定義されています。

参照先 files_struct::conn・errno・fd_handle::fd・files_struct::fh・flush_write_cache()・files_struct::fsp_name・get_dfree_info()・release_level_2_oplocks_on_change()・set_filelen_write_cache().

参照元 call_nt_transact_create()・call_trans2open()・reply_ntcreate_and_X()・reply_open_and_X()・reply_write()・smb_set_file_allocation_info().

{
        int ret;
        SMB_STRUCT_STAT st;
        connection_struct *conn = fsp->conn;
        SMB_BIG_UINT space_avail;
        SMB_BIG_UINT bsize,dfree,dsize;

        release_level_2_oplocks_on_change(fsp);

        /*
         * Actually try and commit the space on disk....
         */

        DEBUG(10,("vfs_allocate_file_space: file %s, len %.0f\n", fsp->fsp_name, (double)len ));

        if (((SMB_OFF_T)len) < 0) {
                DEBUG(0,("vfs_allocate_file_space: %s negative len requested.\n", fsp->fsp_name ));
                errno = EINVAL;
                return -1;
        }

        ret = SMB_VFS_FSTAT(fsp,fsp->fh->fd,&st);
        if (ret == -1)
                return ret;

        if (len == (SMB_BIG_UINT)st.st_size)
                return 0;

        if (len < (SMB_BIG_UINT)st.st_size) {
                /* Shrink - use ftruncate. */

                DEBUG(10,("vfs_allocate_file_space: file %s, shrink. Current size %.0f\n",
                                fsp->fsp_name, (double)st.st_size ));

                flush_write_cache(fsp, SIZECHANGE_FLUSH);
                if ((ret = SMB_VFS_FTRUNCATE(fsp, fsp->fh->fd, (SMB_OFF_T)len)) != -1) {
                        set_filelen_write_cache(fsp, len);
                }
                return ret;
        }

        /* Grow - we need to test if we have enough space. */

        if (!lp_strict_allocate(SNUM(fsp->conn)))
                return 0;

        len -= st.st_size;
        len /= 1024; /* Len is now number of 1k blocks needed. */
        space_avail = get_dfree_info(conn,fsp->fsp_name,False,&bsize,&dfree,&dsize);
        if (space_avail == (SMB_BIG_UINT)-1) {
                return -1;
        }

        DEBUG(10,("vfs_allocate_file_space: file %s, grow. Current size %.0f, needed blocks = %.0f, space avail = %.0f\n",
                        fsp->fsp_name, (double)st.st_size, (double)len, (double)space_avail ));

        if (len > space_avail) {
                errno = ENOSPC;
                return -1;
        }

        return 0;
}

int vfs_set_filelen	(	files_struct *	fsp,
		SMB_OFF_T	len
	)

vfs.c の 510 行で定義されています。

参照先 files_struct::conn・fd_handle::fd・files_struct::fh・flush_write_cache()・files_struct::fsp_name・notify_fname()・release_level_2_oplocks_on_change()・set_filelen_write_cache().

参照元 reply_open_and_X()・reply_write()・smb_set_file_size().

{
        int ret;

        release_level_2_oplocks_on_change(fsp);
        DEBUG(10,("vfs_set_filelen: ftruncate %s to len %.0f\n", fsp->fsp_name, (double)len));
        flush_write_cache(fsp, SIZECHANGE_FLUSH);
        if ((ret = SMB_VFS_FTRUNCATE(fsp, fsp->fh->fd, len)) != -1) {
                set_filelen_write_cache(fsp, len);
                notify_fname(fsp->conn, NOTIFY_ACTION_MODIFIED,
                             FILE_NOTIFY_CHANGE_SIZE
                             | FILE_NOTIFY_CHANGE_ATTRIBUTES,
                             fsp->fsp_name);
        }

        return ret;
}

int vfs_fill_sparse	(	files_struct *	fsp,
		SMB_OFF_T	len
	)

vfs.c の 538 行で定義されています。

参照先 errno・fd_handle::fd・files_struct::fh・flush_write_cache()・files_struct::fsp_name・release_level_2_oplocks_on_change()・set_filelen_write_cache()・sparse_buf・strerror()・total.

参照元 real_write_file().

{
        int ret;
        SMB_STRUCT_STAT st;
        SMB_OFF_T offset;
        size_t total;
        size_t num_to_write;
        ssize_t pwrite_ret;

        release_level_2_oplocks_on_change(fsp);
        ret = SMB_VFS_FSTAT(fsp,fsp->fh->fd,&st);
        if (ret == -1) {
                return ret;
        }

        if (len <= st.st_size) {
                return 0;
        }

        DEBUG(10,("vfs_fill_sparse: write zeros in file %s from len %.0f to len %.0f (%.0f bytes)\n",
                fsp->fsp_name, (double)st.st_size, (double)len, (double)(len - st.st_size)));

        flush_write_cache(fsp, SIZECHANGE_FLUSH);

        if (!sparse_buf) {
                sparse_buf = SMB_CALLOC_ARRAY(char, SPARSE_BUF_WRITE_SIZE);
                if (!sparse_buf) {
                        errno = ENOMEM;
                        return -1;
                }
        }

        offset = st.st_size;
        num_to_write = len - st.st_size;
        total = 0;

        while (total < num_to_write) {
                size_t curr_write_size = MIN(SPARSE_BUF_WRITE_SIZE, (num_to_write - total));

                pwrite_ret = SMB_VFS_PWRITE(fsp, fsp->fh->fd, sparse_buf, curr_write_size, offset + total);
                if (pwrite_ret == -1) {
                        DEBUG(10,("vfs_fill_sparse: SMB_VFS_PWRITE for file %s failed with error %s\n",
                                fsp->fsp_name, strerror(errno) ));
                        return -1;
                }
                if (pwrite_ret == 0) {
                        return 0;
                }

                total += pwrite_ret;
        }

        set_filelen_write_cache(fsp, len);
        return 0;
}

static ssize_t read_fn	(	int	fd,
		void *	buf,
		size_t	len
	)			[static]

vfs.c の 601 行で定義されています。

参照先 in_fsp.

参照元 vfs_transfer_file().

{
        return SMB_VFS_READ(in_fsp, fd, buf, len);
}

static ssize_t write_fn	(	int	fd,
		const void *	buf,
		size_t	len
	)			[static]

vfs.c の 606 行で定義されています。

参照先 out_fsp.

参照元 vfs_transfer_file().

{
        return SMB_VFS_WRITE(out_fsp, fd, buf, len);
}

SMB_OFF_T vfs_transfer_file	(	files_struct *	in,
		files_struct *	out,
		SMB_OFF_T	n
	)

vfs.c の 611 行で定義されています。

参照先 fd_handle::fd・files_struct::fh・in_fsp・out_fsp・read_fn()・transfer_file_internal()・write_fn().

参照元 copy_file()・copy_internals().

{
        in_fsp = in;
        out_fsp = out;

        return transfer_file_internal(in_fsp->fh->fd, out_fsp->fh->fd, n, read_fn, write_fn);
}

char* vfs_readdirname	(	connection_struct *	conn,
		void *	p
	)

vfs.c の 623 行で定義されています。

参照先 telldir().

参照元 form_junctions()・ReadDirName().

{
        SMB_STRUCT_DIRENT *ptr= NULL;
        char *dname;

        if (!p)
                return(NULL);

        ptr = SMB_VFS_READDIR(conn, (DIR *)p);
        if (!ptr)
                return(NULL);

        dname = ptr->d_name;

#ifdef NEXT2
        if (telldir(p) < 0)
                return(NULL);
#endif

#ifdef HAVE_BROKEN_READDIR_NAME
        /* using /usr/ucb/cc is BAD */
        dname = dname - 2;
#endif

        return(dname);
}

int vfs_ChDir	(	connection_struct *	conn,
		const char *	path
	)

vfs.c の 654 行で定義されています。

参照先 strcsequal().

参照元 _dfs_Add()・_dfs_Enum()・_dfs_GetInfo()・_dfs_Remove()・change_dir_owner_to_parent()・close_cnum()・create_conn_struct()・make_connection_with_chdir()・set_current_service()・setup_dfs_referral().

{
        int res;
        static pstring LastDir="";

        if (strcsequal(path,"."))
                return(0);

        if (*path == '/' && strcsequal(LastDir,path))
                return(0);

        DEBUG(4,("vfs_ChDir to %s\n",path));

        res = SMB_VFS_CHDIR(conn,path);
        if (!res)
                pstrcpy(LastDir,path);
        return(res);
}

static void array_promote	(	char *	array,
		int	elsize,
		int	element
	)			[static]

vfs.c の 689 行で定義されています。

参照元 vfs_GetWd().

{
        char *p;
        if (element == 0)
                return;

        p = (char *)SMB_MALLOC(elsize);

        if (!p) {
                DEBUG(5,("array_promote: malloc fail\n"));
                return;
        }

        memcpy(p,array + element * elsize, elsize);
        memmove(array + elsize,array,elsize*element);
        memcpy(array,p,elsize);
        SAFE_FREE(p);
}

char* vfs_GetWd	(	connection_struct *	conn,
		char *	path
	)

vfs.c の 714 行で定義されています。

参照先 array_promote()・dos_path・errno・ino_list・strerror()・string_set()・use_getwd_cache・valid.

参照元 change_dir_owner_to_parent().

{
        pstring s;
        static BOOL getwd_cache_init = False;
        SMB_STRUCT_STAT st, st2;
        int i;

        *s = 0;

        if (!use_getwd_cache)
                return(SMB_VFS_GETWD(conn,path));

        /* init the cache */
        if (!getwd_cache_init) {
                getwd_cache_init = True;
                for (i=0;i<MAX_GETWDCACHE;i++) {
                        string_set(&ino_list[i].dos_path,"");
                        ino_list[i].valid = False;
                }
        }

        /*  Get the inode of the current directory, if this doesn't work we're
                in trouble :-) */

        if (SMB_VFS_STAT(conn, ".",&st) == -1) {
                /* Known to fail for root: the directory may be
                 * NFS-mounted and exported with root_squash (so has no root access). */
                DEBUG(1,("vfs_GetWd: couldn't stat \".\" path=%s error %s (NFS problem ?)\n", path, strerror(errno) ));
                return(SMB_VFS_GETWD(conn,path));
        }


        for (i=0; i<MAX_GETWDCACHE; i++) {
                if (ino_list[i].valid) {

                        /*  If we have found an entry with a matching inode and dev number
                                then find the inode number for the directory in the cached string.
                                If this agrees with that returned by the stat for the current
                                directory then all is o.k. (but make sure it is a directory all
                                the same...) */

                        if (st.st_ino == ino_list[i].inode && st.st_dev == ino_list[i].dev) {
                                if (SMB_VFS_STAT(conn,ino_list[i].dos_path,&st2) == 0) {
                                        if (st.st_ino == st2.st_ino && st.st_dev == st2.st_dev &&
                                                        (st2.st_mode & S_IFMT) == S_IFDIR) {
                                                pstrcpy (path, ino_list[i].dos_path);

                                                /* promote it for future use */
                                                array_promote((char *)&ino_list[0],sizeof(ino_list[0]),i);
                                                return (path);
                                        } else {
                                                /*  If the inode is different then something's changed,
                                                        scrub the entry and start from scratch. */
                                                ino_list[i].valid = False;
                                        }
                                }
                        }
                }
        }

        /*  We don't have the information to hand so rely on traditional methods.
                The very slow getcwd, which spawns a process on some systems, or the
                not quite so bad getwd. */

        if (!SMB_VFS_GETWD(conn,s)) {
                DEBUG(0,("vfs_GetWd: SMB_VFS_GETWD call failed, errno %s\n",strerror(errno)));
                return (NULL);
        }

        pstrcpy(path,s);

        DEBUG(5,("vfs_GetWd %s, inode %.0f, dev %.0f\n",s,(double)st.st_ino,(double)st.st_dev));

        /* add it to the cache */
        i = MAX_GETWDCACHE - 1;
        string_set(&ino_list[i].dos_path,s);
        ino_list[i].dev = st.st_dev;
        ino_list[i].inode = st.st_ino;
        ino_list[i].valid = True;

        /* put it at the top of the list */
        array_promote((char *)&ino_list[0],sizeof(ino_list[0]),i);

        return (path);
}

NTSTATUS reduce_name	(	connection_struct *	conn,
		const pstring	fname
	)

vfs.c の 805 行で定義されています。

参照先 connection_struct::connectpath・errno・map_nt_error_from_unix()・strrchr_m().

参照元 check_name()・copy_internals()・hardlink_internals().

{
#ifdef REALPATH_TAKES_NULL
        BOOL free_resolved_name = True;
#else
#ifdef PATH_MAX
        char resolved_name_buf[PATH_MAX+1];
#else
        pstring resolved_name_buf;
#endif
        BOOL free_resolved_name = False;
#endif
        char *resolved_name = NULL;
        size_t con_path_len = strlen(conn->connectpath);
        char *p = NULL;

        DEBUG(3,("reduce_name [%s] [%s]\n", fname, conn->connectpath));

#ifdef REALPATH_TAKES_NULL
        resolved_name = SMB_VFS_REALPATH(conn,fname,NULL);
#else
        resolved_name = SMB_VFS_REALPATH(conn,fname,resolved_name_buf);
#endif

        if (!resolved_name) {
                switch (errno) {
                        case ENOTDIR:
                                DEBUG(3,("reduce_name: Component not a directory in getting realpath for %s\n", fname));
                                return map_nt_error_from_unix(errno);
                        case ENOENT:
                        {
                                pstring tmp_fname;
                                fstring last_component;
                                /* Last component didn't exist. Remove it and try and canonicalise the directory. */

                                pstrcpy(tmp_fname, fname);
                                p = strrchr_m(tmp_fname, '/');
                                if (p) {
                                        *p++ = '\0';
                                        fstrcpy(last_component, p);
                                } else {
                                        fstrcpy(last_component, tmp_fname);
                                        pstrcpy(tmp_fname, ".");
                                }

#ifdef REALPATH_TAKES_NULL
                                resolved_name = SMB_VFS_REALPATH(conn,tmp_fname,NULL);
#else
                                resolved_name = SMB_VFS_REALPATH(conn,tmp_fname,resolved_name_buf);
#endif
                                if (!resolved_name) {
                                        DEBUG(3,("reduce_name: couldn't get realpath for %s\n", fname));
                                        return map_nt_error_from_unix(errno);
                                }
                                pstrcpy(tmp_fname, resolved_name);
                                pstrcat(tmp_fname, "/");
                                pstrcat(tmp_fname, last_component);
#ifdef REALPATH_TAKES_NULL
                                SAFE_FREE(resolved_name);
                                resolved_name = SMB_STRDUP(tmp_fname);
                                if (!resolved_name) {
                                        DEBUG(0,("reduce_name: malloc fail for %s\n", tmp_fname));
                                        return NT_STATUS_NO_MEMORY;
                                }
#else
#ifdef PATH_MAX
                                safe_strcpy(resolved_name_buf, tmp_fname, PATH_MAX);
#else
                                pstrcpy(resolved_name_buf, tmp_fname);
#endif
                                resolved_name = resolved_name_buf;
#endif
                                break;
                        }
                        default:
                                DEBUG(1,("reduce_name: couldn't get realpath for %s\n", fname));
                                return map_nt_error_from_unix(errno);
                }
        }

        DEBUG(10,("reduce_name realpath [%s] -> [%s]\n", fname, resolved_name));

        if (*resolved_name != '/') {
                DEBUG(0,("reduce_name: realpath doesn't return absolute paths !\n"));
                if (free_resolved_name) {
                        SAFE_FREE(resolved_name);
                }
                return NT_STATUS_OBJECT_NAME_INVALID;
        }

        /* Check for widelinks allowed. */
        if (!lp_widelinks(SNUM(conn)) && (strncmp(conn->connectpath, resolved_name, con_path_len) != 0)) {
                DEBUG(2, ("reduce_name: Bad access attempt: %s is a symlink outside the share path", fname));
                if (free_resolved_name) {
                        SAFE_FREE(resolved_name);
                }
                return NT_STATUS_ACCESS_DENIED;
        }

        /* Check if we are allowing users to follow symlinks */
        /* Patch from David Clerc <David.Clerc@cui.unige.ch>
                University of Geneva */
                                                                                                                                                    
#ifdef S_ISLNK
        if (!lp_symlinks(SNUM(conn))) {
                SMB_STRUCT_STAT statbuf;
                if ( (SMB_VFS_LSTAT(conn,fname,&statbuf) != -1) &&
                                (S_ISLNK(statbuf.st_mode)) ) {
                        if (free_resolved_name) {
                                SAFE_FREE(resolved_name);
                        }
                        DEBUG(3,("reduce_name: denied: file path name %s is a symlink\n",resolved_name));
                        return NT_STATUS_ACCESS_DENIED;
                }
        }
#endif

        DEBUG(3,("reduce_name: %s reduced to %s\n", fname, resolved_name));
        if (free_resolved_name) {
                SAFE_FREE(resolved_name);
        }
        return NT_STATUS_OK;
}

---

変数

static_decl_vfs

vfs.c の 31 行で定義されています。

struct vfs_init_function_entry* backends = NULL [static]

vfs.c の 39 行で定義されています。

char* sparse_buf [static]

vfs.c の 535 行で定義されています。

参照元 vfs_fill_sparse().

files_struct* in_fsp [static]

vfs.c の 598 行で定義されています。

参照元 read_fn()・vfs_transfer_file().

files_struct* out_fsp [static]

vfs.c の 599 行で定義されています。

参照元 vfs_transfer_file()・write_fn().

SMB_DEV_T dev

vfs.c の 677 行で定義されています。

参照元 cmd_mknod()・downgrade_oplock()・free_dev_mode()・make_connection()・make_connection_snum()・msg_file_was_renamed()・open_file_ntcreate()・process_kernel_oplock_break()・remove_oplock()・reply_tcon()・smb_unix_mknod().

SMB_INO_T inode

vfs.c の 678 行で定義されています。

参照元 call_trans2open()・dos_attr_query()・downgrade_oplock()・msg_file_was_renamed()・open_file_ntcreate()・process_kernel_oplock_break()・remove_oplock().

char* dos_path

vfs.c の 679 行で定義されています。

参照元 vfs_GetWd().

BOOL valid

vfs.c の 680 行で定義されています。

参照元 _lsa_lookup_sids_internal()・copy_print_driver_3()・display_print_driver_3()・lookup_sids()・torture_utable()・user_ok()・vfs_GetWd().

struct { ... } ino_list[MAX_GETWDCACHE] [static]

参照元 vfs_GetWd().

BOOL use_getwd_cache

loadparm.c の 83 行で定義されています。

参照元 vfs_GetWd().

---