static void trace_onreply_in(struct cell* t, int type, struct tmcb_params *ps) { db_key_t db_keys[NR_KEYS]; db_val_t db_vals[NR_KEYS]; static char fromip_buff[IP_ADDR_MAX_STR_SIZE+12]; static char toip_buff[IP_ADDR_MAX_STR_SIZE+12]; struct sip_msg* msg; struct sip_msg* req; int_str avp_value; struct usr_avp *avp; char statusbuf[8]; if(t==NULL || t->uas.request==0 || ps==NULL) { LM_DBG("no uas request, local transaction\n"); return; } req = ps->req; msg = ps->rpl; if(msg==NULL || req==NULL) { LM_DBG("no reply\n"); return; } avp = NULL; if(traced_user_avp.n!=0) avp=search_first_avp(traced_user_avp_type, traced_user_avp, &avp_value, 0); if((avp==NULL) && trace_is_off(req)) { LM_DBG("trace off...\n"); return; } if(parse_from_header(msg)==-1 || msg->from==NULL || get_from(msg)==NULL) { LM_ERR("cannot parse FROM header\n"); goto error; } if(parse_headers(msg, HDR_CALLID_F, 0)!=0) { LM_ERR("cannot parse call-id\n"); return; } db_keys[0] = msg_column; db_vals[0].type = DB_BLOB; db_vals[0].nul = 0; if(msg->len>0) { db_vals[0].val.blob_val.s = msg->buf; db_vals[0].val.blob_val.len = msg->len; } else { db_vals[0].val.blob_val.s = "No reply buffer"; db_vals[0].val.blob_val.len = sizeof("No reply buffer")-1; } /* check Call-ID header */ if(msg->callid==NULL || msg->callid->body.s==NULL) { LM_ERR("cannot find Call-ID header!\n"); goto error; } db_keys[1] = callid_column; db_vals[1].type = DB_STR; db_vals[1].nul = 0; db_vals[1].val.str_val.s = msg->callid->body.s; db_vals[1].val.str_val.len = msg->callid->body.len; db_keys[2] = method_column; db_vals[2].type = DB_STR; db_vals[2].nul = 0; db_vals[2].val.str_val.s = t->method.s; db_vals[2].val.str_val.len = t->method.len; db_keys[3] = status_column; db_vals[3].type = DB_STRING; db_vals[3].nul = 0; strcpy(statusbuf, int2str(ps->code, NULL)); db_vals[3].val.string_val = statusbuf; db_keys[4] = fromip_column; db_vals[4].type = DB_STRING; db_vals[4].nul = 0; siptrace_copy_proto(msg->rcv.proto, fromip_buff); strcat(fromip_buff, ip_addr2a(&msg->rcv.src_ip)); strcat(fromip_buff,":"); strcat(fromip_buff, int2str(msg->rcv.src_port, NULL)); db_vals[4].val.string_val = fromip_buff; db_keys[5] = toip_column; db_vals[5].type = DB_STRING; db_vals[5].nul = 0; // db_vals[5].val.string_val = ip_addr2a(&msg->rcv.dst_ip);; if(trace_local_ip) db_vals[5].val.string_val = trace_local_ip; else { siptrace_copy_proto(msg->rcv.proto, toip_buff); strcat(toip_buff, ip_addr2a(&msg->rcv.dst_ip)); strcat(toip_buff,":"); strcat(toip_buff, int2str(msg->rcv.dst_port, NULL)); db_vals[5].val.string_val = toip_buff; } db_keys[6] = date_column; db_vals[6].type = DB_DATETIME; db_vals[6].nul = 0; db_vals[6].val.time_val = time(NULL); db_keys[7] = direction_column; db_vals[7].type = DB_STRING; db_vals[7].nul = 0; db_vals[7].val.string_val = "in"; db_keys[8] = fromtag_column; db_vals[8].type = DB_STR; db_vals[8].nul = 0; db_vals[8].val.str_val.s = get_from(msg)->tag_value.s; db_vals[8].val.str_val.len = get_from(msg)->tag_value.len; db_funcs.use_table(db_con, siptrace_get_table()); db_keys[9] = traced_user_column; db_vals[9].type = DB_STR; db_vals[9].nul = 0; if( !trace_is_off(req) ) { db_vals[9].val.str_val.s = ""; db_vals[9].val.str_val.len = 0; LM_DBG("storing info...\n"); if(db_funcs.insert(db_con, db_keys, db_vals, NR_KEYS) < 0) { LM_ERR("error storing trace\n"); goto error; } #ifdef STATISTICS update_stat(siptrace_rpl, 1); #endif } if(avp==NULL) goto done; trace_send_duplicate(db_vals[0].val.blob_val.s, db_vals[0].val.blob_val.len); db_vals[9].val.str_val.s = avp_value.s.s; db_vals[9].val.str_val.len = avp_value.s.len; LM_DBG("storing info...\n"); if(db_funcs.insert(db_con, db_keys, db_vals, NR_KEYS) < 0) { LM_ERR("error storing trace\n"); goto error; } avp = search_next_avp( avp, &avp_value); while(avp!=NULL) { db_vals[9].val.str_val.s = avp_value.s.s; db_vals[9].val.str_val.len = avp_value.s.len; LM_DBG("storing info ...\n"); if(db_funcs.insert(db_con, db_keys, db_vals, NR_KEYS) < 0) { LM_ERR("error storing trace\n"); goto error; } avp = search_next_avp( avp, &avp_value); } done: return; error: return; }
static int db_restore(void) { ua_pres_t* p= NULL; db_key_t result_cols[19]; db1_res_t *res= NULL; db_row_t *row = NULL; db_val_t *row_vals= NULL; str pres_uri, pres_id; str etag, tuple_id; str watcher_uri, call_id; str to_tag, from_tag, remote_contact; str record_route, contact, extra_headers; int size= 0, i; int n_result_cols= 0; int puri_col,pid_col,expires_col,flag_col,etag_col, desired_expires_col; int watcher_col,callid_col,totag_col,fromtag_col,cseq_col,remote_contact_col; int event_col,contact_col,tuple_col,record_route_col, extra_headers_col; int version_col; if (dbmode==PUA_DB_ONLY) { LM_ERR( "db_restore shouldn't be called in PUA_DB_ONLY mode\n" ); return(-1); } result_cols[puri_col=n_result_cols++] = &str_pres_uri_col; result_cols[pid_col=n_result_cols++] = &str_pres_id_col; result_cols[expires_col=n_result_cols++]= &str_expires_col; result_cols[flag_col=n_result_cols++] = &str_flag_col; result_cols[etag_col=n_result_cols++] = &str_etag_col; result_cols[tuple_col=n_result_cols++] = &str_tuple_id_col; result_cols[watcher_col=n_result_cols++]= &str_watcher_uri_col; result_cols[callid_col=n_result_cols++] = &str_call_id_col; result_cols[totag_col=n_result_cols++] = &str_to_tag_col; result_cols[fromtag_col=n_result_cols++]= &str_from_tag_col; result_cols[cseq_col= n_result_cols++] = &str_cseq_col; result_cols[event_col= n_result_cols++] = &str_event_col; result_cols[record_route_col= n_result_cols++] = &str_record_route_col; result_cols[contact_col= n_result_cols++] = &str_contact_col; result_cols[remote_contact_col= n_result_cols++] = &str_remote_contact_col; result_cols[extra_headers_col= n_result_cols++] = &str_extra_headers_col; result_cols[desired_expires_col= n_result_cols++] = &str_desired_expires_col; result_cols[version_col= n_result_cols++] = &str_version_col; if(!pua_db) { LM_ERR("null database connection\n"); return -1; } if(pua_dbf.use_table(pua_db, &db_table)< 0) { LM_ERR("in use table\n"); return -1; } if(db_fetch_query(&pua_dbf, pua_fetch_rows, pua_db, 0, 0, 0, result_cols, 0, n_result_cols, 0, &res)< 0) { LM_ERR("while querrying table\n"); if(res) { pua_dbf.free_result(pua_db, res); res = NULL; } return -1; } if(res==NULL) return -1; if(res->n<=0) { LM_INFO("the query returned no result\n"); pua_dbf.free_result(pua_db, res); res = NULL; return 0; } do { LM_DBG("found %d db entries\n", res->n); for(i =0 ; i< res->n ; i++) { row = &res->rows[i]; row_vals = ROW_VALUES(row); pres_uri.s= (char*)row_vals[puri_col].val.string_val; pres_uri.len = strlen(pres_uri.s); LM_DBG("pres_uri= %.*s\n", pres_uri.len, pres_uri.s); memset(&etag, 0, sizeof(str)); memset(&tuple_id, 0, sizeof(str)); memset(&watcher_uri, 0, sizeof(str)); memset(&call_id, 0, sizeof(str)); memset(&to_tag, 0, sizeof(str)); memset(&from_tag, 0, sizeof(str)); memset(&record_route, 0, sizeof(str)); memset(&pres_id, 0, sizeof(str)); memset(&contact, 0, sizeof(str)); memset(&remote_contact, 0, sizeof(str)); memset(&extra_headers, 0, sizeof(str)); pres_id.s= (char*)row_vals[pid_col].val.string_val; if(pres_id.s) pres_id.len = strlen(pres_id.s); if(row_vals[etag_col].val.string_val) { etag.s= (char*)row_vals[etag_col].val.string_val; etag.len = strlen(etag.s); tuple_id.s= (char*)row_vals[tuple_col].val.string_val; tuple_id.len = strlen(tuple_id.s); } if(row_vals[watcher_col].val.string_val) { watcher_uri.s= (char*)row_vals[watcher_col].val.string_val; watcher_uri.len = strlen(watcher_uri.s); call_id.s= (char*)row_vals[callid_col].val.string_val; call_id.len = strlen(call_id.s); to_tag.s= (char*)row_vals[totag_col].val.string_val; to_tag.len = strlen(to_tag.s); from_tag.s= (char*)row_vals[fromtag_col].val.string_val; from_tag.len = strlen(from_tag.s); if(row_vals[record_route_col].val.string_val) { record_route.s= (char*)row_vals[record_route_col].val.string_val; record_route.len= strlen(record_route.s); } contact.s= (char*)row_vals[contact_col].val.string_val; contact.len = strlen(contact.s); remote_contact.s= (char*)row_vals[remote_contact_col].val.string_val; remote_contact.len = strlen(remote_contact.s); } extra_headers.s= (char*)row_vals[extra_headers_col].val.string_val; if(extra_headers.s) extra_headers.len= strlen(extra_headers.s); else extra_headers.len= 0; size= sizeof(ua_pres_t)+ sizeof(str)+ (pres_uri.len+ pres_id.len+ tuple_id.len)* sizeof(char); if(extra_headers.s) size+= sizeof(str)+ extra_headers.len* sizeof(char); if(watcher_uri.s) size+= sizeof(str)+ (watcher_uri.len+ call_id.len+ to_tag.len+ from_tag.len+ record_route.len+ contact.len)* sizeof(char); p= (ua_pres_t*)shm_malloc(size); if(p== NULL) { LM_ERR("no more share memmory"); goto error; } memset(p, 0, size); size= sizeof(ua_pres_t); p->pres_uri= (str*)((char*)p+ size); size+= sizeof(str); p->pres_uri->s= (char*)p + size; memcpy(p->pres_uri->s, pres_uri.s, pres_uri.len); p->pres_uri->len= pres_uri.len; size+= pres_uri.len; if(pres_id.s) { p->id.s= (char*)p + size; memcpy(p->id.s, pres_id.s, pres_id.len); p->id.len= pres_id.len; size+= pres_id.len; } if(tuple_id.s && tuple_id.len) { p->tuple_id.s= (char*)p + size; memcpy(p->tuple_id.s, tuple_id.s, tuple_id.len); p->tuple_id.len= tuple_id.len; size+= tuple_id.len; } if(watcher_uri.s && watcher_uri.len) { p->watcher_uri= (str*)((char*)p+ size); size+= sizeof(str); p->watcher_uri->s= (char*)p+ size; memcpy(p->watcher_uri->s, watcher_uri.s, watcher_uri.len); p->watcher_uri->len= watcher_uri.len; size+= watcher_uri.len; p->to_tag.s= (char*)p+ size; memcpy(p->to_tag.s, to_tag.s, to_tag.len); p->to_tag.len= to_tag.len; size+= to_tag.len; p->from_tag.s= (char*)p+ size; memcpy(p->from_tag.s, from_tag.s, from_tag.len); p->from_tag.len= from_tag.len; size+= from_tag.len; p->call_id.s= (char*)p + size; memcpy(p->call_id.s, call_id.s, call_id.len); p->call_id.len= call_id.len; size+= call_id.len; if(record_route.s && record_route.len) { p->record_route.s= (char*)p + size; memcpy(p->record_route.s, record_route.s, record_route.len); p->record_route.len= record_route.len; size+= record_route.len; } p->contact.s= (char*)p + size; memcpy(p->contact.s, contact.s, contact.len); p->contact.len= contact.len; size+= contact.len; p->cseq= row_vals[cseq_col].val.int_val; p->remote_contact.s= (char*)shm_malloc(remote_contact.len* sizeof(char)); if(p->remote_contact.s== NULL) { LM_ERR("No more shared memory\n"); goto error; } memcpy(p->remote_contact.s, remote_contact.s, remote_contact.len); p->remote_contact.len= remote_contact.len; p->version= row_vals[version_col].val.int_val; } if(extra_headers.s) { p->extra_headers= (str*)((char*)p+ size); size+= sizeof(str); p->extra_headers->s= (char*)p+ size; memcpy(p->extra_headers->s, extra_headers.s, extra_headers.len); p->extra_headers->len= extra_headers.len; size+= extra_headers.len; } LM_DBG("size= %d\n", size); p->event= row_vals[event_col].val.int_val; p->expires= row_vals[expires_col].val.int_val; p->desired_expires= row_vals[desired_expires_col].val.int_val; p->flag|= row_vals[flag_col].val.int_val; memset(&p->etag, 0, sizeof(str)); if(etag.s && etag.len) { /* alloc separately */ p->etag.s= (char*)shm_malloc(etag.len* sizeof(char)); if(p->etag.s== NULL) { LM_ERR("no more share memory\n"); goto error; } memcpy(p->etag.s, etag.s, etag.len); p->etag.len= etag.len; } print_ua_pres(p); insert_htable(p); } } while((db_fetch_next(&pua_dbf, pua_fetch_rows, pua_db, &res)==1) && (RES_ROW_N(res)>0)); pua_dbf.free_result(pua_db, res); res = NULL; if(pua_dbf.delete(pua_db, 0, 0 , 0, 0) < 0) { LM_ERR("while deleting information from db\n"); goto error; } return 0; error: if(res) pua_dbf.free_result(pua_db, res); if(p) shm_free(p); return -1; }
static int mod_init(void) { int i; startup_time = (int) time(NULL); kz_json_escape_char = kz_json_escape_str.s[0]; if (dbk_node_hostname.s == NULL) { LM_ERR("You must set the node_hostname parameter\n"); return -1; } dbk_node_hostname.len = strlen(dbk_node_hostname.s); dbk_consumer_event_key.len = strlen(dbk_consumer_event_key.s); dbk_consumer_event_subkey.len = strlen(dbk_consumer_event_subkey.s); if(kz_init_avp()) { LM_ERR("Error in avp params\n"); return -1; } if(!kz_amqp_init()) { return -1; } if(kz_timer_ms > 0) { kz_timer_tv.tv_usec = (kz_timer_ms % 1000) * 1000; kz_timer_tv.tv_sec = kz_timer_ms / 1000; } if(dbk_pua_mode == 1) { kz_db_url.len = kz_db_url.s ? strlen(kz_db_url.s) : 0; LM_DBG("db_url=%s/%d/%p\n", ZSW(kz_db_url.s), kz_db_url.len,kz_db_url.s); kz_presentity_table.len = strlen(kz_presentity_table.s); if(kz_db_url.len > 0) { /* binding to database module */ if (db_bind_mod(&kz_db_url, &kz_pa_dbf)) { LM_ERR("Database module not found\n"); return -1; } if (!DB_CAPABILITY(kz_pa_dbf, DB_CAP_ALL)) { LM_ERR("Database module does not implement all functions" " needed by kazoo module\n"); return -1; } kz_pa_db = kz_pa_dbf.init(&kz_db_url); if (!kz_pa_db) { LM_ERR("Connection to database failed\n"); return -1; } kz_pa_dbf.close(kz_pa_db); kz_pa_db = NULL; } } int total_workers = dbk_consumer_workers + (dbk_consumer_processes * kz_server_counter) + 2; register_procs(total_workers); cfg_register_child(total_workers); if (pipe(kz_cmd_pipe_fds) < 0) { LM_ERR("cmd pipe() failed\n"); return -1; } kz_worker_pipes_fds = (int*) shm_malloc(sizeof(int) * (dbk_consumer_workers) * 2 ); kz_worker_pipes = (int*) shm_malloc(sizeof(int) * dbk_consumer_workers); for(i=0; i < dbk_consumer_workers; i++) { kz_worker_pipes_fds[i*2] = kz_worker_pipes_fds[i*2+1] = -1; if (pipe(&kz_worker_pipes_fds[i*2]) < 0) { LM_ERR("worker pipe(%d) failed\n", i); return -1; } } kz_cmd_pipe = kz_cmd_pipe_fds[1]; for(i=0; i < dbk_consumer_workers; i++) { kz_worker_pipes[i] = kz_worker_pipes_fds[i*2+1]; } return 0; }
/* synchronize backend with the db */ static void update_db_handler(unsigned int ticks, void* param) { /* data */ table_entry_t *head_table; table_entry_value_t *value; table_entry_info_t *info; /* columns to be compared ( clusterer_id_col ) */ db_key_t key_cmp; /* with values */ db_val_t val_cmp; /* columns to be set */ db_key_t key_set[3]; /* with values */ db_val_t val_set[3]; int i; CON_OR_RESET(db_hdl); /* table to use*/ if (dr_dbf.use_table(db_hdl, &db_table) < 0) { LM_ERR("cannot select table \"%.*s\"\n", db_table.len, db_table.s); return; } val_cmp.type = DB_INT; val_cmp.nul = 0; for (i = 0; i < 2; ++i) { val_set[i].type = DB_INT; val_set[i].nul = 0; } val_set[2].type = DB_BIGINT; val_set[2].nul = 0; key_cmp = &id_col; key_set[0] = &state_col; key_set[1] = &no_tries_col; key_set[2] = &last_attempt_col; lock_start_write(ref_lock); head_table = *tdata; /* iterating through backend storage to find all data that * must be synchronized with the db */ while (head_table != NULL) { info = head_table->info; while (info != NULL) { value = info->value; while (value != NULL) { if (value->dirty_bit == 1) { LM_DBG("setting row with primary key %d the status %d\n", value->id, value->state); val_cmp.val.int_val = value->id; val_set[0].val.int_val = value->state; val_set[1].val.int_val = value->no_tries; val_set[2].val.int_val = value->last_attempt; /* updating */ if (dr_dbf.update(db_hdl, &key_cmp, &op_eq, &val_cmp, key_set, val_set, 1, 3) < 0) { LM_ERR("DB update failed\n"); } else { /* only if the query is successful the data is synchronized */ value->dirty_bit = 0; } } value = value->next; } info = info->next; } head_table = head_table->next; } lock_stop_write(ref_lock); }
static int mod_init(void) { int heartbeats_timer_interval; cluster_info_t *cl; LM_INFO("Clusterer module - initializing\n"); db_table.len = strlen(db_table.s); id_col.len = strlen(id_col.s); cluster_id_col.len = strlen(cluster_id_col.s); node_id_col.len = strlen(node_id_col.s); url_col.len = strlen(url_col.s); state_col.len = strlen(state_col.s); no_ping_retries_col.len = strlen(no_ping_retries_col.s); priority_col.len = strlen(priority_col.s); sip_addr_col.len = strlen(sip_addr_col.s); flags_col.len = strlen(flags_col.s); description_col.len = strlen(description_col.s); /* only allow the DB URL to be skipped in "P2P discovery" mode */ init_db_url(clusterer_db_url, db_mode == 0); if (current_id < 1) { LM_CRIT("Invalid 'my_node_id' parameter\n"); return -1; } if (ping_interval <= 0) { LM_WARN("Invalid ping_interval parameter, using default value\n"); ping_interval = DEFAULT_PING_INTERVAL; } if (node_timeout < 0) { LM_WARN("Invalid node_timeout parameter, using default value\n"); node_timeout = DEFAULT_NODE_TIMEOUT; } if (ping_timeout <= 0) { LM_WARN("Invalid ping_timeout parameter, using default value\n"); ping_timeout = DEFAULT_PING_TIMEOUT; } /* create & init lock */ if ((cl_list_lock = lock_init_rw()) == NULL) { LM_CRIT("Failed to init lock\n"); return -1; } /* data pointer in shm */ if (cluster_list == NULL) { cluster_list = shm_malloc(sizeof *cluster_list); if (!cluster_list) { LM_CRIT("No more shm memory\n"); goto error; } *cluster_list = NULL; } else { /* sanity check of my_node_id if node_id also set in a my_node_info param */ for (cl = *cluster_list; cl; cl = cl->next) if (cl->current_node->node_id != current_id) { LM_ERR("Bad 'my_node_id' parameter, value: %d different than" " the node_id property in the 'my_node_info' parameter\n", current_id); goto error; } } if (db_mode) { /* bind to the mysql module */ if (db_bind_mod(&clusterer_db_url, &dr_dbf)) { LM_CRIT("Cannot bind to database module! " "Did you forget to load a database module ?\n"); goto error; } if (!DB_CAPABILITY(dr_dbf, DB_CAP_QUERY)) { LM_CRIT("Given SQL DB does not provide query types needed by this module!\n"); goto error; } /* init DB connection */ if ((db_hdl = dr_dbf.init(&clusterer_db_url)) == 0) { LM_ERR("cannot initialize database connection\n"); goto error; } if (load_db_info(&dr_dbf, db_hdl, &db_table, cluster_list) < 0) { LM_ERR("Failed to load info from DB\n"); goto error; } } /* register timer */ heartbeats_timer_interval = gcd(ping_interval*1000, ping_timeout); heartbeats_timer_interval = gcd(heartbeats_timer_interval, node_timeout*1000); if (heartbeats_timer_interval % 1000 == 0) { if (register_timer("clstr-heartbeats-timer", heartbeats_timer_handler, NULL, heartbeats_timer_interval/1000, TIMER_FLAG_DELAY_ON_DELAY) < 0) { LM_CRIT("Unable to register clusterer heartbeats timer\n"); goto error; } } else { if (register_utimer("clstr-heartbeats-utimer", heartbeats_utimer_handler, NULL, heartbeats_timer_interval*1000, TIMER_FLAG_DELAY_ON_DELAY) < 0) { LM_CRIT("Unable to register clusterer heartbeats timer\n"); goto error; } } if (bin_register_cb(&cl_internal_cap, bin_rcv_cl_packets, NULL) < 0) { LM_CRIT("Cannot register clusterer binary packet callback!\n"); goto error; } if (bin_register_cb(&cl_extra_cap, bin_rcv_cl_extra_packets, NULL) < 0) { LM_CRIT("Cannot register extra clusterer binary packet callback!\n"); goto error; } /* create generic message receiving events */ if (gen_rcv_evs_init() < 0) { LM_ERR("cannot create cluster message received event\n"); return -1; } return 0; error: lock_destroy_rw(cl_list_lock); cl_list_lock = NULL; if (cluster_list) { shm_free(cluster_list); cluster_list = 0; } return -1; }
/** Module init function */ static int mod_init(void) { char* p = NULL; char* flags = NULL; int regexp_flags = 0; int i = 0, j; pv_spec_t avp_spec; LM_DBG("start\n"); /* load b2b_entities api */ if(load_b2b_api(&b2b_api)< 0) { LM_ERR("Failed to load b2b api\n"); return -1; } if(b2bl_hsize< 1 || b2bl_hsize> 20) { LM_ERR("Wrong hash size. Needs to be greater than 1" " and smaller than 20. Be aware that you should set the log 2" " value of the real size\n"); return -1; } b2bl_hsize = 1<<b2bl_hsize; if(server_address.s == NULL) { if(extern_scenarios) { LM_ERR("'server_address' parameter not set. This parameter is" " compulsory if you want to use extern scenarios. It must" " be set to the IP address of the machine\n"); return -1; } } else server_address.len = strlen(server_address.s); if(init_b2bl_htable() < 0) { LM_ERR("Failed to initialize b2b logic hash table\n"); return -1; } if(b2b_clean_period < 0) { LM_ERR("Wrong parameter - b2b_clean_period [%d]\n", b2b_clean_period); return -1; } if(b2b_update_period < 0) { LM_ERR("Wrong parameter - b2b_update_period [%d]\n", b2b_update_period); return -1; } if(b2bl_db_mode && db_url.s) { db_url.len = strlen(db_url.s); b2bl_dbtable.len = strlen(b2bl_dbtable.s); /* binding to database module */ if (db_bind_mod(&db_url, &b2bl_dbf)) { LM_ERR("Database module not found\n"); return -1; } if (!DB_CAPABILITY(b2bl_dbf, DB_CAP_ALL)) { LM_ERR("Database module does not implement all functions" " needed by b2b_entities module\n"); return -1; } b2bl_db = b2bl_dbf.init(&db_url); if(!b2bl_db) { LM_ERR("connecting to database failed\n"); return -1; } /*verify table versions */ if(db_check_table_version(&b2bl_dbf, b2bl_db, &b2bl_dbtable, TABLE_VERSION) < 0) { LM_ERR("error during table version check\n"); return -1; } b2bl_db_init(); /* reload data */ if(b2b_logic_restore() < 0) { LM_ERR("Failed to restore data from database\n"); return -1; } if(b2bl_db) b2bl_dbf.close(b2bl_db); b2bl_db = NULL; } else b2bl_db_mode = 0; if (b2bl_key_avp_param.s) b2bl_key_avp_param.len = strlen(b2bl_key_avp_param.s); if (b2bl_key_avp_param.s && b2bl_key_avp_param.len > 0) { if (pv_parse_spec(&b2bl_key_avp_param, &avp_spec)==0 || avp_spec.type!=PVT_AVP) { LM_ERR("malformed or non AVP %.*s AVP definition\n", b2bl_key_avp_param.len, b2bl_key_avp_param.s); return -1; } if (pv_get_avp_name(0, &(avp_spec.pvp), &b2bl_key_avp_name, &b2bl_key_avp_type)!=0){ LM_ERR("[%.*s]- invalid AVP definition\n", b2bl_key_avp_param.len, b2bl_key_avp_param.s); return -1; } } else { b2bl_key_avp_name = -1; b2bl_key_avp_type = 0; } if(b2bl_from_spec_param.s) { b2bl_from_spec_param.len = strlen(b2bl_from_spec_param.s); if(pv_parse_spec(&b2bl_from_spec_param, &b2bl_from_spec)==NULL) { LM_ERR("failed to parse b2bl_from spec\n"); return E_CFG; } switch(b2bl_from_spec.type) { case PVT_NONE: case PVT_EMPTY: case PVT_NULL: case PVT_MARKER: case PVT_COLOR: LM_ERR("invalid b2bl_from spec\n"); return -1; default: ; } } /* parse extra headers */ if(custom_headers.s) custom_headers.len = strlen(custom_headers.s); memset(custom_headers_lst, 0, HDR_LST_LEN*sizeof(str)); custom_headers_lst[i].s = custom_headers.s; if(custom_headers.s) { p = strchr(custom_headers.s, ';'); while(p) { custom_headers_lst[i].len = p - custom_headers_lst[i].s; /* check if this is among the default headers */ for(j = 0; j< HDR_DEFAULT_LEN; j++) { if(custom_headers_lst[i].len == default_headers[j].len && strncmp(custom_headers_lst[i].s, default_headers[j].s, default_headers[j].len)== 0) goto next_hdr; } /* check if defined twice */ for(j = 0; j< i; j++) { if(custom_headers_lst[i].len == custom_headers_lst[j].len && strncmp(custom_headers_lst[i].s, custom_headers_lst[j].s, custom_headers_lst[j].len)== 0) goto next_hdr; } i++; if(i == HDR_LST_LEN) { LM_ERR("Too many extra headers defined." " The maximum value is %d\n.", HDR_LST_LEN); return -1; } next_hdr: p++; if(p-custom_headers.s >= custom_headers.len) break; custom_headers_lst[i].s = p; p = strchr(p, ';'); } } if(p == NULL) { custom_headers_lst[i].len = custom_headers.s + custom_headers.len - custom_headers_lst[i].s; if(custom_headers_lst[i].len == 0) i--; } custom_headers_lst_len = i +1; if(custom_headers_regexp.s) { custom_headers_regexp.len = strlen(custom_headers_regexp.s); if ((custom_headers_re=pkg_malloc(sizeof(regex_t)))==0) { LM_ERR("no more pkg memory\n"); return -1; } if (*custom_headers_regexp.s == '/') { flags = (char *)memchr(custom_headers_regexp.s+1, '/', custom_headers_regexp.len-1); if (flags) { custom_headers_regexp.s++; custom_headers_regexp.len = flags - custom_headers_regexp.s; custom_headers_regexp.s[custom_headers_regexp.len] = '\0'; flags++; while(*flags != '\0') { switch (*flags) { case 'i': regexp_flags |= REG_ICASE; break; case 'e': regexp_flags |= REG_EXTENDED; break; default: LM_ERR("Unknown option '%c'\n", *flags); } flags++; } } else { LM_ERR("Second '/' missing from regexp\n"); return -1; } } if (regcomp(custom_headers_re, custom_headers_regexp.s, regexp_flags) != 0) { pkg_free(custom_headers_re); LM_ERR("bad regexp '%.*s'\n", custom_headers_regexp.len, custom_headers_regexp.s); return -1; } } if(init_callid_hdr.s) init_callid_hdr.len = strlen(init_callid_hdr.s); register_timer("b2bl-clean", b2bl_clean, 0, b2b_clean_period, TIMER_FLAG_DELAY_ON_DELAY); if(b2bl_db_mode == WRITE_BACK) register_timer("b2bl-dbupdate", b2bl_db_timer_update, 0, b2b_update_period, TIMER_FLAG_SKIP_ON_DELAY); return 0; }
static int mod_init(void) { pv_spec_t avp_spec; int i; init_db_url( db_url , 0 /*cannot be null*/); siptrace_table.len = strlen(siptrace_table.s); date_column.len = strlen(date_column.s); callid_column.len = strlen(callid_column.s); traced_user_column.len = strlen(traced_user_column.s); msg_column.len = strlen(msg_column.s); method_column.len = strlen(method_column.s); status_column.len = strlen(status_column.s); fromproto_column.len = strlen(fromproto_column.s); fromip_column.len = strlen(fromip_column.s); fromport_column.len = strlen(fromport_column.s); toproto_column.len = strlen(toproto_column.s); toip_column.len = strlen(toip_column.s); toport_column.len = strlen(toport_column.s); fromtag_column.len = strlen(fromtag_column.s); direction_column.len = strlen(direction_column.s); if (traced_user_avp_str.s) traced_user_avp_str.len = strlen(traced_user_avp_str.s); if (trace_table_avp_str.s) trace_table_avp_str.len = strlen(trace_table_avp_str.s); if (dup_uri_str.s) dup_uri_str.len = strlen(dup_uri_str.s); if (trace_local_ip.s) parse_trace_local_ip(); LM_INFO("initializing...\n"); fix_flag_name(trace_flag_str, trace_flag); trace_flag = get_flag_id_by_name(FLAG_TYPE_MSG, trace_flag_str); if (flag_idx2mask(&trace_flag)<0) return -1; trace_to_database_flag = (int*)shm_malloc(sizeof(int)); if(trace_to_database_flag==NULL) { LM_ERR("no more shm memory left\n"); return -1; } *trace_to_database_flag = trace_to_database; if(trace_to_database_flag!=NULL && *trace_to_database_flag!=0) { /* Find a database module */ if (db_bind_mod(&db_url, &db_funcs)) { LM_ERR("unable to bind database module\n"); return -1; } if (trace_to_database_flag && !DB_CAPABILITY(db_funcs, DB_CAP_INSERT)) { LM_ERR("database modules does not provide all functions needed by module\n"); return -1; } if ((db_con = db_funcs.init(&db_url)) == 0) { LM_CRIT("Cannot connect to DB\n"); return -1; } if(db_check_table_version(&db_funcs, db_con, &siptrace_table, SIPTRACE_TABLE_VERSION) < 0) { LM_ERR("error during table version check.\n"); return -1; } db_funcs.close(db_con); db_con = 0; } trace_on_flag = (int*)shm_malloc(sizeof(int)); if(trace_on_flag==NULL) { LM_ERR("no more shm memory left\n"); return -1; } *trace_on_flag = trace_on; /* register callbacks to TM */ if (load_tm_api(&tmb)!=0) { LM_ERR("can't load tm api\n"); return -1; } if(tmb.register_tmcb( 0, 0, TMCB_REQUEST_IN, trace_onreq_in, 0, 0) <=0) { LM_ERR("can't register trace_onreq_in\n"); return -1; } /* register sl callback */ register_slcb_f = (register_slcb_t)find_export("register_slcb", 0, 0); if(register_slcb_f==NULL) { LM_ERR("can't load sl api\n"); return -1; } if(register_slcb_f(SLCB_REPLY_OUT,trace_sl_onreply_out, NULL)!=0) { LM_ERR("can't register trace_sl_onreply_out\n"); return -1; } if(register_fwdcb(trace_msg_out_w)!=0) { LM_ERR("can't register trace_sl_ack_out\n"); return -1; } if(enable_ack_trace&®ister_slcb_f(SLCB_ACK_IN,trace_sl_ack_in,NULL)!=0) { LM_ERR("can't register trace_sl_ack_in\n"); return -1; } if(dup_uri_str.s!=0) { dup_uri_str.len = strlen(dup_uri_str.s); dup_uri = (struct sip_uri *)pkg_malloc(sizeof(struct sip_uri)); if(dup_uri==0) { LM_ERR("no more pkg memory left\n"); return -1; } memset(dup_uri, 0, sizeof(struct sip_uri)); if(parse_uri(dup_uri_str.s, dup_uri_str.len, dup_uri)<0) { LM_ERR("bad dup uri\n"); return -1; } } if(traced_user_avp_str.s && traced_user_avp_str.len > 0) { if (pv_parse_spec(&traced_user_avp_str, &avp_spec)==0 || avp_spec.type!=PVT_AVP) { LM_ERR("malformed or non AVP %.*s AVP definition\n", traced_user_avp_str.len, traced_user_avp_str.s); return -1; } if(pv_get_avp_name(0, &avp_spec.pvp, &traced_user_avp, &traced_user_avp_type)!=0) { LM_ERR("[%.*s] - invalid AVP definition\n", traced_user_avp_str.len, traced_user_avp_str.s); return -1; } } else { traced_user_avp = -1; traced_user_avp_type = 0; } if(trace_table_avp_str.s && trace_table_avp_str.len > 0) { if (pv_parse_spec(&trace_table_avp_str, &avp_spec)==0 || avp_spec.type!=PVT_AVP) { LM_ERR("malformed or non AVP %.*s AVP definition\n", trace_table_avp_str.len, trace_table_avp_str.s); return -1; } if(pv_get_avp_name(0, &avp_spec.pvp, &trace_table_avp, &trace_table_avp_type)!=0) { LM_ERR("[%.*s] - invalid AVP definition\n" , trace_table_avp_str.len, trace_table_avp_str.s); return -1; } } else { trace_table_avp = -1; trace_table_avp_type = 0; } if (duplicate_with_hep) { load_hep = (load_hep_f)find_export("load_hep", 1, 0); if (!load_hep) { LM_ERR("Can't bind proto hep!\n"); return -1; } if (load_hep(&hep_api)) { LM_ERR("can't bind proto hep\n"); return -1; } } /* init the DB keys for future queries */ db_keys[0] = &msg_column; db_keys[1] = &callid_column; db_keys[2] = &method_column; db_keys[3] = &status_column; db_keys[4] = &fromproto_column; db_keys[5] = &fromip_column; db_keys[6] = &fromport_column; db_keys[7] = &toproto_column; db_keys[8] = &toip_column; db_keys[9] = &toport_column; db_keys[10] = &date_column; db_keys[11] = &direction_column; db_keys[12] = &fromtag_column; db_keys[13] = &traced_user_column; /* init DB values info which is constant ( type, null ) */ db_vals[0].type = DB_BLOB; db_vals[1].type = DB_STR; db_vals[2].type = DB_STR; db_vals[3].type = DB_STR; db_vals[4].type = DB_STR; db_vals[5].type = DB_STR; db_vals[6].type = DB_INT; db_vals[7].type = DB_STR; db_vals[8].type = DB_STR; db_vals[9].type = DB_INT; db_vals[10].type = DB_DATETIME; db_vals[11].type = DB_STRING; db_vals[12].type = DB_STR; db_vals[13].type = DB_STR; /* no field can be null */ for (i=0;i<NR_KEYS;i++) db_vals[i].nul = 0; return 0; }
int update_watchers_status(str pres_uri, pres_ev_t* ev, str* rules_doc) { subs_t subs; db_key_t query_cols[6], result_cols[5]; db_val_t query_vals[6]; int n_result_cols= 0, n_query_cols = 0; db1_res_t* result= NULL; db_row_t *row; db_val_t *row_vals ; int i; str w_user, w_domain, reason= {0, 0}; unsigned int status; int status_col, w_user_col, w_domain_col, reason_col; subs_t* subs_array= NULL,* s; unsigned int hash_code; int err_ret= -1; int n= 0; typedef struct ws { int status; str reason; str w_user; str w_domain; }ws_t; ws_t* ws_list= NULL; LM_DBG("start\n"); if(ev->content_type.s== NULL) { ev= contains_event(&ev->name, NULL); if(ev== NULL) { LM_ERR("wrong event parameter\n"); return 0; } } memset(&subs, 0, sizeof(subs_t)); subs.pres_uri= pres_uri; subs.event= ev; subs.auth_rules_doc= rules_doc; /* update in watchers_table */ query_cols[n_query_cols]= &str_presentity_uri_col; query_vals[n_query_cols].nul= 0; query_vals[n_query_cols].type= DB1_STR; query_vals[n_query_cols].val.str_val= pres_uri; n_query_cols++; query_cols[n_query_cols]= &str_event_col; query_vals[n_query_cols].nul= 0; query_vals[n_query_cols].type= DB1_STR; query_vals[n_query_cols].val.str_val= ev->name; n_query_cols++; result_cols[status_col= n_result_cols++]= &str_status_col; result_cols[reason_col= n_result_cols++]= &str_reason_col; result_cols[w_user_col= n_result_cols++]= &str_watcher_username_col; result_cols[w_domain_col= n_result_cols++]= &str_watcher_domain_col; if (pa_dbf.use_table(pa_db, &watchers_table) < 0) { LM_ERR( "in use_table\n"); goto done; } if(pa_dbf.query(pa_db, query_cols, 0, query_vals, result_cols,n_query_cols, n_result_cols, 0, &result)< 0) { LM_ERR( "in sql query\n"); goto done; } if(result== NULL) return 0; if(result->n<= 0) { err_ret= 0; goto done; } LM_DBG("found %d record-uri in watchers_table\n", result->n); hash_code= core_case_hash(&pres_uri, &ev->name, shtable_size); subs.db_flag= hash_code; /*must do a copy as sphere_check requires database queries */ if(sphere_enable) { n= result->n; ws_list= (ws_t*)pkg_malloc(n * sizeof(ws_t)); if(ws_list== NULL) { LM_ERR("No more private memory\n"); goto done; } memset(ws_list, 0, n * sizeof(ws_t)); for(i= 0; i< result->n ; i++) { row= &result->rows[i]; row_vals = ROW_VALUES(row); status= row_vals[status_col].val.int_val; reason.s= (char*)row_vals[reason_col].val.string_val; reason.len= reason.s?strlen(reason.s):0; w_user.s= (char*)row_vals[w_user_col].val.string_val; w_user.len= strlen(w_user.s); w_domain.s= (char*)row_vals[w_domain_col].val.string_val; w_domain.len= strlen(w_domain.s); if(reason.len) { ws_list[i].reason.s = (char*)pkg_malloc(reason.len* sizeof(char)); if(ws_list[i].reason.s== NULL) { LM_ERR("No more private memory\n"); goto done; } memcpy(ws_list[i].reason.s, reason.s, reason.len); ws_list[i].reason.len= reason.len; } else ws_list[i].reason.s= NULL; ws_list[i].w_user.s = (char*)pkg_malloc(w_user.len* sizeof(char)); if(ws_list[i].w_user.s== NULL) { LM_ERR("No more private memory\n"); goto done; } memcpy(ws_list[i].w_user.s, w_user.s, w_user.len); ws_list[i].w_user.len= w_user.len; ws_list[i].w_domain.s = (char*)pkg_malloc(w_domain.len* sizeof(char)); if(ws_list[i].w_domain.s== NULL) { LM_ERR("No more private memory\n"); goto done; } memcpy(ws_list[i].w_domain.s, w_domain.s, w_domain.len); ws_list[i].w_domain.len= w_domain.len; ws_list[i].status= status; } pa_dbf.free_result(pa_db, result); result= NULL; for(i=0; i< n; i++) { subs.watcher_user = ws_list[i].w_user; subs.watcher_domain = ws_list[i].w_domain; subs.status = ws_list[i].status; memset(&subs.reason, 0, sizeof(str)); if( pres_update_status(subs, reason, query_cols, query_vals, n_query_cols, &subs_array)< 0) { LM_ERR("failed to update watcher status\n"); goto done; } } for(i=0; i< n; i++) { pkg_free(ws_list[i].w_user.s); pkg_free(ws_list[i].w_domain.s); if(ws_list[i].reason.s) pkg_free(ws_list[i].reason.s); } ws_list= NULL; goto send_notify; } for(i = 0; i< result->n; i++) { row= &result->rows[i]; row_vals = ROW_VALUES(row); status= row_vals[status_col].val.int_val; reason.s= (char*)row_vals[reason_col].val.string_val; reason.len= reason.s?strlen(reason.s):0; w_user.s= (char*)row_vals[w_user_col].val.string_val; w_user.len= strlen(w_user.s); w_domain.s= (char*)row_vals[w_domain_col].val.string_val; w_domain.len= strlen(w_domain.s); subs.watcher_user= w_user; subs.watcher_domain= w_domain; subs.status= status; memset(&subs.reason, 0, sizeof(str)); if( pres_update_status(subs,reason, query_cols, query_vals, n_query_cols, &subs_array)< 0) { LM_ERR("failed to update watcher status\n"); goto done; } } pa_dbf.free_result(pa_db, result); result= NULL; send_notify: if (pres_notifier_processes == 0) { s= subs_array; while(s) { if(notify(s, NULL, NULL, 0)< 0) { LM_ERR( "sending Notify request\n"); goto done; } /* delete from database also */ if(s->status== TERMINATED_STATUS) { if(pres_db_delete_status(s)<0) { LM_ERR("failed to delete terminated " "dialog from database\n"); goto done; } } s= s->next; } } free_subs_list(subs_array, PKG_MEM_TYPE, 0); return 0; done: if(result) pa_dbf.free_result(pa_db, result); free_subs_list(subs_array, PKG_MEM_TYPE, 0); if(ws_list) { for(i= 0; i< n; i++) { if(ws_list[i].w_user.s) pkg_free(ws_list[i].w_user.s); else break; if(ws_list[i].w_domain.s) pkg_free(ws_list[i].w_domain.s); if(ws_list[i].reason.s) pkg_free(ws_list[i].reason.s); } } return err_ret; }
/* * Closes the DB connection. */ void matrix_db_close(void) { if (matrix_dbh) { matrix_dbf.close(matrix_dbh); matrix_dbh = NULL; } }
/** * Initialize children */ static int child_init(int rank) { if (rank==PROC_INIT || rank==PROC_TCP_MAIN) return 0; pid = my_pid(); if(library_mode) return 0; if (rank == PROC_MAIN) { int i; for (i = 0; i < pres_notifier_processes; i++) { char tmp[21]; snprintf(tmp, 21, "PRESENCE NOTIFIER %d", i); pres_notifier_id[i] = i; if (fork_basic_utimer(PROC_TIMER, tmp, 1, pres_timer_send_notify, &pres_notifier_id[i], 1000000/pres_notifier_poll_rate) < 0) { LM_ERR("Failed to start PRESENCE NOTIFIER %d\n", i); return -1; } } return 0; } if (pa_dbf.init==0) { LM_CRIT("child_init: database not bound\n"); return -1; } /* Do not pool the connections where possible when running notifier processes. */ if (pres_notifier_processes > 0 && pa_dbf.init2) pa_db = pa_dbf.init2(&db_url, DB_POOLING_NONE); else pa_db = pa_dbf.init(&db_url); if (!pa_db) { LM_ERR("child %d: unsuccessful connecting to database\n", rank); return -1; } if (pa_dbf.use_table(pa_db, &presentity_table) < 0) { LM_ERR( "child %d:unsuccessful use_table presentity_table\n", rank); return -1; } if (pa_dbf.use_table(pa_db, &active_watchers_table) < 0) { LM_ERR( "child %d:unsuccessful use_table active_watchers_table\n", rank); return -1; } if (pa_dbf.use_table(pa_db, &watchers_table) < 0) { LM_ERR( "child %d:unsuccessful use_table watchers_table\n", rank); return -1; } LM_DBG("child %d: Database connection opened successfully\n", rank); return 0; }
int pres_update_status(subs_t subs, str reason, db_key_t* query_cols, db_val_t* query_vals, int n_query_cols, subs_t** subs_array) { db_key_t update_cols[5]; db_val_t update_vals[5]; int n_update_cols= 0; int u_status_col, u_reason_col, q_wuser_col, q_wdomain_col; int status; query_cols[q_wuser_col=n_query_cols]= &str_watcher_username_col; query_vals[n_query_cols].nul= 0; query_vals[n_query_cols].type= DB1_STR; n_query_cols++; query_cols[q_wdomain_col=n_query_cols]= &str_watcher_domain_col; query_vals[n_query_cols].nul= 0; query_vals[n_query_cols].type= DB1_STR; n_query_cols++; update_cols[u_status_col= n_update_cols]= &str_status_col; update_vals[u_status_col].nul= 0; update_vals[u_status_col].type= DB1_INT; n_update_cols++; update_cols[u_reason_col= n_update_cols]= &str_reason_col; update_vals[u_reason_col].nul= 0; update_vals[u_reason_col].type= DB1_STR; n_update_cols++; status= subs.status; if(subs.event->get_auth_status(&subs)< 0) { LM_ERR( "getting status from rules document\n"); return -1; } LM_DBG("subs.status= %d\n", subs.status); if(get_status_str(subs.status)== NULL) { LM_ERR("wrong status: %d\n", subs.status); return -1; } if(subs.status!= status || reason.len!= subs.reason.len || (reason.s && subs.reason.s && strncmp(reason.s, subs.reason.s, reason.len))) { /* update in watchers_table */ query_vals[q_wuser_col].val.str_val= subs.watcher_user; query_vals[q_wdomain_col].val.str_val= subs.watcher_domain; update_vals[u_status_col].val.int_val= subs.status; update_vals[u_reason_col].val.str_val= subs.reason; if (pa_dbf.use_table(pa_db, &watchers_table) < 0) { LM_ERR( "in use_table\n"); return -1; } if(pa_dbf.update(pa_db, query_cols, 0, query_vals, update_cols, update_vals, n_query_cols, n_update_cols)< 0) { LM_ERR( "in sql update\n"); return -1; } /* save in the list all affected dialogs */ /* if status switches to terminated -> delete dialog */ if(update_pw_dialogs(&subs, subs.db_flag, subs_array)< 0) { LM_ERR( "extracting dialogs from [watcher]=%.*s@%.*s to" " [presentity]=%.*s\n", subs.watcher_user.len, subs.watcher_user.s, subs.watcher_domain.len, subs.watcher_domain.s, subs.pres_uri.len, subs.pres_uri.s); return -1; } } return 0; }
/** * init module function */ static int mod_init(void) { if(pres_uri_match == 1) { presence_sip_uri_match = sip_uri_case_insensitive_match; } else { presence_sip_uri_match = sip_uri_case_sensitive_match; } if(register_mi_mod(exports.name, mi_cmds)!=0) { LM_ERR("failed to register MI commands\n"); return -1; } if(presence_init_rpc()!=0) { LM_ERR("failed to register RPC commands\n"); return -1; } LM_DBG("db_url=%s/%d/%p\n", ZSW(db_url.s), db_url.len,db_url.s); if(db_url.s== NULL) library_mode= 1; EvList= init_evlist(); if(!EvList){ LM_ERR("unsuccessful initialize event list\n"); return -1; } if(library_mode== 1) { LM_DBG("Presence module used for API library purpose only\n"); return 0; } if(expires_offset<0) expires_offset = 0; if(to_tag_pref==NULL || strlen(to_tag_pref)==0) to_tag_pref="10"; if(max_expires<= 0) max_expires = 3600; if(min_expires < 0) min_expires = 0; if(min_expires > max_expires) min_expires = max_expires; if(min_expires_action < 1 || min_expires_action > 2) { LM_ERR("min_expires_action must be 1 = RFC 6665/3261 Reply 423, 2 = force min_expires value\n"); return -1; } if(server_address.s== NULL) LM_DBG("server_address parameter not set in configuration file\n"); /* bind the SL API */ if (sl_load_api(&slb)!=0) { LM_ERR("cannot bind to SL API\n"); return -1; } /* load all TM stuff */ if(load_tm_api(&tmb)==-1) { LM_ERR("Can't load tm functions. Module TM not loaded?\n"); return -1; } if(db_url.s== NULL) { LM_ERR("database url not set!\n"); return -1; } /* binding to database module */ if (db_bind_mod(&db_url, &pa_dbf)) { LM_ERR("Database module not found\n"); return -1; } if (!DB_CAPABILITY(pa_dbf, DB_CAP_ALL)) { LM_ERR("Database module does not implement all functions" " needed by presence module\n"); return -1; } pa_db = pa_dbf.init(&db_url); if (!pa_db) { LM_ERR("Connection to database failed\n"); return -1; } /*verify table versions */ if((db_check_table_version(&pa_dbf, pa_db, &presentity_table, P_TABLE_VERSION) < 0) || (db_check_table_version(&pa_dbf, pa_db, &watchers_table, S_TABLE_VERSION) < 0)) { LM_ERR("error during table version check\n"); return -1; } if(subs_dbmode != NO_DB && db_check_table_version(&pa_dbf, pa_db, &active_watchers_table, ACTWATCH_TABLE_VERSION) < 0) { LM_ERR("wrong table version for %s\n", active_watchers_table.s); return -1; } if(subs_dbmode != DB_ONLY) { if(shtable_size< 1) shtable_size= 512; else shtable_size= 1<< shtable_size; subs_htable= new_shtable(shtable_size); if(subs_htable== NULL) { LM_ERR(" initializing subscribe hash table\n"); return -1; } if(restore_db_subs()< 0) { LM_ERR("restoring subscribe info from database\n"); return -1; } } if(publ_cache_enabled) { if(phtable_size< 1) phtable_size= 256; else phtable_size= 1<< phtable_size; pres_htable= new_phtable(); if(pres_htable== NULL) { LM_ERR("initializing presentity hash table\n"); return -1; } if(pres_htable_restore()< 0) { LM_ERR("filling in presentity hash table from database\n"); return -1; } } startup_time = (int) time(NULL); if(clean_period>0) { register_timer(msg_presentity_clean, 0, clean_period); register_timer(msg_watchers_clean, 0, clean_period); } if(db_update_period>0) register_timer(timer_db_update, 0, db_update_period); if (pres_waitn_time <= 0) pres_waitn_time = 5; if (pres_notifier_poll_rate <= 0) pres_notifier_poll_rate = 10; if (pres_notifier_processes < 0 || subs_dbmode != DB_ONLY) pres_notifier_processes = 0; if (pres_notifier_processes > 0) { if ((pres_notifier_id = shm_malloc(sizeof(int) * pres_notifier_processes)) == NULL) { LM_ERR("allocating shared memory\n"); return -1; } register_basic_timers(pres_notifier_processes); } if (db_table_lock_type != 1) db_table_lock = DB_LOCKING_NONE; pa_dbf.close(pa_db); pa_db = NULL; return 0; }
static int update_pw_dialogs_dbonlymode(subs_t* subs, subs_t** subs_array) { db_key_t query_cols[5], db_cols[3]; db_val_t query_vals[5], db_vals[3]; db_key_t result_cols[24]; int n_query_cols=0, n_result_cols=0, n_update_cols=0; int event_col, pres_uri_col, watcher_user_col, watcher_domain_col; int r_pres_uri_col,r_to_user_col,r_to_domain_col; int r_from_user_col,r_from_domain_col,r_callid_col; int r_to_tag_col,r_from_tag_col,r_sockinfo_col; int r_event_id_col,r_local_contact_col,r_contact_col; int r_record_route_col, r_reason_col; int r_event_col, r_local_cseq_col, r_remote_cseq_col; int r_status_col, r_version_col; int r_expires_col, r_watcher_user_col, r_watcher_domain_col; db1_res_t *result= NULL; db_val_t *row_vals; db_row_t *rows; int nr_rows, loop; subs_t s, *cs; str ev_sname; if(pa_db == NULL) { LM_ERR("null database connection\n"); return(-1); } if (pa_dbf.use_table(pa_db, &active_watchers_table) < 0) { LM_ERR("use table failed\n"); return(-1); } query_cols[event_col=n_query_cols]= &str_event_col; query_vals[event_col].nul= 0; query_vals[event_col].type= DB1_STR; query_vals[event_col].val.str_val= subs->event->name ; n_query_cols++; query_cols[pres_uri_col=n_query_cols]= &str_presentity_uri_col; query_vals[pres_uri_col].nul= 0; query_vals[pres_uri_col].type= DB1_STR; query_vals[pres_uri_col].val.str_val= subs->pres_uri; n_query_cols++; query_cols[watcher_user_col=n_query_cols]= &str_watcher_username_col; query_vals[watcher_user_col].nul= 0; query_vals[watcher_user_col].type= DB1_STR; query_vals[watcher_user_col].val.str_val= subs->watcher_user; n_query_cols++; query_cols[watcher_domain_col=n_query_cols]= &str_watcher_domain_col; query_vals[watcher_domain_col].nul= 0; query_vals[watcher_domain_col].type= DB1_STR; query_vals[watcher_domain_col].val.str_val= subs->watcher_domain; n_query_cols++; result_cols[r_to_user_col=n_result_cols++] = &str_to_user_col; result_cols[r_to_domain_col=n_result_cols++] = &str_to_domain_col; result_cols[r_from_user_col=n_result_cols++] = &str_from_user_col; result_cols[r_from_domain_col=n_result_cols++] = &str_from_domain_col; result_cols[r_watcher_user_col=n_result_cols++] = &str_watcher_username_col; result_cols[r_watcher_domain_col=n_result_cols++] = &str_watcher_domain_col; result_cols[r_callid_col=n_result_cols++] = &str_callid_col; result_cols[r_to_tag_col=n_result_cols++] = &str_to_tag_col; result_cols[r_from_tag_col=n_result_cols++] = &str_from_tag_col; result_cols[r_sockinfo_col=n_result_cols++] = &str_socket_info_col; result_cols[r_event_id_col=n_result_cols++] = &str_event_id_col; result_cols[r_local_contact_col=n_result_cols++] = &str_local_contact_col; result_cols[r_record_route_col=n_result_cols++] = &str_record_route_col; result_cols[r_reason_col=n_result_cols++] = &str_reason_col; result_cols[r_local_cseq_col=n_result_cols++] = &str_local_cseq_col; result_cols[r_version_col=n_result_cols++] = &str_version_col; result_cols[r_expires_col=n_result_cols++] = &str_expires_col; result_cols[r_event_col=n_result_cols++] = &str_event_col; result_cols[r_pres_uri_col=n_result_cols++] = &str_presentity_uri_col; result_cols[r_contact_col=n_result_cols++] = &str_contact_col; /* these ones are unused for some reason !!! */ result_cols[r_remote_cseq_col=n_result_cols++] = &str_remote_cseq_col; result_cols[r_status_col=n_result_cols++] = &str_status_col; /*********************************************/ if(pa_dbf.query(pa_db, query_cols, 0, query_vals, result_cols, n_query_cols, n_result_cols, 0, &result )< 0) { LM_ERR("Can't query db\n"); if(result) pa_dbf.free_result(pa_db, result); return(-1); } if(result == NULL) return(-1); nr_rows = RES_ROW_N(result); LM_DBG("found %d matching dialogs\n", nr_rows); if (nr_rows <= 0) { pa_dbf.free_result(pa_db, result); return 0; } rows = RES_ROWS(result); /* get the results and fill in return data structure */ for (loop=0; loop <nr_rows; loop++) { row_vals = ROW_VALUES(&rows[loop]); memset(&s, 0, sizeof(subs_t)); s.status= subs->status; s.reason.s= subs->reason.s; s.reason.len= s.reason.s?strlen(s.reason.s):0; //>>>>>>>>>> s.pres_uri.s= (char*)row_vals[r_pres_uri_col].val.string_val; s.pres_uri.len= s.pres_uri.s?strlen(s.pres_uri.s):0; s.to_user.s= (char*)row_vals[r_to_user_col].val.string_val; s.to_user.len= s.to_user.s?strlen(s.to_user.s):0; s.to_domain.s= (char*)row_vals[r_to_domain_col].val.string_val; s.to_domain.len= s.to_domain.s?strlen(s.to_domain.s):0; s.from_user.s= (char*)row_vals[r_from_user_col].val.string_val; s.from_user.len= s.from_user.s?strlen(s.from_user.s):0; s.from_domain.s= (char*)row_vals[r_from_domain_col].val.string_val; s.from_domain.len= s.from_domain.s?strlen(s.from_domain.s):0; s.watcher_user.s= (char*)row_vals[r_watcher_user_col].val.string_val; s.watcher_user.len= s.watcher_user.s?strlen(s.watcher_user.s):0; s.watcher_domain.s= (char*)row_vals[r_watcher_domain_col].val.string_val; s.watcher_domain.len= s.watcher_domain.s?strlen(s.watcher_domain.s):0; s.event_id.s=(char*)row_vals[r_event_id_col].val.string_val; s.event_id.len= (s.event_id.s)?strlen(s.event_id.s):0; s.to_tag.s= (char*)row_vals[r_to_tag_col].val.string_val; s.to_tag.len= s.to_tag.s?strlen(s.to_tag.s):0; s.from_tag.s= (char*)row_vals[r_from_tag_col].val.string_val; s.from_tag.len= s.from_tag.s?strlen(s.from_tag.s):0; s.callid.s= (char*)row_vals[r_callid_col].val.string_val; s.callid.len= s.callid.s?strlen(s.callid.s):0; s.record_route.s= (char*)row_vals[r_record_route_col].val.string_val; s.record_route.len= (s.record_route.s)?strlen(s.record_route.s):0; s.contact.s= (char*)row_vals[r_contact_col].val.string_val; s.contact.len= s.contact.s?strlen(s.contact.s):0; s.sockinfo_str.s = (char*)row_vals[r_sockinfo_col].val.string_val; s.sockinfo_str.len = s.sockinfo_str.s?strlen(s.sockinfo_str.s):0; s.local_contact.s = (char*)row_vals[r_local_contact_col].val.string_val; s.local_contact.len = s.local_contact.s?strlen(s.local_contact.s):0; ev_sname.s= (char*)row_vals[r_event_col].val.string_val; ev_sname.len= ev_sname.s?strlen(ev_sname.s):0; s.event = contains_event(&ev_sname, NULL); if(s.event == NULL) { LM_ERR("event not found and set to NULL\n"); } s.local_cseq = row_vals[r_local_cseq_col].val.int_val; s.expires = row_vals[r_expires_col].val.int_val; if( s.expires > (int)time(NULL) + expires_offset) s.expires -= (int)time(NULL); else s.expires = 0; s.version = row_vals[r_version_col].val.int_val; cs = mem_copy_subs(&s, PKG_MEM_TYPE); if (cs == NULL) { LM_ERR("while copying subs_t structure\n"); /* tidy up and return */ pa_dbf.free_result(pa_db, result); return(-1); } cs->local_cseq++; cs->next= (*subs_array); (*subs_array)= cs; printf_subs(cs); } pa_dbf.free_result(pa_db, result); if (pres_notifier_processes == 0 && subs->status == TERMINATED_STATUS) { /* delete the records */ if(pa_dbf.delete(pa_db, query_cols, 0, query_vals, n_query_cols)< 0) { LM_ERR("sql delete failed\n"); return(-1); } return(0); } /* otherwise we update the records */ db_cols[n_update_cols] = &str_status_col; db_vals[n_update_cols].type = DB1_INT; db_vals[n_update_cols].nul = 0; db_vals[n_update_cols].val.int_val = subs->status; n_update_cols++; db_cols[n_update_cols] = &str_reason_col; db_vals[n_update_cols].type = DB1_STR; db_vals[n_update_cols].nul = 0; db_vals[n_update_cols].val.str_val= subs->reason; n_update_cols++; db_cols[n_update_cols] = &str_updated_col; db_vals[n_update_cols].type = DB1_INT; db_vals[n_update_cols].nul = 0; if (subs->callid.len == 0 || subs->from_tag.len == 0) { db_vals[n_update_cols].val.int_val = (int) ((rand() / (RAND_MAX + 1.0)) * (pres_waitn_time * pres_notifier_poll_rate * pres_notifier_processes)); } else { db_vals[n_update_cols].val.int_val = core_case_hash(&subs->callid, &subs->from_tag, 0) % (pres_waitn_time * pres_notifier_poll_rate * pres_notifier_processes); } n_update_cols++; if(pa_dbf.update(pa_db, query_cols, 0, query_vals, db_cols,db_vals,n_query_cols,n_update_cols) < 0) { LM_ERR("DB update failed\n"); return(-1); } return(0); }
static void trace_onreply_out(struct cell* t, int type, struct tmcb_params *ps) { db_key_t db_keys[NR_KEYS]; db_val_t db_vals[NR_KEYS]; int faked = 0; static char fromip_buff[IP_ADDR_MAX_STR_SIZE+12]; static char toip_buff[IP_ADDR_MAX_STR_SIZE+12]; struct sip_msg* msg; struct sip_msg* req; int_str avp_value; struct usr_avp *avp; struct ip_addr to_ip; int len; char statusbuf[8]; str *sbuf; struct dest_info *dst; if (t==NULL || t->uas.request==0 || ps==NULL) { LM_DBG("no uas request, local transaction\n"); return; } avp = NULL; if(traced_user_avp.n!=0) avp=search_first_avp(traced_user_avp_type, traced_user_avp, &avp_value, 0); if((avp==NULL) && trace_is_off(t->uas.request)) { LM_DBG("trace off...\n"); return; } req = ps->req; msg = ps->rpl; if(msg==NULL || msg==FAKED_REPLY) { msg = t->uas.request; faked = 1; } if(parse_from_header(msg)==-1 || msg->from==NULL || get_from(msg)==NULL) { LM_ERR("cannot parse FROM header\n"); goto error; } if(parse_headers(msg, HDR_CALLID_F, 0)!=0) { LM_ERR("cannot parse call-id\n"); return; } db_keys[0] = msg_column; db_vals[0].type = DB_BLOB; db_vals[0].nul = 0; sbuf = (str*)ps->extra1; if(faked==0) { if(sbuf!=0 && sbuf->len>0) { db_vals[0].val.blob_val.s = sbuf->s; db_vals[0].val.blob_val.len = sbuf->len; } else if(t->uas.response.buffer.s!=NULL) { db_vals[0].val.blob_val.s = t->uas.response.buffer.s; db_vals[0].val.blob_val.len = t->uas.response.buffer.len; } else if(msg->len>0) { db_vals[0].val.blob_val.s = msg->buf; db_vals[0].val.blob_val.len = msg->len; } else { db_vals[0].val.blob_val.s = "No reply buffer"; db_vals[0].val.blob_val.len = sizeof("No reply buffer")-1; } } else { if(sbuf!=0 && sbuf->len>0) { db_vals[0].val.blob_val.s = sbuf->s; db_vals[0].val.blob_val.len = sbuf->len; } else if(t->uas.response.buffer.s==NULL) { db_vals[0].val.blob_val.s = "No reply buffer"; db_vals[0].val.blob_val.len = sizeof("No reply buffer")-1; } else { db_vals[0].val.blob_val.s = t->uas.response.buffer.s; db_vals[0].val.blob_val.len = t->uas.response.buffer.len; } } /* check Call-ID header */ if(msg->callid==NULL || msg->callid->body.s==NULL) { LM_ERR("cannot find Call-ID header!\n"); goto error; } db_keys[1] = callid_column; db_vals[1].type = DB_STR; db_vals[1].nul = 0; db_vals[1].val.str_val.s = msg->callid->body.s; db_vals[1].val.str_val.len = msg->callid->body.len; db_keys[2] = method_column; db_vals[2].type = DB_STR; db_vals[2].nul = 0; db_vals[2].val.str_val.s = t->method.s; db_vals[2].val.str_val.len = t->method.len; db_keys[4] = fromip_column; db_vals[4].type = DB_STRING; db_vals[4].nul = 0; if(trace_local_ip) db_vals[4].val.string_val = trace_local_ip; else { siptrace_copy_proto(msg->rcv.proto, fromip_buff); strcat(fromip_buff, ip_addr2a(&req->rcv.dst_ip)); strcat(fromip_buff,":"); strcat(fromip_buff, int2str(req->rcv.dst_port, NULL)); db_vals[4].val.string_val = fromip_buff; } db_keys[3] = status_column; db_vals[3].type = DB_STRING; db_vals[3].nul = 0; strcpy(statusbuf, int2str(ps->code, NULL)); db_vals[3].val.string_val = statusbuf; db_keys[5] = toip_column; db_vals[5].type = DB_STRING; db_vals[5].nul = 0; memset(&to_ip, 0, sizeof(struct ip_addr)); dst = (struct dest_info*)ps->extra2; if(dst==0) { db_vals[5].val.string_val = "any:255.255.255.255"; } else { su2ip_addr(&to_ip, &dst->to); siptrace_copy_proto(dst->proto, toip_buff); strcat(toip_buff, ip_addr2a(&to_ip)); strcat(toip_buff, ":"); strcat(toip_buff, int2str((unsigned long)su_getport(&dst->to), &len)); LM_DBG("dest [%s]\n", toip_buff); db_vals[5].val.string_val = toip_buff; } db_keys[6] = date_column; db_vals[6].type = DB_DATETIME; db_vals[6].nul = 0; db_vals[6].val.time_val = time(NULL); db_keys[7] = direction_column; db_vals[7].type = DB_STRING; db_vals[7].nul = 0; db_vals[7].val.string_val = "out"; db_keys[8] = fromtag_column; db_vals[8].type = DB_STR; db_vals[8].nul = 0; db_vals[8].val.str_val.s = get_from(msg)->tag_value.s; db_vals[8].val.str_val.len = get_from(msg)->tag_value.len; db_funcs.use_table(db_con, siptrace_get_table()); db_keys[9] = traced_user_column; db_vals[9].type = DB_STR; db_vals[9].nul = 0; if( !trace_is_off(req) ) { db_vals[9].val.str_val.s = ""; db_vals[9].val.str_val.len = 0; LM_DBG("storing info...\n"); if(db_funcs.insert(db_con, db_keys, db_vals, NR_KEYS) < 0) { LM_ERR("error storing trace\n"); goto error; } #ifdef STATISTICS update_stat(siptrace_rpl, 1); #endif } if(avp==NULL) goto done; trace_send_duplicate(db_vals[0].val.blob_val.s, db_vals[0].val.blob_val.len); db_vals[9].val.str_val.s = avp_value.s.s; db_vals[9].val.str_val.len = avp_value.s.len; LM_DBG("storing info...\n"); if(db_funcs.insert(db_con, db_keys, db_vals, NR_KEYS) < 0) { LM_ERR("error storing trace\n"); goto error; } avp = search_next_avp( avp, &avp_value); while(avp!=NULL) { db_vals[9].val.str_val.s = avp_value.s.s; db_vals[9].val.str_val.len = avp_value.s.len; LM_DBG("### - storing info (%d) ...\n", faked); if(db_funcs.insert(db_con, db_keys, db_vals, NR_KEYS) < 0) { LM_ERR("error storing trace\n"); goto error; } avp = search_next_avp( avp, &avp_value); } done: return; error: return; }
void query_xcap_update(unsigned int ticks, void* param) { db_key_t query_cols[3], update_cols[3]; db_val_t query_vals[3], update_vals[3]; db_key_t result_cols[7]; int n_result_cols = 0, n_query_cols= 0, n_update_cols= 0; db_res_t* result= NULL; int user_col, domain_col, doc_type_col, etag_col, doc_uri_col, port_col; db_row_t *row ; db_val_t *row_vals ; unsigned int port; char* etag, *path, *new_etag= NULL, *doc= NULL; int u_doc_col, u_etag_col; str user, domain, uri; int i; /* query the ones I have to handle */ query_cols[n_query_cols] = "source"; query_vals[n_query_cols].type = DB_INT; query_vals[n_query_cols].nul = 0; query_vals[n_query_cols].val.int_val= XCAP_CL_MOD; n_query_cols++; query_cols[n_query_cols] = "path"; query_vals[n_query_cols].type = DB_STR; query_vals[n_query_cols].nul = 0; update_cols[u_doc_col=n_update_cols] = "doc"; update_vals[n_update_cols].type = DB_STRING; update_vals[n_update_cols].nul = 0; n_update_cols++; update_cols[u_etag_col=n_update_cols] = "etag"; update_vals[n_update_cols].type = DB_STRING; update_vals[n_update_cols].nul = 0; n_update_cols++; result_cols[user_col= n_result_cols++] = "username"; result_cols[domain_col=n_result_cols++] = "domain"; result_cols[doc_type_col=n_result_cols++] = "doc_type"; result_cols[etag_col=n_result_cols++] = "etag"; result_cols[doc_uri_col= n_result_cols++] = "doc_uri"; result_cols[port_col= n_result_cols++] = "port"; if (xcap_dbf.use_table(xcap_db, xcap_db_table) < 0) { LM_ERR("in use_table-[table]= %s\n", xcap_db_table); goto error; } if(xcap_dbf.query(xcap_db, query_cols, 0, query_vals, result_cols, 1, n_result_cols, 0, &result)< 0) { LM_ERR("in sql query\n"); goto error; } if(result== NULL) { LM_ERR("in sql query- null result\n"); return; } if(result->n<= 0) { xcap_dbf.free_result(xcap_db, result); return; } n_query_cols++; /* ask if updated */ for(i= 0; i< result->n; i++) { row = &result->rows[i]; row_vals = ROW_VALUES(row); path= (char*)row_vals[doc_uri_col].val.string_val; port= row_vals[port_col].val.int_val; etag= (char*)row_vals[etag_col].val.string_val; user.s= (char*)row_vals[user_col].val.string_val; user.len= strlen(user.s); domain.s= (char*)row_vals[domain_col].val.string_val; domain.len= strlen(domain.s); /* send HTTP request */ doc= send_http_get(path, port, etag, IF_NONE_MATCH, &new_etag); if(doc== NULL) { LM_DBG("document not update\n"); continue; } if(new_etag== NULL) { LM_ERR("etag not found\n"); pkg_free(doc); goto error; } /* update in xcap db table */ update_vals[u_doc_col].val.string_val= doc; update_vals[u_etag_col].val.string_val= etag; if(xcap_dbf.update(xcap_db, query_cols, 0, query_vals, update_cols, update_vals, n_query_cols, n_update_cols)< 0) { LM_ERR("in sql update\n"); pkg_free(doc); goto error; } /* call registered callbacks */ if(uandd_to_uri(user, domain, &uri)< 0) { LM_ERR("converting user and domain to uri\n"); pkg_free(doc); goto error; } run_xcap_update_cb(row_vals[doc_type_col].val.int_val, uri, doc); pkg_free(doc); } xcap_dbf.free_result(xcap_db, result); return; error: if(result) xcap_dbf.free_result(xcap_db, result); }
/** * Loads the routing data from the database given in global * variable db_url and stores it in routing tree rd. * * @param rd Pointer to the route data tree where the routing data * shall be loaded into * * @return 0 means ok, -1 means an error occured * */ int load_route_data(struct rewrite_data * rd) { db_res_t * res = NULL; db_row_t * row = NULL; int i, ret; int carrier_count = 0; struct carrier * carriers = NULL, * tmp = NULL; static str query_str; str tmp_carrier; str tmp_domain; str tmp_scan_prefix; str tmp_rewrite_host; str tmp_rewrite_prefix; str tmp_rewrite_suffix; str tmp_host_name; str tmp_reply_code; str tmp_next_domain; str tmp_comment; int no_rows=10; if( (strlen("SELECT DISTINCT FROM WHERE = ") + db_table.len + columns[COL_DOMAIN]->len + columns[COL_CARRIER]->len + 20) > QUERY_LEN) { LM_ERR("query too long\n"); return -1; } if((carrier_count = store_carriers(&carriers)) <= 0){ LM_ERR("error while retrieving carriers\n"); goto errout; } if ((rd->carriers = shm_malloc(sizeof(struct carrier_tree *) * carrier_count)) == NULL) { LM_ERR("out of shared memory\n"); goto errout; } memset(rd->carriers, 0, sizeof(struct carrier_tree *) * carrier_count); rd->tree_num = carrier_count; tmp = carriers; for (i=0; i<carrier_count; i++) { memset(query, 0, QUERY_LEN); ret = snprintf(query, QUERY_LEN, "SELECT DISTINCT %.*s FROM %.*s WHERE %.*s=%i", columns[COL_DOMAIN]->len, columns[COL_DOMAIN]->s, db_table.len, db_table.s, columns[COL_CARRIER]->len, columns[COL_CARRIER]->s, tmp->id); if (ret < 0) { LM_ERR("error in snprintf"); goto errout; } query_str.s = query; query_str.len = ret; if (dbf.raw_query(dbh, &query_str, &res) < 0) { LM_ERR("Failed to query database.\n"); goto errout; } LM_INFO("name %s, id %i, trees: %i\n", tmp->name, tmp->id, RES_ROW_N(res)); tmp_carrier.s=tmp->name; tmp_carrier.len=strlen(tmp_carrier.s); if (add_carrier_tree(&tmp_carrier, tmp->id, rd, RES_ROW_N(res)) == NULL) { LM_ERR("can't add carrier %s\n", tmp->name); goto errout; } dbf.free_result(dbh, res); res = NULL; tmp = tmp->next; } if (dbf.use_table(dbh, &db_table) < 0) { LM_ERR("Cannot set database table '%.*s'.\n", db_table.len, db_table.s); return -1; } if (DB_CAPABILITY(dbf, DB_CAP_FETCH)) { if (dbf.query(dbh, NULL, NULL, NULL, (db_key_t *) columns, 0, COLUMN_NUM, NULL, NULL) < 0) { LM_ERR("Failed to query database to prepare fetchrow.\n"); return -1; } no_rows = estimate_available_rows( 4+64+64+64+4+4+4+64+4+64+64+128, COLUMN_NUM); if (no_rows==0) no_rows = 10; if(dbf.fetch_result(dbh, &res, no_rows) < 0) { LM_ERR("Fetching rows failed\n"); return -1; } } else { if (dbf.query(dbh, NULL, NULL, NULL, (db_key_t *)columns, 0, COLUMN_NUM, NULL, &res) < 0) { LM_ERR("Failed to query database.\n"); return -1; } } int n = 0; do { LM_DBG("loading, cycle %d", n++); for (i = 0; i < RES_ROW_N(res); ++i) { row = &RES_ROWS(res)[i]; tmp_domain.s=(char *)row->values[COL_DOMAIN].val.string_val; tmp_scan_prefix.s=(char *)row->values[COL_SCAN_PREFIX].val.string_val; tmp_rewrite_host.s=(char *)row->values[COL_REWRITE_HOST].val.string_val; tmp_rewrite_prefix.s=(char *)row->values[COL_REWRITE_PREFIX].val.string_val; tmp_rewrite_suffix.s=(char *)row->values[COL_REWRITE_SUFFIX].val.string_val; tmp_comment.s=(char *)row->values[COL_COMMENT].val.string_val; if (tmp_domain.s==NULL) tmp_domain.s=""; if (tmp_scan_prefix.s==NULL) tmp_scan_prefix.s=""; if (tmp_rewrite_host.s==NULL) tmp_rewrite_host.s=""; if (tmp_rewrite_prefix.s==NULL) tmp_rewrite_prefix.s=""; if (tmp_rewrite_suffix.s==NULL) tmp_rewrite_suffix.s=""; if (tmp_comment.s==NULL) tmp_comment.s=""; tmp_domain.len=strlen(tmp_domain.s); tmp_scan_prefix.len=strlen(tmp_scan_prefix.s); tmp_rewrite_host.len=strlen(tmp_rewrite_host.s); tmp_rewrite_prefix.len=strlen(tmp_rewrite_prefix.s); tmp_rewrite_suffix.len=strlen(tmp_rewrite_suffix.s); tmp_comment.len=strlen(tmp_comment.s); if (add_route(rd, row->values[COL_CARRIER].val.int_val, &tmp_domain, &tmp_scan_prefix, row->values[COL_FLAGS].val.int_val, row->values[COL_MASK].val.int_val, 0, row->values[COL_PROB].val.double_val, &tmp_rewrite_host, row->values[COL_STRIP].val.int_val, &tmp_rewrite_prefix, &tmp_rewrite_suffix, 1, 0, -1, NULL, &tmp_comment) == -1) { goto errout; } } if (DB_CAPABILITY(dbf, DB_CAP_FETCH)) { if(dbf.fetch_result(dbh, &res, no_rows) < 0) { LM_ERR("fetching rows failed\n"); dbf.free_result(dbh, res); return -1; } } else { break; } } while(RES_ROW_N(res) > 0); dbf.free_result(dbh, res); res = NULL; if (dbf.use_table(dbh, &db_failure_table) < 0) { LM_ERR("cannot set database table '%.*s'.\n", db_failure_table.len, db_failure_table.s); return -1; } if (dbf.query(dbh, NULL, NULL, NULL, (db_key_t *)failure_columns, 0, FAILURE_COLUMN_NUM, NULL, &res) < 0) { LM_ERR("failed to query database.\n"); return -1; } for (i = 0; i < RES_ROW_N(res); ++i) { row = &RES_ROWS(res)[i]; tmp_domain.s=(char *)row->values[FCOL_DOMAIN].val.string_val; tmp_scan_prefix.s=(char *)row->values[FCOL_SCAN_PREFIX].val.string_val; tmp_host_name.s=(char *)row->values[FCOL_HOST_NAME].val.string_val; tmp_reply_code.s=(char *)row->values[FCOL_REPLY_CODE].val.string_val; tmp_next_domain.s=(char *)row->values[FCOL_NEXT_DOMAIN].val.string_val; tmp_comment.s=(char *)row->values[FCOL_COMMENT].val.string_val; if (tmp_domain.s==NULL) tmp_domain.s=""; if (tmp_scan_prefix.s==NULL) tmp_scan_prefix.s=""; if (tmp_host_name.s==NULL) tmp_host_name.s=""; if (tmp_reply_code.s==NULL) tmp_reply_code.s=""; if (tmp_next_domain.s==NULL) tmp_next_domain.s=""; if (tmp_comment.s==NULL) tmp_comment.s=""; tmp_domain.len=strlen(tmp_domain.s); tmp_scan_prefix.len=strlen(tmp_scan_prefix.s); tmp_host_name.len=strlen(tmp_host_name.s); tmp_reply_code.len=strlen(tmp_reply_code.s); tmp_next_domain.len=strlen(tmp_next_domain.s); tmp_comment.len=strlen(tmp_comment.s); if (add_failure_route(rd, row->values[FCOL_CARRIER].val.int_val, &tmp_domain, &tmp_scan_prefix, &tmp_host_name, &tmp_reply_code, row->values[FCOL_FLAGS].val.int_val, row->values[FCOL_MASK].val.int_val, &tmp_next_domain, &tmp_comment) == -1) { goto errout; } } destroy_carriers(carriers); dbf.free_result(dbh, res); return 0; errout: destroy_carriers(carriers); if (res) { dbf.free_result(dbh, res); } return -1; }
static int frd_load_data(dr_head_p drp, free_list_t **fl) { static const size_t col_count = 16; db_res_t *res = NULL; unsigned int no_rows = 0, row_count, i; db_row_t *rows; db_val_t *values; db_key_t query_cols[] = { &rid_col, &pid_col, &prefix_col, &start_h_col, &end_h_col, &days_col, &cpm_thresh_warn_col, &cpm_thresh_crit_col, &calldur_thresh_warn_col, &calldur_thresh_crit_col, &totalc_thresh_warn_col, &totalc_thresh_crit_col, &concalls_thresh_warn_col, &concalls_thresh_crit_col, &seqcalls_thresh_warn_col, &seqcalls_thresh_crit_col }; if (db_handle == NULL) { LM_ERR("Invalid db handler\n"); return -1; } if (dbf.use_table(db_handle, &table_name) != 0) { LM_ERR("Cannot use table\n"); return -1; } if (DB_CAPABILITY(dbf, DB_CAP_FETCH)) { if (dbf.query(db_handle, 0, 0, 0, query_cols, 0, col_count, 0, 0) != 0) { LM_ERR("Error while querying db\n"); goto error; } /* estimate rows */ no_rows = estimate_available_rows(4 + 64 + 5 + 5 + 64 + 5 * 2 * 4, col_count); if (no_rows == 0) no_rows = 10; if (dbf.fetch_result(db_handle, &res, no_rows) != 0) { LM_ERR("Error while fetching rows\n"); goto error; } } else { /* No fetching capability */ if (dbf.query(db_handle, 0, 0, 0, query_cols, 0, col_count, 0, &res) != 0) { LM_ERR("Error while querying db\n"); goto error; } } /* Process the actual data */ unsigned int rid, pid, j; str prefix, start_time, end_time, days; free_list_t *fl_it = NULL; *fl = NULL; do { row_count = RES_ROW_N(res); rows = RES_ROWS(res); fl_it = pkg_malloc(sizeof(free_list_t)); if (fl_it == NULL) { LM_ERR ("no more pkg memory"); dbf.free_result(db_handle, res); return -1; } fl_it ->next = *fl; *fl = fl_it; fl_it->trec = shm_malloc(sizeof(tmrec_t) * row_count); if (fl_it->trec == NULL) goto no_more_shm; fl_it->thr = shm_malloc(sizeof(frd_thresholds_t) * row_count); if (fl_it->thr == NULL) goto no_more_shm; fl_it->n = row_count; for (i = 0; i < row_count; ++i) { values = ROW_VALUES(rows + i); fl_it->trec[i].byday = NULL; /* rule id */ if (VAL_NULL(values)) { LM_ERR("rule id cannot be NULL - skipping rule\n"); continue; } rid = VAL_INT(values); /* profile id */ if (VAL_NULL(values + 1)) { LM_ERR("profile id cannot be NULL - skipping rule\n"); continue; } pid = VAL_INT(values + 1); get_str_from_dbval(prefix_col.s, values + 2, 1, 1, prefix, null_val); get_str_from_dbval(start_h_col.s, values + 3, 1, 1, start_time, null_val); get_str_from_dbval(end_h_col.s, values + 4, 1, 1, end_time, null_val); get_str_from_dbval(days_col.s, values + 5, 1, 1, days, null_val); if (create_time_rec(&start_time, &end_time, &days, fl_it->trec + i) != 0) goto null_val; /* Now load the thresholds */ for (j = 0; j < 2 * 5; ++j) { if (VAL_NULL(values + 6 + j)) goto null_val; memcpy((char*)fl_it->thr + i * sizeof(frd_thresholds_t) + j * sizeof(unsigned int), &VAL_INT(values + 6 + j), sizeof(unsigned int)); } /* Rule OK, time to put it in DR */ if (drb.add_rule(drp, rid, &prefix, pid, 0, fl_it->trec + i, (void*)(&fl_it->thr[i])) != 0) { LM_ERR("Cannot add rule in dr <%u>. Skipping...\n", rid); } null_val: continue; } if (DB_CAPABILITY(dbf, DB_CAP_FETCH)) { /* any more rows to fetch ? */ if(dbf.fetch_result(db_handle, &res, no_rows)<0) { LM_ERR("error while fetching rows\n"); goto error; } /* success in fetching more rows - continue the loop */ } else break; } while (RES_ROW_N(res) > 0); dbf.free_result(db_handle, res); return 0; no_more_shm: LM_ERR ("no more shm memory\n"); dbf.free_result(db_handle, res); error: return -1; }
void main_db_close(void){ dbf.close(dbh); dbh = NULL; }
static int alias_db_query(struct sip_msg* _msg, str table, struct sip_uri *puri, unsigned long flags, set_alias_f set_alias, void *param) { str user_s; db_key_t db_keys[2]; db_val_t db_vals[2]; db_key_t db_cols[2]; db1_res_t* db_res = NULL; int i; if (flags&ALIAS_REVERSE_FLAG) { /* revert lookup: user->alias */ db_keys[0] = &user_column; db_keys[1] = &domain_column; db_cols[0] = &alias_user_column; db_cols[1] = &alias_domain_column; } else { /* normal lookup: alias->user */ db_keys[0] = &alias_user_column; db_keys[1] = &alias_domain_column; db_cols[0] = &user_column; db_cols[1] = &domain_column; } db_vals[0].type = DB1_STR; db_vals[0].nul = 0; db_vals[0].val.str_val.s = puri->user.s; db_vals[0].val.str_val.len = puri->user.len; if ( flags&ALIAS_DOMAIN_FLAG ) { db_vals[1].type = DB1_STR; db_vals[1].nul = 0; db_vals[1].val.str_val.s = puri->host.s; db_vals[1].val.str_val.len = puri->host.len; if (domain_prefix.s && domain_prefix.len>0 && domain_prefix.len<puri->host.len && strncasecmp(puri->host.s,domain_prefix.s, domain_prefix.len)==0) { db_vals[1].val.str_val.s += domain_prefix.len; db_vals[1].val.str_val.len -= domain_prefix.len; } } adbf.use_table(db_handle, &table); if(adbf.query( db_handle, db_keys, NULL, db_vals, db_cols, (flags&ALIAS_DOMAIN_FLAG)?2:1 /*no keys*/, 2 /*no cols*/, NULL, &db_res)!=0 || db_res==NULL) { LM_ERR("failed to query database\n"); goto err_server; } if (RES_ROW_N(db_res)<=0 || RES_ROWS(db_res)[0].values[0].nul != 0) { LM_DBG("no alias found for R-URI\n"); goto err_server; } memcpy(useruri_buf, "sip:", 4); for(i=0; i<RES_ROW_N(db_res); i++) { user_s.len = 4; user_s.s = useruri_buf+4; switch(RES_ROWS(db_res)[i].values[0].type) { case DB1_STRING: strcpy(user_s.s, (char*)RES_ROWS(db_res)[i].values[0].val.string_val); user_s.len += strlen(user_s.s); break; case DB1_STR: strncpy(user_s.s, (char*)RES_ROWS(db_res)[i].values[0].val.str_val.s, RES_ROWS(db_res)[i].values[0].val.str_val.len); user_s.len += RES_ROWS(db_res)[i].values[0].val.str_val.len; break; case DB1_BLOB: strncpy(user_s.s, (char*)RES_ROWS(db_res)[i].values[0].val.blob_val.s, RES_ROWS(db_res)[i].values[0].val.blob_val.len); user_s.len += RES_ROWS(db_res)[i].values[0].val.blob_val.len; break; default: LM_ERR("unknown type of DB user column\n"); goto err_server; } /* add the @*/ useruri_buf[user_s.len] = '@'; user_s.len++; /* add the domain */ user_s.s = useruri_buf+user_s.len; switch(RES_ROWS(db_res)[i].values[1].type) { case DB1_STRING: strcpy(user_s.s, (char*)RES_ROWS(db_res)[i].values[1].val.string_val); user_s.len += strlen(user_s.s); break; case DB1_STR: strncpy(user_s.s, (char*)RES_ROWS(db_res)[i].values[1].val.str_val.s, RES_ROWS(db_res)[i].values[1].val.str_val.len); user_s.len += RES_ROWS(db_res)[i].values[1].val.str_val.len; useruri_buf[user_s.len] = '\0'; break; case DB1_BLOB: strncpy(user_s.s, (char*)RES_ROWS(db_res)[i].values[1].val.blob_val.s, RES_ROWS(db_res)[i].values[1].val.blob_val.len); user_s.len += RES_ROWS(db_res)[i].values[1].val.blob_val.len; useruri_buf[user_s.len] = '\0'; break; default: LM_ERR("unknown type of DB user column\n"); goto err_server; } user_s.s = useruri_buf; /* set the URI */ LM_DBG("new URI [%d] is [%.*s]\n", i, user_s.len ,user_s.s ); if (set_alias(_msg, &user_s, i, param)!=0) { LM_ERR("error while setting alias\n"); goto err_server; } } /** * Free the DB result */ if (adbf.free_result(db_handle, db_res) < 0) { LM_DBG("failed to freeing result of query\n"); } return 1; err_server: if (db_res!=NULL) { if(adbf.free_result(db_handle, db_res) < 0) { LM_DBG("failed to freeing result of query\n"); } } return -1; }
void db_destroy(void){ if(dbh){ dbf.close(dbh); } return; }
/** * init module function */ static int mod_init(void) { bind_presence_t bind_presence; presence_api_t pres; if(passive_mode==1) return 0; if(register_mi_mod(exports.name, mi_cmds)!=0) { LM_ERR("failed to register MI commands\n"); return -1; } LM_DBG("db_url=%s/%d/%p\n",ZSW(db_url.s),db_url.len, db_url.s); /* bind the SL API */ if (sl_load_api(&slb)!=0) { LM_ERR("cannot bind to SL API\n"); return -1; } bind_presence= (bind_presence_t)find_export("bind_presence", 1,0); if (!bind_presence) { LM_ERR("Can't bind presence\n"); return -1; } if (bind_presence(&pres) < 0) { LM_ERR("Can't bind to presence module\n"); return -1; } pres_get_sphere= pres.get_sphere; pres_add_event= pres.add_event; pres_update_watchers= pres.update_watchers_status; pres_contains_event= pres.contains_event; pres_get_presentity= pres.get_presentity; pres_free_presentity= pres.free_presentity; if (pres_add_event == NULL || pres_update_watchers== NULL) { LM_ERR("Can't import add_event\n"); return -1; } if(xml_add_events()< 0) { LM_ERR("adding xml events\n"); return -1; } if(force_active== 0) { /* binding to mysql module */ if (db_bind_mod(&db_url, &pxml_dbf)) { LM_ERR("Database module not found\n"); return -1; } if (!DB_CAPABILITY(pxml_dbf, DB_CAP_ALL)) { LM_ERR("Database module does not implement all functions" " needed by the module\n"); return -1; } pxml_db = pxml_dbf.init(&db_url); if (!pxml_db) { LM_ERR("while connecting to database\n"); return -1; } if(db_check_table_version(&pxml_dbf, pxml_db, &xcap_table, S_TABLE_VERSION) < 0) { LM_ERR("error during table version check.\n"); return -1; } if(!integrated_xcap_server ) { xcap_api_t xcap_api; bind_xcap_t bind_xcap; /* bind xcap */ bind_xcap= (bind_xcap_t)find_export("bind_xcap", 1, 0); if (!bind_xcap) { LM_ERR("Can't bind xcap_client\n"); return -1; } if (bind_xcap(&xcap_api) < 0) { LM_ERR("Can't bind xcap_api\n"); return -1; } xcap_GetNewDoc= xcap_api.getNewDoc; if(xcap_GetNewDoc== NULL) { LM_ERR("can't import get_elem from xcap_client module\n"); return -1; } if(xcap_api.register_xcb(PRES_RULES, xcap_doc_updated)< 0) { LM_ERR("registering xcap callback function\n"); return -1; } } } if(shm_copy_xcap_list()< 0) { LM_ERR("copying xcap server list in share memory\n"); return -1; } if(pxml_db) pxml_dbf.close(pxml_db); pxml_db = NULL; return 0; }
/* * input: rule straight from the DDDS + avp-stack. * * output: adds found rules to the stack and return * 1 on success * 0 on failure */ static int check_rule(str *rule, char *service, int service_len, struct avp_stack *stack) { /* for the select */ db_key_t keys[2]; db_val_t vals[2]; db_key_t cols[4]; db1_res_t* res; db_row_t* row; db_val_t* val; int i; char *type; int type_len; LM_INFO("checking for '%.*s'.\n", rule->len, ZSW(rule->s)); if ((service_len != 11) || (strncasecmp("d2p+sip:fed", service, 11) && strncasecmp("d2p+sip:std", service, 11) && strncasecmp("d2p+sip:dom", service, 11))) { LM_ERR("can only cope with d2p+sip:fed, d2p+sip:std,and d2p+sip:dom " "for now (and not %.*s).\n", service_len, service); return(0); } type = service + 8; type_len = service_len - 8; if (domainpolicy_dbf.use_table(db_handle, &domainpolicy_table) < 0) { LM_ERR("failed to domainpolicy table\n"); return -1; } keys[0]=&domainpolicy_col_rule; keys[1]=&domainpolicy_col_type; cols[0]=&domainpolicy_col_rule; cols[1]=&domainpolicy_col_type; cols[2]=&domainpolicy_col_att; cols[3]=&domainpolicy_col_val; VAL_TYPE(&vals[0]) = DB1_STR; VAL_NULL(&vals[0]) = 0; VAL_STR(&vals[0]).s = rule->s; VAL_STR(&vals[0]).len = rule->len; VAL_TYPE(&vals[1]) = DB1_STR; VAL_NULL(&vals[1]) = 0; VAL_STR(&vals[1]).s = type; VAL_STR(&vals[1]).len = type_len; /* * SELECT rule, att, val from domainpolicy where rule = "..." */ if (domainpolicy_dbf.query(db_handle, keys, 0, vals, cols, 2, 4, 0, &res) < 0 ) { LM_ERR("querying database\n"); return -1; } LM_INFO("querying database OK\n"); if (RES_ROW_N(res) == 0) { LM_DBG("rule '%.*s' is not know.\n", rule->len, ZSW(rule->s)); domainpolicy_dbf.free_result(db_handle, res); return 0; } else { LM_DBG("rule '%.*s' is known\n", rule->len, ZSW(rule->s)); row = RES_ROWS(res); for(i = 0; i < RES_ROW_N(res); i++) { if (ROW_N(row + i) != 4) { LM_ERR("unexpected cell count\n"); return(-1); } val = ROW_VALUES(row + i); if ((VAL_TYPE(val) != DB1_STRING) || (VAL_TYPE(val+1) != DB1_STRING) || (VAL_TYPE(val+2) != DB1_STRING) || (VAL_TYPE(val+3) != DB1_STRING)) { LM_ERR("unexpected cell types\n"); return(-1); } if (VAL_NULL(val+2) || VAL_NULL(val+3)) { LM_INFO("db returned NULL values. Fine with us.\n"); continue; } LM_INFO("DB returned %s/%s \n",VAL_STRING(val+2),VAL_STRING(val+3)); if (!stack_push(stack, (char *) VAL_STRING(val+2), (char *) VAL_STRING(val+3))) { return(-1); } } domainpolicy_dbf.free_result(db_handle, res); return 1; } }
/* loads data from the db */ table_entry_t* load_info(db_func_t *dr_dbf, db_con_t* db_hdl, str *db_table) { int int_vals[7]; char *str_vals[2]; int no_of_results; int i, n; int no_rows = 5; int db_cols = 10; unsigned long last_attempt; static db_key_t clusterer_machine_id_key = &machine_id_col; static db_val_t clusterer_machine_id_value = { .type = DB_INT, .nul = 0, }; VAL_INT(&clusterer_machine_id_value) = server_id; /* the columns from the db table */ db_key_t columns[10]; /* result from a db query */ db_res_t* res; /* a row from the db table */ db_row_t* row; /* the processed result */ table_entry_t *data; res = 0; data = 0; columns[0] = &cluster_id_col; columns[1] = &machine_id_col; columns[2] = &state_col; columns[3] = &description_col; columns[4] = &url_col; columns[5] = &id_col; columns[6] = &last_attempt_col; columns[7] = &failed_attempts_col; columns[8] = &no_tries_col; columns[9] = &duration_col; CON_OR_RESET(db_hdl); /* checking if the table version is up to date*/ if (db_check_table_version(dr_dbf, db_hdl, db_table, 1/*version*/) != 0) goto error; /* read data */ if (dr_dbf->use_table(db_hdl, db_table) < 0) { LM_ERR("cannot select table \"%.*s\"\n", db_table->len, db_table->s); goto error; } LM_DBG("DB query - retrieve the clusters list" "in which the specified server runs\n"); /* first we see in which clusters the specified server runs*/ if (dr_dbf->query(db_hdl, &clusterer_machine_id_key, &op_eq, &clusterer_machine_id_value, columns, 1, 1, 0, &res) < 0) { LM_ERR("DB query failed - cannot retrieve the clusters list in which" " the specified server runs\n"); goto error; } LM_DBG("%d rows found in %.*s\n", RES_ROW_N(res), db_table->len, db_table->s); if (RES_ROW_N(res) == 0) { LM_WARN("No machines found in cluster %d\n", server_id); return 0; } clusterer_cluster_id_key = pkg_realloc(clusterer_cluster_id_key, RES_ROW_N(res) * sizeof(db_key_t)); if (!clusterer_cluster_id_key) { LM_ERR("no more pkg memory\n"); goto error; } for (i = 0; i < RES_ROW_N(res); i++) clusterer_cluster_id_key[i] = &cluster_id_col; clusterer_cluster_id_value = pkg_realloc(clusterer_cluster_id_value, RES_ROW_N(res) * sizeof(db_val_t)); if (!clusterer_cluster_id_value) { LM_ERR("no more pkg memory\n"); goto error; } for (i = 0; i < RES_ROW_N(res); i++) { VAL_TYPE(clusterer_cluster_id_value + i) = DB_INT; VAL_NULL(clusterer_cluster_id_value + i) = 0; } for (i = 0; i < RES_ROW_N(res); i++) { row = RES_ROWS(res) + i; check_val(cluster_id_col, ROW_VALUES(row), DB_INT, 1, 0); VAL_INT(clusterer_cluster_id_value + i) = VAL_INT(ROW_VALUES(row)); } no_of_results = RES_ROW_N(res); dr_dbf->free_result(db_hdl, res); res = 0; LM_DBG("DB query - retrieve valid connections\n"); /* fetch is the best strategy */ CON_USE_OR_OP(db_hdl); if (DB_CAPABILITY(*dr_dbf, DB_CAP_FETCH)) { if (dr_dbf->query(db_hdl, clusterer_cluster_id_key, 0, clusterer_cluster_id_value, columns, no_of_results, db_cols, 0, 0) < 0) { LM_ERR("DB query failed - retrieve valid connections \n"); goto error; } no_rows = estimate_available_rows(4 + 4 + 4 + 64 + 4 + 45 + 4 + 8 + 4 + 4, db_cols); if (no_rows == 0) no_rows = 5; if (dr_dbf->fetch_result(db_hdl, &res, no_rows) < 0) { LM_ERR("Error fetching rows\n"); goto error; } } else { if (dr_dbf->query(db_hdl, clusterer_cluster_id_key, 0, clusterer_cluster_id_value, columns, no_of_results, db_cols, 0, &res) < 0) { LM_ERR("DB query failed - retrieve valid connections\n"); goto error; } } LM_DBG("%d rows found in %.*s\n", RES_ROW_N(res), db_table->len, db_table->s); n = 0; do { for (i = 0; i < RES_ROW_N(res); i++) { row = RES_ROWS(res) + i; /* CLUSTER ID column */ check_val(cluster_id_col, ROW_VALUES(row), DB_INT, 1, 0); int_vals[INT_VALS_CLUSTER_ID_COL] = VAL_INT(ROW_VALUES(row)); /* MACHINE ID column */ check_val(machine_id_col, ROW_VALUES(row) + 1, DB_INT, 1, 0); int_vals[INT_VALS_MACHINE_ID_COL] = VAL_INT(ROW_VALUES(row) + 1); /* STATE column */ check_val(state_col, ROW_VALUES(row) + 2, DB_INT, 1, 0); int_vals[INT_VALS_STATE_COL] = VAL_INT(ROW_VALUES(row) + 2); /* DESCRIPTION column */ check_val(description_col, ROW_VALUES(row) + 3, DB_STRING, 0, 0); str_vals[STR_VALS_DESCRIPTION_COL] = (char*) VAL_STRING(ROW_VALUES(row) + 3); /* URL column */ check_val(url_col, ROW_VALUES(row) + 4, DB_STRING, 1, 1); str_vals[STR_VALS_URL_COL] = (char*) VAL_STRING(ROW_VALUES(row) + 4); /* CLUSTERER_ID column */ check_val(id_col, ROW_VALUES(row) + 5, DB_INT, 1, 0); int_vals[INT_VALS_CLUSTERER_ID_COL] = VAL_INT(ROW_VALUES(row) + 5); /* LAST_ATTEMPT column */ check_val(last_attempt_col, ROW_VALUES(row) + 6, DB_BIGINT, 1, 0); last_attempt = VAL_BIGINT(ROW_VALUES(row) + 6); /* FAILED_ATTEMPTS column */ check_val(failed_attempts_col, ROW_VALUES(row) + 7, DB_INT, 1, 0); int_vals[INT_VALS_FAILED_ATTEMPTS_COL] = VAL_INT(ROW_VALUES(row) + 7); /* NO_TRIES column */ check_val(no_tries_col, ROW_VALUES(row) + 8, DB_INT, 1, 0); int_vals[INT_VALS_NO_TRIES_COL] = VAL_INT(ROW_VALUES(row) + 8); /* DURATION column */ check_val(duration_col, ROW_VALUES(row) + 9, DB_INT, 1, 0); int_vals[INT_VALS_DURATION_COL] = VAL_INT(ROW_VALUES(row) + 9); /* store data */ if (add_info(&data, int_vals, last_attempt, str_vals) < 0) { LM_DBG("error while adding info to shm\n"); goto error; } LM_DBG("machine id %d\n", int_vals[0]); LM_DBG("cluster id %d\n", int_vals[1]); LM_DBG("state %d\n", int_vals[2]); LM_DBG("clusterer_id %d\n", int_vals[3]); LM_DBG("description %s\n", str_vals[0]); LM_DBG("url %s\n", str_vals[1]); n++; } if (n == 1) LM_WARN("The server is the only one in the cluster\n"); if (DB_CAPABILITY(*dr_dbf, DB_CAP_FETCH)) { if (dr_dbf->fetch_result(db_hdl, &res, no_rows) < 0) { LM_ERR("fetching rows (1)\n"); goto error; } } else { break; } } while (RES_ROW_N(res) > 0); LM_DBG("%d records found in %.*s\n", n, db_table->len, db_table->s); dr_dbf->free_result(db_hdl, res); res = 0; return data; error: if (res) dr_dbf->free_result(db_hdl, res); if (data) free_data(data); data = NULL; return 0; } /* deallocates data */ void free_data(table_entry_t *data) { table_entry_t *tmp_entry; table_entry_info_t *info; table_entry_info_t *tmp_info; table_entry_value_t *value; table_entry_value_t *tmp_value; struct module_timestamp *timestamp; struct module_timestamp *tmp_timestamp; while (data != NULL) { tmp_entry = data; data = data->next; info = tmp_entry->info; while (info != NULL) { value = info->value; while (value != NULL) { if (value->path.s) shm_free(value->path.s); if (value->description.s) shm_free(value->description.s); timestamp = value->in_timestamps; while (timestamp != NULL) { tmp_timestamp = timestamp; timestamp = timestamp->next; shm_free(tmp_timestamp); } tmp_value = value; value = value->next; shm_free(tmp_value); } tmp_info = info; info = info->next; shm_free(tmp_info); } shm_free(tmp_entry); } }
/* close a db connection */ void acc_db_close(void) { if (db_handle && acc_dbf.close) acc_dbf.close(db_handle); }
/** * init module function */ static int mod_init(void) { LM_DBG("...\n"); if (register_mi_mod(exports.name, mi_cmds)!=0) { LM_ERR("failed to register MI commands\n"); return -1; } if(min_expires< 0) min_expires= 0; if(default_expires< 600) default_expires= 3600; /* load TM API */ if(load_tm_api(&tmb)==-1) { LM_ERR("can't load tm functions\n"); return -1; } db_url.len = db_url.s ? strlen(db_url.s) : 0; LM_DBG("db_url=%s/%d/%p\n", ZSW(db_url.s), db_url.len, db_url.s); db_table.len = db_table.s ? strlen(db_table.s) : 0; /* binding to database module */ if (db_bind_mod(&db_url, &pua_dbf)) { LM_ERR("Database module not found\n"); return -1; } if (!DB_CAPABILITY(pua_dbf, DB_CAP_ALL)) { LM_ERR("Database module does not implement all functions needed" " by the module\n"); return -1; } pua_db = pua_dbf.init(&db_url); if (!pua_db) { LM_ERR("while connecting database\n"); return -1; } /* verify table version */ if(db_check_table_version(&pua_dbf, pua_db, &db_table, PUA_TABLE_VERSION) < 0) { LM_ERR("error during table version check.\n"); return -1; } if (dbmode != PUA_DB_ONLY) { if(HASH_SIZE<=1) HASH_SIZE= 512; else HASH_SIZE = 1<<HASH_SIZE; HashT= new_htable(); if(HashT== NULL) { LM_ERR("while creating new hash table\n"); return -1; } if(db_restore()< 0) { LM_ERR("while restoring hash_table\n"); return -1; } } if (dbmode != PUA_DB_DEFAULT && dbmode != PUA_DB_ONLY) { dbmode = PUA_DB_DEFAULT; LM_ERR( "Invalid dbmode-using default mode\n" ); } if(update_period<0) { LM_ERR("wrong clean_period\n"); return -1; } if ( init_puacb_list() < 0) { LM_ERR("callbacks initialization failed\n"); return -1; } pua_evlist= init_pua_evlist(); if(pua_evlist==0) { LM_ERR("when initializing pua_evlist\n"); return -1; } if(pua_add_events()< 0) { LM_ERR("while adding events\n"); return -1; } if(check_remote_contact<0 || check_remote_contact>1) { LM_ERR("bad value for check_remote_contact\n"); return -1; } startup_time = (int) time(NULL); if (update_period > 0) /* probably should check > 5 here!! -croc */ register_timer(hashT_clean, 0, update_period- 5); if (dbmode != PUA_DB_ONLY) { if (update_period > 0) register_timer(db_update, 0, update_period); } if(pua_db) pua_dbf.close(pua_db); pua_db = NULL; outbound_proxy.len = outbound_proxy.s ? strlen(outbound_proxy.s) : 0; return 0; }
int acc_db_request( struct sip_msg *rq) { int m; int n; int i; struct tm *t; /* formated database columns */ m = core2strar( rq, val_arr, int_arr, type_arr ); for(i=0; i<m; i++) VAL_STR(db_vals+i) = val_arr[i]; /* time value */ VAL_TIME(db_vals+(m++)) = acc_env.ts; /* extra time value */ if(acc_time_mode==1) { VAL_INT(db_vals+(m++)) = (int)acc_env.tv.tv_sec; i++; VAL_INT(db_vals+(m++)) = (int)acc_env.tv.tv_usec; i++; } else if(acc_time_mode==2) { VAL_DOUBLE(db_vals+(m++)) = ((double)(acc_env.tv.tv_sec * 1000) + (acc_env.tv.tv_usec / 1000)) / 1000; i++; } else if(acc_time_mode==3 || acc_time_mode==4) { if(acc_time_mode==3) { t = localtime(&acc_env.ts); } else { t = gmtime(&acc_env.ts); } if(strftime(acc_time_format_buf, ACC_TIME_FORMAT_SIZE, acc_time_format, t)<=0) { acc_time_format_buf[0] = '\0'; } VAL_STRING(db_vals+(m++)) = acc_time_format_buf; i++; } /* extra columns */ m += extra2strar( db_extra, rq, val_arr+m, int_arr+m, type_arr+m); for( i++ ; i<m; i++) VAL_STR(db_vals+i) = val_arr[i]; if (acc_dbf.use_table(db_handle, &acc_env.text/*table*/) < 0) { LM_ERR("error in use_table\n"); return -1; } /* multi-leg columns */ if ( !leg_info ) { if(acc_db_insert_mode==1 && acc_dbf.insert_delayed!=NULL) { if (acc_dbf.insert_delayed(db_handle, db_keys, db_vals, m) < 0) { LM_ERR("failed to insert delayed into database\n"); return -1; } } else if(acc_db_insert_mode==2 && acc_dbf.insert_async!=NULL) { if (acc_dbf.insert_async(db_handle, db_keys, db_vals, m) < 0) { LM_ERR("failed to insert async into database\n"); return -1; } } else { if (acc_dbf.insert(db_handle, db_keys, db_vals, m) < 0) { LM_ERR("failed to insert into database\n"); return -1; } } } else { n = legs2strar(leg_info,rq,val_arr+m,int_arr+m,type_arr+m,1); do { for (i=m; i<m+n; i++) VAL_STR(db_vals+i)=val_arr[i]; if(acc_db_insert_mode==1 && acc_dbf.insert_delayed!=NULL) { if(acc_dbf.insert_delayed(db_handle,db_keys,db_vals,m+n)<0) { LM_ERR("failed to insert delayed into database\n"); return -1; } } else if(acc_db_insert_mode==2 && acc_dbf.insert_async!=NULL) { if(acc_dbf.insert_async(db_handle,db_keys,db_vals,m+n)<0) { LM_ERR("failed to insert async into database\n"); return -1; } } else { if (acc_dbf.insert(db_handle, db_keys, db_vals, m+n) < 0) { LM_ERR("failed to insert into database\n"); return -1; } } }while ( (n=legs2strar(leg_info,rq,val_arr+m,int_arr+m, type_arr+m,0))!=0 ); } return 1; }
static void db_update(unsigned int ticks,void *param) { ua_pres_t* p= NULL; db_key_t q_cols[20], result_cols[1]; db1_res_t *res= NULL; db_key_t db_cols[5]; db_val_t q_vals[20], db_vals[5]; db_op_t db_ops[1] ; int n_query_cols= 0, n_query_update= 0; int n_update_cols= 0; int i; int puri_col,pid_col,expires_col,flag_col,etag_col,tuple_col,event_col; int watcher_col,callid_col,totag_col,fromtag_col,record_route_col,cseq_col; int no_lock= 0, contact_col, desired_expires_col, extra_headers_col; int remote_contact_col, version_col; if (dbmode==PUA_DB_ONLY) return; if(ticks== 0 && param == NULL) no_lock= 1; /* cols and values used for insert */ q_cols[puri_col= n_query_cols] = &str_pres_uri_col; q_vals[puri_col].type = DB1_STR; q_vals[puri_col].nul = 0; n_query_cols++; q_cols[pid_col= n_query_cols] = &str_pres_id_col; q_vals[pid_col].type = DB1_STR; q_vals[pid_col].nul = 0; n_query_cols++; q_cols[flag_col= n_query_cols] = &str_flag_col; q_vals[flag_col].type = DB1_INT; q_vals[flag_col].nul = 0; n_query_cols++; q_cols[event_col= n_query_cols] = &str_event_col; q_vals[event_col].type = DB1_INT; q_vals[event_col].nul = 0; n_query_cols++; q_cols[watcher_col= n_query_cols] = &str_watcher_uri_col; q_vals[watcher_col].type = DB1_STR; q_vals[watcher_col].nul = 0; n_query_cols++; q_cols[callid_col= n_query_cols] = &str_call_id_col; q_vals[callid_col].type = DB1_STR; q_vals[callid_col].nul = 0; n_query_cols++; q_cols[totag_col= n_query_cols] = &str_to_tag_col; q_vals[totag_col].type = DB1_STR; q_vals[totag_col].nul = 0; n_query_cols++; q_cols[fromtag_col= n_query_cols] = &str_from_tag_col; q_vals[fromtag_col].type = DB1_STR; q_vals[fromtag_col].nul = 0; n_query_cols++; q_cols[etag_col= n_query_cols] = &str_etag_col; q_vals[etag_col].type = DB1_STR; q_vals[etag_col].nul = 0; n_query_cols++; q_cols[tuple_col= n_query_cols] = &str_tuple_id_col; q_vals[tuple_col].type = DB1_STR; q_vals[tuple_col].nul = 0; n_query_cols++; q_cols[cseq_col= n_query_cols]= &str_cseq_col; q_vals[cseq_col].type = DB1_INT; q_vals[cseq_col].nul = 0; n_query_cols++; q_cols[expires_col= n_query_cols] = &str_expires_col; q_vals[expires_col].type = DB1_INT; q_vals[expires_col].nul = 0; n_query_cols++; q_cols[desired_expires_col= n_query_cols] = &str_desired_expires_col; q_vals[desired_expires_col].type = DB1_INT; q_vals[desired_expires_col].nul = 0; n_query_cols++; q_cols[record_route_col= n_query_cols] = &str_record_route_col; q_vals[record_route_col].type = DB1_STR; q_vals[record_route_col].nul = 0; n_query_cols++; q_cols[contact_col= n_query_cols] = &str_contact_col; q_vals[contact_col].type = DB1_STR; q_vals[contact_col].nul = 0; n_query_cols++; q_cols[remote_contact_col= n_query_cols] = &str_remote_contact_col; q_vals[remote_contact_col].type = DB1_STR; q_vals[remote_contact_col].nul = 0; n_query_cols++; q_cols[version_col= n_query_cols] = &str_version_col; q_vals[version_col].type = DB1_INT; q_vals[version_col].nul = 0; n_query_cols++; /* must keep this the last column to be inserted */ q_cols[extra_headers_col= n_query_cols] = &str_extra_headers_col; q_vals[extra_headers_col].type = DB1_STR; q_vals[extra_headers_col].nul = 0; n_query_cols++; /* cols and values used for update */ db_cols[0]= &str_expires_col; db_vals[0].type = DB1_INT; db_vals[0].nul = 0; db_cols[1]= &str_cseq_col; db_vals[1].type = DB1_INT; db_vals[1].nul = 0; db_cols[2]= &str_etag_col; db_vals[2].type = DB1_STR; db_vals[2].nul = 0; db_cols[3]= &str_desired_expires_col; db_vals[3].type = DB1_INT; db_vals[3].nul = 0; db_cols[4]= &str_version_col; db_vals[4].type = DB1_INT; db_vals[4].nul = 0; result_cols[0]= &str_expires_col; if(pua_db== NULL) { LM_ERR("null database connection\n"); return; } if(pua_dbf.use_table(pua_db, &db_table)< 0) { LM_ERR("in use table\n"); return ; } for(i=0; i<HASH_SIZE; i++) { if(!no_lock) lock_get(&HashT->p_records[i].lock); p = HashT->p_records[i].entity->next; while(p) { if(p->expires - (int)time(NULL)< 0) { p= p->next; continue; } switch(p->db_flag) { case NO_UPDATEDB_FLAG: { LM_DBG("NO_UPDATEDB_FLAG\n"); break; } case UPDATEDB_FLAG: { LM_DBG("UPDATEDB_FLAG\n"); n_update_cols= 0; n_query_update= 0; q_vals[puri_col].val.str_val = *(p->pres_uri); n_query_update++; q_vals[pid_col].val.str_val = p->id; n_query_update++; q_vals[flag_col].val.int_val = p->flag; n_query_update++; q_vals[event_col].val.int_val = p->event; n_query_update++; if(p->watcher_uri) { q_vals[watcher_col].val.str_val = *(p->watcher_uri); n_query_update++; q_vals[callid_col].val.str_val = p->call_id; n_query_update++; q_vals[totag_col].val.str_val = p->to_tag; n_query_update++; q_vals[fromtag_col].val.str_val = p->from_tag; n_query_update++; } db_vals[0].val.int_val= p->expires; n_update_cols++; db_vals[1].val.int_val= p->cseq ; n_update_cols++; db_vals[2].val.str_val= p->etag ; n_update_cols++; db_vals[3].val.int_val= p->desired_expires; n_update_cols++; db_vals[4].val.int_val= p->version; n_update_cols++; LM_DBG("Updating:n_query_update= %d\tn_update_cols= %d\n", n_query_update, n_update_cols); if(pua_dbf.query(pua_db, q_cols, 0, q_vals, result_cols, n_query_update, 1, 0, &res)< 0) { LM_ERR("while querying db table pua\n"); if(!no_lock) lock_release(&HashT->p_records[i].lock); if(res) pua_dbf.free_result(pua_db, res); return ; } if(res && res->n> 0) { if(pua_dbf.update(pua_db, q_cols, 0, q_vals, db_cols, db_vals, n_query_update, n_update_cols)<0) { LM_ERR("while updating in database\n"); if(!no_lock) lock_release(&HashT->p_records[i].lock); pua_dbf.free_result(pua_db, res); res= NULL; return ; } pua_dbf.free_result(pua_db, res); res= NULL; } else { if(res) { pua_dbf.free_result(pua_db, res); res= NULL; } LM_DBG("UPDATEDB_FLAG and no record found\n"); // p->db_flag= INSERTDB_FLAG; } break; } case INSERTDB_FLAG: { LM_DBG("INSERTDB_FLAG\n"); q_vals[puri_col].val.str_val = *(p->pres_uri); q_vals[pid_col].val.str_val = p->id; q_vals[flag_col].val.int_val = p->flag; q_vals[callid_col].val.str_val = p->call_id; q_vals[fromtag_col].val.str_val = p->from_tag; q_vals[cseq_col].val.int_val= p->cseq; q_vals[expires_col].val.int_val = p->expires; q_vals[desired_expires_col].val.int_val = p->desired_expires; q_vals[event_col].val.int_val = p->event; q_vals[version_col].val.int_val = p->version; if((p->watcher_uri)) q_vals[watcher_col].val.str_val = *(p->watcher_uri); else { q_vals[watcher_col].val.str_val.s = ""; q_vals[watcher_col].val.str_val.len = 0; } if(p->tuple_id.s == NULL) { q_vals[tuple_col].val.str_val.s=""; q_vals[tuple_col].val.str_val.len=0; } else q_vals[tuple_col].val.str_val = p->tuple_id; if(p->etag.s == NULL) { q_vals[etag_col].val.str_val.s=""; q_vals[etag_col].val.str_val.len=0; } else q_vals[etag_col].val.str_val = p->etag; if (p->to_tag.s == NULL) { q_vals[totag_col].val.str_val.s=""; q_vals[totag_col].val.str_val.len=0; } else q_vals[totag_col].val.str_val = p->to_tag; if(p->record_route.s== NULL) { q_vals[record_route_col].val.str_val.s= ""; q_vals[record_route_col].val.str_val.len = 0; } else q_vals[record_route_col].val.str_val = p->record_route; if(p->contact.s == NULL) { q_vals[contact_col].val.str_val.s = ""; q_vals[contact_col].val.str_val.len = 0; } else q_vals[contact_col].val.str_val = p->contact; if(p->remote_contact.s) { q_vals[remote_contact_col].val.str_val = p->remote_contact; LM_DBG("p->remote_contact = %.*s\n", p->remote_contact.len, p->remote_contact.s); } else { q_vals[remote_contact_col].val.str_val.s = ""; q_vals[remote_contact_col].val.str_val.len = 0; } if(p->extra_headers) q_vals[extra_headers_col].val.str_val = *(p->extra_headers); else { q_vals[extra_headers_col].val.str_val.s = ""; q_vals[extra_headers_col].val.str_val.len = 0; } if(pua_dbf.insert(pua_db, q_cols, q_vals,n_query_cols )<0) { LM_ERR("while inserting in db table pua\n"); if(!no_lock) lock_release(&HashT->p_records[i].lock); return ; } break; } } p->db_flag= NO_UPDATEDB_FLAG; p= p->next; } if(!no_lock) lock_release(&HashT->p_records[i].lock); } db_vals[0].val.int_val= (int)time(NULL)- 10; db_ops[0]= OP_LT; if(pua_dbf.delete(pua_db, db_cols, db_ops, db_vals, 1) < 0) { LM_ERR("while deleting from db table pua\n"); } return ; }
/** * init module function */ static int mod_init(void) { #ifdef HAVE_IHTTP load_ih_f load_ih; #endif int i; init_db_url( db_url , 0 /*cannot be null*/); LM_INFO("initializing ...\n"); if(!jdomain) { LM_ERR("jdomain is NULL\n"); return -1; } /* import mysql functions */ if (db_bind_mod(&db_url, &jabber_dbf)<0) { LM_ERR("database module not found\n"); return -1; } if (!DB_CAPABILITY(jabber_dbf, DB_CAP_QUERY)) { LM_ERR("database module does not implement 'query' function\n"); return -1; } db_con = (db_con_t**)shm_malloc(nrw*sizeof(db_con_t*)); if (db_con == NULL) { LM_ERR("no more shm memory\n"); return -1; } /* load the TM API */ if (load_tm_api(&tmb)!=0) { LM_ERR("can't load TM API\n"); return -1; } #ifdef HAVE_IHTTP /* import the iHTTP auto-loading function */ if ( !(load_ih=(load_ih_f)find_export("load_ih", IH_NO_SCRIPT_F, 0))) { LM_ERR("can't import load_ih\n"); return -1; } /* let the auto-loading function load all TM stuff */ if (load_ih( &ihb )==-1) return -1; #endif pipes = (int**)pkg_malloc(nrw*sizeof(int*)); if (pipes == NULL) { LM_ERR("no more pkg memory (pipes)\n"); return -1; } for(i=0; i<nrw; i++) { pipes[i] = (int*)pkg_malloc(2*sizeof(int)); if (!pipes[i]) { LM_ERR("no more pkg memory (pipes)\n"); return -1; } } for(i=0; i<nrw; i++) { db_con[i] = jabber_dbf.init(&db_url); if (!db_con[i]) { LM_ERR("failed to connect to the database\n"); return -1; } else { if (jabber_dbf.use_table(db_con[i], &db_table) < 0) { LM_ERR("use_table failed\n"); return -1; } LM_DBG("database connection opened successfully\n"); } } /** creating the pipes */ for(i=0;i<nrw;i++) { /* create the pipe*/ if (pipe(pipes[i])==-1) { LM_ERR("cannot create pipe!\n"); return -1; } LM_DBG("pipe[%d] = <%d>-<%d>\n", i, pipes[i][0], pipes[i][1]); } if((jwl = xj_wlist_init(pipes,nrw,max_jobs,cache_time,sleep_time, delay_time)) == NULL) { LM_ERR("failed to initialize workers list\n"); return -1; } if(xj_wlist_set_aliases(jwl, jaliases, jdomain, proxy) < 0) { LM_ERR("failed to set aliases and outbound proxy\n"); return -1; } LM_DBG("initialized ...\n"); return 0; }
static int mod_child_init(int rank) { int pid; int i; kz_amqp_zone_ptr g; kz_amqp_server_ptr s; fire_init_event(rank); if (rank==PROC_INIT || rank==PROC_TCP_MAIN) return 0; // if (rank>PROC_MAIN) // kz_cmd_pipe = kz_cmd_pipe_fds[1]; if (rank==PROC_MAIN) { /* pid=fork_process(PROC_NOCHLDINIT, "AMQP Timer", 0); if (pid<0) return -1; if(pid==0){ return(kz_amqp_timeout_proc()); } */ for(i=0; i < dbk_consumer_workers; i++) { pid=fork_process(i+1, "AMQP Consumer Worker", 1); if (pid<0) return -1; /* error */ if(pid==0){ close(kz_worker_pipes_fds[i*2+1]); return(kz_amqp_consumer_worker_proc(kz_worker_pipes_fds[i*2])); } } for (g = kz_amqp_get_zones(); g != NULL; g = g->next) { int w = (g == kz_amqp_get_primary_zone() ? dbk_consumer_processes : 1); for(i=0; i < w; i++) { for (s = g->servers->head; s != NULL; s = s->next) { pid=fork_process(PROC_NOCHLDINIT, "AMQP Consumer", 0); if (pid<0) return -1; /* error */ if(pid==0){ return(kz_amqp_consumer_proc(s)); } } } } pid=fork_process(PROC_NOCHLDINIT, "AMQP Publisher", 1); if (pid<0) return -1; /* error */ if(pid==0){ close(kz_cmd_pipe_fds[1]); kz_amqp_publisher_proc(kz_cmd_pipe_fds[0]); } return 0; } if(dbk_pua_mode == 1) { if (kz_pa_dbf.init==0) { LM_CRIT("child_init: database not bound\n"); return -1; } kz_pa_db = kz_pa_dbf.init(&kz_db_url); if (!kz_pa_db) { LM_ERR("child %d: unsuccessful connecting to database\n", rank); return -1; } if (kz_pa_dbf.use_table(kz_pa_db, &kz_presentity_table) < 0) { LM_ERR( "child %d:unsuccessful use_table presentity_table\n", rank); return -1; } LM_DBG("child %d: Database connection opened successfully\n", rank); } return 0; }
static int sip_trace(struct sip_msg *msg, char *s1, char *s2) { db_key_t db_keys[NR_KEYS]; db_val_t db_vals[NR_KEYS]; static char toip_buff[IP_ADDR_MAX_STR_SIZE+6]; static char fromip_buff[IP_ADDR_MAX_STR_SIZE+6]; int_str avp_value; struct usr_avp *avp; if(msg==NULL) { LM_DBG("no uas request, local transaction\n"); return -1; } avp = NULL; if(traced_user_avp.n!=0) avp=search_first_avp(traced_user_avp_type, traced_user_avp, &avp_value, 0); if((avp==NULL) && (trace_on_flag==NULL || *trace_on_flag==0)) { LM_DBG("trace off...\n"); return -1; } if(parse_from_header(msg)==-1 || msg->from==NULL || get_from(msg)==NULL) { LM_ERR("cannot parse FROM header\n"); goto error; } if(parse_headers(msg, HDR_CALLID_F, 0)!=0 || msg->callid==NULL || msg->callid->body.s==NULL) { LM_ERR("cannot parse call-id\n"); goto error; } db_keys[0] = msg_column; db_vals[0].type = DB_BLOB; db_vals[0].nul = 0; db_vals[0].val.blob_val.s = msg->buf; db_vals[0].val.blob_val.len = msg->len; db_keys[1] = callid_column; db_vals[1].type = DB_STR; db_vals[1].nul = 0; db_vals[1].val.str_val.s = msg->callid->body.s; db_vals[1].val.str_val.len = msg->callid->body.len; db_keys[2] = method_column; db_vals[2].type = DB_STR; db_vals[2].nul = 0; if(msg->first_line.type==SIP_REQUEST) { db_vals[2].val.str_val.s = msg->first_line.u.request.method.s; db_vals[2].val.str_val.len = msg->first_line.u.request.method.len; } else { db_vals[2].val.str_val.s = ""; db_vals[2].val.str_val.len = 0; } db_keys[3] = status_column; db_vals[3].type = DB_STR; db_vals[3].nul = 0; if(msg->first_line.type==SIP_REPLY) { db_vals[3].val.str_val.s = msg->first_line.u.reply.status.s; db_vals[3].val.str_val.len = msg->first_line.u.reply.status.len; } else { db_vals[3].val.str_val.s = ""; db_vals[3].val.str_val.len = 0; } db_keys[4] = fromip_column; db_vals[4].type = DB_STRING; db_vals[4].nul = 0; siptrace_copy_proto(msg->rcv.proto, fromip_buff); strcat(fromip_buff, ip_addr2a(&msg->rcv.src_ip)); strcat(fromip_buff,":"); strcat(fromip_buff, int2str(msg->rcv.src_port, NULL)); db_vals[4].val.string_val = fromip_buff; db_keys[5] = toip_column; db_vals[5].type = DB_STRING; db_vals[5].nul = 0; // db_vals[5].val.string_val = ip_addr2a(&msg->rcv.dst_ip);; siptrace_copy_proto(msg->rcv.proto, toip_buff); strcat(toip_buff, ip_addr2a(&msg->rcv.dst_ip)); strcat(toip_buff,":"); strcat(toip_buff, int2str(msg->rcv.dst_port, NULL)); db_vals[5].val.string_val = toip_buff; db_keys[6] = date_column; db_vals[6].type = DB_DATETIME; db_vals[6].nul = 0; db_vals[6].val.time_val = time(NULL); db_keys[7] = direction_column; db_vals[7].type = DB_STRING; db_vals[7].nul = 0; db_vals[7].val.string_val = "in"; db_keys[8] = fromtag_column; db_vals[8].type = DB_STR; db_vals[8].nul = 0; db_vals[8].val.str_val.s = get_from(msg)->tag_value.s; db_vals[8].val.str_val.len = get_from(msg)->tag_value.len; db_funcs.use_table(db_con, siptrace_get_table()); db_keys[9] = traced_user_column; db_vals[9].type = DB_STR; db_vals[9].nul = 0; if(trace_on_flag!=NULL && *trace_on_flag!=0) { db_vals[9].val.str_val.s = ""; db_vals[9].val.str_val.len = 0; LM_DBG("storing info...\n"); if(db_funcs.insert(db_con, db_keys, db_vals, NR_KEYS) < 0) { LM_ERR("error storing trace\n"); goto error; } #ifdef STATISTICS if(msg->first_line.type==SIP_REPLY) { update_stat(siptrace_rpl, 1); } else { update_stat(siptrace_req, 1); } #endif } if(avp==NULL) goto done; trace_send_duplicate(db_vals[0].val.blob_val.s, db_vals[0].val.blob_val.len); db_vals[9].val.str_val.s = avp_value.s.s; db_vals[9].val.str_val.len = avp_value.s.len; LM_DBG("storing info...\n"); if(db_funcs.insert(db_con, db_keys, db_vals, NR_KEYS) < 0) { LM_ERR("error storing trace\n"); goto error; } avp = search_next_avp( avp, &avp_value); while(avp!=NULL) { db_vals[9].val.str_val.s = avp_value.s.s; db_vals[9].val.str_val.len = avp_value.s.len; LM_DBG("storing info...\n"); if(db_funcs.insert(db_con, db_keys, db_vals, NR_KEYS) < 0) { LM_ERR("error storing trace\n"); goto error; } avp = search_next_avp( avp, &avp_value); } done: return 1; error: return -1; }