int ast_custom_payload_sipinfo_decode(struct ast_custom_payload *pl, struct ast_variable **headers, char **content_type, char **content, char **useragent_filter) { struct custom_sipinfo *sipinfo; struct ast_variable *cur = NULL; char *data; int i; *headers = NULL; *content_type = NULL; *content = NULL; *useragent_filter = NULL; if (pl->type != AST_CUSTOM_SIP_INFO) { return -1; } sipinfo = (struct custom_sipinfo *) pl->data; data = sipinfo->data; for (i = 0; i < sipinfo->num_headers; i++) { const char *name; const char *value; name = data; data += strlen(name) + 1; value = data; data += strlen(value) + 1; if (*headers) { if ((cur->next = ast_variable_new(name, value, ""))) { cur = cur->next; } } else { *headers = cur = ast_variable_new(name, value, ""); } } if (sipinfo->content_present) { *content_type = ast_strdup(data); data += strlen(data) + 1; *content = ast_strdup(data); data += strlen(data) + 1; } if (sipinfo->useragent_filter_present) { *useragent_filter = ast_strdup(data); } return 0; }
int ast_json_to_ast_variables(struct ast_json *json_variables, struct ast_variable **variables) { struct ast_json_iter *it_json_var; *variables = NULL; for (it_json_var = ast_json_object_iter(json_variables); it_json_var; it_json_var = ast_json_object_iter_next(json_variables, it_json_var)) { struct ast_variable *new_var; const char *key = ast_json_object_iter_key(it_json_var); if (ast_strlen_zero(key)) { continue; } new_var = ast_variable_new(key, ast_json_string_get(ast_json_object_iter_value(it_json_var)), ""); if (!new_var) { ast_variables_destroy(*variables); *variables = NULL; return -1; } ast_variable_list_append(variables, new_var); } return 0; }
static int localnet_to_vl(const void *obj, struct ast_variable **fields) { const struct ast_sip_transport *transport = obj; char str[MAX_OBJECT_FIELD]; struct ast_variable *head = NULL; struct ast_ha *ha; RAII_VAR(struct ast_sip_transport_state *, state, find_state_by_transport(transport), ao2_cleanup); if (!state) { return -1; } for (ha = state->localnet; ha; ha = ha->next) { const char *addr = ast_strdupa(ast_sockaddr_stringify_addr(&ha->addr)); snprintf(str, MAX_OBJECT_FIELD, "%s%s/%s", ha->sense == AST_SENSE_ALLOW ? "!" : "", addr, ast_sockaddr_stringify_addr(&ha->netmask)); ast_variable_list_append(&head, ast_variable_new("local_net", str, "")); } if (head) { *fields = head; } return 0; }
static int json_to_ast_variables(struct ast_json *json_variables, struct ast_variable **variables) { struct ast_variable *current = NULL; struct ast_json_iter *it_json_var; for (it_json_var = ast_json_object_iter(json_variables); it_json_var; it_json_var = ast_json_object_iter_next(json_variables, it_json_var)) { struct ast_variable *new_var; new_var = ast_variable_new(ast_json_object_iter_key(it_json_var), ast_json_string_get(ast_json_object_iter_value(it_json_var)), ""); if (!new_var) { ast_variables_destroy(*variables); *variables = NULL; return 1; } if (!current) { *variables = new_var; current = *variables; } else { current->next = new_var; current = new_var; } } return 0; }
static int on_aor_update_endpoint_state(void *obj, void *arg, int flags) { struct ast_sip_aor *aor = obj; struct ao2_container *endpoints; RAII_VAR(struct ast_variable *, var, NULL, ast_variables_destroy); const char *aor_name = ast_sorcery_object_get_id(aor); char *aor_like; if (ast_strlen_zero(aor_name)) { return -1; } if (aor->permanent_contacts && ((int)(aor->qualify_frequency * 1000)) <= 0) { aor_like = ast_alloca(strlen(aor_name) + 3); sprintf(aor_like, "%%%s%%", aor_name); var = ast_variable_new("aors LIKE", aor_like, ""); if (!var) { return -1; } endpoints = ast_sorcery_retrieve_by_fields(ast_sip_get_sorcery(), "endpoint", AST_RETRIEVE_FLAG_MULTIPLE, var); if (endpoints) { /* * Because aors are a string list, we have to use a pattern match but since a simple * pattern match could return an endpoint that has an aor of "aaabccc" when searching * for "abc", we still have to iterate over them to find an exact aor match. */ ao2_callback(endpoints, 0, aor_update_endpoint_state, (char *)aor_name); ao2_ref(endpoints, -1); } } return 0; }
static void qualify_and_schedule_all(void) { struct ast_variable *var = ast_variable_new("qualify_frequency >", "0", ""); struct ao2_container *aors; struct ao2_container *contacts; if (!var) { return; } aors = ast_sorcery_retrieve_by_fields(ast_sip_get_sorcery(), "aor", AST_RETRIEVE_FLAG_MULTIPLE, var); ao2_callback(sched_qualifies, OBJ_NODATA | OBJ_MULTIPLE | OBJ_UNLINK, unschedule_all_cb, NULL); if (aors) { ao2_callback(aors, OBJ_NODATA, qualify_and_schedule_all_cb, NULL); ao2_ref(aors, -1); } contacts = ast_sorcery_retrieve_by_fields(ast_sip_get_sorcery(), "contact", AST_RETRIEVE_FLAG_MULTIPLE, var); if (contacts) { ao2_callback(contacts, OBJ_NODATA, qualify_and_schedule_cb_without_aor, NULL); ao2_ref(contacts, -1); } ast_variables_destroy(var); }
static struct ast_config *realtime_directory(char *context) { struct ast_config *cfg; struct ast_config *rtdata; struct ast_category *cat; struct ast_variable *var; char *mailbox; char *fullname; char *hidefromdir; char tmp[100]; /* Load flat file config. */ cfg = ast_config_load(VOICEMAIL_CONFIG); if (!cfg) { /* Loading config failed. */ ast_log(LOG_WARNING, "Loading config failed.\n"); return NULL; } /* Get realtime entries, categorized by their mailbox number and present in the requested context */ rtdata = ast_load_realtime_multientry("voicemail", "mailbox LIKE", "%", "context", context, NULL); /* if there are no results, just return the entries from the config file */ if (!rtdata) return cfg; /* Does the context exist within the config file? If not, make one */ cat = ast_category_get(cfg, context); if (!cat) { cat = ast_category_new(context); if (!cat) { ast_log(LOG_WARNING, "Out of memory\n"); ast_config_destroy(cfg); return NULL; } ast_category_append(cfg, cat); } mailbox = ast_category_browse(rtdata, NULL); while (mailbox) { fullname = ast_variable_retrieve(rtdata, mailbox, "fullname"); hidefromdir = ast_variable_retrieve(rtdata, mailbox, "hidefromdir"); snprintf(tmp, sizeof(tmp), "no-password,%s,hidefromdir=%s", fullname ? fullname : "", hidefromdir ? hidefromdir : "no"); var = ast_variable_new(mailbox, tmp); if (var) ast_variable_append(cat, var); else ast_log(LOG_WARNING, "Out of memory adding mailbox '%s'\n", mailbox); mailbox = ast_category_browse(rtdata, mailbox); } ast_config_destroy(rtdata); return cfg; }
static int contact_to_var_list(void *object, void *arg, int flags) { struct ast_sip_contact_wrapper *wrapper = object; struct ast_variable **var = arg; ast_variable_list_append(&*var, ast_variable_new("contact", wrapper->contact->uri, "")); return 0; }
/*! * \brief Verifies a user event header/value pair * * \param user_event which user event to check * \param header The header to verify * \param value The value read from the event * * \retval -1 on error or evaluation failure * \retval 0 if match not needed or success */ static int verify_user_event_fields(int user_event, const char *header, const char *value) { struct ast_variable *current; struct ast_variable *expected; regex_t regexbuf; int error; if (user_event >= AST_VECTOR_SIZE(&expected_user_event_fields)) { return -1; } expected = AST_VECTOR_GET(&expected_user_event_fields, user_event); if (!expected) { return -1; } for (current = expected; current; current = current->next) { struct ast_variable *bad_header; if (strcmp(current->name, header)) { continue; } error = regcomp(®exbuf, current->value, REG_EXTENDED | REG_NOSUB); if (error) { char error_buf[128]; regerror(error, ®exbuf, error_buf, sizeof(error_buf)); ast_log(LOG_ERROR, "Failed to compile regex '%s' for header check '%s': %s\n", current->value, current->name, error_buf); return -1; } if (!regexec(®exbuf, value, 0, NULL, 0)) { regfree(®exbuf); return 0; } bad_header = ast_variable_new(header, value, __FILE__); if (bad_header) { struct ast_variable *bad_headers_head = NULL; if (user_event < AST_VECTOR_SIZE(&bad_headers)) { bad_headers_head = AST_VECTOR_GET(&bad_headers, user_event); } ast_variable_list_append(&bad_headers_head, bad_header); AST_VECTOR_INSERT(&bad_headers, user_event, bad_headers_head); } regfree(®exbuf); return -1; } return 0; }
static void update_all_unqualified_endpoints(void) { struct ao2_container *aors; struct ao2_container *contacts; RAII_VAR(struct ast_variable *, var_aor, NULL, ast_variables_destroy); RAII_VAR(struct ast_variable *, var_contact, NULL, ast_variables_destroy); RAII_VAR(char *, time_now, NULL, ast_free); struct timeval tv = ast_tvnow(); if (!(var_aor = ast_variable_new("contact !=", "", ""))) { return; } if (!(var_aor->next = ast_variable_new("qualify_frequency <=", "0", ""))) { return; } if (ast_asprintf(&time_now, "%ld", tv.tv_sec) == -1) { return; } if (!(var_contact = ast_variable_new("expiration_time >", time_now, ""))) { return; } if (!(var_contact->next = ast_variable_new("qualify_frequency <=", "0", ""))) { return; } aors = ast_sorcery_retrieve_by_fields(ast_sip_get_sorcery(), "aor", AST_RETRIEVE_FLAG_MULTIPLE, var_aor); if (aors) { ao2_callback(aors, OBJ_NODATA, on_aor_update_endpoint_state, NULL); ao2_ref(aors, -1); } contacts = ast_sorcery_retrieve_by_fields(ast_sip_get_sorcery(), "contact", AST_RETRIEVE_FLAG_MULTIPLE, var_contact); if (contacts) { ao2_callback(contacts, OBJ_NODATA, contact_update_endpoint_state, NULL); ao2_ref(contacts, -1); } }
static int realtime_sorcery_update(const char *database, const char *table, const char *keyfield, const char *entity, const struct ast_variable *fields) { struct ast_category *object, *found; if (!(found = ast_category_get(realtime_objects, entity, NULL))) { return 0; } else if (!(object = ast_category_new(entity, "", 0))) { return -1; } ast_category_delete(realtime_objects, found); ast_variable_append(object, ast_variables_dup((struct ast_variable*)fields)); ast_variable_append(object, ast_variable_new(keyfield, entity, "")); ast_category_append(realtime_objects, object); return 1; }
static int sorcery_realtime_create(const struct ast_sorcery *sorcery, void *data, void *object) { const char *family = data; RAII_VAR(struct ast_variable *, fields, ast_sorcery_objectset_create(sorcery, object), ast_variables_destroy); struct ast_variable *id = ast_variable_new(UUID_FIELD, ast_sorcery_object_get_id(object), ""); if (!fields || !id) { ast_variables_destroy(id); return -1; } /* Place the identifier at the front for sanity sake */ id->next = fields; fields = id; return (ast_store_realtime_fields(family, fields) <= 0) ? -1 : 0; }
enum ast_json_to_ast_vars_code ast_json_to_ast_variables(struct ast_json *json_variables, struct ast_variable **variables) { struct ast_json_iter *it_json_var; *variables = NULL; for (it_json_var = ast_json_object_iter(json_variables); it_json_var; it_json_var = ast_json_object_iter_next(json_variables, it_json_var)) { struct ast_variable *new_var; const char *key = ast_json_object_iter_key(it_json_var); const char *value; struct ast_json *json_value; if (ast_strlen_zero(key)) { continue; } json_value = ast_json_object_iter_value(it_json_var); if (ast_json_typeof(json_value) != AST_JSON_STRING) { /* Error: Only strings allowed */ ast_variables_destroy(*variables); *variables = NULL; return AST_JSON_TO_AST_VARS_CODE_INVALID_TYPE; } value = ast_json_string_get(json_value); /* Should never be NULL. Otherwise, how could it be a string type? */ ast_assert(value != NULL); if (!value) { /* To be safe. */ continue; } new_var = ast_variable_new(key, value, ""); if (!new_var) { /* Error: OOM */ ast_variables_destroy(*variables); *variables = NULL; return AST_JSON_TO_AST_VARS_CODE_OOM; } ast_variable_list_append(variables, new_var); } return AST_JSON_TO_AST_VARS_CODE_SUCCESS; }
static void sorcery_realtime_retrieve_regex(const struct ast_sorcery *sorcery, void *data, const char *type, struct ao2_container *objects, const char *regex) { char field[strlen(UUID_FIELD) + 6], value[strlen(regex) + 3]; RAII_VAR(struct ast_variable *, fields, NULL, ast_variables_destroy); /* The realtime API provides no direct ability to do regex so for now we support a limited subset using pattern matching */ snprintf(field, sizeof(field), "%s LIKE", UUID_FIELD); if (regex[0] == '^') { snprintf(value, sizeof(value), "%s%%", regex + 1); } else { snprintf(value, sizeof(value), "%%%s%%", regex); } if (!(fields = ast_variable_new(field, value, ""))) { return; } sorcery_realtime_retrieve_multiple(sorcery, data, type, objects, fields); }
/*! \brief Helper function which converts a json object to a sorcery object set */ static struct ast_variable *sorcery_json_to_objectset(struct ast_json *json) { struct ast_json_iter *field; struct ast_variable *objset = NULL; for (field = ast_json_object_iter(json); field; field = ast_json_object_iter_next(json, field)) { struct ast_json *value = ast_json_object_iter_value(field); struct ast_variable *variable = ast_variable_new(ast_json_object_iter_key(field), ast_json_string_get(value), ""); if (!variable) { ast_variables_destroy(objset); return NULL; } variable->next = objset; objset = variable; } return objset; }
/*! * \brief Build ast_config struct from above definitions * * \retval NULL Failed to build the config * \retval non-NULL An ast_config struct populated with data */ static struct ast_config *build_cfg(void) { struct ast_config *cfg; struct association *cat_iter; struct pair *var_iter; size_t i; size_t j; cfg = ast_config_new(); if (!cfg) { goto fail; } for (i = 0; i < ARRAY_LEN(categories); ++i) { struct ast_category *cat; cat_iter = &categories[i]; cat = ast_category_new(cat_iter->category, "", 999999); if (!cat) { goto fail; } ast_category_append(cfg, cat); for (j = 0; j < ARRAY_LEN(cat_iter->vars); ++j) { struct ast_variable *var; var_iter = &cat_iter->vars[j]; var = ast_variable_new(var_iter->name, var_iter->val, ""); if (!var) { goto fail; } ast_variable_append(cat, var); } } return cfg; fail: ast_config_destroy(cfg); return NULL; }
static void sorcery_realtime_retrieve_multiple(const struct ast_sorcery *sorcery, void *data, const char *type, struct ao2_container *objects, const struct ast_variable *fields) { const char *family = data; RAII_VAR(struct ast_config *, rows, NULL, ast_config_destroy); RAII_VAR(struct ast_variable *, all, NULL, ast_variables_destroy); struct ast_category *row = NULL; if (!fields) { char field[strlen(UUID_FIELD) + 6], value[2]; /* If no fields have been specified we want all rows, so trick realtime into doing it */ snprintf(field, sizeof(field), "%s LIKE", UUID_FIELD); snprintf(value, sizeof(value), "%%"); if (!(all = ast_variable_new(field, value, ""))) { return; } fields = all; } if (!(rows = ast_load_realtime_multientry_fields(family, fields))) { return; } while ((row = ast_category_browse_filtered(rows, NULL, row, NULL))) { struct ast_variable *objectset = ast_category_detach_variables(row); RAII_VAR(struct ast_variable *, id, NULL, ast_variables_destroy); RAII_VAR(void *, object, NULL, ao2_cleanup); objectset = sorcery_realtime_filter_objectset(objectset, &id, sorcery, type); if (id && (object = ast_sorcery_alloc(sorcery, type, id->value)) && !ast_sorcery_objectset_apply(sorcery, object, objectset)) { ao2_link(objects, object); } ast_variables_destroy(objectset); } }
static struct ast_variable *parse_cookies(char *cookies) { char *cur; struct ast_variable *vars = NULL, *var; /* Skip Cookie: */ cookies += 8; while ((cur = strsep(&cookies, ";"))) { char *name, *val; name = val = cur; strsep(&val, "="); if (ast_strlen_zero(name) || ast_strlen_zero(val)) { continue; } name = ast_strip(name); val = ast_strip_quoted(val, "\"", "\""); if (ast_strlen_zero(name) || ast_strlen_zero(val)) { continue; } if (option_debug) { ast_log(LOG_DEBUG, "mmm ... cookie! Name: '%s' Value: '%s'\n", name, val); } var = ast_variable_new(name, val); var->next = vars; vars = var; } return vars; }
/*! * \internal * \brief Find an endpoint associated with the given contact. */ static struct ast_sip_endpoint *find_an_endpoint(struct ast_sip_contact *contact) { struct ao2_container *endpoints; struct ast_sip_endpoint *endpoint; struct ast_variable *var; char *aor = ast_alloca(strlen(contact->aor) + 3); sprintf(aor, "%%%s%%", contact->aor); var = ast_variable_new("aors LIKE", aor, ""); endpoints = ast_sorcery_retrieve_by_fields(ast_sip_get_sorcery(), "endpoint", AST_RETRIEVE_FLAG_MULTIPLE, var); ast_variables_destroy(var); /* * Because aors are a string list, we have to use a pattern match but since a simple * pattern match could return an endpoint that has an aor of "aaabccc" when searching * for "abc", we still have to iterate over them to find an exact aor match. */ endpoint = ao2_callback(endpoints, 0, on_endpoint, (char *)contact->aor); ao2_ref(endpoints, -1); return endpoint; }
static struct ast_config *config_curl(const char *url, const char *unused, const char *file, struct ast_config *cfg, struct ast_flags flags, const char *sugg_incl, const char *who_asked) { struct ast_str *query, *buffer; char buf1[200]; char *stringp, *line, *pair, *key; int last_cat_metric = -1, cat_metric = -1; struct ast_category *cat = NULL; char *cur_cat = ""; char *category = "", *var_name = "", *var_val = ""; struct ast_flags loader_flags = { 0 }; if (!ast_custom_function_find("CURL")) { ast_log(LOG_ERROR, "func_curl.so must be loaded in order to use res_config_curl.so!!\n"); return NULL; } if (!(query = ast_str_thread_get(&query_buf, 100))) { return NULL; } if (!(buffer = ast_str_thread_get(&result_buf, 16))) { return NULL; } ast_uri_encode(file, buf1, sizeof(buf1), ast_uri_http); ast_str_set(&query, 0, "${CURL(%s/static?file=%s)}", url, buf1); /* Do the CURL query */ ast_str_substitute_variables(&buffer, 0, NULL, ast_str_buffer(query)); /* Line oriented output */ stringp = ast_str_buffer(buffer); cat = ast_config_get_current_category(cfg); while ((line = strsep(&stringp, "\r\n"))) { if (ast_strlen_zero(line)) { continue; } while ((pair = strsep(&line, "&"))) { key = strsep(&pair, "="); ast_uri_decode(key, ast_uri_http); if (pair) { ast_uri_decode(pair, ast_uri_http); } if (!strcasecmp(key, "category")) { category = S_OR(pair, ""); } else if (!strcasecmp(key, "var_name")) { var_name = S_OR(pair, ""); } else if (!strcasecmp(key, "var_val")) { var_val = S_OR(pair, ""); } else if (!strcasecmp(key, "cat_metric")) { cat_metric = pair ? atoi(pair) : 0; } } if (!strcmp(var_name, "#include")) { if (!ast_config_internal_load(var_val, cfg, loader_flags, "", who_asked)) return NULL; } if (!cat || strcmp(category, cur_cat) || last_cat_metric != cat_metric) { if (!(cat = ast_category_new(category, "", 99999))) break; cur_cat = category; last_cat_metric = cat_metric; ast_category_append(cfg, cat); } ast_variable_append(cat, ast_variable_new(var_name, var_val, "")); } return cfg; }
void ast_ari_invoke(struct ast_tcptls_session_instance *ser, const char *uri, enum ast_http_method method, struct ast_variable *get_params, struct ast_variable *headers, struct ast_ari_response *response) { RAII_VAR(struct stasis_rest_handlers *, root, NULL, ao2_cleanup); struct stasis_rest_handlers *handler; RAII_VAR(struct ast_variable *, path_vars, NULL, ast_variables_destroy); char *path = ast_strdupa(uri); char *path_segment; stasis_rest_callback callback; root = handler = get_root_handler(); ast_assert(root != NULL); while ((path_segment = strsep(&path, "/")) && (strlen(path_segment) > 0)) { struct stasis_rest_handlers *found_handler = NULL; int i; ast_uri_decode(path_segment, ast_uri_http_legacy); ast_debug(3, "Finding handler for %s\n", path_segment); for (i = 0; found_handler == NULL && i < handler->num_children; ++i) { struct stasis_rest_handlers *child = handler->children[i]; ast_debug(3, " Checking %s\n", child->path_segment); if (child->is_wildcard) { /* Record the path variable */ struct ast_variable *path_var = ast_variable_new(child->path_segment, path_segment, __FILE__); path_var->next = path_vars; path_vars = path_var; found_handler = child; } else if (strcmp(child->path_segment, path_segment) == 0) { found_handler = child; } } if (found_handler == NULL) { /* resource not found */ ast_debug(3, " Handler not found\n"); ast_ari_response_error( response, 404, "Not Found", "Resource not found"); return; } else { ast_debug(3, " Got it!\n"); handler = found_handler; } } ast_assert(handler != NULL); if (method == AST_HTTP_OPTIONS) { handle_options(handler, headers, response); return; } if (method < 0 || method >= AST_HTTP_MAX_METHOD) { add_allow_header(handler, response); ast_ari_response_error( response, 405, "Method Not Allowed", "Invalid method"); return; } if (handler->ws_server && method == AST_HTTP_GET) { /* WebSocket! */ ari_handle_websocket(handler->ws_server, ser, uri, method, get_params, headers); /* Since the WebSocket code handles the connection, we shouldn't * do anything else; setting no_response */ response->no_response = 1; return; } callback = handler->callbacks[method]; if (callback == NULL) { add_allow_header(handler, response); ast_ari_response_error( response, 405, "Method Not Allowed", "Invalid method"); return; } callback(ser, get_params, path_vars, headers, response); if (response->message == NULL && response->response_code == 0) { /* Really should not happen */ ast_log(LOG_ERROR, "ARI %s %s not implemented\n", ast_get_http_method(method), uri); ast_ari_response_error( response, 501, "Not Implemented", "Method not implemented"); } }
static struct ast_config *config_sqlite(const char *database, const char *table, const char *file, struct ast_config *cfg) { struct ast_variable *new_v, *v; struct ast_category *cur_cat; char ttable[ARRAY_SIZE]; int configured = 0, res = 0; sqlite3_stmt *stmt = NULL;; int cat_metric=0, last_cat_metric=0; char sql[ARRAY_SIZE]; char last[ARRAY_SIZE] = ""; char path[ARRAY_SIZE]; sqlite3 *db; int running=0; int i=0; struct ast_config *config; /* if the data was not passed from extconfig.conf then get it from sqlite.conf */ if(!database || ast_strlen_zero(database)) { if (!file || !strcmp (file, "res_sqlite.conf")) return NULL; // cant configure myself with myself ! config = ast_config_load ("res_sqlite.conf"); if (config) { for (v = ast_variable_browse (config, "config"); v; v = v->next) { if (!strcmp (v->name, "table")) { strncpy (ttable, v->value, sizeof (ttable)); configured++; } else if (!strcmp (v->name, "dbfile")) { pick_path(v->value,path,ARRAY_SIZE); configured++; } } ast_config_destroy (config); } } else { pick_path((char *)database,path,ARRAY_SIZE); strncpy (ttable, table, sizeof (ttable)); configured = 2; } if (configured < 2) return NULL; db=open_db(path); if (!db) return NULL; sprintf (sql, "select * from %s where filename='%s' and commented=0 order by filename,cat_metric desc,var_metric asc,id", ttable, file); res = sqlite3_prepare(db,sql,0,&stmt,0); if (res) { ast_log (LOG_WARNING, "SQL select error [%s]!\n[%s]\n\n",sqlite3_errmsg(db), sql); return NULL; } cur_cat = ast_config_get_current_category(cfg); /* 0 id int 1 cat_metric int not null default 0, 2 var_metric int not null default 0, 3 commented int not null default 0, 4 filename varchar(128) not null, 5 category varchar(128) not null default 'default', 6 var_name varchar(128) not null, 7 var_val varchar(128) not null */ running = 1; while (running) { res = sqlite3_step(stmt); running = 1; switch( res ){ case SQLITE_DONE: running = 0 ; break; case SQLITE_BUSY: sleep(2); running = 2; break ; case SQLITE_ERROR: running = 0; break; case SQLITE_MISUSE: running = 0; break; case SQLITE_ROW: default: break; } if (!running) break; if (running == 2) continue; if(option_verbose > 4) for(i=0;i<8;i++){ ast_verbose(VERBOSE_PREFIX_3"SQLite Config: %d=%s\n",i,sqlite3_column_text(stmt,i)); } if (strcmp (last, sqlite3_column_text(stmt,5)) || last_cat_metric != cat_metric) { cur_cat = ast_category_new((char *)sqlite3_column_text(stmt,5)); if (!cur_cat) { ast_log(LOG_WARNING, "Out of memory!\n"); break; } strcpy (last, sqlite3_column_text(stmt,5)); last_cat_metric = cat_metric; ast_category_append(cfg, cur_cat); } new_v = ast_variable_new ((char *)sqlite3_column_text(stmt,6), (char *)sqlite3_column_text(stmt,7)); ast_variable_append(cur_cat, new_v); } if ((sqlite3_finalize(stmt))) ast_log(LOG_ERROR,"ERROR: %s\n",sqlite3_errmsg(db)); return cfg; }
static char *handle_uri(struct sockaddr_in *sin, char *uri, int *status, char **title, int *contentlength, struct ast_variable **cookies, unsigned int *static_content) { char *c; char *turi; char *params; char *var; char *val; struct ast_http_uri *urih=NULL; int len; struct ast_variable *vars=NULL, *v, *prev = NULL; params = strchr(uri, '?'); if (params) { *params = '\0'; params++; while ((var = strsep(¶ms, "&"))) { val = strchr(var, '='); if (val) { *val = '\0'; val++; ast_uri_decode(val); } else val = ""; ast_uri_decode(var); if ((v = ast_variable_new(var, val))) { if (vars) prev->next = v; else vars = v; prev = v; } } } if (prev) prev->next = *cookies; else vars = *cookies; *cookies = NULL; ast_uri_decode(uri); if (!strncasecmp(uri, prefix, prefix_len)) { uri += prefix_len; if (!*uri || (*uri == '/')) { if (*uri == '/') uri++; ast_rwlock_rdlock(&uris_lock); urih = uris; while(urih) { len = strlen(urih->uri); if (!strncasecmp(urih->uri, uri, len)) { if (!uri[len] || uri[len] == '/') { turi = uri + len; if (*turi == '/') turi++; if (!*turi || urih->has_subtree) { uri = turi; break; } } } urih = urih->next; } if (!urih) ast_rwlock_unlock(&uris_lock); } } if (urih) { if (urih->static_content) *static_content = 1; c = urih->callback(sin, uri, vars, status, title, contentlength); ast_rwlock_unlock(&uris_lock); } else if (ast_strlen_zero(uri) && ast_strlen_zero(prefix)) { /* Special case: If no prefix, and no URI, send to /static/index.html */ c = ast_http_error(302, "Moved Temporarily", "Location: /static/index.html\r\n", "Redirecting to /static/index.html."); *status = 302; *title = strdup("Moved Temporarily"); } else { c = ast_http_error(404, "Not Found", NULL, "The requested URL was not found on this server."); *status = 404; *title = strdup("Not Found"); } ast_variables_destroy(vars); return c; }
static struct ast_variable *realtime_pgsql(const char *database, const char *table, va_list ap) { PGresult *result = NULL; int num_rows = 0; char sql[256]; char *stringp; char *chunk; char *op; const char *newparam, *newval; struct ast_variable *var = NULL, *prev = NULL; if (!table) { ast_log(LOG_WARNING, "Postgresql RealTime: No table specified.\n"); return NULL; } /* Get the first parameter and first value in our list of passed paramater/value pairs */ newparam = va_arg(ap, const char *); newval = va_arg(ap, const char *); if (!newparam || !newval) { ast_log(LOG_WARNING, "Postgresql RealTime: Realtime retrieval requires at least 1 parameter and 1 value to search on.\n"); if (pgsqlConn) { PQfinish(pgsqlConn); pgsqlConn = NULL; }; return NULL; } /* Create the first part of the query using the first parameter/value pairs we just extracted If there is only 1 set, then we have our query. Otherwise, loop thru the list and concat */ op = strchr(newparam, ' ') ? "" : " ="; snprintf(sql, sizeof(sql), "SELECT * FROM %s WHERE %s%s '%s'", table, newparam, op, newval); while ((newparam = va_arg(ap, const char *))) { newval = va_arg(ap, const char *); if (!strchr(newparam, ' ')) op = " ="; else op = ""; snprintf(sql + strlen(sql), sizeof(sql) - strlen(sql), " AND %s%s '%s'", newparam, op, newval); } va_end(ap); /* We now have our complete statement; Lets connect to the server and execute it. */ ast_mutex_lock(&pgsql_lock); if (!pgsql_reconnect(database)) { ast_mutex_unlock(&pgsql_lock); return NULL; } if (!(result = PQexec(pgsqlConn, sql))) { ast_log(LOG_WARNING, "Postgresql RealTime: Failed to query database. Check debug for more info.\n"); ast_log(LOG_DEBUG, "Postgresql RealTime: Query: %s\n", sql); ast_log(LOG_DEBUG, "Postgresql RealTime: Query Failed because: %s\n", PQerrorMessage(pgsqlConn)); ast_mutex_unlock(&pgsql_lock); return NULL; } else { ExecStatusType result_status = PQresultStatus(result); if (result_status != PGRES_COMMAND_OK && result_status != PGRES_TUPLES_OK && result_status != PGRES_NONFATAL_ERROR) { ast_log(LOG_WARNING, "Postgresql RealTime: Failed to query database. Check debug for more info.\n"); ast_log(LOG_DEBUG, "Postgresql RealTime: Query: %s\n", sql); ast_log(LOG_DEBUG, "Postgresql RealTime: Query Failed because: %s (%s)\n", PQresultErrorMessage(result), PQresStatus(result_status)); ast_mutex_unlock(&pgsql_lock); return NULL; } } ast_log(LOG_DEBUG, "1Postgresql RealTime: Result=%p Query: %s\n", result, sql); if ((num_rows = PQntuples(result)) > 0) { int i = 0; int rowIndex = 0; int numFields = PQnfields(result); char **fieldnames = NULL; ast_log(LOG_DEBUG, "Postgresql RealTime: Found %d rows.\n", num_rows); if (!(fieldnames = ast_calloc(1, numFields * sizeof(char *)))) { ast_mutex_unlock(&pgsql_lock); PQclear(result); return NULL; } for (i = 0; i < numFields; i++) fieldnames[i] = PQfname(result, i); for (rowIndex = 0; rowIndex < num_rows; rowIndex++) { for (i = 0; i < numFields; i++) { stringp = PQgetvalue(result, rowIndex, i); while (stringp) { chunk = strsep(&stringp, ";"); if (chunk && !ast_strlen_zero(ast_strip(chunk))) { if (prev) { prev->next = ast_variable_new(fieldnames[i], chunk); if (prev->next) { prev = prev->next; } } else { prev = var = ast_variable_new(fieldnames[i], chunk); } } } } } free(fieldnames); } else { ast_log(LOG_WARNING, "Postgresql RealTime: Could not find any rows in table %s.\n", table); } ast_mutex_unlock(&pgsql_lock); PQclear(result); return var; }
static struct ast_config *config_pgsql(const char *database, const char *table, const char *file, struct ast_config *cfg, int withcomments) { PGresult *result = NULL; long num_rows; struct ast_variable *new_v; struct ast_category *cur_cat = NULL; char sqlbuf[1024] = ""; char *sql; size_t sqlleft = sizeof(sqlbuf); char last[80] = ""; int last_cat_metric = 0; last[0] = '\0'; if (!file || !strcmp(file, RES_CONFIG_PGSQL_CONF)) { ast_log(LOG_WARNING, "Postgresql RealTime: Cannot configure myself.\n"); return NULL; } ast_build_string(&sql, &sqlleft, "SELECT category, var_name, var_val, cat_metric FROM %s ", table); ast_build_string(&sql, &sqlleft, "WHERE filename='%s' and commented=0", file); ast_build_string(&sql, &sqlleft, "ORDER BY cat_metric DESC, var_metric ASC, category, var_name "); ast_log(LOG_DEBUG, "Postgresql RealTime: Static SQL: %s\n", sqlbuf); /* We now have our complete statement; Lets connect to the server and execute it. */ ast_mutex_lock(&pgsql_lock); if (!pgsql_reconnect(database)) { ast_mutex_unlock(&pgsql_lock); return NULL; } if (!(result = PQexec(pgsqlConn, sqlbuf))) { ast_log(LOG_WARNING, "Postgresql RealTime: Failed to query database. Check debug for more info.\n"); ast_log(LOG_DEBUG, "Postgresql RealTime: Query: %s\n", sql); ast_log(LOG_DEBUG, "Postgresql RealTime: Query Failed because: %s\n", PQerrorMessage(pgsqlConn)); ast_mutex_unlock(&pgsql_lock); return NULL; } else { ExecStatusType result_status = PQresultStatus(result); if (result_status != PGRES_COMMAND_OK && result_status != PGRES_TUPLES_OK && result_status != PGRES_NONFATAL_ERROR) { ast_log(LOG_WARNING, "Postgresql RealTime: Failed to query database. Check debug for more info.\n"); ast_log(LOG_DEBUG, "Postgresql RealTime: Query: %s\n", sql); ast_log(LOG_DEBUG, "Postgresql RealTime: Query Failed because: %s (%s)\n", PQresultErrorMessage(result), PQresStatus(result_status)); ast_mutex_unlock(&pgsql_lock); return NULL; } } if ((num_rows = PQntuples(result)) > 0) { int rowIndex = 0; ast_log(LOG_DEBUG, "Postgresql RealTime: Found %ld rows.\n", num_rows); for (rowIndex = 0; rowIndex < num_rows; rowIndex++) { char *field_category = PQgetvalue(result, rowIndex, 0); char *field_var_name = PQgetvalue(result, rowIndex, 1); char *field_var_val = PQgetvalue(result, rowIndex, 2); char *field_cat_metric = PQgetvalue(result, rowIndex, 3); if (!strcmp(field_var_name, "#include")) { if (!ast_config_internal_load(field_var_val, cfg, 0)) { PQclear(result); ast_mutex_unlock(&pgsql_lock); return NULL; } continue; } if (strcmp(last, field_category) || last_cat_metric != atoi(field_cat_metric)) { cur_cat = ast_category_new(field_category); if (!cur_cat) break; strcpy(last, field_category); last_cat_metric = atoi(field_cat_metric); ast_category_append(cfg, cur_cat); } new_v = ast_variable_new(field_var_name, field_var_val); ast_variable_append(cur_cat, new_v); } } else { ast_log(LOG_WARNING, "Postgresql RealTime: Could not find config '%s' in database.\n", file); } PQclear(result); ast_mutex_unlock(&pgsql_lock); return cfg; }
static int apply_outgoing(struct outgoing *o, char *fn, FILE *f) { char buf[256]; char *c, *c2; int lineno = 0; struct ast_variable *var; while(fgets(buf, sizeof(buf), f)) { lineno++; /* Trim comments */ c = buf; while ((c = strchr(c, '#'))) { if ((c == buf) || (*(c-1) == ' ') || (*(c-1) == '\t')) *c = '\0'; else c++; } c = buf; while ((c = strchr(c, ';'))) { if ((c > buf) && (c[-1] == '\\')) { memmove(c - 1, c, strlen(c) + 1); c++; } else { *c = '\0'; break; } } /* Trim trailing white space */ while(!ast_strlen_zero(buf) && buf[strlen(buf) - 1] < 33) buf[strlen(buf) - 1] = '\0'; if (!ast_strlen_zero(buf)) { c = strchr(buf, ':'); if (c) { *c = '\0'; c++; while ((*c) && (*c < 33)) c++; #if 0 printf("'%s' is '%s' at line %d\n", buf, c, lineno); #endif if (!strcasecmp(buf, "channel")) { ast_copy_string(o->tech, c, sizeof(o->tech)); if ((c2 = strchr(o->tech, '/'))) { *c2 = '\0'; c2++; ast_copy_string(o->dest, c2, sizeof(o->dest)); } else { ast_log(LOG_NOTICE, "Channel should be in form Tech/Dest at line %d of %s\n", lineno, fn); o->tech[0] = '\0'; } } else if (!strcasecmp(buf, "callerid")) { ast_callerid_split(c, o->cid_name, sizeof(o->cid_name), o->cid_num, sizeof(o->cid_num)); } else if (!strcasecmp(buf, "application")) { ast_copy_string(o->app, c, sizeof(o->app)); } else if (!strcasecmp(buf, "data")) { ast_copy_string(o->data, c, sizeof(o->data)); } else if (!strcasecmp(buf, "maxretries")) { if (sscanf(c, "%d", &o->maxretries) != 1) { ast_log(LOG_WARNING, "Invalid max retries at line %d of %s\n", lineno, fn); o->maxretries = 0; } } else if (!strcasecmp(buf, "context")) { ast_copy_string(o->context, c, sizeof(o->context)); } else if (!strcasecmp(buf, "extension")) { ast_copy_string(o->exten, c, sizeof(o->exten)); } else if (!strcasecmp(buf, "priority")) { if ((sscanf(c, "%d", &o->priority) != 1) || (o->priority < 1)) { ast_log(LOG_WARNING, "Invalid priority at line %d of %s\n", lineno, fn); o->priority = 1; } } else if (!strcasecmp(buf, "retrytime")) { if ((sscanf(c, "%d", &o->retrytime) != 1) || (o->retrytime < 1)) { ast_log(LOG_WARNING, "Invalid retrytime at line %d of %s\n", lineno, fn); o->retrytime = 300; } } else if (!strcasecmp(buf, "waittime")) { if ((sscanf(c, "%d", &o->waittime) != 1) || (o->waittime < 1)) { ast_log(LOG_WARNING, "Invalid retrytime at line %d of %s\n", lineno, fn); o->waittime = 45; } } else if (!strcasecmp(buf, "retry")) { o->retries++; } else if (!strcasecmp(buf, "startretry")) { if (sscanf(c, "%ld", &o->callingpid) != 1) { ast_log(LOG_WARNING, "Unable to retrieve calling PID!\n"); o->callingpid = 0; } } else if (!strcasecmp(buf, "endretry") || !strcasecmp(buf, "abortretry")) { o->callingpid = 0; o->retries++; } else if (!strcasecmp(buf, "delayedretry")) { } else if (!strcasecmp(buf, "setvar") || !strcasecmp(buf, "set")) { c2 = c; strsep(&c2, "="); if (c2) { var = ast_variable_new(c, c2); if (var) { var->next = o->vars; o->vars = var; } } else ast_log(LOG_WARNING, "Malformed \"%s\" argument. Should be \"%s: variable=value\"\n", buf, buf); } else if (!strcasecmp(buf, "account")) { ast_copy_string(o->account, c, sizeof(o->account)); } else if (!strcasecmp(buf, "alwaysdelete")) { ast_set2_flag(&o->options, ast_true(c), SPOOL_FLAG_ALWAYS_DELETE); } else if (!strcasecmp(buf, "archive")) { ast_set2_flag(&o->options, ast_true(c), SPOOL_FLAG_ARCHIVE); } else { ast_log(LOG_WARNING, "Unknown keyword '%s' at line %d of %s\n", buf, lineno, fn); } } else ast_log(LOG_NOTICE, "Syntax error at line %d of %s\n", lineno, fn); } } ast_copy_string(o->fn, fn, sizeof(o->fn)); if (ast_strlen_zero(o->tech) || ast_strlen_zero(o->dest) || (ast_strlen_zero(o->app) && ast_strlen_zero(o->exten))) { ast_log(LOG_WARNING, "At least one of app or extension must be specified, along with tech and dest in file %s\n", fn); return -1; } return 0; }
/*! * \brief Excute an Select query and return ast_config list * \param url * \param unused * \param fields list containing one or more field/operator/value set. * * \retval struct ast_config pointer on success * \retval NULL on failure */ static struct ast_config *realtime_multi_curl(const char *url, const char *unused, const struct ast_variable *fields) { struct ast_str *query, *buffer; char buf1[256], buf2[256]; const struct ast_variable *field; char *stringp, *line, *pair, *key, *initfield = NULL; int start = 1; struct ast_variable *var = NULL; struct ast_config *cfg = NULL; struct ast_category *cat = NULL; if (!ast_custom_function_find("CURL")) { ast_log(LOG_ERROR, "func_curl.so must be loaded in order to use res_config_curl.so!!\n"); return NULL; } if (!(query = ast_str_thread_get(&query_buf, 16))) { return NULL; } if (!(buffer = ast_str_thread_get(&result_buf, 16))) { return NULL; } ast_str_set(&query, 0, "${CURL(%s/multi,", url); for (field = fields; field; field = field->next) { if (start) { char *op; initfield = ast_strdupa(field->name); if ((op = strchr(initfield, ' '))) *op = '\0'; } ast_uri_encode(field->name, buf1, sizeof(buf1), ast_uri_http); ast_uri_encode(field->value, buf2, sizeof(buf2), ast_uri_http); ast_str_append(&query, 0, "%s%s=%s", !start ? "&" : "", buf1, buf2); start = 0; } ast_str_append(&query, 0, ")}"); /* Do the CURL query */ ast_str_substitute_variables(&buffer, 0, NULL, ast_str_buffer(query)); if (!(cfg = ast_config_new())) { return NULL; } /* Line oriented output */ stringp = ast_str_buffer(buffer); while ((line = strsep(&stringp, "\r\n"))) { if (ast_strlen_zero(line)) { continue; } if (!(cat = ast_category_new("", "", 99999))) { continue; } while ((pair = strsep(&line, "&"))) { key = strsep(&pair, "="); ast_uri_decode(key, ast_uri_http); if (pair) { ast_uri_decode(pair, ast_uri_http); } if (!strcasecmp(key, initfield) && pair) { ast_category_rename(cat, pair); } if (!ast_strlen_zero(key)) { var = ast_variable_new(key, S_OR(pair, ""), ""); ast_variable_append(cat, var); } } ast_category_append(cfg, cat); } return cfg; }
void ast_ari_asterisk_update_object(struct ast_variable *headers, struct ast_ari_asterisk_update_object_args *args, struct ast_ari_response *response) { RAII_VAR(struct ast_sorcery *, sorcery, NULL, ast_sorcery_unref); RAII_VAR(struct ast_sorcery_object_type *, object_type, NULL, ao2_cleanup); RAII_VAR(void *, sorcery_obj, NULL, ao2_cleanup); struct ast_json *fields; struct ast_variable *update_set = NULL; int created = 0; sorcery = ast_sorcery_retrieve_by_module_name(args->config_class); if (!sorcery) { ast_ari_response_error( response, 404, "Not Found", "configClass '%s' not found", args->config_class); return; } object_type = ast_sorcery_get_object_type(sorcery, args->object_type); if (!object_type) { ast_ari_response_error( response, 404, "Not Found", "objectType '%s' not found", args->object_type); return; } sorcery_obj = ast_sorcery_retrieve_by_id(sorcery, args->object_type, args->id); if (!sorcery_obj) { ast_debug(5, "Sorcery object '%s' does not exist; creating it\n", args->id); sorcery_obj = ast_sorcery_alloc(sorcery, args->object_type, args->id); if (!sorcery_obj) { ast_ari_response_alloc_failed(response); return; } created = 1; } else { void *copy; copy = ast_sorcery_copy(sorcery, sorcery_obj); if (!copy) { ast_ari_response_alloc_failed(response); return; } ao2_ref(sorcery_obj, -1); sorcery_obj = copy; } fields = ast_json_object_get(args->fields, "fields"); if (!fields && !created) { /* Whoops. We need data. */ ast_ari_response_error( response, 400, "Bad request", "Fields must be provided to update object '%s'", args->id); return; } else if (fields) { size_t i; for (i = 0; i < ast_json_array_size(fields); i++) { struct ast_variable *new_var; struct ast_json *json_value = ast_json_array_get(fields, i); if (!json_value) { continue; } new_var = ast_variable_new( ast_json_string_get(ast_json_object_get(json_value, "attribute")), ast_json_string_get(ast_json_object_get(json_value, "value")), ""); if (!new_var) { ast_variables_destroy(update_set); ast_ari_response_alloc_failed(response); return; } ast_variable_list_append(&update_set, new_var); } } /* APPLY! Note that a NULL update_set is fine (and necessary), as it * will force validation on a newly created object. */ if (ast_sorcery_objectset_apply(sorcery, sorcery_obj, update_set)) { ast_variables_destroy(update_set); ast_ari_response_error( response, 400, "Bad request", "%s of object '%s' failed field value validation", created ? "Creation" : "Update", args->id); return; } ast_variables_destroy(update_set); if (created) { if (ast_sorcery_create(sorcery, sorcery_obj)) { ast_ari_response_error( response, 403, "Forbidden", "Cannot create sorcery objects of type '%s'", args->object_type); return; } } else { if (ast_sorcery_update(sorcery, sorcery_obj)) { ast_ari_response_error( response, 403, "Forbidden", "Cannot update sorcery objects of type '%s'", args->object_type); return; } } return_sorcery_object(sorcery, sorcery_obj, response); }
static struct ast_config *realtime_multi_pgsql(const char *database, const char *table, va_list ap) { PGresult *result = NULL; int num_rows = 0, pgerror; char sql[256], escapebuf[513]; const char *initfield = NULL; char *stringp; char *chunk; char *op; const char *newparam, *newval; struct ast_variable *var = NULL; struct ast_config *cfg = NULL; struct ast_category *cat = NULL; if (!table) { ast_log(LOG_WARNING, "PostgreSQL RealTime: No table specified.\n"); return NULL; } if (!(cfg = ast_config_new())) return NULL; /* Get the first parameter and first value in our list of passed paramater/value pairs */ newparam = va_arg(ap, const char *); newval = va_arg(ap, const char *); if (!newparam || !newval) { ast_log(LOG_WARNING, "PostgreSQL RealTime: Realtime retrieval requires at least 1 parameter and 1 value to search on.\n"); if (pgsqlConn) { PQfinish(pgsqlConn); pgsqlConn = NULL; }; return NULL; } initfield = ast_strdupa(newparam); if ((op = strchr(initfield, ' '))) { *op = '\0'; } /* Create the first part of the query using the first parameter/value pairs we just extracted If there is only 1 set, then we have our query. Otherwise, loop thru the list and concat */ if (!strchr(newparam, ' ')) op = " ="; else op = ""; PQescapeStringConn(pgsqlConn, escapebuf, newval, (sizeof(escapebuf) - 1) / 2, &pgerror); if (pgerror) { ast_log(LOG_ERROR, "Postgres detected invalid input: '%s'\n", newval); va_end(ap); return NULL; } snprintf(sql, sizeof(sql), "SELECT * FROM %s WHERE %s%s '%s'", table, newparam, op, escapebuf); while ((newparam = va_arg(ap, const char *))) { newval = va_arg(ap, const char *); if (!strchr(newparam, ' ')) op = " ="; else op = ""; PQescapeStringConn(pgsqlConn, escapebuf, newval, (sizeof(escapebuf) - 1) / 2, &pgerror); if (pgerror) { ast_log(LOG_ERROR, "Postgres detected invalid input: '%s'\n", newval); va_end(ap); return NULL; } snprintf(sql + strlen(sql), sizeof(sql) - strlen(sql), " AND %s%s '%s'", newparam, op, escapebuf); } if (initfield) { snprintf(sql + strlen(sql), sizeof(sql) - strlen(sql), " ORDER BY %s", initfield); } va_end(ap); /* We now have our complete statement; Lets connect to the server and execute it. */ ast_mutex_lock(&pgsql_lock); if (!pgsql_reconnect(database)) { ast_mutex_unlock(&pgsql_lock); return NULL; } if (!(result = PQexec(pgsqlConn, sql))) { ast_log(LOG_WARNING, "PostgreSQL RealTime: Failed to query database. Check debug for more info.\n"); ast_debug(1, "PostgreSQL RealTime: Query: %s\n", sql); ast_debug(1, "PostgreSQL RealTime: Query Failed because: %s\n", PQerrorMessage(pgsqlConn)); ast_mutex_unlock(&pgsql_lock); return NULL; } else { ExecStatusType result_status = PQresultStatus(result); if (result_status != PGRES_COMMAND_OK && result_status != PGRES_TUPLES_OK && result_status != PGRES_NONFATAL_ERROR) { ast_log(LOG_WARNING, "PostgreSQL RealTime: Failed to query database. Check debug for more info.\n"); ast_debug(1, "PostgreSQL RealTime: Query: %s\n", sql); ast_debug(1, "PostgreSQL RealTime: Query Failed because: %s (%s)\n", PQresultErrorMessage(result), PQresStatus(result_status)); ast_mutex_unlock(&pgsql_lock); return NULL; } } ast_debug(1, "PostgreSQL RealTime: Result=%p Query: %s\n", result, sql); if ((num_rows = PQntuples(result)) > 0) { int numFields = PQnfields(result); int i = 0; int rowIndex = 0; char **fieldnames = NULL; ast_debug(1, "PostgreSQL RealTime: Found %d rows.\n", num_rows); if (!(fieldnames = ast_calloc(1, numFields * sizeof(char *)))) { ast_mutex_unlock(&pgsql_lock); PQclear(result); return NULL; } for (i = 0; i < numFields; i++) fieldnames[i] = PQfname(result, i); for (rowIndex = 0; rowIndex < num_rows; rowIndex++) { var = NULL; if (!(cat = ast_category_new("","",99999))) continue; for (i = 0; i < numFields; i++) { stringp = PQgetvalue(result, rowIndex, i); while (stringp) { chunk = strsep(&stringp, ";"); if (!ast_strlen_zero(ast_strip(chunk))) { if (initfield && !strcmp(initfield, fieldnames[i])) { ast_category_rename(cat, chunk); } var = ast_variable_new(fieldnames[i], chunk, ""); ast_variable_append(cat, var); } } } ast_category_append(cfg, cat); } ast_free(fieldnames); } else { ast_log(LOG_WARNING, "PostgreSQL RealTime: Could not find any rows in table %s.\n", table); } ast_mutex_unlock(&pgsql_lock); PQclear(result); return cfg; }
/*! * \brief Execute a curl query and return ast_variable list * \param url The base URL from which to retrieve data * \param unused Not currently used * \param fields list containing one or more field/operator/value set. * * \retval var on success * \retval NULL on failure */ static struct ast_variable *realtime_curl(const char *url, const char *unused, const struct ast_variable *fields) { struct ast_str *query, *buffer; char buf1[256], buf2[256]; const struct ast_variable *field; char *stringp, *pair, *key; unsigned int start = 1; struct ast_variable *var = NULL, *prev = NULL; if (!ast_custom_function_find("CURL")) { ast_log(LOG_ERROR, "func_curl.so must be loaded in order to use res_config_curl.so!!\n"); return NULL; } if (!(query = ast_str_thread_get(&query_buf, 16))) { return NULL; } if (!(buffer = ast_str_thread_get(&result_buf, 16))) { return NULL; } ast_str_set(&query, 0, "${CURL(%s/single,", url); for (field = fields; field; field = field->next) { ast_uri_encode(field->name, buf1, sizeof(buf1), ast_uri_http); ast_uri_encode(field->value, buf2, sizeof(buf2), ast_uri_http); ast_str_append(&query, 0, "%s%s=%s", !start ? "&" : "", buf1, buf2); start = 0; } ast_str_append(&query, 0, ")}"); ast_str_substitute_variables(&buffer, 0, NULL, ast_str_buffer(query)); /* Remove any trailing newline characters */ if ((stringp = strchr(ast_str_buffer(buffer), '\r')) || (stringp = strchr(ast_str_buffer(buffer), '\n'))) { *stringp = '\0'; } stringp = ast_str_buffer(buffer); while ((pair = strsep(&stringp, "&"))) { key = strsep(&pair, "="); ast_uri_decode(key, ast_uri_http); if (pair) { ast_uri_decode(pair, ast_uri_http); } if (!ast_strlen_zero(key)) { if (prev) { prev->next = ast_variable_new(key, S_OR(pair, ""), ""); if (prev->next) { prev = prev->next; } } else { prev = var = ast_variable_new(key, S_OR(pair, ""), ""); } } } return var; }