int copy_file(char *in_path, char *out_path) {
      ssize_t c;
   // log_add(DEBUGGING, "In copy_file\n");
    process_path(in_path, out_path);
    strcat(out_filename, FORMAT);
   // log_add(DEBUGGING, "out %s\n", out_filename);
    
    if ((fdin = open(in_filename, O_RDONLY)) < 0) {
        //log_add(FATAL, "Can't open input file\n");
        return errno;
    }
    
    if (fstat(fdin, &statbuf) < 0) {
       // log_add(FATAL, "Can't determine the input file size\n");
        return errno;
    }
    
    if  ((fdout = open(out_filename, O_RDWR | O_CREAT | O_TRUNC | O_APPEND, statbuf.st_mode)) < 0 ) {
        //log_add(FATAL, "Can't create output file\n");
        return errno;
    }
    
    while((c = read(fdin, buffer, SIZE)) > 0) {
        if (write(fdout, buffer, c) < 0) {
           // log_add(FATAL, "Writing failed\n");
            return errno;
        }
    }
    
    return 0;
}
示例#2
0
/*******************************************************************************
Process a directory. Open it, read all it's entries (objects) and call
process_path for each one (EXCEPT '.' and '..') and close it.
*******************************************************************************/
void process_directory(char *pathname, regex_t *extregexpptr, int recursiondepth) {
	DIR				*dirptr;
	struct dirent	*direntptr;
	char			newpathname[MAXPATHLENGTH];
	char			dirpath[MAXPATHLENGTH];

	if (strcmp(pathname, "/")) {
		sprintf(dirpath, "%s%c", pathname, PATHDELIMITERCHAR);	/* not "/" */
	} else {
		sprintf(dirpath, "%c", PATHDELIMITERCHAR);			/* pathname is "/" */
	}

	if ((dirptr=opendir(pathname)) == (DIR*)NULL) {
		fprintf(stderr, "opendir error");
		perror(pathname);
		returncode = 1;
		return;
	}

	while ((direntptr=readdir(dirptr)) != (struct dirent *)NULL) {
		if (strcmp(direntptr->d_name, ".") && strcmp(direntptr->d_name, "..")) {
			/* create newpathname from pathname/objectname */
			sprintf(newpathname, "%s%s", dirpath, direntptr->d_name);
			process_path(newpathname, extregexpptr, recursiondepth+1);
		}
	}

	if (closedir(dirptr)) {
		perror(pathname);
		returncode = 1;
	}
}
示例#3
0
static void update_one(const char *path)
{
	if (!verify_path(path)) {
		fprintf(stderr, "Ignoring path %s\n", path);
		return;
	}
	if (mark_valid_only) {
		if (mark_ce_flags(path, CE_VALID, mark_valid_only == MARK_FLAG))
			die("Unable to mark file %s", path);
		return;
	}
	if (mark_skip_worktree_only) {
		if (mark_ce_flags(path, CE_SKIP_WORKTREE, mark_skip_worktree_only == MARK_FLAG))
			die("Unable to mark file %s", path);
		return;
	}

	if (force_remove) {
		if (remove_file_from_cache(path))
			die("git update-index: unable to remove %s", path);
		report("remove '%s'", path);
		return;
	}
	if (process_path(path))
		die("Unable to process path %s", path);
	report("add '%s'", path);
}
示例#4
0
char *sftp_find_realpath(struct allocator *a, const char *path, unsigned flags) {
  char *cwd, *abspath, *result = 0;
  size_t nresult = 0;

  D(("sftp_find_realpath '%s' %#x", path, flags));

  /* Default is current directory */
  if(path[0] == 0)
    path = ".";

  /* Convert relative paths to absolute paths */
  if(path[0] != '/') {
    if(!(cwd = sftp_getcwd(a)))
      return 0;
    assert(cwd[0] == '/');
    abspath = sftp_alloc(a, strlen(cwd) + strlen(path) + 2);
    strcpy(abspath, cwd);
    strcat(abspath, "/");
    strcat(abspath, path);
    path = abspath;
    D(("convert relative path to '%s'", path));
  }

  /* The result always starts with a / */
  result = append(a, result, &nresult, "/");

  /* All the work happens below */
  return process_path(a, result, &nresult, path, flags);
}
示例#5
0
static void update_one(const char *path, const char *prefix, int prefix_length)
{
	const char *p = prefix_path(prefix, prefix_length, path);
	if (!verify_path(p)) {
		fprintf(stderr, "Ignoring path %s\n", path);
		goto free_return;
	}
	if (mark_valid_only) {
		if (mark_valid(p))
			die("Unable to mark file %s", path);
		goto free_return;
	}

	if (force_remove) {
		if (remove_file_from_cache(p))
			die("git update-index: unable to remove %s", path);
		report("remove '%s'", path);
		goto free_return;
	}
	if (process_path(p))
		die("Unable to process path %s", path);
	report("add '%s'", path);
 free_return:
	if (p < path || p > path + strlen(path))
		free((char*)p);
}
void process_directory(const char* path) {
  /*
   * Update the number of directories seen, use opendir() to open the
   * directory, and then use readdir() to loop through the entries
   * and process them. You have to be careful not to process the
   * "." and ".." directory entries, or you'll end up spinning in
   * (infinite) loops. Also make sure you closedir() when you're done.
   *
   * You'll also want to use chdir() to move into this new directory,
   * with a matching call to chdir() to move back out of it when you're
   * done.
   */

  ++num_dirs;

  DIR *dir = opendir(path);
  struct dirent *entry;

  chdir(path);

  while((entry = readdir(dir)) != NULL) {
    if(strcmp(entry->d_name, ".") != 0 && strcmp(entry->d_name, "..") != 0) {
      process_path(entry->d_name);
    }
  }

  closedir(dir);
  chdir("..");
}
示例#7
0
文件: fs.c 项目: jpbottaro/minios
/* rename oldpath to newpath */
int fs_rename(const char *oldpath, const char *newpath)
{
    struct inode_s *dir, *last_dir, *ino;
    char path[MAX_PATH], name[MAX_NAME];

    dir = last_dir = ino = NULL;

    /* get last component of path */
    process_path(newpath, path, name);
    if (name[0] == '\0') {
        char tmp[MAX_PATH];
        process_path(oldpath, tmp, name);
    }

    dir = current_dir();
    /* get last directory of target path */
    if ( (last_dir = find_inode(dir, path, FS_SEARCH_GET)) == NULL)
        goto err;

    /* remove entry from the old directory */
    if ( (ino = find_inode(dir, oldpath, FS_SEARCH_REMOVE)) == NULL)
        goto err;

    /* new entry in the last directory of path (or old one if file exists) */
    if (add_entry(last_dir, ino->i_num, name) == ERROR)
        goto err;

    /* check if oldpath was a dir, and update '..' in that case */
    if (IS_DIR(ino->i_mode)) {
        add_entry(ino, last_dir->i_num, "..");
        last_dir->i_nlinks++;
    }

    release_inode(last_dir);
    release_inode(dir);
    release_inode(ino);

    return OK;

err:
    release_inode(last_dir);
    release_inode(dir);
    release_inode(ino);

    return ERROR;
}
示例#8
0
 //-----------------------------------------------------------------
 bool FileExists(const std::string& filename)
 {
     std::string abs;
     if (process_path(filename, abs)) {
         try {
             return fs::exists(abs);
         } catch (...) { }
     }
     return false;
 }
示例#9
0
 //-----------------------------------------------------------------
 int GetFileSize(const std::string& filename)
 {
     std::string abs;
     if (process_path(filename, abs)) {
         try {
             return (int)fs::file_size(abs);
         } catch (...) { }
     }
     return -1;
 }
示例#10
0
 //-----------------------------------------------------------------
 bool IsDirectory(const std::string& filename)
 {
     std::string abs;
     if (process_path(filename, abs)) {
         try {
             return fs::is_directory(abs);
         } catch (...) { }
     }
     return false;
 }
示例#11
0
 //-----------------------------------------------------------------
 bool CreateDirectory(const std::string& directory)
 {
     std::string abs;
     if (process_path(directory, abs)) {
         try {
             return fs::create_directory(abs);
         } catch (...) { }
     }
     return false;
 }
示例#12
0
 //-----------------------------------------------------------------
 bool IsFile(const std::string& filename)
 {
     std::string abs;
     if (process_path(filename, abs)) {
         try {
             return fs::is_regular_file(abs);
         } catch (...) { }
     }
     return false;
 }
示例#13
0
 //-----------------------------------------------------------------
 int GetFileModTime(const std::string& filename)
 {
     std::string abs;
     if (process_path(filename, abs)) {
         try {
             return (int)fs::last_write_time(abs);
         } catch (...) { }
     }
     return -1;
 }
示例#14
0
/* Initializes the driver, processes the specified arguments and reports the
 * clusters found.
 */
void process_args(int argc, char** argv)
{
    size_t i;

    memset(&recorded_dirs, 0, sizeof(DirList));

    for (i = 0;  i < BUCKET_COUNT;  i++)
        init_file_list(&buckets[i]);

    if (argc)
    {
        /* Read file names from command line */
        for (i = 0;  i < argc;  i++)
        {
            kill_trailing_slashes(argv[i]);
            process_path(argv[i], 0);
        }
    }
    else
    {
        char* path;

        /* Read file names from stdin */
        while ((path = read_path(stdin)))
        {
            kill_trailing_slashes(path);
            process_path(path, 0);
            free(path);
        }
    }

    if (unique_files_flag)
        process_uniques();
    else
        process_clusters();

    for (i = 0;  i < BUCKET_COUNT;  i++)
        free_file_list(&buckets[i]);

    free(recorded_dirs.dirs);
    memset(&recorded_dirs, 0, sizeof(DirList));
}
示例#15
0
 //-----------------------------------------------------------------
 bool RemoveFile(const std::string& filename)
 {
     std::string abs;
     if (process_path(filename, abs)) {
         try {
             fs::remove(abs);
             return true;
         } catch (...) { }
     }
     return false;
 }
示例#16
0
文件: oldfind.c 项目: hnw/iOS-FindCmd
static void do_process_top_dir (char *pathname,
				char *base,
				int mode,
				ino_t inum,
				struct stat *pstat)
{
  (void) pstat;

  process_path (pathname, base, false, ".", mode, inum);
  complete_pending_execdirs ();
}
示例#17
0
 //-----------------------------------------------------------------
 IFile* OpenFile(const std::string& filename, int mode)
 {
     std::string abs;
     if (process_path(filename, abs)) {
         RefPtr<File> file = File::Create();
         if (file->open(abs, mode)) {
             file->setName(filename);
             return file.release();
         }
     }
     return 0;
 }
示例#18
0
文件: find.c 项目: zozoh94/FindClone
void process_dir(char* pathname)
{
	DIR *dir = opendir(pathname);
	if(dir == NULL)
		fprintf(stderr,"%s: \"%s\": %s\n", program_name, pathname, strerror_l(errno, locale));
	else {
		++current_level;
		process_path(pathname);
		--current_level;
	}

	closedir(dir);
}
示例#19
0
int mozilla2john(int argc, char **argv)
{
    int i;

    if (argc < 2) {
        fprintf(stderr, "Usage: mozilla2john [key3.db files]\n");
        return -1;
    }
    for (i = 1; i < argc; i++)
        process_path(argv[i]);

    return 0;
}
void process_directory(const char* path) {
  struct dirent *dirThing;
  DIR *directory = opendir(path);
  chdir(path);

  while((dirThing = readdir(directory)) != 0){
    if(!(strcmp(dirThing->d_name, ".") == 0 || strcmp(dirThing->d_name, "..") == 0)){
       process_path(dirThing->d_name);
     }
  }
  closedir(directory);
  num_dirs++;
  chdir("..");
}
示例#21
0
 //-----------------------------------------------------------------
 bool EnumerateFiles(const std::string& directory, std::vector<std::string>& fileList)
 {
     std::string abs;
     if (process_path(directory, abs)) {
         try {
             fileList.clear();
             fs::directory_iterator end_iter;
             for (fs::directory_iterator iter(abs); iter != end_iter; ++iter) {
                 fileList.push_back(iter->path().filename());
             }
             return true;
         } catch (...) { }
     }
     return false;
 }
示例#22
0
/* On success, returns a Potrace state st with st->status ==
   POTRACE_STATUS_OK. On failure, returns NULL if no Potrace state
   could be created (with errno set), or returns an incomplete Potrace
   state (with st->status == POTRACE_STATUS_INCOMPLETE, and with errno
   set). Complete or incomplete Potrace state can be freed with
   potrace_state_free(). */
potrace_state_t *potrace_trace(const potrace_param_t *param, const potrace_bitmap_t *bm) {
  int r;
  path_t *plist = NULL;
  potrace_state_t *st;
  progress_t prog;
  progress_t subprog;
  
  /* prepare private progress bar state */
  prog.callback = param->progress.callback;
  prog.data = param->progress.data;
  prog.min = param->progress.min;
  prog.max = param->progress.max;
  prog.epsilon = param->progress.epsilon;
  prog.d_prev = param->progress.min;

  /* allocate state object */
  st = (potrace_state_t *)malloc(sizeof(potrace_state_t));
  if (!st) {
    return NULL;
  }

  progress_subrange_start(0.0, 0.1, &prog, &subprog);

  /* process the image */
  r = bm_to_pathlist(bm, &plist, param, &subprog);
  if (r) {
    free(st);
    return NULL;
  }

  st->status = POTRACE_STATUS_OK;
  st->plist = plist;
  st->priv = NULL;  /* private state currently unused */

  progress_subrange_end(&prog, &subprog);

  progress_subrange_start(0.1, 1.0, &prog, &subprog);

  /* partial success. */
  r = process_path(plist, param, &subprog);
  if (r) {
    st->status = POTRACE_STATUS_INCOMPLETE;
  }

  progress_subrange_end(&prog, &subprog);

  return st;
}
int main (int argc, char *argv[]) {
  // Ensure an argument was provided.
  if (argc != 2) {
    printf ("Usage: %s <path>\n", argv[0]);
    printf ("       where <path> is the file or root of the tree you want to summarize.\n");
    return 1;
  }
  num_dirs = 0;
  num_regular = 0;
  process_path(argv[1]);
  printf("Processed all the files from <%s>.\n", argv[1]);
  printf("There were %d directories.\n", num_dirs);
  printf("There were %d regular files.\n", num_regular);

  return 0;
}
void process_directory(const char* path) {
      ++num_dirs;    

    DIR *dir = opendir(path);
    struct dirent *entry;

    chdir(path);

    while((entry = readdir(dir)) != NULL) {
    	if(strcmp(entry->d_name, ".") != 0 && strcmp(entry->d_name, "..") != 0){
        	process_path(entry->d_name);
        }
      }
  
  closedir(dir);
  chdir("..");
}
示例#25
0
/* Recurses into a directory, collecting all or all non-hidden files,
 * according to the specified options.
 */
static void process_directory(const char* path,
                              const struct stat* sb,
                              int depth)
{
    DIR* dir;
    struct dirent* dir_entry;
    char* child_path;
    const char* name;

    if (has_recorded_directory(sb->st_dev, sb->st_ino))
        return;

    record_directory(sb->st_dev, sb->st_ino);

    dir = opendir(path);
    if (!dir)
    {
        if (!quiet_flag)
            warning("%s: %s", path, strerror(errno));

        return;
    }

    while ((dir_entry = readdir(dir)))
    {
        name = dir_entry->d_name;
        if (name[0] == '.')
        {
            if (!all_files_flag)
                continue;

            if (strcmp(name, ".") == 0 || strcmp(name, "..") == 0)
                continue;
        }

        if (asprintf(&child_path, "%s/%s", path, name) < 0)
            error(_("Out of memory"));

        process_path(child_path, depth);
        free(child_path);
    }

    closedir(dir);
}
示例#26
0
文件: fs.c 项目: jpbottaro/minios
/* create new directory */
int fs_mkdir(const char *pathname, mode_t mode)
{
    struct inode_s *ino, *dir, *tmpdir;
    char path[MAX_PATH], name[MAX_NAME];

    ino = dir = tmpdir = NULL;

    process_path(pathname, path, name);
    tmpdir = current_dir();
    /* get inode numbers from parent and new dir */
    if ( (dir = find_inode(tmpdir, path, FS_SEARCH_GET)) == NULL)
        goto err;
    release_inode(tmpdir);
    if ( (ino = find_inode(dir, name, FS_SEARCH_ADD)) == NULL)
        goto err;

    /* fill new dir inode */
    fill_inode(ino, mode);
    ino->i_mode = (ino->i_mode & ~I_TYPE) | I_DIRECTORY;

    /* add '.' */
    empty_entry(ino, ino->i_num, ".");
    ino->i_nlinks++;

    /* and '..' */
    empty_entry(ino, dir->i_num, "..");
    dir->i_nlinks++;
    dir->i_dirty = 1;

    /* update dir size */
    ino->i_size = DIRENTRY_SIZE * 2;

    release_inode(dir);
    release_inode(ino);

    return OK;

err:
    release_inode(tmpdir);
    release_inode(dir);
    release_inode(ino);

    return ERROR;
}
int extract_main(int argc, char** argv)
{
    parse_extract_options(argc, argv);
    std::ofstream ofs;
    if (not opt::output_file.empty())
    {
        ofs.open(opt::output_file);
        os_p = &ofs;
    }
    else
    {
        os_p = &std::cout;
    }
    for (unsigned i = 0; i < opt::paths.size(); ++i)
    {
        process_path(opt::paths[i]);
    }
    return 0;
}
示例#28
0
static void update_one(const char *path)
{
	int stat_errno = 0;
	struct stat st;

	if (mark_valid_only || mark_skip_worktree_only || force_remove ||
	    mark_fsmonitor_only)
		st.st_mode = 0;
	else if (lstat(path, &st) < 0) {
		st.st_mode = 0;
		stat_errno = errno;
	} /* else stat is valid */

	if (!verify_path(path, st.st_mode)) {
		fprintf(stderr, "Ignoring path %s\n", path);
		return;
	}
	if (mark_valid_only) {
		if (mark_ce_flags(path, CE_VALID, mark_valid_only == MARK_FLAG))
			die("Unable to mark file %s", path);
		return;
	}
	if (mark_skip_worktree_only) {
		if (mark_ce_flags(path, CE_SKIP_WORKTREE, mark_skip_worktree_only == MARK_FLAG))
			die("Unable to mark file %s", path);
		return;
	}
	if (mark_fsmonitor_only) {
		if (mark_ce_flags(path, CE_FSMONITOR_VALID, mark_fsmonitor_only == MARK_FLAG))
			die("Unable to mark file %s", path);
		return;
	}

	if (force_remove) {
		if (remove_file_from_cache(path))
			die("git update-index: unable to remove %s", path);
		report("remove '%s'", path);
		return;
	}
	if (process_path(path, &st, stat_errno))
		die("Unable to process path %s", path);
	report("add '%s'", path);
}
示例#29
0
文件: find.c 项目: zozoh94/FindClone
void process_top_path(char* pathname)
{
	bool free_path = false;
	//On ajoute un / à la fin du pathname si il n'en contient pas déjà un
 	if(pathname[strlen(pathname)-1] == '/') 
		path_process = pathname;
	else {
		free_path = true;
		path_process = malloc(strlen(pathname)+1);
		if(path_process == NULL) {
			error_mem();
			exit(EXIT_FAILURE);
		}
		memcpy(path_process, pathname, strlen(pathname));
		path_process[strlen(pathname)] = '/';
	}
	/*On se place dans le dossier de départ pour que les commandes suivantes comprennent
	  les chemins relatifs */
	if(chdir(path_process) != -1) { //Si l'ouverture s'est bien passé on execute process_path
		struct stat stat_file;
		if(lstat(pathname, &stat_file) != -1) {
			if(current_level >= mindepth)
				apply_predicates(pathname, &stat_file);
			if(!S_ISLNK(stat_file.st_mode))
				process_path(path_process);
		}
	}
	else {  
		if(errno == EACCES) { //Si l'ouveture ne s'est pas bien passé et que c'est un problème de permissions
			struct stat stat_file;
			if(lstat(path_process, &stat_file) != -1 && current_level >= mindepth) {
				apply_predicates(pathname, &stat_file);
			}
		}
		fprintf(stderr,"%s: \"%s\": %s\n", program_name, pathname, strerror_l(errno, locale));
	}
	if(free_path)
		free(path_process);
}
示例#30
0
文件: fs.c 项目: jpbottaro/minios
/* remove directory (only if it is empty) */
int fs_rmdir(const char *pathname)
{
    struct inode_s *ino, *dir, *tmpdir;
    char path[MAX_PATH], name[MAX_NAME];

    ino = dir = tmpdir = NULL;

    process_path(pathname, path, name);
    tmpdir = current_dir();
    /* get inode numbers from parent and new dir */
    if ( (dir = find_inode(tmpdir, path, FS_SEARCH_GET)) == NULL)
        goto err;
    release_inode(tmpdir);
    if ( (ino = find_inode(dir, name, FS_SEARCH_ADD)) == NULL)
        goto err;

    /* check if its a dir and it is empty */
    if (!IS_DIR(ino->i_mode) || ino->i_size != DIRENTRY_SIZE * 2)
        goto err;

    /* this cant give an error */
    release_inode(find_inode(dir, name, FS_SEARCH_REMOVE));

    /* free blocks and inode */
    rm_inode(ino->i_num);

    release_inode(dir);
    release_inode(ino);

    return OK;

err:
    release_inode(tmpdir);
    release_inode(dir);
    release_inode(ino);

    return ERROR;
}