static int analyzer_png_pload_analyze(struct pload *p, struct pload_buffer *pb, void *priv) { if (pb->data_len < ANALYZER_PNG_HEADER_MIN_SIZE) return PLOAD_ANALYSIS_MORE; if (memcmp(pb->data, ANALYZER_PNG_SIGNATURE, strlen(ANALYZER_PNG_SIGNATURE))) { pomlog(POMLOG_DEBUG "PNG signature not found"); return PLOAD_ANALYSIS_FAILED; } // We got a PNG file if (memcmp(pb->data + 12, ANALYZER_PNG_HEADER_NAME, strlen(ANALYZER_PNG_HEADER_NAME))) { pomlog(POMLOG_DEBUG "IHDR not found where it was supposed to be"); return PLOAD_ANALYSIS_FAILED; } // We got the right header uint16_t height, width; width = ntohl(*(unsigned int*)(pb->data + 16)); height = ntohl(*(unsigned int*)(pb->data + 20)); struct data *pload_data = pload_get_data(p); PTYPE_UINT16_SETVAL(pload_data[analyzer_png_pload_width].value, width); data_set(pload_data[analyzer_png_pload_width]); PTYPE_UINT16_SETVAL(pload_data[analyzer_png_pload_height].value, height); data_set(pload_data[analyzer_png_pload_height]); debug_png("Got PNG of %ux%u", width, height); return PLOAD_ANALYSIS_OK; }
static int analyzer_docsis_reg_status_update(struct analyzer_docsis_priv *priv, struct analyzer_docsis_cm *cm, enum docsis_mmt_rng_status new_status, ptime ts, struct proto_process_stack *stack, unsigned int stack_index) { if (cm->ranging_status == new_status) return POM_OK; if (event_has_listener(priv->evt_cm_reg_status)) { struct event *evt = event_alloc(priv->evt_cm_reg_status); if (!evt) { pom_mutex_unlock(&priv->lock); return POM_ERR; } struct data *evt_data = event_get_data(evt); PTYPE_UINT8_SETVAL(evt_data[analyzer_docsis_cm_reg_status_old].value, cm->ranging_status); data_set(evt_data[analyzer_docsis_cm_reg_status_old]); PTYPE_UINT8_SETVAL(evt_data[analyzer_docsis_cm_reg_status_new].value, new_status); data_set(evt_data[analyzer_docsis_cm_reg_status_new]); PTYPE_MAC_SETADDR(evt_data[analyzer_docsis_cm_reg_status_mac].value, cm->mac); data_set(evt_data[analyzer_docsis_cm_reg_status_mac]); PTYPE_UINT8_SETVAL(evt_data[analyzer_docsis_cm_reg_status_timeout].value, T4_TIMEOUT * cm->t4_multiplier); data_set(evt_data[analyzer_docsis_cm_reg_status_timeout]); if (event_process(evt, stack, stack_index, ts) != POM_OK) { pom_mutex_unlock(&priv->lock); return POM_ERR; } } cm->ranging_status = new_status; return POM_OK; }
static int analyzer_gif_pload_process(struct analyzer *analyzer, struct analyzer_pload_buffer *pload) { if (pload->buff_pos < ANALYZER_GIF_HEADER_MIN_SIZE) return POM_OK; unsigned char *buff = pload->buff; if (!memcmp(pload->buff, ANALYZER_GIF_VERSION_87A, strlen(ANALYZER_GIF_VERSION_87A)) || !memcmp(pload->buff, ANALYZER_GIF_VERSION_89A, strlen(ANALYZER_GIF_VERSION_89A))) { // We got a GIF file uint16_t height, width; width = (buff[7] << 8) + buff[8]; height = (buff[9] << 8) + buff[10]; pload->state = analyzer_pload_buffer_state_analyzed; PTYPE_UINT16_SETVAL(pload->data[analyzer_gif_pload_width].value, width); data_set(pload->data[analyzer_gif_pload_width]); PTYPE_UINT16_SETVAL(pload->data[analyzer_gif_pload_height].value, height); data_set(pload->data[analyzer_gif_pload_height]); debug_gif("Got GIF image of %ux%u", width, height); } else { pomlog(POMLOG_DEBUG "GIF signature not found"); pload->type = NULL; } return POM_OK; }
void test_data() { struct Data* d = data_generate(10); data_set(0, 1, d); data_set(2, 1, d); data_set(4, 1, d); data_set(9,1,d); data_show(d); data_delete(4,d); data_show(d); data_set(3,1,d); data_show(d); data_free(d); }
void data_add(uint8_t data, struct Data* d) { uint16_t a = (BASE_L * (d->data_number +1 ) - 1) / 8 + 1; uint16_t b = (BASE_L * d->data_number - 1) / 8 + 1; if( a > b ) { d->data_array = realloc(d->data_array, a); d->data_number += 1; data_set(d->data_number-1, data, d); } else { d->data_number += 1; data_set(d->data_number-1, data, d); } }
void servo_update(void){ if(data_get(SERVO_DONE)){ int angle = T3_VALUE * 0.06 + (data_get(SERVO_ANGLE) * T3_VALUE *(0.24-0.06) / 90 ); SetPulseOC1(0, angle); data_set(SERVO_DONE, 0); } }
int run_vanilla_nolemma(unsigned epochs, float alpha){ //Data set (Ratnaparkhi's 94 RRR data set) vector<string> ydict; vector<string> xdict; PPADataEncoder data_set("PPAttachData/training"); data_set.add_data("PPAttachData/devset"); data_set.add_data("PPAttachData/test"); data_set.getYdictionary(ydict); data_set.getXdictionary(xdict); //External Word vectors Word2vec w2v; vector<string> wvdict; af::array w2v_embeddings; w2v.load_dictionary("PPAttachData/embeddings/deps.words"); w2v.filter(xdict); //training set data_set.clear(); data_set.add_data("PPAttachData/training"); data_set.getXdictionary(xdict); //build network cerr << "building network"<<endl; SymbolicFeedForwardNetwork<string,string> net; net.set_output_layer("loss",new SoftMaxLoss<string>(ydict)); net.add_layer("top",new LinearLayer()); net.add_layer("hidden",new ReLUActivation(400)); net.add_layer("A",new LinearLayer()); net.add_input_layer("lookupA",new LinearLookup<string>(w2v.get_keys(),w2v.get_values(),data_set.x_vocab_size(),true)); net.connect_layers("loss","top"); net.connect_layers("top","hidden"); net.connect_layers("hidden","A"); net.connect_layers("A","lookupA"); vector<string> ydata; vector<vector<string>> xdata(1,vector<string>()); data_set.getYdata(ydata); data_set.getXdata(xdata[0]); net.set_batch_data(ydata,xdata); net.train_all(ydata,xdata,epochs,100,alpha,true,epochs/2);//10 epochs, batch size= 100,alpha=0.01, Adagrad=On, start averaging at 50th epoch PPADataEncoder dev_set("PPAttachData/devset"); dev_set.getYdata(ydata); dev_set.getXdata(xdata[0]); float dev_acc = net.eval_avg(ydata,xdata); cout << "dev acc = " << dev_acc << endl; PPADataEncoder test_set("PPAttachData/test"); test_set.getYdata(ydata); test_set.getXdata(xdata[0]); float test_acc = net.eval_avg(ydata,xdata); cout << "test acc = " << test_acc << endl; return 0; }
data_t * _any_setattr(data_t *self, char _unused_ *func_name, arguments_t *args) { data_t *attrname = arguments_get_arg(args, 0); data_t *value = arguments_get_arg(args, 1); name_t *name = name_create(1, data_tostring(attrname)); data_t *ret; ret = data_set(self, name, value); name_free(name); return ret; }
std::vector< std::vector<double> > lines_to_data_points(const std::vector<std::string>& line, char separator){ // convert vector of lines to vector of data points, which are // vector<double>. // There is simple support for separators, which // works by replacing the separator with ' '. if(line.size() == 0) return std::vector< std::vector<double> >(); size_t data_point_size = 0; double tmp; std::string l = line[0]; std::replace(l.begin(), l.end(), separator, ' '); std::stringstream ss(l); while(ss >> tmp) ++data_point_size; if(ss.fail() && !ss.eof()) throw(std::runtime_error("Could not convert data points from strings")); if(data_point_size == 0) throw(std::runtime_error("Size of first data point is apparently 0")); std::vector< std::vector<double> > data_set(line.size(), std::vector<double>(data_point_size)); for(size_t i = 0; i != line.size(); ++i){ std::stringstream ss; if(separator == ' '){ ss.str(line[i]); }else{ std::string l = line[i]; std::replace(l.begin(), l.end(), separator, ' '); ss.str(l); } for(size_t j = 0; j != data_point_size; ++j){ if(!(ss >> data_set[i][j])) throw(std::runtime_error(std::string("Could not read data point on line ") + x_to_string(i + 1))); } if(!ss.eof()) throw(std::runtime_error(std::string("Data point on line ") + x_to_string(i + 1) + std::string(" is too long:\n") + ss.str() + std::string("\nexpected: ") + x_to_string(data_point_size) + std::string("\n"))); } return data_set; }
static ssize_t data_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t size) { struct gpio_sw_classdev *gpio_sw_cdev = dev_get_drvdata(dev); ssize_t ret = -EINVAL; char *after; int data = simple_strtoul(buf, &after, 10); size_t count = after - buf; if (isspace(*after)) count++; if (count == size) { ret = count; data_set(gpio_sw_cdev, data); } return ret; }
void msg_processing(uint8_t * mess) { int data; // Fonction: // 0x01 pour READ // 0x10 pour WRITE switch(mess[FUNC]) { case READ: data = data_get(mess[ADDR]); PutCharInFifo ( &descrFifoTX, START_BYTE); PutCharInFifo ( &descrFifoTX, mess[FUNC]); PutCharInFifo ( &descrFifoTX, mess[ADDR]); PutCharInFifo ( &descrFifoTX, data); break; case WRITE: data_set(mess[ADDR], mess[VALUE]); break; default: break; } }
static int analyzer_smtp_event_fill_common_data(struct analyzer_smtp_ce_priv *cpriv, struct data *data) { if (cpriv->client_hello) { PTYPE_STRING_SETVAL(data[analyzer_smtp_common_client_hello].value, cpriv->client_hello); data_set(data[analyzer_smtp_common_client_hello]); } if (cpriv->server_hello) { PTYPE_STRING_SETVAL(data[analyzer_smtp_common_server_hello].value, cpriv->server_hello); data_set(data[analyzer_smtp_common_server_hello]); } if (cpriv->client_addr) { data[analyzer_smtp_common_client_addr].value = ptype_alloc_from(cpriv->client_addr); data[analyzer_smtp_common_client_addr].flags &= ~DATA_FLAG_NO_CLEAN; if (data[analyzer_smtp_common_client_addr].value) data_set(data[analyzer_smtp_common_client_addr]); } if (cpriv->server_addr) { data[analyzer_smtp_common_server_addr].value = ptype_alloc_from(cpriv->server_addr); data[analyzer_smtp_common_server_addr].flags &= ~DATA_FLAG_NO_CLEAN; if (data[analyzer_smtp_common_server_addr].value) data_set(data[analyzer_smtp_common_server_addr]); } if (cpriv->server_port) { PTYPE_UINT16_SETVAL(data[analyzer_smtp_common_server_port].value, cpriv->server_port); data_set(data[analyzer_smtp_common_server_port]); } if (cpriv->server_host) { PTYPE_STRING_SETVAL(data[analyzer_smtp_common_server_host].value, cpriv->server_host); data_set(data[analyzer_smtp_common_server_host]); } return POM_OK; }
static int proto_smtp_process(void *proto_priv, struct packet *p, struct proto_process_stack *stack, unsigned int stack_index) { struct proto_process_stack *s = &stack[stack_index]; struct proto_process_stack *s_next = &stack[stack_index + 1]; if (conntrack_get_unique_from_parent(stack, stack_index) != POM_OK) { pomlog(POMLOG_ERR "Could not get conntrack entry"); return PROTO_ERR; } // There should no need to keep the lock here since we are in the packet_stream lock from proto_tcp conntrack_unlock(s->ce); struct proto_smtp_priv *ppriv = proto_priv; struct proto_smtp_conntrack_priv *priv = s->ce->priv; if (!priv) { priv = malloc(sizeof(struct proto_smtp_conntrack_priv)); if (!priv) { pom_oom(sizeof(struct proto_smtp_conntrack_priv)); return PROTO_ERR; } memset(priv, 0, sizeof(struct proto_smtp_conntrack_priv)); priv->parser[POM_DIR_FWD] = packet_stream_parser_alloc(SMTP_MAX_LINE, PACKET_STREAM_PARSER_FLAG_TRIM); if (!priv->parser[POM_DIR_FWD]) { free(priv); return PROTO_ERR; } priv->parser[POM_DIR_REV] = packet_stream_parser_alloc(SMTP_MAX_LINE, PACKET_STREAM_PARSER_FLAG_TRIM); if (!priv->parser[POM_DIR_REV]) { packet_stream_parser_cleanup(priv->parser[POM_DIR_FWD]); free(priv); return PROTO_ERR; } priv->server_direction = POM_DIR_UNK; s->ce->priv = priv; } if (priv->flags & PROTO_SMTP_FLAG_INVALID) return PROTO_OK; struct packet_stream_parser *parser = priv->parser[s->direction]; if (packet_stream_parser_add_payload(parser, s->pload, s->plen) != POM_OK) return PROTO_ERR; char *line = NULL; size_t len = 0; while (1) { // Some check to do prior to parse the payload if (s->direction == POM_DIR_REVERSE(priv->server_direction)) { if (priv->flags & PROTO_SMTP_FLAG_STARTTLS) { // Last command was a STARTTLS command, this is the TLS negociation // Since we can't parse this, mark it as invalid priv->flags |= PROTO_SMTP_FLAG_INVALID; return PROTO_OK; } else if (priv->flags & PROTO_SMTP_FLAG_CLIENT_DATA) { // We are receiving payload data, check where the end is void *pload; size_t plen; packet_stream_parser_get_remaining(parser, &pload, &plen); if (!plen) return PROTO_OK; // Look for the "<CR><LF>.<CR><LF>" sequence if (priv->data_end_pos > 0) { // The previous packet ended with something that might be the final sequence // Check if we have the rest int i, found = 1; for (i = 0; i < PROTO_SMTP_DATA_END_LEN - priv->data_end_pos && i <= plen; i++) { if (*(char*)(pload + i) != PROTO_SMTP_DATA_END[priv->data_end_pos + i]) { found = 0; break; } } if (found) { // If we have already processed the dot after <CR><LF> there is no way to remove it // Thus we mark this connection as invalid. Most MTA will send at worst the last // 3 bytes of the end sequence in a sequence packet if (i != plen || (priv->data_end_pos >= 2 && plen < 3)) { pomlog(POMLOG_DEBUG "The final line was not at the of a packet as expected !"); priv->flags |= PROTO_SMTP_FLAG_INVALID; event_process_end(priv->data_evt); priv->data_evt = NULL; return PROTO_OK; } s_next->pload = pload; s_next->plen = plen - PROTO_SMTP_DATA_END_LEN + 2; // The last line return is part of the payload priv->flags |= PROTO_SMTP_FLAG_CLIENT_DATA_END; priv->flags &= ~PROTO_SMTP_FLAG_CLIENT_DATA; priv->data_end_pos = 0; return PROTO_OK; } priv->data_end_pos = 0; } char *dotline = pom_strnstr(pload, PROTO_SMTP_DATA_END, plen); if (dotline) { if (pload + plen - PROTO_SMTP_DATA_END_LEN != dotline) { pomlog(POMLOG_DEBUG "The final line was not at the of a packet as expected !"); priv->flags |= PROTO_SMTP_FLAG_INVALID; event_process_end(priv->data_evt); priv->data_evt = NULL; return PROTO_OK; } s_next->pload = pload; s_next->plen = plen - PROTO_SMTP_DATA_END_LEN + 2; // The last line return is part of the payload priv->flags |= PROTO_SMTP_FLAG_CLIENT_DATA_END; priv->flags &= ~PROTO_SMTP_FLAG_CLIENT_DATA; } else { // Check if the end of the payload contains part of the "<CR><LF>.<CR><LF>" sequence int i, found = 0; for (i = 1 ; (i < PROTO_SMTP_DATA_END_LEN) && (i <= plen); i++) { if (!memcmp(pload + plen - i, PROTO_SMTP_DATA_END, i)) { found = 1; break; } } if (found) priv->data_end_pos = i; s_next->pload = pload; s_next->plen = plen; } return PROTO_OK; } } // Process commands if (packet_stream_parser_get_line(parser, &line, &len) != POM_OK) return PROTO_ERR; if (!line) return PROTO_OK; if (!len) // Probably a missed packet return PROTO_OK; // Try to find the server direction if (priv->server_direction == POM_DIR_UNK) { unsigned int code = atoi(line); if (code > 0) { priv->server_direction = s->direction; } else { priv->server_direction = POM_DIR_REVERSE(s->direction); } } if (s->direction == priv->server_direction) { // Parse the response code and generate the event if ((len < 5) || // Server response is 3 digit error code, a space or hyphen and then at least one letter of text (line[3] != ' ' && line[3] != '-')) { pomlog(POMLOG_DEBUG "Too short or invalid response from server"); priv->flags |= PROTO_SMTP_FLAG_INVALID; return POM_OK; } int code = atoi(line); if (code == 0) { pomlog(POMLOG_DEBUG "Invalid response from server"); priv->flags |= PROTO_SMTP_FLAG_INVALID; return POM_OK; } if (event_has_listener(ppriv->evt_reply)) { struct data *evt_data = NULL; if (priv->reply_evt) { evt_data = event_get_data(priv->reply_evt); uint16_t cur_code = *PTYPE_UINT16_GETVAL(evt_data[proto_smtp_reply_code].value); if (cur_code != code) { pomlog(POMLOG_WARN "Multiline code not the same as previous line : %hu -> %hu", cur_code, code); event_process_end(priv->reply_evt); priv->reply_evt = NULL; } } if (!priv->reply_evt) { priv->reply_evt = event_alloc(ppriv->evt_reply); if (!priv->reply_evt) return PROTO_ERR; evt_data = event_get_data(priv->reply_evt); PTYPE_UINT16_SETVAL(evt_data[proto_smtp_reply_code].value, code); data_set(evt_data[proto_smtp_reply_code]); } if (len > 4) { struct ptype *txt = ptype_alloc("string"); if (!txt) return PROTO_ERR; PTYPE_STRING_SETVAL_N(txt, line + 4, len - 4); if (data_item_add_ptype(evt_data, proto_smtp_reply_text, strdup("text"), txt) != POM_OK) return PROTO_ERR; } if (!event_is_started(priv->reply_evt)) event_process_begin(priv->reply_evt, stack, stack_index, p->ts); } if (line[3] != '-') { // Last line in the response if (priv->reply_evt) { event_process_end(priv->reply_evt); priv->reply_evt = NULL; } } if (priv->flags & PROTO_SMTP_FLAG_STARTTLS) { // The last command was STARTTLS priv->flags &= ~PROTO_SMTP_FLAG_STARTTLS; if (code == 220) { // TLS has the go, we can't parse from now so mark as invalid priv->flags |= PROTO_SMTP_FLAG_INVALID; return POM_OK; } } } else { // Client command if (len < 4) { // Client commands are at least 4 bytes long pomlog(POMLOG_DEBUG "Too short or invalid query from client"); priv->flags |= PROTO_SMTP_FLAG_INVALID; return POM_OK; } // Make sure it's a command by checking it's at least a four letter word int i; for (i = 0; i < 4; i++) { // In some case it can also be a base64 encoded word if (! ((line[i] >= 'A' && line[i] <= 'Z') || (line[i] >= 'a' && line[i] <= 'z') || (line[i] >= '0' && line [i] <= '9') || line[i] == '=')) break; } if ((i < 4)) { pomlog(POMLOG_DEBUG "Recieved invalid client command"); priv->flags |= PROTO_SMTP_FLAG_INVALID; return POM_OK; } if (!strncasecmp(line, "DATA", strlen("DATA")) && len == strlen("DATA")) { priv->flags |= PROTO_SMTP_FLAG_CLIENT_DATA; } else if (!strncasecmp(line, "STARTTLS", strlen("STARTTLS")) && len == strlen("STARTTLS")) { priv->flags |= PROTO_SMTP_FLAG_STARTTLS; } if (event_has_listener(ppriv->evt_cmd)) { struct event *evt = event_alloc(ppriv->evt_cmd); if (!evt) return PROTO_ERR; size_t cmdlen = len; char *space = memchr(line, ' ', len); if (space) cmdlen = space - line; struct data *evt_data = event_get_data(evt); PTYPE_STRING_SETVAL_N(evt_data[proto_smtp_cmd_name].value, line, cmdlen); data_set(evt_data[proto_smtp_cmd_name]); if (space) { PTYPE_STRING_SETVAL_N(evt_data[proto_smtp_cmd_arg].value, space + 1, len - 1 - cmdlen); data_set(evt_data[proto_smtp_cmd_arg]); } if (priv->flags & PROTO_SMTP_FLAG_CLIENT_DATA) { // The event ends at the end of the message priv->data_evt = evt; return event_process_begin(evt, stack, stack_index, p->ts); } else { return event_process(evt, stack, stack_index, p->ts); } } } } return PROTO_OK; }
Matrix<double> InputsSelectionAlgorithm::calculate_logistic_correlations(void) const { // Control sentence (if debug) #ifdef __OPENNN_DEBUG__ std::ostringstream buffer; if(!training_strategy_pointer) { buffer << "OpenNN Exception: InputsSelectionAlgorithm class.\n" << "void check(void) const method.\n" << "Pointer to training strategy is NULL.\n"; throw std::logic_error(buffer.str()); } // Performance functional stuff if(!training_strategy_pointer->has_performance_functional()) { buffer << "OpenNN Exception: InputsSelectionAlgorithm class.\n" << "void check(void) const method.\n" << "Pointer to performance functional is NULL.\n"; throw std::logic_error(buffer.str()); } if(!training_strategy_pointer->get_performance_functional_pointer()->has_data_set()) { buffer << "OpenNN Exception: InputsSelectionAlgorithm class.\n" << "void check(void) const method.\n" << "Pointer to data set is NULL.\n"; throw std::logic_error(buffer.str()); } #endif // Problem stuff const PerformanceFunctional* performance_functional_pointer = training_strategy_pointer->get_performance_functional_pointer(); const DataSet* data_set_pointer = performance_functional_pointer->get_data_set_pointer(); const Variables& variables = data_set_pointer->get_variables(); const size_t inputs_number = variables.count_inputs_number(); const size_t targets_number = variables.count_targets_number(); const Vector<size_t> input_indices = variables.arrange_inputs_indices(); const Vector<size_t> target_indices = variables.arrange_targets_indices(); Matrix<double> correlations(inputs_number, targets_number); for(size_t i = 0; i < inputs_number; i++) { const Vector<double> inputs = data_set_pointer->get_variable(input_indices[i]); for(size_t j = 0; j < targets_number; j++) { const Vector<double> targets = data_set_pointer->get_variable(target_indices[j]); Matrix<double> data(inputs.size(), 2); data.set_column(0, inputs); data.set_column(1, targets); DataSet data_set(data); data_set.scale_inputs("MinimumMaximum"); Instances* instances_pointer = data_set.get_instances_pointer(); instances_pointer->set_training(); NeuralNetwork neural_network(1, 1); MultilayerPerceptron* multilayer_perceptron_pointer = neural_network.get_multilayer_perceptron_pointer(); multilayer_perceptron_pointer->set_layer_activation_function(0, Perceptron::Logistic); PerformanceFunctional performance_functional(&neural_network, &data_set); performance_functional.set_objective_type(PerformanceFunctional::MEAN_SQUARED_ERROR_OBJECTIVE); TrainingStrategy training_strategy(&performance_functional); training_strategy.set_main_type(TrainingStrategy::LEVENBERG_MARQUARDT_ALGORITHM); training_strategy.get_Levenberg_Marquardt_algorithm_pointer()->set_display(false); training_strategy.get_Levenberg_Marquardt_algorithm_pointer()->set_performance_goal(0.0); training_strategy.get_Levenberg_Marquardt_algorithm_pointer()->set_gradient_norm_goal(0.0); training_strategy.get_Levenberg_Marquardt_algorithm_pointer()->set_minimum_performance_increase(0.0); training_strategy.perform_training(); const Vector<double> outputs = neural_network.calculate_output_data(inputs.to_column_matrix()).to_vector(); correlations(i,j) = targets.calculate_linear_correlation(outputs); } } return(correlations); }
static int analyzer_smtp_event_process_begin(struct event *evt, void *obj, struct proto_process_stack *stack, unsigned int stack_index) { struct analyzer *analyzer = obj; struct analyzer_smtp_priv *apriv = analyzer->priv; struct proto_process_stack *s = &stack[stack_index]; if (!s->ce) return POM_ERR; // Only process stuff if we have the DATA event or if we already have an event struct event_reg *evt_reg = event_get_reg(evt); struct data *evt_data = event_get_data(evt); struct analyzer_smtp_ce_priv *cpriv = conntrack_get_priv(s->ce, analyzer); // It's expected that an SMTP connection will always contain at least one message // So we always create the cpriv and event, no matter what if (!cpriv) { cpriv = malloc(sizeof(struct analyzer_smtp_ce_priv)); if (!cpriv) { pom_oom(sizeof(struct analyzer_smtp_ce_priv)); return POM_ERR; } memset(cpriv, 0, sizeof(struct analyzer_smtp_ce_priv)); if (conntrack_add_priv(s->ce, analyzer, cpriv, analyzer_smtp_ce_priv_cleanup) != POM_OK) { free(cpriv); return POM_ERR; } } if (!cpriv->evt_msg) { cpriv->evt_msg = event_alloc(apriv->evt_msg); if (!cpriv->evt_msg) return POM_ERR; } struct data *msg_data = event_get_data(cpriv->evt_msg); if (evt_reg == apriv->evt_cmd) { if (!cpriv->common_data_fetched) analyzer_smtp_event_fetch_common_data(cpriv, stack, stack_index, POM_DIR_REVERSE(s->direction)); // Process commands // A message was being transmitted and we recevied a new command if (event_is_started(cpriv->evt_msg)) { event_process_end(cpriv->evt_msg); cpriv->evt_msg = NULL; } char *cmd = PTYPE_STRING_GETVAL(evt_data[proto_smtp_cmd_name].value); if (!cmd) return POM_OK; char *arg = PTYPE_STRING_GETVAL(evt_data[proto_smtp_cmd_arg].value); if (arg) { while (*arg == ' ') arg++; } if (!strcasecmp(cmd, "MAIL")) { if (strncasecmp(arg, "FROM:", strlen("FROM:"))) { pomlog(POMLOG_DEBUG "Unparseable MAIL command"); return POM_OK; } arg += strlen("FROM:"); while (*arg == ' ') arg++; if (*arg == '<') arg++; size_t len; char *end = strchr(arg, '>'); if (end) len = end - arg; else len = strlen(arg); PTYPE_STRING_SETVAL_N(msg_data[analyzer_smtp_msg_from].value, arg, len); data_set(msg_data[analyzer_smtp_msg_from]); cpriv->last_cmd = analyzer_smtp_last_cmd_mail_from; } else if (!strcasecmp(cmd, "RCPT")) { if (strncasecmp(arg, "TO:", strlen("TO:"))) { pomlog(POMLOG_DEBUG "Unparseable RCPT command"); return POM_OK; } arg += strlen("TO:"); while (*arg == ' ') arg++; if (*arg == '<') arg++; size_t len; char *end = strchr(arg, '>'); if (end) len = end - arg; else len = strlen(arg); struct ptype *to = ptype_alloc("string"); if (!to) return POM_ERR; PTYPE_STRING_SETVAL_N(to, arg, len); if (data_item_add_ptype(msg_data, analyzer_smtp_msg_to, strdup("to"), to) != POM_OK) { ptype_cleanup(to); return POM_ERR; } cpriv->last_cmd = analyzer_smtp_last_cmd_rcpt_to; } else if (!strcasecmp(cmd, "DATA")) { cpriv->last_cmd = analyzer_smtp_last_cmd_data; if (!event_is_started(cpriv->evt_msg)) { analyzer_smtp_event_fill_common_data(cpriv, msg_data); event_process_begin(cpriv->evt_msg, stack, stack_index, event_get_timestamp(evt)); } else { pomlog(POMLOG_DEBUG "Message event already started !"); } } else if (!strcasecmp(cmd, "RSET")) { // Cleanup the event event_cleanup(cpriv->evt_msg); cpriv->evt_msg = NULL; cpriv->last_cmd = analyzer_smtp_last_cmd_other; } else if (!strcasecmp(cmd, "HELO") || !strcasecmp(cmd, "EHLO")) { if (cpriv->client_hello) { pomlog(POMLOG_DEBUG "We already have a client hello !"); free(cpriv->client_hello); } cpriv->client_hello = strdup(arg); if (!cpriv->client_hello) { pom_oom(strlen(arg) + 1); return POM_ERR; } cpriv->last_cmd = analyzer_smtp_last_cmd_other; } else if (!strcasecmp(cmd, "AUTH")) { if (!strncasecmp(arg, "PLAIN", strlen("PLAIN"))) { arg += strlen("PLAIN"); while (*arg == ' ') arg++; if (cpriv->evt_auth) { event_process_end(cpriv->evt_auth); cpriv->evt_auth = NULL; } if (strlen(arg)) { if (analyzer_smtp_parse_auth_plain(apriv, cpriv, arg) == POM_OK) { event_process_begin(cpriv->evt_auth, stack, stack_index, event_get_timestamp(evt)); cpriv->last_cmd = analyzer_smtp_last_cmd_auth_plain_creds; } } else { cpriv->last_cmd = analyzer_smtp_last_cmd_auth_plain; } } else if (!strncasecmp(arg, "LOGIN", strlen("LOGIN"))) { arg += strlen("LOGIN"); while (*arg == ' ') arg++; if (cpriv->evt_auth) { event_process_end(cpriv->evt_auth); cpriv->evt_auth = NULL; } cpriv->evt_auth = event_alloc(apriv->evt_auth); if (!cpriv->evt_auth) return POM_ERR; struct data *auth_data = event_get_data(cpriv->evt_auth); analyzer_smtp_event_fill_common_data(cpriv, auth_data); // Set the authentication type PTYPE_STRING_SETVAL(auth_data[analyzer_smtp_auth_type].value, "LOGIN"); data_set(auth_data[analyzer_smtp_auth_type]); if (strlen(arg)) { char *username = NULL; size_t out_len = 0; struct ptype *username_pt = NULL; if (decoder_decode_simple("base64", arg, strlen(arg), &username, &out_len) == POM_OK) { username_pt = ptype_alloc("string"); if (username_pt) { PTYPE_STRING_SETVAL_P(username_pt, username); if (data_item_add_ptype(auth_data, analyzer_smtp_auth_params, strdup("username"), username_pt) != POM_OK) { ptype_cleanup(username_pt); event_cleanup(cpriv->evt_auth); cpriv->evt_auth = NULL; username_pt = NULL; } } else { free(username); } } if (!username_pt) { cpriv->last_cmd = analyzer_smtp_last_cmd_other; event_process_begin(cpriv->evt_auth, stack, stack_index, event_get_timestamp(evt)); } } else { cpriv->last_cmd = analyzer_smtp_last_cmd_auth_login; } } } else if (cpriv->last_cmd == analyzer_smtp_last_cmd_auth_plain) { // We are expecting the credentials right now if (analyzer_smtp_parse_auth_plain(apriv, cpriv, cmd) == POM_OK) { event_process_begin(cpriv->evt_auth, stack, stack_index, event_get_timestamp(evt)); cpriv->last_cmd = analyzer_smtp_last_cmd_auth_plain_creds; } else { cpriv->last_cmd = analyzer_smtp_last_cmd_other; } } else if (cpriv->last_cmd == analyzer_smtp_last_cmd_auth_login) { char *username = NULL; size_t out_len = 0; struct ptype *username_pt = NULL; if (decoder_decode_simple("base64", cmd, strlen(cmd), &username, &out_len) == POM_OK) { username_pt = ptype_alloc("string"); if (username_pt) { PTYPE_STRING_SETVAL_P(username_pt, username); struct data *auth_data = event_get_data(cpriv->evt_auth); if (data_item_add_ptype(auth_data, analyzer_smtp_auth_params, strdup("username"), username_pt) != POM_OK) { ptype_cleanup(username_pt); event_process_end(cpriv->evt_auth); cpriv->evt_auth = NULL; username_pt = NULL; } } else { free(username); } } if (!username_pt) { cpriv->last_cmd = analyzer_smtp_last_cmd_other; } else { event_process_begin(cpriv->evt_auth, stack, stack_index, event_get_timestamp(evt)); cpriv->last_cmd = analyzer_smtp_last_cmd_auth_login_user; } } else if (cpriv->last_cmd == analyzer_smtp_last_cmd_auth_login_user) { char *password = NULL; size_t out_len = 0; struct ptype *password_pt = NULL; if (decoder_decode_simple("base64", cmd, strlen(cmd), &password, &out_len) == POM_OK) { password_pt = ptype_alloc("string"); if (password_pt) { PTYPE_STRING_SETVAL_P(password_pt, password); struct data *auth_data = event_get_data(cpriv->evt_auth); if (data_item_add_ptype(auth_data, analyzer_smtp_auth_params, strdup("password"), password_pt) != POM_OK) { ptype_cleanup(password_pt); event_process_end(cpriv->evt_auth); cpriv->evt_auth = NULL; password_pt = NULL; } } else { free(password); } } if (!password_pt) { cpriv->last_cmd = analyzer_smtp_last_cmd_other; } else { cpriv->last_cmd = analyzer_smtp_last_cmd_auth_login_pass; } } else { cpriv->last_cmd = analyzer_smtp_last_cmd_other; } } else if (evt_reg == apriv->evt_reply) { if (!cpriv->common_data_fetched) analyzer_smtp_event_fetch_common_data(cpriv, stack, stack_index, s->direction); // Process replies uint16_t code = *PTYPE_UINT16_GETVAL(evt_data[proto_smtp_reply_code].value); switch (cpriv->last_cmd) { default: case analyzer_smtp_last_cmd_other: if (code == 220 && evt_data[proto_smtp_reply_text].items && evt_data[proto_smtp_reply_text].items->value) { // STARTTLS returns 220 as well so ignore extra code 220 if (!cpriv->server_hello) { char *helo = PTYPE_STRING_GETVAL(evt_data[proto_smtp_reply_text].items->value); cpriv->server_hello = strdup(helo); if (!cpriv->server_hello) { pom_oom(strlen(helo) + 1); return POM_ERR; } } } break; case analyzer_smtp_last_cmd_mail_from: if (code != 250) { // FROM is invalid data_unset(msg_data[analyzer_smtp_msg_from]); } break; case analyzer_smtp_last_cmd_rcpt_to: // For now just don't do anything // It's best to keep a destination in there even if it's invalid or denied break; case analyzer_smtp_last_cmd_data: if (code == 354) { // The message is starting, keep last_cmd intact return POM_OK; } // Message is over (if ever transmited) if (event_is_started(cpriv->evt_msg)) { struct data *msg_data = event_get_data(cpriv->evt_msg); PTYPE_UINT16_SETVAL(msg_data[analyzer_smtp_msg_result].value, code); data_set(msg_data[analyzer_smtp_msg_result]); event_process_end(cpriv->evt_msg); cpriv->evt_msg = NULL; } break; case analyzer_smtp_last_cmd_auth_plain: case analyzer_smtp_last_cmd_auth_login: case analyzer_smtp_last_cmd_auth_login_user: // Check if authentication phase can continue if (code == 334) { // Don't reset cpriv->last_cmd return POM_OK; } else { struct data *evt_data = event_get_data(cpriv->evt_auth); PTYPE_BOOL_SETVAL(evt_data[analyzer_smtp_auth_success].value, 0); data_set(evt_data[analyzer_smtp_auth_success]); event_process_end(cpriv->evt_auth); cpriv->evt_auth = NULL; } break; case analyzer_smtp_last_cmd_auth_plain_creds: case analyzer_smtp_last_cmd_auth_login_pass: { // We just processed the credentials struct data *auth_data = event_get_data(cpriv->evt_auth); char success = 0; if (code == 235) success = 1; PTYPE_BOOL_SETVAL(auth_data[analyzer_smtp_auth_success].value, success); data_set(auth_data[analyzer_smtp_auth_success]); event_process_end(cpriv->evt_auth); cpriv->evt_auth = NULL; break; } } cpriv->last_cmd = analyzer_smtp_last_cmd_other; } return POM_OK; }
static int analyzer_smtp_parse_auth_plain(struct analyzer_smtp_priv *apriv, struct analyzer_smtp_ce_priv *cpriv, char *auth_plain) { // Parse SASL AUTH PLAIN as described in RFC 4616 // The decoded arg must be at least 3 bytes if (strlen(auth_plain) < 4 || memchr(auth_plain, '=', 4)) { pomlog(POMLOG_DEBUG "AUTH PLAIN argument too short"); return POM_OK; } // Allocate the event cpriv->evt_auth = event_alloc(apriv->evt_auth); if (!cpriv->evt_auth) return POM_ERR; struct data *evt_data = event_get_data(cpriv->evt_auth); analyzer_smtp_event_fill_common_data(cpriv, evt_data); // Set the authentication type PTYPE_STRING_SETVAL(evt_data[analyzer_smtp_auth_type].value, "PLAIN"); data_set(evt_data[analyzer_smtp_auth_type]); // Parse the authentication stuff char *creds_str = NULL; size_t out_len = 0; if (decoder_decode_simple("base64", auth_plain, strlen(auth_plain), &creds_str, &out_len) != POM_OK) { pomlog(POMLOG_DEBUG "Unable to decode AUTH PLAIN message"); return POM_OK; } if (out_len < 3) { pomlog(POMLOG_DEBUG "Invalid decoded AUTH PLAIN data"); return POM_OK; } char *tmp = creds_str; // Add the identity if (strlen(tmp)) { // SASL AUTH PLAIN specifies struct ptype *identity = ptype_alloc("string"); if (!identity) goto err; PTYPE_STRING_SETVAL(identity, tmp); if (data_item_add_ptype(evt_data, analyzer_smtp_auth_params, strdup("identity"), identity) != POM_OK) { ptype_cleanup(identity); goto err; } } tmp += strlen(tmp) + 1; // Add the username struct ptype *username = ptype_alloc("string"); if (!username) goto err; PTYPE_STRING_SETVAL(username, tmp); if (data_item_add_ptype(evt_data, analyzer_smtp_auth_params, strdup("username"), username) != POM_OK) { ptype_cleanup(username); goto err; } tmp += strlen(tmp) + 1; // Add the password struct ptype *password = ptype_alloc("string"); if (!password) goto err; PTYPE_STRING_SETVAL(password, tmp); if (data_item_add_ptype(evt_data, analyzer_smtp_auth_params, strdup("password"), password) != POM_OK) { ptype_cleanup(password); goto err; } free(creds_str); return POM_OK; err: event_cleanup(cpriv->evt_auth); cpriv->evt_auth = NULL; free(creds_str); return POM_ERR; }
int analyzer_ppp_pap_finalize(struct analyzer_ppp_pap_priv *apriv, struct analyzer_ppp_pap_ce_priv *cpriv) { if (!cpriv->evt_request) return POM_OK; struct event *evt = NULL; struct data *evt_data = NULL; struct data *evt_req_data = event_get_data(cpriv->evt_request); evt = event_alloc(apriv->evt_auth); if (!evt) return POM_ERR; evt_data = event_get_data(evt); if (ptype_copy(evt_data[analyzer_ppp_pap_auth_peer_id].value, evt_req_data[evt_ppp_pap_request_peer_id].value) != POM_OK) { event_cleanup(evt); return POM_ERR; } data_set(evt_data[analyzer_ppp_pap_auth_peer_id]); if (ptype_copy(evt_data[analyzer_ppp_pap_auth_password].value, evt_req_data[evt_ppp_pap_request_password].value) != POM_OK) { event_cleanup(evt); return POM_ERR; } data_set(evt_data[analyzer_ppp_pap_auth_password]); if (cpriv->client) { evt_data[analyzer_ppp_pap_auth_client].value = cpriv->client; data_set(evt_data[analyzer_ppp_pap_auth_client]); data_do_clean(evt_data[analyzer_ppp_pap_auth_client]); cpriv->client = NULL; } if (cpriv->server) { evt_data[analyzer_ppp_pap_auth_server].value = cpriv->server; data_set(evt_data[analyzer_ppp_pap_auth_server]); data_do_clean(evt_data[analyzer_ppp_pap_auth_server]); cpriv->server = NULL; } if (cpriv->vlan) { evt_data[analyzer_ppp_pap_auth_vlan].value = cpriv->vlan; data_set(evt_data[analyzer_ppp_pap_auth_vlan]); data_do_clean(evt_data[analyzer_ppp_pap_auth_vlan]); cpriv->vlan = NULL; } if (cpriv->top_proto) { PTYPE_STRING_SETVAL(evt_data[analyzer_ppp_pap_auth_top_proto].value, cpriv->top_proto); data_set(evt_data[analyzer_ppp_pap_auth_top_proto]); } if (ptype_copy(evt_data[analyzer_ppp_pap_auth_identifier].value, evt_req_data[evt_ppp_pap_request_identifier].value) != POM_OK) { event_cleanup(evt); return POM_ERR; } data_set(evt_data[analyzer_ppp_pap_auth_identifier]); if (cpriv->evt_ack_nack) { struct data *evt_ack_data = event_get_data(cpriv->evt_ack_nack); uint8_t code = *PTYPE_UINT8_GETVAL(evt_ack_data[evt_ppp_pap_ack_nack_code].value); if (code == 2) { PTYPE_BOOL_SETVAL(evt_data[analyzer_ppp_pap_auth_success].value, 1); } else { PTYPE_BOOL_SETVAL(evt_data[analyzer_ppp_pap_auth_success].value, 0); } data_set(evt_data[analyzer_ppp_pap_auth_success]); event_refcount_dec(cpriv->evt_ack_nack); cpriv->evt_ack_nack = NULL; } ptime ts = event_get_timestamp(cpriv->evt_request); event_refcount_dec(cpriv->evt_request); cpriv->evt_request = NULL; return event_process(evt, NULL, 0, ts); }
int analyzer_eap_finalize(struct analyzer_eap_priv *apriv, struct analyzer_eap_ce_priv *cpriv) { if (!cpriv->evt_request || !cpriv->evt_response) return POM_OK; struct event *evt = NULL; struct data *evt_data = NULL; struct data *evt_req_data = event_get_data(cpriv->evt_request); struct data *evt_rsp_data = event_get_data(cpriv->evt_response); if (!data_is_set(evt_rsp_data[evt_eap_md5_challenge_value])) return POM_OK; if (!data_is_set(evt_req_data[evt_eap_md5_challenge_value])) return POM_OK; evt = event_alloc(apriv->evt_md5_auth); if (!evt) return POM_ERR; evt_data = event_get_data(evt); if (ptype_copy(evt_data[analyzer_eap_md5_challenge].value, evt_req_data[evt_eap_md5_challenge_value].value) != POM_OK) return POM_ERR; data_set(evt_data[analyzer_eap_md5_challenge]); if (ptype_copy(evt_data[analyzer_eap_md5_response].value, evt_rsp_data[evt_eap_md5_challenge_value].value) != POM_OK) return POM_ERR; data_set(evt_data[analyzer_eap_md5_response]); if (cpriv->client) { evt_data[analyzer_eap_common_client].value = cpriv->client; data_set(evt_data[analyzer_eap_common_client]); data_do_clean(evt_data[analyzer_eap_common_client]); cpriv->client = NULL; } if (cpriv->server) { evt_data[analyzer_eap_common_server].value = cpriv->server; data_set(evt_data[analyzer_eap_common_server]); data_do_clean(evt_data[analyzer_eap_common_server]); cpriv->server = NULL; } if (cpriv->vlan) { evt_data[analyzer_eap_common_vlan].value = cpriv->vlan; data_set(evt_data[analyzer_eap_common_vlan]); data_do_clean(evt_data[analyzer_eap_common_vlan]); cpriv->vlan = NULL; } if (cpriv->top_proto) { PTYPE_STRING_SETVAL(evt_data[analyzer_eap_common_top_proto].value, cpriv->top_proto); data_set(evt_data[analyzer_eap_common_top_proto]); } if (ptype_copy(evt_data[analyzer_eap_common_identifier].value, evt_req_data[evt_eap_common_identifier].value) != POM_OK) return POM_ERR; data_set(evt_data[analyzer_eap_common_identifier]); if (!data_is_set(evt_rsp_data[evt_eap_md5_challenge_name])) return POM_OK; if (ptype_copy(evt_data[analyzer_eap_common_username].value, evt_rsp_data[evt_eap_md5_challenge_name].value) != POM_OK) return POM_ERR; data_set(evt_data[analyzer_eap_common_username]); if (cpriv->evt_result) { struct data *evt_res_data = event_get_data(cpriv->evt_result); ptype_copy(evt_data[analyzer_eap_common_success].value, evt_res_data[evt_eap_success_failure_success].value); data_set(evt_data[analyzer_eap_common_success]); event_refcount_dec(cpriv->evt_result); cpriv->evt_result = NULL; } ptime ts = event_get_timestamp(cpriv->evt_response); event_refcount_dec(cpriv->evt_request); cpriv->evt_request = NULL; event_refcount_dec(cpriv->evt_response); cpriv->evt_response = NULL; return event_process(evt, NULL, 0, ts); }
typename boost::enable_if<is_multi_array<T>, void>::type read_dataset(h5xxObject const& object, std::string const& name, T & array, slice const& file_slice) { dataset data_set(object, name); read_dataset(data_set, array, file_slice); }
static int proto_eap_process(void *proto_priv, struct packet *p, struct proto_process_stack *stack, unsigned int stack_index) { struct proto_process_stack *s = &stack[stack_index]; if (sizeof(struct eap_header) > s->plen) return PROTO_INVALID; struct proto_eap_priv *priv = proto_priv; struct eap_header *hdr = s->pload; PTYPE_UINT8_SETVAL(s->pkt_info->fields_value[proto_eap_field_code], hdr->code); PTYPE_UINT8_SETVAL(s->pkt_info->fields_value[proto_eap_field_identifier], hdr->identifier); if (hdr->code < 1 || hdr->code > 4) return PROTO_INVALID; uint16_t len = ntohs(hdr->length); if (len > s->plen) return PROTO_INVALID; // Keep only the payload lenght len -= sizeof(struct eap_header); if (conntrack_get(stack, stack_index) != POM_OK) return PROTO_ERR; if (conntrack_delayed_cleanup(s->ce, *PTYPE_UINT32_GETVAL(priv->p_timeout), p->ts) != POM_OK) { conntrack_unlock(s->ce); return PROTO_ERR; } conntrack_unlock(s->ce); if (hdr->code == 3 || hdr->code == 4) { // Content length is 0 for success and failure if (len != 4) return PROTO_INVALID; len = 0; if (!event_has_listener(priv->evt_success_failure)) return PROTO_OK; struct event *evt = event_alloc(priv->evt_success_failure); if (!evt) return PROTO_ERR; struct data *evt_data = event_get_data(evt); PTYPE_UINT8_SETVAL(evt_data[evt_eap_common_identifier].value, hdr->identifier); data_set(evt_data[evt_eap_common_identifier]); PTYPE_BOOL_SETVAL(evt_data[evt_eap_success_failure_success].value, (hdr->code == 3 ? 1 : 0)); data_set(evt_data[evt_eap_success_failure_success]); return event_process(evt, stack, stack_index, p->ts); } // At this point, code is either 1 or 2 (request/response) void *pload = s->pload + sizeof(struct eap_header); uint8_t type = 0; // There is at least 1 byte of data for request/response if (len < 1) return PROTO_INVALID; len--; type = *(uint8_t*)pload; pload++; struct event *evt = NULL; struct data *evt_data = NULL; switch (type) { case 1: // Identity if (!event_has_listener(priv->evt_identity)) break; evt = event_alloc(priv->evt_identity); if (!evt) return PROTO_ERR; if (len) { evt_data = event_get_data(evt); PTYPE_STRING_SETVAL_N(evt_data[evt_eap_identity_identity].value, pload, len); data_set(evt_data[evt_eap_identity_identity]); } break; case 4: // MD5-Challenge if (!event_has_listener(priv->evt_md5_challenge)) break; if (len < 17) return PROTO_INVALID; uint8_t value_size = *(uint8_t*)pload; if (value_size != 16) return PROTO_INVALID; pload++; len--; evt = event_alloc(priv->evt_md5_challenge); if (!evt) return PROTO_ERR; evt_data = event_get_data(evt); PTYPE_BYTES_SETLEN(evt_data[evt_eap_md5_challenge_value].value, 16); PTYPE_BYTES_SETVAL(evt_data[evt_eap_md5_challenge_value].value, pload); data_set(evt_data[evt_eap_md5_challenge_value]); if (len > 16) { PTYPE_STRING_SETVAL_N(evt_data[evt_eap_md5_challenge_name].value, pload + 16, len - 16); data_set(evt_data[evt_eap_md5_challenge_name]); } break; } if (evt) { if (!evt_data) evt_data = event_get_data(evt); PTYPE_UINT8_SETVAL(evt_data[evt_eap_common_identifier].value, hdr->identifier); data_set(evt_data[evt_eap_common_identifier]); PTYPE_UINT8_SETVAL(evt_data[evt_eap_common_code].value, hdr->code); data_set(evt_data[evt_eap_common_code]); if (event_process(evt, stack, stack_index, p->ts) != POM_OK) return PROTO_ERR; } return PROTO_OK; }
static int analyzer_rtp_pload_process(void *obj, struct packet *p, struct proto_process_stack *stack, unsigned int stack_index) { struct analyzer *analyzer = obj; struct analyzer_rtp_priv *priv = analyzer->priv; struct proto_process_stack *pload_stack = &stack[stack_index]; struct proto_process_stack *s = &stack[stack_index - 1]; if (!s->ce) return POM_ERR; struct analyzer_rtp_ce_priv *cp = conntrack_get_priv(s->ce, obj); if (!cp) { cp = malloc(sizeof(struct analyzer_rtp_ce_priv)); if (!cp) { pom_oom(sizeof(struct analyzer_rtp_ce_priv)); return POM_ERR; } memset(cp, 0, sizeof(struct analyzer_rtp_ce_priv)); if (conntrack_add_priv(s->ce, obj, cp, analyzer_rtp_ce_cleanup) != POM_OK) return POM_ERR; } int dir = s->direction; if (!cp->evt[dir]) { cp->evt[dir] = event_alloc(priv->evt_rtp_stream); if (!cp->evt[dir]) return POM_ERR; struct data *evt_data = event_get_data(cp->evt[dir]); ptype_copy(evt_data[analyzer_rtp_stream_ssrc].value, s->pkt_info->fields_value[proto_rtp_field_ssrc]); data_set(evt_data[analyzer_rtp_stream_ssrc]); // For now we always assume RTP is over UDP or TCP if (stack_index > 2) { struct proto_process_stack *l4_stack = &stack[stack_index - 2]; unsigned int i; for (i = 0; !data_is_set(evt_data[analyzer_rtp_stream_src_port]) || !data_is_set(evt_data[analyzer_rtp_stream_dst_port]); i++) { struct proto_reg_info *l4_info = proto_get_info(l4_stack->proto); char *name = l4_info->pkt_fields[i].name; if (!name) break; if (!data_is_set(evt_data[analyzer_rtp_stream_src_port]) && !strcmp(name, "sport")) { ptype_copy(evt_data[analyzer_rtp_stream_src_port].value, l4_stack->pkt_info->fields_value[i]); data_set(evt_data[analyzer_rtp_stream_src_port]); } else if (!data_is_set(evt_data[analyzer_rtp_stream_dst_port]) && !strcmp(name, "dport")) { ptype_copy(evt_data[analyzer_rtp_stream_dst_port].value, l4_stack->pkt_info->fields_value[i]); data_set(evt_data[analyzer_rtp_stream_dst_port]); } } } if (stack_index > 3) { struct proto_process_stack *l3_stack = &stack[stack_index - 3]; unsigned int i; for (i = 0; !data_is_set(evt_data[analyzer_rtp_stream_src_addr]) || !data_is_set(evt_data[analyzer_rtp_stream_dst_addr]); i++) { struct proto_reg_info *l3_info = proto_get_info(l3_stack->proto); char *name = l3_info->pkt_fields[i].name; if (!name) break; if (!data_is_set(evt_data[analyzer_rtp_stream_src_addr]) && !strcmp(name, "src")) { evt_data[analyzer_rtp_stream_src_addr].value = ptype_alloc_from(l3_stack->pkt_info->fields_value[i]); if (evt_data[analyzer_rtp_stream_src_addr].value) data_set(evt_data[analyzer_rtp_stream_src_addr]); } else if (!data_is_set(evt_data[analyzer_rtp_stream_dst_addr]) && !strcmp(name, "dst")) { evt_data[analyzer_rtp_stream_dst_addr].value = ptype_alloc_from(l3_stack->pkt_info->fields_value[i]); if (evt_data[analyzer_rtp_stream_dst_addr].value) data_set(evt_data[analyzer_rtp_stream_dst_addr]); } } } struct proto *sess_proto = telephony_stream_info_get_sess_proto(s->ce); if (sess_proto) { struct proto_reg_info *proto_reg = proto_get_info(sess_proto); PTYPE_STRING_SETVAL(evt_data[analyzer_rtp_stream_sess_proto].value, proto_reg->name); data_set(evt_data[analyzer_rtp_stream_sess_proto]); } char *call_id = telephony_stream_info_get_call_id(s->ce); if (call_id) { PTYPE_STRING_SETVAL_P(evt_data[analyzer_rtp_stream_call_id].value, call_id); data_set(evt_data[analyzer_rtp_stream_call_id]); } if (event_process_begin(cp->evt[dir], stack, stack_index, p->ts) != POM_OK) return POM_ERR; } if (!cp->pload[dir]) { cp->pload[dir] = pload_alloc(cp->evt[dir], 0); if (!cp->pload[dir]) return POM_ERR; struct telephony_codec_info info = { 0 }; if (telephony_stream_info_get_codec(&info, stack, stack_index - 1) == POM_OK) { char *pload_type = telephony_codec_info_get_pload_type(&info); if (pload_type) pload_set_type(cp->pload[dir], pload_type); } } if (pload_append(cp->pload[dir], pload_stack->pload, pload_stack->plen) != POM_OK) return POM_ERR; return POM_OK; }
static int analyzer_tftp_pkt_process(void *obj, struct packet *p, struct proto_process_stack *stack, unsigned int stack_index) { struct analyzer_tftp_priv *priv = obj; struct proto_process_stack *s = &stack[stack_index]; struct proto_process_stack *s_prev = &stack[stack_index - 1]; uint16_t opcode = *PTYPE_UINT16_GETVAL(s_prev->pkt_info->fields_value[proto_tftp_field_opcode]); // Get the session struct conntrack_session *session = conntrack_session_get(s_prev->ce); if (!session) return POM_ERR; struct analyzer_tftp_session_priv *spriv = conntrack_session_get_priv(session, obj); if (!spriv) { // Add session priv if it is not done yet spriv = malloc(sizeof(struct analyzer_tftp_session_priv)); if (!spriv) { pom_oom(sizeof(struct analyzer_tftp_session_priv)); goto err; } memset(spriv, 0, sizeof(struct analyzer_tftp_session_priv)); if (conntrack_session_add_priv(session, obj, spriv, analyzer_tftp_session_priv_cleanup) != POM_OK) { free(spriv); goto err; } } void *pload = s->pload; uint32_t plen = s->plen; switch (opcode) { case tftp_rrq: case tftp_wrq: { if (plen < 3) return POM_OK; // Invalid packet // Find the filename // The below should always be valid as proto_tftp already checked this char *filename = pload; char *mode = memchr(filename, 0, plen - 1) + 1; struct analyzer_tftp_file *fq = malloc(sizeof(struct analyzer_tftp_file)); if (!fq) { pom_oom(sizeof(struct analyzer_tftp_file)); goto err; } memset(fq, 0, sizeof(struct analyzer_tftp_file)); // Get the port on which we expect this file // No need to check the IP as we got the session biding struct proto_process_stack *s_l4 = &stack[stack_index - 2]; unsigned int i; for (i = 0; !fq->port ; i++) { struct proto_reg_info *pinfo = proto_get_info(s_l4->proto); char *name = pinfo->pkt_fields[i].name; if (!name) { pomlog(POMLOG_ERR "Source port not found in RRQ/WRQ packets"); goto err; } if (!strcmp(name, "sport")) { fq->port = *PTYPE_UINT16_GETVAL(s_l4->pkt_info->fields_value[i]); break; } } fq->evt = event_alloc(priv->evt_file); if (!fq->evt) { free(fq); goto err; } struct data *evt_data = event_get_data(fq->evt); PTYPE_STRING_SETVAL(evt_data[analyzer_tftp_file_filename].value, filename); data_set(evt_data[analyzer_tftp_file_filename]); PTYPE_STRING_SETVAL(evt_data[analyzer_tftp_file_mode].value, mode); data_set(evt_data[analyzer_tftp_file_mode]); PTYPE_BOOL_SETVAL(evt_data[analyzer_tftp_file_write].value, opcode == tftp_wrq); data_set(evt_data[analyzer_tftp_file_write]); fq->next = spriv->files; if (fq->next) fq->next->prev = fq; spriv->files = fq; conntrack_session_unlock(session); event_process_begin(fq->evt, stack, stack_index, p->ts); break; } case tftp_data: { if (plen < sizeof(uint16_t)) return POM_OK; // Invalid packet struct analyzer_tftp_file *f = conntrack_get_priv(s_prev->ce, obj); struct data *evt_data = NULL; if (!f) { // The file is not yet associated to this connection // Find it in the queue struct proto_process_stack *s_l4 = &stack[stack_index - 2]; unsigned int i; uint16_t sport = 0, dport = 0; for (i = 0; !sport || !dport ; i++) { struct proto_reg_info *pinfo = proto_get_info(s_l4->proto); char *name = pinfo->pkt_fields[i].name; if (!name) { pomlog(POMLOG_ERR "Source port not found in data packets"); goto err; } if (!strcmp(name, "sport")) sport = *PTYPE_UINT16_GETVAL(s_l4->pkt_info->fields_value[i]); if (!strcmp(name, "dport")) dport = *PTYPE_UINT16_GETVAL(s_l4->pkt_info->fields_value[i]); } // Find the file in the session list for (f = spriv->files; ; f = f->next) { evt_data = event_get_data(f->evt); if (*PTYPE_BOOL_GETVAL(evt_data[analyzer_tftp_file_write].value)) { if (f->port == sport) break; } else { if (f->port == dport) break; } } if (!f) { pomlog(POMLOG_DEBUG "File not found in queued file request."); conntrack_session_unlock(session); return POM_OK; } // Remove the file from the queue and assign it to the conntrack if (f->prev) f->prev->next = f->next; else spriv->files = f->next; if (f->next) f->next->prev = f->prev; f->prev = NULL; f->next = NULL; // Create the payload buffer f->pload = pload_alloc(f->evt, PLOAD_FLAG_NEED_MAGIC); if (!f->pload) goto err; conntrack_add_priv(s_prev->ce, obj, f, analyzer_tftp_conntrack_priv_cleanup); } else { evt_data = event_get_data(f->evt); } conntrack_session_unlock(session); if (!f->pload) { pomlog(POMLOG_DEBUG "Ignoring extra packet"); return POM_OK; } // Discard the block ID pload += sizeof(uint16_t); plen -= sizeof(uint16_t); if (pload_append(f->pload, pload, plen) != POM_OK) goto err; uint32_t *size = PTYPE_UINT32_GETVAL(evt_data[analyzer_tftp_file_size].value); *size += plen; if (plen < ANALYZER_TFTP_BLK_SIZE) { // Got last packet ! data_set(evt_data[analyzer_tftp_file_size]); int res = pload_end(f->pload); res += event_process_end(f->evt); f->evt = NULL; f->pload = NULL; if (res) goto err; } break; } case tftp_error: { conntrack_session_unlock(session); struct analyzer_tftp_file *f = conntrack_get_priv(s_prev->ce, obj); if (f && f->pload) { int res = pload_end(f->pload); res += event_process_end(f->evt); f->pload = NULL; f->evt = NULL; if (res) goto err; } break; } default: conntrack_session_unlock(session); break; } return POM_OK; err: conntrack_session_unlock(session); return POM_ERR; }
static int proto_ppp_pap_process(void *proto_priv, struct packet *p, struct proto_process_stack *stack, unsigned int stack_index) { struct proto_process_stack *s = &stack[stack_index]; if (sizeof(struct ppp_pap_header) > s->plen) return PROTO_INVALID; struct ppp_pap_header *pchdr = s->pload; size_t len = ntohs(pchdr->length); if (len > s->plen) return PROTO_INVALID; // Keep only the payload len len -= sizeof(struct ppp_pap_header); PTYPE_UINT8_SETVAL(s->pkt_info->fields_value[proto_ppp_pap_field_code], pchdr->code); PTYPE_UINT8_SETVAL(s->pkt_info->fields_value[proto_ppp_pap_field_identifier], pchdr->identifier); struct proto_ppp_pap_priv *priv = proto_priv; if (conntrack_get(stack, stack_index) != POM_OK) return PROTO_ERR; if (conntrack_delayed_cleanup(s->ce, *PTYPE_UINT32_GETVAL(priv->p_auth_timeout), p->ts) != POM_OK) { conntrack_unlock(s->ce); return PROTO_ERR; } conntrack_unlock(s->ce); if (pchdr->code == 1 && event_has_listener(priv->evt_request)) { if (len < 4) return PROTO_INVALID; uint8_t *peer_id_len = s->pload + sizeof(struct ppp_pap_header); if (*peer_id_len > len - 2) return PROTO_INVALID; len -= (*peer_id_len + 1); uint8_t *pwd_len = peer_id_len + *peer_id_len + 1; if (*pwd_len > len - 1) return PROTO_INVALID; // Process the challenge/response event struct event *evt = event_alloc(priv->evt_request); if (!evt) return PROTO_ERR; struct data *evt_data = event_get_data(evt); PTYPE_UINT8_SETVAL(evt_data[evt_ppp_pap_request_code].value, pchdr->code); data_set(evt_data[evt_ppp_pap_request_code]); PTYPE_UINT8_SETVAL(evt_data[evt_ppp_pap_request_identifier].value, pchdr->identifier); data_set(evt_data[evt_ppp_pap_request_identifier]); PTYPE_STRING_SETVAL_N(evt_data[evt_ppp_pap_request_peer_id].value, (char *)peer_id_len + 1, *peer_id_len); data_set(evt_data[evt_ppp_pap_request_peer_id]); PTYPE_STRING_SETVAL_N(evt_data[evt_ppp_pap_request_password].value, (char *)pwd_len + 1, *pwd_len); data_set(evt_data[evt_ppp_pap_request_password]); if (event_process(evt, stack, stack_index, p->ts) != POM_OK) return PROTO_ERR; } if ((pchdr->code == 2 || pchdr->code == 3) && event_has_listener(priv->evt_ack_nack)) { struct event *evt = event_alloc(priv->evt_ack_nack); if (!evt) return PROTO_ERR; struct data *evt_data = event_get_data(evt); PTYPE_UINT8_SETVAL(evt_data[evt_ppp_pap_ack_nack_code].value, pchdr->code); data_set(evt_data[evt_ppp_pap_ack_nack_code]); PTYPE_UINT8_SETVAL(evt_data[evt_ppp_pap_ack_nack_identifier].value, pchdr->identifier); data_set(evt_data[evt_ppp_pap_ack_nack_identifier]); uint8_t *msg_len = s->pload + sizeof(struct ppp_pap_header); if (*msg_len > len - 1) return PROTO_INVALID; PTYPE_STRING_SETVAL_N(evt_data[evt_ppp_pap_ack_nack_message].value, (char *)msg_len + 1, *msg_len); data_set(evt_data[evt_ppp_pap_ack_nack_message]); if (event_process(evt, stack, stack_index, p->ts) != POM_OK) return PROTO_ERR; } return PROTO_OK; }
static int analyzer_arp_pkt_process(void *obj, struct packet *p, struct proto_process_stack *stack, unsigned int stack_index) { struct analyzer *analyzer = obj; struct analyzer_arp_priv *priv = analyzer->priv; struct proto_process_stack *s = &stack[stack_index]; struct proto_process_stack *s_prev = &stack[stack_index - 1]; struct in_addr arp_ip = PTYPE_IPV4_GETADDR(s->pkt_info->fields_value[proto_arp_field_sender_proto_addr]); // Discard bogon 0.0.0.0 if (!arp_ip.s_addr) return POM_OK; // Find that IP in the table uint32_t id = arp_ip.s_addr & ANALYZER_ARP_HOST_MASK; char *arp_mac = PTYPE_MAC_GETADDR(s->pkt_info->fields_value[proto_arp_field_sender_hw_addr]); uint16_t vlan = 0; if (s_prev->proto == priv->proto_vlan) vlan = *PTYPE_UINT16_GETVAL(s_prev->pkt_info->fields_value[proto_vlan_field_vid]); pom_mutex_lock(&priv->lock); struct analyzer_arp_host *host; for (host = priv->hosts[id]; host; host = host->next) { if (host->ip.s_addr == arp_ip.s_addr && host->vlan == vlan) break; } if (!host) { // Host not found ! host = malloc(sizeof(struct analyzer_arp_host)); if (!host) { pom_mutex_unlock(&priv->lock); pom_oom(sizeof(struct analyzer_arp_host)); return POM_ERR; } memset(host, 0, sizeof(struct analyzer_arp_host)); host->ip.s_addr = arp_ip.s_addr; memcpy(host->mac, arp_mac, sizeof(host->mac)); host->vlan = vlan; host->next = priv->hosts[id]; if (host->next) host->next->prev = host; priv->hosts[id] = host; pom_mutex_unlock(&priv->lock); // Announce the new station if (event_has_listener(priv->evt_new_sta)) { struct event *evt = event_alloc(priv->evt_new_sta); if (!evt) return POM_ERR; struct data *evt_data = evt->data; ptype_copy(evt_data[analyzer_arp_new_sta_mac_addr].value, s->pkt_info->fields_value[proto_arp_field_sender_hw_addr]); data_set(evt_data[analyzer_arp_new_sta_mac_addr]); ptype_copy(evt_data[analyzer_arp_new_sta_ip_addr].value, s->pkt_info->fields_value[proto_arp_field_sender_proto_addr]); data_set(evt_data[analyzer_arp_new_sta_ip_addr]); PTYPE_UINT16_SETVAL(evt_data[analyzer_arp_new_sta_vlan].value, vlan); data_set(evt_data[analyzer_arp_new_sta_vlan]); PTYPE_STRING_SETVAL(evt_data[analyzer_arp_new_sta_input].value, p->input->name); data_set(evt_data[analyzer_arp_new_sta_input]); if (event_process(evt, stack, stack_index) != POM_OK) return POM_ERR; } // Nothing else to do return POM_OK; } // Host was found, check mac if (memcmp(host->mac, arp_mac, sizeof(host->mac))) { if (event_has_listener(priv->evt_sta_changed)) { struct event *evt = event_alloc(priv->evt_sta_changed); if (!evt) { pom_mutex_unlock(&priv->lock); return POM_ERR; } struct data *evt_data = evt->data; PTYPE_MAC_SETADDR(evt_data[analyzer_arp_sta_changed_old_mac_addr].value, host->mac); data_set(evt_data[analyzer_arp_sta_changed_old_mac_addr]); ptype_copy(evt_data[analyzer_arp_sta_changed_new_mac_addr].value, s->pkt_info->fields_value[proto_arp_field_sender_hw_addr]); data_set(evt_data[analyzer_arp_sta_changed_new_mac_addr]); ptype_copy(evt_data[analyzer_arp_sta_changed_ip_addr].value, s->pkt_info->fields_value[proto_arp_field_sender_proto_addr]); data_set(evt_data[analyzer_arp_sta_changed_ip_addr]); PTYPE_UINT16_SETVAL(evt_data[analyzer_arp_sta_changed_vlan].value, vlan); data_set(evt_data[analyzer_arp_sta_changed_vlan]); PTYPE_STRING_SETVAL(evt_data[analyzer_arp_sta_changed_input].value, p->input->name); data_set(evt_data[analyzer_arp_sta_changed_input]); if (event_process(evt, stack, stack_index) != POM_OK) { pom_mutex_unlock(&priv->lock); return POM_ERR; } } memcpy(host->mac, arp_mac, sizeof(host->mac)); } pom_mutex_unlock(&priv->lock); return POM_OK; }
static int analyzer_docsis_pkt_process(void *obj, struct packet *p, struct proto_process_stack *stack, unsigned int stack_index) { struct analyzer *analyzer = obj; struct analyzer_docsis_priv *priv = analyzer->priv; struct proto_process_stack *s = &stack[stack_index]; uint8_t *type = PTYPE_UINT8_GETVAL(s->pkt_info->fields_value[proto_docsis_mgmt_field_type]); char *mac_dst = PTYPE_MAC_GETADDR(s->pkt_info->fields_value[proto_docsis_mgmt_field_dst]); // FIXME : improve this filtering at the source // Filter some useless messages we don't care about if (*type == MMT_UCD2 || *type == MMT_UCD3 || *type == MMT_MDD) return POM_OK; if (*type != MMT_RNG_RSP) { pomlog(POMLOG_DEBUG "Unhandled DOCSIS MGMT message type %u for destination mac %02hhX:%02hhX:%02hhX:%02hhX:%02hhX:%02hhX", *type, mac_dst[0], mac_dst[1], mac_dst[2], mac_dst[3], mac_dst[4], mac_dst[5]); return POM_OK; } // Use the last bits for the modem ID uint16_t id = ntohs(*(uint16_t*) (mac_dst + 4)) & ANALYZER_DOCSIS_CM_MASK; pom_mutex_lock(&priv->lock); struct analyzer_docsis_cm *cm; for (cm = priv->cms[id]; cm; cm = cm->next) { if (!memcmp(cm->mac, mac_dst, sizeof(cm->mac))) break; } if (!cm) { // Cable modem not found ! cm = malloc(sizeof(struct analyzer_docsis_cm)); if (!cm) { pom_mutex_unlock(&priv->lock); pom_oom(sizeof(struct analyzer_docsis_cm)); return POM_ERR; } memset(cm, 0, sizeof(struct analyzer_docsis_cm)); cm->t = timer_alloc(cm, analyzer_docsis_cm_timeout); if (!cm->t) { pom_mutex_unlock(&priv->lock); free(cm); return POM_ERR; } cm->analyzer = analyzer; memcpy(cm->mac, mac_dst, sizeof(cm->mac)); cm->t4_multiplier = 1; cm->next = priv->cms[id]; if (cm->next) cm->next->prev = cm; priv->cms[id] = cm; // Announce the new CM if (event_has_listener(priv->evt_cm_new)) { struct event *evt = event_alloc(priv->evt_cm_new); if (!evt) { pom_mutex_unlock(&priv->lock); return POM_ERR; } struct data *evt_data = event_get_data(evt); PTYPE_MAC_SETADDR(evt_data[analyzer_docsis_cm_new_mac].value, cm->mac); data_set(evt_data[analyzer_docsis_cm_new_mac]); PTYPE_STRING_SETVAL(evt_data[analyzer_docsis_cm_new_input].value, p->input->name); data_set(evt_data[analyzer_docsis_cm_new_input]); if (event_process(evt, stack, stack_index, p->ts) != POM_OK) { pom_mutex_unlock(&priv->lock); return POM_ERR; } } } switch (*type) { case MMT_RNG_RSP: analyzer_docsis_pkt_parse_rng_rsp(priv, cm, p, stack, stack_index); break; // FIXME If ranging_status is 0 and we receive another msg, probably it's actually registered // and we need to call analyzer_docsis_reg_status_update(); } timer_queue_now(cm->t, T4_TIMEOUT * cm->t4_multiplier, p->ts); pom_mutex_unlock(&priv->lock); return POM_OK; }
int coro__ut_data_1( co_t *co_p ) { static dword i; if ( *co_p ) goto **co_p; /* begin */ data_clear_watch( peek__ut_data_1 ); data_watch( peek__ut_data_1, _ut_data_1_watch ); data_set_byte( var__ut_byte, 1 ); data_set_dword( var__ut_array_1, 1 ); data_set_float( var__ut_float, 0.0 ); data_reset_all( peek__ut_data_2 ); /* Main operations */ for ( i = 0; i < CYCLE_COUNT; i++ ) { /* 1 */ data_set_byte( var__ut_byte, ( byte ) i ); do { /* wait */ *co_p = &&L__0; L__0: if (!( data_get_changed( peek__ut_data_1, var__ut_word ))) { /* cond */ return CO_WAIT; } } while ( 0 ); /* 3 */ data_reset( peek__ut_data_1, var__ut_word ); assert_u32_eq(( word ) i, data_get_word( var__ut_word )); data_set_dword( var__ut_array_1, i << 8 ); do { /* wait */ *co_p = &&L__1; L__1: if (!( data_get_changed( peek__ut_data_1, var__ut_array_3 ))) { /* cond */ return CO_WAIT; } } while ( 0 ); /* 5 */ data_reset( peek__ut_data_1, var__ut_array_3 ); assert_u32_eq( data_get_dword( var__ut_array_1 ), data_get_dword( var__ut_array_3 )); data_set_dword( var__ut_array_0, data_get_dword( var__ut_array_2 )); data_set_dword( var__ut_array_2, 0 ); data_set_float( var__ut_float, data_get_float( var__ut_float ) + 0.25 ); data_reset( peek__ut_data_1, var__ut_float ); do { /* wait */ *co_p = &&L__2; L__2: if (!( data_get_changed( peek__ut_data_1, var__ut_float ))) { /* cond */ return CO_WAIT; } } while ( 0 ); } assert_u32_eq( 0x55555555, data_get_dword( var__ut_array_0 )); /* Auxiliary operations */ data_set_all_changed( peek__ut_data_1 ); assert(( data_get_changed( peek__ut_data_1, var__ut_word ) && data_get_changed( peek__ut_data_1, var__ut_array_3 ) && data_get_changed( peek__ut_data_1, var__ut_float ) && !data_get_changed( peek__ut_data_1, var__ut_array_1 ) && !data_get_changed( peek__ut_data_1, var__ut_array_2 )) ); data_reset_all( peek__ut_data_1 ); assert_not( data_get_changed_any( peek__ut_data_1 )); data_set_changed( var__ut_byte ); assert_not( data_get_changed_any( peek__ut_data_1 )); data_set_changed( var__ut_float ); assert( data_get_changed_any( peek__ut_data_1 )); do { /* yield */ *co_p = &&L__3; return CO_YIELD; L__3:; } while ( 0 ); data_clear_watch( peek__ut_data_1 ); assert_not( data_get_changed_any( peek__ut_data_1 )); data_watch_array( peek__ut_data_1, _ut_data_array_watch ); data_set_changed( var__ut_float ); data_set_changed( var__ut_word ); data_set_changed( var__ut_array_0 ); assert_not( data_get_changed_any( peek__ut_data_1 )); data_set_changed( var__ut_array_1 ); assert( data_get_changed( peek__ut_data_1, var__ut_array_1 )); data_set_changed( var__ut_array_2 ); assert( data_get_changed( peek__ut_data_1, var__ut_array_2 )); data_set_changed( var__ut_array_3 ); assert( data_get_changed( peek__ut_data_1, var__ut_array_3 )); data_set_changed( var__ut_byte ); assert( data_get_changed( peek__ut_data_1, var__ut_byte )); do { /* yield */ *co_p = &&L__4; return CO_YIELD; L__4:; } while ( 0 ); assert_u32_eq( var__ut_array, data_atovar( data_vartoa( var__ut_array_0 ))); assert_str_eq( "_ut_byte", data_vartoa( data_atovar( "_ut_byte" ))); i = 0x00ABCDEF; data_set( var__ut_array_3, &i ); assert_str_eq( "0x00ABCDEF", data_get_string( __str, var__ut_array_3 )); data_set_string( var__ut_float, "8080.02" ); assert_str_eq( "8080.02", data_get_string( __str, var__ut_float )); assert_str_eq( "word", data_get_type( var__ut_word )); /* end */ *co_p = &&L__END__ut_data_1; L__END__ut_data_1: return CO_END; }
void test_hamming() { struct Hamming_config* conf = hamming_generate_config(); printf("\nTest of the (%d, %d, 3) Hamming code\n--------------------------------\n\n", N, K); // Display the generator and control matrix printf("Control matrix: \n"); matrix_show(conf->CONTROL_MATRIX); printf("Generator matrix: \n"); matrix_show(conf->GENERATOR_MATRIX); printf("Syndromes array: \n"); for(uint8_t i = 0; i <= N; i++) { print_var_bits(i); printf(" : "); print_var_bits(conf->SYNDROMES_ARRAY->data_array[i]); printf(" (%d : %d)", i, conf->SYNDROMES_ARRAY->data_array[i]); printf("\n"); } printf("\n"); // Generation of the word to encode struct Matrix* dte = matrix_generate(K, 1); matrix_set(dte, 3, 1, 1); matrix_set(dte, 1, 1, 1); // Display printf("Data to encode : %d elements\n", dte->data->data_number); matrix_show_word(dte); // Encoding struct Matrix* d = hamming_encode(dte, conf); printf("Data encoded : %d elements\n", d->data->data_number); matrix_show_word(d); // Add an error data_set(3, 1, d->data); printf("Data modified : %d elements\n", d->data->data_number); matrix_show_word(d); // Correction struct Matrix* r = hamming_syndrome(d, conf); printf("\n\nCorrection\n-----------\n\n"); printf("Syndrome of the modified code : %d \n", matrix_word_to_int(r)); if(!matrix_is_null(r)) { uint8_t b = hamming_check_syndrome(r, conf); printf("The bit %d is corrupted\n", b + 1); } else printf("No bit corrupted\n"); matrix_free(dte); matrix_free(d); matrix_free(r); hamming_free_config(conf); }
static int analyzer_jpeg_pload_analyze(struct analyzer *analyzer, struct analyzer_pload_buffer *pload, void *buffer, size_t buff_len) { struct analyzer_jpeg_pload_priv *priv = analyzer_pload_buffer_get_priv(pload); if (!priv) { priv = malloc(sizeof(struct analyzer_jpeg_pload_priv)); if (!priv) { pom_oom(sizeof(struct analyzer_jpeg_pload_priv)); return POM_ERR; } memset(priv, 0, sizeof(struct analyzer_jpeg_pload_priv)); priv->pload_buff = buffer; priv->pload_buff_len = buff_len; // Setup error handler struct jpeg_error_mgr *jerr = malloc(sizeof(struct jpeg_error_mgr)); if (!jerr) { free(priv); pom_oom(sizeof(struct jpeg_error_mgr)); return POM_ERR; } memset(jerr, 0, sizeof(struct jpeg_error_mgr)); priv->cinfo.err = jpeg_std_error(jerr); priv->cinfo.err->error_exit = analyzer_jpeg_lib_error_exit; // Allocate the decompressor jpeg_create_decompress(&priv->cinfo); priv->cinfo.client_data = priv; #ifdef HAVE_LIBEXIF // Save APP1 jpeg_save_markers(&priv->cinfo, JPEG_APP0 + 1, 0xFFFF); #endif // Allocate the source struct jpeg_source_mgr *src = malloc(sizeof(struct jpeg_source_mgr)); if (!src) { free(priv->cinfo.err); pom_oom(sizeof(struct jpeg_source_mgr)); jpeg_destroy_decompress(&priv->cinfo); free(priv); return POM_ERR; } memset(src, 0, sizeof(struct jpeg_source_mgr)); src->init_source = analyzer_jpeg_lib_init_source; src->fill_input_buffer = analyzer_jpeg_lib_fill_input_buffer; src->skip_input_data = analyzer_jpeg_lib_skip_input_data; src->resync_to_restart = jpeg_resync_to_restart; src->term_source = analyzer_jpeg_lib_term_source; priv->cinfo.src = src; analyzer_pload_buffer_set_priv(pload, priv); } else { priv->pload_buff = buffer; priv->pload_buff_len = buff_len; } if (priv->jpeg_lib_pos >= buff_len) // Nothing more to process return POM_OK; int res = POM_OK; if (!setjmp(priv->jmp_buff)) { if (priv->jpeg_lib_pos) { // It's not garanteed that buffer points to the // same memory area after each call, so we reset it here priv->cinfo.src->next_input_byte = buffer + priv->jpeg_lib_pos; } if (jpeg_read_header(&priv->cinfo, TRUE) == JPEG_SUSPENDED) return POM_OK; // Headers are incomplete struct data *data = analyzer_pload_buffer_get_data(pload); PTYPE_UINT16_SETVAL(data[analyzer_jpeg_pload_width].value, priv->cinfo.image_width); data_set(data[analyzer_jpeg_pload_width]); PTYPE_UINT16_SETVAL(data[analyzer_jpeg_pload_height].value, priv->cinfo.image_height); data_set(data[analyzer_jpeg_pload_height]); debug_jpeg("JPEG read header returned %u, image is %ux%u", res, priv->cinfo.image_width, priv->cinfo.image_height); #ifdef HAVE_LIBEXIF // Parse the exif data jpeg_saved_marker_ptr marker; for (marker = priv->cinfo.marker_list; marker && marker->marker != JPEG_APP0 + 1; marker = marker->next); if (marker) { ExifData *exif_data = exif_data_new_from_data(marker->data, marker->data_length); if (!exif_data) { pomlog(POMLOG_DEBUG "Unable to parse EXIF data"); } exif_data_foreach_content(exif_data, analyzer_jpeg_exif_content_process, pload); exif_data_free(exif_data); } #endif analyzer_pload_buffer_set_state(pload, analyzer_pload_buffer_state_analyzed); } else { pomlog(POMLOG_DEBUG "Error while parsing JPEG headers"); res = POM_ERR; } free(priv->cinfo.err); free(priv->cinfo.src); jpeg_destroy_decompress(&priv->cinfo); free(priv); analyzer_pload_buffer_set_priv(pload, NULL); return res; }