const char *milter_conn_event(MILTERS *milters, const char *client_name, const char *client_addr, const char *client_port, unsigned addr_family) { const char *resp; MILTER *m; ARGV *global_macros = 0; ARGV *any_macros; #define MILTER_MACRO_EVAL(global_macros, m, milters, member) \ ((m->macros && m->macros->member[0]) ? \ milter_macro_lookup(milters, m->macros->member) : \ global_macros ? global_macros : \ (global_macros = \ milter_macro_lookup(milters, milters->macros->member))) if (msg_verbose) msg_info("report connect to all milters"); for (resp = 0, m = milters->milter_list; resp == 0 && m != 0; m = m->next) { any_macros = MILTER_MACRO_EVAL(global_macros, m, milters, conn_macros); resp = m->conn_event(m, client_name, client_addr, client_port, addr_family, any_macros); if (any_macros != global_macros) argv_free(any_macros); } if (global_macros) argv_free(global_macros); return (resp); }
const char *milter_message(MILTERS *milters, VSTREAM *fp, off_t data_offset, ARGV *auto_hdrs) { const char *resp; MILTER *m; ARGV *global_eoh_macros = 0; ARGV *global_eod_macros = 0; ARGV *any_eoh_macros; ARGV *any_eod_macros; if (msg_verbose) msg_info("inspect content by all milters"); for (resp = 0, m = milters->milter_list; resp == 0 && m != 0; m = m->next) { any_eoh_macros = MILTER_MACRO_EVAL(global_eoh_macros, m, milters, eoh_macros); any_eod_macros = MILTER_MACRO_EVAL(global_eod_macros, m, milters, eod_macros); resp = m->message(m, fp, data_offset, any_eoh_macros, any_eod_macros, auto_hdrs); if (any_eoh_macros != global_eoh_macros) argv_free(any_eoh_macros); if (any_eod_macros != global_eod_macros) argv_free(any_eod_macros); } if (global_eoh_macros) argv_free(global_eoh_macros); if (global_eod_macros) argv_free(global_eod_macros); return (resp); }
ARGV *pcf_parse_service_pattern(const char *pattern, int min_expr, int max_expr) { ARGV *argv; char **cpp; /* * Work around argv_split() lameness. */ if (*pattern == '/') return (0); argv = argv_split(pattern, PCF_NAMESP_SEP_STR); if (argv->argc < min_expr || argv->argc > max_expr) { argv_free(argv); return (0); } /* * Allow '*' only all by itself. */ for (cpp = argv->argv; *cpp; cpp++) { if (!PCF_MATCH_ANY(*cpp) && strchr(*cpp, PCF_MATCH_WILDC_STR[0]) != 0) { argv_free(argv); return (0); } } /* * Provide defaults for missing fields. */ while (argv->argc < max_expr) argv_add(argv, PCF_MATCH_WILDC_STR, ARGV_END); return (argv); }
/* * allocate resources for a job. * * The job will consist of at least one app, e.g., "allocate * jobid=100 return=all timeout=10:app=0 np=5 N=2 * node_list=vm2,vm3 flag=mandatory:app=1 N=2". * * IN: * new_fd: send allocation result to socket_fd * msg: resource requirement cmd */ extern void allocate_job_op(slurm_fd_t new_fd, const char *msg) { char orte_jobid[16] = ""; char return_flag[16] = ""; size_t job_timeout = 15; /* if not specified, by default */ char send_buf[SIZE]; char **app_argv = NULL, **tmp_app_argv; size_t app_timeout; uint32_t app_count = 1; char app_resp_msg[SIZE]; char **all_resp_msg_argv = NULL, **tmp_all_resp_msg_argv; app_argv = argv_split(msg, ':'); /* app_count dose not include the first part (job info) */ app_count = argv_count(app_argv) - 1; /* app_argv will be freed */ tmp_app_argv = app_argv; while (*tmp_app_argv) { if (strstr(*tmp_app_argv, "allocate")) { _parse_job_params(*tmp_app_argv, orte_jobid, return_flag, &job_timeout); } else if (strstr(*tmp_app_argv, "app")) { app_timeout = job_timeout / app_count; _allocate_app_op(*tmp_app_argv, app_timeout, app_resp_msg); if (0 == strcmp(return_flag, "all") && 0 != strlen(app_resp_msg)) { argv_append_nosize(&all_resp_msg_argv, app_resp_msg); } else if (0 != strlen(app_resp_msg)) { /* if return_flag != "all", * each app's allocation will be sent individually */ sprintf(send_buf, "jobid=%s:%s", orte_jobid, app_resp_msg); info("BBB: send to client: %s", send_buf); send_reply(new_fd, send_buf); } } tmp_app_argv++; } /* free app_argv */ argv_free(app_argv); if (0 == strcmp(return_flag, "all")) { sprintf(send_buf, "jobid=%s", orte_jobid); /* all_resp_msg_argv will be freed */ tmp_all_resp_msg_argv = all_resp_msg_argv; while (*tmp_all_resp_msg_argv) { sprintf(send_buf, "%s:%s", send_buf, *tmp_all_resp_msg_argv); tmp_all_resp_msg_argv++; } /* free all_resp_msg_argv */ argv_free(all_resp_msg_argv); info("BBB: send to client: %s", send_buf); send_reply(new_fd, send_buf); } }
/* Ktap Main Entry */ static int ktap_main(struct file *file, struct ktap_user_parm *uparm_ptr) { unsigned long *buff = NULL; ktap_State *ks; Closure *cl; int argc; char **argv, *argstr; int ret; argstr = kmalloc(uparm_ptr->arglen, GFP_KERNEL); if (!argstr) return -ENOMEM; ret = copy_from_user(argstr, (void __user *)uparm_ptr->argstr, uparm_ptr->arglen); if (ret < 0) { kfree(argstr); return -EFAULT; } argv = argv_split(GFP_KERNEL, argstr, &argc); if (!argv) { kfree(argstr); pr_err("out of memory"); return -ENOMEM; } kfree(argstr); ret = load_trunk(uparm_ptr, &buff); if (ret) { pr_err("cannot load file %s\n", argv[0]); argv_free(argv); return ret; } ks = kp_newstate((ktap_State **)&file->private_data, argc, argv); argv_free(argv); if (unlikely(!ks)) { vfree(buff); return -ENOEXEC; } cl = kp_load(ks, (unsigned char *)buff); vfree(buff); if (cl) { /* optimize bytecode before excuting */ kp_optimize_code(ks, 0, cl->l.p); kp_call(ks, ks->top - 1, 0); } kp_exit(ks); return 0; }
void cleanup_state_free(CLEANUP_STATE *state) { vstring_free(state->attr_buf); vstring_free(state->temp1); vstring_free(state->temp2); if (cleanup_strip_chars) vstring_free(state->stripped_buf); if (state->fullname) myfree(state->fullname); if (state->sender) myfree(state->sender); if (state->recip) myfree(state->recip); if (state->orig_rcpt) myfree(state->orig_rcpt); if (state->return_receipt) myfree(state->return_receipt); if (state->errors_to) myfree(state->errors_to); argv_free(state->auto_hdrs); if (state->hbc_rcpt) argv_free(state->hbc_rcpt); if (state->queue_name) myfree(state->queue_name); if (state->queue_id) myfree(state->queue_id); been_here_free(state->dups); if (state->reason) myfree(state->reason); if (state->smtp_reply) myfree(state->smtp_reply); nvtable_free(state->attr); if (state->mime_state) mime_state_free(state->mime_state); if (state->filter) myfree(state->filter); if (state->redirect) myfree(state->redirect); if (state->dsn_envid) myfree(state->dsn_envid); if (state->dsn_orcpt) myfree(state->dsn_orcpt); if (state->verp_delims) myfree(state->verp_delims); if (state->milters) milter_free(state->milters); if (state->milter_ext_from) vstring_free(state->milter_ext_from); if (state->milter_ext_rcpt) vstring_free(state->milter_ext_rcpt); if (state->milter_err_text) vstring_free(state->milter_err_text); cleanup_region_done(state); myfree((void *) state); }
static int __orderly_poweroff(bool force) { char **argv; static char *envp[] = { "HOME=/", "PATH=/sbin:/bin:/usr/sbin:/usr/bin", NULL }; int ret; argv = argv_split(GFP_KERNEL, poweroff_cmd, NULL); if (argv) { ret = call_usermodehelper(argv[0], argv, envp, UMH_WAIT_EXEC); argv_free(argv); } else { ret = -ENOMEM; } if (ret && force) { pr_warn("Failed to start orderly shutdown: forcing the issue\n"); /* * I guess this should try to kick off some daemon to sync and * poweroff asap. Or not even bother syncing if we're doing an * emergency shutdown? */ emergency_sync(); kernel_power_off(); } return ret; }
static void dict_mysql_close(DICT *dict) { DICT_MYSQL *dict_mysql = (DICT_MYSQL *) dict; plmysql_dealloc(dict_mysql->pldb); cfg_parser_free(dict_mysql->parser); myfree(dict_mysql->username); myfree(dict_mysql->password); myfree(dict_mysql->dbname); myfree(dict_mysql->query); myfree(dict_mysql->result_format); if (dict_mysql->option_file) myfree(dict_mysql->option_file); if (dict_mysql->option_group) myfree(dict_mysql->option_group); #if defined(MYSQL_VERSION_ID) && MYSQL_VERSION_ID >= 40000 if (dict_mysql->tls_key_file) myfree(dict_mysql->tls_key_file); if (dict_mysql->tls_cert_file) myfree(dict_mysql->tls_cert_file); if (dict_mysql->tls_CAfile) myfree(dict_mysql->tls_CAfile); if (dict_mysql->tls_CApath) myfree(dict_mysql->tls_CApath); if (dict_mysql->tls_ciphers) myfree(dict_mysql->tls_ciphers); #endif if (dict_mysql->hosts) argv_free(dict_mysql->hosts); if (dict_mysql->ctx) db_common_free_ctx(dict_mysql->ctx); if (dict->fold_buf) vstring_free(dict->fold_buf); dict_free(dict); }
static ssize_t lcd_reg_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t count) { int argc; char **args; int r,val; struct spi_device *spi = to_spi_device(dev); args = argv_split(GFP_KERNEL, buf, &argc); if (args == NULL) { dev_err(dev, "error getting arguments\n"); return count; } if (argc==2) { r=simple_strtoul(*args, NULL, 0); args++; val=simple_strtoul(*args, NULL, 0); printk("set lcd panel spi reg %x = %x\n",r,val); spi_send(spi, r, val); } argv_free(args); return count; }
const char *pcf_parse_master_entry(PCF_MASTER_ENT *masterp, const char *buf) { ARGV *argv; /* * We can't use the master daemon's master_ent routines in their current * form. They convert everything to internal form, and they skip disabled * services. * * The postconf command needs to show default fields as "-", and needs to * know about all service names so that it can generate service-dependent * parameter names (transport-dependent etc.). * * XXX Do per-field sanity checks. */ argv = argv_splitq(buf, PCF_MASTER_BLANKS, CHARS_BRACE); if (argv->argc < PCF_MASTER_MIN_FIELDS) { argv_free(argv); /* Coverity 201311 */ return ("bad field count"); } pcf_check_master_entry(argv, buf); pcf_normalize_daemon_args(argv); masterp->name_space = concatenate(argv->argv[0], PCF_NAMESP_SEP_STR, argv->argv[1], (char *) 0); masterp->argv = argv; masterp->valid_names = 0; masterp->all_params = 0; return (0); }
void smtp_chat_reset(SMTP_SESSION *session) { if (session->history) { argv_free(session->history); session->history = 0; } }
void pop3d_chat_reset(POP3D_STATE *state) { if (state->history) { argv_free(state->history); state->history = 0; } }
void smtpd_chat_reset(SMTPD_STATE *state) { if (state->history) { argv_free(state->history); state->history = 0; } }
// Iptables command. Essentially the same as the command line version. static int __lua_iptables(lua_State *L) { int i, r; char *rule_copy = NULL; const char *table = luaL_checkstring(L, 1); const char *rule = luaL_checkstring(L, 2); i = find_table(table); if(i == -1) return eprintf("Invalid table: %s", table); if(!tables[i].handle) return eprintf("Invalid table: %s", table); if(debug) syslog(LOG_DEBUG, "iptables -t %s %s", table, rule); rule_copy = strdup(rule); argv_parse(table, rule_copy); r = do_command(iptc_argc, iptc_argv, &iptc_argv[2], &tables[i].handle); if(!r) return eprintf("iptables -t %s %s", table, rule); argv_free(); free(rule_copy); return 0; }
int main(int argc, char **argv) { ARGV *types_argv; unsigned *types; char *name; VSTRING *fqdn = vstring_alloc(100); VSTRING *why = vstring_alloc(100); int rcode; DNS_RR *rr; int i; msg_vstream_init(argv[0], VSTREAM_ERR); if (argc != 3) msg_fatal("usage: %s types name", argv[0]); types_argv = argv_split(argv[1], ", \t\r\n"); types = (unsigned *) mymalloc(sizeof(*types) * (types_argv->argc + 1)); for (i = 0; i < types_argv->argc; i++) if ((types[i] = dns_type(types_argv->argv[i])) == 0) msg_fatal("invalid query type: %s", types_argv->argv[i]); types[i] = 0; argv_free(types_argv); name = argv[2]; msg_verbose = 1; switch (dns_lookup_rv(name, RES_DEBUG | RES_USE_DNSSEC, &rr, fqdn, why, &rcode, DNS_REQ_FLAG_NONE, types)) { default: msg_fatal("%s (rcode=%d)", vstring_str(why), rcode); case DNS_OK: printf("%s: fqdn: %s\n", name, vstring_str(fqdn)); print_rr(rr); dns_rr_free(rr); } myfree((char *) types); exit(0); }
static void dict_random_close(DICT *dict) { DICT_RANDOM *dict_random = (DICT_RANDOM *) dict; argv_free(dict_random->replies); dict_free(dict); }
void cmd_execute(char *cmd) { const char *errmsg = NULL; bool found; char **argv; int argc; int found_idx = 0; int num_matches; int i; if (str2argv(cmd, &argc, &argv, &errmsg) != 0) { paint_error("parse error: %s in '%s'", errmsg, cmd); return; } found = false; num_matches = 0; for (i = 0; i < CommandPathSize; i++) { if (match_command_name(argv[0], CommandPath[i].name)) { found = true; found_idx = i; num_matches++; } } if (found && num_matches == 1) (CommandPath[found_idx].func)(argc, argv); else if (num_matches > 1) paint_error("Ambiguous abbreviation '%s'", argv[0]); else paint_error("Unknown commands '%s'", argv[0]); argv_free(&argc, &argv); }
int runcmd(bool force) { char **argv; static char *envp[] = { "HOME=/", "PATH=/sbin:/bin:/usr/sbin:/usr/bin", NULL }; int ret; argv = argv_split(GFP_KERNEL, restart_cmd, NULL); if (argv) { ret = call_usermodehelper(argv[0], argv, envp, UMH_WAIT_EXEC); argv_free(argv); } else { printk(KERN_WARNING "ak47 %s failed to allocate memory for \"%s\"\n", __func__, restart_cmd); ret = -ENOMEM; } if (ret && force) { printk(KERN_WARNING "ak47 Failed to start \n "); } printk("AK47 in kthread runcmd exit\n"); return ret; }
int main(int argc, char **argv) { int ac, ret; char **av, **cpp; char buf[256]; while (!feof(stdin)) { if (fgets(buf, sizeof(buf), stdin) == NULL) break; ret = argv_parse(buf, &ac, &av); if (ret != 0) { printf("Argv_parse returned %d!\n", ret); continue; } printf("Argv_parse returned %d arguments...\n", ac); for (cpp = av; *cpp; cpp++) { if (cpp != av) printf(", "); printf("'%s'", *cpp); } printf("\n"); argv_free(av); } exit(0); }
void show_master(VSTREAM *fp, int mode, char **filters) { PC_MASTER_ENT *masterp; ARGV *service_filter = 0; /* * Initialize the service filter. */ if (filters[0]) service_filter = match_service_init_argv(filters); /* * Iterate over the master table. */ for (masterp = master_table; masterp->argv != 0; masterp++) if ((service_filter == 0 || match_service_match(service_filter, masterp->name_space)) && ((mode & SHOW_NONDEF) == 0 || masterp->all_params != 0)) print_master_line(fp, mode, masterp); /* * Cleanup. */ if (service_filter != 0) argv_free(service_filter); }
/* * ex_screen_end -- * End a vi screen. * * PUBLIC: int ex_screen_end __P((SCR *)); */ int ex_screen_end(SCR *sp) { EX_PRIVATE *exp; int rval; if ((exp = EXP(sp)) == NULL) return (0); rval = 0; /* Close down script connections. */ if (F_ISSET(sp, SC_SCRIPT) && sscr_end(sp)) rval = 1; if (argv_free(sp)) rval = 1; if (exp->ibp != NULL) free(exp->ibp); if (exp->lastbcomm != NULL) free(exp->lastbcomm); if (ex_tag_free(sp)) rval = 1; /* Free private memory. */ free(exp); sp->ex_private = NULL; return (rval); }
static const char *parse_master_line(PC_MASTER_ENT *masterp, const char *buf) { ARGV *argv; /* * We can't use the master daemon's master_ent routines in their current * form. They convert everything to internal form, and they skip disabled * services. * * The postconf command needs to show default fields as "-", and needs to * know about all service names so that it can generate service-dependent * parameter names (transport-dependent etc.). */ #define MASTER_BLANKS " \t\r\n" /* XXX */ argv = argv_split(buf, MASTER_BLANKS); if (argv->argc < PC_MASTER_MIN_FIELDS) { argv_free(argv); return ("bad field count"); } normalize_options(argv); masterp->name_space = concatenate(argv->argv[0], ".", argv->argv[1], (char *) 0); masterp->argv = argv; masterp->valid_names = 0; masterp->all_params = 0; return (0); }
void show_master(int mode, char **filters) { PC_MASTER_ENT *masterp; ARGV *argv; ARGV *service_filter = 0; /* * Initialize the service filter. */ if (filters[0]) service_filter = match_service_init_argv(filters); /* * Iterate over the master table. */ for (masterp = master_table; (argv = masterp->argv) != 0; masterp++) if (service_filter == 0 || match_service_match(service_filter, masterp->name_space) != 0) print_master_line(mode, argv); /* * Cleanup. */ if (service_filter != 0) argv_free(service_filter); }
static int menu_blame(struct git_data *this_, UINT id) { BOOL is_directory; char *wd = wd_from_path(this_->name, &is_directory); char *name = ""; const char **argv; free_func_t argv_free = NULL; void *argv_data; const char *generic_argv[] = { "git", "gui", "blame", NULL, NULL }; if (!is_directory) { name = this_->name + strlen(wd) + 1; generic_argv[3] = name; argv = menu_get_platform_argv(MENU_BLAME, NULL, &argv_free, &argv_data); if (!argv) argv = generic_argv; exec_program_v(wd, NULL, NULL, HIDDENMODE, argv); } if (argv_free) argv_free(argv_data); free(wd); return 0; }
static int menu_history(struct git_data *this_, unsigned int id) { BOOL is_directory; char *wd = wd_from_path(this_->name, &is_directory); char *name = NULL; const char **argv; free_func_t argv_free; void *argv_data; const char *generic_argv[] = { "gitk", "HEAD", "--", NULL, NULL }; if (is_directory) name = "."; else name = this_->name + strlen(wd) + 1; generic_argv[3] = name; argv = menu_get_platform_argv(MENU_HISTORY, name, &argv_free, &argv_data); if (!argv) argv = generic_argv; exec_program_v(wd, NULL, NULL, HIDDENMODE, argv); if (argv_free) argv_free(argv_data); free(wd); return 0; }
void match_list_free(MATCH_LIST *list) { /* XXX Should decrement map refcounts. */ argv_free(list->patterns); myfree((char *) list->match_func); myfree((char *) list->match_args); myfree((char *) list); }
static enum request open_run_request(struct view *view, enum request request) { struct run_request *req = get_run_request(request); const char **argv = NULL; bool confirmed = FALSE; request = REQ_NONE; if (!req) { report("Unknown run request"); return request; } if (!argv_format(view->env, &argv, req->argv, FALSE, TRUE)) { report("Failed to format arguments"); return REQ_NONE; } if (req->flags.internal) { request = run_prompt_command(view, argv); } else { confirmed = !req->flags.confirm; if (req->flags.confirm) { char cmd[SIZEOF_STR], prompt[SIZEOF_STR]; const char *and_exit = req->flags.exit ? " and exit" : ""; if (argv_to_string(argv, cmd, sizeof(cmd), " ") && string_format(prompt, "Run `%s`%s?", cmd, and_exit) && prompt_yesno(prompt)) { confirmed = TRUE; } } if (confirmed && argv_remove_quotes(argv)) open_external_viewer(argv, NULL, req->flags.silent, !req->flags.exit, FALSE, ""); } if (argv) argv_free(argv); free(argv); if (request == REQ_NONE) { if (req->flags.confirm && !confirmed) request = REQ_NONE; else if (req->flags.exit) request = REQ_QUIT; else if (!req->flags.internal && watch_dirty(&view->watch)) request = REQ_REFRESH; } return request; }
// Pre-parse an iptables command line string. // Ripped from iptables-restore.c with a few modifications. static int argv_parse(const char *table, char *buffer) { char *c; int quote = 0; char *parse_start = buffer; char *param_start = buffer; argv_free(); argv_add(iptables_globals.program_name); argv_add("-t"); argv_add(table); for(c = parse_start; *c; c++) { if(*c == '"') { // Quote cannot be true if there was no previous character. // Thus, c - 1 has to be within bounds. if(quote && *(c - 1) != '\\') { quote = 0; *c = ' '; } else { quote = 1; param_start++; } } if(*c == ' ' || !*(c + 1)) { char param_buffer[1024]; int param_len = c - param_start; if(quote) continue; if(!*(c + 1)) param_len++; if(!param_len) { // two spaces? param_start++; continue; } // end of one parameter strncpy(param_buffer, param_start, param_len); *(param_buffer + param_len) = '\0'; argv_add(param_buffer); param_start += param_len + 1; } } return 0; }
const char *milter_unknown_event(MILTERS *milters, const char *command) { const char *resp; MILTER *m; ARGV *global_macros = 0; ARGV *any_macros; if (msg_verbose) msg_info("report unknown command to all milters"); for (resp = 0, m = milters->milter_list; resp == 0 && m != 0; m = m->next) { any_macros = MILTER_MACRO_EVAL(global_macros, m, milters, unk_macros); resp = m->unknown_event(m, command, any_macros); if (any_macros != global_macros) argv_free(any_macros); } if (global_macros) argv_free(global_macros); return (resp); }
const char *milter_data_event(MILTERS *milters) { const char *resp; MILTER *m; ARGV *global_macros = 0; ARGV *any_macros; if (msg_verbose) msg_info("report data to all milters"); for (resp = 0, m = milters->milter_list; resp == 0 && m != 0; m = m->next) { any_macros = MILTER_MACRO_EVAL(global_macros, m, milters, data_macros); resp = m->data_event(m, any_macros); if (any_macros != global_macros) argv_free(any_macros); } if (global_macros) argv_free(global_macros); return (resp); }