/*
* doing similar to $ gtar | compression | encryption
*/
static void
start_backup(
dle_t *dle,
char *host,
int dataf,
int mesgf,
int indexf)
{
char tmppath[PATH_MAX];
int dumpin, dumpout, compout;
char *cmd = NULL;
char *indexcmd = NULL;
char *dirname = NULL;
int l;
char dumptimestr[80] = "UNUSED";
struct tm *gmtm;
amandates_t *amdates = NULL;
time_t prev_dumptime = 0;
char *error_pn = NULL;
char *compopt = NULL;
char *encryptopt = skip_argument;
char *tquoted;
char *fquoted;
char *qdisk;
int infd, outfd;
ssize_t nb;
char buf[32768];
char *amandates_file = NULL;
am_level_t *alevel = (am_level_t *)dle->levellist->data;
int level = alevel->level;
int native_pipe[2];
int client_pipe[2];
int data_out;
have_filter = FALSE;
crc32_init(&native_crc.crc);
crc32_init(&client_crc.crc);
/* create pipes to compute the native CRC */
if (pipe(native_pipe) < 0) {
char *errmsg;
char *qerrmsg;
errmsg = g_strdup_printf(_("Program '%s': can't create pipe"),
dle->program);
qerrmsg = quote_string(errmsg);
fdprintf(mesgf, _("sendbackup: error [%s]\n"), errmsg);
dbprintf(_("ERROR %s\n"), qerrmsg);
amfree(qerrmsg);
amfree(errmsg);
return;
}
if (dle->encrypt == ENCRYPT_CUST ||
dle->compress == COMP_FAST ||
dle->compress == COMP_BEST ||
dle->compress == COMP_CUST) {
have_filter = TRUE;
/* create pipes to compute the client CRC */
if (pipe(client_pipe) < 0) {
char *errmsg;
char *qerrmsg;
errmsg = g_strdup_printf(_("Application '%s': can't create pipe"),
dle->program);
qerrmsg = quote_string(errmsg);
fdprintf(mesgf, _("sendbackup: error [%s]\n"), errmsg);
dbprintf(_("ERROR %s\n"), qerrmsg);
amfree(qerrmsg);
amfree(errmsg);
return;
}
data_out = client_pipe[1];
client_pipe[1] = -1;
} else {
data_out = dataf;
dataf = -1;
}
error_pn = g_strconcat(get_pname(), "-smbclient", NULL);
qdisk = quote_string(dle->disk);
dbprintf(_("start: %s:%s lev %d\n"), host, qdisk, level);
g_fprintf(stderr, _("%s: start [%s:%s level %d]\n"),
get_pname(), host, qdisk, level);
/* apply client-side encryption here */
if ( dle->encrypt == ENCRYPT_CUST ) {
encpid = pipespawn(dle->clnt_encrypt, STDIN_PIPE, 0,
&compout, &data_out, &mesgf,
dle->clnt_encrypt, encryptopt, NULL);
dbprintf(_("gnutar: pid %ld: %s\n"), (long)encpid, dle->clnt_encrypt);
aclose(data_out);
} else {
compout = data_out;
data_out = -1;
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, &mesgf,
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);
}
aclose(compout);
} else if (dle->compress == COMP_CUST) {
compopt = skip_argument;
comppid = pipespawn(dle->compprog, STDIN_PIPE, 0,
&dumpout, &compout, &mesgf,
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);
}
aclose(compout);
} else {
dumpout = compout;
compout = -1;
comppid = -1;
}
gnutar_list_dir = getconf_str(CNF_GNUTAR_LIST_DIR);
if (strlen(gnutar_list_dir) == 0)
gnutar_list_dir = NULL;
#ifdef SAMBA_CLIENT /* { */
if (dle->device[0] == '/' && dle->device[1]=='/')
amfree(incrname);
else
#endif /* } */
if (gnutar_list_dir) {
char *basename = NULL;
char number[NUM_STR_SIZE];
char *inputname = NULL;
int baselevel;
char *sdisk = sanitise_filename(dle->disk);
basename = g_strjoin(NULL, gnutar_list_dir,
"/",
host,
sdisk,
NULL);
amfree(sdisk);
g_snprintf(number, sizeof(number), "%d", level);
incrname = g_strjoin(NULL, basename, "_", number, ".new", NULL);
unlink(incrname);
/*
* Open the listed incremental file from the previous level. Search
* backward until one is found. If none are found (which will also
* be true for a level 0), arrange to read from /dev/null.
*/
baselevel = level;
infd = -1;
while (infd == -1) {
if (--baselevel >= 0) {
g_snprintf(number, sizeof(number), "%d", baselevel);
g_free(inputname);
inputname = g_strconcat(basename, "_", number, NULL);
} else {
g_free(inputname);
inputname = g_strdup("/dev/null");
}
if ((infd = open(inputname, O_RDONLY)) == -1) {
int save_errno = errno;
char *qname = quote_string(inputname);
dbprintf(_("gnutar: error opening '%s': %s\n"),
qname,
strerror(save_errno));
if (baselevel < 0) {
error(_("error [opening '%s': %s]"), qname, strerror(save_errno));
/*NOTREACHED*/
}
amfree(qname);
}
}
/*
* Copy the previous listed incremental file to the new one.
*/
if ((outfd = open(incrname, O_WRONLY|O_CREAT, 0600)) == -1) {
error(_("error [opening '%s': %s]"), incrname, strerror(errno));
/*NOTREACHED*/
}
while ((nb = read(infd, &buf, sizeof(buf))) > 0) {
if (full_write(outfd, &buf, (size_t)nb) < (size_t)nb) {
error(_("error [writing to '%s': %s]"), incrname,
strerror(errno));
/*NOTREACHED*/
}
}
if (nb < 0) {
error(_("error [reading from '%s': %s]"), inputname, strerror(errno));
/*NOTREACHED*/
}
if (close(infd) != 0) {
error(_("error [closing '%s': %s]"), inputname, strerror(errno));
/*NOTREACHED*/
}
if (close(outfd) != 0) {
error(_("error [closing '%s': %s]"), incrname, strerror(errno));
/*NOTREACHED*/
}
tquoted = quote_string(incrname);
if(baselevel >= 0) {
fquoted = quote_string(inputname);
dbprintf(_("doing level %d dump as listed-incremental from '%s' to '%s'\n"),
level, fquoted, tquoted);
amfree(fquoted);
} else {
dbprintf(_("doing level %d dump as listed-incremental to '%s'\n"),
level, tquoted);
}
amfree(tquoted);
amfree(inputname);
amfree(basename);
} else {
/* no gnutar-listdir, so we're using amandates */
/* find previous dump time, failing completely if there's a problem */
amandates_file = getconf_str(CNF_AMANDATES);
if(!start_amandates(amandates_file, 0)) {
error(_("error [opening %s: %s]"), amandates_file, strerror(errno));
/*NOTREACHED*/
}
amdates = amandates_lookup(dle->disk);
prev_dumptime = EPOCH;
for(l = 0; l < level; l++) {
if(amdates->dates[l] > prev_dumptime)
prev_dumptime = amdates->dates[l];
}
finish_amandates();
free_amandates();
gmtm = gmtime(&prev_dumptime);
g_snprintf(dumptimestr, sizeof(dumptimestr),
"%04d-%02d-%02d %2d:%02d:%02d GMT",
gmtm->tm_year + 1900, gmtm->tm_mon+1, gmtm->tm_mday,
gmtm->tm_hour, gmtm->tm_min, gmtm->tm_sec);
dbprintf(_("gnutar: doing level %d dump from amandates-derived date: %s\n"),
level, dumptimestr);
}
dirname = amname_to_dirname(dle->device);
cur_dumptime = time(0);
cur_level = level;
cur_disk = g_strdup(dle->disk);
#ifdef GNUTAR
# define PROGRAM_GNUTAR GNUTAR
#else
# define PROGRAM_GNUTAR "tar"
#endif
indexcmd = g_strjoin(NULL,
PROGRAM_GNUTAR,
" -tf", " -",
" 2>/dev/null",
" | sed", " -e",
" \'s/^\\.//\'",
NULL);
#ifdef SAMBA_CLIENT /* { */
/* Use sambatar if the disk to back up is a PC disk */
if (dle->device[0] == '/' && dle->device[1]=='/') {
char *sharename = NULL, *user_and_password = NULL, *domain = NULL;
char *share = NULL, *subdir = NULL;
char *pwtext = NULL;
char *taropt;
int passwdf = -1;
size_t lpass;
size_t pwtext_len;
char *pw_fd_env;
parsesharename(dle->device, &share, &subdir);
if (!share) {
amfree(share);
amfree(subdir);
set_pname(error_pn);
amfree(error_pn);
error(_("cannot parse disk entry %s for share/subdir"), qdisk);
/*NOTREACHED*/
}
if ((subdir) && (SAMBA_VERSION < 2)) {
amfree(share);
amfree(subdir);
set_pname(error_pn);
amfree(error_pn);
error(_("subdirectory specified for share %s but samba not v2 or better"), qdisk);
/*NOTREACHED*/
}
if ((user_and_password = findpass(share, &domain)) == NULL) {
if(domain) {
memset(domain, '\0', strlen(domain));
amfree(domain);
}
set_pname(error_pn);
amfree(error_pn);
error(_("error [invalid samba host or password not found?]"));
/*NOTREACHED*/
}
lpass = strlen(user_and_password);
if ((pwtext = strchr(user_and_password, '%')) == NULL) {
memset(user_and_password, '\0', lpass);
amfree(user_and_password);
if(domain) {
memset(domain, '\0', strlen(domain));
amfree(domain);
}
set_pname(error_pn);
amfree(error_pn);
error(_("password field not \'user%%pass\' for %s"), qdisk);
/*NOTREACHED*/
}
*pwtext++ = '\0';
pwtext_len = strlen(pwtext);
if ((sharename = makesharename(share, 0)) == 0) {
memset(user_and_password, '\0', lpass);
amfree(user_and_password);
if(domain) {
memset(domain, '\0', strlen(domain));
amfree(domain);
}
set_pname(error_pn);
amfree(error_pn);
error(_("error [can't make share name of %s]"), share);
/*NOTREACHED*/
}
taropt = g_strdup("-T");
if(dle->exclude_file && dle->exclude_file->nb_element == 1) {
strappend(taropt, "X");
}
#if SAMBA_VERSION >= 2
strappend(taropt, "q");
#endif
strappend(taropt, "c");
if (level != 0) {
strappend(taropt, "g");
} else if (dle->record) {
strappend(taropt, "a");
}
if (subdir) {
dbprintf(_("gnutar: backup of %s/%s\n"), sharename, subdir);
} else {
dbprintf(_("gnutar: backup of %s\n"), sharename);
}
program->backup_name = program->restore_name = SAMBA_CLIENT;
cmd = g_strdup(program->backup_name);
info_tapeheader(dle);
start_index(dle->create_index, native_pipe[1], mesgf, indexf, indexcmd);
if (pwtext_len > 0) {
pw_fd_env = "PASSWD_FD";
} else {
pw_fd_env = "dummy_PASSWD_FD";
}
dumppid = pipespawn(cmd, STDIN_PIPE|PASSWD_PIPE, 0,
&dumpin, &native_pipe[1], &mesgf,
pw_fd_env, &passwdf,
"smbclient",
sharename,
*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
"-d0",
taropt,
"-",
dle->exclude_file && dle->exclude_file->nb_element == 1 ? dle->exclude_file->first->name : skip_argument,
NULL);
if(domain) {
memset(domain, '\0', strlen(domain));
amfree(domain);
}
if(pwtext_len > 0 && full_write(passwdf, pwtext, pwtext_len) < pwtext_len) {
int save_errno = errno;
aclose(passwdf);
memset(user_and_password, '\0', lpass);
amfree(user_and_password);
set_pname(error_pn);
amfree(error_pn);
error(_("error [password write failed: %s]"), strerror(save_errno));
/*NOTREACHED*/
}
memset(user_and_password, '\0', lpass);
amfree(user_and_password);
aclose(passwdf);
amfree(sharename);
amfree(share);
amfree(subdir);
amfree(taropt);
tarpid = dumppid;
} else
#endif /*end of samba */
{
int nb_exclude = 0;
int nb_include = 0;
GPtrArray *argv_ptr = g_ptr_array_new();
char *file_exclude = NULL;
char *file_include = NULL;
messagelist_t mlist = NULL;
if (dle->exclude_file) nb_exclude+=dle->exclude_file->nb_element;
if (dle->exclude_list) nb_exclude+=dle->exclude_list->nb_element;
if (dle->include_file) nb_include+=dle->include_file->nb_element;
if (dle->include_list) nb_include+=dle->include_list->nb_element;
if (nb_exclude > 0) file_exclude = build_exclude(dle, &mlist);
if (nb_include > 0) file_include = build_include(dle, dirname, &mlist);
g_slist_free(mlist); // MUST also free the message
cmd = g_strjoin(NULL, amlibexecdir, "/", "runtar", NULL);
info_tapeheader(dle);
start_index(dle->create_index, native_pipe[1], mesgf, indexf, indexcmd);
g_ptr_array_add(argv_ptr, g_strdup("runtar"));
if (g_options->config)
g_ptr_array_add(argv_ptr, g_strdup(g_options->config));
else
g_ptr_array_add(argv_ptr, g_strdup("NOCONFIG"));
#ifdef GNUTAR
g_ptr_array_add(argv_ptr, g_strdup(GNUTAR));
#else
g_ptr_array_add(argv_ptr, g_strdup("tar"));
#endif
g_ptr_array_add(argv_ptr, g_strdup("--create"));
g_ptr_array_add(argv_ptr, g_strdup("--file"));
g_ptr_array_add(argv_ptr, g_strdup("-"));
g_ptr_array_add(argv_ptr, g_strdup("--directory"));
canonicalize_pathname(dirname, tmppath);
g_ptr_array_add(argv_ptr, g_strdup(tmppath));
g_ptr_array_add(argv_ptr, g_strdup("--one-file-system"));
if (gnutar_list_dir && incrname) {
g_ptr_array_add(argv_ptr, g_strdup("--listed-incremental"));
g_ptr_array_add(argv_ptr, g_strdup(incrname));
} else {
g_ptr_array_add(argv_ptr, g_strdup("--incremental"));
g_ptr_array_add(argv_ptr, g_strdup("--newer"));
g_ptr_array_add(argv_ptr, g_strdup(dumptimestr));
}
#ifdef ENABLE_GNUTAR_ATIME_PRESERVE
/* --atime-preserve causes gnutar to call
* utime() after reading files in order to
* adjust their atime. However, utime()
* updates the file's ctime, so incremental
* dumps will think the file has changed. */
g_ptr_array_add(argv_ptr, g_strdup("--atime-preserve"));
#endif
g_ptr_array_add(argv_ptr, g_strdup("--sparse"));
g_ptr_array_add(argv_ptr, g_strdup("--ignore-failed-read"));
g_ptr_array_add(argv_ptr, g_strdup("--totals"));
if(file_exclude) {
g_ptr_array_add(argv_ptr, g_strdup("--exclude-from"));
g_ptr_array_add(argv_ptr, g_strdup(file_exclude));
}
if(file_include) {
g_ptr_array_add(argv_ptr, g_strdup("--files-from"));
g_ptr_array_add(argv_ptr, g_strdup(file_include));
}
else {
g_ptr_array_add(argv_ptr, g_strdup("."));
}
g_ptr_array_add(argv_ptr, NULL);
dumppid = pipespawnv(cmd, STDIN_PIPE, 0,
&dumpin, &native_pipe[1], &mesgf,
(char **)argv_ptr->pdata);
tarpid = dumppid;
amfree(file_exclude);
amfree(file_include);
g_ptr_array_free_full(argv_ptr);
}
dbprintf(_("gnutar: %s: pid %ld\n"), cmd, (long)dumppid);
amfree(qdisk);
amfree(dirname);
amfree(cmd);
amfree(indexcmd);
amfree(error_pn);
/* close the write ends of the pipes */
aclose(dumpin);
aclose(native_pipe[1]);
aclose(mesgf);
if (dle->create_index)
aclose(indexf);
if (shm_control_name) {
shm_ring = shm_ring_link(shm_control_name);
shm_ring_producer_set_size(shm_ring, NETWORK_BLOCK_BYTES*16, NETWORK_BLOCK_BYTES*4);
native_crc.in = native_pipe[0];
if (!have_filter) {
native_crc.out = dumpout;
native_crc.shm_ring = shm_ring;
native_crc.thread = g_thread_create(handle_crc_to_shm_ring_thread,
(gpointer)&native_crc, TRUE, NULL);
} else {
native_crc.out = dumpout;
native_crc.thread = g_thread_create(handle_crc_thread,
(gpointer)&native_crc, TRUE, NULL);
client_crc.in = client_pipe[0];
client_crc.out = dataf;
client_crc.shm_ring = shm_ring;
client_crc.thread = g_thread_create(handle_crc_to_shm_ring_thread,
(gpointer)&client_crc, TRUE, NULL);
}
} else {
native_crc.in = native_pipe[0];
native_crc.out = dumpout;
native_crc.thread = g_thread_create(handle_crc_thread,
(gpointer)&native_crc, TRUE, NULL);
if (have_filter) {
client_crc.in = client_pipe[0];
client_crc.out = dataf;
client_crc.thread = g_thread_create(handle_crc_thread,
(gpointer)&client_crc, TRUE, NULL);
}
}
}
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 */
}