int handle_control_request(ServiceHandler h, char *buf, int bufSize) { int cmd = -1; int dataNum = -1; if(bufSize == 0) return -1; int ret; char ppData[MAX_DATA_NUM][MAX_DATA_NUM] = {0}; ret = parse_ctl_data(buf, bufSize, &cmd, &dataNum, ppData); debug_argv("cmd:%d, num:%d \n",cmd, dataNum); if(dataNum > 1) { ret = -1; } debug_argv("ret %d\n",ret); if(-1 == ret) { debug_argv("\n"); error_response(h,"Data Format Error!\n"); return -1; } if(cmd == CTL_REG_CMD && (dataNum == 1 || dataNum == 0)) { debug_argv("handleControlrequests!!\n"); if(dataNum == 1) { add_cluster_nodes(cluster_nodes_g, ppData,dataNum); } int nodeNum = MAX_DATA_NUM; cluster_nodes_info(cluster_nodes_g,ppData,&nodeNum); for(ret = 0;ret<nodeNum;ret++) debug_argv("%s\n",ppData[ret]); bufSize = MAX_BUF_LEN; format_ctl_data(buf,&bufSize,CTL_REG_CMD,ppData,nodeNum); send_data(h,buf,bufSize); } else { debug_argv("\n"); error_response(h,"Unknow Request!\n"); return -1; } return 0; }
void cachedb_operate(struct module_qstate* qstate, enum module_ev event, int id, struct outbound_entry* outbound) { struct cachedb_env* ie = (struct cachedb_env*)qstate->env->modinfo[id]; struct cachedb_qstate* iq = (struct cachedb_qstate*)qstate->minfo[id]; verbose(VERB_QUERY, "cachedb[module %d] operate: extstate:%s event:%s", id, strextstate(qstate->ext_state[id]), strmodulevent(event)); if(iq) log_query_info(VERB_QUERY, "cachedb operate: query", &qstate->qinfo); /* perform cachedb state machine */ if((event == module_event_new || event == module_event_pass) && iq == NULL) { if(!cachedb_new(qstate, id)) { (void)error_response(qstate, id, LDNS_RCODE_SERVFAIL); return; } iq = (struct cachedb_qstate*)qstate->minfo[id]; } if(iq && (event == module_event_pass || event == module_event_new)) { cachedb_handle_query(qstate, iq, ie, id); return; } if(iq && (event == module_event_moddone)) { cachedb_handle_response(qstate, iq, ie, id); return; } if(iq && outbound) { /* cachedb does not need to process responses at this time * ignore it. cachedb_process_response(qstate, iq, ie, id, outbound, event); */ return; } if(event == module_event_error) { verbose(VERB_ALGO, "got called with event error, giving up"); (void)error_response(qstate, id, LDNS_RCODE_SERVFAIL); return; } if(!iq && (event == module_event_moddone)) { /* during priming, module done but we never started */ qstate->ext_state[id] = module_finished; return; } log_err("bad event for cachedb"); (void)error_response(qstate, id, LDNS_RCODE_SERVFAIL); }
int connection_proxy_req_parse(Connection *conn) { int rc = 0; Host *target_host = conn->req->target_host; Backend *req_action = conn->req->action; check_debug(!IOBuf_closed(conn->iob), "Client closed, goodbye."); rc = Connection_read_header(conn, conn->req); check_debug(rc > 0, "Failed to read another header."); error_unless(Request_is_http(conn->req), conn, 400, "Someone tried to change the protocol on us from HTTP."); Backend *found = Host_match_backend(target_host, Request_path(conn->req), NULL); error_unless(found, conn, 404, "Handler not found: %s", bdata(Request_path(conn->req))); // break out of PROXY if the actions don't match if(found != req_action) { Request_set_action(conn->req, found); return Connection_backend_event(found, conn); } else { return HTTP_REQ; } error_response(conn, 500, "Invalid code branch, tell Zed."); error: return REMOTE_CLOSE; }
// complete the response to a get request. void finish_get_command(conn *c) { item *it; int i; // setup all items for writing out. for (i = 0; i < c->ileft; i++) { it = *(c->ilist + i); if (it) { // Construct the response. Each hit adds three elements to the // outgoing data list: // "VALUE <key> <flags> <data_length>\r\n" // "<data>\r\n" // The <data> element is stored on the connection item list, not on // the iov list. if (!conn_add_iov(c, "VALUE ", 6) || !conn_add_iov(c, ITEM_key(it), it->nkey) || !conn_add_iov(c, ITEM_suffix(it), it->nsuffix + it->nbytes)) { item_remove(it); error_response(c, "SERVER_ERROR out of memory writing get response"); return; } if (config.verbose > 1) { fprintf(stderr, ">%d sending key %s\n", c->sfd, ITEM_key(it)); } } else { fprintf(stderr, "ERROR corrupted ilist!\n"); exit(1); } } if (config.verbose > 1) { fprintf(stderr, ">%d END\n", c->sfd); } if (!conn_add_iov(c, "END\r\n", 5) != 0) { error_response(c, "SERVER_ERROR out of memory writing get response"); } else { conn_set_state(c, conn_mwrite); } }
static void ironbee_plugin_send_response_hdr(TSCont contp, TSHttpTxn txnp) { assert(contp != NULL); assert(txnp != NULL); tsib_txn_ctx *txndata; txndata = TSContDataGet(contp); if (txndata == NULL) { /* Ironbee is unavailable to help with our response. */ /* This contp is not ours, so we leave it. */ internal_error_response(txnp); TSHttpTxnReenable(txnp, TS_EVENT_HTTP_CONTINUE); return; } /* If ironbee has sent us into an error response then * we came here in our error path, with nonzero status. */ if (txndata->status != 0) { error_response(txnp, txndata); } /* Feed ironbee the headers if not done already. */ if (!ib_flags_all(txndata->tx->flags, IB_TX_FRES_STARTED)) { if (process_hdr(txndata, txnp, &tsib_direction_client_resp) != HDR_OK) { /* I think this is a shouldn't happen event, and that * if it does we have an ironbee bug or misconfiguration. * Log an error to catch if it happens in practice. */ ib_log_error_tx(txndata->tx, "process_hdr returned error in send_response_hdr event"); } } /* If there is an ironbee-generated response body, notify ironbee. * * NOTE: I do not see anywhere else to put this as the error body is * just a buffer and not delivered via normal IO channels, so * the error body will never get caught by an event. */ if ((txndata->status != 0) && (txndata->err_body != NULL)) { const char *data = txndata->err_body; size_t data_length = txndata->err_body_len; ib_log_debug_tx(txndata->tx, "error_response: calling ib_state_notify_response_body_data() %s:%d", __FILE__, __LINE__); ib_state_notify_response_body_data(txndata->tx->ib, txndata->tx, data, data_length); } TSHttpTxnReenable(txnp, TS_EVENT_HTTP_CONTINUE); }
// process a memcached set command. void process_update_command(conn *c, token_t *tokens, const size_t ntokens, int comm, bool handle_cas) { int vlen; assert(c != NULL); if (tokens[KEY_TOKEN].length > KEY_MAX_LENGTH || !safe_strtol(tokens[4].value, (int32_t *)&vlen)) { error_response(c, "CLIENT_ERROR bad command line format"); return; } if (vlen < 0) { error_response(c, "CLIENT_ERROR bad command line format"); return; } // setup value to be read c->sbytes = vlen + 2; // for \r\n consumption. conn_set_state(c, conn_read_value); }
bool proc (geonlp::ServicePtr service, const std::string& request_json, picojson::value& response) { picojson::ext req; if (request_json.length() == 0) return false; try { req.initByJson(request_json); } catch (picojson::PicojsonException e) { error_response(std::string("Request string is not a valid JSON representation.")); exit(0); } response = service->proc(picojson::value(req)); return true; }
// Get POST message from stdin to string void get_post_message(std::string& message) { message = ""; char* cp = getenv("CONTENT_LENGTH"); if (!cp) { error_response(std::string("CONTENT_LENGTH is not defined.")); exit(0); } int len = atoi(getenv("CONTENT_LENGTH")); char buf[len + 1]; std::cin.read(buf, len); buf[len] = '\0'; message = buf; }
static inline int Connection_backend_event(Backend *found, Connection *conn) { switch(found->type) { case BACKEND_HANDLER: return HANDLER; case BACKEND_DIR: return DIRECTORY; case BACKEND_PROXY: return PROXY; default: error_response(conn, 501, "Invalid backend type: %d", found->type); } error: return CLOSE; }
int connection_identify_request(Connection *conn) { int next = CLOSE; if(Request_is_xml(conn->req)) { if(biseq(Request_path(conn->req), &POLICY_XML_REQUEST)) { debug("XML POLICY CONNECTION: %s", bdata(Request_path(conn->req))); conn->type = CONN_TYPE_SOCKET; taskname("XML"); next = SOCKET_REQ; } else { debug("XML MESSAGE"); conn->type = CONN_TYPE_MSG; taskname("MSG"); next = MSG_REQ; } } else if(Request_is_json(conn->req)) { debug("JSON SOCKET MESSAGE"); conn->type = CONN_TYPE_MSG; taskname("MSG"); next = MSG_REQ; } else if(Request_is_websocket(conn->req)) { debug("WEBSOCKET MESSAGE"); conn->type = CONN_TYPE_SOCKET; taskname("WS"); next = WS_REQ; } else if(Request_is_http(conn->req)) { debug("HTTP MESSAGE"); conn->type = CONN_TYPE_HTTP; taskname("HTTP"); next = HTTP_REQ; } else { error_response(conn, 500, "Invalid code branch, tell Zed."); } return next; error: return CLOSE; }
static inline int ident_and_register(Connection *conn, int reg_too) { int next = CLOSE; if(Request_is_xml(conn->req)) { if(biseq(Request_path(conn->req), &POLICY_XML_REQUEST)) { debug("XML POLICY CONNECTION"); conn->type = CONN_TYPE_SOCKET; taskname("XML"); next = SOCKET_REQ; } else { debug("XML MESSAGE"); conn->type = CONN_TYPE_MSG; taskname("MSG"); next = MSG_REQ; } } else if(Request_is_json(conn->req)) { debug("JSON SOCKET MESSAGE"); conn->type = CONN_TYPE_MSG; taskname("MSG"); next = MSG_REQ; } else if(Request_is_http(conn->req)) { debug("HTTP MESSAGE"); conn->type = CONN_TYPE_HTTP; taskname("HTTP"); next = HTTP_REQ; } else { error_response(conn, 500, "Invalid code branch, tell Zed."); } if(reg_too) Register_connect(IOBuf_fd(conn->iob), (void*)conn); return next; error: return CLOSE; }
int main(int argc, char* argv[]) { default_id = picojson::value(long(0)); char* cp = getenv("REQUEST_METHOD"); if (!cp) { error_response(std::string("Unknown method '") + cp + "'."); exit(0); } if (!strcmp(cp, "POST")) { std::string request; get_post_message(request); try { geonlp::ServicePtr service = geonlp::createService(); picojson::value response; proc(service, request, response); std::cout << "Content-Type: application/json; charset=utf-8\n"; std::cout << "Access-Control-Allow-Origin: *\n\n"; std::cout << response.serialize(); } catch (geonlp::ServiceCreateFailedException& e) { json_error_response(e.what(), default_id); exit(0); } } else if (strcmp(cp, "GET") && strcmp(cp, "HEAD")) { // Preflignted requests std::cout << "Access-Control-Allow-Origin: *\n"; std::cout << "Access-Control-Allow-Methods: POST, OPTIONS\n"; std::cout << "Access-Control-Allow-Headers: X-GeoNLP-Authorization, Content-type\n"; std::cout << "Access-Control-Max-Age: 3600\n"; std::cout << "Content-Length: 0\n"; std::cout << "Content-Type: text/plain\n\n"; exit(0); } return 0; }
static int mdrc_gains(double *bands, int nb_bands, t_mdrc_gains **p_p_mdrc_gains) // inputs : // bands : band cut off frequencies (first band cut off frequency = 0) // nb_bands : number of bands (1 to 5) // // outputs (into **p_p_mdrc_gains) : // index : index of filter for each band // gains : best found gains for each band // band_responses : response of each band // global_response : global response // error : error { double FreqCutoff[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 15, 20, 25, 30, 35, 40, 45, 50, 55, 60, 65, 70, 75, 80, 85, 90, 95, 100, 110, 120, 130, 140, 150, 160, 170}; // b2, -b1/2, b0, -a1/2, a2 double LPCoefTab[][5] = {{ 0, -0, 0, 8388607, 8388607}, { 356, -356, 356, 8310966, 8234749}, { 1411, -1411, 1411, 8233344, 8083724}, { 3146, -3146, 3146, 8155760, 7935495}, { 5541, -5541, 5541, 8078234, 7790021}, { 8577, -8577, 8577, 8000780, 7647261}, { 12238, -12238, 12238, 7923418, 7507178}, { 16504, -16504, 16504, 7846162, 7369732}, { 21358, -21358, 21358, 7769030, 7234882}, { 26783, -26783, 26783, 7692034, 7102590}, { 32761, -32761, 32761, 7615190, 6972818}, { 70399, -70399, 70399, 7233707, 6360402}, { 119556, -119556, 119556, 6857840, 5805295}, { 178504, -178504, 178504, 6488789, 5302984}, { 245707, -245707, 245707, 6127486, 4849190}, { 319807, -319807, 319807, 5774638, 4439894}, { 399607, -399607, 399607, 5430758, 4071336}, { 484057, -484057, 484057, 5096202, 3740025}, { 572239, -572239, 572239, 4771190, 3442727}, { 663351, -663351, 663351, 4455832, 3176458}, { 756697, -756697, 756697, 4150147, 2938474}, { 851674, -851674, 851674, 3854084, 2726259}, { 947762, -947762, 947762, 3567532, 2537505}, {1044512, -1044512, 1044512, 3290333, 2370105}, {1141538, -1141538, 1141538, 3022295, 2222134}, {1238513, -1238513, 1238513, 2763196, 2091835}, {1335156, -1335156, 1335156, 2512796, 1977608}, {1431229, -1431229, 1431229, 2270842, 1877993}, {1526534, -1526534, 1526534, 2037068, 1791664}, {1714194, -1714194, 1714194, 1592982, 1654134}, {1897115, -1897115, 1897115, 1178372, 1556594}, {2074617, -2074617, 2074617, 791105, 1492071}, {2246282, -2246282, 2246282, 429132, 1454786}, {2411881, -2411881, 2411881, 90515, 1439948}, {2571327, -2571327, 2571327, -226558, 1443585}, {2724636, -2724636, 2724636, -523771, 1462394}}; double HPCoefTab[][5] = {{8388607, 8388607, 8388607, 8388607, 8388607}, {8311322, 8311322, 8311322, 8310966, 8234749}, {8234756, 8234756, 8234756, 8233344, 8083724}, {8158906, 8158906, 8158906, 8155760, 7935495}, {8083774, 8083774, 8083774, 8078234, 7790021}, {8009357, 8009357, 8009357, 8000780, 7647261}, {7935656, 7935656, 7935656, 7923418, 7507178}, {7862666, 7862666, 7862666, 7846162, 7369732}, {7790387, 7790387, 7790387, 7769030, 7234882}, {7718816, 7718816, 7718816, 7692034, 7102590}, {7647952, 7647952, 7647952, 7615190, 6972818}, {7304106, 7304106, 7304106, 7233707, 6360402}, {6977396, 6977396, 6977396, 6857840, 5805295}, {6667292, 6667292, 6667292, 6488789, 5302984}, {6373192, 6373192, 6373192, 6127486, 4849190}, {6094444, 6094444, 6094444, 5774638, 4439894}, {5830366, 5830366, 5830366, 5430758, 4071336}, {5580260, 5580260, 5580260, 5096202, 3740025}, {5343428, 5343428, 5343428, 4771190, 3442727}, {5119182, 5119182, 5119182, 4455832, 3176458}, {4906844, 4906844, 4906844, 4150147, 2938474}, {4705759, 4705759, 4705759, 3854084, 2726259}, {4515294, 4515294, 4515294, 3567532, 2537505}, {4334844, 4334844, 4334844, 3290333, 2370105}, {4163833, 4163833, 4163833, 3022295, 2222134}, {4001709, 4001709, 4001709, 2763196, 2091835}, {3847952, 3847952, 3847952, 2512796, 1977608}, {3702071, 3702071, 3702071, 2270842, 1877993}, {3563602, 3563602, 3563602, 2037068, 1791664}, {3307176, 3307176, 3307176, 1592982, 1654134}, {3075486, 3075486, 3075486, 1178372, 1556594}, {2865722, 2865722, 2865722, 791105, 1492071}, {2675414, 2675414, 2675414, 429132, 1454786}, {2502396, 2502396, 2502396, 90515, 1439948}, {2344769, 2344769, 2344769, -226558, 1443585}, {2200865, 2200865, 2200865, -523771, 1462394}}; const int nb_filters = sizeof(FreqCutoff) / sizeof(*FreqCutoff); double coef = pow(2.0, -23.0); double swap_tmp, max_response; double error, best_error, error_max, dx; double weigthing[N]; double best_gains[NB_BANDS_MAX]; int i, j, counter, counter_max; t_mdrc_gains *p_mdrc_gains; int *p_index; double *p_gains; t_complex *p_band_response; t_complex *p_global_response; nb_bands = (nb_bands > NB_BANDS_MAX ? NB_BANDS_MAX : nb_bands); p_mdrc_gains = (t_mdrc_gains *) malloc(sizeof(t_mdrc_gains)); if(p_mdrc_gains == NULL) { return -1; } p_index = p_mdrc_gains->index; p_gains = p_mdrc_gains->gains; p_global_response = p_mdrc_gains->global_response; *p_p_mdrc_gains = p_mdrc_gains; for(i = 0; i < sizeof(FreqCutoff) / sizeof(*FreqCutoff); i++) { FreqCutoff[i] *= 100.0; } for(i = 0; i < sizeof(LPCoefTab) / sizeof(*LPCoefTab); i++) { swap_tmp = LPCoefTab[i][2] * coef; LPCoefTab[i][2] = LPCoefTab[i][0] * coef; LPCoefTab[i][0] = swap_tmp; LPCoefTab[i][1] *= coef * -2.0; LPCoefTab[i][3] *= coef * -2.0; LPCoefTab[i][4] *= coef; } for(i = 0; i < sizeof(HPCoefTab) / sizeof(*HPCoefTab); i++) { swap_tmp = HPCoefTab[i][2] * coef; HPCoefTab[i][2] = HPCoefTab[i][0] * coef; HPCoefTab[i][0] = swap_tmp; HPCoefTab[i][1] *= coef * -2.0; HPCoefTab[i][3] *= coef * -2.0; HPCoefTab[i][4] *= coef; } compute_weigthing(weigthing); if(nb_bands > 1) { for(i = 1; i < nb_bands; i++) { for(j = 0; j < nb_filters; j++) { if(bands[i] <= FreqCutoff[j]) { p_index[i - 1] = j; // select nearest frequency if(j > 0) { if((FreqCutoff[j] - bands[i]) > (bands[i] - FreqCutoff[j - 1])) { p_index[i - 1] = j - 1; } } break; } } } for(i = 0; i < nb_bands; i++) { double max_square; int index_LP, index_HP; p_band_response = p_mdrc_gains->band_responses[i]; if(i == 0) { index_LP = p_index[i]; response(LPCoefTab[index_LP][0], LPCoefTab[index_LP][1], LPCoefTab[index_LP][2], LPCoefTab[index_LP][3], LPCoefTab[index_LP][4], 1.0, 0.0, 0.0, 0.0, 0.0, p_band_response); } else if(i < nb_bands - 1) { index_LP = p_index[i]; index_HP = p_index[i - 1]; response(LPCoefTab[index_LP][0], LPCoefTab[index_LP][1], LPCoefTab[index_LP][2], LPCoefTab[index_LP][3], LPCoefTab[index_LP][4], HPCoefTab[index_HP][0], HPCoefTab[index_HP][1], HPCoefTab[index_HP][2], HPCoefTab[index_HP][3], HPCoefTab[index_HP][4], p_band_response); } else { index_HP = p_index[i - 1]; response(1.0, 0.0, 0.0, 0.0, 0.0, HPCoefTab[index_HP][0], HPCoefTab[index_HP][1], HPCoefTab[index_HP][2], HPCoefTab[index_HP][3], HPCoefTab[index_HP][4], p_band_response); } max_square = 0.0; for(j = 0; j < N; j++) { double square = p_band_response[j].re * p_band_response[j].re + p_band_response[j].im * p_band_response[j].im; if(square > max_square) { max_square = square; } } p_gains[i] = 1.0 / sqrt(max_square); } error = error_response(p_mdrc_gains, p_gains, nb_bands, weigthing); memcpy(best_gains, p_gains, nb_bands * sizeof(double)); best_error = error; dx = 0.1; error_max = 0.05; counter = 1; counter_max = 1000000; display_result(counter, error, dx); // coarse gains search while((best_error > error_max) && (counter < counter_max)) { solve_gains(&counter, dx, 5, nb_bands, best_gains, &best_error, p_mdrc_gains, weigthing, error_max, counter_max); dx *= 0.5; } // fine gains search counter_max *= 2; error_max *= 0.2; dx *= 0.2; solve_gains(&counter, dx, 10, nb_bands, best_gains, &best_error, p_mdrc_gains, weigthing, error_max, counter_max); memcpy(p_gains, best_gains, nb_bands * sizeof(double)); error = best_error; display_result(counter, error, dx); } else { p_index[0] = 0; p_gains[0] = 1.0; response(1.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, p_mdrc_gains->band_responses[0]); error = error_response(p_mdrc_gains, p_gains, nb_bands, weigthing); printf("no sub-band\n"); } for(i = 0; i < N; i++) { p_global_response[i].re = 0.0; p_global_response[i].im = 0.0; for(j = 0; j < nb_bands; j++) { p_global_response[i].re += p_gains[j] * p_mdrc_gains->band_responses[j][i].re; p_global_response[i].im += p_gains[j] * p_mdrc_gains->band_responses[j][i].im; } } p_mdrc_gains->error = error; return 0; }
int handle_one_request(ServiceHandler h, char *buf, int buf_size) { debug; char Buf[MAX_BUF_LEN] = "\0"; int BufSize = MAX_BUF_LEN; char Data1[MAX_BUF_LEN] = "\0"; char Data2[MAX_BUF_LEN] = "\0"; mDataFormat data = (mDataFormat) malloc(sizeof(struct DataFormat)); data->value1 = Data1; data->value2 = Data2; memset(Data1, 0, MAX_BUF_LEN); memset(Data2, 0, MAX_BUF_LEN); data->value1 = Data1; data->value2 = Data2; /*if(receive_data(h,Buf,&BufSize) == 0) { fprintf(stderr,"Connection Error,%s:%d\n",__FILE__,__LINE__); return -1; }*/ if(BufSize == 0) { free(data); return -1; } int ret = parse_data(buf,data); // print the received data // printRec(data); if(ret == -1) { error_response(h,"Data Format Error!\n"); printf("server parse_data error!\n"); free(data); return -1; } if(data->cmd == OPEN_CMD) { debug; Database db = createNewDB(data->value1); debug_argv("open db:%p\n",db); match_sockfd_mdb(h, db); BufSize = MAX_BUF_LEN; data->value_num = 0; BufSize = format_data(Buf,data); assert(BufSize > 0); send_data(h,Buf,BufSize); } else if(data->cmd == CLOSE_CMD) { debug_argv("close db\n"); Database db = NULL; get_mdb(h, &db); closeDB(db); BufSize = MAX_BUF_LEN; data->value_num = 0; BufSize = format_data(Buf,data); send_data(h,Buf,BufSize); detach_sockfd_mdb(h); service_stop(h); free(data); return 0; } else if(data->cmd == GET_CMD) { Database db = NULL; get_mdb(h, &db); //debug_argv("get db:%p\n",db); int key = *(int *)data->value1; Data value; char tem[MAX_BUF_LEN] = "\0"; value.value = tem; ret = getValueByKey(db, key, &value); // printf("server getdata value => %s\n", value.value); if(ret == -1) { error_response(h,"The key NOT FOUND!\n"); free(data); return -1; } BufSize = MAX_BUF_LEN; data->value_num = 1; data->len_value1 = strlen(value.value); data->value1 = value.value; BufSize = format_data(Buf,data); send_data(h,Buf,BufSize); } else if(data->cmd == SET_CMD) { int key = *(int *)data->value1; Data value; value.value = data->value2; value.length = data->len_value2; Database db = NULL; get_mdb(h, &db); debug_argv("set: db:%p\n",db); ret = putKeyValue(db,key,&value); if (ret == -1) { error_response(h,"Save key & value error!\n"); printf("set error : %d, %s\n", key, value.value); free(data); return -1; } BufSize = MAX_BUF_LEN; data->value_num = 0; BufSize = format_data(Buf,data); send_data(h,Buf,BufSize); } else if(data->cmd == DEL_CMD) { int key = *(int *)data->value1;; Database db = NULL; get_mdb(h, &db); debug_argv("delete: db:%p\n",db); ret = deleteValueByKey(db,key); if(ret == -1) { error_response(h,"The key NOT FOUND!\n"); free(data); return -1; } BufSize = MAX_BUF_LEN; data->value_num = 0; BufSize = format_data(Buf,data); send_data(h,Buf,BufSize); } else { printf("Unknow Request!\n"); error_response(h, "Unknow Request!\n"); } free(data); return 0; }
void UdpServerListenHandler::HandleReadBlock(const ErrorCode & error_code, const boost::shared_ptr<BlockData> & block, const RID & resource_id, boost::uint32_t transaction_id, boost::uint16_t block_index, const std::set<boost::uint16_t> & subpiece_indexs, boost::uint16_t dest_protocol_version, const boost::asio::ip::udp::endpoint & end_point) { if (!server_) { return; } if (error_code == ErrorCodes::Success) { for(std::set<boost::uint16_t>::const_iterator iter = subpiece_indexs.begin(); iter != subpiece_indexs.end(); ++iter) { protocol::SubPieceInfo sub_piece_info = RequestParser::ParseFromSNToPeer(block_index, *iter); boost::uint16_t subpiece_index = *iter; if (subpiece_index < block->GetSubPieceNumber()) { statistics_->OnSubPieceResponseSent(); boost::shared_ptr<ResponseTask> subpiece_response( new SubPieceResponseTask( end_point, block, subpiece_index, transaction_id, resource_id, guid_, sub_piece_info, dest_protocol_version)); AddResponseTask(subpiece_response); } else { statistics_->OnError(ErrorCodes::ResourceNotFound); boost::shared_ptr<ResponseTask> error_response( new ErrorResponseTask( end_point, transaction_id, resource_id, guid_, protocol::ErrorPacket::PPV_SUBPIECE_NO_RESOURCEID, dest_protocol_version)); AddResponseTask(error_response); } } } else { statistics_->OnError(error_code); boost::shared_ptr<ResponseTask> error_response( new ErrorResponseTask( end_point, transaction_id, resource_id, guid_, protocol::ErrorPacket::PPV_SUBPIECE_NO_RESOURCEID, dest_protocol_version)); AddResponseTask(error_response); } }
// process a memcached get(s) command. (we don't support CAS). void process_get_command(conn *c, token_t *tokens, size_t ntokens, bool return_cas) { char *key; size_t nkey; int i = 0; item *it; token_t *key_token = &tokens[KEY_TOKEN]; char *suffix; assert(c != NULL); if (config.alloc && c->mem_blob == NULL) { long size = config.alloc_mean + gsl_ran_gaussian(c->thread->r, config.alloc_stddev); size = size <= 0 ? 10 : size; if (config.verbose > 0) { fprintf(stderr, "allocated blob: %ld\n", size); } c->mem_blob = malloc(sizeof(char) * size); c->mem_free_delay = 0; if (config.rtt_delay) { double r = config.rtt_mean + gsl_ran_gaussian(c->thread->r, config.rtt_stddev); if (r >= config.rtt_cutoff) { int wait = r / 100; if (config.verbose > 0) { fprintf(stderr, "delay: %d\n", wait); } c->mem_free_delay = wait; conn_set_state(c, conn_mwrite); } } } // process the whole command line, (only part of it may be tokenized right now) do { // process all tokenized keys at this stage. while(key_token->length != 0) { key = key_token->value; nkey = key_token->length; if(nkey > KEY_MAX_LENGTH) { error_response(c, "CLIENT_ERROR bad command line format"); return; } // lookup key-value. it = item_get(key, nkey); // hit. if (it) { if (i >= c->isize && !conn_expand_items(c)) { item_remove(it); break; } // Construct the response. Each hit adds three elements to the // outgoing data list: // "VALUE <key> <flags> <data_length>\r\n" // "<data>\r\n" // The <data> element is stored on the connection item list, not on // the iov list. if (!conn_add_iov(c, "VALUE ", 6) != 0 || !conn_add_iov(c, ITEM_key(it), it->nkey) != 0 || !conn_add_iov(c, ITEM_suffix(it), it->nsuffix + it->nbytes) != 0) { item_remove(it); break; } if (config.verbose > 1) { fprintf(stderr, ">%d sending key %s\n", c->sfd, key); } // add item to remembered list (i.e., we've taken ownership of them // through refcounting and later must release them once we've // written out the iov associated with them). item_update(it); *(c->ilist + i) = it; i++; } key_token++; } /* * If the command string hasn't been fully processed, get the next set * of tokens. */ if(key_token->value != NULL) { ntokens = tokenize_command(key_token->value, tokens, MAX_TOKENS); key_token = tokens; } } while(key_token->value != NULL); c->icurr = c->ilist; c->ileft = i; if (config.verbose > 1) { fprintf(stderr, ">%d END\n", c->sfd); } // If the loop was terminated because of out-of-memory, it is not reliable // to add END\r\n to the buffer, because it might not end in \r\n. So we // send SERVER_ERROR instead. if (key_token->value != NULL || !conn_add_iov(c, "END\r\n", 5) != 0) { error_response(c, "SERVER_ERROR out of memory writing get response"); } else { conn_set_state(c, conn_mwrite); } }
void UdpServerListenHandler::OnUdpRecv(protocol::Packet const & packet) { if (!server_) { return; } if (packet.PacketAction == protocol::RequestSubPiecePacketFromSN::Action) { statistics_->OnRequestForSubPieceReceived(); SessionManager::Type error_type = session_manager_->TryAddSession(packet.end_point, packet.transaction_id_); if (error_type == SessionManager::NewSessionCreated || error_type == SessionManager::SessionAlreadyExists) { if (error_type == SessionManager::NewSessionCreated) { statistics_->OnNewSessionAccepted(); } std::map<boost::uint16_t, std::set<boost::uint16_t> > request_in_sn_type; protocol::RequestSubPiecePacketFromSN const & request_subpiece_packet = static_cast<protocol::RequestSubPiecePacketFromSN const &>(packet); RequestParser::ParseFromPeerToSN(request_subpiece_packet, request_in_sn_type); size_t sub_piece_cnt = 0; for (std::map<boost::uint16_t, std::set<boost::uint16_t> >::const_iterator iter = request_in_sn_type.begin(); iter != request_in_sn_type.end(); ++iter) { memory_cache_->AsyncReadBlock(request_subpiece_packet.resource_name_, iter->first, *(iter->second.begin()), boost::bind(&UdpServerListenHandler::HandleReadBlock, shared_from_this(), _1, _2, request_subpiece_packet.resource_id_, request_subpiece_packet.transaction_id_, iter->first, iter->second, request_subpiece_packet.protocol_version_, request_subpiece_packet.end_point)); statistics_->OnBlockSubpieceDensityStat(*(iter->second.begin()), *(iter->second.rbegin()), iter->second.size()); sub_piece_cnt += iter->second.size(); } if (sub_piece_cnt) statistics_->OnResourceSubpieceDensityStat( request_in_sn_type.begin()->first * (BlockData::MaxBlockSize / SUB_PIECE_SIZE) + *request_in_sn_type.begin()->second.begin(), request_in_sn_type.rbegin()->first * (BlockData::MaxBlockSize / SUB_PIECE_SIZE) + *request_in_sn_type.rbegin()->second.rbegin(), sub_piece_cnt ); } else if (error_type == SessionManager::MaxSessionNumberReached) { const protocol::RequestSubPiecePacketFromSN & sn_packet = dynamic_cast<const protocol::RequestSubPiecePacketFromSN&>(packet); boost::shared_ptr<ResponseTask> error_response( new ErrorResponseTask( sn_packet.end_point, sn_packet.transaction_id_, sn_packet.resource_id_, guid_, protocol::ErrorPacket::PPV_CONNECT_CONNECTION_FULL, sn_packet.protocol_version_)); AddResponseTask(error_response); statistics_->OnNewSessionRejected(); } else { statistics_->OnDuplicateRequestReceived(); } } else if (packet.PacketAction == protocol::CloseSessionPacket::Action) { session_manager_->CloseSession(packet.end_point); statistics_->OnClientClosedSession(); } else { statistics_->OnUnknownPacketReceived(); LOG4CPLUS_WARN(Loggers::UdpServer(), "UdpServer received illegal packet."); } if (time_counter_.elapse() >= UdpServerStatistics::StatisticsIntervalInSeconds*1000) { statistics_->ReportStatus(session_manager_); time_counter_.reset(); } }
/* * POSIX 環境マネージャのメインルーチン * * 次の処理を行う * * ・初期化 * ポートマネージャに要求受け付け用のポートを登録する * ファイルシステム/プロセス/メモリの各処理の初期化を行う * * ・要求の受け付け * 要求の受け付けは、要求受け付けポートによって行う。 * * ・要求の処理 * * 要求の受けつけから処理がおわるまでは他の要求は受け付けない。 */ void posix_start (void) { struct posix_request request; #if 0 extern B _end; #endif if (init_port () == FAIL) { dbg_printf ("Cannot allocate port.\n"); slp_tsk (); } init_log (); #if 0 /* これではプログラムの最後をとることはできない */ init_malloc ((UW)&_end); #else /* 余裕を見て設定してあるが、manager が大きくなったときには調整が必要 */ init_malloc (0x100000); #endif /* 各機能単位での初期化 */ init_fs (); init_process (); init_memory (); banner (); for (;;) { /* 次の要求メッセージを待つ */ if (get_request (&request) == FAIL) { /* リクエスト取得に失敗した */ #ifdef DEBUG dbg_printf ("Cannot get request.\n"); #endif continue; } #ifdef DEBUG dbg_printf ("OP = %d\n ", request.operation); #endif /* 取得したリクエストを処理する */ if ((request.operation < 0) || (request.operation > NR_POSIX_SYSCALL)) { /* リクエスト要求にあるオペレーションは、サポートしていない */ error_response (&request, EP_NOSUP); } else { #ifdef DEBUG dbg_printf ("systemcall: %s\n", syscall_table[request.operation].name); #endif (*syscall_table[request.operation].syscall)(&request); } #ifdef DEBUG dbg_printf ("posix: systemcall end.\n"); #endif } /* ここには来ない */ }
/** * Plugin for the IronBee ATS. * * Handles some ATS events. * * @param[in,out] contp Pointer to the continuation * @param[in,out] event Event from ATS * @param[in,out] edata Event data * * @returns status */ int ironbee_plugin(TSCont contp, TSEvent event, void *edata) { ib_status_t rc; TSCont mycont; TSHttpTxn txnp = (TSHttpTxn) edata; TSHttpSsn ssnp = (TSHttpSsn) edata; tsib_txn_ctx *txndata; tsib_ssn_ctx *ssndata; tsib_hdr_outcome status; TSMutex ts_mutex = NULL; TSDebug("ironbee", "Entering ironbee_plugin with %d", event); switch (event) { /* CONNECTION */ case TS_EVENT_HTTP_SSN_START: /* start of connection */ /* But we can't initialize conn stuff here, because there's * no API to get the connection stuff required by ironbee * at this point. So instead, intercept the first TXN * * what we can and must do: create a new contp whose * lifetime is our ssn */ ts_mutex = TSMutexCreate(); mycont = TSContCreate(ironbee_plugin, ts_mutex); TSHttpSsnHookAdd (ssnp, TS_HTTP_TXN_START_HOOK, mycont); ssndata = TSmalloc(sizeof(*ssndata)); memset(ssndata, 0, sizeof(*ssndata)); /* The only failure here is EALLOC, and if that happens * we're ****ed anyway */ rc = ib_lock_create_malloc(&(ssndata->mutex)); assert(rc == IB_OK); ssndata->contp = mycont; ssndata->ts_mutex = ts_mutex; TSContDataSet(mycont, ssndata); TSHttpSsnHookAdd (ssnp, TS_HTTP_SSN_CLOSE_HOOK, mycont); TSHttpSsnReenable (ssnp, TS_EVENT_HTTP_CONTINUE); break; case TS_EVENT_HTTP_TXN_START: { /* start of Request */ /* First req on a connection, we set up conn stuff */ ib_status_t rc; ib_engine_t *ib = NULL; ssndata = TSContDataGet(contp); ib_lock_lock(ssndata->mutex); if (ssndata->iconn == NULL) { rc = tsib_manager_engine_acquire(&ib); if (rc == IB_DECLINED) { /* OK, this means the manager is disabled deliberately, * but otherwise all's well. So this TXN * gets processed without intervention from Ironbee * and is invisble when our SSN_CLOSE hook runs. */ ib_lock_unlock(ssndata->mutex); TSHttpTxnReenable(txnp, TS_EVENT_HTTP_CONTINUE); TSDebug("ironbee", "Decline from engine manager"); break; } else if (rc != IB_OK) { TSError("[ironbee] Failed to acquire engine: %s", ib_status_to_string(rc)); goto noib_error; } if (ib != NULL) { rc = ib_conn_create(ib, &ssndata->iconn, contp); if (rc != IB_OK) { TSError("[ironbee] ib_conn_create: %s", ib_status_to_string(rc)); tsib_manager_engine_release(ib); goto noib_error; } /* In the normal case, release the engine when the * connection's memory pool is destroyed */ rc = ib_mm_register_cleanup(ssndata->iconn->mm, cleanup_ib_connection, ib); if (rc != IB_OK) { TSError("[ironbee] ib_mm_register_cleanup: %s", ib_status_to_string(rc)); tsib_manager_engine_release(ib); goto noib_error; } TSDebug("ironbee", "CONN CREATE: conn=%p", ssndata->iconn); ssndata->txnp = txnp; ssndata->txn_count = ssndata->closing = 0; rc = ironbee_conn_init(ssndata); if (rc != IB_OK) { TSError("[ironbee] ironbee_conn_init: %s", ib_status_to_string(rc)); goto noib_error; } TSContDataSet(contp, ssndata); TSDebug("ironbee", "ironbee_plugin: ib_state_notify_conn_opened()"); rc = ib_state_notify_conn_opened(ib, ssndata->iconn); if (rc != IB_OK) { TSError("[ironbee] Failed to notify connection opened: %s", ib_status_to_string(rc)); } } else { /* Use TSError where there's no ib or tx */ TSError("Ironbee: No ironbee engine!"); goto noib_error; } } /* create a txn cont (request ctx) and tx */ txndata = TSmalloc(sizeof(*txndata)); memset(txndata, 0, sizeof(*txndata)); txndata->ssn = ssndata; txndata->txnp = txnp; rc = ib_tx_create(&txndata->tx, ssndata->iconn, txndata); if (rc != IB_OK) { TSError("[ironbee] Failed to create tx: %d", rc); tsib_manager_engine_release(ib); TSfree(txndata); goto noib_error; } ++ssndata->txn_count; ib_lock_unlock(ssndata->mutex); ib_log_debug_tx(txndata->tx, "TX CREATE: conn=%p tx=%p id=%s txn_count=%d", ssndata->iconn, txndata->tx, txndata->tx->id, txndata->ssn->txn_count); mycont = TSContCreate(ironbee_plugin, ssndata->ts_mutex); TSContDataSet(mycont, txndata); TSHttpTxnHookAdd(txnp, TS_HTTP_TXN_CLOSE_HOOK, mycont); /* Hook to process responses */ TSHttpTxnHookAdd(txnp, TS_HTTP_READ_RESPONSE_HDR_HOOK, mycont); /* Hook to process requests */ TSHttpTxnHookAdd(txnp, TS_HTTP_READ_REQUEST_HDR_HOOK, mycont); /* Create continuations for input and output filtering * to give them txn lifetime. */ txndata->in_data_cont = TSTransformCreate(in_data_event, txnp); TSContDataSet(txndata->in_data_cont, txndata); txndata->out_data_cont = TSTransformCreate(out_data_event, txnp); TSContDataSet(txndata->out_data_cont, txndata); TSHttpTxnReenable(txnp, TS_EVENT_HTTP_CONTINUE); break; noib_error: ib_lock_unlock(ssndata->mutex); /* NULL txndata signals this to SEND_RESPONSE */ mycont = TSContCreate(ironbee_plugin, ssndata->ts_mutex); TSContDataSet(mycont, NULL); TSError("[ironbee] Internal error initialising for transaction"); TSHttpTxnHookAdd(txnp, TS_HTTP_SEND_RESPONSE_HDR_HOOK, mycont); TSHttpTxnReenable(txnp, TS_EVENT_HTTP_ERROR); break; } /* HTTP RESPONSE */ case TS_EVENT_HTTP_READ_RESPONSE_HDR: txndata = TSContDataGet(contp); if (txndata->tx == NULL) { TSHttpTxnReenable(txnp, TS_EVENT_HTTP_CONTINUE); break; } /* Feed ironbee the headers if not done already. */ if (!ib_flags_all(txndata->tx->flags, IB_TX_FRES_STARTED)) { status = process_hdr(txndata, txnp, &tsib_direction_server_resp); /* OK, if this was an HTTP 100 response, it's not the * response we're interested in. No headers have been * sent yet, and no data will be sent until we've * reached here again with the final response. */ if (status == HDR_HTTP_100) { TSHttpTxnReenable(txnp, TS_EVENT_HTTP_CONTINUE); break; } // FIXME: Need to know if this fails as it (I think) means // that the response did not come from the server and // that ironbee should ignore it. /* I've not seen a fail here. AFAICT if either the origin * isn't responding or we're responding from cache. we * never reach here in the first place. */ } /* If ironbee signalled an error while processing request body data, * this is the first opportunity to divert to an errordoc */ if (HTTP_CODE(txndata->status)) { ib_log_debug_tx(txndata->tx, "HTTP code %d contp=%p", txndata->status, contp); TSHttpTxnHookAdd(txnp, TS_HTTP_SEND_RESPONSE_HDR_HOOK, contp); TSHttpTxnReenable(txnp, TS_EVENT_HTTP_ERROR); break; } /* If we're not going to inspect response body data * we can bring forward notification of response-end * so we're in time to respond with an errordoc if Ironbee * wants to block in the response phase. * * This currently fails. However, that appears to be because I * can't unset IB_TX_FINSPECT_RESBODY with InspectionEngineOptions */ if (!ib_flags_all(txndata->tx->flags, IB_TX_FINSPECT_RESBODY)) { if (!ib_flags_all(txndata->tx->flags, IB_TX_FRES_STARTED) ) { ib_state_notify_response_started(txndata->tx->ib, txndata->tx, NULL); } if (!ib_flags_all(txndata->tx->flags, IB_TX_FRES_FINISHED) ) { ib_state_notify_response_finished(txndata->tx->ib, txndata->tx); } /* Test again for Ironbee telling us to block */ if (HTTP_CODE(txndata->status)) { TSHttpTxnHookAdd(txnp, TS_HTTP_SEND_RESPONSE_HDR_HOOK, contp); TSHttpTxnReenable(txnp, TS_EVENT_HTTP_ERROR); break; } } /* Flag that we're too late to divert to an error response */ ib_tx_flags_set(txndata->tx, IB_TX_FCLIENTRES_STARTED); /* Normal execution. Add output filter to inspect response. */ TSHttpTxnHookAdd(txnp, TS_HTTP_RESPONSE_TRANSFORM_HOOK, txndata->out_data_cont); TSHttpTxnReenable(txnp, TS_EVENT_HTTP_CONTINUE); break; /* Hook for processing response headers. */ case TS_EVENT_HTTP_SEND_RESPONSE_HDR: txndata = TSContDataGet(contp); if (txndata == NULL) { /* Ironbee is unavailable to help with our response. */ internal_error_response(txnp); /* This contp isn't going through the normal flow. */ TSContDestroy(contp); TSHttpTxnReenable(txnp, TS_EVENT_HTTP_CONTINUE); break; } /* If ironbee has sent us into an error response then * we came here in our error path, with nonzero status. */ if (txndata->status != 0) { error_response(txnp, txndata); } /* Feed ironbee the headers if not done already. */ if (!ib_flags_all(txndata->tx->flags, IB_TX_FRES_STARTED)) { if (process_hdr(txndata, txnp, &tsib_direction_client_resp) != HDR_OK) { /* I think this is a shouldn't happen event, and that * if it does we have an ironbee bug or misconfiguration. * Log an error to catch if it happens in practice. */ ib_log_error_tx(txndata->tx, "process_hdr returned error in send_response_hdr event"); } } /* If there is an ironbee-generated response body, notify ironbee. * * NOTE: I do not see anywhere else to put this as the error body is * just a buffer and not delivered via normal IO channels, so * the error body will never get caught by an event. */ if ((txndata->status != 0) && (txndata->err_body != NULL)) { const char *data = txndata->err_body; size_t data_length = txndata->err_body_len; ib_log_debug_tx(txndata->tx, "error_response: calling ib_state_notify_response_body_data() %s:%d", __FILE__, __LINE__); ib_state_notify_response_body_data(txndata->tx->ib, txndata->tx, data, data_length); } TSHttpTxnReenable(txnp, TS_EVENT_HTTP_CONTINUE); break; /* HTTP REQUEST */ case TS_EVENT_HTTP_READ_REQUEST_HDR: /* hook to examine output headers. They're not available yet */ TSHttpTxnHookAdd(txnp, TS_HTTP_PRE_REMAP_HOOK, contp); TSHttpTxnReenable(txnp, TS_EVENT_HTTP_CONTINUE); break; /* hook for processing incoming request/headers * The OS_DNS hook is an alternative here. */ case TS_EVENT_HTTP_PRE_REMAP: { int request_inspection_finished = 0; txndata = TSContDataGet(contp); assert ((txndata != NULL) && (txndata->tx != NULL)); status = process_hdr(txndata, txnp, &tsib_direction_client_req); if (HDR_OUTCOME_IS_HTTP_OR_ERROR(status, txndata)) { if (status == HDR_HTTP_STATUS) { ib_log_debug_tx(txndata->tx, "HTTP code %d contp=%p", txndata->status, contp); } else { /* Ironbee set a status we don't handle. * We returned EINVAL, but we also need housekeeping to * avoid a crash in modhtp and log something bad. */ ib_log_debug_tx(txndata->tx, "Internal error %d contp=%p", txndata->status, contp); /* Ugly hack: notifications to stop modhtp bombing out */ request_inspection_finished = 1; } } else { /* Other nonzero statuses not supported */ switch(status) { case HDR_OK: /* If we're not inspecting the Request body, * we can bring forward notification of end-request * so any header-only tests run on Request phase * can abort the tx before opening a backend connection. */ if (!ib_flags_all(txndata->tx->flags, IB_TX_FINSPECT_REQBODY)) { request_inspection_finished = 1; } break; /* All's well */ case HDR_HTTP_STATUS: // FIXME: should we take the initiative here and return 500? ib_log_error_tx(txndata->tx, "Internal error: ts-ironbee requested error but no error response set."); break; case HDR_HTTP_100: /* This can't actually happen with current Trafficserver * versions, as TS will generate a 400 error without * reference to us. But in case that changes in future ... */ ib_log_error_tx(txndata->tx, "No request headers found."); break; default: ib_log_error_tx(txndata->tx, "Unhandled state arose in handling request headers."); break; } } if (request_inspection_finished) { if (!ib_flags_all(txndata->tx->flags, IB_TX_FREQ_STARTED) ) { ib_state_notify_request_started(txndata->tx->ib, txndata->tx, NULL); } if (!ib_flags_all(txndata->tx->flags, IB_TX_FREQ_FINISHED) ) { ib_state_notify_request_finished(txndata->tx->ib, txndata->tx); } } else { /* hook an input filter to watch data */ TSHttpTxnHookAdd(txnp, TS_HTTP_REQUEST_TRANSFORM_HOOK, txndata->in_data_cont); } /* Flag that we can no longer prevent a request going to backend */ ib_tx_flags_set(txndata->tx, IB_TX_FSERVERREQ_STARTED); /* Check whether Ironbee told us to block the request. * This could now come not just from process_hdr, but also * from a brought-forward notification if we aren't inspecting * a request body and notified request_finished. */ if (HTTP_CODE(txndata->status)) { TSHttpTxnHookAdd(txnp, TS_HTTP_SEND_RESPONSE_HDR_HOOK, contp); TSHttpTxnReenable(txnp, TS_EVENT_HTTP_ERROR); } else { TSHttpTxnReenable(txnp, TS_EVENT_HTTP_CONTINUE); } break; } /* CLEANUP EVENTS */ case TS_EVENT_HTTP_TXN_CLOSE: { txndata = TSContDataGet(contp); TSContDestroy(txndata->out_data_cont); TSContDestroy(txndata->in_data_cont); TSContDataSet(contp, NULL); TSContDestroy(contp); if ( (txndata != NULL) && (txndata->tx != NULL) ) { ib_log_debug_tx(txndata->tx, "TXN Close: %p", (void *)contp); tsib_txn_ctx_destroy(txndata); } TSHttpTxnReenable(txnp, TS_EVENT_HTTP_CONTINUE); break; } case TS_EVENT_HTTP_SSN_CLOSE: TSDebug("ironbee", "SSN Close: %p", (void *)contp); tsib_ssn_ctx_destroy(TSContDataGet(contp)); tsib_manager_engine_cleanup(); TSHttpSsnReenable(ssnp, TS_EVENT_HTTP_CONTINUE); break; case TS_EVENT_MGMT_UPDATE: { TSDebug("ironbee", "Management update"); ib_status_t rc; rc = tsib_manager_engine_create(); if (rc != IB_OK) { TSError("[ironbee] Error creating new engine: %s", ib_status_to_string(rc)); } break; } /* if we get here we've got a bug */ default: TSError("[ironbee] *** Unhandled event %d in ironbee_plugin.", event); break; } return 0; }
static void solve_gains(int *p_counter, double dx, int n, int nb_bands, double *p_best_gains, double *p_best_error, t_mdrc_gains *p_mdrc_gains, double *p_weigthing, double error_max, int counter_max) { double gains[NB_BANDS_MAX], x1[NB_BANDS_MAX], x2[NB_BANDS_MAX], x3[NB_BANDS_MAX], x4[NB_BANDS_MAX], x5[NB_BANDS_MAX], error; int i1, i2, i3, i4, i5; memcpy(gains, p_best_gains, nb_bands * sizeof(double)); for(i1 = -n; i1 <= n; i1++) { memcpy(x1, gains, nb_bands * sizeof(double)); x1[0] = gains[0] * pow(1.0 + dx, i1); if(nb_bands >= 2) { memcpy(x2, x1, nb_bands * sizeof(double)); for(i2 = -n; i2 <= n; i2++) { x2[1] = x1[1] * pow(1.0 + dx, i2); if(nb_bands >= 3) { memcpy(x3, x2, nb_bands * sizeof(double)); for(i3 = -n; i3 <= n; i3++) { x3[2] = x2[2] * pow(1.0 + dx, i3); if(nb_bands >= 4) { memcpy(x4, x3, nb_bands * sizeof(double)); for(i4 = -n; i4 <= n; i4++) { x4[3] = x3[3] * pow(1.0 + dx, i4); if(nb_bands >= 5) { memcpy(x5, x4, nb_bands * sizeof(double)); for(i5 = -n; i5 <= n; i5++) { x5[4] = x4[4] * pow(1.0 + dx, i5); error = error_response(p_mdrc_gains, x5, nb_bands, p_weigthing); (*p_counter)++; if(error < *p_best_error) { memcpy(p_best_gains, x5, nb_bands * sizeof(double)); *p_best_error = error; display_result(*p_counter, error, dx); } } memcpy(gains, p_best_gains, nb_bands * sizeof(double)); error = *p_best_error; if((error < error_max) || (*p_counter > counter_max)) { return; } } else { error = error_response(p_mdrc_gains, x4, nb_bands, p_weigthing); (*p_counter)++; if(error < *p_best_error) { memcpy(p_best_gains, x4, nb_bands * sizeof(double)); *p_best_error = error; display_result(*p_counter, error, dx); } } } memcpy(gains, p_best_gains, nb_bands * sizeof(double)); error = *p_best_error; if((error < error_max) || (*p_counter > counter_max)) { return; } } else { error = error_response(p_mdrc_gains, x3, nb_bands, p_weigthing); (*p_counter)++; if(error < *p_best_error) { memcpy(p_best_gains, x3, nb_bands * sizeof(double)); *p_best_error = error; display_result(*p_counter, error, dx); } } } memcpy(gains, p_best_gains, nb_bands * sizeof(double)); error = *p_best_error; if((error < error_max) || (*p_counter > counter_max)) { return; } } else { error = error_response(p_mdrc_gains, x2, nb_bands, p_weigthing); (*p_counter)++; if(error < *p_best_error) { memcpy(p_best_gains, x2, nb_bands * sizeof(double)); *p_best_error = error; display_result(*p_counter, error, dx); } } } memcpy(gains, p_best_gains, nb_bands * sizeof(double)); error = *p_best_error; if((error < error_max) || (*p_counter > counter_max)) { return; } } else { error = error_response(p_mdrc_gains, x1, nb_bands, p_weigthing); (*p_counter)++; if(error < *p_best_error) { memcpy(p_best_gains, x1, nb_bands * sizeof(double)); *p_best_error = error; display_result(*p_counter, error, dx); } } } }