triggerconfig_t * add_trigger(rulepackage_t * rpkg, zmsg_t * request,zmsg_t * reply) {
char * rule_id = zmsg_popstr(request);
zclock_log("new trigger!");
if (remove_rule(rpkg->context, rpkg->triggers, rule_id)) {
// already have a rule with that id!
zclock_log("Received duplicate rule %s - killing old trigger", rule_id);
}
triggerconfig_t * tconf = malloc(sizeof(triggerconfig_t));
tconf->base_config = rpkg->base_config;
create_triggerconfig(tconf, request, rpkg->channel, rule_id);
// when we create this trigger, what guarantee do we have that
// the line listener is active? FIX
// basically we have none. crap.
char * created = create_trigger(rpkg->triggers, rule_id, rpkg->context, tconf);
if(NULL == created) {
// happy path, so add to db
zmsg_pushstr(reply, "ok");
} else {
zclock_log("create_trigger failed: %s", created);
free(tconf);
tconf=NULL;
zmsg_pushstr(reply, created);
}
free(created);
return tconf;
}
widget_move::widget_move(QWidget *parent)
: widget_src_dst(parent),
__creator(0)
{
connect(__add_action, SIGNAL(triggered()), this, SLOT(create_rule()));
connect(__edit_action, SIGNAL(triggered()), this, SLOT(edit_rule()));
connect(__remove_action, SIGNAL(triggered()), this, SLOT(remove_rule()));
}
void
free_rules(struct cork_dllist *rules)
{
struct cork_dllist_item *iter;
while ((iter = cork_dllist_head(rules)) != NULL) {
rule_t *rule = cork_container_of(iter, rule_t, entries);
remove_rule(rule);
}
}
bool IF::get_remove_rule(){
if(!selected_rule&&!selected_condition)return true;
if(selected_rule){
if(!selected_rule->get_remove_rule()){
return false;
}
if(!remove_rule()){
return false;
}
/*
for(unsigned i=0;i<true_rules.size();i++){
if(true_rules.at(i)==selected_rule){
delete selected_rule;
selected_rule=0;
true_rules.at(i)=true_rules.back();
true_rules.pop_back();
return false;
}
}
for(unsigned i=0;i<false_rules.size();i++){
if(false_rules.at(i)==selected_rule){
delete selected_rule;
selected_rule=0;
false_rules.at(i)=false_rules.back();
false_rules.pop_back();
return false;
}
}
*/
}
if(selected_condition){
if(!remove_condition()){
return false;
}
}
return false;
}
static void
handle_request(void *ctx) {
conn_t *conn = ctx;
struct evbuffer *rsps = evbuffer_new();
struct state *s = conn->state;
if (strcmp(conn->method, "GET") == 0) {
if (strcmp(conn->url, "/getproxies") == 0)
get_proxies(rsps);
else if (strcmp(conn->url, "/getlists") == 0)
get_lists(rsps);
else if (strncmp(conn->url, "/query?", 7) == 0)
query(rsps, evhttp_decode_uri(conn->url + 7));
else if (strcmp(conn->url, "/getlog") == 0)
get_log(rsps);
else if (strcmp(conn->url, "/gettrylist") == 0)
get_trylist(rsps);
else if (strcmp(conn->url, "/getversion") == 0)
evbuffer_add_printf(rsps, VERSION);
}
else if (strcmp(conn->method, "POST") == 0) {
struct evkeyvalq kv;
struct evhttp_uri *uri = evhttp_uri_parse_with_flags(conn->url, 0);
evhttp_parse_query_str(evhttp_uri_get_query(uri), &kv);
char *cont;
if (s->length)
cont = s->body;
const char *path = evhttp_uri_get_path(uri);
if (strcmp(path, "/addrule") == 0 || strcmp(path, "/rmrule") == 0) {
struct evkeyvalq kvc;
evhttp_parse_query_str(cont, &kvc);
char *list = evhttp_decode_uri(evhttp_find_header(&kvc, "list"));
char *rule = evhttp_decode_uri(evhttp_find_header(&kvc, "rule"));
if (get_domain(rule) == NULL)
evbuffer_add_printf(rsps, "Invalid rule.");
else {
if (strcmp(path, "/addrule") == 0)
update_rule(list, rule);
else
remove_rule(list, rule);
evbuffer_add_printf(rsps, "OK");
}
free(list);
free(rule);
free(cont);
}
else if (strcmp(path, "/flush") == 0) {
flush_list();
evbuffer_add_printf(rsps, "OK");
}
else if (strcmp(path, "/rmlog") == 0) {
rm_log(rsps);
}
else if (strcmp(path, "/purgetrylist") == 0) {
purgetrylist(rsps);
}
evhttp_uri_free(uri);
}
ret(conn->be_client, rsps);
evbuffer_free(rsps);
}
void handle_command(zmsg_t * request,
zmsg_t * reply,
rulepackage_t * rpkg,
channeldb_t * db ) {
char * command = zmsg_popstr(request);
zclock_log("%s worker servicing request %s", rpkg->servicename,command);
if (strcmp(command, "AddTrigger") == 0) {
triggerconfig_t * tconf = add_trigger(rpkg, request, reply);
if(tconf) db_store_trigger(db, tconf);
} else if (strcmp(command, "AddAction") == 0) {
zclock_log("actions not implemented yet"); //TODO
} else if (strcmp(command,"RemoveRule") == 0) {
char * rule_id = zmsg_popstr(request);
// we always evaluate both, hence | usage rather than ||
int found = remove_rule(rpkg->context, rpkg->triggers, rule_id) |
remove_rule(rpkg->context, rpkg->actions, rule_id);
if(found) {
// must also delete from local db.
db_delete_action(db, rule_id);
db_delete_trigger(db, rule_id);
zmsg_pushstr(reply, "200");
} else {
// not there!
zclock_log("Received delete trigger request for nonexistent rule %s, ignoring", rule_id);
zmsg_pushstr(reply, "404");
zmsg_pushstr(reply, "rule not found");
}
} else if (strcmp(command, "AddMonitor")==0) {
add_monitor(rpkg, reply);
} else if (strcmp(command, "Service") == 0) {
assert(zmsg_size(request) == 1);
// TODO this is incomplete
// services also have names
char * name = zmsg_popstr(request);
// char * service_pipe;
// we _could_ just throw the request out into the ether, but
// really, we want this to be a reply-request sort of deal.
// otherwise, we have to contend with the same problem we have
// with monitors: that they need to stay active.
// let's set up a hash of pipes, and just have a worker for each
// possible service.
// problems: this _is_ synchronous for the channel involved.
// this means we can't subsume monitors into it. probably ok for
// now.
//service_function * service_func;
// if ((service_func=zhash_lookup(config->services, name))) {
// found it, let's execute
// problem here is that we don't particularly want to wait for
// the next update, even though it's probably within the next
// 60th of a second.
// what are our options?
// 1. listen to line000X, wait, return
// 2. spin off a thread with a reference to the request, let
// it reply on our behalf... i think this probably doesn't
// work, majordomo expects a response before it gives you more
// work.
// 3. cache current value somewhere. this is fast, but pretty
// sketchy in synchronisation terms. it migh tbe ok, given
// that it's explicitly just sampling.
// char * result = service_func();
//zmsg_pushstr(reply, result);
// } else {
zclock_log("bad service %s", name);
zmsg_pushstr(reply, "no such service");
} else {
zclock_log("Can't handle command %s: ignoring", command);
zmsg_pushstr(reply, "bad command");
}
zmsg_destroy(&request);
}
static void parse_request(char* req, int len) {
char *start, *end;
char *interceptor_name = NULL, proto_s[4] = { 0 }, addr_s[16] = { 0 },
port_s[6] = { 0 }, ruleid_s[20] = {0};
uint8_t ipproto = 0, filter_by = 0;
uint32_t ruleid;
__be32 daddr = 0, saddr = 0;
__be16 dport = 0, sport = 0;
filter_specs* sp;
switch (req[0]) {
case 'R':
for (start = end = req + 2; *end != ':' && *end != '\0'; end++)
;
if (start == end) {
printk("Unable to parse interceptor name for proc registry.\n");
return;
}
interceptor_name = kmalloc(end - start + 1, GFP_ATOMIC);
if (!interceptor_name) {
printk(
"%s in %s:%d: kmalloc failed. Unnable to create name for interceptor.\n",
__FILE__, __FUNCTION__, __LINE__);
return;
}
memset(interceptor_name, 0, end - start + 1);
memcpy(interceptor_name, start, end - start);
//protocol
for (start = end = end + 1; *end != ':' && *end != '\0'; end++)
;
if (start != end) {
memcpy(proto_s, start, end - start);
ipproto = simple_strtol(proto_s, NULL, 10);
filter_by |= FILTER_BY_L4_PROTO;
}
//destination address
for (start = end = end + 1; *end != ':' && *end != '\0'; end++)
;
if (start != end) {
memcpy(addr_s, start, end - start);
daddr = simple_strtol(addr_s, NULL, 10);
memset(addr_s, 0, 16);
filter_by |= FILTER_BY_DST_ADDR;
}
//source address
for (start = end = end + 1; *end != ':' && *end != '\0'; end++)
;
if (start != end) {
memcpy(addr_s, start, end - start);
saddr = simple_strtol(addr_s, NULL, 10);
filter_by |= FILTER_BY_SRC_ADDR;
}
//destination port
for (start = end = end + 1; *end != ':' && *end != '\0'; end++)
;
if (start != end) {
memcpy(port_s, start, end - start);
dport = simple_strtol(port_s, NULL, 10);
memset(port_s, 0, 7);
filter_by |= FILTER_BY_DST_PORT;
}
//source port
for (start = end = end + 1; *end != ':' && *end != '\0'; end++)
;
if (start != end) {
memcpy(port_s, start, end - start);
sport = simple_strtol(port_s, NULL, 10);
filter_by |= FILTER_BY_SRC_PORT;
}
sp = create_filter_specs(filter_by, daddr, saddr, dport, sport, ipproto);
if (!create_rule(interceptor_name, sp))
printk("Proc registry could not create rule. Create rule failed.\n");
break;
case 'U':
for (start = end = req + 2; *end != ':' && *end != '\0'; end++)
;
if(start == end){
printk("Proc registry could not get rule id.\n");
break;
}
memcpy(ruleid_s, start, end - start);
ruleid = simple_strtol(ruleid_s, NULL, 10);
remove_rule(ruleid);
break;
default:
printk("Unknown request to proc registry.\n");
}
return;
}
