void run_amcleanup( char *config_name) { pid_t amcleanup_pid; char *amcleanup_program; char *amcleanup_options[4]; switch(amcleanup_pid = fork()) { case -1: return; break; case 0: /* child process */ amcleanup_program = vstralloc(sbindir, "/", "amcleanup", NULL); amcleanup_options[0] = amcleanup_program; amcleanup_options[1] = "-p"; amcleanup_options[2] = config_name; amcleanup_options[3] = NULL; execve(amcleanup_program, amcleanup_options, safe_env()); error("exec %s: %s", amcleanup_program, strerror(errno)); /*NOTREACHED*/ default: break; } waitpid(amcleanup_pid, NULL, 0); }
static void amgtar_restore( application_argument_t *argument) { char *cmd; GPtrArray *argv_ptr = g_ptr_array_new(); char **env; int j; char *e; if (!gnutar_path) { error(_("GNUTAR-PATH not defined")); } cmd = stralloc(gnutar_path); g_ptr_array_add(argv_ptr, stralloc(gnutar_path)); g_ptr_array_add(argv_ptr, stralloc("--numeric-owner")); if (gnutar_no_unquote) g_ptr_array_add(argv_ptr, stralloc("--no-unquote")); g_ptr_array_add(argv_ptr, stralloc("-xpGvf")); g_ptr_array_add(argv_ptr, stralloc("-")); for (j=1; j< argument->argc; j++) { g_ptr_array_add(argv_ptr, stralloc(argument->argv[j])); } g_ptr_array_add(argv_ptr, NULL); env = safe_env(); become_root(); execve(cmd, (char **)argv_ptr->pdata, env); e = strerror(errno); error(_("error [exec %s: %s]"), cmd, e); }
void startup_tape_process( char *taper_program) { int fd[2]; char **config_options; if(socketpair(AF_UNIX, SOCK_STREAM, 0, fd) == -1) { error(_("taper pipe: %s"), strerror(errno)); /*NOTREACHED*/ } if(fd[0] < 0 || fd[0] >= (int)FD_SETSIZE) { error(_("taper socketpair 0: descriptor %d out of range (0 .. %d)\n"), fd[0], (int)FD_SETSIZE-1); /*NOTREACHED*/ } if(fd[1] < 0 || fd[1] >= (int)FD_SETSIZE) { error(_("taper socketpair 1: descriptor %d out of range (0 .. %d)\n"), fd[1], (int)FD_SETSIZE-1); /*NOTREACHED*/ } switch(taper_pid = fork()) { case -1: error(_("fork taper: %s"), strerror(errno)); /*NOTREACHED*/ case 0: /* child process */ aclose(fd[0]); if(dup2(fd[1], 0) == -1 || dup2(fd[1], 1) == -1) error(_("taper dup2: %s"), strerror(errno)); config_options = get_config_options(2); config_options[0] = "taper"; config_options[1] = get_config_name(); safe_fd(-1, 0); execve(taper_program, config_options, safe_env()); error("exec %s: %s", taper_program, strerror(errno)); /*NOTREACHED*/ default: /* parent process */ aclose(fd[1]); taper = fd[0]; taper_ev_read = NULL; } }
void startup_chunk_process( chunker_t *chunker, char *chunker_program) { int fd[2]; char **config_options; if(socketpair(AF_UNIX, SOCK_STREAM, 0, fd) == -1) { error(_("%s pipe: %s"), chunker->name, strerror(errno)); /*NOTREACHED*/ } switch(chunker->pid = fork()) { case -1: error(_("fork %s: %s"), chunker->name, strerror(errno)); /*NOTREACHED*/ case 0: /* child process */ aclose(fd[0]); if(dup2(fd[1], 0) == -1 || dup2(fd[1], 1) == -1) { error(_("%s dup2: %s"), chunker->name, strerror(errno)); /*NOTREACHED*/ } config_options = get_config_options(2); config_options[0] = chunker->name ? chunker->name : "chunker", config_options[1] = get_config_name(); safe_fd(-1, 0); execve(chunker_program, config_options, safe_env()); error(_("exec %s (%s): %s"), chunker_program, chunker->name, strerror(errno)); /*NOTREACHED*/ default: /* parent process */ aclose(fd[1]); chunker->down = 0; chunker->fd = fd[0]; chunker->ev_read = NULL; g_fprintf(stderr,_("driver: started %s pid %u\n"), chunker->name, (unsigned)chunker->pid); fflush(stderr); } }
static void amstar_restore( application_argument_t *argument) { char *cmd; GPtrArray *argv_ptr = g_ptr_array_new(); char **env; int j; char *e; if (!star_path) { error(_("STAR-PATH not defined")); } cmd = stralloc(star_path); g_ptr_array_add(argv_ptr, stralloc(star_path)); g_ptr_array_add(argv_ptr, stralloc("-x")); g_ptr_array_add(argv_ptr, stralloc("-v")); g_ptr_array_add(argv_ptr, stralloc("-xattr")); g_ptr_array_add(argv_ptr, stralloc("-acl")); g_ptr_array_add(argv_ptr, stralloc("errctl=WARN|SAMEFILE|SETTIME|DIFF|SETACL|SETXATTR|SETMODE|BADACL *")); g_ptr_array_add(argv_ptr, stralloc("-no-fifo")); g_ptr_array_add(argv_ptr, stralloc("-f")); g_ptr_array_add(argv_ptr, stralloc("-")); for (j=1; j< argument->argc; j++) g_ptr_array_add(argv_ptr, stralloc(argument->argv[j]+2));/*remove ./ */ g_ptr_array_add(argv_ptr, NULL); env = safe_env(); become_root(); execve(cmd, (char **)argv_ptr->pdata, env); e = strerror(errno); error(_("error [exec %s: %s]"), cmd, e); }
int main( int argc, char ** argv) { #ifdef GNUTAR int i; char *e; char *dbf; char *cmdline; GPtrArray *array = g_ptr_array_new(); gchar **strings; char **new_argv; #endif if (argc > 1 && argv[1] && g_str_equal(argv[1], "--version")) { printf("runtar-%s\n", VERSION); return (0); } /* * Configure program for internationalization: * 1) Only set the message locale for now. * 2) Set textdomain for all amanda related programs to "amanda" * We don't want to be forced to support dozens of message catalogs. */ setlocale(LC_MESSAGES, "C"); textdomain("amanda"); safe_fd(-1, 0); safe_cd(); set_pname("runtar"); /* Don't die when child closes pipe */ signal(SIGPIPE, SIG_IGN); dbopen(DBG_SUBDIR_CLIENT); config_init(CONFIG_INIT_CLIENT, NULL); if (argc < 3) { error(_("Need at least 3 arguments\n")); /*NOTREACHED*/ } dbprintf(_("version %s\n"), VERSION); if (!g_str_equal(argv[3], "--create")) { error(_("Can only be used to create tar archives\n")); /*NOTREACHED*/ } #ifndef GNUTAR g_fprintf(stderr,_("gnutar not available on this system.\n")); dbprintf(_("%s: gnutar not available on this system.\n"), argv[0]); dbclose(); return 1; #else /* * Print out version information for tar. */ do { FILE * version_file; char version_buf[80]; if ((version_file = popen(GNUTAR " --version 2>&1", "r")) != NULL) { if (fgets(version_buf, (int)sizeof(version_buf), version_file) != NULL) { dbprintf(_(GNUTAR " version: %s\n"), version_buf); } else { if (ferror(version_file)) { dbprintf(_(GNUTAR " version: Read failure: %s\n"), strerror(errno)); } else { dbprintf(_(GNUTAR " version: Read failure; EOF\n")); } } } else { dbprintf(_(GNUTAR " version: unavailable: %s\n"), strerror(errno)); } } while(0); #ifdef WANT_SETUID_CLIENT check_running_as(RUNNING_AS_CLIENT_LOGIN | RUNNING_AS_UID_ONLY); if (!become_root()) { error(_("error [%s could not become root (is the setuid bit set?)]\n"), get_pname()); /*NOTREACHED*/ } #else check_running_as(RUNNING_AS_CLIENT_LOGIN); #endif /* skip argv[0] */ argc--; argv++; dbprintf(_("config: %s\n"), argv[0]); if (!g_str_equal(argv[0], "NOCONFIG")) dbrename(argv[0], DBG_SUBDIR_CLIENT); argc--; argv++; new_argv = g_new0(char *, argc+1); new_argv[0] = g_strdup_printf("%s", argv[0]); g_ptr_array_add(array, g_strdup(GNUTAR)); for (i = 1; argv[i]; i++) { g_ptr_array_add(array, quote_string(argv[i])); new_argv[i] = g_strdup_printf("%s", argv[i]); } g_ptr_array_add(array, NULL); strings = (gchar **)g_ptr_array_free(array, FALSE); cmdline = g_strjoinv(" ", strings); g_strfreev(strings); dbprintf(_("running: %s\n"), cmdline); amfree(cmdline); dbf = dbfn(); if (dbf) { dbf = g_strdup(dbf); } dbclose(); execve(GNUTAR, new_argv, safe_env()); e = strerror(errno); dbreopen(dbf, "more"); amfree(dbf); dbprintf(_("execve of %s failed (%s)\n"), GNUTAR, e); dbclose(); g_fprintf(stderr, _("runtar: could not exec %s: %s\n"), GNUTAR, e); return 1; #endif }
int main( int argc, char ** argv) { #ifndef ERRMSG char *dump_program; int i; char *e; char *cmdline; #endif /* ERRMSG */ /* * Configure program for internationalization: * 1) Only set the message locale for now. * 2) Set textdomain for all amanda related programs to "amanda" * We don't want to be forced to support dozens of message catalogs. */ setlocale(LC_MESSAGES, "C"); textdomain("amanda"); safe_fd(-1, 0); safe_cd(); set_pname("rundump"); /* Don't die when child closes pipe */ signal(SIGPIPE, SIG_IGN); dbopen(DBG_SUBDIR_CLIENT); config_init(CONFIG_INIT_CLIENT, NULL); if (argc < 3) { error(_("Need at least 3 arguments\n")); /*NOTREACHED*/ } dbprintf(_("version %s\n"), VERSION); #ifdef ERRMSG /* { */ g_fprintf(stderr, ERRMSG); dbprintf("%s: %s", argv[0], ERRMSG); dbclose(); return 1; #else /* } { */ #ifdef WANT_SETUID_CLIENT check_running_as(RUNNING_AS_CLIENT_LOGIN | RUNNING_AS_UID_ONLY); if (!become_root()) { error(_("error [%s could not become root (is the setuid bit set?)]\n"), get_pname()); /*NOTREACHED*/ } #else check_running_as(RUNNING_AS_CLIENT_LOGIN); #endif /* skip argv[0] */ argc--; argv++; dbprintf(_("config: %s\n"), argv[0]); if (strcmp(argv[0], "NOCONFIG") != 0) dbrename(argv[0], DBG_SUBDIR_CLIENT); argc--; argv++; #ifdef XFSDUMP if (strcmp(argv[0], "xfsdump") == 0) dump_program = XFSDUMP; else /* strcmp(argv[0], "xfsdump") != 0 */ #endif #ifdef VXDUMP if (strcmp(argv[0], "vxdump") == 0) dump_program = VXDUMP; else /* strcmp(argv[0], "vxdump") != 0 */ #endif #ifdef VDUMP if (strcmp(argv[0], "vdump") == 0) dump_program = VDUMP; else /* strcmp(argv[0], "vdump") != 0 */ #endif #if defined(DUMP) dump_program = DUMP; #else # if defined(XFSDUMP) dump_program = XFSDUMP; # else # if defined(VXDUMP) dump_program = VXDUMP; # else dump_program = "dump"; # endif # endif #endif cmdline = stralloc(dump_program); for (i = 1; argv[i]; i++) { char *quoted; quoted = quote_string(argv[i]); cmdline = vstrextend(&cmdline, " ", quoted, NULL); amfree(quoted); } dbprintf(_("running: %s\n"), cmdline); amfree(cmdline); execve(dump_program, argv, safe_env()); e = strerror(errno); dbprintf(_("failed (%s)\n"), e); dbclose(); g_fprintf(stderr, _("rundump: could not exec %s: %s\n"), dump_program, e); return 1; #endif /* } */ }
void startup_tape_process( char *taper_program, int taper_parallel_write, gboolean no_taper) { int fd[2]; int i; char **config_options; taper_t *taper; /* always allocate the tapetable */ tapetable = calloc(sizeof(taper_t), taper_parallel_write+1); if (!tapetable) { error(_("could not g_malloc tapetable")); /*NOTREACHED*/ } for (taper = tapetable, i = 0; i < taper_parallel_write; taper++, i++) { taper->name = g_strdup_printf("worker%d", i); taper->sendresult = 0; taper->input_error = NULL; taper->tape_error = NULL; taper->result = 0; taper->dumper = NULL; taper->disk = NULL; taper->first_label = NULL; taper->first_fileno = 0; taper->state = TAPER_STATE_DEFAULT; taper->left = 0; taper->written = 0; /* jump right to degraded mode if there's no taper */ if (no_taper) { taper->tape_error = g_strdup("no taper started (--no-taper)"); taper->result = BOGUS; } } /* don't start the taper if we're not supposed to */ if (no_taper) return; if(socketpair(AF_UNIX, SOCK_STREAM, 0, fd) == -1) { error(_("taper pipe: %s"), strerror(errno)); /*NOTREACHED*/ } if(fd[0] < 0 || fd[0] >= (int)FD_SETSIZE) { error(_("taper socketpair 0: descriptor %d out of range (0 .. %d)\n"), fd[0], (int)FD_SETSIZE-1); /*NOTREACHED*/ } if(fd[1] < 0 || fd[1] >= (int)FD_SETSIZE) { error(_("taper socketpair 1: descriptor %d out of range (0 .. %d)\n"), fd[1], (int)FD_SETSIZE-1); /*NOTREACHED*/ } switch(taper_pid = fork()) { case -1: error(_("fork taper: %s"), strerror(errno)); /*NOTREACHED*/ case 0: /* child process */ aclose(fd[0]); if(dup2(fd[1], 0) == -1 || dup2(fd[1], 1) == -1) error(_("taper dup2: %s"), strerror(errno)); config_options = get_config_options(2); config_options[0] = "taper"; config_options[1] = get_config_name(); safe_fd(-1, 0); execve(taper_program, config_options, safe_env()); error("exec %s: %s", taper_program, strerror(errno)); /*NOTREACHED*/ default: /* parent process */ aclose(fd[1]); taper_fd = fd[0]; taper_ev_read = NULL; } }
static gboolean start_impl( XferElement *elt) { char *tmpbuf; XferFilterProcess *self = (XferFilterProcess *)elt; char *cmd_str; char **argv; char *errmsg; char **env; int rfd, wfd; /* first build up a log message of what we're going to do, properly shell quoted */ argv = self->argv; cmd_str = g_shell_quote(*(argv++)); while (*argv) { char *qarg = g_shell_quote(*(argv++)); tmpbuf = g_strconcat(cmd_str, " ", qarg, NULL); g_free(cmd_str); cmd_str = tmpbuf; g_free(qarg); } g_debug("%s spawning: %s", xfer_element_repr(elt), cmd_str); rfd = xfer_element_swap_output_fd(elt->upstream, -1); wfd = xfer_element_swap_input_fd(elt->downstream, -1); /* now fork off the child and connect the pipes */ switch (self->child_pid = fork()) { case -1: error("cannot fork: %s", strerror(errno)); /* NOTREACHED */ case 0: /* child */ /* first, copy our fd's out of the stdio range */ while (rfd >= 0 && rfd <= STDERR_FILENO) rfd = dup(rfd); while (wfd >= 0 && wfd <= STDERR_FILENO) wfd = dup(wfd); /* set up stdin, stdout, and stderr, overwriting anything already open * on those fd's */ if (rfd > 0) dup2(rfd, STDIN_FILENO); if (wfd > 0) dup2(wfd, STDOUT_FILENO); dup2(self->pipe_err[1], STDERR_FILENO); /* and close everything else */ safe_fd(-1, 0); env = safe_env(); if (self->need_root && !become_root()) { errmsg = g_strdup_printf("could not become root: %s\n", strerror(errno)); full_write(STDERR_FILENO, errmsg, strlen(errmsg)); exit(1); } execve(self->argv[0], self->argv, env); free_env(env); errmsg = g_strdup_printf("exec of '%s' failed: %s\n", self->argv[0], strerror(errno)); full_write(STDERR_FILENO, errmsg, strlen(errmsg)); exit(1); default: /* parent */ break; } g_free(cmd_str); /* close the pipe fd's */ close(rfd); close(wfd); close(self->pipe_err[1]); /* watch for child death */ self->child_watch = new_child_watch_source(self->child_pid); g_source_set_callback(self->child_watch, (GSourceFunc)child_watch_callback, self, NULL); g_source_attach(self->child_watch, NULL); g_source_unref(self->child_watch); return TRUE; }
static void amgtar_restore( application_argument_t *argument) { char *cmd; GPtrArray *argv_ptr = g_ptr_array_new(); char **env; int j; char *e; char *include_filename = NULL; char *exclude_filename = NULL; int tarpid; if (!gnutar_path) { error(_("GNUTAR-PATH not defined")); } cmd = g_strdup(gnutar_path); g_ptr_array_add(argv_ptr, g_strdup(gnutar_path)); g_ptr_array_add(argv_ptr, g_strdup("--numeric-owner")); if (gnutar_no_unquote) g_ptr_array_add(argv_ptr, g_strdup("--no-unquote")); if (gnutar_acls) g_ptr_array_add(argv_ptr, g_strdup("--acls")); if (gnutar_selinux) g_ptr_array_add(argv_ptr, g_strdup("--selinux")); if (gnutar_xattrs) g_ptr_array_add(argv_ptr, g_strdup("--xattrs")); /* ignore trailing zero blocks on input (this was the default until tar-1.21) */ if (argument->ignore_zeros) { g_ptr_array_add(argv_ptr, g_strdup("--ignore-zeros")); } if (argument->tar_blocksize) { g_ptr_array_add(argv_ptr, g_strdup("--blocking-factor")); g_ptr_array_add(argv_ptr, g_strdup(argument->tar_blocksize)); } g_ptr_array_add(argv_ptr, g_strdup("-xpGvf")); g_ptr_array_add(argv_ptr, g_strdup("-")); if (gnutar_directory) { struct stat stat_buf; if(stat(gnutar_directory, &stat_buf) != 0) { fprintf(stderr,"can not stat directory %s: %s\n", gnutar_directory, strerror(errno)); exit(1); } if (!S_ISDIR(stat_buf.st_mode)) { fprintf(stderr,"%s is not a directory\n", gnutar_directory); exit(1); } if (access(gnutar_directory, W_OK) != 0) { fprintf(stderr, "Can't write to %s: %s\n", gnutar_directory, strerror(errno)); exit(1); } g_ptr_array_add(argv_ptr, g_strdup("--directory")); g_ptr_array_add(argv_ptr, g_strdup(gnutar_directory)); } g_ptr_array_add(argv_ptr, g_strdup("--wildcards")); if (argument->dle.exclude_list && argument->dle.exclude_list->nb_element == 1) { FILE *exclude; char *sdisk; int in_argv; int entry_in_exclude = 0; char line[2*PATH_MAX]; FILE *exclude_list; if (argument->dle.disk) { sdisk = sanitise_filename(argument->dle.disk); } else { sdisk = g_strdup_printf("no_dle-%d", (int)getpid()); } exclude_filename= g_strjoin(NULL, AMANDA_TMPDIR, "/", "exclude-", sdisk, NULL); exclude_list = fopen(argument->dle.exclude_list->first->name, "r"); if (!exclude_list) { fprintf(stderr, "Cannot open exclude file '%s': %s\n", argument->dle.exclude_list->first->name, strerror(errno)); error("Cannot open exclude file '%s': %s\n", argument->dle.exclude_list->first->name, strerror(errno)); /*NOTREACHED*/ } exclude = fopen(exclude_filename, "w"); if (!exclude) { fprintf(stderr, "Cannot open exclude file '%s': %s\n", exclude_filename, strerror(errno)); fclose(exclude_list); error("Cannot open exclude file '%s': %s\n", exclude_filename, strerror(errno)); /*NOTREACHED*/ } while (fgets(line, 2*PATH_MAX, exclude_list)) { char *escaped; line[strlen(line)-1] = '\0'; /* remove '\n' */ escaped = escape_tar_glob(line, &in_argv); if (in_argv) { g_ptr_array_add(argv_ptr, "--exclude"); g_ptr_array_add(argv_ptr, escaped); } else { fprintf(exclude,"%s\n", escaped); entry_in_exclude++; amfree(escaped); } } fclose(exclude_list); fclose(exclude); g_ptr_array_add(argv_ptr, g_strdup("--exclude-from")); g_ptr_array_add(argv_ptr, exclude_filename); } if (argument->exclude_list_glob) { g_ptr_array_add(argv_ptr, g_strdup("--exclude-from")); g_ptr_array_add(argv_ptr, g_strdup(argument->exclude_list_glob)); } { GPtrArray *argv_include = g_ptr_array_new(); FILE *include; char *sdisk; int in_argv; guint i; int entry_in_include = 0; if (argument->dle.disk) { sdisk = sanitise_filename(argument->dle.disk); } else { sdisk = g_strdup_printf("no_dle-%d", (int)getpid()); } include_filename = g_strjoin(NULL, AMANDA_TMPDIR, "/", "include-", sdisk, NULL); include = fopen(include_filename, "w"); if (!include) { fprintf(stderr, "Cannot open include file '%s': %s\n", include_filename, strerror(errno)); error("Cannot open include file '%s': %s\n", include_filename, strerror(errno)); /*NOTREACHED*/ } if (argument->dle.include_list && argument->dle.include_list->nb_element == 1) { char line[2*PATH_MAX]; FILE *include_list = fopen(argument->dle.include_list->first->name, "r"); if (!include_list) { fclose(include); fprintf(stderr, "Cannot open include file '%s': %s\n", argument->dle.include_list->first->name, strerror(errno)); error("Cannot open include file '%s': %s\n", argument->dle.include_list->first->name, strerror(errno)); /*NOTREACHED*/ } while (fgets(line, 2*PATH_MAX, include_list)) { char *escaped; line[strlen(line)-1] = '\0'; /* remove '\n' */ escaped = escape_tar_glob(line, &in_argv); if (in_argv) { g_ptr_array_add(argv_include, escaped); } else { fprintf(include,"%s\n", escaped); entry_in_include++; amfree(escaped); } } fclose(include_list); } for (j=1; j< argument->argc; j++) { char *escaped = escape_tar_glob(argument->argv[j], &in_argv); if (in_argv) { g_ptr_array_add(argv_include, escaped); } else { fprintf(include,"%s\n", escaped); entry_in_include++; amfree(escaped); } } fclose(include); if (entry_in_include) { g_ptr_array_add(argv_ptr, g_strdup("--files-from")); g_ptr_array_add(argv_ptr, include_filename); } if (argument->include_list_glob) { g_ptr_array_add(argv_ptr, g_strdup("--files-from")); g_ptr_array_add(argv_ptr, g_strdup(argument->include_list_glob)); } for (i = 0; i < argv_include->len; i++) { g_ptr_array_add(argv_ptr, (char *)g_ptr_array_index(argv_include,i)); } amfree(sdisk); } g_ptr_array_add(argv_ptr, NULL); debug_executing(argv_ptr); tarpid = fork(); switch (tarpid) { case -1: error(_("%s: fork returned: %s"), get_pname(), strerror(errno)); case 0: env = safe_env(); become_root(); execve(cmd, (char **)argv_ptr->pdata, env); e = strerror(errno); error(_("error [exec %s: %s]"), cmd, e); break; default: break; } waitpid(tarpid, NULL, 0); if (argument->verbose == 0) { if (exclude_filename) unlink(exclude_filename); unlink(include_filename); } amfree(cmd); amfree(include_filename); amfree(exclude_filename); }
int main( int argc, char ** argv) { int foreground; int batch; int redirect; char **datearg = NULL; int nb_datearg = 0; char *conf_diskfile; char *conf_tapelist; char *conf_logfile; int conf_usetimestamps; disklist_t diskq; disk_t *dp; pid_t pid; pid_t driver_pid, reporter_pid; amwait_t exitcode; int opt; GSList *holding_list=NULL, *holding_file; int driver_pipe[2]; char date_string[100]; char date_string_standard[100]; time_t today; char *errstr; struct tm *tm; char *tapedev; char *tpchanger; char *qdisk, *qhname; GSList *datestamp_list = NULL; config_overrides_t *cfg_ovr; char **config_options; find_result_t *holding_files; disklist_t holding_disklist = { NULL, NULL }; /* * Configure program for internationalization: * 1) Only set the message locale for now. * 2) Set textdomain for all amanda related programs to "amanda" * We don't want to be forced to support dozens of message catalogs. */ setlocale(LC_MESSAGES, "C"); textdomain("amanda"); safe_fd(-1, 0); safe_cd(); set_pname("amflush"); /* Don't die when child closes pipe */ signal(SIGPIPE, SIG_IGN); dbopen(DBG_SUBDIR_SERVER); add_amanda_log_handler(amanda_log_stderr); foreground = 0; batch = 0; redirect = 1; /* process arguments */ cfg_ovr = new_config_overrides(argc/2); while((opt = getopt(argc, argv, "bfso:D:")) != EOF) { switch(opt) { case 'b': batch = 1; break; case 'f': foreground = 1; break; case 's': redirect = 0; break; case 'o': add_config_override_opt(cfg_ovr, optarg); break; case 'D': if (datearg == NULL) datearg = g_malloc(21*sizeof(char *)); if(nb_datearg == 20) { g_fprintf(stderr,_("maximum of 20 -D arguments.\n")); exit(1); } datearg[nb_datearg++] = g_strdup(optarg); datearg[nb_datearg] = NULL; break; } } argc -= optind, argv += optind; if(!foreground && !redirect) { g_fprintf(stderr,_("Can't redirect to stdout/stderr if not in forground.\n")); exit(1); } if(argc < 1) { error(_("Usage: amflush [-b] [-f] [-s] [-D date]* [-o configoption]* <confdir> [host [disk]* ]*")); /*NOTREACHED*/ } set_config_overrides(cfg_ovr); config_init(CONFIG_INIT_EXPLICIT_NAME, argv[0]); conf_diskfile = config_dir_relative(getconf_str(CNF_DISKFILE)); read_diskfile(conf_diskfile, &diskq); amfree(conf_diskfile); if (config_errors(NULL) >= CFGERR_WARNINGS) { config_print_errors(); if (config_errors(NULL) >= CFGERR_ERRORS) { g_critical(_("errors processing config file")); } } check_running_as(RUNNING_AS_DUMPUSER); dbrename(get_config_name(), DBG_SUBDIR_SERVER); /* load DLEs from the holding disk, in case there's anything to flush there */ search_holding_disk(&holding_files, &holding_disklist); /* note that the dumps are added to the global disklist, so we need not * consult holding_files or holding_disklist after this. The holding-only * dumps will be filtered properly by match_disklist, setting the dp->todo * flag appropriately. */ errstr = match_disklist(&diskq, argc-1, argv+1); if (errstr) { g_printf(_("%s"),errstr); amfree(errstr); } conf_tapelist = config_dir_relative(getconf_str(CNF_TAPELIST)); if(read_tapelist(conf_tapelist)) { error(_("could not load tapelist \"%s\""), conf_tapelist); /*NOTREACHED*/ } amfree(conf_tapelist); conf_usetimestamps = getconf_boolean(CNF_USETIMESTAMPS); amflush_datestamp = get_datestamp_from_time(0); if(conf_usetimestamps == 0) { amflush_timestamp = g_strdup(amflush_datestamp); } else { amflush_timestamp = get_timestamp_from_time(0); } conf_logdir = config_dir_relative(getconf_str(CNF_LOGDIR)); conf_logfile = g_strjoin(NULL, conf_logdir, "/log", NULL); if (access(conf_logfile, F_OK) == 0) { run_amcleanup(get_config_name()); } if (access(conf_logfile, F_OK) == 0) { char *process_name = get_master_process(conf_logfile); error(_("%s exists: %s is already running, or you must run amcleanup"), conf_logfile, process_name); /*NOTREACHED*/ } driver_program = g_strjoin(NULL, amlibexecdir, "/", "driver", NULL); reporter_program = g_strjoin(NULL, sbindir, "/", "amreport", NULL); logroll_program = g_strjoin(NULL, amlibexecdir, "/", "amlogroll", NULL); tapedev = getconf_str(CNF_TAPEDEV); tpchanger = getconf_str(CNF_TPCHANGER); if (tapedev == NULL && tpchanger == NULL) { error(_("No tapedev or tpchanger specified")); } /* if dates were specified (-D), then use match_datestamp * against the list of all datestamps to turn that list * into a set of existing datestamps (basically, evaluate the * expressions into actual datestamps) */ if(datearg) { GSList *all_datestamps; GSList *datestamp; int i, ok; all_datestamps = holding_get_all_datestamps(); for(datestamp = all_datestamps; datestamp != NULL; datestamp = datestamp->next) { ok = 0; for(i=0; i<nb_datearg && ok==0; i++) { ok = match_datestamp(datearg[i], (char *)datestamp->data); } if (ok) datestamp_list = g_slist_insert_sorted(datestamp_list, g_strdup((char *)datestamp->data), g_compare_strings); } slist_free_full(all_datestamps, g_free); } else { /* otherwise, in batch mode, use all datestamps */ if(batch) { datestamp_list = holding_get_all_datestamps(); } /* or allow the user to pick datestamps */ else { datestamp_list = pick_datestamp(); } } if(!datestamp_list) { g_printf(_("Could not find any Amanda directories to flush.\n")); exit(1); } holding_list = holding_get_files_for_flush(datestamp_list); if (holding_list == NULL) { g_printf(_("Could not find any valid dump image, check directory.\n")); exit(1); } if (access(conf_logfile, F_OK) == 0) { char *process_name = get_master_process(conf_logfile); error(_("%s exists: someone started %s"), conf_logfile, process_name); /*NOTREACHED*/ } log_add(L_INFO, "%s pid %ld", get_pname(), (long)getpid()); if(!batch) confirm(datestamp_list); for(dp = diskq.head; dp != NULL; dp = dp->next) { if(dp->todo) { char *qname; qname = quote_string(dp->name); log_add(L_DISK, "%s %s", dp->host->hostname, qname); amfree(qname); } } if(!foreground) { /* write it before redirecting stdout */ puts(_("Running in background, you can log off now.")); puts(_("You'll get mail when amflush is finished.")); } if(redirect) redirect_stderr(); if(!foreground) detach(); add_amanda_log_handler(amanda_log_stderr); add_amanda_log_handler(amanda_log_trace_log); today = time(NULL); tm = localtime(&today); if (tm) { strftime(date_string, 100, "%a %b %e %H:%M:%S %Z %Y", tm); strftime(date_string_standard, 100, "%Y-%m-%d %H:%M:%S %Z", tm); } else { error(_("BAD DATE")); /* should never happen */ } g_fprintf(stderr, _("amflush: start at %s\n"), date_string); g_fprintf(stderr, _("amflush: datestamp %s\n"), amflush_timestamp); g_fprintf(stderr, _("amflush: starttime %s\n"), amflush_timestamp); g_fprintf(stderr, _("amflush: starttime-locale-independent %s\n"), date_string_standard); log_add(L_START, _("date %s"), amflush_timestamp); /* START DRIVER */ if(pipe(driver_pipe) == -1) { error(_("error [opening pipe to driver: %s]"), strerror(errno)); /*NOTREACHED*/ } if((driver_pid = fork()) == 0) { /* * This is the child process. */ dup2(driver_pipe[0], 0); close(driver_pipe[1]); config_options = get_config_options(3); config_options[0] = "driver"; config_options[1] = get_config_name(); config_options[2] = "nodump"; safe_fd(-1, 0); execve(driver_program, config_options, safe_env()); error(_("cannot exec %s: %s"), driver_program, strerror(errno)); /*NOTREACHED*/ } else if(driver_pid == -1) { error(_("cannot fork for %s: %s"), driver_program, strerror(errno)); /*NOTREACHED*/ } driver_stream = fdopen(driver_pipe[1], "w"); if (!driver_stream) { error(_("Can't fdopen: %s"), strerror(errno)); /*NOTREACHED*/ } g_fprintf(driver_stream, "DATE %s\n", amflush_timestamp); for(holding_file=holding_list; holding_file != NULL; holding_file = holding_file->next) { dumpfile_t file; holding_file_get_dumpfile((char *)holding_file->data, &file); if (holding_file_size((char *)holding_file->data, 1) <= 0) { g_debug("%s is empty - ignoring", (char *)holding_file->data); log_add(L_INFO, "%s: removing file with no data.", (char *)holding_file->data); holding_file_unlink((char *)holding_file->data); dumpfile_free_data(&file); continue; } /* search_holding_disk should have already ensured that every * holding dumpfile has an entry in the dynamic disklist */ dp = lookup_disk(file.name, file.disk); assert(dp != NULL); /* but match_disklist may have indicated we should not flush it */ if (dp->todo == 0) continue; qdisk = quote_string(file.disk); qhname = quote_string((char *)holding_file->data); g_fprintf(stderr, "FLUSH %s %s %s %d %s\n", file.name, qdisk, file.datestamp, file.dumplevel, qhname); g_debug("flushing '%s'", (char *)holding_file->data); g_fprintf(driver_stream, "FLUSH %s %s %s %d %s\n", file.name, qdisk, file.datestamp, file.dumplevel, qhname); amfree(qdisk); amfree(qhname); dumpfile_free_data(&file); } g_fprintf(stderr, "ENDFLUSH\n"); fflush(stderr); g_fprintf(driver_stream, "ENDFLUSH\n"); fflush(driver_stream); fclose(driver_stream); /* WAIT DRIVER */ while(1) { if((pid = wait(&exitcode)) == -1) { if(errno == EINTR) { continue; } else { error(_("wait for %s: %s"), driver_program, strerror(errno)); /*NOTREACHED*/ } } else if (pid == driver_pid) { break; } } slist_free_full(datestamp_list, g_free); datestamp_list = NULL; slist_free_full(holding_list, g_free); holding_list = NULL; if(redirect) { /* rename errfile */ char *errfile, *errfilex, *nerrfilex, number[100]; int tapecycle; int maxdays, days; struct stat stat_buf; errfile = g_strjoin(NULL, conf_logdir, "/amflush", NULL); errfilex = NULL; nerrfilex = NULL; tapecycle = getconf_int(CNF_TAPECYCLE); maxdays = tapecycle + 2; days = 1; /* First, find out the last existing errfile, */ /* to avoid ``infinite'' loops if tapecycle is infinite */ g_snprintf(number,100,"%d",days); errfilex = newvstralloc(errfilex, errfile, ".", number, NULL); while ( days < maxdays && stat(errfilex,&stat_buf)==0) { days++; g_snprintf(number,100,"%d",days); errfilex = newvstralloc(errfilex, errfile, ".", number, NULL); } g_snprintf(number,100,"%d",days); errfilex = newvstralloc(errfilex, errfile, ".", number, NULL); nerrfilex = NULL; while (days > 1) { amfree(nerrfilex); nerrfilex = errfilex; days--; g_snprintf(number,100,"%d",days); errfilex = g_strjoin(NULL, errfile, ".", number, NULL); if (rename(errfilex, nerrfilex) != 0) { error(_("cannot rename \"%s\" to \"%s\": %s"), errfilex, nerrfilex, strerror(errno)); /*NOTREACHED*/ } } errfilex = newvstralloc(errfilex, errfile, ".1", NULL); if (rename(errfile,errfilex) != 0) { error(_("cannot rename \"%s\" to \"%s\": %s"), errfilex, nerrfilex, strerror(errno)); /*NOTREACHED*/ } amfree(errfile); amfree(errfilex); amfree(nerrfilex); } /* * Have amreport generate report and send mail. Note that we do * not bother checking the exit status. If it does not work, it * can be rerun. */ if((reporter_pid = fork()) == 0) { /* * This is the child process. */ config_options = get_config_options(3); config_options[0] = "amreport"; config_options[1] = get_config_name(); config_options[2] = "--from-amdump"; safe_fd(-1, 0); execve(reporter_program, config_options, safe_env()); error(_("cannot exec %s: %s"), reporter_program, strerror(errno)); /*NOTREACHED*/ } else if(reporter_pid == -1) { error(_("cannot fork for %s: %s"), reporter_program, strerror(errno)); /*NOTREACHED*/ } while(1) { if((pid = wait(&exitcode)) == -1) { if(errno == EINTR) { continue; } else { error(_("wait for %s: %s"), reporter_program, strerror(errno)); /*NOTREACHED*/ } } else if (pid == reporter_pid) { break; } } log_add(L_INFO, "pid-done %ld", (long)getpid()); /* * Call amlogroll to rename the log file to its datestamped version. * Since we exec at this point, our exit code will be that of amlogroll. */ config_options = get_config_options(2); config_options[0] = "amlogroll"; config_options[1] = get_config_name(); safe_fd(-1, 0); execve(logroll_program, config_options, safe_env()); error(_("cannot exec %s: %s"), logroll_program, strerror(errno)); /*NOTREACHED*/ return 0; /* keep the compiler happy */ }
static void amstar_restore( application_argument_t *argument) { char *cmd; GPtrArray *argv_ptr = g_ptr_array_new(); char **env; int j; char *e; if (!star_path) { error(_("STAR-PATH not defined")); } cmd = stralloc(star_path); g_ptr_array_add(argv_ptr, stralloc(star_path)); if (star_directory) { struct stat stat_buf; if(stat(star_directory, &stat_buf) != 0) { fprintf(stderr,"can not stat directory %s: %s\n", star_directory, strerror(errno)); exit(1); } if (!S_ISDIR(stat_buf.st_mode)) { fprintf(stderr,"%s is not a directory\n", star_directory); exit(1); } if (access(star_directory, W_OK) != 0 ) { fprintf(stderr, "Can't write to %s: %s\n", star_directory, strerror(errno)); exit(1); } g_ptr_array_add(argv_ptr, stralloc("-C")); g_ptr_array_add(argv_ptr, stralloc(star_directory)); } g_ptr_array_add(argv_ptr, stralloc("-x")); g_ptr_array_add(argv_ptr, stralloc("-v")); g_ptr_array_add(argv_ptr, stralloc("-xattr")); g_ptr_array_add(argv_ptr, stralloc("-acl")); g_ptr_array_add(argv_ptr, stralloc("errctl=WARN|SAMEFILE|SETTIME|DIFF|SETACL|SETXATTR|SETMODE|BADACL *")); g_ptr_array_add(argv_ptr, stralloc("-no-fifo")); g_ptr_array_add(argv_ptr, stralloc("-f")); g_ptr_array_add(argv_ptr, stralloc("-")); if (argument->dle.exclude_list && argument->dle.exclude_list->nb_element == 1) { g_ptr_array_add(argv_ptr, stralloc("-exclude-from")); g_ptr_array_add(argv_ptr, stralloc(argument->dle.exclude_list->first->name)); } if (argument->dle.include_list && argument->dle.include_list->nb_element == 1) { g_ptr_array_add(argv_ptr, stralloc2("list=", argument->dle.include_list->first->name)); } for (j=1; j< argument->argc; j++) g_ptr_array_add(argv_ptr, stralloc(argument->argv[j]+2));/*remove ./ */ g_ptr_array_add(argv_ptr, NULL); debug_executing(argv_ptr); env = safe_env(); become_root(); execve(cmd, (char **)argv_ptr->pdata, env); e = strerror(errno); error(_("error [exec %s: %s]"), cmd, e); }
int main( int argc, char ** argv) { int interactive = 0; int level = 0; int mesgpipe[2]; dle_t *dle = NULL; char *dumpdate, *stroptions; char *qdisk = NULL; char *qamdevice = NULL; char *line = NULL; char *err_extra = NULL; char *s; int i; int ch; GSList *errlist; FILE *mesgstream; level_t *alevel; /* initialize */ /* * Configure program for internationalization: * 1) Only set the message locale for now. * 2) Set textdomain for all amanda related programs to "amanda" * We don't want to be forced to support dozens of message catalogs. */ setlocale(LC_MESSAGES, "C"); textdomain("amanda"); safe_fd(DATA_FD_OFFSET, DATA_FD_COUNT*2); safe_cd(); set_pname("sendbackup"); /* Don't die when child closes pipe */ signal(SIGPIPE, SIG_IGN); /* Don't die when interrupt received */ signal(SIGINT, SIG_IGN); if(argc > 1 && strcmp(argv[1],"-t") == 0) { interactive = 1; argc--; argv++; } else { interactive = 0; } erroutput_type = (ERR_INTERACTIVE|ERR_SYSLOG); dbopen(DBG_SUBDIR_CLIENT); startclock(); dbprintf(_("Version %s\n"), version()); if(argc > 2 && strcmp(argv[1], "amandad") == 0) { amandad_auth = stralloc(argv[2]); } our_features = am_init_feature_set(); our_feature_string = am_feature_to_string(our_features); config_init(CONFIG_INIT_CLIENT, NULL); /* (check for config errors comes later) */ check_running_as(RUNNING_AS_CLIENT_LOGIN); if(interactive) { /* * In interactive (debug) mode, the backup data is sent to * /dev/null and none of the network connections back to driver * programs on the tape host are set up. The index service is * run and goes to stdout. */ g_fprintf(stderr, _("%s: running in interactive test mode\n"), get_pname()); fflush(stderr); } qdisk = NULL; dumpdate = NULL; stroptions = NULL; for(; (line = agets(stdin)) != NULL; free(line)) { if (line[0] == '\0') continue; if(interactive) { g_fprintf(stderr, "%s> ", get_pname()); fflush(stderr); } if(strncmp_const(line, "OPTIONS ") == 0) { g_options = parse_g_options(line+8, 1); if(!g_options->hostname) { g_options->hostname = alloc(MAX_HOSTNAME_LENGTH+1); gethostname(g_options->hostname, MAX_HOSTNAME_LENGTH); g_options->hostname[MAX_HOSTNAME_LENGTH] = '\0'; } if (g_options->config) { /* overlay this configuration on the existing (nameless) configuration */ config_init(CONFIG_INIT_CLIENT | CONFIG_INIT_EXPLICIT_NAME | CONFIG_INIT_OVERLAY, g_options->config); dbrename(get_config_name(), DBG_SUBDIR_CLIENT); } /* check for any config errors now */ if (config_errors(&errlist) >= CFGERR_ERRORS) { char *errstr = config_errors_to_error_string(errlist); g_printf("%s\n", errstr); dbclose(); return 1; } if (am_has_feature(g_options->features, fe_req_xml)) { break; } continue; } if (dle && dle->program != NULL) { err_extra = _("multiple requests"); goto err; } dbprintf(_(" sendbackup req: <%s>\n"), line); dle = alloc_dle(); s = line; ch = *s++; skip_whitespace(s, ch); /* find the program name */ if(ch == '\0') { err_extra = _("no program name"); goto err; /* no program name */ } dle->program = s - 1; skip_non_whitespace(s, ch); s[-1] = '\0'; if (strcmp(dle->program, "APPLICATION")==0) { dle->program_is_application_api=1; skip_whitespace(s, ch); /* find dumper name */ if (ch == '\0') { goto err; /* no program */ } dle->program = s - 1; skip_non_whitespace(s, ch); s[-1] = '\0'; } dle->program = stralloc(dle->program); skip_whitespace(s, ch); /* find the disk name */ if(ch == '\0') { err_extra = _("no disk name"); goto err; /* no disk name */ } amfree(qdisk); qdisk = s - 1; ch = *qdisk; skip_quoted_string(s, ch); s[-1] = '\0'; qdisk = stralloc(qdisk); dle->disk = unquote_string(qdisk); skip_whitespace(s, ch); /* find the device or level */ if (ch == '\0') { err_extra = _("bad level"); goto err; } if(!isdigit((int)s[-1])) { amfree(qamdevice); qamdevice = s - 1; ch = *qamdevice; skip_quoted_string(s, ch); s[-1] = '\0'; qamdevice = stralloc(qamdevice); dle->device = unquote_string(qamdevice); skip_whitespace(s, ch); /* find level number */ } else { dle->device = stralloc(dle->disk); qamdevice = stralloc(qdisk); } /* find the level number */ if(ch == '\0' || sscanf(s - 1, "%d", &level) != 1) { err_extra = _("bad level"); goto err; /* bad level */ } skip_integer(s, ch); alevel = g_new0(level_t, 1); alevel->level = level; dle->levellist = g_slist_append(dle->levellist, alevel); skip_whitespace(s, ch); /* find the dump date */ if(ch == '\0') { err_extra = _("no dumpdate"); goto err; /* no dumpdate */ } amfree(dumpdate); dumpdate = s - 1; skip_non_whitespace(s, ch); s[-1] = '\0'; dumpdate = stralloc(dumpdate); skip_whitespace(s, ch); /* find the options keyword */ if(ch == '\0') { err_extra = _("no options"); goto err; /* no options */ } if(strncmp_const_skip(s - 1, "OPTIONS ", s, ch) != 0) { err_extra = _("no OPTIONS keyword"); goto err; /* no options */ } skip_whitespace(s, ch); /* find the options string */ if(ch == '\0') { err_extra = _("bad options string"); goto err; /* no options */ } amfree(stroptions); stroptions = stralloc(s - 1); } amfree(line); if (g_options == NULL) { g_printf(_("ERROR [Missing OPTIONS line in sendbackup input]\n")); error(_("Missing OPTIONS line in sendbackup input\n")); /*NOTREACHED*/ } if (am_has_feature(g_options->features, fe_req_xml)) { char *errmsg = NULL; dle = amxml_parse_node_FILE(stdin, &errmsg); if (errmsg) { err_extra = errmsg; goto err; } if (!dle) { err_extra = _("One DLE required"); goto err; } else if (dle->next) { err_extra = _("Only one DLE allowed"); goto err; } qdisk = quote_string(dle->disk); if (dle->device == NULL) dle->device = stralloc(dle->disk); qamdevice = quote_string(dle->device); dumpdate = stralloc("NODATE"); stroptions = stralloc(""); } else { parse_options(stroptions, dle, g_options->features, 0); } gdle = dle; if (dle->program == NULL || dle->disk == NULL || dle->device == NULL || dle->levellist == NULL || dumpdate == NULL) { err_extra = _("no valid sendbackup request"); goto err; } if (g_slist_length(dle->levellist) != 1) { err_extra = _("Too many level"); goto err; } alevel = (level_t *)dle->levellist->data; level = alevel->level; dbprintf(_(" Parsed request as: program `%s'\n"), dle->program); dbprintf(_(" disk `%s'\n"), qdisk); dbprintf(_(" device `%s'\n"), qamdevice); dbprintf(_(" level %d\n"), level); dbprintf(_(" since %s\n"), dumpdate); dbprintf(_(" options `%s'\n"), stroptions); if (dle->program_is_application_api==1) { /* check that the application_api exist */ } else { for(i = 0; programs[i]; i++) { if (strcmp(programs[i]->name, dle->program) == 0) { break; } } if (programs[i] == NULL) { dbprintf(_("ERROR [%s: unknown program %s]\n"), get_pname(), dle->program); error(_("ERROR [%s: unknown program %s]"), get_pname(), dle->program); /*NOTREACHED*/ } program = programs[i]; } if(!interactive) { datafd = DATA_FD_OFFSET + 0; mesgfd = DATA_FD_OFFSET + 2; indexfd = DATA_FD_OFFSET + 4; } if (!dle->create_index) indexfd = -1; if (dle->auth && amandad_auth) { if(strcasecmp(dle->auth, amandad_auth) != 0) { g_printf(_("ERROR [client configured for auth=%s while server requested '%s']\n"), amandad_auth, dle->auth); exit(-1); } } if (dle->kencrypt) { g_printf("KENCRYPT\n"); } g_printf(_("CONNECT DATA %d MESG %d INDEX %d\n"), DATA_FD_OFFSET, DATA_FD_OFFSET+1, indexfd == -1 ? -1 : DATA_FD_OFFSET+2); g_printf(_("OPTIONS ")); if(am_has_feature(g_options->features, fe_rep_options_features)) { g_printf("features=%s;", our_feature_string); } if(am_has_feature(g_options->features, fe_rep_options_hostname)) { g_printf("hostname=%s;", g_options->hostname); } g_printf("\n"); fflush(stdout); if (freopen("/dev/null", "w", stdout) == NULL) { dbprintf(_("Error redirecting stdout to /dev/null: %s\n"), strerror(errno)); exit(1); } if(interactive) { if((datafd = open("/dev/null", O_RDWR)) < 0) { error(_("ERROR [open of /dev/null for debug data stream: %s]\n"), strerror(errno)); /*NOTREACHED*/ } mesgfd = 2; indexfd = 1; } if(!interactive) { if(datafd == -1 || mesgfd == -1 || (dle->create_index && indexfd == -1)) { dbclose(); exit(1); } } mesgstream = fdopen(mesgfd,"w"); run_client_scripts(EXECUTE_ON_PRE_DLE_BACKUP, g_options, dle, mesgstream); fflush(mesgstream); if (dle->program_is_application_api==1) { guint j; char *cmd=NULL; GPtrArray *argv_ptr; char levelstr[20]; backup_support_option_t *bsu; char *compopt = NULL; char *encryptopt = skip_argument; int compout, dumpout; GSList *scriptlist; script_t *script; time_t cur_dumptime; int result; GPtrArray *errarray; int errfd[2]; FILE *dumperr; /* apply client-side encryption here */ if ( dle->encrypt == ENCRYPT_CUST ) { encpid = pipespawn(dle->clnt_encrypt, STDIN_PIPE, 0, &compout, &datafd, &mesgfd, dle->clnt_encrypt, encryptopt, NULL); dbprintf(_("encrypt: pid %ld: %s\n"), (long)encpid, dle->clnt_encrypt); } else { compout = datafd; encpid = -1; } /* now do the client-side compression */ if(dle->compress == COMP_FAST || dle->compress == COMP_BEST) { compopt = skip_argument; #if defined(COMPRESS_BEST_OPT) && defined(COMPRESS_FAST_OPT) if(dle->compress == COMP_BEST) { compopt = COMPRESS_BEST_OPT; } else { compopt = COMPRESS_FAST_OPT; } #endif comppid = pipespawn(COMPRESS_PATH, STDIN_PIPE, 0, &dumpout, &compout, &mesgfd, COMPRESS_PATH, compopt, NULL); dbprintf(_("gnutar: pid %ld: %s"), (long)comppid, COMPRESS_PATH); if(compopt != skip_argument) { dbprintf(_("pid %ld: %s %s\n"), (long)comppid, COMPRESS_PATH, compopt); } else { dbprintf(_("pid %ld: %s\n"), (long)comppid, COMPRESS_PATH); } } else if (dle->compress == COMP_CUST) { compopt = skip_argument; comppid = pipespawn(dle->compprog, STDIN_PIPE, 0, &dumpout, &compout, &mesgfd, dle->compprog, compopt, NULL); if(compopt != skip_argument) { dbprintf(_("pid %ld: %s %s\n"), (long)comppid, dle->compprog, compopt); } else { dbprintf(_("pid %ld: %s\n"), (long)comppid, dle->compprog); } } else { dumpout = compout; comppid = -1; } cur_dumptime = time(0); bsu = backup_support_option(dle->program, g_options, dle->disk, dle->device, &errarray); if (!bsu) { char *errmsg; char *qerrmsg; guint i; for (i=0; i < errarray->len; i++) { errmsg = g_ptr_array_index(errarray, i); qerrmsg = quote_string(errmsg); fdprintf(mesgfd, _("sendbackup: error [Application '%s': %s]\n"), dle->program, errmsg); dbprintf("aa: %s\n",qerrmsg); amfree(qerrmsg); } if (i == 0) { /* no errarray */ errmsg = vstrallocf(_("Can't execute application '%s'"), dle->program); qerrmsg = quote_string(errmsg); fdprintf(mesgfd, _("sendbackup: error [%s]\n"), errmsg); dbprintf(_("ERROR %s\n"), qerrmsg); amfree(qerrmsg); amfree(errmsg); } return 0; } if (pipe(errfd) < 0) { char *errmsg; char *qerrmsg; errmsg = vstrallocf(_("Application '%s': can't create pipe"), dle->program); qerrmsg = quote_string(errmsg); fdprintf(mesgfd, _("sendbackup: error [%s]\n"), errmsg); dbprintf(_("ERROR %s\n"), qerrmsg); amfree(qerrmsg); amfree(errmsg); return 0; } switch(application_api_pid=fork()) { case 0: argv_ptr = g_ptr_array_new(); cmd = vstralloc(APPLICATION_DIR, "/", dle->program, NULL); g_ptr_array_add(argv_ptr, stralloc(dle->program)); g_ptr_array_add(argv_ptr, stralloc("backup")); if (bsu->message_line == 1) { g_ptr_array_add(argv_ptr, stralloc("--message")); g_ptr_array_add(argv_ptr, stralloc("line")); } if (g_options->config && bsu->config == 1) { g_ptr_array_add(argv_ptr, stralloc("--config")); g_ptr_array_add(argv_ptr, stralloc(g_options->config)); } if (g_options->hostname && bsu->host == 1) { g_ptr_array_add(argv_ptr, stralloc("--host")); g_ptr_array_add(argv_ptr, stralloc(g_options->hostname)); } if (dle->disk && bsu->disk == 1) { g_ptr_array_add(argv_ptr, stralloc("--disk")); g_ptr_array_add(argv_ptr, stralloc(dle->disk)); } g_ptr_array_add(argv_ptr, stralloc("--device")); g_ptr_array_add(argv_ptr, stralloc(dle->device)); if (level <= bsu->max_level) { g_ptr_array_add(argv_ptr, stralloc("--level")); g_snprintf(levelstr,19,"%d",level); g_ptr_array_add(argv_ptr, stralloc(levelstr)); } if (indexfd != -1 && bsu->index_line == 1) { g_ptr_array_add(argv_ptr, stralloc("--index")); g_ptr_array_add(argv_ptr, stralloc("line")); } if (dle->record && bsu->record == 1) { g_ptr_array_add(argv_ptr, stralloc("--record")); } application_property_add_to_argv(argv_ptr, dle, bsu); for (scriptlist = dle->scriptlist; scriptlist != NULL; scriptlist = scriptlist->next) { script = (script_t *)scriptlist->data; if (script->result && script->result->proplist) { property_add_to_argv(argv_ptr, script->result->proplist); } } g_ptr_array_add(argv_ptr, NULL); dbprintf(_("%s: running \"%s\n"), get_pname(), cmd); for (j = 1; j < argv_ptr->len - 1; j++) dbprintf(" %s\n", (char *)g_ptr_array_index(argv_ptr,j)); dbprintf(_("\"\n")); if(dup2(dumpout, 1) == -1) { error(_("Can't dup2: %s"),strerror(errno)); /*NOTREACHED*/ } if (dup2(errfd[1], 2) == -1) { error(_("Can't dup2: %s"),strerror(errno)); /*NOTREACHED*/ } if(dup2(mesgfd, 3) == -1) { error(_("Can't dup2: %s"),strerror(errno)); /*NOTREACHED*/ } if(indexfd > 0) { if(dup2(indexfd, 4) == -1) { error(_("Can't dup2: %s"),strerror(errno)); /*NOTREACHED*/ } fcntl(indexfd, F_SETFD, 0); } application_api_info_tapeheader(mesgfd, dle->program, dle); if (indexfd != 0) { safe_fd(3, 2); } else { safe_fd(3, 1); } execve(cmd, (char **)argv_ptr->pdata, safe_env()); exit(1); break; default: break; case -1: error(_("%s: fork returned: %s"), get_pname(), strerror(errno)); } close(errfd[1]); dumperr = fdopen(errfd[0],"r"); if (!dumperr) { error(_("Can't fdopen: %s"), strerror(errno)); /*NOTREACHED*/ } result = 0; while ((line = agets(dumperr)) != NULL) { if (strlen(line) > 0) { fdprintf(mesgfd, "sendbackup: error [%s]\n", line); dbprintf("error: %s\n", line); result = 1; } amfree(line); } result |= check_result(mesgfd); if (result == 0) { char *amandates_file; amandates_file = getconf_str(CNF_AMANDATES); if(start_amandates(amandates_file, 1)) { amandates_updateone(dle->disk, level, cur_dumptime); finish_amandates(); free_amandates(); } else { if (GPOINTER_TO_INT(dle->estimatelist->data) == ES_CALCSIZE && bsu->calcsize) { error(_("error [opening %s for writing: %s]"), amandates_file, strerror(errno)); } else { g_debug(_("non-fatal error opening '%s' for writing: %s]"), amandates_file, strerror(errno)); } } } amfree(bsu); } else { if(!interactive) { /* redirect stderr */ if(dup2(mesgfd, 2) == -1) { dbprintf(_("Error redirecting stderr to fd %d: %s\n"), mesgfd, strerror(errno)); dbclose(); exit(1); } } if(pipe(mesgpipe) == -1) { s = strerror(errno); dbprintf(_("error [opening mesg pipe: %s]\n"), s); error(_("error [opening mesg pipe: %s]"), s); } program->start_backup(dle, g_options->hostname, datafd, mesgpipe[1], indexfd); dbprintf(_("Started backup\n")); parse_backup_messages(dle, mesgpipe[0]); dbprintf(_("Parsed backup messages\n")); } run_client_scripts(EXECUTE_ON_POST_DLE_BACKUP, g_options, dle, mesgstream); fflush(mesgstream); amfree(qdisk); amfree(qamdevice); amfree(dumpdate); amfree(stroptions); amfree(our_feature_string); am_release_feature_set(our_features); our_features = NULL; free_g_options(g_options); dbclose(); return 0; err: if (err_extra) { g_printf(_("ERROR FORMAT ERROR IN REQUEST PACKET '%s'\n"), err_extra); dbprintf(_("REQ packet is bogus: %s\n"), err_extra); } else { g_printf(_("ERROR FORMAT ERROR IN REQUEST PACKET\n")); dbprintf(_("REQ packet is bogus\n")); } amfree(qdisk); amfree(qamdevice); amfree(dumpdate); amfree(stroptions); amfree(our_feature_string); dbclose(); return 1; }
pid_t pipespawnv_passwd( char * prog, int pipedef, int need_root, int * stdinfd, int * stdoutfd, int * stderrfd, char ** my_argv) { pid_t pid; int i, inpipe[2], outpipe[2], errpipe[2], passwdpipe[2]; char number[NUM_STR_SIZE]; char **arg; char *e; char **env; char *cmdline; char **newenv; char *passwdvar = NULL; int *passwdfd = NULL; GPtrArray *array = g_ptr_array_new(); gchar **strings; /* * Log the command line and count the args. */ if ((pipedef & PASSWD_PIPE) != 0) { passwdvar = *my_argv++; passwdfd = (int *)*my_argv++; } memset(inpipe, -1, sizeof(inpipe)); memset(outpipe, -1, sizeof(outpipe)); memset(errpipe, -1, sizeof(errpipe)); memset(passwdpipe, -1, sizeof(passwdpipe)); g_ptr_array_add(array, g_strdup(prog)); for(arg = my_argv; *arg != NULL; arg++) { if (*arg == skip_argument) continue; g_ptr_array_add(array, quote_string(*arg)); } g_ptr_array_add(array, NULL); strings = (gchar **)g_ptr_array_free(array, FALSE); cmdline = g_strjoinv(" ", strings); g_strfreev(strings); dbprintf(_("Spawning \"%s\" in pipeline\n"), cmdline); /* * Create the pipes */ if ((pipedef & STDIN_PIPE) != 0) { if(pipe(inpipe) == -1) { error(_("error [open pipe to %s: %s]"), prog, strerror(errno)); /*NOTREACHED*/ } } if ((pipedef & STDOUT_PIPE) != 0) { if(pipe(outpipe) == -1) { error(_("error [open pipe to %s: %s]"), prog, strerror(errno)); /*NOTREACHED*/ } } if ((pipedef & STDERR_PIPE) != 0) { if(pipe(errpipe) == -1) { error(_("error [open pipe to %s: %s]"), prog, strerror(errno)); /*NOTREACHED*/ } } if ((pipedef & PASSWD_PIPE) != 0) { if(pipe(passwdpipe) == -1) { error(_("error [open pipe to %s: %s]"), prog, strerror(errno)); /*NOTREACHED*/ } } /* * Fork and set up the return or run the program. */ switch(pid = fork()) { case -1: e = strerror(errno); error(_("error [fork %s: %s]"), prog, e); /*NOTREACHED*/ default: /* parent process */ if ((pipedef & STDIN_PIPE) != 0) { aclose(inpipe[0]); /* close input side of pipe */ *stdinfd = inpipe[1]; } if ((pipedef & STDOUT_PIPE) != 0) { aclose(outpipe[1]); /* close output side of pipe */ *stdoutfd = outpipe[0]; } if ((pipedef & STDERR_PIPE) != 0) { aclose(errpipe[1]); /* close output side of pipe */ *stderrfd = errpipe[0]; } if ((pipedef & PASSWD_PIPE) != 0) { aclose(passwdpipe[0]); /* close input side of pipe */ *passwdfd = passwdpipe[1]; } break; case 0: /* child process */ debug_dup_stderr_to_debug(); if ((pipedef & STDIN_PIPE) != 0) { aclose(inpipe[1]); /* close output side of pipe */ } else { inpipe[0] = *stdinfd; } if ((pipedef & STDOUT_PIPE) != 0) { aclose(outpipe[0]); /* close input side of pipe */ } else { outpipe[1] = *stdoutfd; } if ((pipedef & STDERR_PIPE) != 0) { aclose(errpipe[0]); /* close input side of pipe */ } else { errpipe[1] = *stderrfd; } if ((pipedef & PASSWD_PIPE) != 0) { aclose(passwdpipe[1]); /* close output side of pipe */ } /* * Shift the pipes to the standard file descriptors as requested. */ if(dup2(inpipe[0], 0) == -1) { g_fprintf(stderr, "error [spawn %s: dup2 in: %s]", prog, strerror(errno)); exit(1); /*NOTREACHED*/ } if(dup2(outpipe[1], 1) == -1) { g_fprintf(stderr, "error [spawn %s: dup2 out: %s]", prog, strerror(errno)); exit(1); /*NOTREACHED*/ } if(dup2(errpipe[1], 2) == -1) { g_fprintf(stderr, "error [spawn %s: dup2 err: %s]", prog, strerror(errno)); exit(1); /*NOTREACHED*/ } /* * Get the "safe" environment. If we are sending a password to * the child via a pipe, add the environment variable for that. */ env = safe_env(); if ((pipedef & PASSWD_PIPE) != 0) { for (i = 0; env[i] != NULL; i++) (void)i; /* make lint happy and do nothing */ newenv = (char **)g_malloc((i + 1 + 1) * sizeof(*newenv)); g_snprintf(number, sizeof(number), "%d", passwdpipe[0]); newenv[0] = g_strjoin(NULL, passwdvar, "=", number, NULL); for(i = 0; env[i] != NULL; i++) newenv[i + 1] = env[i]; newenv[i + 1] = NULL; amfree(env); env = newenv; safe_fd(passwdpipe[0], 1); } else { safe_fd(-1, 0); } if (need_root) { become_root(); } else { /* if our real userid is zero, the child shouldn't inherit * that, so drop privs permanently */ if (getuid() == 0 && !set_root_privs(-1)) { error(_("could not drop root privileges")); } } execve(prog, my_argv, env); e = strerror(errno); error(_("error [exec %s: %s]"), prog, e); /*NOTREACHED*/ } amfree(cmdline); return pid; }
static void amstar_restore( application_argument_t *argument) { char *cmd; GPtrArray *argv_ptr = g_ptr_array_new(); char **env; int j; char *e; if (!star_path) { error(_("STAR-PATH not defined")); } cmd = g_strdup(star_path); g_ptr_array_add(argv_ptr, g_strdup(star_path)); if (star_directory) { struct stat stat_buf; if(stat(star_directory, &stat_buf) != 0) { fprintf(stderr,"can not stat directory %s: %s\n", star_directory, strerror(errno)); exit(1); } if (!S_ISDIR(stat_buf.st_mode)) { fprintf(stderr,"%s is not a directory\n", star_directory); exit(1); } if (access(star_directory, W_OK) != 0 ) { fprintf(stderr, "Can't write to %s: %s\n", star_directory, strerror(errno)); exit(1); } g_ptr_array_add(argv_ptr, g_strdup("-C")); g_ptr_array_add(argv_ptr, g_strdup(star_directory)); } g_ptr_array_add(argv_ptr, g_strdup("-x")); g_ptr_array_add(argv_ptr, g_strdup("-v")); g_ptr_array_add(argv_ptr, g_strdup("-xattr")); g_ptr_array_add(argv_ptr, g_strdup("-acl")); g_ptr_array_add(argv_ptr, g_strdup("errctl=WARN|SAMEFILE|SETTIME|DIFF|SETACL|SETXATTR|SETMODE|BADACL *")); g_ptr_array_add(argv_ptr, g_strdup("-no-fifo")); g_ptr_array_add(argv_ptr, g_strdup("-f")); g_ptr_array_add(argv_ptr, g_strdup("-")); if (argument->dle.exclude_list && argument->dle.exclude_list->nb_element == 1) { g_ptr_array_add(argv_ptr, g_strdup("-exclude-from")); g_ptr_array_add(argv_ptr, g_strdup(argument->dle.exclude_list->first->name)); } if (argument->dle.include_list && argument->dle.include_list->nb_element == 1) { FILE *include_list = fopen(argument->dle.include_list->first->name, "r"); if (include_list) { char line[2*PATH_MAX+2]; while (fgets(line, 2*PATH_MAX, include_list)) { line[strlen(line)-1] = '\0'; /* remove '\n' */ if (strncmp(line, "./", 2) == 0) g_ptr_array_add(argv_ptr, g_strdup(line+2)); /* remove ./ */ else if (strcmp(line, ".") != 0) g_ptr_array_add(argv_ptr, g_strdup(line)); } fclose(include_list); } } for (j=1; j< argument->argc; j++) { if (strncmp(argument->argv[j], "./", 2) == 0) g_ptr_array_add(argv_ptr, g_strdup(argument->argv[j]+2));/*remove ./ */ else if (strcmp(argument->argv[j], ".") != 0) g_ptr_array_add(argv_ptr, g_strdup(argument->argv[j])); } g_ptr_array_add(argv_ptr, NULL); debug_executing(argv_ptr); env = safe_env(); become_root(); execve(cmd, (char **)argv_ptr->pdata, env); e = strerror(errno); error(_("error [exec %s: %s]"), cmd, e); }
static void check_disk( dle_t *dle) { char *device = NULL; char *err = NULL; char *user_and_password = NULL; char *domain = NULL; char *share = NULL, *subdir = NULL; size_t lpass = 0; int amode = R_OK; int access_result; char *access_type; char *extra_info = NULL; char *qdisk = NULL; char *qamdevice = NULL; char *qdevice = NULL; if (dle->disk) { need_global_check=1; qdisk = quote_string(dle->disk); qamdevice = quote_string(dle->device); device = g_strdup("nodevice"); dbprintf(_("checking disk %s\n"), qdisk); if (GPOINTER_TO_INT(dle->estimatelist->data) == ES_CALCSIZE) { if (dle->device[0] == '/' && dle->device[1] == '/') { err = g_strdup_printf( _("Can't use CALCSIZE for samba estimate, use CLIENT: %s"), dle->device); goto common_exit; } } if (g_str_equal(dle->program, "GNUTAR")) { if(dle->device[0] == '/' && dle->device[1] == '/') { #ifdef SAMBA_CLIENT int nullfd, checkerr; int passwdfd; char *pwtext; size_t pwtext_len; pid_t checkpid; amwait_t retstat; pid_t wpid; int rc; char *line; char *sep; FILE *ferr; char *pw_fd_env; int errdos; parsesharename(dle->device, &share, &subdir); if (!share) { err = g_strdup_printf( _("cannot parse for share/subdir disk entry %s"), dle->device); goto common_exit; } if ((subdir) && (SAMBA_VERSION < 2)) { err = g_strdup_printf(_("subdirectory specified for share '%s' but, samba is not v2 or better"), dle->device); goto common_exit; } if ((user_and_password = findpass(share, &domain)) == NULL) { err = g_strdup_printf(_("cannot find password for %s"), dle->device); goto common_exit; } lpass = strlen(user_and_password); if ((pwtext = strchr(user_and_password, '%')) == NULL) { err = g_strdup_printf( _("password field not \'user%%pass\' for %s"), dle->device); goto common_exit; } *pwtext++ = '\0'; pwtext_len = (size_t)strlen(pwtext); amfree(device); if ((device = makesharename(share, 0)) == NULL) { err = g_strdup_printf(_("cannot make share name of %s"), share); goto common_exit; } if ((nullfd = open("/dev/null", O_RDWR)) == -1) { err = g_strdup_printf(_("Cannot access /dev/null : %s"), strerror(errno)); goto common_exit; } if (pwtext_len > 0) { pw_fd_env = "PASSWD_FD"; } else { pw_fd_env = "dummy_PASSWD_FD"; } checkpid = pipespawn(SAMBA_CLIENT, STDERR_PIPE|PASSWD_PIPE, 0, &nullfd, &nullfd, &checkerr, pw_fd_env, &passwdfd, "smbclient", device, *user_and_password ? "-U" : skip_argument, *user_and_password ? user_and_password : skip_argument, "-E", domain ? "-W" : skip_argument, domain ? domain : skip_argument, #if SAMBA_VERSION >= 2 subdir ? "-D" : skip_argument, subdir ? subdir : skip_argument, #endif "-c", "quit", NULL); checkpid = checkpid; amfree(domain); aclose(nullfd); /*@ignore@*/ if ((pwtext_len > 0) && full_write(passwdfd, pwtext, pwtext_len) < pwtext_len) { err = g_strdup_printf(_("password write failed: %s: %s"), dle->device, strerror(errno)); aclose(passwdfd); goto common_exit; } /*@end@*/ memset(user_and_password, '\0', (size_t)lpass); amfree(user_and_password); aclose(passwdfd); ferr = fdopen(checkerr, "r"); if (!ferr) { g_printf(_("ERROR [Can't fdopen ferr: %s]\n"), strerror(errno)); error(_("Can't fdopen ferr: %s"), strerror(errno)); /*NOTREACHED*/ } sep = ""; errdos = 0; for(sep = ""; (line = agets(ferr)) != NULL; free(line)) { if (line[0] == '\0') continue; strappend(extra_info, sep); strappend(extra_info, line); sep = ": "; if(strstr(line, "ERRDOS") != NULL) { errdos = 1; } } afclose(ferr); checkerr = -1; rc = 0; sep = ""; while ((wpid = wait(&retstat)) != -1) { if (!WIFEXITED(retstat) || WEXITSTATUS(retstat) != 0) { char *exitstr = str_exit_status("smbclient", retstat); strappend(err, sep); strappend(err, exitstr); sep = "\n"; amfree(exitstr); rc = 1; } } if (errdos != 0 || rc != 0) { char *tmpbuf; if (extra_info) { tmpbuf = g_strdup_printf( _("samba access error: %s: %s %s"), dle->device, extra_info, err); amfree(extra_info); } else { tmpbuf = g_strdup_printf(_("samba access error: %s: %s"), dle->device, err); } g_free(err); err = tmpbuf; } #else err = g_strdup_printf( _("This client is not configured for samba: %s"), qdisk); #endif goto common_exit; } amode = F_OK; amfree(device); device = amname_to_dirname(dle->device); } else if (g_str_equal(dle->program, "DUMP")) { if(dle->device[0] == '/' && dle->device[1] == '/') { err = g_strdup_printf( _("The DUMP program cannot handle samba shares, use GNUTAR: %s"), qdisk); goto common_exit; } #ifdef VDUMP /* { */ #ifdef DUMP /* { */ if (g_str_equal(amname_to_fstype(dle->device), "advfs")) #else /* }{*/ if (1) #endif /* } */ { amfree(device); device = amname_to_dirname(dle->device); amode = F_OK; } else #endif /* } */ { amfree(device); device = amname_to_devname(dle->device); #ifdef USE_RUNDUMP amode = F_OK; #else amode = R_OK; #endif } } } if (dle->program_is_application_api) { pid_t application_api_pid; backup_support_option_t *bsu; int app_err[2]; GPtrArray *errarray; bsu = backup_support_option(dle->program, g_options, dle->disk, dle->device, &errarray); if (!bsu) { char *line; guint i; for (i=0; i < errarray->len; i++) { line = g_ptr_array_index(errarray, i); fprintf(stdout, _("ERROR Application '%s': %s\n"), dle->program, line); amfree(line); } err = g_strdup_printf(_("Application '%s': can't run support command"), dle->program); goto common_exit; } if (dle->data_path == DATA_PATH_AMANDA && (bsu->data_path_set & DATA_PATH_AMANDA)==0) { g_printf("ERROR application %s doesn't support amanda data-path\n", dle->program); } if (dle->data_path == DATA_PATH_DIRECTTCP && (bsu->data_path_set & DATA_PATH_DIRECTTCP)==0) { g_printf("ERROR application %s doesn't support directtcp data-path\n", dle->program); } if (GPOINTER_TO_INT(dle->estimatelist->data) == ES_CALCSIZE && !bsu->calcsize) { g_printf("ERROR application %s doesn't support calcsize estimate\n", dle->program); } if (dle->include_file && dle->include_file->nb_element > 0 && !bsu->include_file) { g_printf("ERROR application %s doesn't support include-file\n", dle->program); } if (dle->include_list && dle->include_list->nb_element > 0 && !bsu->include_list) { g_printf("ERROR application %s doesn't support include-list\n", dle->program); } if (dle->include_optional && !bsu->include_optional) { g_printf("ERROR application %s doesn't support optional include\n", dle->program); } if (dle->exclude_file && dle->exclude_file->nb_element > 0 && !bsu->exclude_file) { g_printf("ERROR application %s doesn't support exclude-file\n", dle->program); } if (dle->exclude_list && dle->exclude_list->nb_element > 0 && !bsu->exclude_list) { g_printf("ERROR application %s doesn't support exclude-list\n", dle->program); } if (dle->exclude_optional && !bsu->exclude_optional) { g_printf("ERROR application %s doesn't support optional exclude\n", dle->program); } fflush(stdout);fflush(stderr); if (pipe(app_err) < 0) { err = g_strdup_printf(_("Application '%s': can't create pipe"), dle->program); goto common_exit; } switch (application_api_pid = fork()) { case -1: err = g_strdup_printf(_("fork failed: %s"), strerror(errno)); goto common_exit; case 0: /* child */ { GPtrArray *argv_ptr = g_ptr_array_new(); GPtrArray *argv_quoted = g_ptr_array_new(); gchar **args, **quoted_strings, **ptr; char *cmd = g_strjoin(NULL, APPLICATION_DIR, "/", dle->program, NULL); GSList *scriptlist; script_t *script; estimatelist_t el; char *cmdline; aclose(app_err[0]); dup2(app_err[1], 2); g_ptr_array_add(argv_ptr, g_strdup(dle->program)); g_ptr_array_add(argv_ptr, g_strdup("selfcheck")); if (bsu->message_line == 1) { g_ptr_array_add(argv_ptr, g_strdup("--message")); g_ptr_array_add(argv_ptr, g_strdup("line")); } if (g_options->config != NULL && bsu->config == 1) { g_ptr_array_add(argv_ptr, g_strdup("--config")); g_ptr_array_add(argv_ptr, g_strdup(g_options->config)); } if (g_options->hostname != NULL && bsu->host == 1) { g_ptr_array_add(argv_ptr, g_strdup("--host")); g_ptr_array_add(argv_ptr, g_strdup(g_options->hostname)); } if (dle->disk != NULL && bsu->disk == 1) { g_ptr_array_add(argv_ptr, g_strdup("--disk")); g_ptr_array_add(argv_ptr, g_strdup(dle->disk)); } if (dle->device) { g_ptr_array_add(argv_ptr, g_strdup("--device")); g_ptr_array_add(argv_ptr, g_strdup(dle->device)); } if (dle->create_index && bsu->index_line == 1) { g_ptr_array_add(argv_ptr, g_strdup("--index")); g_ptr_array_add(argv_ptr, g_strdup("line")); } if (dle->record && bsu->record == 1) { g_ptr_array_add(argv_ptr, g_strdup("--record")); } for (el = dle->estimatelist; el != NULL; el=el->next) { estimate_t estimate = (estimate_t)GPOINTER_TO_INT(el->data); if (estimate == ES_CALCSIZE && bsu->calcsize == 1) { g_ptr_array_add(argv_ptr, g_strdup("--calcsize")); } } application_property_add_to_argv(argv_ptr, dle, bsu, g_options->features); for (scriptlist = dle->scriptlist; scriptlist != NULL; scriptlist = scriptlist->next) { script = (script_t *)scriptlist->data; if (script->result && script->result->proplist) { property_add_to_argv(argv_ptr, script->result->proplist); } } g_ptr_array_add(argv_ptr, NULL); args = (gchar **)g_ptr_array_free(argv_ptr, FALSE); /* * Build the command line to display */ g_ptr_array_add(argv_quoted, g_strdup(cmd)); for (ptr = args; *ptr; ptr++) g_ptr_array_add(argv_quoted, quote_string(*ptr)); g_ptr_array_add(argv_quoted, NULL); quoted_strings = (gchar **)g_ptr_array_free(argv_quoted, FALSE); cmdline = g_strjoinv(" ", quoted_strings); g_strfreev(quoted_strings); dbprintf(_("Spawning \"%s\" in pipeline\n"), cmdline); amfree(cmdline); safe_fd(-1, 0); execve(cmd, args, safe_env()); g_printf(_("ERROR [Can't execute %s: %s]\n"), cmd, strerror(errno)); exit(127); } default: /* parent */ { int status; FILE *app_stderr; char *line; aclose(app_err[1]); app_stderr = fdopen(app_err[0], "r"); if (!app_stderr) { g_printf(_("ERROR [Can't fdopen app_stderr: %s]\n"), strerror(errno)); error(_("Can't fdopen app_stderr: %s"), strerror(errno)); /*NOTREACHED*/ } while((line = agets(app_stderr)) != NULL) { if (strlen(line) > 0) { fprintf(stdout, "ERROR Application '%s': %s\n", dle->program, line); dbprintf("ERROR %s\n", line); } amfree(line); } fclose(app_stderr); if (waitpid(application_api_pid, &status, 0) < 0) { err = g_strdup_printf(_("waitpid failed: %s"), strerror(errno)); goto common_exit; } else if (!WIFEXITED(status)) { err = g_strdup_printf(_("Application '%s': exited with signal %d"), dle->program, WTERMSIG(status)); goto common_exit; } else if (WEXITSTATUS(status) != 0) { err = g_strdup_printf(_("Application '%s': exited with status %d"), dle->program, WEXITSTATUS(status)); goto common_exit; } } } amfree(bsu); fflush(stdout);fflush(stderr); amfree(device); amfree(qamdevice); amfree(qdisk); return; } if (device) { qdevice = quote_string(device); dbprintf(_("device %s\n"), qdevice); /* skip accessability test if this is an AFS entry */ if(strncmp_const(device, "afs:") != 0) { #ifdef CHECK_FOR_ACCESS_WITH_OPEN access_result = open(device, O_RDONLY); access_type = "open"; #else access_result = access(device, amode); access_type = "access"; #endif if(access_result == -1) { err = g_strdup_printf(_("Could not %s %s (%s): %s"), access_type, qdevice, qdisk, strerror(errno)); } #ifdef CHECK_FOR_ACCESS_WITH_OPEN aclose(access_result); #endif } } common_exit: if (!qdevice) qdevice = quote_string(device); amfree(share); amfree(subdir); if(user_and_password) { memset(user_and_password, '\0', (size_t)lpass); amfree(user_and_password); } amfree(domain); if(err) { g_printf(_("ERROR %s\n"), err); dbprintf(_("%s\n"), err); amfree(err); } else { if (dle->disk) { g_printf("OK %s\n", qdisk); dbprintf(_("disk %s OK\n"), qdisk); } if (dle->device) { g_printf("OK %s\n", qamdevice); dbprintf(_("amdevice %s OK\n"), qamdevice); } if (device) { g_printf("OK %s\n", qdevice); dbprintf(_("device %s OK\n"), qdevice); } } if(extra_info) { dbprintf(_("extra info: %s\n"), extra_info); amfree(extra_info); } amfree(qdisk); amfree(qdevice); amfree(qamdevice); amfree(device); /* XXX perhaps do something with level: read dumpdates and sanity check */ }