int * open_exec_for_in_out_err (const char *filename, char * const *args) { Filename expand; FILE **files; static int ret[3]; struct epic_loadfile *elf; File * fr; if (normalize_filename(filename, expand)) strlcpy(expand, filename, sizeof(expand)); if ((files = open_exec(filename, args))) { int foo; for (foo = 0; foo < 3; foo++) { if (!(elf=(struct epic_loadfile *)malloc(sizeof(struct epic_loadfile)))) { yell("Not enough memory."); return NULL; } elf->fp=files[foo]; #ifdef HAVE_LIBARCHIVE elf->a=NULL; #endif fr=new_file(elf); ret[foo] = fr->id; } return ret; } else return NULL; }
void systrace_parameters(void) { struct passwd *pw; char *normcwd; uid_t uid = getuid(); iamroot = getuid() == 0; /* Find out current username. */ if ((pw = getpwuid(uid)) == NULL) { snprintf(username, sizeof(username), "uid %u", uid); } else { strlcpy(username, pw->pw_name, sizeof(username)); strlcpy(home, pw->pw_dir, sizeof(home)); } /* Determine current working directory for filtering */ if (getcwd(cwd, sizeof(cwd)) == NULL) err(1, "getcwd"); if ((normcwd = normalize_filename(-1, 0, cwd, ICLINK_ALL)) == NULL) errx(1, "normalize_filename"); if (strlcpy(cwd, normcwd, sizeof(cwd)) >= sizeof(cwd)) errx(1, "cwd too long"); }
/* * set_log_file: sets the log file name. If logging is on already, this * closes the last log file and reopens it with the new name. This is called * automatically when you SET LOGFILE. */ void set_log_file (const void *stuff) { const char *filename = (const char *)stuff; Filename expand; if (!filename) return; if (normalize_filename(filename, expand)) { say("SET LOGFILE: %s contains an invalid directory", filename); return; } set_string_var(LOGFILE_VAR, expand); if (irclog_fp) { int value; value = 0; logger(&value); value = 1; logger(&value); } }
static struct directory * attach_directory (const char *name) { char *cname = normalize_filename (name); struct directory *dir = make_directory (name, cname); if (dirtail) dirtail->next = dir; else dirhead = dir; dirtail = dir; return dir; }
/* Return a directory entry for a given file NAME, or zero if none found. */ static struct directory * find_directory (const char *name) { if (! directory_table) return 0; else { char *caname = normalize_filename (name); struct directory *dir = make_directory (name, caname); struct directory *ret = hash_lookup (directory_table, dir); free_directory (dir); return ret; } }
int open_file_for_write (const char *filename, const char *mode) { Filename expand; struct epic_loadfile *elf; File * fr; if (normalize_filename(filename, expand)) strlcpy(expand, filename, sizeof(expand)); if (!(elf = epic_fopen(expand, mode, 1))) return -1; fr=new_file(elf); return fr->id; }
static FILE *open_log (const char *logfile, FILE **fp) { time_t t; char my_buffer[256]; struct tm *ugh; Filename fullname; time(&t); ugh = localtime(&t); /* Not gmtime, m'kay? */ /* Ugh. Solaris. */ strftime(my_buffer, 255, "%a %b %d %H:%M:%S %Y", ugh); if (*fp) { say("Logging is already on"); return *fp; } if (!logfile) return NULL; if (normalize_filename(logfile, fullname)) { say("SET LOGFILE: %s contains an invalid directory", logfile); return NULL; } if ((*fp = fopen(fullname, "a")) != NULL) { chmod(fullname, S_IREAD | S_IWRITE); say("Starting logfile %s", fullname); fprintf(*fp, "IRC log started %s\n", my_buffer); fflush(*fp); } else { say("Couldn't open logfile %s: %s", fullname, strerror(errno)); *fp = NULL; } return (*fp); }
void queue_deferred_unlink (const char *name, bool is_dir) { struct deferred_unlink *p; if (dunlink_head && records_written > dunlink_head->records_written + deferred_unlink_delay) flush_deferred_unlinks (false); p = dunlink_alloc (); p->next = NULL; p->file_name = normalize_filename (name); p->is_dir = is_dir; p->records_written = records_written; if (dunlink_tail) dunlink_tail->next = p; else dunlink_head = p; dunlink_tail = p; dunlink_count++; }
void file_chooser_with_entry(char * title, GtkWidget * parent, GtkFileChooserAction action, int filter, GtkWidget * entry, char * destpath) { GtkWidget * dialog; const gchar * selected_filename = gtk_entry_get_text(GTK_ENTRY(entry)); char path[MAXLEN]; path[0] = '\0'; dialog = gtk_file_chooser_dialog_new(title, GTK_WINDOW(parent), action, GTK_STOCK_APPLY, GTK_RESPONSE_ACCEPT, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, NULL); if (options.show_hidden) { gtk_file_chooser_set_show_hidden(GTK_FILE_CHOOSER(dialog), options.show_hidden); } if (strlen(selected_filename)) { char * filename = g_filename_from_utf8(selected_filename, -1, NULL, NULL, NULL); if (filename == NULL) { gtk_widget_destroy(dialog); return; } normalize_filename(filename, path); g_free(filename); } else { strncpy(path, destpath, MAXLEN-1); } gtk_file_chooser_set_filename(GTK_FILE_CHOOSER(dialog), path); if (action == GTK_FILE_CHOOSER_ACTION_SAVE) { char * bname = g_path_get_basename(path); gtk_file_chooser_set_current_name(GTK_FILE_CHOOSER(dialog), bname); g_free(bname); } gtk_window_set_position(GTK_WINDOW(dialog), GTK_WIN_POS_CENTER_ON_PARENT); gtk_dialog_set_default_response(GTK_DIALOG(dialog), GTK_RESPONSE_ACCEPT); assign_fc_filters(GTK_FILE_CHOOSER(dialog), filter); if (aqualung_dialog_run(GTK_DIALOG(dialog)) == GTK_RESPONSE_ACCEPT) { char * utf8; selected_filename = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(dialog)); utf8 = g_filename_to_utf8(selected_filename, -1, NULL, NULL, NULL); if (utf8 == NULL) { gtk_widget_destroy(dialog); } gtk_entry_set_text(GTK_ENTRY(entry), utf8); strncpy(destpath, selected_filename, MAXLEN-1); g_free(utf8); } gtk_widget_destroy(dialog); }
/* ** PC to BR meta-function */ int pctobr(t_env* env) { char end = 0; int i = 0; unsigned int count = 0; unsigned char conv = 0; unsigned int lines = 0; unsigned char buf[BUFFER_SIZE]; /* received buffer */ unsigned char str[BUFFER_SIZE]; /* sent buffer */ char* tmpfilename = "/tmp/eutp.tmp"; for (i = 0; i < BUFFER_SIZE; i++) { buf[i] = 0; str[i] = 0; } conv = normalize_filename(env); if ((env->fd = open(env->list[env->pcfilenum]->d_name, O_RDONLY)) == -1) { brl_message("!Erreur ouv pc", 0); sleep(1); return 0; } env->fs = fdopen(env->fd, "r"); /* Ouverture fichier en écriture sur le terminal braille */ str[0] = '\x0C'; strncpy((char*)&str[1], "Fo\x00", 3); str[4] = env->curext; strncpy((char*)&str[5], env->filename, 8); brl_write(str+1, 12); brl_read(buf); if (!strncmp((char*)buf, "\003FE\x21", 4)) { if (brl_yesno_question("! Remplacer ? #")) str[3] = 1; else return 1; brl_write(str+1, 12); brl_read(buf); } if (strncmp((char*)buf, "\002FW", 3)) { brl_lasting_message("! erreur ouv br"); brl_writeStr(CLOSE_FILE); return 1; } while (!end) { end = read_trame_from_file(env, str, &count); for (i = 0; i < 30; i++) printf(",%d,", str[i]); printf("\n"); if (count == 4242) /* fin fichier */ { printf("fin fichier\n"); end = 1; } brl_write(str+1, count); brl_read(buf); if (strncmp((char*)buf, (char*)"\002FW", 3)) { printf("erreur transfert\n"); for (i = 0; i < 30; i++) printf(",%d,", buf[i]); printf("\n"); brl_lasting_message("! Erreur transfert"); brl_writeStr(CLOSE_FILE); return 1; } lines++; sprintf((char*)str, "... %s.%c %d", env->filename, env->curext, lines); brl_message((char*)str, 0); } brl_writeStr(CLOSE_FILE); brl_read(buf); if (strncmp((char*)buf, "\003FE\x10", 4)) { printf("errer fermeture\n"); for (i = 0; i < 30; i++) printf(",%d,", buf[i]); printf("\n"); brl_lasting_message("! err fermeture"); fclose(env->fs); close(env->fd); return 1; } brl_message("! Fin transfert", 0); sleep(1); fclose(env->fs); close(env->fd); if (conv) unlink(tmpfilename); return 1; }
static FILE * open_log (const char *logfile, FILE **fp) { char * tempname; size_t templen; Filename fullname; /* If the user hasn't specified a logfile, do nothing */ if (!logfile) return NULL; /* If the user is already logging here, tell them. */ if (*fp) { say("Logging is already on"); return *fp; } /* If necessary, remove "s on the outside of the filename */ /* I do this way too much on accident; it's annoying not to have it */ tempname = LOCAL_COPY(logfile); templen = strlen(tempname); if (templen > 2 && tempname[0] == '"' && tempname[templen - 1] == '"') { tempname[templen - 1] = 0; tempname++; } /* If the result is an empty filename then just punt */ if (!tempname || !*tempname) { yell("Cannot log to the filename [%s] because the result " "was an empty filename", logfile); return NULL; } if (normalize_filename(tempname, fullname)) { yell("Warning: I could not normalize the filename [%s] " "(the result was [%s] -- watch out", logfile, fullname); (void)0; /* Do nothing... */ } if ((*fp = fopen(fullname, "a")) != NULL) { time_t t; struct tm * ltime; char timestr[256]; /* Convert the time to a string to insert in the file */ time(&t); ltime = localtime(&t); /* Not gmtime, m'kay? */ strftime(timestr, 255, "%a %b %d %H:%M:%S %Y", ltime); chmod(fullname, S_IREAD | S_IWRITE); say("Starting logfile %s", fullname); fprintf(*fp, "IRC log started %s\n", timestr); fflush(*fp); } else { yell("Couldn't open logfile %s: %s", fullname, strerror(errno)); *fp = NULL; } return (*fp); }
void collect_and_sort_names (void) { struct name *name; struct name *next_name, *prev_name; int num_names; struct stat statbuf; Hash_table *nametab; name_gather (); if (!namelist) addname (".", 0, false, NULL); if (listed_incremental_option) { switch (chdir_count ()) { case 0: break; case 1: if (namelist->change_dir == 0) USAGE_ERROR ((0, 0, _("Using -C option inside file list is not " "allowed with --listed-incremental"))); break; default: USAGE_ERROR ((0, 0, _("Only one -C option is allowed with " "--listed-incremental"))); } read_directory_file (); } num_names = 0; for (name = namelist; name; name = name->next, num_names++) { if (name->found_count || name->directory) continue; if (name->matching_flags & EXCLUDE_WILDCARDS) /* NOTE: EXCLUDE_ANCHORED is not relevant here */ /* FIXME: just skip regexps for now */ continue; chdir_do (name->change_dir); if (name->name[0] == 0) continue; if (deref_stat (dereference_option, name->name, &statbuf) != 0) { stat_diag (name->name); continue; } if (S_ISDIR (statbuf.st_mode)) { name->found_count++; add_hierarchy_to_namelist (name, statbuf.st_dev, true); } } namelist = merge_sort (namelist, num_names, compare_names); num_names = 0; nametab = hash_initialize (0, 0, name_hash, name_compare, NULL); for (name = namelist; name; name = next_name) { next_name = name->next; name->caname = normalize_filename (name->name); if (prev_name) { struct name *p = hash_lookup (nametab, name); if (p) { /* Keep the one listed in the command line */ if (!name->parent) { if (p->child) rebase_child_list (p->child, name); /* FIXME: remove_directory (p->caname); ? */ remname (p); free_name (p); num_names--; } else { if (name->child) rebase_child_list (name->child, p); /* FIXME: remove_directory (name->caname); ? */ remname (name); free_name (name); continue; } } } name->found_count = 0; if (!hash_insert (nametab, name)) xalloc_die (); prev_name = name; num_names++; } nametail = prev_name; hash_free (nametab); namelist = merge_sort (namelist, num_names, compare_names_found); if (listed_incremental_option) { for (name = namelist; name && name->name[0] == 0; name++) ; if (name) append_incremental_renames (name->directory); } }
/* Destructively turn slashes into backslashes. */ static void unixtodos_filename (char *p) { normalize_filename (p, '\\'); }
/* Destructively turn backslashes into slashes. */ #if 0 /* unused */ static void dostounix_filename (char *p) { normalize_filename (p, '/'); }
int main (void) { const char delimiters[] = "\t"; char *tmpdir, *write_name, *read_name, *failed_name, *failedpath_name, *trashed_name, *line; ssize_t linesize; size_t bufsize = 2048; char *a1, *a2, *a3, *a4, *tmp; tmpdir = getenv("PWIZ_TMPDIR"); if (tmpdir == NULL || tmpdir[0] == 0) { tmpdir = "."; } (void) asprintf (&write_name, "%s/filelist_raw.lst", tmpdir); (void) asprintf (&read_name, "%s/filelist_read.lst", tmpdir); (void) asprintf (&failed_name, "%s/filelist_failed.lst", tmpdir); (void) asprintf (&failedpath_name, "%s/filelist_failedpath.lst", tmpdir); (void) asprintf (&trashed_name, "%s/filelist_trashed.lst", tmpdir); /* FIXME: Error handling. */ write_file = fopen (write_name, "w"); read_file = fopen (read_name, "w"); failed_file = fopen (failed_name, "w"); failedpath_file = fopen (failedpath_name, "w"); trashed_file = fopen (trashed_name, "w"); failedsave_file = failed_file; free (write_name); free (read_name); free (failed_name); free (failedpath_name); free (trashed_name); line = malloc (2048); trash_buffer = malloc (2048); trash_name = malloc (1); strcpy (trash_name, ""); while ((linesize = getline (&line, &bufsize, stdin)) >= 0) { line[linesize-1] = '\0'; tmp = line; a1 = strsep (&tmp, delimiters); if (tmp) { a2 = strsep (&tmp, delimiters); if (tmp) { a3 = strsep (&tmp, delimiters); if (tmp) { a4 = strsep (&tmp, delimiters); } } } if (!strcmp(a2, "read")) { normalize_filename (a3); handle_read (a3, a4); } else if (!strcmp(a2, "open")) { normalize_filename (a3); fprintf (write_file, "%s file\n", a3); } else if (!strcmp(a2, "mkdir")) { normalize_filename (a3); fprintf (write_file, "%s dir\n", a3); } else if (!strcmp(a2, "symlink") || !strcmp(a2, "link")) { normalize_filename (a4); fprintf (write_file, "%s file\n", a4); } } fclose (write_file); fclose (read_file); fclose (failed_file); fclose (failedpath_file); fclose (trashed_file); exit(0); }