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)
{
+ struct smb_filename *smb_fname_base = NULL;
char *name = NULL;
char *pathreal = NULL;
+ char *found_name = NULL;
+ int ret;
+ const char *name_temp = NULL;
+ NTSTATUS status;
+
SET_STAT_INVALID(*pst);
if (dptr->has_wild || dptr->did_stat) {
- return dptr_normal_ReadDirName(dptr, poffset, pst);
+ 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
}
if (VALID_STAT(*pst)) {
- name = dptr->wcard;
+ name = talloc_strdup(ctx, dptr->wcard);
goto ret;
}
if (!pathreal)
return NULL;
- if (SMB_VFS_STAT(dptr->conn, pathreal, pst) == 0) {
- name = dptr->wcard;
+ /* Create an smb_filename with stream_name == NULL. */
+ status = create_synthetic_smb_fname(ctx, pathreal, NULL, NULL,
+ &smb_fname_base);
+ if (!NT_STATUS_IS_OK(status)) {
+ return NULL;
+ }
+
+ if (SMB_VFS_STAT(dptr->conn, smb_fname_base) == 0) {
+ *pst = smb_fname_base->st;
+ TALLOC_FREE(smb_fname_base);
+ name = talloc_strdup(ctx, dptr->wcard);
goto clean;
} else {
+ TALLOC_FREE(smb_fname_base);
/* 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 = dptr->wcard;
+ name = talloc_strdup(ctx, dptr->wcard);
goto clean;
}
}
goto clean;
}
+ /*
+ * 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);
- return dptr_normal_ReadDirName(dptr, poffset, pst);
+ name_temp = dptr_normal_ReadDirName(dptr, poffset, pst);
+ name = talloc_strdup(ctx, name_temp);
+ return name;
clean:
TALLOC_FREE(pathreal);
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,
+ 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;
}
- if (!VALID_STAT(sbuf) && (SMB_VFS_STAT(conn, pathreal, &sbuf)) != 0) {
- DEBUG(5,("Couldn't stat 1 [%s]. Error = %s\n",
- pathreal, strerror(errno) ));
- TALLOC_FREE(pathreal);
- continue;
+ if (!VALID_STAT(sbuf)) {
+ struct smb_filename *smb_fname = NULL;
+ NTSTATUS status;
+
+ /* Create smb_fname with NULL stream_name. */
+ status =
+ create_synthetic_smb_fname(ctx, pathreal,
+ NULL, NULL,
+ &smb_fname);
+ if (!NT_STATUS_IS_OK(status)) {
+ TALLOC_FREE(pathreal);
+ TALLOC_FREE(filename);
+ return NULL;
+ }
+
+ if ((SMB_VFS_STAT(conn, smb_fname)) != 0) {
+ DEBUG(5,("Couldn't stat 1 [%s]. Error "
+ "= %s\n", pathreal,
+ strerror(errno)));
+ TALLOC_FREE(smb_fname);
+ TALLOC_FREE(pathreal);
+ TALLOC_FREE(filename);
+ continue;
+ }
+ sbuf = smb_fname->st;
+ TALLOC_FREE(smb_fname);
}
*mode = dos_mode(conn,pathreal,&sbuf);
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;
fileid = vfs_file_id_from_sbuf(conn, &sbuf);
get_file_infos(fileid, NULL, &write_time_ts);
if (!null_timespec(write_time_ts)) {
- *date = convert_timespec_to_time_t(write_time_ts);
+ *date = write_time_ts;
}
}
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)
+static bool user_can_read_file(connection_struct *conn,
+ struct smb_filename *smb_fname)
{
/*
* If user is a member of the Admin group
return True;
}
- return can_access_file_acl(conn, name, FILE_READ_DATA);
+ return can_access_file_acl(conn, smb_fname, FILE_READ_DATA);
}
/*******************************************************************
use it for anything security sensitive.
********************************************************************/
-static bool user_can_write_file(connection_struct *conn, char *name, SMB_STRUCT_STAT *pst)
+static bool user_can_write_file(connection_struct *conn,
+ const struct smb_filename *smb_fname)
{
/*
* If user is a member of the Admin group
return True;
}
- SMB_ASSERT(VALID_STAT(*pst));
+ SMB_ASSERT(VALID_STAT(smb_fname->st));
/* Pseudo-open the file */
- if(S_ISDIR(pst->st_mode)) {
+ if(S_ISDIR(smb_fname->st.st_ex_mode)) {
return True;
}
- return can_write_to_file(conn, name, pst);
+ return can_write_to_file(conn, smb_fname);
}
/*******************************************************************
Is a file a "special" type ?
********************************************************************/
-static bool file_is_special(connection_struct *conn, char *name, SMB_STRUCT_STAT *pst)
+static bool file_is_special(connection_struct *conn,
+ const struct smb_filename *smb_fname)
{
/*
* If user is a member of the Admin group
if (conn->admin_user)
return False;
- SMB_ASSERT(VALID_STAT(*pst));
+ SMB_ASSERT(VALID_STAT(smb_fname->st));
- if (S_ISREG(pst->st_mode) || S_ISDIR(pst->st_mode) || S_ISLNK(pst->st_mode))
+ if (S_ISREG(smb_fname->st.st_ex_mode) ||
+ S_ISDIR(smb_fname->st.st_ex_mode) ||
+ S_ISLNK(smb_fname->st.st_ex_mode))
return False;
return True;
bool hide_unreadable = lp_hideunreadable(SNUM(conn));
bool hide_unwriteable = lp_hideunwriteable_files(SNUM(conn));
bool hide_special = lp_hide_special_files(SNUM(conn));
+ char *entry = NULL;
+ struct smb_filename *smb_fname_base = NULL;
+ NTSTATUS status;
+ bool ret = false;
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) {
+ ret = false;
+ goto out;
}
/* 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;
+ ret = true;
+ goto out;
+ }
+
+ /* Create an smb_filename with stream_name == NULL. */
+ status = create_synthetic_smb_fname(talloc_tos(), entry, NULL,
+ pst, &smb_fname_base);
+ if (!NT_STATUS_IS_OK(status)) {
+ ret = false;
+ goto out;
}
/* 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 (!VALID_STAT(*pst) && (SMB_VFS_STAT(conn, entry, pst) != 0))
- {
- SAFE_FREE(entry);
- return True;
+ if (!VALID_STAT(*pst)) {
+ if (SMB_VFS_STAT(conn, smb_fname_base) != 0) {
+ ret = true;
+ goto out;
+ } else {
+ *pst = smb_fname_base->st;
+ }
}
/* Honour _hide unreadable_ option */
- if (hide_unreadable && !user_can_read_file(conn, entry)) {
+ if (hide_unreadable &&
+ !user_can_read_file(conn, smb_fname_base)) {
DEBUG(10,("is_visible_file: file %s is unreadable.\n",
entry ));
- SAFE_FREE(entry);
- return False;
+ ret = false;
+ goto out;
}
/* Honour _hide unwriteable_ option */
- if (hide_unwriteable && !user_can_write_file(conn, entry, pst)) {
+ if (hide_unwriteable && !user_can_write_file(conn,
+ smb_fname_base)) {
DEBUG(10,("is_visible_file: file %s is unwritable.\n",
entry ));
- SAFE_FREE(entry);
- return False;
+ ret = false;
+ goto out;
}
/* Honour _hide_special_ option */
- if (hide_special && file_is_special(conn, entry, pst)) {
+ if (hide_special && file_is_special(conn, smb_fname_base)) {
DEBUG(10,("is_visible_file: file %s is special.\n",
entry ));
- SAFE_FREE(entry);
- return False;
+ ret = false;
+ goto out;
}
- SAFE_FREE(entry);
}
- return True;
+
+ ret = true;
+ out:
+ TALLOC_FREE(smb_fname_base);
+ TALLOC_FREE(entry);
+ return ret;
}
static int smb_Dir_destructor(struct smb_Dir *dirp)