static BOOL scan_directory(connection_struct *conn, const char *path, char *name, size_t maxlength)
{
struct smb_Dir *cur_dir;
const char *dname;
BOOL mangled;
long curpos;
mangled = mangle_is_mangled(name, conn->params);
/* handle null paths */
if (*path == 0)
path = ".";
/* If we have a case-sensitive filesystem, it doesn't do us any
* good to search for a name. If a case variation of the name was
* there, then the original stat(2) would have found it.
*/
if (!(conn->fs_capabilities & FILE_CASE_SENSITIVE_SEARCH)) {
errno = ENOENT;
return False;
}
/*
* The incoming name can be mangled, and if we de-mangle it
* here it will not compare correctly against the filename (name2)
* read from the directory and then mangled by the mangle_map()
* call. We need to mangle both names or neither.
* (JRA).
*
* Fix for bug found by Dina Fine. If in case sensitive mode then
* the mangle cache is no good (3 letter extension could be wrong
* case - so don't demangle in this case - leave as mangled and
* allow the mangling of the directory entry read (which is done
* case insensitively) to match instead. This will lead to more
* false positive matches but we fail completely without it. JRA.
*/
if (mangled && !conn->case_sensitive) {
mangled = !mangle_check_cache( name, maxlength, conn->params);
}
/* open the directory */
if (!(cur_dir = OpenDir(conn, path, NULL, 0))) {
DEBUG(3,("scan dir didn't open dir [%s]\n",path));
return(False);
}
/* now scan for matching names */
curpos = 0;
while ((dname = ReadDirName(cur_dir, &curpos))) {
/* Is it dot or dot dot. */
if ((dname[0] == '.') && (!dname[1] || (dname[1] == '.' && !dname[2]))) {
continue;
}
/*
* At this point dname is the unmangled name.
* name is either mangled or not, depending on the state of the "mangled"
* variable. JRA.
*/
/*
* Check mangled name against mangled name, or unmangled name
* against unmangled name.
*/
if ((mangled && mangled_equal(name,dname,conn->params)) || fname_equal(name, dname, conn->case_sensitive)) {
/* we've found the file, change it's name and return */
safe_strcpy(name, dname, maxlength);
CloseDir(cur_dir);
return(True);
}
}
CloseDir(cur_dir);
errno = ENOENT;
return(False);
}
static bool recursive_rmdir(TALLOC_CTX *ctx,
connection_struct *conn,
struct smb_filename *smb_dname)
{
const char *dname = NULL;
char *talloced = NULL;
bool ret = True;
long offset = 0;
SMB_STRUCT_STAT st;
struct smb_Dir *dir_hnd;
SMB_ASSERT(!is_ntfs_stream_smb_fname(smb_dname));
dir_hnd = OpenDir(talloc_tos(), conn, smb_dname->base_name, NULL, 0);
if(dir_hnd == NULL)
return False;
while((dname = ReadDirName(dir_hnd, &offset, &st, &talloced))) {
struct smb_filename *smb_dname_full = NULL;
char *fullname = NULL;
bool do_break = true;
NTSTATUS status;
if (ISDOT(dname) || ISDOTDOT(dname)) {
TALLOC_FREE(talloced);
continue;
}
if (!is_visible_file(conn, smb_dname->base_name, dname, &st,
false)) {
TALLOC_FREE(talloced);
continue;
}
/* Construct the full name. */
fullname = talloc_asprintf(ctx,
"%s/%s",
smb_dname->base_name,
dname);
if (!fullname) {
errno = ENOMEM;
goto err_break;
}
status = create_synthetic_smb_fname(talloc_tos(), fullname,
NULL, NULL,
&smb_dname_full);
if (!NT_STATUS_IS_OK(status)) {
goto err_break;
}
if(SMB_VFS_LSTAT(conn, smb_dname_full) != 0) {
goto err_break;
}
if(smb_dname_full->st.st_ex_mode & S_IFDIR) {
if(!recursive_rmdir(ctx, conn, smb_dname_full)) {
goto err_break;
}
if(SMB_VFS_RMDIR(conn,
smb_dname_full->base_name) != 0) {
goto err_break;
}
} else if(SMB_VFS_UNLINK(conn, smb_dname_full) != 0) {
goto err_break;
}
/* Successful iteration. */
do_break = false;
err_break:
TALLOC_FREE(smb_dname_full);
TALLOC_FREE(fullname);
TALLOC_FREE(talloced);
if (do_break) {
ret = false;
break;
}
}
TALLOC_FREE(dir_hnd);
return ret;
}
static NTSTATUS rmdir_internals(TALLOC_CTX *ctx, files_struct *fsp)
{
connection_struct *conn = fsp->conn;
struct smb_filename *smb_dname = fsp->fsp_name;
int ret;
SMB_ASSERT(!is_ntfs_stream_smb_fname(smb_dname));
/* Might be a symlink. */
if(SMB_VFS_LSTAT(conn, smb_dname) != 0) {
return map_nt_error_from_unix(errno);
}
if (S_ISLNK(smb_dname->st.st_ex_mode)) {
/* Is what it points to a directory ? */
if(SMB_VFS_STAT(conn, smb_dname) != 0) {
return map_nt_error_from_unix(errno);
}
if (!(S_ISDIR(smb_dname->st.st_ex_mode))) {
return NT_STATUS_NOT_A_DIRECTORY;
}
ret = SMB_VFS_UNLINK(conn, smb_dname);
} else {
ret = SMB_VFS_RMDIR(conn, smb_dname->base_name);
}
if (ret == 0) {
notify_fname(conn, NOTIFY_ACTION_REMOVED,
FILE_NOTIFY_CHANGE_DIR_NAME,
smb_dname->base_name);
return NT_STATUS_OK;
}
if(((errno == ENOTEMPTY)||(errno == EEXIST)) && lp_veto_files(SNUM(conn))) {
/*
* Check to see if the only thing in this directory are
* vetoed files/directories. If so then delete them and
* retry. If we fail to delete any of them (and we *don't*
* do a recursive delete) then fail the rmdir.
*/
SMB_STRUCT_STAT st;
const char *dname = NULL;
char *talloced = NULL;
long dirpos = 0;
struct smb_Dir *dir_hnd = OpenDir(talloc_tos(), conn,
smb_dname->base_name, NULL,
0);
if(dir_hnd == NULL) {
errno = ENOTEMPTY;
goto err;
}
while ((dname = ReadDirName(dir_hnd, &dirpos, &st,
&talloced)) != NULL) {
if((strcmp(dname, ".") == 0) || (strcmp(dname, "..")==0)) {
TALLOC_FREE(talloced);
continue;
}
if (!is_visible_file(conn, smb_dname->base_name, dname,
&st, false)) {
TALLOC_FREE(talloced);
continue;
}
if(!IS_VETO_PATH(conn, dname)) {
TALLOC_FREE(dir_hnd);
TALLOC_FREE(talloced);
errno = ENOTEMPTY;
goto err;
}
TALLOC_FREE(talloced);
}
/* We only have veto files/directories.
* Are we allowed to delete them ? */
if(!lp_recursive_veto_delete(SNUM(conn))) {
TALLOC_FREE(dir_hnd);
errno = ENOTEMPTY;
goto err;
}
/* Do a recursive delete. */
RewindDir(dir_hnd,&dirpos);
while ((dname = ReadDirName(dir_hnd, &dirpos, &st,
&talloced)) != NULL) {
struct smb_filename *smb_dname_full = NULL;
char *fullname = NULL;
bool do_break = true;
NTSTATUS status;
if (ISDOT(dname) || ISDOTDOT(dname)) {
TALLOC_FREE(talloced);
continue;
}
if (!is_visible_file(conn, smb_dname->base_name, dname,
&st, false)) {
TALLOC_FREE(talloced);
continue;
}
fullname = talloc_asprintf(ctx,
"%s/%s",
smb_dname->base_name,
dname);
if(!fullname) {
errno = ENOMEM;
goto err_break;
}
status = create_synthetic_smb_fname(talloc_tos(),
fullname, NULL,
NULL,
&smb_dname_full);
if (!NT_STATUS_IS_OK(status)) {
errno = map_errno_from_nt_status(status);
goto err_break;
}
if(SMB_VFS_LSTAT(conn, smb_dname_full) != 0) {
goto err_break;
}
if(smb_dname_full->st.st_ex_mode & S_IFDIR) {
if(!recursive_rmdir(ctx, conn,
smb_dname_full)) {
goto err_break;
}
if(SMB_VFS_RMDIR(conn,
smb_dname_full->base_name) != 0) {
goto err_break;
}
} else if(SMB_VFS_UNLINK(conn, smb_dname_full) != 0) {
goto err_break;
}
/* Successful iteration. */
do_break = false;
err_break:
TALLOC_FREE(fullname);
TALLOC_FREE(smb_dname_full);
TALLOC_FREE(talloced);
if (do_break)
break;
}
TALLOC_FREE(dir_hnd);
/* Retry the rmdir */
ret = SMB_VFS_RMDIR(conn, smb_dname->base_name);
}
err:
if (ret != 0) {
DEBUG(3,("rmdir_internals: couldn't remove directory %s : "
"%s\n", smb_fname_str_dbg(smb_dname),
strerror(errno)));
return map_nt_error_from_unix(errno);
}
notify_fname(conn, NOTIFY_ACTION_REMOVED,
FILE_NOTIFY_CHANGE_DIR_NAME,
smb_dname->base_name);
return NT_STATUS_OK;
}
void DirFileProvider::Restart()
{
OpenDir(startDir);
}
/*
* Execute command.
*/
void
DoCommand(
Client_t *cli)
{
int rc;
char *cmd_name;
char *lasts;
char *msg;
rc = 0;
SetErrno = 0;
msg = cli->cmdbuf;
/*
* Extract command name.
*/
/* LINTED improper pointer/integer combination */
cmd_name = strtok_r(msg, " ", &lasts);
if (strcmp(cmd_name, SAMRFT_CMD_CONNECT) == 0) {
SendReply(cli, "%s %d %d", SAMRFT_CMD_CONNECT, 0, 0);
} else if (strcmp(cmd_name, SAMRFT_CMD_CONFIG) == 0) {
char *hostname;
int blksize;
int tcpwindowsize;
hostname = getString(&lasts);
blksize = GetCfgBlksize();
tcpwindowsize = GetCfgTcpWindowsize();
SamStrdup(cli->hostname, hostname);
rc = CreateCrew(cli, 1, blksize);
SendReply(cli, "%s %d %d %d %d",
SAMRFT_CMD_CONFIG, rc, 1, blksize, tcpwindowsize);
} else if (strcmp(cmd_name, SAMRFT_CMD_OPEN) == 0) {
char *filename;
int oflag;
SamrftCreateAttr_t creat;
filename = getString(&lasts);
oflag = getInteger(&lasts);
if (getInteger(&lasts)) {
(void) memset((char *)&creat, 0,
sizeof (SamrftCreateAttr_t));
creat.mode = getInteger(&lasts);
creat.uid = getInteger(&lasts);
creat.gid = getInteger(&lasts);
rc = OpenFile(cli, filename, oflag, &creat);
} else {
rc = OpenFile(cli, filename, oflag, NULL);
}
SendReply(cli, "%s %d %d", SAMRFT_CMD_OPEN, rc, errno);
} else if (strcmp(cmd_name, SAMRFT_CMD_DPORT) == 0) {
struct sockaddr_in data;
int seqnum;
char *addr = (char *)&data.sin_addr;
char *port = (char *)&data.sin_port;
(void) memset((char *)&data, 0, sizeof (struct sockaddr_in));
data.sin_family = AF_INET;
seqnum = getInteger(&lasts);
/*
* Addr.
*/
addr[0] = getInteger(&lasts);
addr[1] = getInteger(&lasts);
addr[2] = getInteger(&lasts);
addr[3] = getInteger(&lasts);
/*
* Port.
*/
port[0] = getInteger(&lasts);
port[1] = getInteger(&lasts);
rc = InitDataConnection(cli, "r", seqnum,
data.sin_family, (struct sockaddr *)&data);
SendReply(cli, "%s %d %d", SAMRFT_CMD_DPORT, rc, errno);
} else if (strcmp(cmd_name, SAMRFT_CMD_DPORT6) == 0) {
struct sockaddr_in6 data;
struct sockaddr_in *data4 = (struct sockaddr_in *)&data;
int i;
int seqnum;
char *addr;
char *port;
(void) memset((char *)&data, 0, sizeof (struct sockaddr_in6));
seqnum = getInteger(&lasts);
/*
* Address family.
*/
data.sin6_family = getInteger(&lasts);
if (data.sin6_family == AF_INET6) {
addr = (char *)&data.sin6_addr;
port = (char *)&data.sin6_port;
} else {
addr = (char *)&data4->sin_addr;
port = (char *)&data4->sin_port;
}
/*
* Addr.
*/
for (i = 0; i < 16; i++) {
addr[i] = getInteger(&lasts);
}
/*
* Port.
*/
port[0] = getInteger(&lasts);
port[1] = getInteger(&lasts);
rc = InitDataConnection(cli, "r", seqnum,
data.sin6_family, (struct sockaddr *)&data);
SendReply(cli, "%s %d %d", SAMRFT_CMD_DPORT6, rc, errno);
} else if (strcmp(cmd_name, SAMRFT_CMD_STOR) == 0) {
fsize_t nbytes;
nbytes = getLongLong(&lasts);
rc = ReceiveData(cli, nbytes);
} else if (strcmp(cmd_name, SAMRFT_CMD_SEND) == 0) {
size_t nbytes;
nbytes = getInteger(&lasts);
rc = ReceiveData(cli, nbytes);
SendReply(cli, "%s %d %d", SAMRFT_CMD_SEND, rc, errno);
} else if (strcmp(cmd_name, SAMRFT_CMD_RECV) == 0) {
size_t nbytes;
nbytes = getInteger(&lasts);
/*
* Process receive command from client. Send data from local
* file over data sockets to the client process.
*/
rc = SendData(cli, nbytes);
SendReply(cli, "%s %d %d", SAMRFT_CMD_RECV, rc, errno);
} else if (strcmp(cmd_name, SAMRFT_CMD_SEEK) == 0) {
off64_t setpos;
int whence;
off64_t offset;
setpos = getLongLong(&lasts);
whence = getInteger(&lasts);
rc = SeekFile(cli, setpos, whence, &offset);
SendReply(cli, "%s %d %d %lld", SAMRFT_CMD_SEEK,
rc, errno, offset);
} else if (strcmp(cmd_name, SAMRFT_CMD_FLOCK) == 0) {
int type;
type = getInteger(&lasts);
rc = FlockFile(cli, type);
SendReply(cli, "%s %d %d", SAMRFT_CMD_FLOCK, rc, errno);
} else if (strcmp(cmd_name, SAMRFT_CMD_ARCHIVEOP) == 0) {
char *path;
char *ops;
path = getString(&lasts);
ops = getString(&lasts);
rc = sam_archive(path, ops);
SendReply(cli, "%s %d %d", SAMRFT_CMD_ARCHIVEOP, rc, errno);
} else if (strcmp(cmd_name, SAMRFT_CMD_CLOSE) == 0) {
rc = CloseFile(cli);
SendReply(cli, "%s %d %d", SAMRFT_CMD_CLOSE, rc, errno);
} else if (strcmp(cmd_name, SAMRFT_CMD_UNLINK) == 0) {
char *name;
name = getString(&lasts);
rc = UnlinkFile(cli, name);
SendReply(cli, "%s %d %d", SAMRFT_CMD_UNLINK, rc, errno);
} else if (strcmp(cmd_name, SAMRFT_CMD_DISCONN) == 0) {
Trace(TR_DEBUG, "RFT disconnect, no reply: '%s'", cli->cmdbuf);
CleanupCrew(cli);
cli->disconnect = 1;
/*
* No reply.
*/
} else if (strcmp(cmd_name, SAMRFT_CMD_ISMOUNTED) == 0) {
int mounted;
char *mount_point;
mount_point = getString(&lasts);
mounted = IsMounted(cli, mount_point);
SendReply(cli, "%s %d", SAMRFT_CMD_ISMOUNTED, mounted);
} else if (strcmp(cmd_name, SAMRFT_CMD_STAT) == 0) {
struct stat64 buf;
char *filename;
filename = getString(&lasts);
(void) memset(&buf, 0, sizeof (buf));
rc = stat64(filename, &buf);
SendReply(cli, "%s %d %d %d %d %d %lld",
SAMRFT_CMD_STAT, rc, errno,
buf.st_mode, buf.st_uid, buf.st_gid, buf.st_size);
} else if (strcmp(cmd_name, SAMRFT_CMD_STATVFS) == 0) {
struct statvfs64 buf;
char *mount_point;
int offlineFiles;
fsize_t offlineFileSize;
mount_point = getString(&lasts);
offlineFiles = getInteger(&lasts);
(void) memset(&buf, 0, sizeof (buf));
rc = statvfs64(mount_point, &buf);
if (rc == 0 && (strcmp(buf.f_basetype, "samfs") == 0) &&
offlineFiles == B_TRUE) {
offlineFileSize = DiskVolsOfflineFiles(mount_point);
/*
* Adjust capacity to include size of offline files.
*/
buf.f_blocks += offlineFileSize / buf.f_frsize;
}
SendReply(cli, "%s %d %d %lld %lld %ld %s",
SAMRFT_CMD_STATVFS, rc, errno,
buf.f_bfree, buf.f_blocks, buf.f_frsize, buf.f_basetype);
} else if (strcmp(cmd_name, SAMRFT_CMD_SPACEUSED) == 0) {
char *path;
fsize_t spaceUsed;
path = getString(&lasts);
spaceUsed = DiskVolsAccumSpaceUsed(path);
SendReply(cli, "%s %d %d %lld",
SAMRFT_CMD_SPACEUSED, rc, errno, spaceUsed);
} else if (strcmp(cmd_name, SAMRFT_CMD_MKDIR) == 0) {
char *dirname;
int mode, uid, gid;
dirname = getString(&lasts);
mode = getInteger(&lasts);
uid = getInteger(&lasts);
gid = getInteger(&lasts);
rc = MkDir(cli, dirname, mode, uid, gid);
SendReply(cli, "%s %d %d", SAMRFT_CMD_MKDIR, rc, errno);
} else if (strcmp(cmd_name, SAMRFT_CMD_OPENDIR) == 0) {
char *dirname;
int dirp;
dirname = getString(&lasts);
rc = OpenDir(cli, dirname, &dirp);
SendReply(cli, "%s %d %d %d", SAMRFT_CMD_OPENDIR,
rc, errno, dirp);
} else if (strcmp(cmd_name, SAMRFT_CMD_READDIR) == 0) {
int dirp;
SamrftReaddirInfo_t dir_info;
dirp = getInteger(&lasts);
rc = ReadDir(cli, dirp, &dir_info);
if (rc == 0) {
SendReply(cli, "%s %d %d %s %d", SAMRFT_CMD_READDIR,
rc, errno, dir_info.name, dir_info.isdir);
} else {
SendReply(cli, "%s %d %d", SAMRFT_CMD_READDIR,
rc, errno);
}
} else if (strcmp(cmd_name, SAMRFT_CMD_CLOSEDIR) == 0) {
int dirp;
dirp = getInteger(&lasts);
CloseDir(cli, dirp);
SendReply(cli, "%s %d %d", SAMRFT_CMD_CLOSEDIR, 0, 0);
} else if (strcmp(cmd_name, SAMRFT_CMD_RMDIR) == 0) {
char *dirname;
dirname = getString(&lasts);
rc = RmDir(cli, dirname);
SendReply(cli, "%s %d %d", SAMRFT_CMD_CLOSEDIR, rc, errno);
} else if (strcmp(cmd_name, SAMRFT_CMD_LOADVOL) == 0) {
struct sam_rminfo rb;
int oflag;
/*
* Create sam_rminfo structure used to create
* a removable-media file.
*/
(void) memset(&rb, 0, sizeof (rb));
rb.flags = getInteger(&lasts);
(void) strncpy(rb.file_id, getString(&lasts),
sizeof (rb.file_id));
(void) strncpy(rb.owner_id, getString(&lasts),
sizeof (rb.owner_id));
(void) strncpy(rb.group_id, getString(&lasts),
sizeof (rb.group_id));
rb.n_vsns = 1;
(void) strncpy(rb.media, getString(&lasts), sizeof (rb.media));
(void) strncpy(rb.section[0].vsn, getString(&lasts),
sizeof (rb.section[0].vsn));
oflag = getInteger(&lasts);
rc = LoadVol(cli, &rb, oflag);
SendReply(cli, "%s %d %d", SAMRFT_CMD_LOADVOL, rc, errno);
} else if (strcmp(cmd_name, SAMRFT_CMD_GETVOLINFO) == 0) {
struct sam_rminfo getrm;
int eq;
rc = GetVolInfo(cli, &getrm, &eq);
SendReply(cli, "%s %d %d %d %lld %d", SAMRFT_CMD_GETVOLINFO,
rc, errno, getrm.block_size, getrm.position, eq);
} else if (strcmp(cmd_name, SAMRFT_CMD_SEEKVOL) == 0) {
int block;
block = getInteger(&lasts);
rc = SeekVol(cli, block);
SendReply(cli, "%s %d %d", SAMRFT_CMD_SEEKVOL, rc, errno);
} else if (strcmp(cmd_name, SAMRFT_CMD_UNLOADVOL) == 0) {
struct sam_ioctl_rmunload unload;
/*
* Create sam_rmunload structure used to unload
* a removable-media file.
*/
(void) memset(&unload, 0, sizeof (unload));
unload.flags = getInteger(&lasts);
rc = UnloadVol(cli, &unload);
SendReply(cli, "%s %d %d %lld", SAMRFT_CMD_UNLOADVOL,
rc, errno, unload.position);
} else {
Trace(TR_ERR, "Unknown RFT command: %s", cmd_name);
}
}
static int get_real_filename_full_scan(connection_struct *conn,
const char *path, const char *name,
bool mangled,
TALLOC_CTX *mem_ctx, char **found_name)
{
struct smb_Dir *cur_dir;
const char *dname = NULL;
char *talloced = NULL;
char *unmangled_name = NULL;
long curpos;
/* handle null paths */
if ((path == NULL) || (*path == 0)) {
path = ".";
}
/* If we have a case-sensitive filesystem, it doesn't do us any
* good to search for a name. If a case variation of the name was
* there, then the original stat(2) would have found it.
*/
if (!mangled && !(conn->fs_capabilities & FILE_CASE_SENSITIVE_SEARCH)) {
errno = ENOENT;
return -1;
}
/*
* The incoming name can be mangled, and if we de-mangle it
* here it will not compare correctly against the filename (name2)
* read from the directory and then mangled by the name_to_8_3()
* call. We need to mangle both names or neither.
* (JRA).
*
* Fix for bug found by Dina Fine. If in case sensitive mode then
* the mangle cache is no good (3 letter extension could be wrong
* case - so don't demangle in this case - leave as mangled and
* allow the mangling of the directory entry read (which is done
* case insensitively) to match instead. This will lead to more
* false positive matches but we fail completely without it. JRA.
*/
if (mangled && !conn->case_sensitive) {
mangled = !mangle_lookup_name_from_8_3(talloc_tos(), name,
&unmangled_name,
conn->params);
if (!mangled) {
/* Name is now unmangled. */
name = unmangled_name;
}
}
/* open the directory */
if (!(cur_dir = OpenDir(talloc_tos(), conn, path, NULL, 0))) {
DEBUG(3,("scan dir didn't open dir [%s]\n",path));
TALLOC_FREE(unmangled_name);
return -1;
}
/* now scan for matching names */
curpos = 0;
while ((dname = ReadDirName(cur_dir, &curpos, NULL, &talloced))) {
/* Is it dot or dot dot. */
if (ISDOT(dname) || ISDOTDOT(dname)) {
TALLOC_FREE(talloced);
continue;
}
/*
* At this point dname is the unmangled name.
* name is either mangled or not, depending on the state
* of the "mangled" variable. JRA.
*/
/*
* Check mangled name against mangled name, or unmangled name
* against unmangled name.
*/
if ((mangled && mangled_equal(name,dname,conn->params)) ||
fname_equal(name, dname, conn->case_sensitive)) {
/* we've found the file, change it's name and return */
*found_name = talloc_strdup(mem_ctx, dname);
TALLOC_FREE(unmangled_name);
TALLOC_FREE(cur_dir);
if (!*found_name) {
errno = ENOMEM;
TALLOC_FREE(talloced);
return -1;
}
TALLOC_FREE(talloced);
return 0;
}
TALLOC_FREE(talloced);
}
TALLOC_FREE(unmangled_name);
TALLOC_FREE(cur_dir);
errno = ENOENT;
return -1;
}
static BOOL notify_hash(connection_struct *conn, char *path, uint32 flags,
struct change_data *data, struct change_data *old_data)
{
SMB_STRUCT_STAT st;
pstring full_name;
char *p;
char *fname;
size_t remaining_len;
size_t fullname_len;
void *dp;
ZERO_STRUCTP(data);
if(vfs_stat(conn,path, &st) == -1)
return False;
data->modify_time = st.st_mtime;
data->status_time = st.st_ctime;
if (old_data) {
/*
* Shortcut to avoid directory scan if the time
* has changed - we always must return true then.
*/
if (old_data->modify_time != data->modify_time ||
old_data->status_time != data->status_time ) {
return True;
}
}
/*
* If we are to watch for changes that are only stored
* in inodes of files, not in the directory inode, we must
* scan the directory and produce a unique identifier with
* which we can determine if anything changed. We use the
* modify and change times from all the files in the
* directory, added together (ignoring wrapping if it's
* larger than the max time_t value).
*/
dp = OpenDir(conn, path, True);
if (dp == NULL)
return False;
data->num_entries = 0;
pstrcpy(full_name, path);
pstrcat(full_name, "/");
fullname_len = strlen(full_name);
remaining_len = sizeof(full_name) - fullname_len - 1;
p = &full_name[fullname_len];
while ((fname = ReadDirName(dp))) {
if(strequal(fname, ".") || strequal(fname, ".."))
continue;
data->num_entries++;
safe_strcpy(p, fname, remaining_len);
ZERO_STRUCT(st);
/*
* Do the stat - but ignore errors.
*/
vfs_stat(conn,full_name, &st);
/*
* Always sum the times.
*/
data->total_time += (st.st_mtime + st.st_ctime);
/*
* If requested hash the names.
*/
if (flags & (FILE_NOTIFY_CHANGE_DIR_NAME|FILE_NOTIFY_CHANGE_FILE_NAME|FILE_NOTIFY_CHANGE_FILE)) {
int i;
unsigned char tmp_hash[16];
mdfour(tmp_hash, (unsigned char *)fname, strlen(fname));
for (i=0;i<16;i++)
data->name_hash[i] ^= tmp_hash[i];
}
/*
* If requested sum the mode_t's.
*/
if (flags & (FILE_NOTIFY_CHANGE_ATTRIBUTES|FILE_NOTIFY_CHANGE_SECURITY))
data->mode_sum = st.st_mode;
}
CloseDir(dp);
return True;
}
DirFileProvider::DirFileProvider(const WCHAR* path, const WCHAR* filter) {
startDir.SetCopy(path);
if (filter && !str::Eq(filter, L"*"))
fileFilter.SetCopy(filter);
OpenDir(path);
}
void Search::SearchLoop()
{
while(true)
{
if (!DownLevel())
{
break;
}
while (SI.GetState()==SI.Ok && _srchState==Ok)
{
if (SI.IsDots())
{
SI.NextItem();
if (SI.IsDots())
{
SI.NextItem();
};
}else if (SI.IsReparsePoint())
{
if (!_fsValid && CheckWord())
{
std::wstring w(SI.GetPath());
w+=SI.GetName();
OutputString(w.c_str());
if(_srchState==Ok)
{
_directoriesFound++;
};
}
if (_srchState==Ok)
{
_directoryCount++;
SI.NextItem();
}
}else if (SI.IsDirectory())
{
if (!_fsValid && CheckWord())
{
std::wstring w(SI.GetPath());
w+=SI.GetName();
OutputString(w.c_str());
if(_srchState==Ok)
{
_directoriesFound++;
};
};
if(_srchState==Ok)
{
_directoryCount++;
OpenDir();
}
}else
{
if (CheckWord() && CheckFileSize())
{
std::wstring w(SI.GetPath());
w+=SI.GetName();
OutputString(w.c_str());
if (_srchState==Ok)
{
_filesFound++;
}
};
if(_srchState==Ok)
{
SI.NextItem();
_fileCount++;//Seems like it counts one too much, but the FindFirstFile isn't counted, so it evens out.
//This is for the windows/winsxs folder, which often stalls the whole program
if ((_fileCount%100==0)&&(clock()-_cycleTimer)>=150 && _stable)
{
SetTimer(_h,1,1,0);
return;
}
}
};
};
};
}
DOS_Drive_Cache::CFileInfo* DOS_Drive_Cache::FindDirInfo(const char* path, char* expandedPath) {
// statics
static char split[2] = { CROSS_FILESPLIT,0 };
char dir [CROSS_LEN];
char work [CROSS_LEN];
const char* start = path;
const char* pos;
CFileInfo* curDir = dirBase;
Bit16u id;
if (save_dir && (strcmp(path,save_path)==0)) {
strcpy(expandedPath,save_expanded);
return save_dir;
};
// LOG_DEBUG("DIR: Find %s",path);
// Remove base dir path
start += strlen(basePath);
strcpy(expandedPath,basePath);
// hehe, baseDir should be cached in...
if (!IsCachedIn(curDir)) {
strcpy(work,basePath);
if (OpenDir(curDir,work,id)) {
char buffer[CROSS_LEN];
char* result = 0;
strcpy(buffer,dirPath);
ReadDir(id,result);
strcpy(dirPath,buffer);
if (dirSearch[id]) {
dirSearch[id]->id = MAX_OPENDIRS;
dirSearch[id] = 0;
}
};
};
do {
// bool errorcheck = false;
pos = strchr(start,CROSS_FILESPLIT);
if (pos) { safe_strncpy(dir,start,pos-start+1); /*errorcheck = true;*/ }
else { strcpy(dir,start); };
// Path found
Bits nextDir = GetLongName(curDir,dir);
strcat(expandedPath,dir);
// Error check
/* if ((errorcheck) && (nextDir<0)) {
LOG_DEBUG("DIR: Error: %s not found.",expandedPath);
};
*/
// Follow Directory
if ((nextDir>=0) && curDir->fileList[nextDir]->isDir) {
curDir = curDir->fileList[nextDir];
strcpy (curDir->orgname,dir);
if (!IsCachedIn(curDir)) {
if (OpenDir(curDir,expandedPath,id)) {
char buffer[CROSS_LEN];
char* result = 0;
strcpy(buffer,dirPath);
ReadDir(id,result);
strcpy(dirPath,buffer);
if (dirSearch[id]) {
dirSearch[id]->id = MAX_OPENDIRS;
dirSearch[id] = 0;
}
};
}
};
if (pos) {
strcat(expandedPath,split);
start = pos+1;
}
} while (pos);
// Save last result for faster access next time
strcpy(save_path,path);
strcpy(save_expanded,expandedPath);
save_dir = curDir;
return curDir;
}
