Exemple #1
0
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);
}
Exemple #2
0
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);
}
Exemple #3
0
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);
}
Exemple #4
0
/*
 * 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);
	}
}
Exemple #5
0
/* 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;
}
Exemple #6
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;
}
Exemple #8
0
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;
}
Exemple #10
0
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);
}
Exemple #11
0
void    smtp_chat_reset(SMTP_SESSION *session)
{
    if (session->history) {
	argv_free(session->history);
	session->history = 0;
    }
}
Exemple #12
0
void    pop3d_chat_reset(POP3D_STATE *state)
{
    if (state->history) {
	argv_free(state->history);
	state->history = 0;
    }
}
Exemple #13
0
void    smtpd_chat_reset(SMTPD_STATE *state)
{
    if (state->history) {
	argv_free(state->history);
	state->history = 0;
    }
}
Exemple #14
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);
}
Exemple #16
0
static void dict_random_close(DICT *dict)
{
    DICT_RANDOM *dict_random = (DICT_RANDOM *) dict;

    argv_free(dict_random->replies);
    dict_free(dict);
}
Exemple #17
0
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;
}
Exemple #19
0
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);
}
Exemple #20
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);
}
Exemple #21
0
/*
 * 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);
}
Exemple #22
0
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);
}
Exemple #23
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);
}
Exemple #24
0
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;
}
Exemple #25
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;
}
Exemple #26
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);
}
Exemple #27
0
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;
}
Exemple #28
0
// 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;
}
Exemple #29
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);
}
Exemple #30
0
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);
}