int vgcfgrestore(struct cmd_context *cmd, int argc, char **argv)
{
const char *vg_name = NULL;
if (argc == 1) {
vg_name = skip_dev_dir(cmd, argv[0], NULL);
if (!validate_name(vg_name)) {
log_error("Volume group name \"%s\" is invalid", vg_name);
return ECMD_FAILED;
}
} else if (!(arg_count(cmd, list_ARG) && arg_count(cmd, file_ARG))) {
log_error("Please specify a *single* volume group to restore.");
return ECMD_FAILED;
}
/*
* FIXME: overloading the -l arg for now to display a
* list of archive files for a particular vg
*/
if (arg_count(cmd, list_ARG)) {
if (!(arg_count(cmd,file_ARG) ?
archive_display_file(cmd,
arg_str_value(cmd, file_ARG, "")) :
archive_display(cmd, vg_name))) {
stack;
return ECMD_FAILED;
}
return ECMD_PROCESSED;
}
if (!lock_vol(cmd, vg_name, LCK_VG_WRITE)) {
log_error("Unable to lock volume group %s", vg_name);
return ECMD_FAILED;
}
if (!lock_vol(cmd, VG_ORPHANS, LCK_VG_WRITE)) {
log_error("Unable to lock orphans");
unlock_vg(cmd, vg_name);
return ECMD_FAILED;
}
cmd->handles_unknown_segments = 1;
if (!(arg_count(cmd, file_ARG) ?
backup_restore_from_file(cmd, vg_name,
arg_str_value(cmd, file_ARG, "")) :
backup_restore(cmd, vg_name))) {
unlock_vg(cmd, VG_ORPHANS);
unlock_vg(cmd, vg_name);
log_error("Restore failed.");
return ECMD_FAILED;
}
log_print("Restored volume group %s", vg_name);
unlock_vg(cmd, VG_ORPHANS);
unlock_vg(cmd, vg_name);
return ECMD_PROCESSED;
}
int main(int _argc, char **_argv)
{
sigset_t set;
int i, sig, goto_daemon = 0, len;
pid_t pid = 0;
struct sigaction sa;
int pagesize = sysconf(_SC_PAGE_SIZE);
int internal = 0;
argc = _argc;
argv = _argv;
if (argc < 2)
goto usage;
for(i = 1; i < argc; i++) {
if (!strcmp(argv[i], "-d"))
goto_daemon = 1;
else if (!strcmp(argv[i], "-p")) {
if (i == argc - 1)
goto usage;
pid_file = argv[++i];
} else if (!strcmp(argv[i], "-c")) {
if (i == argc - 1)
goto usage;
conf_file = argv[++i];
} else if (!strcmp(argv[i], "--dump")) {
if (i == argc - 1)
goto usage;
len = (strlen(argv[i + 1]) / pagesize + 1) * pagesize;
conf_dump = memalign(pagesize, len);
strcpy(conf_dump, argv[++i]);
mprotect(conf_dump, len, PROT_READ);
} else if (!strcmp(argv[i], "--internal"))
internal = 1;
}
if (!conf_file)
goto usage;
if (internal) {
while (getppid() != 1)
sleep(1);
}
if (triton_init(conf_file))
_exit(EXIT_FAILURE);
if (goto_daemon && pid != getpid()) {
/*pid_t pid = fork();
if (pid > 0)
_exit(EXIT_SUCCESS);
if (pid < 0) {
perror("fork");
return EXIT_FAILURE;
}
if (setsid() < 0)
_exit(EXIT_FAILURE);
pid = fork();
if (pid)
_exit(0);
umask(0);
chdir("/");
close(STDIN_FILENO);
close(STDOUT_FILENO);
close(STDERR_FILENO);*/
daemon(0, 0);
}
if (pid_file) {
FILE *f = fopen(pid_file, "w");
if (f) {
fprintf(f, "%i", getpid());
fclose(f);
}
}
change_limits();
#ifdef CRYPTO_OPENSSL
openssl_init();
#endif
if (triton_load_modules("modules"))
return EXIT_FAILURE;
log_msg("accel-ppp version %s\n", ACCEL_PPP_VERSION);
triton_run();
sigfillset(&set);
memset(&sa, 0, sizeof(sa));
sa.sa_handler = config_reload;
sa.sa_mask = set;
sigaction(SIGUSR1, &sa, NULL);
sa.sa_handler = sigsegv;
sa.sa_mask = set;
sigaction(SIGSEGV, &sa, NULL);
sigdelset(&set, SIGKILL);
sigdelset(&set, SIGSTOP);
sigdelset(&set, SIGSEGV);
sigdelset(&set, SIGFPE);
sigdelset(&set, SIGILL);
sigdelset(&set, SIGBUS);
sigdelset(&set, SIGHUP);
sigdelset(&set, SIGIO);
sigdelset(&set, SIGINT);
sigdelset(&set, SIGUSR1);
sigdelset(&set, 35);
sigdelset(&set, 36);
pthread_sigmask(SIG_SETMASK, &set, &orig_set);
sigemptyset(&set);
//sigaddset(&set, SIGINT);
sigaddset(&set, SIGTERM);
sigaddset(&set, SIGSEGV);
sigaddset(&set, SIGILL);
sigaddset(&set, SIGFPE);
sigaddset(&set, SIGBUS);
#ifdef USE_BACKUP
backup_restore(internal);
#endif
sigwait(&set, &sig);
log_info1("terminate, sig = %i\n", sig);
ap_shutdown_soft(shutdown_cb, 1);
pthread_mutex_lock(&lock);
while (!term)
pthread_cond_wait(&cond, &lock);
pthread_mutex_unlock(&lock);
triton_terminate();
if (restart != -1)
__core_restart(restart);
if (pid_file)
unlink(pid_file);
return EXIT_SUCCESS;
usage:
printf("usage: accel-pppd [-d] [-p <file>] -c <file>\n\
where:\n\
-d - daemon mode\n\
-p - write pid to <file>\n\
-c - config file\n");
_exit(EXIT_FAILURE);
}
static STATUS _backup_dir_show(char *path)
{
DIR* d;
struct dirent* de;
d = opendir(path);
return_val_if_fail(d != NULL, RET_FAIL);
int d_size = 0;
int d_alloc = 10;
return_val_if_fail(backup_menu != NULL, RET_FAIL);
char** dirs = malloc(d_alloc * sizeof(char*));
char** dirs_desc = malloc(d_alloc * sizeof(char*));
return_val_if_fail(dirs != NULL, RET_FAIL);
return_val_if_fail(dirs_desc != NULL, RET_FAIL);
int z_size = 1;
int z_alloc = 10;
char** zips = malloc(z_alloc * sizeof(char*));
char** zips_desc=malloc(z_alloc * sizeof(char*));
return_val_if_fail(zips != NULL, RET_FAIL);
return_val_if_fail(zips_desc != NULL, RET_FAIL);
zips[0] = strdup("../");
zips_desc[0]=strdup("../");
while ((de = readdir(d)) != NULL) {
int name_len = strlen(de->d_name);
char de_path[PATH_MAX];
snprintf(de_path, PATH_MAX, "%s/%s", path, de->d_name);
struct stat st ;
assert_if_fail(stat(de_path, &st) == 0);
if (de->d_type == DT_DIR) {
//skip "." and ".." entries
if (name_len == 1 && de->d_name[0] == '.') continue;
if (name_len == 2 && de->d_name[0] == '.' &&
de->d_name[1] == '.') continue;
if (d_size >= d_alloc) {
d_alloc *= 2;
dirs = realloc(dirs, d_alloc * sizeof(char*));
dirs_desc = realloc(dirs_desc, d_alloc * sizeof(char*));
}
dirs[d_size] = malloc(name_len + 2);
dirs_desc[d_size] = malloc(64);
strcpy(dirs[d_size], de->d_name);
dirs[d_size][name_len ] = '\0';
snprintf(dirs_desc[d_size], 64, "%s" ,ctime(&st.st_mtime));
++d_size;
} else if (de->d_type == DT_REG && name_len >= 4 &&
strncasecmp(de->d_name + (name_len - 4), ".zip", 4) == 0) {
if (z_size >= z_alloc) {
z_alloc *= 2;
zips = realloc(zips, z_alloc * sizeof(char*));
zips_desc = realloc(zips_desc, z_alloc * sizeof(char*));
}
zips[z_size] = strdup(de->d_name);
zips_desc[z_size] = malloc(64);
snprintf(zips_desc[z_size], 64, "%s %lldbytes" ,ctime(&st.st_mtime), st.st_size);
z_size++;
}
}
closedir(d);
// append dirs to the zips list
if (d_size + z_size + 1 > z_alloc) {
z_alloc = d_size + z_size + 1;
zips = realloc(zips, z_alloc * sizeof(char*));
zips_desc = realloc(zips_desc, z_alloc * sizeof(char*));
}
memcpy(zips + z_size, dirs, d_size * sizeof(char *));
memcpy(zips_desc + z_size, dirs_desc, d_size * sizeof(char*));
free(dirs);
z_size += d_size;
zips[z_size] = NULL;
zips_desc[z_size] = NULL;
int result;
int chosen_item = 0;
do {
chosen_item = miui_sdmenu(backup_menu->name, zips, zips_desc, z_size);
return_val_if_fail(chosen_item >= 0, RET_FAIL);
char * item = zips[chosen_item];
int item_len = strlen(item);
if ( chosen_item == 0) {
//go up but continue browsing
result = -1;
break;
} else {
// select a zipfile
// the status to the caller
char new_path[PATH_MAX];
strlcpy(new_path, path, PATH_MAX);
strlcat(new_path, "/", PATH_MAX);
strlcat(new_path, item, PATH_MAX);
/*
*nandroid_restore(backup_path, restore_boot, system, data, chache , sdext, wimax)
*/
if (p_current != NULL && RET_YES == miui_confirm(3, p_current->name, p_current->desc, p_current->icon)) {
backup_restore(new_path);
}
break;
}
} while(1);
int i;
for (i = 0; i < z_size; ++i)
{
free(zips[i]);
free(zips_desc[i]);
}
free(zips);
return result;
}