void scan_files(file_search_data* data)
{
size_t i;
size_t count = data->root_files.size;
int skip_symlink_dirs = !(data->options & FIND_FOLLOW_SYMLINKS);
for (i = 0; i < count && !(data->options & FIND_CANCEL); i++)
{
file_t* file = get_root_file(data, i);
assert(!!(file->mode & FILE_IFROOT));
/* check if file is a directory */
if (FILE_ISDIR(file)) {
/* silently skip symlinks to directories if required */
if (skip_symlink_dirs && FILE_ISLNK(file)) {
continue;
}
if (data->max_depth != 0) {
dir_scan(file, data);
} else if ((data->options & FIND_LOG_ERRORS) != 0) {
errno = EISDIR;
log_file_error(file->path);
}
} else {
/* process a regular file or a dash '-' path */
data->call_back(file, data->call_back_data);
}
}
}
static void dir_scan(const char* path,const char* file,file_travel_cb callback,void* user_data)
{
struct stat s;
DIR *dir;
struct dirent *dt;
char dirname[256];
dir_desc_t dir_entry;
memset(dirname, 0, 256);
strncpy(dirname,path,256);
if(stat(file, &s) < 0){
nge_print("stat error!\n");
return;
}
if(S_ISDIR(s.st_mode)){
strcpy(dirname+strlen(dirname), file);
strcpy(dirname+strlen(dirname), "/");
if((dir = opendir(file)) == NULL){
nge_print("opendir %s error!\n",file);
return;
}
if(chdir(file) < 0) {
nge_print("chdir error!\n");
return;
}
while((dt = readdir(dir)) != NULL){
if(dt->d_name[0] == '.'){
continue;
}
dir_scan(dirname,dt->d_name, callback,user_data);
}
if(chdir("..") < 0){
nge_print("chdir error!\n");
return;
}
closedir(dir);
memset(&dir_entry,0,sizeof(dir_desc_t));
sprintf(dir_entry.name,"%s",dirname);
if(dir_entry.name[strlen(dir_entry.name)-1]=='/'){
dir_entry.name[strlen(dir_entry.name)-1]= 0;
if((strcmp(dir_entry.name,file)==0)&&(strlen(dir_entry.name)==strlen(file))){
//current dir ommited
return;
}
dir_entry.flag = FIO_F_DIR;
callback(&dir_entry,user_data);
}
}else{
memset(&dir_entry,0,sizeof(dir_desc_t));
sprintf(dir_entry.name,"%s%s",dirname,file);
dir_entry.flag = FIO_F_FILE;
callback(&dir_entry,user_data);
}
}
// recursively delete everything in the specified directory
// (but not the directory itself).
// If an error occurs, delete as much as possible.
//
int client_clean_out_dir(
const char* dirpath, const char* reason, const char* except
) {
char filename[MAXPATHLEN], path[MAXPATHLEN];
int retval, final_retval = 0;
DIRREF dirp;
if (reason && log_flags.slot_debug) {
msg_printf(0, MSG_INFO, "[slot] cleaning out %s: %s", dirpath, reason);
}
dirp = dir_open(dirpath);
if (!dirp) {
#ifndef _WIN32
if (g_use_sandbox && (errno == EACCES)) {
// dir may be owned by boinc_apps
return remove_project_owned_file_or_dir(dirpath);
}
#endif
return 0; // if dir doesn't exist, it's empty
}
while (1) {
safe_strcpy(filename, "");
retval = dir_scan(filename, dirp, sizeof(filename));
if (retval) {
if (retval != ERR_NOT_FOUND) {
if (log_flags.slot_debug) {
msg_printf(0, MSG_INFO,
"[slot] dir_scan(%s) failed: %s",
dirpath, boincerror(retval)
);
}
final_retval = retval;
}
break;
}
if (except && !strcmp(except, filename)) {
continue;
}
snprintf(path, sizeof(path), "%s/%s", dirpath, filename);
if (is_dir(path)) {
retval = client_clean_out_dir(path, NULL);
if (retval) final_retval = retval;
retval = remove_project_owned_dir(path);
if (retval) final_retval = retval;
} else {
retval = delete_project_owned_file(path, false);
if (retval) final_retval = retval;
}
}
dir_close(dirp);
return final_retval;
}
int io_dir_travel(const char* directory, file_travel_cb callback,void* user_data)
{
char workdir[MAX_NAME]={0};
char backdir[MAX_NAME]={0};
getcwd(backdir,MAX_NAME);
if(directory==NULL)
return 0;
strncpy(workdir,directory,MAX_NAME);
if(workdir[strlen(workdir)-1] == '/')
workdir[strlen(workdir)-1] = 0;
dir_scan("",workdir,callback,user_data);
chdir(backdir);
return 1;
}
static void add_archives(const char *path)
{
Array archives;
int i;
if ((archives = dir_scan(path, is_archive, NULL, NULL)))
{
array_sort(archives, cmp_dir_items);
for (i = 0; i < array_len(archives); i++)
fs_add_path(DIR_ITEM_GET(archives, i)->path);
dir_free(archives);
}
}
/// Recursively delete everything in the specified directory.
/// (but not the directory itself).
/// If an error occurs, delete as much as possible.
///
/// \param[in] dirpath Path to the directory that should be cleared.
/// \return Zero on success, nonzero otherwise.
int client_clean_out_dir(const char* dirpath) {
int final_retval = 0;
DIRREF dirp;
dirp = dir_open(dirpath);
if (!dirp) {
#ifndef _WIN32
if (g_use_sandbox && (errno == EACCES)) {
// dir may be owned by boinc_apps
return remove_project_owned_file_or_dir(dirpath);
}
#endif
return 0; // if dir doesn't exist, it's empty
}
while (true) {
std::string filename;
if (dir_scan(filename, dirp)) {
break;
}
std::string path(dirpath);
path.append("/").append(filename);
int retval;
if (is_dir(path.c_str())) {
retval = client_clean_out_dir(path.c_str());
if (retval) {
final_retval = retval;
}
retval = remove_project_owned_dir(path.c_str());
if (retval) {
final_retval = retval;
}
} else {
retval = delete_project_owned_file(path.c_str(), false);
if (retval) {
final_retval = retval;
}
}
}
dir_close(dirp);
return final_retval;
}
// delete unused stuff in the slots/ directory
//
void delete_old_slot_dirs() {
char filename[1024], path[MAXPATHLEN];
DIRREF dirp;
int retval;
dirp = dir_open(SLOTS_DIR);
if (!dirp) return;
while (1) {
strcpy(filename, "");
retval = dir_scan(filename, dirp, sizeof(filename));
if (retval) break;
snprintf(path, sizeof(path), "%s/%s", SLOTS_DIR, filename);
if (is_dir(path)) {
#ifndef _WIN32
#if HAVE_SYS_SHM_H
char init_data_path[MAXPATHLEN];
SHMEM_SEG_NAME shmem_seg_name;
// If BOINC crashes or exits suddenly (e.g., due to
// being called with --exit_after_finish) it may leave
// orphan shared memory segments in the system.
// Clean these up here. (We must do this before deleting the
// INIT_DATA_FILE, if any, from each slot directory.)
//
snprintf(init_data_path, sizeof(init_data_path), "%s/%s", path, INIT_DATA_FILE);
shmem_seg_name = ftok(init_data_path, 1);
if (shmem_seg_name != -1) {
destroy_shmem(shmem_seg_name);
}
#endif
#endif
if (!gstate.active_tasks.is_slot_dir_in_use(path)) {
client_clean_out_dir(path, "delete old slot dirs");
remove_project_owned_dir(path);
}
} else {
delete_project_owned_file(path, false);
}
}
dir_close(dirp);
}
char *check_validity(
const char *certPath, const char *origFile, unsigned char *signature,
char* caPath
) {
MD5_CTX md5CTX;
int rbytes;
unsigned char md5_md[MD5_DIGEST_LENGTH], rbuf[2048];
SSL_load_error_strings();
SSL_library_init();
if (!is_file(origFile)) {
return NULL;
}
FILE* of = boinc_fopen(origFile, "r");
if (!of) return NULL;
MD5_Init(&md5CTX);
while (0 != (rbytes = (int)fread(rbuf, 1, sizeof(rbuf), of))) {
MD5_Update(&md5CTX, rbuf, rbytes);
}
MD5_Final(md5_md, &md5CTX);
fclose(of);
DIRREF dir = dir_open(certPath);
char file[MAXPATHLEN];
while (!dir_scan(file, dir, sizeof(file))) {
char fpath[MAXPATHLEN];
snprintf(fpath, sizeof(fpath), "%s/%s", certPath, file);
// TODO : replace '128'
if (check_validity_of_cert(fpath, md5_md, signature, 128, caPath)) {
dir_close(dir);
return strdup(fpath);
}
}
dir_close(dir);
return NULL;
}
// recursively delete everything in the specified directory
// (but not the directory itself).
// If an error occurs, delete as much as possible.
//
int client_clean_out_dir(const char* dirpath, const char* reason) {
char filename[256], path[256];
int retval, final_retval = 0;
DIRREF dirp;
if (reason && log_flags.slot_debug) {
msg_printf(0, MSG_INFO, "[slot] cleaning out %s: %s", dirpath, reason);
}
dirp = dir_open(dirpath);
if (!dirp) {
#ifndef _WIN32
if (g_use_sandbox && (errno == EACCES)) {
// dir may be owned by boinc_apps
return remove_project_owned_file_or_dir(dirpath);
}
#endif
return 0; // if dir doesn't exist, it's empty
}
while (1) {
strcpy(filename, "");
retval = dir_scan(filename, dirp, sizeof(filename));
if (retval) break;
sprintf(path, "%s/%s", dirpath, filename);
if (is_dir(path)) {
retval = client_clean_out_dir(path, NULL);
if (retval) final_retval = retval;
retval = remove_project_owned_dir(path);
if (retval) final_retval = retval;
} else {
retval = delete_project_owned_file(path, false);
if (retval) final_retval = retval;
}
}
dir_close(dirp);
return final_retval;
}
Array fs_dir_scan(const char *path, int (*filter)(struct dir_item *))
{
return dir_scan(path, filter, list_files, free_files);
}
