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; }