static switch_status_t enum_lookup(char *root, char *in, enum_record_t **results)
{
switch_status_t sstatus = SWITCH_STATUS_SUCCESS;
char *mnum = NULL, *mroot = NULL, *p;
char *server = NULL;
*results = NULL;
mnum = switch_mprintf("%s%s", *in == '+' ? "" : "+", in);
if ((p = strchr(mnum, '*'))) {
*p++ = '\0';
mroot = switch_mprintf("%s.%s", p, root ? root : globals.isn_root);
root = mroot;
}
if (zstr(root)) {
root = globals.root;
}
if (!(server = switch_core_get_variable("enum-server"))) {
server = globals.server;
}
ldns_lookup(mnum, root, server, results);
switch_safe_free(mnum);
switch_safe_free(mroot);
return sstatus;
}
static switch_call_cause_t sip_outgoing_channel(switch_core_session_t *session, switch_event_t *var_event,
switch_caller_profile_t *outbound_profile,
switch_core_session_t **new_session, switch_memory_pool_t **pool, switch_originate_flag_t flags,
switch_call_cause_t *cancel_cause)
{
const char *profile;
if (session) {
profile = switch_channel_get_variable(switch_core_session_get_channel(session), "sip_profile");
} else {
profile = switch_core_get_variable("sip_profile");
}
if (zstr(profile)) {
profile = "default";
}
outbound_profile->destination_number = switch_core_sprintf(outbound_profile->pool, "%s/%s", profile, outbound_profile->destination_number);
UNPROTECT_INTERFACE(sip_endpoint_interface);
return switch_core_session_outgoing_channel(session, var_event, "sofia", outbound_profile, new_session, pool, SOF_NONE, cancel_cause);
}
static switch_status_t enum_lookup(char *root, char *in, enum_record_t **results, switch_channel_t *channel, switch_core_session_t *session)
{
switch_status_t sstatus = SWITCH_STATUS_SUCCESS;
char *mnum = NULL, *mroot = NULL, *p;
char *server[ENUM_MAXNAMESERVERS];
int inameserver = 0;
char *argv[ ENUM_MAXNAMESERVERS ] = { 0 };
int argc;
int x = 0;
char *enum_nameserver_dup;
const char *enum_nameserver = NULL;
*results = NULL;
mnum = switch_mprintf("%s%s", *in == '+' ? "" : "+", in);
if ((p = strchr(mnum, '*'))) {
*p++ = '\0';
mroot = switch_mprintf("%s.%s", p, root ? root : globals.isn_root);
root = mroot;
}
if (zstr(root)) {
root = globals.root;
}
/* Empty the server array */
for(inameserver=0; inameserver<ENUM_MAXNAMESERVERS; inameserver++) {
server[inameserver] = NULL;
}
inameserver = 0;
/* check for enum_nameserver channel var */
if (channel) {
enum_nameserver = switch_channel_get_variable(channel, "enum_nameserver");
}
if (zstr(enum_nameserver)) {
enum_nameserver = switch_core_get_variable("enum-server");
}
if (!zstr(enum_nameserver)) {
/* Blank the server array */
for(inameserver=0; inameserver<ENUM_MAXNAMESERVERS; inameserver++) {
server[inameserver] = NULL;
}
enum_nameserver_dup = switch_core_session_strdup(session, enum_nameserver);
argc = switch_separate_string(enum_nameserver_dup, ',', argv, (sizeof(argv) / sizeof(argv[0])));
inameserver = 0;
for (x = 0; x < argc; x++) {
server[inameserver] = argv[x];
inameserver++;
}
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "Enum nameserver override : %s\n", enum_nameserver);
}
if (!inameserver) {
/* use config param "nameserver" ( can be up to ENUM_MAXNAMESERVERS ) */
for(inameserver = 0; inameserver<ENUM_MAXNAMESERVERS; inameserver++) {
server[inameserver] = NULL;
if ( globals.nameserver[inameserver] != NULL ) {
server[inameserver] = globals.nameserver[inameserver];
}
}
}
ldns_lookup(mnum, root, server, results);
switch_safe_free(mnum);
switch_safe_free(mroot);
return sstatus;
}
static abyss_bool http_directory_auth(TSession * r, char *domain_name)
{
char *p;
char *x;
char z[256], t[80];
char user[512];
char *pass;
const char *mypass1 = NULL, *mypass2 = NULL;
const char *box = NULL;
int at = 0;
char *dp;
abyss_bool rval = FALSE;
p = RequestHeaderValue(r, "authorization");
if (p) {
NextToken((const char **const) &p);
x = GetToken(&p);
if (x) {
if (!strcasecmp(x, "basic")) {
NextToken((const char **const) &p);
switch_b64_decode(p, user, sizeof(user));
if ((pass = strchr(user, ':'))) {
*pass++ = '\0';
}
if ((dp = strchr(user, '@'))) {
*dp++ = '\0';
domain_name = dp;
at++;
}
if (!domain_name) {
if (globals.virtual_host) {
if ((domain_name = (char *) r->requestInfo.host)) {
if (!strncasecmp(domain_name, "www.", 3)) {
domain_name += 4;
}
}
}
if (!domain_name) {
if (globals.default_domain) {
domain_name = globals.default_domain;
} else {
domain_name = switch_core_get_variable("domain");
}
}
}
if (zstr(user) || zstr(domain_name)) {
goto fail;
}
if (!zstr(globals.realm) && !zstr(globals.user) && !zstr(globals.pass)) {
if (at) {
switch_snprintf(z, sizeof(z), "%s@%s:%s", globals.user, globals.realm, globals.pass);
} else {
switch_snprintf(z, sizeof(z), "%s:%s", globals.user, globals.pass);
}
Base64Encode(z, t);
if (!strcmp(p, t)) {
goto authed;
}
}
if (!user_attributes(user, domain_name, &mypass1, &mypass2, &box, NULL)) {
goto fail;
}
if (!zstr(mypass2) && !strcasecmp(mypass2, "user-choose")) {
switch_safe_free(mypass2);
}
if (!mypass1) {
goto authed;
} else {
if (at) {
switch_snprintf(z, sizeof(z), "%s@%s:%s", user, domain_name, mypass1);
} else {
switch_snprintf(z, sizeof(z), "%s:%s", user, mypass1);
}
Base64Encode(z, t);
if (!strcmp(p, t)) {
goto authed;
}
if (mypass2) {
if (at) {
switch_snprintf(z, sizeof(z), "%s@%s:%s", user, domain_name, mypass2);
} else {
switch_snprintf(z, sizeof(z), "%s:%s", user, mypass2);
}
Base64Encode(z, t);
if (!strcmp(p, t)) {
goto authed;
}
}
if (box) {
if (at) {
switch_snprintf(z, sizeof(z), "%s@%s:%s", box, domain_name, mypass1);
} else {
switch_snprintf(z, sizeof(z), "%s:%s", box, mypass1);
}
Base64Encode(z, t);
if (!strcmp(p, t)) {
goto authed;
}
if (mypass2) {
if (at) {
switch_snprintf(z, sizeof(z), "%s@%s:%s", box, domain_name, mypass2);
} else {
switch_snprintf(z, sizeof(z), "%s:%s", box, mypass2);
}
Base64Encode(z, t);
if (!strcmp(p, t)) {
goto authed;
}
}
}
}
goto fail;
authed:
switch_snprintf(z, sizeof(z), "%s@%s", (box ? box : user), domain_name);
r->requestInfo.user = strdup(z);
ResponseAddField(r, "freeswitch-user", (box ? box : user));
ResponseAddField(r, "freeswitch-domain", domain_name);
rval = TRUE;
goto done;
}
}
}
fail:
switch_snprintf(z, sizeof(z), "Basic realm=\"%s\"", domain_name ? domain_name : globals.realm);
ResponseAddField(r, "WWW-Authenticate", z);
ResponseStatus(r, 401);
done:
switch_safe_free(mypass1);
switch_safe_free(mypass2);
switch_safe_free(box);
return rval;
}
/**
* Encode log as GELF
*/
static char *to_gelf(const switch_log_node_t *node, switch_log_level_t log_level)
{
char *gelf_text = NULL;
cJSON *gelf = cJSON_CreateObject();
char *hostname;
char timestamp[32];
char *full_message = node->content;
char short_message[151];
char *short_message_end = NULL;
char *parsed_full_message = NULL;
char *field_name = NULL;
switch_event_t *log_fields = NULL;
switch_core_session_t *session = NULL;
cJSON_AddItemToObject(gelf, "version", cJSON_CreateString("1.1"));
if ((hostname = switch_core_get_variable("hostname")) && !zstr(hostname)) {
cJSON_AddItemToObject(gelf, "host", cJSON_CreateString(hostname));
} else if ((hostname = switch_core_get_variable("local_ip_v4")) && !zstr(hostname)) {
cJSON_AddItemToObject(gelf, "host", cJSON_CreateString(hostname));
}
switch_snprintf(timestamp, 32, "%"SWITCH_UINT64_T_FMT".%d", (uint64_t)(node->timestamp / 1000000), (node->timestamp % 1000000) / 1000);
cJSON_AddItemToObject(gelf, "timestamp", cJSON_CreateString(timestamp));
cJSON_AddItemToObject(gelf, "_microtimestamp", cJSON_CreateNumber(node->timestamp));
cJSON_AddItemToObject(gelf, "level", cJSON_CreateNumber(to_graylog2_level(log_level)));
cJSON_AddItemToObject(gelf, "_ident", cJSON_CreateString("freeswitch"));
cJSON_AddItemToObject(gelf, "_pid", cJSON_CreateNumber((int)getpid()));
if (!zstr(node->userdata)) {
cJSON_AddItemToObject(gelf, "_uuid", cJSON_CreateString(node->userdata));
}
if (!zstr_buf(node->file)) {
cJSON_AddItemToObject(gelf, "_file", cJSON_CreateString(node->file));
cJSON_AddItemToObject(gelf, "_line", cJSON_CreateNumber(node->line));
}
if (!zstr_buf(node->func)) {
cJSON_AddItemToObject(gelf, "_function", cJSON_CreateString(node->func));
}
/* skip initial space and new line */
if (*full_message == ' ') {
full_message++;
}
if (*full_message == '\n') {
full_message++;
}
/* get fields from channel data, if configured */
if (!zstr(node->userdata) && (session = switch_core_session_locate(node->userdata))) {
switch_channel_t *channel = switch_core_session_get_channel(session);
switch_event_header_t *hp;
/* session_fields name mapped to variable name */
for (hp = globals.session_fields->headers; hp; hp = hp->next) {
if (!zstr(hp->name) && !zstr(hp->value)) {
const char *val = switch_channel_get_variable(channel, hp->value);
if (!zstr(val)) {
if (!log_fields) {
switch_event_create_plain(&log_fields, SWITCH_EVENT_CHANNEL_DATA);
}
switch_event_add_header_string(log_fields, SWITCH_STACK_BOTTOM, hp->name, val);
}
}
}
switch_core_session_rwunlock(session);
}
/* parse list of fields from message text, if any */
if (strncmp(full_message, "LOG_FIELDS", 10) == 0) {
switch_event_create_brackets(full_message+10, '[', ']', ',', &log_fields, &parsed_full_message, SWITCH_TRUE);
full_message = parsed_full_message;
}
/* add additional fields */
if (log_fields) {
switch_event_header_t *hp;
for (hp = log_fields->headers; hp; hp = hp->next) {
if (!zstr(hp->name) && !zstr(hp->value)) {
if (strncmp(hp->name, "@#", 2) == 0) {
field_name = switch_mprintf("_%s", hp->name + 2);
cJSON_AddItemToObject(gelf, field_name, cJSON_CreateNumber(strtod(hp->value, NULL)));
} else {
field_name = switch_mprintf("_%s", hp->name);
cJSON_AddItemToObject(gelf, field_name, cJSON_CreateString(hp->value));
}
free(field_name);
}
}
switch_event_destroy(&log_fields);
}
cJSON_AddItemToObject(gelf, "full_message", cJSON_CreateString(full_message));
switch_snprintf(short_message, sizeof(short_message) - 1, "%s", full_message);
if ((short_message_end = strchr(short_message, '\n'))) {
*short_message_end = '\0';
}
cJSON_AddItemToObject(gelf, "short_message", cJSON_CreateString(short_message));
gelf_text = cJSON_PrintUnformatted(gelf);
cJSON_Delete(gelf);
switch_safe_free(parsed_full_message);
return gelf_text;
}
