int share_file_copy_recursive(SHFL *dest_file, char *fname)
{
shfs_dirent_t *ents;
shfs_t *fs;
SHFL **files;
SHFL *dir;
struct stat st;
char spec_prefix[SHFS_PATH_MAX];
char spec_dir[SHFS_PATH_MAX];
char spec_fname[SHFS_PATH_MAX];
char path[SHFS_PATH_MAX];
char work_path[SHFS_PATH_MAX];
char buf[4096];
char *list_fname;
char *ptr;
int ent_nr;
int err;
int i;
memset(spec_prefix, 0, sizeof(spec_prefix));
ptr = strstr(fname, ":/");
if (ptr) {
ptr += 2;
strncpy(spec_prefix, fname, MIN(sizeof(spec_prefix)-1, (ptr-fname)));
fname += strlen(spec_prefix);
}
if (!strchr(fname, '/') || 0 == strncmp(fname, "./", 2)) {
if (0 == strncmp(fname, "./", 2))
fname += 2;
strcpy(spec_prefix, "file:/");
getcwd(buf, sizeof(buf)-1);
strcat(buf, "/");
strcat(buf, fname);
ptr = strrchr(buf, '/');
strncpy(spec_dir, buf + 1, strlen(buf) - strlen(ptr));
sprintf(spec_fname, "%s%s", spec_dir, ptr+1);
list_fname = basename(spec_fname);
} else {
memset(spec_fname, 0, sizeof(spec_fname));
strncpy(spec_fname, fname, sizeof(spec_fname)-1);
list_fname = basename(spec_fname);
memset(spec_dir, 0, sizeof(spec_dir));
strncpy(spec_dir, fname, MIN(strlen(fname) - strlen(list_fname), sizeof(spec_dir)-1));
}
sprintf(path, "%s%s", spec_prefix, spec_dir);
fprintf(stderr, "DEBUG: file_recursive: shfs_uri_init(%s)\n", path);
fs = shfs_uri_init(path, 0, &dir);
if (!*list_fname) {
/* directory reference. */
ent_nr = 1;
files = (SHFL **)calloc(ent_nr+1, sizeof(SHFL *));
if (!files) return (SHERR_NOMEM);
files[0] = dir;
} else {
/* search files in directory */
err = 0;
ent_nr = shfs_list(dir, list_fname, &ents);
if (ent_nr <= 0)
return (ent_nr);
err = SHERR_NOENT;
files = (SHFL **)calloc(ent_nr+1, sizeof(SHFL *));
if (!files) return (SHERR_NOMEM);
for (i = 0; i < ent_nr; i++) {
ptr = strstr(spec_dir, ":/");
if (ptr) {
sprintf(path, "%s%s", ptr+2, ents[i].d_name);
} else {
sprintf(path, "%s%s", spec_dir, ents[i].d_name);
}
err = shfs_stat(fs, path, &st);
if (err)
break;
files[i] = shfs_file_find(fs, path);
}
shfs_list_free(&ents);
if (err) {
free(files);
return (err);
}
}
#if 0
/* handle recursive hierarchy */
if ((run_flags & PFLAG_RECURSIVE)) {
for (i = 0; i < ent_nr; i++) {
if (shfs_type(files[i]) != SHINODE_DIRECTORY)
continue;
/* .. */
}
}
#endif
for (i = 0; i < ent_nr; i++) {
/* perform file copy */
err = shfs_file_copy(files[i], dest_file);
if (err) {
fprintf(sharetool_fout, "%s: error copying \"%s\" to \"%s\": %s [sherr %d].\n",
process_path, shfs_filename(files[i]), shfs_filename(dest_file),
sherrstr(err), err);
return (err);
}
if (!(run_flags & PFLAG_QUIET) && (run_flags & PFLAG_VERBOSE)) {
fprintf(sharetool_fout, "%s: %s \"%s\" copied to %s \"%s\".\n",
process_path,
shfs_type_str(shfs_type(files[i])), shfs_filename(files[i]),
shfs_type_str(shfs_type(dest_file)), shfs_filename(dest_file));
}
}
free(files);
shfs_free(&fs);
return (0);
}
int share_file_stat_recursive(SHFL *dest_file, char *fname, int *total_p)
{
shfs_dirent_t *ents;
shfs_t *fs;
SHFL **files;
SHFL *dir;
struct stat st;
char spec_prefix[SHFS_PATH_MAX];
char spec_dir[SHFS_PATH_MAX];
char spec_fname[SHFS_PATH_MAX];
char path[SHFS_PATH_MAX];
char work_path[SHFS_PATH_MAX];
char *list_fname;
char buf[4096];
char *ptr;
int ent_nr;
int err;
int i;
memset(spec_prefix, 0, sizeof(spec_prefix));
ptr = strstr(fname, ":/");
if (ptr) {
ptr += 2;
strncpy(spec_prefix, fname, MIN(sizeof(spec_prefix)-1, (ptr-fname)));
fname += strlen(spec_prefix);
}
if (!strchr(fname, '/') || 0 == strncmp(fname, "./", 2)) {
if (0 == strncmp(fname, "./", 2))
fname += 2;
strcpy(spec_prefix, "file:/");
getcwd(buf, sizeof(buf)-1);
strcat(buf, "/");
strcat(buf, fname);
ptr = strrchr(buf, '/');
strncpy(spec_dir, buf + 1, strlen(buf) - strlen(ptr));
sprintf(spec_fname, "%s%s", spec_dir, ptr+1);
list_fname = basename(spec_fname);
} else {
memset(spec_fname, 0, sizeof(spec_fname));
strncpy(spec_fname, fname, sizeof(spec_fname)-1);
list_fname = basename(spec_fname);
memset(spec_dir, 0, sizeof(spec_dir));
strncpy(spec_dir, fname, MIN(strlen(fname) - strlen(list_fname), sizeof(spec_dir)-1));
}
fprintf(stderr, "DEBUG: spec_prefix(%s) spec_dir(%s) spec_fname(%s)\n", spec_prefix, spec_dir, spec_fname);
sprintf(path, "%s%s", spec_prefix, spec_dir);
fs = shfs_uri_init(path, 0, &dir);
fprintf(stderr, "DEBUG: shfs_uri_init(%s)\n", path);
if (!*list_fname) {
/* directory reference. */
ent_nr = 1;
} else {
/* search files in directory */
err = 0;
ent_nr = shfs_list(dir, list_fname, &ents);
if (ent_nr <= 0) {
fprintf(stderr, "DEBUG: share_file_stat_recursive: shfs_list('%s'): ent_nr = %d\n", list_fname, ent_nr);
return (ent_nr);
}
err = SHERR_NOENT;
files = (SHFL **)calloc(ent_nr+1, sizeof(SHFL *));
if (!files) return (SHERR_NOMEM);
for (i = 0; i < ent_nr; i++) {
ptr = strstr(spec_dir, ":/");
if (ptr) {
sprintf(path, "%s%s", ptr+2, ents[i].d_name);
} else {
sprintf(path, "%s%s", spec_dir, ents[i].d_name);
}
err = shfs_stat(fs, path, &st);
if (err) {
fprintf(stderr, "DEBUG: share_file_stat_recursive: %d = shfs_stat('%s')\n", err, path);
break;
}
}
shfs_list_free(&ents);
if (err) {
return (err);
}
}
*total_p = ent_nr;
shfs_free(&fs);
return (0);
}
int shfs_file_remove(shfs_ino_t *file)
{
shfs_ino_t *child;
shbuf_t *buff;
shfs_dirent_t *ents;
size_t ent_max;
int fmt;
int err;
int i;
if (IS_INODE_CONTAINER(shfs_type(file))) {
ents = NULL;
ent_max = shfs_list(file, NULL, &ents);
if (ent_max < 0) {
return (ent_max);
}
if (ents) {
for (i = 0; i < ent_max; i++) {
if (IS_INODE_CONTAINER(ents[i].d_type)) {
child = shfs_inode(file, ents[i].d_name, ents[i].d_type);
err = shfs_file_remove(child);
if (err)
return (err);
} else {
child = shfs_inode(file, NULL, ents[i].d_type);
shfs_inode_clear(child);
}
}
free(ents);
} else {
/* version repository */
if (shfs_attr(file) & SHATTR_VER) {
child = shfs_inode(file, NULL, SHINODE_REPOSITORY);
err = shfs_file_remove(child);
if (err)
return (err);
}
/* specific format */
fmt = shfs_format(file);
if (fmt == SHINODE_NULL && shfs_type(file) == SHINODE_BINARY) {
fmt = SHINODE_AUX;
}
if (fmt != SHINODE_NULL) {
child = shfs_inode(file, NULL, fmt);
if (!IS_INODE_CONTAINER(shfs_type(child))) {
err = shfs_inode_clear(child);
} else {
err = shfs_file_remove(child);
}
if (err)
return (err);
}
}
}
if (shfs_type(file) != SHINODE_DIRECTORY) {
#if 0
/* DEBUG: perform inode_clear on 'fpos' index */
/* clear previous format */
err = shfs_format_set(file, SHINODE_NULL);
if (err)
return (err);
#endif
/* reset stats on file inode. */
file->blk.hdr.mtime = 0;
file->blk.hdr.size = 0;
// file->blk.hdr.type = SHINODE_NULL;
file->blk.hdr.format = SHINODE_NULL;
file->blk.hdr.attr = SHINODE_NULL;
file->blk.hdr.crc = 0;
err = shfs_inode_write_entity(file);
if (err) {
return (err);
}
}
return (0);
}
