int
main(
int argc,
char ** argv)
{
int i;
time_t timer;
char *lineread = NULL;
struct sigaction act, oact;
extern char *optarg;
extern int optind;
char *line = NULL;
const security_driver_t *secdrv;
char *req = NULL;
int response_error;
struct tm *tm;
config_overrides_t *cfg_ovr;
/*
* 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);
set_pname("amrecover");
/* Don't die when child closes pipe */
signal(SIGPIPE, SIG_IGN);
dbopen(DBG_SUBDIR_CLIENT);
localhost = alloc(MAX_HOSTNAME_LENGTH+1);
if (gethostname(localhost, MAX_HOSTNAME_LENGTH) != 0) {
error(_("cannot determine local host name\n"));
/*NOTREACHED*/
}
localhost[MAX_HOSTNAME_LENGTH] = '\0';
/* load the base client configuration */
config_init(CONFIG_INIT_CLIENT, NULL);
if (config_errors(NULL) >= CFGERR_WARNINGS) {
config_print_errors();
if (config_errors(NULL) >= CFGERR_ERRORS) {
g_critical(_("errors processing config file"));
}
}
/* treat amrecover-specific command line options as the equivalent
* -o command-line options to set configuration values */
cfg_ovr = new_config_overrides(argc/2);
/* If the first argument is not an option flag, then we assume
* it is a configuration name to match the syntax of the other
* Amanda utilities. */
if (argc > 1 && argv[1][0] != '-') {
add_config_override(cfg_ovr, "conf", argv[1]);
/* remove that option from the command line */
argv[1] = argv[0];
argv++; argc--;
}
/* now parse regular command-line '-' options */
while ((i = getopt(argc, argv, "o:C:s:t:d:U")) != EOF) {
switch (i) {
case 'C':
add_config_override(cfg_ovr, "conf", optarg);
break;
case 's':
add_config_override(cfg_ovr, "index_server", optarg);
break;
case 't':
add_config_override(cfg_ovr, "tape_server", optarg);
break;
case 'd':
add_config_override(cfg_ovr, "tapedev", optarg);
break;
case 'o':
add_config_override_opt(cfg_ovr, optarg);
break;
case 'U':
case '?':
(void)g_printf(USAGE);
return 0;
}
}
if (optind != argc) {
(void)g_fprintf(stderr, USAGE);
exit(1);
}
/* and now try to load the configuration named in that file */
apply_config_overrides(cfg_ovr);
config_init(CONFIG_INIT_CLIENT | CONFIG_INIT_EXPLICIT_NAME | CONFIG_INIT_OVERLAY,
getconf_str(CNF_CONF));
reapply_config_overrides();
check_running_as(RUNNING_AS_ROOT);
dbrename(get_config_name(), DBG_SUBDIR_CLIENT);
our_features = am_init_feature_set();
our_features_string = am_feature_to_string(our_features);
server_name = NULL;
if (getconf_seen(CNF_INDEX_SERVER) == -2) { /* command line argument */
server_name = getconf_str(CNF_INDEX_SERVER);
}
if (!server_name) {
server_name = getenv("AMANDA_SERVER");
if (server_name) {
g_printf(_("Using index server from environment AMANDA_SERVER (%s)\n"), server_name);
}
}
if (!server_name) {
server_name = getconf_str(CNF_INDEX_SERVER);
}
if (!server_name) {
error(_("No index server set"));
/*NOTREACHED*/
}
server_name = stralloc(server_name);
tape_server_name = NULL;
if (getconf_seen(CNF_TAPE_SERVER) == -2) { /* command line argument */
tape_server_name = getconf_str(CNF_TAPE_SERVER);
}
if (!tape_server_name) {
tape_server_name = getenv("AMANDA_TAPE_SERVER");
if (!tape_server_name) {
tape_server_name = getenv("AMANDA_TAPESERVER");
if (tape_server_name) {
g_printf(_("Using tape server from environment AMANDA_TAPESERVER (%s)\n"), tape_server_name);
}
} else {
g_printf(_("Using tape server from environment AMANDA_TAPE_SERVER (%s)\n"), tape_server_name);
}
}
if (!tape_server_name) {
tape_server_name = getconf_str(CNF_TAPE_SERVER);
}
if (!tape_server_name) {
error(_("No tape server set"));
/*NOTREACHED*/
}
tape_server_name = stralloc(tape_server_name);
amfree(tape_device_name);
tape_device_name = getconf_str(CNF_TAPEDEV);
if (!tape_device_name ||
strlen(tape_device_name) == 0 ||
!getconf_seen(CNF_TAPEDEV)) {
tape_device_name = NULL;
} else {
tape_device_name = stralloc(tape_device_name);
}
authopt = stralloc(getconf_str(CNF_AUTH));
amfree(disk_name);
amfree(mount_point);
amfree(disk_path);
dump_date[0] = '\0';
/* Don't die when child closes pipe */
signal(SIGPIPE, SIG_IGN);
/* set up signal handler */
act.sa_handler = sigint_handler;
sigemptyset(&act.sa_mask);
act.sa_flags = 0;
if (sigaction(SIGINT, &act, &oact) != 0) {
error(_("error setting signal handler: %s"), strerror(errno));
/*NOTREACHED*/
}
protocol_init();
/* We assume that amindexd support fe_amindexd_options_features */
/* and fe_amindexd_options_auth */
/* We should send a noop to really know */
req = vstrallocf("SERVICE amindexd\n"
"OPTIONS features=%s;auth=%s;\n",
our_features_string, authopt);
secdrv = security_getdriver(authopt);
if (secdrv == NULL) {
error(_("no '%s' security driver available for host '%s'"),
authopt, server_name);
/*NOTREACHED*/
}
protocol_sendreq(server_name, secdrv, generic_client_get_security_conf,
req, STARTUP_TIMEOUT, amindexd_response, &response_error);
amfree(req);
protocol_run();
g_printf(_("AMRECOVER Version %s. Contacting server on %s ...\n"),
VERSION, server_name);
if(response_error != 0) {
g_fprintf(stderr,"%s\n",errstr);
exit(1);
}
/* get server's banner */
if (grab_reply(1) == -1) {
aclose(server_socket);
exit(1);
}
if (!server_happy()) {
dbclose();
aclose(server_socket);
exit(1);
}
/* try to get the features from the server */
{
char *their_feature_string = NULL;
indexsrv_features = NULL;
line = vstrallocf("FEATURES %s", our_features_string);
if(exchange(line) == 0) {
their_feature_string = stralloc(server_line+13);
indexsrv_features = am_string_to_feature(their_feature_string);
if (!indexsrv_features)
g_printf(_("Bad feature string from server: %s"), their_feature_string);
}
if (!indexsrv_features)
indexsrv_features = am_set_default_feature_set();
amfree(their_feature_string);
amfree(line);
}
/* set the date of extraction to be today */
(void)time(&timer);
tm = localtime(&timer);
if (tm)
strftime(dump_date, sizeof(dump_date), "%Y-%m-%d", tm);
else
error(_("BAD DATE"));
g_printf(_("Setting restore date to today (%s)\n"), dump_date);
line = vstrallocf("DATE %s", dump_date);
if (converse(line) == -1) {
aclose(server_socket);
exit(1);
}
amfree(line);
line = vstrallocf("SCNF %s", get_config_name());
if (converse(line) == -1) {
aclose(server_socket);
exit(1);
}
amfree(line);
if (server_happy()) {
/* set host we are restoring to this host by default */
amfree(dump_hostname);
set_host(localhost);
if (dump_hostname)
g_printf(_("Use the setdisk command to choose dump disk to recover\n"));
else
g_printf(_("Use the sethost command to choose a host to recover\n"));
}
quit_prog = 0;
do {
if ((lineread = readline("amrecover> ")) == NULL) {
clearerr(stdin);
putchar('\n');
break;
}
if (lineread[0] != '\0')
{
add_history(lineread);
dbprintf(_("user command: '%s'\n"), lineread);
process_line(lineread); /* act on line's content */
}
amfree(lineread);
} while (!quit_prog);
dbclose();
aclose(server_socket);
return 0;
}
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 */
}
static void
check_overall(void)
{
char *cmd;
struct stat buf;
int testfd;
char *gnutar_list_dir;
int need_amandates = 0;
if( need_runtar )
{
cmd = g_strjoin(NULL, amlibexecdir, "/", "runtar", NULL);
check_file(cmd,X_OK);
check_suid(cmd);
amfree(cmd);
}
if( need_rundump )
{
cmd = g_strjoin(NULL, amlibexecdir, "/", "rundump", NULL);
check_file(cmd,X_OK);
check_suid(cmd);
amfree(cmd);
}
if( need_dump ) {
#ifdef DUMP
check_file(DUMP, X_OK);
#else
g_printf(_("ERROR [DUMP program not available]\n"));
#endif
}
if( need_restore ) {
#ifdef RESTORE
check_file(RESTORE, X_OK);
#else
g_printf(_("ERROR [RESTORE program not available]\n"));
#endif
}
if ( need_vdump ) {
#ifdef VDUMP
check_file(VDUMP, X_OK);
#else
g_printf(_("ERROR [VDUMP program not available]\n"));
#endif
}
if ( need_vrestore ) {
#ifdef VRESTORE
check_file(VRESTORE, X_OK);
#else
g_printf(_("ERROR [VRESTORE program not available]\n"));
#endif
}
if( need_xfsdump ) {
#ifdef XFSDUMP
check_file(XFSDUMP, F_OK);
#else
g_printf(_("ERROR [XFSDUMP program not available]\n"));
#endif
}
if( need_xfsrestore ) {
#ifdef XFSRESTORE
check_file(XFSRESTORE, X_OK);
#else
g_printf(_("ERROR [XFSRESTORE program not available]\n"));
#endif
}
if( need_vxdump ) {
#ifdef VXDUMP
check_file(VXDUMP, X_OK);
#else
g_printf(_("ERROR [VXDUMP program not available]\n"));
#endif
}
if( need_vxrestore ) {
#ifdef VXRESTORE
check_file(VXRESTORE, X_OK);
#else
g_printf(_("ERROR [VXRESTORE program not available]\n"));
#endif
}
if( need_gnutar ) {
#ifdef GNUTAR
check_file(GNUTAR, X_OK);
#else
g_printf(_("ERROR [GNUTAR program not available]\n"));
#endif
gnutar_list_dir = getconf_str(CNF_GNUTAR_LIST_DIR);
if (strlen(gnutar_list_dir) == 0)
gnutar_list_dir = NULL;
if (gnutar_list_dir) {
/* make sure our listed-incremental dir is ready */
check_dir(gnutar_list_dir, R_OK|W_OK);
} else {
/* no listed-incremental dir, so check that amandates is ready */
need_amandates = 1;
}
}
if( need_calcsize ) {
char *cmd;
cmd = g_strjoin(NULL, amlibexecdir, "/", "calcsize", NULL);
check_file(cmd, X_OK);
amfree(cmd);
/* calcsize uses amandates */
need_amandates = 1;
}
if (need_amandates) {
char *amandates_file;
amandates_file = getconf_str(CNF_AMANDATES);
check_file(amandates_file, R_OK|W_OK);
}
if( need_samba ) {
#ifdef SAMBA_CLIENT
check_file(SAMBA_CLIENT, X_OK);
#else
g_printf(_("ERROR [SMBCLIENT program not available]\n"));
#endif
testfd = open("/etc/amandapass", R_OK);
if (testfd >= 0) {
if(fstat(testfd, &buf) == 0) {
if ((buf.st_mode & 0x7) != 0) {
g_printf(_("ERROR [/etc/amandapass is world readable!]\n"));
} else {
g_printf(_("OK [/etc/amandapass is readable, but not by all]\n"));
}
} else {
g_printf(_("OK [unable to stat /etc/amandapass: %s]\n"),
strerror(errno));
}
aclose(testfd);
} else {
g_printf(_("ERROR [unable to open /etc/amandapass: %s]\n"),
strerror(errno));
}
}
if (need_compress_path )
check_file(COMPRESS_PATH, X_OK);
if (need_dump || need_xfsdump ) {
if (check_file_exist("/etc/dumpdates")) {
check_file("/etc/dumpdates",
#ifdef USE_RUNDUMP
F_OK
#else
R_OK|W_OK
#endif
);
} else {
#ifndef USE_RUNDUMP
if (access("/etc", R_OK|W_OK) == -1) {
g_printf(_("ERROR [dump will not be able to create the /etc/dumpdates file: %s]\n"), strerror(errno));
}
#endif
}
}
if (need_vdump) {
if (check_file_exist("/etc/vdumpdates")) {
check_file("/etc/vdumpdates", F_OK);
}
}
if (need_global_check) {
check_access("/dev/null", R_OK|W_OK);
check_space(AMANDA_TMPDIR, (off_t)64); /* for amandad i/o */
#ifdef AMANDA_DBGDIR
check_space(AMANDA_DBGDIR, (off_t)64); /* for amandad i/o */
#endif
check_space("/etc", (off_t)64); /* for /etc/dumpdates writing */
}
}
int process(lua_State *L, const char *name, const char* filter_name, int list_only) {
struct archive *a = archive_read_new();
archive_read_support_filter_all(a);
archive_read_support_format_all(a);
if ( (archive_read_open_filename(a, name, 10240)) ) {
lua_pushnil(L);
lua_pushfstring(L, "Error: can't read archive %s: %s\n", name, archive_error_string(a));
return 2;
}
lua_newtable(L);
int top = lua_gettop(L);
struct archive_entry *entry;
int r;
int total = 0;
for (;;) {
r = archive_read_next_header(a, &entry);
if (r == ARCHIVE_EOF)
break;
if (r != ARCHIVE_OK) {
lua_pushnil(L);
lua_pushfstring(L, "%s\n", archive_error_string(a));
aclose(a);
return 2;
}
if (r < ARCHIVE_WARN) {
lua_pushnil(L);
lua_pushfstring(L, "%s\n", "Warning from archive");
aclose(a);
return 2;
}
// skip dirs
if (!S_ISREG(archive_entry_mode(entry)))
continue;
const char *name = archive_entry_pathname(entry);
if(list_only) {
lua_pushstring(L, name);
lua_rawseti(L, top, ++total);
archive_read_data_skip(a); // automatically called anyway
continue;
}
if ( filter_name
&& ! ( strlen(filter_name)==strlen(name) && strncmp(filter_name, name, strlen(name))==0 ) )
{
archive_read_data_skip(a); // automatically called anyway
continue;
}
size_t entry_size = archive_entry_size(entry);
if (entry_size > 0) {
char buff[entry_size];
ssize_t size = archive_read_data(a, buff, entry_size);
if(size <= 0) {
//TODO: send a warning or a black image
//lua_pushfstring(L, "Corrupted data: %s\n", name);
//lua_error(L);
}
lua_pushlstring(L, buff, entry_size);
if(filter_name)
lua_rawseti(L, top, 1);
else
lua_setfield(L, top, name);
}
if(filter_name)break;
}
aclose(a);
return 1;
}
int
main(
int argc,
char ** argv)
{
in_port_t my_port;
struct servent *sp;
int i;
time_t timer;
char *lineread = NULL;
struct sigaction act, oact;
extern char *optarg;
extern int optind;
char cwd[STR_SIZE], *dn_guess = NULL, *mpt_guess = NULL;
char *service_name;
char *line = NULL;
struct tm *tm;
/*
* 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);
set_pname("amoldrecover");
/* Don't die when child closes pipe */
signal(SIGPIPE, SIG_IGN);
dbopen(DBG_SUBDIR_CLIENT);
localhost = alloc(MAX_HOSTNAME_LENGTH+1);
if (gethostname(localhost, MAX_HOSTNAME_LENGTH) != 0) {
error(_("cannot determine local host name\n"));
/*NOTREACHED*/
}
localhost[MAX_HOSTNAME_LENGTH] = '\0';
config = newstralloc(config, DEFAULT_CONFIG);
dbrename(config, DBG_SUBDIR_CLIENT);
check_running_as(RUNNING_AS_ROOT);
amfree(server_name);
server_name = getenv("AMANDA_SERVER");
if(!server_name) server_name = DEFAULT_SERVER;
server_name = stralloc(server_name);
amfree(tape_server_name);
tape_server_name = getenv("AMANDA_TAPESERVER");
if(!tape_server_name) tape_server_name = DEFAULT_TAPE_SERVER;
tape_server_name = stralloc(tape_server_name);
config_init(CONFIG_INIT_CLIENT, NULL);
if (config_errors(NULL) >= CFGERR_WARNINGS) {
config_print_errors();
if (config_errors(NULL) >= CFGERR_ERRORS) {
g_critical(_("errors processing config file"));
}
}
if (argc > 1 && argv[1][0] != '-')
{
/*
* If the first argument is not an option flag, then we assume
* it is a configuration name to match the syntax of the other
* Amanda utilities.
*/
char **new_argv;
new_argv = (char **) alloc((size_t)((argc + 1 + 1) * sizeof(*new_argv)));
new_argv[0] = argv[0];
new_argv[1] = "-C";
for (i = 1; i < argc; i++)
{
new_argv[i + 1] = argv[i];
}
new_argv[i + 1] = NULL;
argc++;
argv = new_argv;
}
while ((i = getopt(argc, argv, "C:s:t:d:U")) != EOF)
{
switch (i)
{
case 'C':
config = newstralloc(config, optarg);
break;
case 's':
server_name = newstralloc(server_name, optarg);
break;
case 't':
tape_server_name = newstralloc(tape_server_name, optarg);
break;
case 'd':
tape_device_name = newstralloc(tape_device_name, optarg);
break;
case 'U':
case '?':
(void)g_printf(USAGE);
return 0;
}
}
if (optind != argc)
{
(void)g_fprintf(stderr, USAGE);
exit(1);
}
amfree(disk_name);
amfree(mount_point);
amfree(disk_path);
dump_date[0] = '\0';
/* Don't die when child closes pipe */
signal(SIGPIPE, SIG_IGN);
/* set up signal handler */
act.sa_handler = sigint_handler;
sigemptyset(&act.sa_mask);
act.sa_flags = 0;
if (sigaction(SIGINT, &act, &oact) != 0) {
error(_("error setting signal handler: %s"), strerror(errno));
/*NOTREACHED*/
}
service_name = stralloc2("amandaidx", SERVICE_SUFFIX);
g_printf(_("AMRECOVER Version %s. Contacting server on %s ...\n"),
version(), server_name);
if ((sp = getservbyname(service_name, "tcp")) == NULL) {
error(_("%s/tcp unknown protocol"), service_name);
/*NOTREACHED*/
}
amfree(service_name);
server_socket = stream_client_privileged(server_name,
(in_port_t)ntohs((in_port_t)sp->s_port),
0,
0,
&my_port,
0);
if (server_socket < 0) {
error(_("cannot connect to %s: %s"), server_name, strerror(errno));
/*NOTREACHED*/
}
if (my_port >= IPPORT_RESERVED) {
aclose(server_socket);
error(_("did not get a reserved port: %d"), my_port);
/*NOTREACHED*/
}
/* get server's banner */
if (grab_reply(1) == -1) {
aclose(server_socket);
exit(1);
}
if (!server_happy())
{
dbclose();
aclose(server_socket);
exit(1);
}
/* do the security thing */
line = get_security();
if (converse(line) == -1) {
aclose(server_socket);
exit(1);
}
if (!server_happy()) {
aclose(server_socket);
exit(1);
}
memset(line, '\0', strlen(line));
amfree(line);
/* try to get the features from the server */
{
char *our_feature_string = NULL;
char *their_feature_string = NULL;
our_features = am_init_feature_set();
our_feature_string = am_feature_to_string(our_features);
line = stralloc2("FEATURES ", our_feature_string);
if(exchange(line) == 0) {
their_feature_string = stralloc(server_line+13);
indexsrv_features = am_string_to_feature(their_feature_string);
}
else {
indexsrv_features = am_set_default_feature_set();
}
amfree(our_feature_string);
amfree(their_feature_string);
amfree(line);
}
/* set the date of extraction to be today */
(void)time(&timer);
tm = localtime(&timer);
if (tm)
strftime(dump_date, sizeof(dump_date), "%Y-%m-%d", tm);
else
error(_("BAD DATE"));
g_printf(_("Setting restore date to today (%s)\n"), dump_date);
line = stralloc2("DATE ", dump_date);
if (converse(line) == -1) {
aclose(server_socket);
exit(1);
}
amfree(line);
line = stralloc2("SCNF ", config);
if (converse(line) == -1) {
aclose(server_socket);
exit(1);
}
amfree(line);
if (server_happy())
{
/* set host we are restoring to this host by default */
amfree(dump_hostname);
set_host(localhost);
if (dump_hostname)
{
/* get a starting disk and directory based on where
we currently are */
switch (guess_disk(cwd, sizeof(cwd), &dn_guess, &mpt_guess))
{
case 1:
/* okay, got a guess. Set disk accordingly */
g_printf(_("$CWD '%s' is on disk '%s' mounted at '%s'.\n"),
cwd, dn_guess, mpt_guess);
set_disk(dn_guess, mpt_guess);
set_directory(cwd);
if (server_happy() && strcmp(cwd, mpt_guess) != 0)
g_printf(_("WARNING: not on root of selected filesystem, check man-page!\n"));
amfree(dn_guess);
amfree(mpt_guess);
break;
case 0:
g_printf(_("$CWD '%s' is on a network mounted disk\n"),
cwd);
g_printf(_("so you must 'sethost' to the server\n"));
/* fake an unhappy server */
server_line[0] = '5';
break;
case 2:
case -1:
default:
g_printf(_("Use the setdisk command to choose dump disk to recover\n"));
/* fake an unhappy server */
server_line[0] = '5';
break;
}
}
}
quit_prog = 0;
do
{
if ((lineread = readline("amrecover> ")) == NULL) {
clearerr(stdin);
putchar('\n');
break;
}
if (lineread[0] != '\0')
{
add_history(lineread);
process_line(lineread); /* act on line's content */
}
amfree(lineread);
} while (!quit_prog);
dbclose();
aclose(server_socket);
return 0;
}
int
dgram_bind(
dgram_t * dgram,
sa_family_t family,
in_port_t * portp)
{
int s, retries;
socklen_t_equiv len;
sockaddr_union name;
int save_errno;
int *portrange;
int sndbufsize = MAX_DGRAM;
portrange = getconf_intrange(CNF_RESERVED_UDP_PORT);
*portp = (in_port_t)0;
g_debug("dgram_bind: setting up a socket with family %d", family);
if((s = socket(family, SOCK_DGRAM, 0)) == -1) {
save_errno = errno;
dbprintf(_("dgram_bind: socket() failed: %s\n"),
strerror(save_errno));
errno = save_errno;
return -1;
}
if(s < 0 || s >= (int)FD_SETSIZE) {
dbprintf(_("dgram_bind: socket out of range: %d\n"),
s);
aclose(s);
errno = EMFILE; /* out of range */
return -1;
}
/* try setting the buffer size (= maximum allowable UDP packet size) */
if (setsockopt(s, SOL_SOCKET, SO_SNDBUF,
(void *) &sndbufsize, sizeof(sndbufsize)) < 0) {
dbprintf("dgram_bind: could not set udp send buffer to %d: %s (ignored)\n",
sndbufsize, strerror(errno));
}
SU_INIT(&name, family);
SU_SET_INADDR_ANY(&name);
/*
* If a port range was specified, we try to get a port in that
* range first. Next, we try to get a reserved port. If that
* fails, we just go for any port.
*
* In all cases, not to use port that's assigned to other services.
*
* It is up to the caller to make sure we have the proper permissions
* to get the desired port, and to make sure we return a port that
* is within the range it requires.
*/
for (retries = 0; ; retries++) {
if (bind_portrange(s, &name, portrange[0], portrange[1], "udp") == 0)
goto out;
dbprintf(_("dgram_bind: Could not bind to port in range: %d - %d.\n"),
portrange[0], portrange[1]);
if (retries >= BIND_CYCLE_RETRIES) {
dbprintf(_("dgram_bind: Giving up...\n"));
break;
}
dbprintf(_("dgram_bind: Retrying entire range after 10 second delay.\n"));
sleep(15);
}
save_errno = errno;
dbprintf(_("dgram_bind: bind(in6addr_any) failed: %s\n"),
strerror(save_errno));
aclose(s);
errno = save_errno;
return -1;
out:
/* find out what name was actually used */
len = (socklen_t_equiv)sizeof(name);
if(getsockname(s, (struct sockaddr *)&name, &len) == -1) {
save_errno = errno;
dbprintf(_("dgram_bind: getsockname() failed: %s\n"), strerror(save_errno));
errno = save_errno;
aclose(s);
return -1;
}
*portp = SU_GET_PORT(&name);
dgram->socket = s;
dbprintf(_("dgram_bind: socket %d bound to %s\n"),
dgram->socket, str_sockaddr(&name));
return 0;
}