int output_register(struct output_reg_info *reg_info) { pomlog(POMLOG_DEBUG "Registering output %s", reg_info->name); if (reg_info->api_ver != OUTPUT_API_VER) { pomlog(POMLOG_ERR "Cannot register output as API version differ : expected %u got %u", OUTPUT_API_VER, reg_info->api_ver); return POM_ERR; } pom_mutex_lock(&output_lock); struct output_reg *output = malloc(sizeof(struct output_reg)); if (!output) { pom_mutex_unlock(&output_lock); pom_oom(sizeof(struct output_reg)); return POM_ERR; } memset(output, 0, sizeof(struct output_reg)); output->reg_info = reg_info; if (registry_add_instance_type(output_registry_class, reg_info->name) != POM_OK) { pom_mutex_unlock(&output_lock); free(output); return POM_ERR; } output->next = output_reg_head; if (output->next) output->next->prev = output; output_reg_head = output; pom_mutex_unlock(&output_lock); mod_refcount_inc(reg_info->mod); return POM_OK; }
int input_register(struct input_reg_info *reg_info) { pomlog(POMLOG_DEBUG "Registering input %s", reg_info->name); if (reg_info->api_ver != INPUT_API_VER) { pomlog(POMLOG_ERR "API version of input %s does not match : expected %s got %s", reg_info->name, INPUT_API_VER, reg_info->api_ver); return POM_ERR; } struct input_reg *tmp; for (tmp = input_reg_head; tmp && strcmp(tmp->info->name, reg_info->name); tmp = tmp->next); if (tmp) { pomlog(POMLOG_ERR "Input %s already registered", reg_info->name); return POM_ERR; } struct input_reg *reg = malloc(sizeof(struct input_reg)); if(!reg) { pom_oom(sizeof(struct input_reg)); return POM_ERR; } memset(reg, 0, sizeof(struct input_reg)); reg->info = reg_info; if (registry_add_instance_type(input_registry_class, reg_info->name) != POM_OK) { free(reg); return POM_ERR; } mod_refcount_inc(reg_info->mod); reg->next = input_reg_head; input_reg_head = reg; if (reg->next) reg->next->prev = reg; return POM_OK; }
int decoder_register(char *name, struct decoder_reg_info *reg_info) { pomlog(POMLOG_DEBUG "Registering decoder %s", name); struct decoder_reg *decoder = malloc(sizeof(struct decoder_reg)); if (!decoder) { pom_oom(sizeof(struct decoder_reg)); return POM_ERR; } memset(decoder, 0, sizeof(struct decoder_reg)); decoder->info = reg_info; decoder->name = name; decoder->next = decoder_reg_head; if (decoder->next) decoder->next->prev = decoder; decoder_reg_head = decoder; mod_refcount_inc(reg_info->mod); return POM_OK; }
int ptype_register(struct ptype_reg_info *reg_info, struct mod_reg *mod) { pomlog(POMLOG_DEBUG "Registering ptype %s", reg_info->name); if (reg_info->api_ver != PTYPE_API_VER) { pomlog(POMLOG_ERR "API version of ptype %s does not match : expected %u got %u", reg_info->name, PTYPE_API_VER, reg_info->api_ver); return POM_ERR; } struct ptype_reg *reg = malloc(sizeof(struct ptype_reg)); if (!reg) { pom_oom(sizeof(struct ptype_reg)); return POM_ERR; } memset(reg, 0, sizeof(struct ptype_reg)); struct ptype_reg *tmp; for (tmp = ptype_reg_head; tmp && strcmp(tmp->info->name, reg_info->name); tmp = tmp->next); if (tmp) { pomlog(POMLOG_ERR "Ptype %s already registered", reg_info->name); free(reg); return POM_ERR; } reg->info = reg_info; reg->module = mod; mod_refcount_inc(mod); reg->next = ptype_reg_head; ptype_reg_head = reg; if (reg->next) reg->next->prev = reg; return POM_OK; }
int proto_register(struct proto_reg_info *reg_info) { if (reg_info->api_ver != PROTO_API_VER) { pomlog(POMLOG_ERR "Cannot register proto as API version differ : expected %u got %u", PROTO_API_VER, reg_info->api_ver); return POM_ERR; } // Check if the protocol already exists struct proto *proto; for (proto = proto_head; proto && strcmp(proto->info->name, reg_info->name); proto = proto->next); if (proto) return POM_ERR; // Allocate the protocol proto = malloc(sizeof(struct proto)); if (!proto) { pom_oom(sizeof(struct proto)); return POM_ERR; } memset(proto, 0, sizeof(struct proto)); proto->info = reg_info; proto->id = proto_count; proto_count++; if (reg_info->number_class) { proto->number_class = proto_number_class_get(reg_info->number_class); if (!proto->number_class) goto err_proto; } int res = pthread_rwlock_init(&proto->expectation_lock, NULL); if (res) { pomlog(POMLOG_ERR "Error while initializing the proto_expectation rwlock : %s", pom_strerror(res)); goto err_proto; } res = pthread_rwlock_init(&proto->listeners_lock, NULL); if (res) { pomlog(POMLOG_ERR "Error while initializing the proto_listeners rwlock : %s", pom_strerror(res)); goto err_lock1; } proto->reg_instance = registry_add_instance(proto_registry_class, reg_info->name); if (!proto->reg_instance) { pomlog(POMLOG_ERR "Error while adding the registry instanc for protocol %s", reg_info->name); goto err_lock; } // Allocate the conntrack table if (reg_info->ct_info) { proto->ct = conntrack_table_alloc(reg_info->ct_info->default_table_size, (reg_info->ct_info->rev_pkt_field_id == -1 ? 0 : 1)); if (!proto->ct) { pomlog(POMLOG_ERR "Error while allocating conntrack tables"); goto err_registry; } proto->perf_conn_cur = registry_instance_add_perf(proto->reg_instance, "conn_cur", registry_perf_type_gauge, "Current number of monitored connection", "connections"); proto->perf_conn_tot = registry_instance_add_perf(proto->reg_instance, "conn_tot", registry_perf_type_counter, "Total number of connections", "connections"); proto->perf_conn_hash_col = registry_instance_add_perf(proto->reg_instance, "conn_hash_col", registry_perf_type_counter, "Total number of conntrack hash collisions", "collisions"); if (!proto->perf_conn_cur || !proto->perf_conn_tot || !proto->perf_conn_hash_col) goto err_conntrack; } proto->perf_pkts = registry_instance_add_perf(proto->reg_instance, "pkts", registry_perf_type_counter, "Number of packets processed", "pkts"); proto->perf_bytes = registry_instance_add_perf(proto->reg_instance, "bytes", registry_perf_type_counter, "Number of bytes processed", "bytes"); proto->perf_expt_pending = registry_instance_add_perf(proto->reg_instance, "expectations_pending", registry_perf_type_gauge, "Number of expectations pending", "expectations"); proto->perf_expt_matched = registry_instance_add_perf(proto->reg_instance, "expectations_matched", registry_perf_type_counter, "Number of expectations matched", "expectations"); if (!proto->perf_pkts || !proto->perf_bytes || !proto->perf_expt_pending || !proto->perf_expt_matched) goto err_conntrack; if (reg_info->init) { if (reg_info->init(proto, proto->reg_instance) == POM_ERR) { pomlog(POMLOG_ERR "Error while registering proto %s", reg_info->name); goto err_conntrack; } } mod_refcount_inc(reg_info->mod); proto->next = proto_head; if (proto->next) proto->next->prev = proto; proto_head = proto; pomlog(POMLOG_DEBUG "Proto %s registered", reg_info->name); return POM_OK; err_conntrack: // Remove proto number if any proto_number_unregister(proto); conntrack_table_cleanup(proto->ct); err_registry: registry_remove_instance(proto->reg_instance); err_lock: pthread_rwlock_destroy(&proto->listeners_lock); err_lock1: pthread_rwlock_destroy(&proto->expectation_lock); err_proto: free(proto); return POM_ERR; }