char * list(gfarm_stringlist *paths, gfs_glob_t *types, int *need_newline) { char *e, *e_save = NULL; gfarm_stringlist dirs, files; int i, nfiles, ndirs; if (option_directory_itself) { return (list_files("", gfarm_stringlist_length(paths), GFARM_STRINGLIST_STRARRAY(*paths), need_newline)); } e = gfarm_stringlist_init(&dirs); if (e != NULL) { fprintf(stderr, "%s: %s\n", program_name, e); return (e); } e = gfarm_stringlist_init(&files); if (e != NULL) { fprintf(stderr, "%s: %s\n", program_name, e); gfarm_stringlist_free(&dirs); return (e); } for (i = 0; i < gfarm_stringlist_length(paths); i++) { char *path = gfarm_stringlist_elem(paths, i); if (gfs_glob_elem(types, i) == GFS_DT_DIR) gfarm_stringlist_add(&dirs, path); else gfarm_stringlist_add(&files, path); } nfiles = gfarm_stringlist_length(&files); ndirs = gfarm_stringlist_length(&dirs); if (nfiles > 0) { e = list_files("", nfiles, GFARM_STRINGLIST_STRARRAY(files), need_newline); /* warning is already printed in list_files() */ if (e_save == NULL) e_save = e; } gfarm_stringlist_free(&files); if (nfiles == 0 && ndirs == 1) { e = list_dir("", gfarm_stringlist_elem(&dirs, 0), need_newline); /* warning is already printed in list_dir() */ } else { e = list_dirs("", ndirs, GFARM_STRINGLIST_STRARRAY(dirs), need_newline); /* warning is already printed in list_dirs() */ } if (e_save == NULL) e_save = e; gfarm_stringlist_free(&dirs); return (e_save); }
static gfarm_error_t gfarm_hash_to_string_array(struct gfarm_hash_table *hash, int *array_lengthp, char ***arrayp) { struct gfarm_hash_iterator iter; struct gfarm_hash_entry *entry; gfarm_stringlist ls; char *ent, **array; gfarm_error_t e; e = gfarm_stringlist_init(&ls); if (e != GFARM_ERR_NO_ERROR) return (e); for (gfarm_hash_iterator_begin(hash, &iter); !gfarm_hash_iterator_is_end(&iter); gfarm_hash_iterator_next(&iter)) { entry = gfarm_hash_iterator_access(&iter); if (entry != NULL) { ent = strdup(gfarm_hash_entry_key(entry)); if (ent == NULL) e = GFARM_ERR_NO_MEMORY; else e = gfarm_stringlist_add(&ls, ent); } if (e != GFARM_ERR_NO_ERROR) goto stringlist_free; } array = gfarm_strings_alloc_from_stringlist(&ls); if (array == NULL) { e = GFARM_ERR_NO_MEMORY; goto stringlist_free; } *array_lengthp = gfarm_stringlist_length(&ls); *arrayp = array; stringlist_free: if (e == GFARM_ERR_NO_ERROR) gfarm_stringlist_free(&ls); else gfarm_stringlist_free_deeply(&ls); return (e); }
int main(int argc, char **argv) { int argc_save = argc; char **argv_save = argv; gfarm_error_t e, e_save = GFARM_ERR_NO_ERROR; int i, n, ch, opt_recursive = 0; gfarm_stringlist paths; gfs_glob_t types; if (argc >= 1) program_name = basename(argv[0]); while ((ch = getopt(argc, argv, "rR?")) != -1) { switch (ch) { case 'r': case 'R': opt_recursive = 1; break; case '?': default: usage(); } } argc -= optind; argv += optind; e = gfarm_initialize(&argc_save, &argv_save); if (e != GFARM_ERR_NO_ERROR) { fprintf(stderr, "%s: %s\n", program_name, gfarm_error_string(e)); exit(1); } if (argc == 0) { usage(); } e = gfarm_stringlist_init(&paths); if (e != GFARM_ERR_NO_ERROR) { fprintf(stderr, "%s: %s\n", program_name, gfarm_error_string(e)); exit(EXIT_FAILURE); } e = gfs_glob_init(&types); if (e != GFARM_ERR_NO_ERROR) { fprintf(stderr, "%s: %s\n", program_name, gfarm_error_string(e)); exit(EXIT_FAILURE); } for (i = 0; i < argc; i++) gfs_glob(argv[i], &paths, &types); gfs_glob_free(&types); n = gfarm_stringlist_length(&paths); for (i = 0; i < n; i++) { char *p = gfarm_stringlist_elem(&paths, i); struct gfs_stat st; if ((e = gfs_stat(p, &st)) != GFARM_ERR_NO_ERROR) { fprintf(stderr, "%s: %s\n", p, gfarm_error_string(e)); } else { if (GFARM_S_ISREG(st.st_mode)) e = display_replica_catalog(p, &st, NULL); else if (opt_recursive) e = gfarm_foreach_directory_hierarchy( display_replica_catalog, display_name, NULL, p, NULL); else fprintf(stderr, "%s: not a file\n", p); gfs_stat_free(&st); if (e_save == GFARM_ERR_NO_ERROR) e_save = e; } } gfarm_stringlist_free_deeply(&paths); e = gfarm_terminate(); if (e != GFARM_ERR_NO_ERROR) { fprintf(stderr, "%s: %s\n", program_name, gfarm_error_string(e)); exit(1); } return (e_save == GFARM_ERR_NO_ERROR ? 0 : 1); }
int main(int argc, char *argv[]) { char *src_hostfile = NULL, *dst_hostfile = NULL; gfarm_stringlist paths; gfs_glob_t types; int mode_src_ch = 0, mode_dst_ch = 0, parallel = -1; int i, ch; gfarm_error_t e; const char *errmsg, *errmsg2 = NULL; struct gfrep_arg gfrep_arg; struct flist flist; if (argc >= 1) program_name = basename(argv[0]); memset(&gfrep_arg, 0, sizeof(gfrep_arg)); memset(&flist, 0, sizeof(flist)); flist.src_domain = ""; flist.dst_domain = ""; e = gfarm_initialize(&argc, &argv); error_check(e); #ifdef _OPENMP while ((ch = getopt(argc, argv, "h:j:mnqvxS:D:H:N:?")) != -1) { #else while ((ch = getopt(argc, argv, "h:mnqvxS:D:H:N:?")) != -1) { #endif switch (ch) { case 'h': src_hostfile = optarg; conflict_check(&mode_src_ch, ch); break; #ifdef _OPENMP case 'j': parallel = strtol(optarg, NULL, 0); break; #endif case 'm': act = &migrate_mode; break; case 'n': opt_noexec = 1; break; case 'q': opt_quiet = 1; break; case 'v': opt_verbose = 1; break; case 'x': opt_remove = 1; break; case 'S': flist.src_domain = optarg; conflict_check(&mode_src_ch, ch); break; case 'D': flist.dst_domain = optarg; conflict_check(&mode_dst_ch, ch); break; case 'H': dst_hostfile = optarg; conflict_check(&mode_dst_ch, ch); break; case 'N': opt_nrep = strtol(optarg, NULL, 0); break; case '?': default: usage(); } } argc -= optind; argv += optind; /* make writing-to-stderr atomic, for GfarmFS-FUSE log output */ setvbuf(stderr, NULL, _IOLBF, 0); if (!opt_quiet) { printf("constructing file list..."); fflush(stdout); } e = gfarm_stringlist_init(&paths); if (e == GFARM_ERR_NO_ERROR) { e = gfs_glob_init(&types); if (e == GFARM_ERR_NO_ERROR) { for (i = 0; i < argc; i++) gfs_glob(argv[i], &paths, &types); gfs_glob_free(&types); } } error_check(e); e = gfarm_list_init(&flist.slist); error_check(e); e = gfarm_list_init(&flist.dlist); error_check(e); flist.srchash = gfarm_hash_table_alloc(HOSTHASH_SIZE, gfarm_hash_casefold, gfarm_hash_key_equal_casefold); if (flist.srchash == NULL) error_check(GFARM_ERR_NO_MEMORY); e = create_hosthash_from_file(src_hostfile, HOSTHASH_SIZE, &flist.src_hosthash); error_check(e); e = create_hosthash_from_file(dst_hostfile, HOSTHASH_SIZE, &flist.dst_hosthash); error_check(e); for (i = 0; i < gfarm_stringlist_length(&paths); i++) { char *file = gfarm_stringlist_elem(&paths, i), *realpath = NULL; e = gfarm_realpath_by_gfarm2fs(file, &realpath); if (e == GFARM_ERR_NO_ERROR) file = realpath; e = gfarm_foreach_directory_hierarchy( create_filelist, NULL, NULL, file, &flist); free(realpath); if (e != GFARM_ERR_NO_ERROR) break; } gfarm_stringlist_free_deeply(&paths); error_check(e); if (!opt_quiet) printf(" done\n"); if (opt_verbose) { printf("files to be replicated\n"); print_file_list(&flist.slist); } if (opt_verbose && opt_remove) { printf("files having too many replicas\n"); print_file_list(&flist.dlist); } if (gfarm_list_length(&flist.slist) <= 0 && (!opt_remove || gfarm_list_length(&flist.dlist) <= 0)) exit(0); /* no file */ /* replicate files */ e = gfarm_hash_to_string_array( flist.srchash, &gfrep_arg.nsrc, &gfrep_arg.src); error_check(e); gfarm_hash_table_free(flist.srchash); if (!opt_quiet) { printf("investigating hosts..."); fflush(stdout); } e = create_hostlist_by_domain_and_hash( gfarm_list_length(&flist.slist) > 0 ? gfarm_list_elem(&flist.slist, 0) : gfarm_list_elem(&flist.dlist, 0), flist.dst_domain, flist.dst_hosthash, &gfrep_arg.ndst, &gfrep_arg.dst, &gfrep_arg.dst_port); error_check(e); if (!opt_quiet) printf(" done\n"); errmsg = pfor_list(act, &flist.slist, parallel, &gfrep_arg); gfarm_list_free(&flist.slist); /* remove file replicas */ if (opt_remove) errmsg2 = pfor_list( &remove_mode, &flist.dlist, parallel, &gfrep_arg); gfarm_list_free(&flist.dlist); if (errmsg == NULL) errmsg = errmsg2; if (errmsg != NULL) fprintf(stderr, "%s\n", errmsg), exit(EXIT_FAILURE); gfarm_strings_free_deeply(gfrep_arg.nsrc, gfrep_arg.src); gfarm_strings_free_deeply(gfrep_arg.ndst, gfrep_arg.dst); free(gfrep_arg.dst_port); e = gfarm_terminate(); error_check(e); return (0); }
char * gfarm_import_fragment_config_read(char *config, int *np, char ***hosttabp, file_offset_t **sizetabp, int *error_linep) { char *e, **host_table, line[1024]; int i, table_size = TABLE_SIZE_INITIAL; file_offset_t *size_table = malloc(sizeof(size_table[0]) * table_size); file_offset_t *stab; gfarm_stringlist host_list; FILE *fp; *error_linep = -1; if (size_table == NULL) return (GFARM_ERR_NO_MEMORY); e = gfarm_stringlist_init(&host_list); if (e != NULL) { free(size_table); return (e); } if (strcmp(config, "-") == 0) { fp = stdin; } else if ((fp = fopen(config, "r")) == NULL) { gfarm_stringlist_free(&host_list); free(size_table); return (GFARM_ERR_NO_SUCH_OBJECT); } for (i = 0; fgets(line, sizeof(line), fp) != NULL; i++) { int l = strlen(line); char *s, *t, *host; file_offset_t size; if (l > 0 && line[l - 1] == '\n') line[--l] = '\0'; size = string_to_file_offset(line, &s); if (s == line) { e = "fragment size expected"; *error_linep = i + 1; goto error; } while (isspace(*s)) s++; if (*s == '\0') { e = "fragment hostname expected"; *error_linep = i + 1; goto error; } for (t = s; *t != '\0' && !isspace(*t); t++) ; *t = '\0'; host = strdup(s); if (host == NULL) { e = GFARM_ERR_NO_MEMORY; *error_linep = i + 1; goto error; } e = gfarm_stringlist_add(&host_list, host); if (e != NULL) { *error_linep = i + 1; goto error; } if (i >= table_size) { table_size += TABLE_SIZE_DELTA; stab = realloc(size_table, sizeof(size_table[0]) * table_size); if (stab == NULL) { e = GFARM_ERR_NO_MEMORY; *error_linep = i + 1; goto error; } size_table = stab; } size_table[i] = size; } if (i == 0) { e = "empty file"; goto error; } host_table = gfarm_strings_alloc_from_stringlist(&host_list); if (host_table == NULL) { e = GFARM_ERR_NO_MEMORY; goto error; } if (i < table_size) { stab = realloc(size_table, sizeof(size_table[0]) * i); if (stab == NULL) { e = GFARM_ERR_NO_MEMORY; goto error; } memcpy(stab, size_table, sizeof(size_table[0]) * i); size_table = stab; } /* * do not call gfarm_stringlist_free_deeply() here, * because the strings are passed to *host_table. */ gfarm_stringlist_free(&host_list); /* no limit on last fragment */ size_table[i - 1] = FILE_OFFSET_T_MAX; *np = i; *hosttabp = host_table; *sizetabp = size_table; if (strcmp(config, "-") != 0) fclose(fp); return (NULL); error: if (strcmp(config, "-") != 0) fclose(fp); gfarm_stringlist_free_deeply(&host_list); free(size_table); return (e); }
char * gfarm_hostlist_read(char *filename, int *np, char ***host_table_p, int *error_linep) { gfarm_stringlist host_list; FILE *fp; int i; char *e, line[1024]; *error_linep = -1; e = gfarm_stringlist_init(&host_list); if (e != NULL) return (e); if (strcmp(filename, "-") == 0) { fp = stdin; } else if ((fp = fopen(filename, "r")) == NULL) { gfarm_stringlist_free(&host_list); return (GFARM_ERR_NO_SUCH_OBJECT); } for (i = 0; fgets(line, sizeof(line), fp) != NULL; i++) { int l = strlen(line); char *s, *t, *host; if (l > 0 && line[l - 1] == '\n') line[--l] = '\0'; for (s = line; isspace(*s); s++) ; if (*s == '\0') { e = "hostname expected"; *error_linep = i + 1; goto error; } for (t = s; *t != '\0' && !isspace(*t); t++) ; *t = '\0'; host = strdup(s); if (host == NULL) { e = GFARM_ERR_NO_MEMORY; *error_linep = i + 1; goto error; } e = gfarm_stringlist_add(&host_list, host); if (e != NULL) { free(host); *error_linep = i + 1; goto error; } } if (i == 0) { e = "empty file"; goto error; } *np = gfarm_stringlist_length(&host_list); *host_table_p = gfarm_strings_alloc_from_stringlist(&host_list); if (e != NULL) goto error; /* * do not call gfarm_stringlist_free_deeply() here, * because the strings are passed to *host_table. */ gfarm_stringlist_free(&host_list); if (strcmp(filename, "-") != 0) fclose(fp); return (NULL); error: if (strcmp(filename, "-") != 0) fclose(fp); gfarm_stringlist_free_deeply(&host_list); return (e); }
static void remove_cwd_entries() { char *e; char cwdbf[PATH_MAX * 2]; int i; GFS_Dir dir; struct gfs_dirent *entry; gfarm_stringlist entry_list; e = gfs_getcwd(cwdbf, sizeof(cwdbf)); if (e != NULL) { fprintf(stderr, "%s\n", e); return; } e = gfs_opendir(".", &dir); if (e != NULL) { fprintf(stderr, "%s: %s\n", cwdbf, e); return; } e = gfarm_stringlist_init(&entry_list); if (e != NULL) { fprintf(stderr, "%s: %s\n", cwdbf, e); return; } while ((e = gfs_readdir(dir, &entry)) == NULL && entry != NULL) { char *p; if (entry->d_name[0] == '.' && (entry->d_name[1] == '\0' || (entry->d_name[1] == '.' && entry->d_name[2] == '\0'))) continue; /* "." or ".." */ p = strdup(entry->d_name); if (p == NULL) { fprintf(stderr, "%s\n", GFARM_ERR_NO_MEMORY); exit (1); } e = gfarm_stringlist_add(&entry_list, p); if (e != NULL) { fprintf(stderr, "%s/%s: %s\n", cwdbf, entry->d_name, e); } } if (e != NULL) fprintf(stderr, "%s: %s\n", cwdbf, e); gfs_closedir(dir); for (i = 0; i < gfarm_stringlist_length(&entry_list); i++) { struct gfs_stat gs; char *path = gfarm_stringlist_elem(&entry_list, i); e = gfs_stat(path, &gs); if (e != NULL) { fprintf(stderr, "%s/%s: %s\n", cwdbf, path, e); continue; } if (GFARM_S_ISREG(gs.st_mode)) { char *url; url = gfarm_url_prefix_add(path); if (url == NULL) { fprintf(stderr, "%s\n", GFARM_ERR_NO_MEMORY); exit (1); } e = gfs_unlink(url); if (e != NULL) fprintf(stderr, "%s/%s: %s\n", cwdbf, path, e); free(url); } else if (GFARM_S_ISDIR(gs.st_mode)) { e = gfs_chdir(path); if (e != NULL) { fprintf(stderr, "%s/%s: %s\n", cwdbf, path, e); continue; } remove_cwd_entries(); e = gfs_chdir(".."); if (e != NULL) { fprintf(stderr, "%s: %s\n", cwdbf, e); exit (1); } e = gfs_rmdir(path); if (e != NULL) fprintf(stderr, "%s/%s: %s\n", cwdbf, path, e); } gfs_stat_free(&gs); } gfarm_stringlist_free_deeply(&entry_list); }
int main(int argc, char **argv) { extern char *optarg; extern int optind; int argc_save = argc; char **argv_save = argv; char *e, *section = NULL; int i, ch, error = 0; gfarm_stringlist paths; gfs_glob_t types; int argc_expanded; if (argc >= 1) program_name = basename(argv[0]); while ((ch = getopt(argc, argv, "I:")) != -1) { switch (ch) { case 'I': section = optarg; break; case '?': default: usage(); } } argc -= optind; argv += optind; e = gfarm_initialize(&argc_save, &argv_save); if (e != NULL) { fprintf(stderr, "%s: %s\n", program_name, e); exit(1); } if (argc == 0) { usage(); } e = gfarm_stringlist_init(&paths); if (e != NULL) { fprintf(stderr, "%s: %s\n", program_name, e); exit(EXIT_FAILURE); } e = gfs_glob_init(&types); if (e != NULL) { fprintf(stderr, "%s: %s\n", program_name, e); exit(EXIT_FAILURE); } for (i = 0; i < argc; i++) gfs_glob(argv[i], &paths, &types); argc_expanded = gfarm_stringlist_length(&paths); for (i = 0; i < argc_expanded; i++) { char *p = gfarm_stringlist_elem(&paths, i); if (argc_expanded > 1) printf("%s:\n", p); if (display_replica_catalog_section(p, section) != NULL) error = 1; if (argc_expanded > 1 && i < argc_expanded - 1) printf("\n"); } gfs_glob_free(&types); gfarm_stringlist_free_deeply(&paths); e = gfarm_terminate(); if (e != NULL) { fprintf(stderr, "%s: %s\n", program_name, e); exit(1); } return (error); }
int main(int argc, char *argv[]) { extern int optind; int c, i, error = 0; gfarm_stringlist paths; gfs_glob_t types; char *e; if (argc <= 1) usage(); program_name = basename(argv[0]); while ((c = getopt(argc, argv, "hv?")) != EOF) { switch (c) { case 'v': option_verbose = 1; break; case 'h': case '?': default: usage(); } } argc -= optind; argv += optind; e = gfarm_initialize(&argc, &argv); if (e != NULL) { fprintf(stderr, "%s: %s\n", program_name, e); exit(1); } e = gfarm_stringlist_init(&paths); if (e != NULL) { fprintf(stderr, "%s: %s\n", program_name, e); exit(EXIT_FAILURE); } e = gfs_glob_init(&types); if (e != NULL) { fprintf(stderr, "%s: %s\n", program_name, e); exit(EXIT_FAILURE); } for (i = 0; i < argc; i++) gfs_glob(argv[i], &paths, &types); for (i = 0; i < gfarm_stringlist_length(&paths); i++) { char *url = gfarm_stringlist_elem(&paths, i); e = gfsck_dir("", url); if (e != NULL) { fprintf(stderr, "%s: %s\n", url, e); error = 1; } } gfs_glob_free(&types); gfarm_stringlist_free_deeply(&paths); e = gfarm_terminate(); if (e != NULL) { fprintf(stderr, "%s: %s\n", program_name, e); exit(1); } exit(error); }
static char * replicate_so_and_symlink(char *dir, size_t size) { char *canonic_path, *gfarm_url, *so_pat, *lpath; char *e, *e_save; int i, rv; gfarm_stringlist paths; gfs_glob_t types; static char so_pat_template[] = "/*.so*"; e = gfs_mntpath_canonicalize(dir, size, &canonic_path); if (e != NULL) return (e); e = gfarm_path_canonical_to_url(canonic_path, &gfarm_url); free(canonic_path); if (e != NULL) return (e); so_pat = malloc(strlen(gfarm_url) + sizeof(so_pat_template)); if (so_pat == NULL) { free(gfarm_url); return (GFARM_ERR_NO_MEMORY); } sprintf(so_pat, "%s%s", gfarm_url, so_pat_template); free(gfarm_url); e_save = gfarm_stringlist_init(&paths); if (e_save != NULL) goto free_so_pat; e_save = gfs_glob_init(&types); if (e_save != NULL) goto free_paths; e_save = gfs_glob(so_pat, &paths, &types); if (e_save != NULL) goto free_types; /* XXX - should replicate so files in parallel */ for (i = 0; i < gfarm_stringlist_length(&paths); i++) { char *gfarm_so, *local_so; gfarm_so = gfarm_stringlist_elem(&paths, i); if (strcmp(gfarm_so, so_pat) == 0) /* no "*.so*" file in dir */ break; e = gfarm_url_execfile_replicate_to_local(gfarm_so, &lpath); if (e != NULL) { fprintf(stderr, "%s: %s\n", gfarm_so, e); if (e_save == NULL) e_save = e; if (e == GFARM_ERR_NO_MEMORY) break; continue; } /* create a symlink */ e = gfarm_url_localize(gfarm_so, &local_so); if (e != NULL) { fprintf(stderr, "%s: %s\n", gfarm_so, e); if (e_save == NULL) e_save = e; if (e == GFARM_ERR_NO_MEMORY) break; free(lpath); continue; } unlink(local_so); rv = symlink(lpath, local_so); if (rv == -1) { perror(local_so); if (e_save == NULL) e_save = gfarm_errno_to_error(errno); } free(local_so); free(lpath); } free_types: gfs_glob_free(&types); free_paths: gfarm_stringlist_free_deeply(&paths); free_so_pat: free(so_pat); return (e_save); }
int main(int argc, char **argv) { char *e; gfarm_stringlist paths; gfs_glob_t types; int i, c, exit_code = EXIT_SUCCESS; extern char *optarg; if (argc > 0) program_name = basename(argv[0]); e = gfarm_initialize(&argc, &argv); if (e != NULL) { fprintf(stderr, "%s: %s\n", program_name, e); exit(EXIT_FAILURE); } if (isatty(STDOUT_FILENO)) { char *s = getenv("COLUMNS"); #ifdef TIOCGWINSZ struct winsize win; #endif if (s != NULL) screen_width = strtol(s, NULL, 0); #ifdef TIOCGWINSZ else if (ioctl(STDOUT_FILENO, TIOCGWINSZ, &win) == 0 && win.ws_col > 0) screen_width = win.ws_col; #endif option_output_format = OF_MULTI_COLUMN; } else { option_output_format = OF_ONE_PER_LINE; } while ((c = getopt(argc, argv, "1CFRSTdlrt?")) != -1) { switch (c) { case '1': option_output_format = OF_ONE_PER_LINE; break; case 'C': option_output_format = OF_MULTI_COLUMN; break; case 'F': option_type_suffix = 1; break; case 'R': option_recursive = 1; break; case 'S': option_sort_order = SO_SIZE; break; case 'T': option_complete_time = 1; break; case 'd': option_directory_itself = 1; break; case 'l': option_output_format = OF_LONG; break; case 'r': option_reverse_sort = 1; break; case 't': option_sort_order = SO_MTIME; break; case '?': default: usage(); } } argc -= optind; argv += optind; e = gfarm_stringlist_init(&paths); if (e != NULL) { fprintf(stderr, "%s: %s\n", program_name, e); exit(EXIT_FAILURE); } e = gfs_glob_init(&types); if (e != NULL) { fprintf(stderr, "%s: %s\n", program_name, e); exit(EXIT_FAILURE); } if (argc < 1) { gfarm_stringlist_add(&paths, "gfarm:."); gfs_glob_add(&types, GFS_DT_DIR); } else { for (i = 0; i < argc; i++) { int last; /* do not treat glob error as an error */ gfs_glob(argv[i], &paths, &types); last = gfs_glob_length(&types) - 1; if (last >= 0 && gfs_glob_elem(&types, last) == GFS_DT_UNKNOWN) { /* * Currently, this only happens if there is * no file which matches with argv[i]. * In such case, the number of entries which * were added by gfs_glob() is 1. * But also please note that GFS_DT_UNKNOWN * may happen on other case in future. */ struct gfs_stat s; char *path = gfarm_stringlist_elem(&paths, last); e = gfs_stat(path, &s); if (e != NULL) { fprintf(stderr, "%s: %s\n", path, e); exit_code = EXIT_FAILURE; /* remove last entry */ /* XXX: FIXME layering violation */ free(paths.array[last]); paths.length--; types.length--; } else { GFS_GLOB_ELEM(types, last) = GFARM_S_ISDIR(s.st_mode) ? GFS_DT_DIR : GFS_DT_REG; gfs_stat_free(&s); } } } } if (gfarm_stringlist_length(&paths) > 0) { int need_newline = 0; #if 1 if (list(&paths, &types, &need_newline) != NULL) { /* warning is already printed in list() */ exit_code = EXIT_FAILURE; } #else for (i = 0; i < gfarm_stringlist_length(&paths); i++) printf("<%s>\n", gfarm_stringlist_elem(&paths, i)); #endif } return (exit_code); }
char * list_dir(char *prefix, char *dirname, int *need_newline) { char *e, *s, *path, *e_save = NULL; gfarm_stringlist names; gfs_glob_t types; GFS_Dir dir; struct gfs_dirent *entry; int len = strlen(prefix) + strlen(dirname); path = malloc(len + 1 + 1); if (path == NULL) return (GFARM_ERR_NO_MEMORY); sprintf(path, "%s%s", prefix, dirname); e = gfarm_stringlist_init(&names); if (e != NULL) { fprintf(stderr, "%s: %s\n", program_name, e); free(path); return (e); } e = gfs_glob_init(&types); if (e != NULL) { fprintf(stderr, "%s: %s\n", program_name, e); gfarm_stringlist_free(&names); free(path); return (e); } e = gfs_opendir(path, &dir); if (e != NULL) { fprintf(stderr, "%s: %s\n", path, e); gfs_glob_free(&types); gfarm_stringlist_free(&names); free(path); return (e); } while ((e = gfs_readdir(dir, &entry)) == NULL && entry != NULL) { s = strdup(entry->d_name); if (s == NULL) { e = GFARM_ERR_NO_MEMORY; break; } gfarm_stringlist_add(&names, s); gfs_glob_add(&types, entry->d_type); } if (e != NULL) { fprintf(stderr, "%s%s: %s\n", prefix, dirname, e); e_save = e; } gfs_closedir(dir); if (*gfarm_path_dir_skip(gfarm_url_prefix_skip(path)) != '\0') { path[len] = '/'; path[len + 1] = '\0'; } e = list_files(path, gfarm_stringlist_length(&names), GFARM_STRINGLIST_STRARRAY(names), need_newline); if (e_save == NULL) e_save = e; if (option_recursive) { int i; for (i = 0; i < gfarm_stringlist_length(&names); i++) { s = GFARM_STRINGLIST_STRARRAY(names)[i]; if (s[0] == '.' && (s[1] == '\0' || (s[1] == '.' && s[2] == '\0'))) continue; if (gfs_glob_elem(&types, i) == GFS_DT_DIR) { e = list_dirs(path, 1, &s, need_newline); if (e_save == NULL) e_save = e; } } } gfs_glob_free(&types); gfarm_stringlist_free_deeply(&names); free(path); return (e_save); }
/* * common routine for gfrepbe_client and gfrepbe_server. * other programs/libraries shouldn't use this function. */ char * gfs_client_rep_filelist_receive(struct xxx_connection *from_client, int *np, gfarm_stringlist *files, gfarm_stringlist *sections, char *message_prefix) { int eof, n; char *e, *file, *section; /* * XXX FIXME: This should be done in parallel during replication. */ e = gfarm_stringlist_init(files); if (e != NULL) { fprintf(stderr, "%s: allocating memory for filenames: %s\n", message_prefix, e); return (e); } e = gfarm_stringlist_init(sections); if (e != NULL) { fprintf(stderr, "%s: allocating memory for sections: %s\n", message_prefix, e); return (e); } n = 0; for (;;) { e = xxx_proto_recv(from_client, 0, &eof, "ss", &file, §ion); if (e != NULL) { fprintf(stderr, "%s: error while receiving requests: " "%s\n", message_prefix, e); return (e); } if (eof) { fprintf(stderr, "%s: unexpected EOF " "while receiving file:section lists\n", message_prefix); return (GFARM_ERR_PROTOCOL); } if (*file == '\0') { /* end of list */ if (*section != '\0') { fprintf(stderr, "%s: " "protocol error, unexpected section = <%s>" " at the end of replication list\n", message_prefix, section); return (GFARM_ERR_PROTOCOL); } free(file); free(section); break; } e = gfarm_stringlist_add(files, file); if (e != NULL) { fprintf(stderr, "%s: %s for file %s:%s\n", message_prefix, e, file, section); return (e); } e = gfarm_stringlist_add(sections, section); if (e != NULL) { fprintf(stderr, "%s: %s for section %s:%s\n", message_prefix, e, file, section); return (e); } n++; } *np = n; return (NULL); }
gfarm_error_t gfarm_modify_host(const char *hostname, int port, char **hostaliases, char *architecture, int ncpu, int flags, int add_aliases) { gfarm_error_t e, e2; struct gfarm_host_info hi; int host_info_needs_free = 0; gfarm_stringlist aliases; if (port == 0 || *hostaliases == NULL || architecture == NULL || ncpu < 1 || flags == -1 || add_aliases) { e = gfm_client_host_info_get_by_names(gfarm_metadb_server, 1, &hostname, &e2, &hi); if (e != GFARM_ERR_NO_ERROR) return (e); if (e2 != GFARM_ERR_NO_ERROR) return (e2); host_info_needs_free = 1; if (!add_aliases) { /* XXX - do check_hostaliases() here, too. */ hostaliases = hostaliases; } else { e = check_hostaliases( gfarm_strarray_length(hostaliases), hostaliases); if (e != GFARM_ERR_NO_ERROR) goto free_host_info; e = gfarm_stringlist_init(&aliases); if (e != GFARM_ERR_NO_ERROR) goto free_host_info; if (hi.hostaliases != NULL) { e = gfarm_stringlist_cat(&aliases, hi.hostaliases); if (e != GFARM_ERR_NO_ERROR) goto free_aliases; } if (hostaliases != NULL) { e = gfarm_stringlist_cat(&aliases, hostaliases); if (e != GFARM_ERR_NO_ERROR) goto free_aliases; } e = gfarm_stringlist_add(&aliases, NULL); if (e != GFARM_ERR_NO_ERROR) goto free_aliases; hostaliases = GFARM_STRINGLIST_STRARRAY(aliases); } if (port == 0) port = hi.port; if (architecture == NULL) architecture = hi.architecture; if (ncpu < 1) ncpu = hi.ncpu; if (flags == -1) flags = hi.flags; } e = update_host(hostname, port, gfarm_strarray_length(hostaliases), hostaliases, architecture, ncpu, flags, gfm_client_host_info_modify); #if 0 /* XXX FIXME not yet in v2 */ if (e == GFARM_ERR_NO_ERROR && !add_aliases && *hostaliases == NULL) e = gfarm_host_info_remove_hostaliases(hostname); #endif free_aliases: if (add_aliases) gfarm_stringlist_free(&aliases); free_host_info: if (host_info_needs_free) gfarm_host_info_free(&hi); return (e); }