int write_instructions(int fd, int fdwrite) { char *tmp; int size; int i; char *ins; char *param; t_asm *my_asm; i = 2; my_asm = NULL; while ((tmp = get_next_line(fd))) { i++; if (tmp != NULL && tmp[0] != '.' && all_space(tmp) != 0) { tmp = remove_space(tmp); ins = parse_action(tmp, 0); param = parse_action(tmp, 1); ins = remove_all_space(ins); param = remove_all_space(param); if (check_arg(ins) != 1 || check_param(ins, param) != 1) return (error_line(i)); my_asm = add_action(my_asm, ins, param); } } my_asm = my_asm->next; if ((size = instructions_file(fdwrite, my_asm)) == -1 || write_size(fdwrite, size) == -1) return (-1); return (0); }
/** * Init function for the powerkey component * * @return TRUE on success, FALSE on failure */ gboolean mce_powerkey_init(void) { gboolean status = FALSE; gchar *tmp = NULL; /* Append triggers/filters to datapipes */ append_input_trigger_to_datapipe(&keypress_pipe, powerkey_trigger); /* req_trigger_powerkey_event */ if (mce_dbus_handler_add(MCE_REQUEST_IF, MCE_TRIGGER_POWERKEY_EVENT_REQ, NULL, DBUS_MESSAGE_TYPE_METHOD_CALL, trigger_powerkey_event_req_dbus_cb) == NULL) goto EXIT; /* Get configuration options */ longdelay = mce_conf_get_int(MCE_CONF_POWERKEY_GROUP, MCE_CONF_POWERKEY_LONG_DELAY, DEFAULT_POWER_LONG_DELAY); mediumdelay = mce_conf_get_int(MCE_CONF_POWERKEY_GROUP, MCE_CONF_POWERKEY_MEDIUM_DELAY, DEFAULT_POWER_MEDIUM_DELAY); tmp = mce_conf_get_string(MCE_CONF_POWERKEY_GROUP, MCE_CONF_POWERKEY_SHORT_ACTION, ""); /* Since we've set a default, error handling is unnecessary */ (void)parse_action(tmp, &shortpresssignal, &shortpressaction); g_free(tmp); tmp = mce_conf_get_string(MCE_CONF_POWERKEY_GROUP, MCE_CONF_POWERKEY_LONG_ACTION, ""); /* Since we've set a default, error handling is unnecessary */ (void)parse_action(tmp, &longpresssignal, &longpressaction); g_free(tmp); doublepressdelay = mce_conf_get_int(MCE_CONF_POWERKEY_GROUP, MCE_CONF_POWERKEY_DOUBLE_DELAY, DEFAULT_POWER_DOUBLE_DELAY); tmp = mce_conf_get_string(MCE_CONF_POWERKEY_GROUP, MCE_CONF_POWERKEY_DOUBLE_ACTION, ""); /* Since we've set a default, error handling is unnecessary */ (void)parse_action(tmp, &doublepresssignal, &doublepressaction); g_free(tmp); status = TRUE; EXIT: return status; }
static void parse_config(const char *fn, char *s) { struct parse_state state; next_token(&state); int kw = lookup_keyword(args[0]); parse_new_section(&state, kw, nargs, args); { // case K_service: set service handle action // add service into list state->context = parse_service(state, nargs, args); { struct service *svc; list_init(&svc->onrestart.commands); list_add_tail(&service_list, &svc->slist); } // case K_on: // add action into list state->context = parse_action(state, nargs, args); { list_add_tail(&action_list, &act->alist); } } }
static int do_command(char *str) { int action, id; char action_str[10+1] = {0}, id_str[64+1] = {0}; if (0 == strncasecmp(str, "HELP", strlen(str))) { print_help(stdout); return 0; } if (2 != sscanf(str, " %10s %64s", action_str, id_str)) return -1; if (0 == strncasecmp(action_str, "TARGET", strlen(action_str))) return parse_target(id_str); action = parse_action(action_str); id = parse_id(id_str); if (action == BAD_ACTION || id == BAD_ID) return -1; if (id == AMBIGUOUS_ID) { fprintf(stdout, "id %s is too ambiguous\n", id_str); return 0; } fprintf(stdout, "sending: %s %s\n", action_string[action], idtab[id].name); idtab[id].func(action, id, str); return 0; }
int read_options(struct client_options *cl_opts, int argc, char **argv) { const char *options = "u:p:h:c:o:A:N:f:s:"; char *action = NULL; char cur_option; memset(cl_opts, 0, sizeof(struct client_options)); while ((cur_option = (char)getopt(argc, argv, options)) != -1) { if (!optarg) { usage(); return 0; } switch(cur_option) { case 's': cl_opts->str_filesize = optarg; break; case 'u': cl_opts->username = optarg; break; case 'p': cl_opts->password = optarg; break; case 'h': cl_opts->url = optarg; break; case 'c': cl_opts->container = optarg; break; case 'o': cl_opts->object = optarg; break; case 'A': action = optarg; break; case 'N': cl_opts->path = optarg; break; case 'f': cl_opts->filename = optarg; break; case '?': default: usage(); return 0; break; } } if ((action == NULL) && (cl_opts->path == NULL)) { usage(); return 0; } if (action != NULL) { cl_opts->action = parse_action(action); } else { cl_opts->action = ACTION_NODELIST; } }
static int cgroup_parse_opt(struct filter_util *qu, char *handle, int argc, char **argv, struct nlmsghdr *n) { struct tcmsg *t = NLMSG_DATA(n); struct rtattr *tail; long h = 0; if (handle) { h = strtol(handle, NULL, 0); if (h == LONG_MIN || h == LONG_MAX) { fprintf(stderr, "Illegal handle \"%s\", must be numeric.\n", handle); return -1; } } t->tcm_handle = h; tail = (struct rtattr*)(((void*)n)+NLMSG_ALIGN(n->nlmsg_len)); addattr_l(n, MAX_MSG, TCA_OPTIONS, NULL, 0); while (argc > 0) { if (matches(*argv, "match") == 0) { NEXT_ARG(); if (parse_ematch(&argc, &argv, TCA_CGROUP_EMATCHES, n)) { fprintf(stderr, "Illegal \"ematch\"\n"); return -1; } continue; } else if (matches(*argv, "action") == 0) { NEXT_ARG(); if (parse_action(&argc, &argv, TCA_CGROUP_ACT, n)) { fprintf(stderr, "Illegal \"action\"\n"); return -1; } continue; } else if (matches(*argv, "police") == 0) { NEXT_ARG(); if (parse_police(&argc, &argv, TCA_CGROUP_POLICE, n)) { fprintf(stderr, "Illegal \"police\"\n"); return -1; } continue; } else if (strcmp(*argv, "help") == 0) { explain(); return -1; } else { fprintf(stderr, "What is \"%s\"?\n", *argv); explain(); return -1; } argc--; argv++; } tail->rta_len = (((void*)n)+n->nlmsg_len) - (void*)tail; return 0; }
void SpriteData::parse(const Pathname& dir, FileReader& reader) { std::vector<FileReader> sections = reader.get_sections(); for(std::vector<FileReader>::iterator i = sections.begin(); i != sections.end(); ++i) actions.push_back(parse_action(dir, *i)); if(actions.size() == 0) throw std::runtime_error("Sprite contains no actions"); }
/* ================= G_AddIP_f ================= */ void G_AddIP_f(edict_t *ent) { unsigned mask, compare; unsigned duration; ipaction_t action; int start, argc; char *s; start = ent ? 0 : 1; argc = gi.argc() - start; if (argc < 2) { gi.cprintf(ent, PRINT_HIGH, "Usage: %s <ip-mask> [duration] [action]\n", gi.argv(start)); return; } if (numipfilters == MAX_IPFILTERS) { gi.cprintf(ent, PRINT_HIGH, "IP filter list is full\n"); return; } s = gi.argv(start + 1); if (!parse_filter(s, &mask, &compare)) { gi.cprintf(ent, PRINT_HIGH, "Bad filter address: %s\n", s); return; } duration = ent ? DEF_DURATION : 0; action = IPA_BAN; if (argc > 2) { s = gi.argv(start + 2); duration = parse_duration(s); if (ent) { if (!duration) { gi.cprintf(ent, PRINT_HIGH, "You may not add permanent bans.\n"); return; } if (duration > MAX_DURATION) { duration = MAX_DURATION; } } if (argc > 3) { s = gi.argv(start + 3); action = parse_action(s); if (action == IPA_NONE) { gi.cprintf(ent, PRINT_HIGH, "Bad action specifier: %s\n", s); return; } } } add_filter(action, mask, compare, duration, ent); }
SpriteData::SpriteData(const lisp::Lisp* lisp, const std::string& basedir) { lisp::ListIterator iter(lisp); while(iter.next()) { if(iter.item() == "name") { iter.value()->get(name); } else if(iter.item() == "action") { parse_action(iter.lisp(), basedir); } else { log_warning << "Unknown sprite field: " << iter.item() << std::endl; } } if(actions.empty()) throw std::runtime_error("Error: Sprite wihtout actions."); }
SpriteData::SpriteData(const ReaderMapping& lisp, const std::string& basedir) : actions(), name() { auto iter = lisp.get_iter(); while(iter.next()) { if(iter.get_key() == "name") { iter.get(name); } else if(iter.get_key() == "action") { parse_action(iter.as_mapping(), basedir); } else { log_warning << "Unknown sprite field: " << iter.get_key() << std::endl; } } if(actions.empty()) throw std::runtime_error("Error: Sprite without actions."); }
static void parse_actions(struct action_context *ctx) { /* "drop;" by itself is a valid (empty) set of actions, but it can't be * combined with other actions because that doesn't make sense. */ if (ctx->lexer->token.type == LEX_T_ID && !strcmp(ctx->lexer->token.s, "drop") && lexer_lookahead(ctx->lexer) == LEX_T_SEMICOLON) { lexer_get(ctx->lexer); /* Skip "drop". */ lexer_get(ctx->lexer); /* Skip ";". */ if (ctx->lexer->token.type != LEX_T_END) { action_syntax_error(ctx, "expecting end of input"); } return; } while (ctx->lexer->token.type != LEX_T_END) { if (!parse_action(ctx)) { return; } } }
int tc_action_modify(int cmd, unsigned flags, int *argc_p, char ***argv_p) { int argc = *argc_p; char **argv = *argv_p; int ret = 0; struct rtattr *tail; struct { struct nlmsghdr n; struct tcamsg t; char buf[MAX_MSG]; } req; req.t.tca_family = AF_UNSPEC; memset(&req, 0, sizeof(req)); req.n.nlmsg_len = NLMSG_LENGTH(sizeof(struct tcamsg)); req.n.nlmsg_flags = NLM_F_REQUEST|flags; req.n.nlmsg_type = cmd; tail = NLMSG_TAIL(&req.n); argc -=1; argv +=1; if (parse_action(&argc, &argv, TCA_ACT_TAB, &req.n)) { fprintf(stderr, "Illegal \"action\"\n"); return -1; } tail->rta_len = (void *) NLMSG_TAIL(&req.n) - (void *) tail; if (rtnl_talk(&rth, &req.n, 0, 0, NULL) < 0) { fprintf(stderr, "We have an error talking to the kernel\n"); ret = -1; } *argc_p = argc; *argv_p = argv; return ret; }
static int fw_parse_opt(struct filter_util *qu, char *handle, int argc, char **argv, struct nlmsghdr *n) { struct tc_police tp; struct tcmsg *t = NLMSG_DATA(n); struct rtattr *tail; memset(&tp, 0, sizeof(tp)); if (handle) { if (get_u32(&t->tcm_handle, handle, 0)) { fprintf(stderr, "Illegal \"handle\"\n"); return -1; } } if (argc == 0) return 0; tail = NLMSG_TAIL(n); addattr_l(n, 4096, TCA_OPTIONS, NULL, 0); while (argc > 0) { if (matches(*argv, "classid") == 0 || matches(*argv, "flowid") == 0) { unsigned handle; NEXT_ARG(); if (get_tc_classid(&handle, *argv)) { fprintf(stderr, "Illegal \"classid\"\n"); return -1; } addattr_l(n, 4096, TCA_FW_CLASSID, &handle, 4); } else if (matches(*argv, "police") == 0) { NEXT_ARG(); if (parse_police(&argc, &argv, TCA_FW_POLICE, n)) { fprintf(stderr, "Illegal \"police\"\n"); return -1; } continue; } else if (matches(*argv, "action") == 0) { NEXT_ARG(); if (parse_action(&argc, &argv, TCA_FW_ACT, n)) { fprintf(stderr, "Illegal fw \"action\"\n"); return -1; } continue; } else if (strcmp(*argv, "indev") == 0) { char d[IFNAMSIZ+1]; memset(d, 0, sizeof (d)); argc--; argv++; if (argc < 1) { fprintf(stderr, "Illegal indev\n"); return -1; } strncpy(d, *argv, sizeof (d) - 1); addattr_l(n, MAX_MSG, TCA_FW_INDEV, d, strlen(d) + 1); } else if (strcmp(*argv, "help") == 0) { explain(); return -1; } else { fprintf(stderr, "What is \"%s\"?\n", *argv); explain(); return -1; } argc--; argv++; } tail->rta_len = (void *) NLMSG_TAIL(n) - (void *) tail; return 0; }
static #endif int real_main(int argc, char *argv[]) { int ret=1; int option=0; int daemon=1; int forking=1; int strip=0; int randomise=0; struct lock *lock=NULL; struct conf **confs=NULL; int forceoverwrite=0; enum action act=ACTION_LIST; const char *backup=NULL; const char *backup2=NULL; char *restoreprefix=NULL; char *stripfrompath=NULL; const char *regex=NULL; const char *browsefile=NULL; char *browsedir=NULL; const char *conffile=get_conf_path(); const char *orig_client=NULL; const char *logfile=NULL; // The orig_client is the original client that the normal client // would like to restore from. #ifndef HAVE_WIN32 int generate_ca_only=0; #endif int vss_restore=1; int test_confs=0; enum burp_mode mode; log_init(argv[0]); #ifndef HAVE_WIN32 if(!strcmp(prog, "bedup")) return run_bedup(argc, argv); if(!strcmp(prog, "bsigs")) return run_bsigs(argc, argv); #endif while((option=getopt(argc, argv, "a:b:c:C:d:fFghil:nq:Qr:s:tvxjz:?"))!=-1) { switch(option) { case 'a': if(parse_action(&act, optarg)) goto end; break; case 'b': // The diff command may have two backups // specified. if(!backup2 && backup) backup2=optarg; if(!backup) backup=optarg; break; case 'c': conffile=optarg; break; case 'C': orig_client=optarg; break; case 'd': restoreprefix=optarg; // for restores browsedir=optarg; // for lists break; case 'f': forceoverwrite=1; break; case 'F': daemon=0; break; case 'g': #ifndef HAVE_WIN32 generate_ca_only=1; #endif break; case 'i': cmd_print_all(); ret=0; goto end; case 'l': logfile=optarg; break; case 'n': forking=0; break; case 'q': randomise=atoi(optarg); break; case 'Q': log_force_quiet(); break; case 'r': regex=optarg; break; case 's': strip=atoi(optarg); break; case 'v': printf("%s-%s\n", progname(), VERSION); ret=0; goto end; case 'x': vss_restore=0; break; case 't': test_confs=1; break; case 'z': browsefile=optarg; break; case 'h': case '?': default: usage(); goto end; } } if(optind<argc) { usage(); goto end; } if(act==ACTION_MONITOR) { // Try to output everything in JSON. log_set_json(1); #ifndef HAVE_WIN32 // Need to do this so that processes reading stdout get the // result of the printfs of logp straight away. setlinebuf(stdout); #endif } if(!(confs=confs_alloc())) goto end; if(reload(confs, conffile, 1)) goto end; // Dry run to test config file syntax. if(test_confs) { ret=run_test_confs(confs, orig_client); goto end; } if(!backup) switch(act) { case ACTION_DELETE: logp("No backup specified for deletion.\n"); goto end; case ACTION_RESTORE: case ACTION_VERIFY: case ACTION_DIFF: case ACTION_DIFF_LONG: logp("No backup specified. Using the most recent.\n"); backup="0"; default: break; } if(!backup2) switch(act) { case ACTION_DIFF: case ACTION_DIFF_LONG: logp("No second backup specified. Using file system scan.\n"); backup2="n"; // For 'next'. default: break; } // The logfile option is only used for the status client stuff. if(logfile && (act!=ACTION_STATUS && act!=ACTION_STATUS_SNAPSHOT)) logp("-l <logfile> option obsoleted\n"); if(orig_client && *orig_client && set_string(confs[OPT_ORIG_CLIENT], orig_client)) goto end; // The random delay needs to happen before the lock is got, otherwise // you would never be able to use burp by hand. if(randomise) set_int(confs[OPT_RANDOMISE], randomise); mode=get_e_burp_mode(confs[OPT_BURP_MODE]); if(mode==BURP_MODE_CLIENT && (act==ACTION_BACKUP_TIMED || act==ACTION_TIMER_CHECK)) random_delay(confs); if(mode==BURP_MODE_SERVER && act==ACTION_CHAMP_CHOOSER) { // These server modes need to run without getting the lock. } else if(mode==BURP_MODE_CLIENT && (act==ACTION_LIST || act==ACTION_LIST_LONG || act==ACTION_DIFF || act==ACTION_DIFF_LONG || act==ACTION_STATUS || act==ACTION_STATUS_SNAPSHOT || act==ACTION_MONITOR)) { // These client modes need to run without getting the lock. } else { const char *lockfile=confs_get_lockfile(confs); if(!(lock=lock_alloc_and_init(lockfile))) goto end; lock_get(lock); switch(lock->status) { case GET_LOCK_GOT: break; case GET_LOCK_NOT_GOT: logp("Could not get lockfile.\n"); logp("Another process is probably running,\n"); goto end; case GET_LOCK_ERROR: default: logp("Could not get lockfile.\n"); logp("Maybe you do not have permissions to write to %s.\n", lockfile); goto end; } } set_int(confs[OPT_OVERWRITE], forceoverwrite); set_int(confs[OPT_STRIP], strip); set_int(confs[OPT_FORK], forking); set_int(confs[OPT_DAEMON], daemon); strip_trailing_slashes(&restoreprefix); strip_trailing_slashes(&browsedir); if(replace_conf_str(confs[OPT_BACKUP], backup) || replace_conf_str(confs[OPT_BACKUP2], backup2) || replace_conf_str(confs[OPT_RESTOREPREFIX], restoreprefix) || replace_conf_str(confs[OPT_STRIP_FROM_PATH], stripfrompath) || replace_conf_str(confs[OPT_REGEX], regex) || replace_conf_str(confs[OPT_BROWSEFILE], browsefile) || replace_conf_str(confs[OPT_BROWSEDIR], browsedir) || replace_conf_str(confs[OPT_MONITOR_LOGFILE], logfile)) goto end; base64_init(); hexmap_init(); if(mode==BURP_MODE_SERVER) { #ifdef HAVE_WIN32 logp("Sorry, server mode is not implemented for Windows.\n"); #else ret=server_modes(act, conffile, lock, generate_ca_only, confs); #endif } else { ret=client(confs, act, vss_restore); } end: lock_release(lock); lock_free(&lock); confs_free(&confs); return ret; }
int main(int argc, char *argv[]) { struct opal_prd_ctx _ctx; enum action action; int rc; check_abi(); ctx = &_ctx; memset(ctx, 0, sizeof(*ctx)); ctx->vlog = pr_log_stdio; ctx->use_syslog = true; /* Parse options */ for (;;) { int c; c = getopt_long(argc, argv, "f:p:dhse", opal_diag_options, NULL); if (c == -1) break; switch (c) { case 'f': ctx->hbrt_file_name = optarg; break; case 'd': ctx->debug = true; break; case 'p': ctx->pnor.path = strndup(optarg, PATH_MAX); break; case 's': ctx->use_syslog = false; break; case 'h': usage(argv[0]); return EXIT_SUCCESS; case 'e': ctx->expert_mode = true; break; case 'v': print_version(); return EXIT_SUCCESS; case '?': default: usage(argv[0]); return EXIT_FAILURE; } } if (optind < argc) { rc = parse_action(argv[optind], &action); if (rc) return EXIT_FAILURE; } else { action = ACTION_RUN_DAEMON; } if (is_prd_supported() < 0) { pr_log(LOG_ERR, "CTRL: PowerNV OPAL runtime diagnostic " "is not supported on this system"); return -1; } switch (action) { case ACTION_RUN_DAEMON: rc = run_prd_daemon(ctx); break; case ACTION_OCC_CONTROL: if (optind + 1 >= argc) { pr_log(LOG_ERR, "CTRL: occ command requires " "an argument"); return EXIT_FAILURE; } rc = send_occ_control(ctx, argv[optind + 1]); break; case ACTION_ATTR_OVERRIDE: if (optind + 1 >= argc) { pr_log(LOG_ERR, "CTRL: attribute override command " "requires an argument"); return EXIT_FAILURE; } rc = send_attr_override(ctx, argc - optind - 1, &argv[optind + 1]); break; case ACTION_HTMGT_PASSTHRU: if (optind + 1 >= argc) { pr_log(LOG_ERR, "CTRL: htmgt passthru requires at least " "one argument"); return EXIT_FAILURE; } rc = send_htmgt_passthru(ctx, argc - optind - 1, &argv[optind + 1]); break; case ACTION_RUN_COMMAND: if (optind + 1 >= argc) { pr_log(LOG_ERR, "CTRL: run command requires " "argument(s)"); return EXIT_FAILURE; } rc = send_run_command(ctx, argc - optind - 1, &argv[optind + 1]); break; default: break; } return rc == 0 ? EXIT_SUCCESS : EXIT_FAILURE; }
/* This is to be called at every loop() */ int ReceiverRouter::get_stm_action() { read_channels(); //Once every 500ms return parse_action(); }
int main (int argc, char *argv[]) { int ret=1; int option=0; int daemon=1; int forking=1; int strip=0; struct lock *lock=NULL; struct conf *conf=NULL; int forceoverwrite=0; enum action act=ACTION_LIST; const char *backup=NULL; const char *restoreprefix=NULL; const char *regex=NULL; const char *browsefile=NULL; const char *browsedir=NULL; const char *conffile=get_conf_path(); const char *orig_client=NULL; // The orig_client is the original client that the normal client // would like to restore from. #ifndef HAVE_WIN32 const char *sclient=NULL; // Status monitor client to view. int generate_ca_only=0; #endif int vss_restore=1; int json=0; init_log(argv[0]); while((option=getopt(argc, argv, "a:b:c:C:d:ghfFil:nr:s:vxjz:?"))!=-1) { switch(option) { case 'a': if(parse_action(&act, optarg)) goto end; break; case 'b': backup=optarg; break; case 'c': conffile=optarg; break; case 'C': orig_client=optarg; #ifndef HAVE_WIN32 sclient=optarg; #endif break; case 'd': restoreprefix=optarg; // for restores browsedir=optarg; // for lists break; case 'f': forceoverwrite=1; break; case 'F': daemon=0; break; case 'g': #ifndef HAVE_WIN32 generate_ca_only=1; #endif break; case 'i': cmd_print_all(); ret=0; goto end; case 'l': logp("-l <logfile> option obsoleted\n"); break; case 'n': forking=0; break; case 'r': regex=optarg; break; case 's': strip=atoi(optarg); break; case 'v': printf("%s-%s\n", progname(), VERSION); ret=0; goto end; case 'x': vss_restore=0; break; case 'j': json=1; break; case 'z': browsefile=optarg; break; case 'h': case '?': default: usage(); goto end; } } if(optind<argc) { usage(); goto end; } if(!(conf=conf_alloc())) goto end; if(reload(conf, conffile, 1 /* first time */, 0 /* no oldmax_children setting */, 0 /* no oldmax_status_children setting */, json)) goto end; if((act==ACTION_RESTORE || act==ACTION_VERIFY) && !backup) { logp("No backup specified. Using the most recent.\n"); backup="0"; } if(act==ACTION_DELETE && !backup) { logp("No backup specified for deletion.\n"); goto end; } if(conf->mode==MODE_CLIENT) { if(orig_client && *orig_client) { if(!(conf->orig_client=strdup(orig_client))) { log_out_of_memory(__func__); goto end; } } } if(conf->mode==MODE_SERVER && (act==ACTION_STATUS || act==ACTION_STATUS_SNAPSHOT || act==ACTION_CHAMP_CHOOSER)) { // These server modes need to run without getting the lock. } else { if(!(lock=lock_alloc_and_init(conf->lockfile))) goto end; lock_get(lock); switch(lock->status) { case GET_LOCK_GOT: break; case GET_LOCK_NOT_GOT: logp("Could not get lockfile.\n"); logp("Another process is probably running,\n"); goto end; case GET_LOCK_ERROR: default: logp("Could not get lockfile.\n"); logp("Maybe you do not have permissions to write to %s.\n", conf->lockfile); goto end; } } conf->overwrite=forceoverwrite; conf->strip=strip; conf->forking=forking; conf->daemon=daemon; if(replace_conf_str(backup, &conf->backup) || replace_conf_str(restoreprefix, &conf->restoreprefix) || replace_conf_str(regex, &conf->regex) || replace_conf_str(browsefile, &conf->browsefile) || replace_conf_str(browsedir, &conf->browsedir)) goto end; if(conf->mode==MODE_SERVER) { #ifdef HAVE_WIN32 logp("Sorry, server mode is not implemented for Windows.\n"); #else if(act==ACTION_STATUS || act==ACTION_STATUS_SNAPSHOT) { // We are running on the server machine, being a client // of the burp server, getting status information. ret=status_client_ncurses(conf, act, sclient); } else if(act==ACTION_CHAMP_CHOOSER) { // We are running on the server machine, wanting to // be a standalone champion chooser process. if(!sclient || !*sclient) { logp("No client name specified for standalone champion chooser process.\n"); logp("Try using the '-C' option.\n"); ret=1; } else ret=champ_chooser_server_standalone(conf, sclient); } else ret=server(conf, conffile, lock, generate_ca_only); #endif } else { logp("before client\n"); ret=client(conf, act, vss_restore, json); logp("after client\n"); } end: lock_release(lock); lock_free(&lock); conf_free(conf); return ret; }
/* Add user input to the 'current' string (as defined by d->str). */ void string_add(Descriptor *d, char *str) { FILE *fl; int terminator = 0, action = 0; register int i = 2, j = 0; char actions[MAX_INPUT_LENGTH]; /* determine if this is the terminal string, and truncate if so */ /* changed to only accept '@' at the beginning of line - J. Elson 1/17/94 */ /* Changed to accept '/<letter>' style editing commands - instead */ /* of solitary '@' to end. - M. Scott 10/15/96 */ delete_doubledollar(str); if ((action = ((*str == '/') && (str[1] != '/') && (str[1] != '*')))) { while (str[i] != '\0') { actions[j] = str[i]; ++i; ++j; } actions[j] = '\0'; *str = '\0'; switch (str[1]) { case 'a': terminator = 2; /* Working on an abort message, */ break; case 'c': if (*(d->str)) { delete [](*(d->str)); *(d->str) = NULL; d->send("Current buffer cleared.\r\n"); } else d->send("Current buffer empty.\r\n"); break; case 'd': parse_action(PARSE_DELETE, actions, d); break; case 'e': parse_action(PARSE_EDIT, actions, d); break; case 'f': if (*(d->str)) parse_action(PARSE_FORMAT, actions, d); else d->send("Current buffer empty.\r\n"); break; case 'i': if (*(d->str)) parse_action(PARSE_INSERT, actions, d); else d->send("Current buffer empty.\r\n"); break; case 'h': parse_action(PARSE_HELP, actions, d); break; case 'l': if (*d->str) parse_action(PARSE_LIST_NORM, actions, d); else d->send("Current buffer empty.\r\n"); break; case 'n': if (*d->str) parse_action(PARSE_LIST_NUM, actions, d); else d->send("Current buffer empty.\r\n"); break; case 'r': parse_action(PARSE_REPLACE, actions, d); break; case 's': terminator = 1; *str = '\0'; break; default: d->send("Invalid option.\r\n"); break; } if(!terminator) return; } if(!terminator) { if (!(*d->str)) { if (strlen(str) > d->max_str) { d->send("String too long - Truncated.\r\n"); *(str + d->max_str) = '\0'; /* Changed this to NOT abort out.. just give warning. */ /* terminator = 1; */ } (*d->str) = new char[d->max_str]; *(*d->str) = '\0'; d->addToString(str); } else { if (!d->addToString(str)) d->send("String too long, limit reached on message. Last line ignored.\r\n"); } } if(terminator) { /* * OLC Edits */ extern void oedit_disp_menu(Descriptor *d); extern void oedit_disp_extradesc_menu(Descriptor *d); extern void redit_disp_menu(Descriptor *d); extern void redit_disp_extradesc_menu(Descriptor *d); extern void redit_disp_exit_menu(Descriptor *d); extern void medit_disp_menu(Descriptor *d); extern void CeditGameOptionsMenu(Descriptor *d); extern void cedit_disp_operation_options(Descriptor *d); #if defined(OASIS_MPROG) extern void medit_change_mprog(Descriptor *d); if (STATE(d) == CON_MEDIT) { switch (OLC_MODE(d)) { case MEDIT_D_DESC: medit_disp_menu(d); break; case MEDIT_MPROG_COMLIST: medit_change_mprog(d); break; } } #endif /* * Here we check for the abort option and reset the pointers. */ if ((terminator == 2) && ((STATE(d) == CON_REDIT) || (STATE(d) == CON_MEDIT) || (STATE(d) == CON_OEDIT) || (STATE(d) == CON_EXDESC) || STATE(d) == CON_CEDIT)) { delete[] (*d->str); if (d->backstr) { *d->str = d->backstr; } else *d->str = NULL; d->backstr = NULL; d->str = NULL; } /* * This fix causes the editor to NULL out empty messages -- M. Scott * Fixed to fix the fix for empty fixed messages. -- gg */ if ((d->str) && (*d->str) && (**d->str == '\0')) { delete[] (*d->str); if(!d->character || d->str != &d->character->player.description) *d->str = str_dup("Nothing.\r\n"); else *d->str = str_dup(" "); } if (STATE(d) == CON_MEDIT) medit_disp_menu(d); if (STATE(d) == CON_OEDIT) { switch (OLC_MODE(d)) { case OEDIT_ACTDESC: oedit_disp_menu(d); break; case OEDIT_EXTRADESC_DESCRIPTION: oedit_disp_extradesc_menu(d); break; } } else if (STATE(d) == CON_REDIT) { switch (OLC_MODE(d)) { case REDIT_DESC: redit_disp_menu(d); break; case REDIT_EXIT_DESCRIPTION: redit_disp_exit_menu(d); break; case REDIT_EXTRADESC_DESCRIPTION: redit_disp_extradesc_menu(d); break; } } else if(STATE(d) == CON_CEDIT) { switch(OLC_MODE(d)) { case CEDIT_GAME_OPTIONS_MENU: CeditGameOptionsMenu(d); break; case CEDIT_OPERATION_OPTIONS_MENU: CeditGameOptionsMenu(d); break; } } else if (!d->connected && d->character && !IS_NPC(d->character)) { if (terminator == 1) { if (*d->str && strlen(*d->str) == 0) { delete (*d->str); *d->str = NULL; } } else { delete (*d->str); if (d->backstr) *d->str = d->backstr; else *d->str = NULL; d->backstr = NULL; d->sendRaw("Message aborted.\r\n"); } } if (d->character && !IS_NPC(d->character)) { REMOVE_BIT(PLR_FLAGS(d->character), Q_BIT(PLR_WRITING)); REMOVE_BIT(PLR_FLAGS(d->character), Q_BIT(PLR_MAILING)); } if (d->backstr) delete [](d->backstr); d->backstr = NULL; d->str = NULL; } //Add a newline only if able -Galnor, 03/20/2009 else if (!action) d->addToString("\r\n"); }
int main(int argc, char* argv[]) { try { auto act = parse_action(argc, argv); switch (act) { case action::WATCH: { auto vars = parse_variable_ids(argc, argv); fv::var_observer obs(vars); auto disconnection = obs.disconnection(); disconnection.get(); return 0; } case action::SET: { auto var_id = fv::variable_id::parse(argv[2]); auto var_value = parse_variable_value(argv[3]); fv::var_observer obs(var_id); std::cerr << oac::format( "Setting %s with value %s", var_id.to_string(), var_value.to_string()) << std::endl; obs.set_value(var_id, var_value); std::cerr << "Value set successfully" << std::endl; return 0; break; } } } catch (const fv::variable_id::parse_error& e) { std::cerr << "Error while parsing program arguments: " << e.message() << std::endl; } catch (const fv::client::communication_error& comm_error) { std::cerr << "Communication error: " << std::endl; std::cerr << comm_error.report() << std::endl << std::endl; } catch (const oac::exception& e) { std::cerr << "Unexpected exception thrown" << std::endl; std::cerr << e.report() << std::endl << std::endl; } catch (...) { std::cerr << "Unexpected exception thrown: no further details available" << std::endl; } print_help(); return 1; }
int main(int argc, char *argv[]) { struct opal_prd_ctx _ctx; enum action action; int rc; ctx = &_ctx; memset(ctx, 0, sizeof(*ctx)); ctx->vlog = pr_log_stdio; ctx->use_syslog = true; /* Parse options */ for (;;) { int c; c = getopt_long(argc, argv, "f:p:dhs", opal_diag_options, NULL); if (c == -1) break; switch (c) { case 'f': ctx->hbrt_file_name = optarg; break; case 'd': ctx->debug = true; break; case 'p': ctx->pnor.path = strndup(optarg, PATH_MAX); break; case 's': ctx->use_syslog = false; break; case 'h': usage(argv[0]); return EXIT_SUCCESS; case 'v': print_version(); return EXIT_SUCCESS; case '?': default: usage(argv[0]); return EXIT_FAILURE; } } if (optind < argc) { rc = parse_action(argv[optind], &action); if (rc) return EXIT_FAILURE; } else { action = ACTION_RUN_DAEMON; } if (action == ACTION_RUN_DAEMON) { rc = run_prd_daemon(ctx); } else if (action == ACTION_OCC_CONTROL) { if (optind + 1 >= argc) { pr_log(LOG_ERR, "CTRL: occ command requires " "an argument"); return EXIT_FAILURE; } rc = send_occ_control(ctx, argv[optind + 1]); } return rc == 0 ? EXIT_SUCCESS : EXIT_FAILURE; }
int init_actions(struct optstruct *opts) { const struct optstruct *opt; if(!(opt = optget(opts, "LogInfected"))->enabled || !strcasecmp(opt->strarg, "Off")) loginfected = LOGINF_NONE; else if(!strcasecmp(opt->strarg, "Basic")) loginfected = LOGINF_BASIC; else if(!strcasecmp(opt->strarg, "Full")) loginfected = LOGINF_FULL; else { logg("!Invalid setting %s for option LogInfected\n", opt->strarg); return 1; } if((opt = optget(opts, "LogClean"))->enabled) { if(!strcasecmp(opt->strarg, "Basic")) loginfected |= LOGCLN_BASIC; else if(!strcasecmp(opt->strarg, "Full")) loginfected |= LOGCLN_FULL; else if(strcasecmp(opt->strarg, "Off")) { logg("!Invalid setting %s for option LogClean\n", opt->strarg); return 1; } } if((opt = optget(opts, "VirusAction"))->enabled) viraction = strdup(opt->strarg); if((opt = optget(opts, "OnFail"))->enabled) { switch(parse_action(opt->strarg)) { case 0: FailAction = SMFIS_ACCEPT; break; case 1: FailAction = SMFIS_TEMPFAIL; break; case 2: FailAction = SMFIS_REJECT; break; default: logg("!Invalid action %s for option OnFail\n", opt->strarg); return 1; } } else FailAction = SMFIS_TEMPFAIL; if((opt = optget(opts, "OnClean"))->enabled) { switch(parse_action(opt->strarg)) { case 0: CleanAction = action_accept; break; case 1: CleanAction = action_defer; break; case 2: CleanAction = action_reject; break; case 3: CleanAction = action_blackhole; break; case 4: CleanAction = action_quarantine; break; default: logg("!Invalid action %s for option OnClean\n", opt->strarg); return 1; } } else CleanAction = action_accept; if((opt = optget(opts, "OnInfected"))->enabled) { switch(parse_action(opt->strarg)) { case 0: InfectedAction = action_accept; break; case 1: InfectedAction = action_defer; break; case 3: InfectedAction = action_blackhole; break; case 4: InfectedAction = action_quarantine; break; case 2: InfectedAction = action_reject_msg; if((opt = optget(opts, "RejectMsg"))->enabled) { const char *src = opt->strarg; char *dst, c; int gotpctv = 0; rejectfmt = dst = malloc(strlen(src) * 4 + 1); if(!dst) { logg("!Failed to allocate memory for RejectMsg\n"); return 1; } while ((c = *src++)) { if(!isprint(c)) { logg("!RejectMsg contains non printable characters\n"); free(rejectfmt); return 1; } *dst++ = c; if(c == '%') { if(*src == 'v') { if(gotpctv) { logg("!%%v may appear at most once in RejectMsg\n"); free(rejectfmt); return 1; } gotpctv |= 1; src++; *dst++ = 's'; } else { dst[0] = dst[1] = dst[2] = '%'; dst += 3; } } } *dst = '\0'; } break; default: logg("!Invalid action %s for option OnInfected\n", opt->strarg); return 1; } } else InfectedAction = action_quarantine; return 0; }
static int flow_parse_opt(struct filter_util *fu, char *handle, int argc, char **argv, struct nlmsghdr *n) { struct tc_police tp; struct tcmsg *t = NLMSG_DATA(n); struct rtattr *tail; __u32 mask = ~0U, xor = 0; __u32 keys = 0, nkeys = 0; __u32 mode = FLOW_MODE_MAP; __u32 tmp; memset(&tp, 0, sizeof(tp)); if (handle) { if (get_u32(&t->tcm_handle, handle, 0)) { fprintf(stderr, "Illegal \"handle\"\n"); return -1; } } tail = NLMSG_TAIL(n); addattr_l(n, 4096, TCA_OPTIONS, NULL, 0); while (argc > 0) { if (matches(*argv, "map") == 0) { mode = FLOW_MODE_MAP; } else if (matches(*argv, "hash") == 0) { mode = FLOW_MODE_HASH; } else if (matches(*argv, "keys") == 0) { NEXT_ARG(); if (flow_parse_keys(&keys, &nkeys, *argv)) return -1; addattr32(n, 4096, TCA_FLOW_KEYS, keys); } else if (matches(*argv, "and") == 0) { NEXT_ARG(); if (get_u32(&tmp, *argv, 0)) { fprintf(stderr, "Illegal \"mask\"\n"); return -1; } transfer_bitop(&mask, &xor, tmp, 0); } else if (matches(*argv, "or") == 0) { NEXT_ARG(); if (get_u32(&tmp, *argv, 0)) { fprintf(stderr, "Illegal \"or\"\n"); return -1; } transfer_bitop(&mask, &xor, ~tmp, tmp); } else if (matches(*argv, "xor") == 0) { NEXT_ARG(); if (get_u32(&tmp, *argv, 0)) { fprintf(stderr, "Illegal \"xor\"\n"); return -1; } transfer_bitop(&mask, &xor, ~0, tmp); } else if (matches(*argv, "rshift") == 0) { NEXT_ARG(); if (get_u32(&tmp, *argv, 0)) { fprintf(stderr, "Illegal \"rshift\"\n"); return -1; } addattr32(n, 4096, TCA_FLOW_RSHIFT, tmp); } else if (matches(*argv, "addend") == 0) { NEXT_ARG(); if (get_addend(&tmp, *argv, keys)) { fprintf(stderr, "Illegal \"addend\"\n"); return -1; } addattr32(n, 4096, TCA_FLOW_ADDEND, tmp); } else if (matches(*argv, "divisor") == 0) { NEXT_ARG(); if (get_u32(&tmp, *argv, 0)) { fprintf(stderr, "Illegal \"divisor\"\n"); return -1; } addattr32(n, 4096, TCA_FLOW_DIVISOR, tmp); } else if (matches(*argv, "baseclass") == 0) { NEXT_ARG(); if (get_tc_classid(&tmp, *argv) || TC_H_MIN(tmp) == 0) { fprintf(stderr, "Illegal \"baseclass\"\n"); return -1; } addattr32(n, 4096, TCA_FLOW_BASECLASS, tmp); } else if (matches(*argv, "perturb") == 0) { NEXT_ARG(); if (get_u32(&tmp, *argv, 0)) { fprintf(stderr, "Illegal \"perturb\"\n"); return -1; } addattr32(n, 4096, TCA_FLOW_PERTURB, tmp); } else if (matches(*argv, "police") == 0) { NEXT_ARG(); if (parse_police(&argc, &argv, TCA_FLOW_POLICE, n)) { fprintf(stderr, "Illegal \"police\"\n"); return -1; } continue; } else if (matches(*argv, "action") == 0) { NEXT_ARG(); if (parse_action(&argc, &argv, TCA_FLOW_ACT, n)) { fprintf(stderr, "Illegal \"action\"\n"); return -1; } continue; } else if (matches(*argv, "match") == 0) { NEXT_ARG(); if (parse_ematch(&argc, &argv, TCA_FLOW_EMATCHES, n)) { fprintf(stderr, "Illegal \"ematch\"\n"); return -1; } continue; } else if (matches(*argv, "help") == 0) { explain(); return -1; } else { fprintf(stderr, "What is \"%s\"?\n", *argv); explain(); return -1; } argv++, argc--; } if (nkeys > 1 && mode != FLOW_MODE_HASH) { fprintf(stderr, "Invalid mode \"map\" for multiple keys\n"); return -1; } addattr32(n, 4096, TCA_FLOW_MODE, mode); if (mask != ~0 || xor != 0) { addattr32(n, 4096, TCA_FLOW_MASK, mask); addattr32(n, 4096, TCA_FLOW_XOR, xor); } tail->rta_len = (void *)NLMSG_TAIL(n) - (void *)tail; return 0; }