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; }