*/
#include "includes.h"
+#include "smbd/globals.h"
/*
This module implements directory related functions for Samba.
*/
-extern struct current_user current_user;
-
/* "Special" directory offsets. */
#define END_OF_DIRECTORY_OFFSET ((long)-1)
#define START_OF_DIRECTORY_OFFSET ((long)0)
bool did_stat; /* Optimisation for non-wcard searches. */
};
-static struct bitmap *dptr_bmap;
-static struct dptr_struct *dirptrs;
-static int dirhandles_open = 0;
#define INVALID_DPTR_KEY (-3)
void init_dptrs(void)
{
- static bool dptrs_init=False;
-
- if (dptrs_init)
+ if (dptr_bmap)
return;
dptr_bmap = bitmap_allocate(MAX_DIRECTORY_HANDLES);
if (!dptr_bmap)
exit_server("out of memory in init_dptrs");
-
- dptrs_init = True;
}
/****************************************************************************
{
if (dptr->dir_hnd) {
DEBUG(4,("Idling dptr dnum %d\n",dptr->dnum));
- CloseDir(dptr->dir_hnd);
- dptr->dir_hnd = NULL;
+ TALLOC_FREE(dptr->dir_hnd);
}
}
if (dirhandles_open >= MAX_OPEN_DIRECTORIES)
dptr_idleoldest();
DEBUG(4,("dptr_get: Reopening dptr key %d\n",key));
- if (!(dptr->dir_hnd = OpenDir(dptr->conn, dptr->path, dptr->wcard, dptr->attr))) {
+ if (!(dptr->dir_hnd = OpenDir(
+ NULL, dptr->conn, dptr->path,
+ dptr->wcard, dptr->attr))) {
DEBUG(4,("dptr_get: Failed to open %s (%s)\n",dptr->path,
strerror(errno)));
return False;
bitmap_clear(dptr_bmap, dptr->dnum - 1);
- if (dptr->dir_hnd) {
- CloseDir(dptr->dir_hnd);
- }
+ TALLOC_FREE(dptr->dir_hnd);
/* Lanman 2 specific code */
SAFE_FREE(dptr->wcard);
return status;
}
- dir_hnd = OpenDir(conn, path, wcard, attr);
+ dir_hnd = OpenDir(NULL, conn, path, wcard, attr);
if (!dir_hnd) {
return map_nt_error_from_unix(errno);
}
dptr = SMB_MALLOC_P(struct dptr_struct);
if(!dptr) {
DEBUG(0,("malloc fail in dptr_create.\n"));
- CloseDir(dir_hnd);
+ TALLOC_FREE(dir_hnd);
return NT_STATUS_NO_MEMORY;
}
if(dptr->dnum == -1 || dptr->dnum > 254) {
DEBUG(0,("dptr_create: returned %d: Error - all old dirptrs in use ?\n", dptr->dnum));
SAFE_FREE(dptr);
- CloseDir(dir_hnd);
+ TALLOC_FREE(dir_hnd);
return NT_STATUS_TOO_MANY_OPENED_FILES;
}
}
if(dptr->dnum == -1 || dptr->dnum < 255) {
DEBUG(0,("dptr_create: returned %d: Error - all new dirptrs in use ?\n", dptr->dnum));
SAFE_FREE(dptr);
- CloseDir(dir_hnd);
+ TALLOC_FREE(dir_hnd);
return NT_STATUS_TOO_MANY_OPENED_FILES;
}
}
if (!dptr->wcard) {
bitmap_clear(dptr_bmap, dptr->dnum - 1);
SAFE_FREE(dptr);
- CloseDir(dir_hnd);
+ TALLOC_FREE(dir_hnd);
return NT_STATUS_NO_MEMORY;
}
if (lp_posix_pathnames() || (wcard[0] == '.' && wcard[1] == 0)) {
int dptr_CloseDir(struct dptr_struct *dptr)
{
DLIST_REMOVE(dirptrs, dptr);
- return CloseDir(dptr->dir_hnd);
+ TALLOC_FREE(dptr->dir_hnd);
+ return 0;
}
void dptr_SeekDir(struct dptr_struct *dptr, long offset)
Return the next visible file name, skipping veto'd and invisible files.
****************************************************************************/
-static const char *dptr_normal_ReadDirName(struct dptr_struct *dptr, long *poffset, SMB_STRUCT_STAT *pst)
+static const char *dptr_normal_ReadDirName(struct dptr_struct *dptr,
+ long *poffset, SMB_STRUCT_STAT *pst)
{
/* Normal search for the next file. */
const char *name;
- while ((name = ReadDirName(dptr->dir_hnd, poffset)) != NULL) {
+ while ((name = ReadDirName(dptr->dir_hnd, poffset, pst)) != NULL) {
if (is_visible_file(dptr->conn, dptr->path, name, pst, True)) {
return name;
}
Return the next visible file name, skipping veto'd and invisible files.
****************************************************************************/
-const char *dptr_ReadDirName(TALLOC_CTX *ctx,
+char *dptr_ReadDirName(TALLOC_CTX *ctx,
struct dptr_struct *dptr,
long *poffset,
SMB_STRUCT_STAT *pst)
{
+ char *name = NULL;
+ char *pathreal = NULL;
+ char *found_name = NULL;
+ int ret;
+ const char *name_temp = NULL;
+
SET_STAT_INVALID(*pst);
- if (dptr->has_wild) {
- return dptr_normal_ReadDirName(dptr, poffset, pst);
+ if (dptr->has_wild || dptr->did_stat) {
+ name_temp = dptr_normal_ReadDirName(dptr, poffset, pst);
+ name = talloc_strdup(ctx, name_temp);
+ return name;
}
- /* If poffset is -1 then we know we returned this name before and we have
- no wildcards. We're at the end of the directory. */
+ /* If poffset is -1 then we know we returned this name before and we
+ * have no wildcards. We're at the end of the directory. */
if (*poffset == END_OF_DIRECTORY_OFFSET) {
return NULL;
}
- if (!dptr->did_stat) {
- char *pathreal = NULL;
-
- /* We know the stored wcard contains no wildcard characters. See if we can match
- with a stat call. If we can't, then set did_stat to true to
- ensure we only do this once and keep searching. */
+ /* We know the stored wcard contains no wildcard characters.
+ * See if we can match with a stat call. If we can't, then set
+ * did_stat to true to ensure we only do this once and keep
+ * searching. */
+
+ dptr->did_stat = true;
+
+ /* First check if it should be visible. */
+ if (!is_visible_file(dptr->conn, dptr->path, dptr->wcard,
+ pst, true))
+ {
+ /* This only returns false if the file was found, but
+ is explicitly not visible. Set us to end of
+ directory, but return NULL as we know we can't ever
+ find it. */
+ goto ret;
+ }
- dptr->did_stat = True;
+ if (VALID_STAT(*pst)) {
+ name = talloc_strdup(ctx, dptr->wcard);
+ goto ret;
+ }
- /* First check if it should be visible. */
- if (!is_visible_file(dptr->conn, dptr->path, dptr->wcard, pst, True)) {
- /* This only returns False if the file was found, but
- is explicitly not visible. Set us to end of directory,
- but return NULL as we know we can't ever find it. */
- dptr->dir_hnd->offset = *poffset = END_OF_DIRECTORY_OFFSET;
- return NULL;
- }
+ pathreal = talloc_asprintf(ctx,
+ "%s/%s",
+ dptr->path,
+ dptr->wcard);
+ if (!pathreal)
+ return NULL;
- if (VALID_STAT(*pst)) {
- /* We need to set the underlying dir_hnd offset to -1 also as
- this function is usually called with the output from TellDir. */
- dptr->dir_hnd->offset = *poffset = END_OF_DIRECTORY_OFFSET;
- return dptr->wcard;
+ if (SMB_VFS_STAT(dptr->conn, pathreal, pst) == 0) {
+ name = talloc_strdup(ctx, dptr->wcard);
+ goto clean;
+ } else {
+ /* If we get any other error than ENOENT or ENOTDIR
+ then the file exists we just can't stat it. */
+ if (errno != ENOENT && errno != ENOTDIR) {
+ name = talloc_strdup(ctx, dptr->wcard);
+ goto clean;
}
+ }
- pathreal = talloc_asprintf(ctx,
- "%s/%s",
- dptr->path,
- dptr->wcard);
- if (!pathreal) {
- return NULL;
- }
+ /* Stat failed. We know this is authoratiative if we are
+ * providing case sensitive semantics or the underlying
+ * filesystem is case sensitive.
+ */
+ if (dptr->conn->case_sensitive ||
+ !(dptr->conn->fs_capabilities & FILE_CASE_SENSITIVE_SEARCH))
+ {
+ goto clean;
+ }
- if (SMB_VFS_STAT(dptr->conn,pathreal,pst) == 0) {
- /* We need to set the underlying dir_hnd offset to -1 also as
- this function is usually called with the output from TellDir. */
- dptr->dir_hnd->offset = *poffset = END_OF_DIRECTORY_OFFSET;
- TALLOC_FREE(pathreal);
- return dptr->wcard;
- } else {
- /* If we get any other error than ENOENT or ENOTDIR
- then the file exists we just can't stat it. */
- if (errno != ENOENT && errno != ENOTDIR) {
- /* We need to set the underlying dir_hdn offset to -1 also as
- this function is usually called with the output from TellDir. */
- dptr->dir_hnd->offset = *poffset = END_OF_DIRECTORY_OFFSET;
- TALLOC_FREE(pathreal);
- return dptr->wcard;
- }
- }
+ /*
+ * Try case-insensitive stat if the fs has the ability. This avoids
+ * scanning the whole directory.
+ */
+ ret = SMB_VFS_GET_REAL_FILENAME(dptr->conn, dptr->path, dptr->wcard,
+ ctx, &found_name);
+ if (ret == 0) {
+ name = found_name;
+ goto clean;
+ } else if (errno == ENOENT) {
+ /* The case-insensitive lookup was authoritative. */
+ goto clean;
+ }
- TALLOC_FREE(pathreal);
+ TALLOC_FREE(pathreal);
- /* Stat failed. We know this is authoratiative if we are
- * providing case sensitive semantics or the underlying
- * filesystem is case sensitive.
- */
+ name_temp = dptr_normal_ReadDirName(dptr, poffset, pst);
+ name = talloc_strdup(ctx, name_temp);
+ return name;
- if (dptr->conn->case_sensitive ||
- !(dptr->conn->fs_capabilities & FILE_CASE_SENSITIVE_SEARCH)) {
- /* We need to set the underlying dir_hnd offset to -1 also as
- this function is usually called with the output from TellDir. */
- dptr->dir_hnd->offset = *poffset = END_OF_DIRECTORY_OFFSET;
- return NULL;
- }
- }
- return dptr_normal_ReadDirName(dptr, poffset, pst);
+clean:
+ TALLOC_FREE(pathreal);
+ret:
+ /* We need to set the underlying dir_hnd offset to -1
+ * also as this function is usually called with the
+ * output from TellDir. */
+ dptr->dir_hnd->offset = *poffset = END_OF_DIRECTORY_OFFSET;
+ return name;
}
/****************************************************************************
DirCacheAdd(dptr->dir_hnd, name, offset);
}
+/****************************************************************************
+ Initialize variables & state data at the beginning of all search SMB requests.
+****************************************************************************/
+void dptr_init_search_op(struct dptr_struct *dptr)
+{
+ SMB_VFS_INIT_SEARCH_OP(dptr->conn, dptr->dir_hnd->dir);
+}
+
/****************************************************************************
Fill the 5 byte server reserved dptr field.
****************************************************************************/
char **pp_fname_out,
SMB_OFF_T *size,
uint32 *mode,
- time_t *date,
- bool check_descend)
+ struct timespec *date,
+ bool check_descend,
+ bool ask_sharemode)
{
- const char *dname = NULL;
+ char *dname = NULL;
bool found = False;
SMB_STRUCT_STAT sbuf;
char *pathreal = NULL;
- const char *filename = NULL;
+ char *filename = NULL;
bool needslash;
*pp_fname_out = NULL;
if (!mangle_is_8_3(filename, False, conn->params)) {
if (!name_to_8_3(filename,mname,False,
conn->params)) {
+ TALLOC_FREE(filename);
continue;
}
- filename = mname;
+ filename = talloc_strdup(ctx, mname);
+ if (!filename) {
+ return False;
+ }
}
if (needslash) {
dname);
}
if (!pathreal) {
+ TALLOC_FREE(filename);
return False;
}
DEBUG(5,("Couldn't stat 1 [%s]. Error = %s\n",
pathreal, strerror(errno) ));
TALLOC_FREE(pathreal);
+ TALLOC_FREE(filename);
continue;
}
if (!dir_check_ftype(conn,*mode,dirtype)) {
DEBUG(5,("[%s] attribs 0x%x didn't match 0x%x\n",filename,(unsigned int)*mode,(unsigned int)dirtype));
TALLOC_FREE(pathreal);
+ TALLOC_FREE(filename);
continue;
}
- *size = sbuf.st_size;
- *date = sbuf.st_mtime;
+ *size = sbuf.st_ex_size;
+ *date = sbuf.st_ex_mtime;
+
+ if (ask_sharemode) {
+ struct timespec write_time_ts;
+ struct file_id fileid;
+
+ fileid = vfs_file_id_from_sbuf(conn, &sbuf);
+ get_file_infos(fileid, NULL, &write_time_ts);
+ if (!null_timespec(write_time_ts)) {
+ *date = write_time_ts;
+ }
+ }
DEBUG(3,("get_dir_entry mask=[%s] found %s "
"fname=%s (%s)\n",
found = True;
- *pp_fname_out = talloc_strdup(ctx, filename);
- if (!*pp_fname_out) {
- return False;
- }
+ SMB_ASSERT(filename != NULL);
+ *pp_fname_out = filename;
DirCacheAdd(conn->dirptr->dir_hnd, dname, curoff);
TALLOC_FREE(pathreal);
}
+
+ if (!found)
+ TALLOC_FREE(filename);
}
return(found);
use it for anything security sensitive.
********************************************************************/
-static bool user_can_read_file(connection_struct *conn, char *name, SMB_STRUCT_STAT *pst)
+static bool user_can_read_file(connection_struct *conn, char *name)
{
- SEC_DESC *psd = NULL;
- files_struct *fsp;
- NTSTATUS status;
- uint32 access_granted;
-
/*
* If user is a member of the Admin group
* we never hide files from them.
return True;
}
- SMB_ASSERT(VALID_STAT(*pst));
-
- /* Pseudo-open the file (note - no fd's created). */
-
- if(S_ISDIR(pst->st_mode)) {
- status = open_directory(conn, NULL, name, pst,
- READ_CONTROL_ACCESS,
- FILE_SHARE_READ|FILE_SHARE_WRITE,
- FILE_OPEN,
- 0, /* no create options. */
- FILE_ATTRIBUTE_DIRECTORY,
- NULL, &fsp);
- } else {
- status = open_file_stat(conn, NULL, name, pst, &fsp);
- }
-
- if (!NT_STATUS_IS_OK(status)) {
- return False;
- }
-
- /* Get NT ACL -allocated in main loop talloc context. No free needed here. */
- status = SMB_VFS_FGET_NT_ACL(fsp,
- (OWNER_SECURITY_INFORMATION|GROUP_SECURITY_INFORMATION|DACL_SECURITY_INFORMATION), &psd);
- close_file(fsp, NORMAL_CLOSE);
-
- /* No access if SD get failed. */
- if (!NT_STATUS_IS_OK(status)) {
- return False;
- }
-
- return se_access_check(psd, current_user.nt_user_token, FILE_READ_DATA,
- &access_granted, &status);
+ return can_access_file_acl(conn, name, FILE_READ_DATA);
}
/*******************************************************************
static bool user_can_write_file(connection_struct *conn, char *name, SMB_STRUCT_STAT *pst)
{
- SEC_DESC *psd = NULL;
- files_struct *fsp;
- int info;
- NTSTATUS status;
- uint32 access_granted;
-
/*
* If user is a member of the Admin group
* we never hide files from them.
/* Pseudo-open the file */
- if(S_ISDIR(pst->st_mode)) {
+ if(S_ISDIR(pst->st_ex_mode)) {
return True;
- } else {
- status = open_file_ntcreate(conn, NULL, name, pst,
- FILE_WRITE_ATTRIBUTES,
- FILE_SHARE_READ|FILE_SHARE_WRITE,
- FILE_OPEN,
- 0,
- FILE_ATTRIBUTE_NORMAL,
- INTERNAL_OPEN_ONLY,
- &info, &fsp);
}
- if (!NT_STATUS_IS_OK(status)) {
- return False;
- }
-
- /* Get NT ACL -allocated in main loop talloc context. No free needed here. */
- status = SMB_VFS_FGET_NT_ACL(fsp,
- (OWNER_SECURITY_INFORMATION|GROUP_SECURITY_INFORMATION|DACL_SECURITY_INFORMATION), &psd);
- close_file(fsp, NORMAL_CLOSE);
-
- /* No access if SD get failed. */
- if (!NT_STATUS_IS_OK(status)) {
- return False;
- }
-
- return se_access_check(psd, current_user.nt_user_token, FILE_WRITE_DATA,
- &access_granted, &status);
+ return can_write_to_file(conn, name, pst);
}
/*******************************************************************
SMB_ASSERT(VALID_STAT(*pst));
- if (S_ISREG(pst->st_mode) || S_ISDIR(pst->st_mode) || S_ISLNK(pst->st_mode))
+ if (S_ISREG(pst->st_ex_mode) || S_ISDIR(pst->st_ex_mode) || S_ISLNK(pst->st_ex_mode))
return False;
return True;
}
/*******************************************************************
- Should the file be seen by the client ? NOTE: A successful return
- is no guarantee of the file's existence ... you also have to check
- whether pst is valid.
+ Should the file be seen by the client?
+ NOTE: A successful return is no guarantee of the file's existence.
********************************************************************/
-bool is_visible_file(connection_struct *conn, const char *dir_path, const char *name, SMB_STRUCT_STAT *pst, bool use_veto)
+bool is_visible_file(connection_struct *conn, const char *dir_path,
+ const char *name, SMB_STRUCT_STAT *pst, bool use_veto)
{
bool hide_unreadable = lp_hideunreadable(SNUM(conn));
bool hide_unwriteable = lp_hideunwriteable_files(SNUM(conn));
bool hide_special = lp_hide_special_files(SNUM(conn));
- SET_STAT_INVALID(*pst);
-
if ((strcmp(".",name) == 0) || (strcmp("..",name) == 0)) {
return True; /* . and .. are always visible. */
}
if (hide_unreadable || hide_unwriteable || hide_special) {
char *entry = NULL;
- if (asprintf(&entry, "%s/%s", dir_path, name) == -1) {
- return False;
+ entry = talloc_asprintf(talloc_tos(), "%s/%s", dir_path, name);
+ if (!entry)
+ return false;
}
/* If it's a dfs symlink, ignore _hide xxxx_ options */
if (lp_host_msdfs() &&
lp_msdfs_root(SNUM(conn)) &&
is_msdfs_link(conn, entry, NULL)) {
- SAFE_FREE(entry);
- return True;
+ TALLOC_FREE(entry);
+ return true;
}
/* If the file name does not exist, there's no point checking
* the configuration options. We succeed, on the basis that the
* checks *might* have passed if the file was present.
*/
- if (SMB_VFS_STAT(conn, entry, pst) != 0) {
- SAFE_FREE(entry);
- return True;
+ if (!VALID_STAT(*pst) && (SMB_VFS_STAT(conn, entry, pst) != 0))
+ {
+ TALLOC_FREE(entry);
+ return true;
}
/* Honour _hide unreadable_ option */
- if (hide_unreadable && !user_can_read_file(conn, entry, pst)) {
- DEBUG(10,("is_visible_file: file %s is unreadable.\n", entry ));
- SAFE_FREE(entry);
- return False;
+ if (hide_unreadable && !user_can_read_file(conn, entry)) {
+ DEBUG(10,("is_visible_file: file %s is unreadable.\n",
+ entry ));
+ TALLOC_FREE(entry);
+ return false;
}
/* Honour _hide unwriteable_ option */
if (hide_unwriteable && !user_can_write_file(conn, entry, pst)) {
- DEBUG(10,("is_visible_file: file %s is unwritable.\n", entry ));
- SAFE_FREE(entry);
- return False;
+ DEBUG(10,("is_visible_file: file %s is unwritable.\n",
+ entry ));
+ TALLOC_FREE(entry);
+ return false;
}
/* Honour _hide_special_ option */
if (hide_special && file_is_special(conn, entry, pst)) {
- DEBUG(10,("is_visible_file: file %s is special.\n", entry ));
- SAFE_FREE(entry);
- return False;
+ DEBUG(10,("is_visible_file: file %s is special.\n",
+ entry ));
+ TALLOC_FREE(entry);
+ return false;
}
- SAFE_FREE(entry);
+ TALLOC_FREE(entry);
}
- return True;
+ return true;
+}
+
+static int smb_Dir_destructor(struct smb_Dir *dirp)
+{
+ if (dirp->dir) {
+ SMB_VFS_CLOSEDIR(dirp->conn,dirp->dir);
+ }
+ dirhandles_open--;
+ return 0;
}
/*******************************************************************
Open a directory.
********************************************************************/
-struct smb_Dir *OpenDir(connection_struct *conn, const char *name, const char *mask, uint32 attr)
+struct smb_Dir *OpenDir(TALLOC_CTX *mem_ctx, connection_struct *conn,
+ const char *name, const char *mask, uint32 attr)
{
- struct smb_Dir *dirp = SMB_MALLOC_P(struct smb_Dir);
+ struct smb_Dir *dirp = TALLOC_ZERO_P(mem_ctx, struct smb_Dir);
if (!dirp) {
return NULL;
}
- ZERO_STRUCTP(dirp);
dirp->conn = conn;
dirp->name_cache_size = lp_directory_name_cache_size(SNUM(conn));
- dirp->dir_path = SMB_STRDUP(name);
+ dirp->dir_path = talloc_strdup(dirp, name);
if (!dirp->dir_path) {
+ errno = ENOMEM;
goto fail;
}
+
+ dirhandles_open++;
+ talloc_set_destructor(dirp, smb_Dir_destructor);
+
dirp->dir = SMB_VFS_OPENDIR(conn, dirp->dir_path, mask, attr);
if (!dirp->dir) {
- DEBUG(5,("OpenDir: Can't open %s. %s\n", dirp->dir_path, strerror(errno) ));
+ DEBUG(5,("OpenDir: Can't open %s. %s\n", dirp->dir_path,
+ strerror(errno) ));
goto fail;
}
- dirhandles_open++;
return dirp;
fail:
-
- if (dirp) {
- if (dirp->dir) {
- SMB_VFS_CLOSEDIR(conn,dirp->dir);
- }
- SAFE_FREE(dirp->dir_path);
- SAFE_FREE(dirp->name_cache);
- SAFE_FREE(dirp);
- }
+ TALLOC_FREE(dirp);
return NULL;
}
-
-/*******************************************************************
- Close a directory.
-********************************************************************/
-
-int CloseDir(struct smb_Dir *dirp)
-{
- int i, ret = 0;
-
- if (dirp->dir) {
- ret = SMB_VFS_CLOSEDIR(dirp->conn,dirp->dir);
- }
- SAFE_FREE(dirp->dir_path);
- if (dirp->name_cache) {
- for (i = 0; i < dirp->name_cache_size; i++) {
- SAFE_FREE(dirp->name_cache[i].name);
- }
- }
- SAFE_FREE(dirp->name_cache);
- SAFE_FREE(dirp);
- dirhandles_open--;
- return ret;
-}
-
/*******************************************************************
- Read from a directory. Also return current offset.
+ Read from a directory.
+ Return directory entry, current offset, and optional stat information.
Don't check for veto or invisible files.
********************************************************************/
-const char *ReadDirName(struct smb_Dir *dirp, long *poffset)
+const char *ReadDirName(struct smb_Dir *dirp, long *poffset,
+ SMB_STRUCT_STAT *sbuf)
{
const char *n;
connection_struct *conn = dirp->conn;
/* Cheat to allow . and .. to be the first entries returned. */
- if (((*poffset == START_OF_DIRECTORY_OFFSET) || (*poffset == DOT_DOT_DIRECTORY_OFFSET)) && (dirp->file_number < 2)) {
+ if (((*poffset == START_OF_DIRECTORY_OFFSET) ||
+ (*poffset == DOT_DOT_DIRECTORY_OFFSET)) && (dirp->file_number < 2))
+ {
if (dirp->file_number == 0) {
n = ".";
*poffset = dirp->offset = START_OF_DIRECTORY_OFFSET;
SeekDir(dirp, *poffset);
}
- while ((n = vfs_readdirname(conn, dirp->dir))) {
+ while ((n = vfs_readdirname(conn, dirp->dir, sbuf))) {
/* Ignore . and .. - we've already returned them. */
if (*n == '.') {
if ((n[1] == '\0') || (n[1] == '.' && n[2] == '\0')) {
}
if (dirp->name_cache == NULL) {
- dirp->name_cache = SMB_CALLOC_ARRAY(struct name_cache_entry,
- dirp->name_cache_size);
+ dirp->name_cache = TALLOC_ZERO_ARRAY(
+ dirp, struct name_cache_entry, dirp->name_cache_size);
if (dirp->name_cache == NULL) {
return;
dirp->name_cache_index = (dirp->name_cache_index+1) %
dirp->name_cache_size;
e = &dirp->name_cache[dirp->name_cache_index];
- SAFE_FREE(e->name);
- e->name = SMB_STRDUP(name);
+ TALLOC_FREE(e->name);
+ e->name = talloc_strdup(dirp, name);
e->offset = offset;
}
SMB_VFS_REWINDDIR(conn, dirp->dir);
dirp->file_number = 0;
*poffset = START_OF_DIRECTORY_OFFSET;
- while ((entry = ReadDirName(dirp, poffset))) {
+ while ((entry = ReadDirName(dirp, poffset, NULL))) {
if (conn->case_sensitive ? (strcmp(entry, name) == 0) : strequal(entry, name)) {
return True;
}
NTSTATUS status = NT_STATUS_OK;
long dirpos = 0;
const char *dname;
- struct smb_Dir *dir_hnd = OpenDir(conn, dirname, NULL, 0);
+ SMB_STRUCT_STAT st;
+ struct smb_Dir *dir_hnd = OpenDir(talloc_tos(), conn, dirname,
+ NULL, 0);
if (!dir_hnd) {
return map_nt_error_from_unix(errno);
}
- while ((dname = ReadDirName(dir_hnd,&dirpos))) {
- SMB_STRUCT_STAT st;
-
+ while ((dname = ReadDirName(dir_hnd, &dirpos, &st))) {
/* Quick check for "." and ".." */
if (dname[0] == '.') {
if (!dname[1] || (dname[1] == '.' && !dname[2])) {
continue;
}
- DEBUG(10,("can_delete_directory: got name %s - can't delete\n", dname ));
+ DEBUG(10,("can_delete_directory: got name %s - can't delete\n",
+ dname ));
status = NT_STATUS_DIRECTORY_NOT_EMPTY;
break;
}
- CloseDir(dir_hnd);
+ TALLOC_FREE(dir_hnd);
return status;
}