void check_file(char *av, t_args *args) { struct stat *stats; stats = malloc(sizeof(*stats)); if (!lstat(av, stats)) { if (S_ISDIR(stats->st_mode)) add_file(&(args->dirs), new_file(ft_strdup(av))); else if (S_ISREG(stats->st_mode)) add_file(&(args->files), new_file(ft_strdup(av))); else if (S_ISLNK(stats->st_mode)) { if (args->opt->l) add_file(&(args->files), new_file(ft_strdup(av))); else add_file(&(args->dirs), new_file(ft_strdup(av))); } } else { ft_error2(av); args->error = 1; } free(stats); }
static void create_cab_file(void) { CCAB cabParams; HFCI hfci; ERF erf; static CHAR a_txt[] = "a.txt", b_txt[] = "b.txt", testdir_c_txt[] = "testdir\\c.txt", testdir_d_txt[] = "testdir\\d.txt"; BOOL res; set_cab_parameters(&cabParams); hfci = FCICreate(&erf, file_placed, mem_alloc, mem_free, fci_open, fci_read, fci_write, fci_close, fci_seek, fci_delete, get_temp_file, &cabParams, NULL); ok(hfci != NULL, "Failed to create an FCI context\n"); add_file(hfci, a_txt); add_file(hfci, b_txt); add_file(hfci, testdir_c_txt); add_file(hfci, testdir_d_txt); res = FCIFlushCabinet(hfci, FALSE, get_next_cabinet, progress); ok(res, "Failed to flush the cabinet\n"); res = FCIDestroy(hfci); ok(res, "Failed to destroy the cabinet\n"); }
int main(int argc, char *argv[]) { int c, fflag; fflag = 0; while ((c = getopt(argc, argv, "Eae:f:nru")) != -1) switch (c) { case 'E': case 'r': Eflag = 1; break; case 'a': aflag = 1; break; case 'e': eflag = 1; add_compunit(CU_STRING, optarg); break; case 'f': fflag = 1; add_compunit(CU_FILE, optarg); break; case 'n': nflag = 1; break; case 'u': setlinebuf(stdout); break; default: case '?': (void)fprintf(stderr, "usage: sed [-aEnru] command [file ...]\n" " sed [-aEnru] [-e command] [-f command_file] [file ...]\n"); exit(1); } argc -= optind; argv += optind; /* First usage case; script is the first arg */ if (!eflag && !fflag && *argv) { add_compunit(CU_STRING, *argv); argv++; } compile(); /* Continue with first and start second usage */ if (*argv) for (; *argv; argv++) add_file(*argv); else add_file(NULL); process(); cfclose(prog, NULL); if (fclose(stdout)) err(FATAL, "stdout: %s", strerror(errno)); exit (0); }
int main(int argc, char *argv[]) { int c, fflag; setprogname(*argv); fflag = 0; while ((c = getopt(argc, argv, "ae:f:nE")) != -1) switch (c) { case 'a': aflag = 1; break; case 'e': eflag = 1; add_compunit(CU_STRING, optarg); break; case 'f': fflag = 1; add_compunit(CU_FILE, optarg); break; case 'n': nflag = 1; break; case 'E': ere = REG_EXTENDED; break; default: case '?': (void)fprintf(stderr, "usage:\t%s [-aEn] script [file ...]\n\t%s [-aEn] [-e script] ... [-f script_file] ... [file ...]\n", getprogname(), getprogname()); exit(1); } argc -= optind; argv += optind; /* First usage case; script is the first arg */ if (!eflag && !fflag && *argv) { add_compunit(CU_STRING, *argv); argv++; } compile(); /* Continue with first and start second usage */ if (*argv) for (; *argv; argv++) add_file(*argv); else add_file(NULL); process(); cfclose(prog, NULL); if (fclose(stdout)) err(FATAL, "stdout: %s", strerror(errno)); exit (0); }
static void max_file_size(void) { add_dir( FOUND, ""); add_file( FOUND, "a", 1); add_file( FOUND, "b", 2); add_file(NOT_FOUND, "c", 3); add_dir ( FOUND, "d"); snprintf(extra_config, sizeof(extra_config), "include=%s\nmax_file_size=2", fullpath); }
static void exclude_dir(void) { add_dir( FOUND, ""); add_file( FOUND, "a", 1); add_dir (NOT_FOUND, "d"); add_file(NOT_FOUND, "d/x", 1); add_file( FOUND, "e", 3); snprintf(extra_config, sizeof(extra_config), "include=%s\n" "exclude=%s/d\n", fullpath, fullpath); }
KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_prepend_config_files(const char *filelist, char **pq, char ***ret_pp) { krb5_error_code ret; const char *p, *q; char **pp; int len; char *fn; pp = NULL; len = 0; p = filelist; while(1) { ssize_t l; q = p; l = strsep_copy(&q, PATH_SEP, NULL, 0); if(l == -1) break; fn = malloc(l + 1); if(fn == NULL) { krb5_free_config_files(pp); return ENOMEM; } (void)strsep_copy(&p, PATH_SEP, fn, l + 1); ret = add_file(&pp, &len, fn); if (ret) { krb5_free_config_files(pp); return ret; } } if (pq != NULL) { int i; for (i = 0; pq[i] != NULL; i++) { fn = strdup(pq[i]); if (fn == NULL) { krb5_free_config_files(pp); return ENOMEM; } ret = add_file(&pp, &len, fn); if (ret) { krb5_free_config_files(pp); return ret; } } } *ret_pp = pp; return 0; }
static void exclude_extension(void) { add_dir( FOUND, ""); add_file(NOT_FOUND, "a.c", 1); add_file(NOT_FOUND, "a.h", 2); add_file( FOUND, "b", 2); add_file( FOUND, "b.x", 2); add_file(NOT_FOUND, "c.c", 3); add_dir ( FOUND, "d"); snprintf(extra_config, sizeof(extra_config), "include=%s\n" "exclude_ext=c\n" "exclude_ext=h\n", fullpath); }
static void simple_entries(void) { add_dir( FOUND, ""); add_file(FOUND, "a", 1); add_file(FOUND, "b", 2); add_file(FOUND, "c", 3); add_dir (FOUND, "d"); add_slnk(FOUND, "e", "a"); add_hlnk(FOUND, "f", "a"); add_hlnk(FOUND, "g", "a"); add_fifo_special(FOUND, "h"); add_sock(FOUND, "i"); snprintf(extra_config, sizeof(extra_config), "include=%s", fullpath); }
int create_file(struct simple_directory *dir, const char *path, mode_t mode) { /* implementation will be something like this, but path strings will * need to be handled better */ char *tmp_path = strdup(path); const char *dn = dirname(tmp_path); /* Debug */ printf("\n\n"); printf("create_file()\n"); printf("Path is: %s\n", path); printf("dirname is: %s\n", dn); if (strcmp(dn, "/") == 0) { printf("Create file\n"); add_file(dir, create_file_struct(path, mode, 1, "", 0)); printf("\n\n"); return 0; } else { printf("Find directory\n"); struct simple_directory *d = find_directory(dir, dn); int dir_len = strlen(dn); char *new_path = strdup(path + dir_len); printf("\n\n"); return create_file(d, new_path, mode); } }
/* The main logic of the public svn_client_add4; the only difference is that this function uses an existing access baton. (svn_client_add4 just generates an access baton and calls this func.) */ static svn_error_t * add(const char *path, svn_depth_t depth, svn_boolean_t force, svn_boolean_t no_ignore, svn_wc_adm_access_t *adm_access, svn_client_ctx_t *ctx, apr_pool_t *pool) { svn_node_kind_t kind; svn_error_t *err; SVN_ERR(svn_io_check_path(path, &kind, pool)); if (kind == svn_node_dir && depth >= svn_depth_files) err = add_dir_recursive(path, adm_access, depth, force, no_ignore, ctx, pool); else if (kind == svn_node_file) err = add_file(path, ctx, adm_access, pool); else err = svn_wc_add2(path, adm_access, NULL, SVN_INVALID_REVNUM, ctx->cancel_func, ctx->cancel_baton, ctx->notify_func2, ctx->notify_baton2, pool); /* Ignore SVN_ERR_ENTRY_EXISTS when FORCE is set. */ if (err && err->apr_err == SVN_ERR_ENTRY_EXISTS && force) { svn_error_clear(err); err = SVN_NO_ERROR; } return err; }
int main(int argc, char **argv) { /*int i;*/ char db_dir[256]; /* the directory where the db file is */ char dbfilename[256]; /* the database filename */ char *filenames[1000]; /* the files to be added */ char **fnames = filenames; short flag; /* flag for deleting or adding */ parse_args(argv, db_dir, filenames, &flag); if (!filenames[0]) { fprintf(stderr, "%s\n", usage); return -1; } parser_init(); build_db_filename(flag, db_dir, dbfilename); if (fresh) unlink(dbfilename); if (flag & Delete) while (*fnames) delete_file(dbfilename, *fnames++); else while (*fnames) add_file(dbfilename, *fnames++, fresh); return 0; }
PathMan::LookUp PathMan::add_file(const char * path, uint8_t mode) { LookUp lu = {FAILURE, State(), 0, 0}; uint32_t len; const char * basename; if (trie.root) lu.err = _check_path(path, len); basename = NULL; if (len > 1) { for (uint16_t k = 0; k < len; k++) { if (path[k] == '/') { if (len > 1 && k < len - 1) { basename = path + k + 1; lu.err = SUCCESS; } } } } else { lu.err = MALFORMED_PATH; } if (lu.err == SUCCESS) { size_t dlen = basename - path; char dirname[dlen + 1]; memcpy(dirname, path, dlen); dirname[dlen] = 0; lu = lookup(dirname); if (lu.err == SUCCESS) { lu = add_file(lu.dir, basename, 0); } } return lu; }
void compiler::add_code(std::istream & in, std::string const & name) { token_iterator i{in}; this->code_ += "// --------------------"; if (!name.empty()) this->code_ += "// " + name; this->code_ +="\n\n"; while (i) { if (i->second == token_type::other && i->first == "#") { ++i; i.skip_whitespace(); if (i->second == token_type::word) { if (i->first == "import") { std::string filename; std::getline(in, filename); filename.erase(0, filename.find_first_not_of(" \t")); this->code_ += "//#import " + filename + "\n"; if (!used_files_.count(filename)) add_file(filename); ++i; continue; } else if (i->first == "version") { unsigned int version; in >> version; if (version > this->glsl_version_) this->glsl_version_ = version; ++i; continue; } else { this->code_ += '#'; } }
void *seeki_alloc(char *str) { struct seeki *sip = malloc(sizeof(struct seeki)); sip->rfp = seek_open(str, 'r'); sip->wfp = seek_open(str, 'w'); sip->cfp = seek_open(str, 'c'); sip->tot_seeks = 0; sip->total_sectors = 0.0; sip->last_start = sip->last_end = 0; memset(&sip->root, 0, sizeof(sip->root)); if (sps_name) { char *oname; memset(&sip->sps, 0, sizeof(sip->sps)); oname = malloc(strlen(sps_name) + strlen(str) + 32); sprintf(oname, "%s_%s.dat", sps_name, str); if ((sip->sps_fp = my_fopen(oname, "w")) == NULL) perror(oname); else add_file(sip->sps_fp, oname); } else sip->sps_fp = NULL; return sip; }
int check_link(t_lem_env *env, char *s) { int i; int j; int k; int a; env->r.nolink = 0; if (matrice_visit0(env, &i, &j, &k) == 0) return (ft_error(env, 1)); a = -1; if (!is_link(s) || (a = check_link2(env, s, &i, &j)) != 0) return (ft_error(env, 2)); while (++k < env->nbroom) { if ((a = ft_strcmp(env->room[k], &s[i + 1])) == 0) break ; } if (a != 0 || j == k) return (ft_error(env, 2)); if (env->matrice[j][k] == 1) return (ft_error(env, 2)); env->matrice[k][j] += 1; env->matrice[j][k] += 1; env->r.nbline += add_file(env, s); return (1); }
int main(int argc, char **argv) { handle_common_asf_args(&argc, &argv, "ASF CEOS Metadata Viewer"); gchar *glade_xml_file; gtk_init(&argc, &argv); // glade_xml_file = (gchar *) find_in_path("mdv.glade"); glade_xml_file = (gchar *) find_in_share("mdv.glade"); glade_xml = glade_xml_new(glade_xml_file, NULL, NULL); g_free(glade_xml_file); set_app_title(); set_font(); if (argc > 1) add_file(argv[1]); glade_xml_signal_autoconnect(glade_xml); gtk_main (); exit (EXIT_SUCCESS); }
int main(int argc, char *argv[]){ int i; struct file *head = NULL; for (i = 1; i < argc; i++){ head = add_file(head, scan_c(argv[i])); /*only handle C language right now*/ } FILE * template = fopen("/etc/code-insight/template.html", "r");
int archive_files( char *names[], int count, char *out_file_name ) { int f_out = open(out_file_name, O_CREAT | O_TRUNC | O_WRONLY), i; if (f_out < 0) return -1; write(f_out, &count, sizeof(int)); for (i = 0; i < count; i++) { int res; printf("%s", names[i]); res = add_file(names[i], f_out); if (res == -1) printf("... Failed, skipped.\n"); else printf("... Complete.\n"); } fchmod(f_out, S_IRUSR | S_IROTH | S_IRGRP); close(f_out); return 0; }
void get_directory_content(t_list *dir, t_list **files, int options) { DIR *pdir; t_dir *pdirent; char *tmp; pdir = NULL; pdirent = NULL; if (!(tmp = set_file_path(NAME(dir), PATH(dir)))) print_mem_error(errno); if ((pdir = opendir(tmp))) { while ((pdirent = readdir(pdir))) { if (pdirent) add_file(pdirent->d_name, files, tmp, options); else print_mem_error(errno); } closedir(pdir); } else print_opendir_error(tmp, errno); ft_strdel(&tmp); sort(*files, options); }
void file_storage::add_file(std::wstring const& file, size_type size, int flags , std::time_t mtime, std::string const& symlink_path) { std::string utf8; wchar_utf8(file, utf8); add_file(utf8, size, flags, mtime, symlink_path); }
void ObjectSettings::add_level(const std::string& text, std::string* value_ptr, const std::string& key, const std::string& basedir, unsigned int flags) { add_file(text, value_ptr, key, {}, {".stl"}, basedir, flags); }
void accept_file_dialog(GtkWidget *widget, gpointer data) { add_file(gtk_file_selection_get_filename(GTK_FILE_SELECTION(filew))); update_list(); gtk_widget_destroy(filew); }
void gnode_to_gui(GNode * root, GtkCTreeNode * a_node) { GNode *tmp; GtkCTreeNode *new_node; NE_DEBUG(DEBUG_GNOME, "Building GUI tree from GNode hierarchy... \n"); if (!root) return; tmp = g_node_first_child(root); while (tmp) { new_node = add_file(name(tmp), file(tmp), a_node); gnode_to_gui(tmp, new_node); tmp = g_node_next_sibling(tmp); } gnode_to_gui(tmp, a_node); }
int main(int argc, char *argv[]) { struct m_inode *mip; FILE *fp; if(argc != 5) { panic(__FILE__, __LINE__, "Usage: %s Image super_block_id pathname filename\n", argv[0]); } fp = fopen(argv[4], "rb"); if(!fp) { panic(__FILE__, __LINE__, "Can't open %s\n", argv[4]); } constructor(argv[1]); add_file(fp, atoi(argv[2]), argv[3]); destructor(); return 0; }
static void exclude_regex(void) { add_dir( FOUND, ""); add_file( FOUND, "a", 1); add_file( FOUND, "b", 1); add_file( FOUND, "c", 1); add_file(NOT_FOUND, "dnotthisone", 1); add_dir ( FOUND, "e"); add_dir (NOT_FOUND, "e/fexc"); add_file(NOT_FOUND, "fnotthisone", 1); snprintf(extra_config, sizeof(extra_config), "include=%s\n" "exclude_regex=not\n" "exclude_regex=exc\n", fullpath); }
SIGNAL_CALLBACK void on_file_selection_dialog_ok_button_clicked(GtkWidget *w) { GtkWidget *file_selection_dialog; gchar **selections; gchar **current; file_selection_dialog = glade_xml_get_widget(glade_xml, "file_selection_dialog"); selections = gtk_file_selection_get_selections( GTK_FILE_SELECTION(file_selection_dialog)); current = selections; while (*current) { add_file(*current); ++current; } g_strfreev(selections); gtk_widget_hide(file_selection_dialog); execute(); }
static BOOL add_directory( HFCI fci, WCHAR *dir ) { static const WCHAR wildcardW[] = {'*',0}; WCHAR *p, *buffer; HANDLE handle; WIN32_FIND_DATAW data; BOOL ret = TRUE; if (!(buffer = cab_alloc( (strlenW(dir) + MAX_PATH + 2) * sizeof(WCHAR) ))) return FALSE; strcpyW( buffer, dir ); p = buffer + strlenW( buffer ); if (p > buffer && p[-1] != '\\') *p++ = '\\'; strcpyW( p, wildcardW ); if ((handle = FindFirstFileW( buffer, &data )) != INVALID_HANDLE_VALUE) { do { if (data.cFileName[0] == '.' && !data.cFileName[1]) continue; if (data.cFileName[0] == '.' && data.cFileName[1] == '.' && !data.cFileName[2]) continue; if (data.dwFileAttributes & FILE_ATTRIBUTE_REPARSE_POINT) continue; strcpyW( p, data.cFileName ); if (data.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) ret = add_directory( fci, buffer ); else ret = add_file( fci, buffer ); if (!ret) break; } while (FindNextFileW( handle, &data )); FindClose( handle ); } cab_free( buffer ); return TRUE; }
EditorSectorMenu::EditorSectorMenu() : sector(Editor::current()->currentsector), sector_name_ptr(sector->get_name_ptr()), original_name(*sector_name_ptr), size(sector->get_editor_size()), new_size(size) { add_label(_("Sector") + " " + sector->get_name()); add_hl(); add_textfield(_("Name"), sector_name_ptr); add_script(_("Initialization script"), sector->get_init_script_ptr()); add_color(_("Ambient light"), sector->get_ambient_light_ptr()); add_numfield(_("Gravity"), §or->gravity); std::vector<std::string> music_formats; music_formats.push_back(".ogg"); music_formats.push_back(".music"); add_file(_("Music"), §or->music, music_formats); add_hl(); add_intfield(_("Width"), &(new_size.width)); add_intfield(_("Height"), &(new_size.height)); add_entry(MNID_RESIZESECTOR, _("Resize")); add_hl(); add_back(_("OK")); }
int retrieve_common(struct file_system_info *fsinfo, struct stats *stats, int repo){ #define retrieve_common_finish(value){ \ unlock(file_mutex[repo][stats->rev]); \ gstrdel(file); \ gstrdel(revision); \ free(temp); \ return value; \ } char *file = NULL; char *revision = calloc(20, sizeof(char)); struct stat *temp = single(struct stat); debug(2, "Received file %s from repo %d;\n", stats->path, repo); lock(file_mutex[repo][stats->rev]); node_t *node = add_file(open_files, stats->path, stats->rev); if (node->count > 0){ node->count++; retrieve_common_finish(0); }; if (create_tmp_file(stats, node) == -1) retrieve_common_finish(-1); if (gmstrcpy(&file, fsinfo->repos[repo], "/", stats->internal, 0) == -1) retrieve_common_finish(-1); sprintf(revision, "%dB", stats->rev); if (retrieve_rdiff(revision, file, node->tmp_path) != 0) retrieve_common_finish(-1); if (stat(node->tmp_path, temp) != 0 || temp->st_size != stats->size) retrieve_common_finish(-1); node->count = 1; retrieve_common_finish(0); };