Skip to content

F
freeswitch
提交 9a4e29d7 authored 作者: Brian West's avatar Brian West
浏览文件
操作

FS-4870

上级 8ec7b25c
隐藏空白字符变更
内嵌 并排
正在显示 包含 525 行增加 和 963 行删除
src/mod/xml_int/mod_xml_ldap/mod_xml_ldap.c
浏览文件 @ 9a4e29d7
...@@ -34,484 +34,611 @@ ...@@ -34,484 +34,611 @@
#include <switch.h> #include <switch.h>
#include <stdlib.h> #include <stdlib.h>
#include <string.h> #include <string.h>
#ifdef MSLDAP
#include <windows.h>
#include <winldap.h>
#include <winber.h>
#define LDAP_OPT_SUCCESS LDAP_SUCCESS
#else
#include <lber.h> #include <lber.h>
#include <ldap.h> #include <ldap.h>
#include <sasl/sasl.h>
#include "lutil_ldap.h" #define PCACHE_TTL 300
#endif #define NCACHE_TTL 900
typedef struct xml_ldap_attribute xml_ldap_attribute_t;
typedef enum { typedef enum {
XML_LDAP_CONFIG = 0, XML_LDAP_CONFIG = 0,
XML_LDAP_DIRECTORY, XML_LDAP_DIRECTORY,
XML_LDAP_DIALPLAN, XML_LDAP_DIALPLAN,
XML_LDAP_PHRASE, XML_LDAP_PHRASE
XML_LDAP_LANGUAGE
} xml_ldap_query_type_t; } xml_ldap_query_type_t;
SWITCH_MODULE_LOAD_FUNCTION(mod_xml_ldap_load);
SWITCH_MODULE_SHUTDOWN_FUNCTION(mod_xml_ldap_shutdown);
SWITCH_MODULE_DEFINITION(mod_xml_ldap, mod_xml_ldap_load, mod_xml_ldap_shutdown, NULL);
typedef struct xml_binding { typedef struct xml_binding {
char *bindings; char *bindings;
char *host; xml_ldap_query_type_t bt;
char *url;
char *basedn; char *basedn;
char *binddn; char *binddn;
char *bindpass; char *bindpass;
char *filter; char *filter;
char **attrs; xml_ldap_attribute_t *attr_list;
lutilSASLdefaults *defaults;
} xml_binding_t; } xml_binding_t;
typedef struct ldap_c { typedef enum exten_types {
LDAP *ld; LDAP_EXTEN_ID = 0,
LDAPMessage *msg; LDAP_EXTEN_CIDR,
LDAPMessage *entry; LDAP_EXTEN_PASSWORD,
BerElement *berkey; LDAP_EXTEN_VM_ENABLED,
BerElement *berval; LDAP_EXTEN_VM_PASSWORD,
char *key; LDAP_EXTEN_VM_MAILFROM,
char *val; LDAP_EXTEN_VM_MAILTO,
char **keyvals; LDAP_EXTEN_VM_EMAILMSG,
char **valvals; LDAP_EXTEN_VM_NOTEMAILMSG,
char *sp; LDAP_EXTEN_VM_ATTACHFILE,
} ldap_ctx; LDAP_EXTEN_USER_CONTEXT,
LDAP_EXTEN_EFF_CLIDNAME,
LDAP_EXTEN_EFF_CLIDNUM,
LDAP_EXTEN_ACCOUNTCODE,
LDAP_EXTEN_RULESET,
LDAP_EXTEN_AREACODE,
LDAP_EXTEN_CID_EXTNAME,
LDAP_EXTEN_CID_EXTNUM,
LDAP_EXTEN_INTNAME,
LDAP_EXTEN_INTNUM,
LDAP_EXTEN_RECORD_CALLS,
LDAP_EXTEN_ACTIVE,
LDAP_EXTEN_CFWD_REWRITECID,
LDAP_EXTEN_CFWD_ACTIVE,
LDAP_EXTEN_CFWD_DEST,
LDAP_EXTEN_CFWD_BUSYACTIVE,
LDAP_EXTEN_CFWD_BUSYDEST,
LDAP_EXTEN_NOANSWERACTIVE,
LDAP_EXTEN_NOANSWERDEST,
LDAP_EXTEN_NOANSWERSECONDS,
LDAP_EXTEN_PROGRESSAUDIO,
LDAP_EXTEN_ALLOW_OUTBOUND,
LDAP_EXTEN_ALLOW_XFER,
LDAP_EXTEN_HOTLINE_ACTIVE,
LDAP_EXTEN_HOTLINE_DEST,
LDAP_EXTEN_CLASSOFSERVICE
} exten_type_t;
struct xml_ldap_attribute {
exten_type_t type;
uint64_t len;
char *val;
xml_ldap_attribute_t *next;
};
SWITCH_MODULE_LOAD_FUNCTION(mod_xml_ldap_load);
SWITCH_MODULE_SHUTDOWN_FUNCTION(mod_xml_ldap_shutdown);
SWITCH_MODULE_DEFINITION(mod_xml_ldap, mod_xml_ldap_load, mod_xml_ldap_shutdown, NULL);
static switch_status_t xml_ldap_directory_result(void *ldap_connection, xml_binding_t *binding, switch_xml_t *xml, int *off); static switch_xml_t xml_ldap_search(const char *section, const char *tag_name, const char *key_name, const char *key_value, switch_event_t *params,
static switch_status_t xml_ldap_dialplan_result(void *ldap_connection, xml_binding_t *binding, switch_xml_t *xml, int *off); void *user_data);
static switch_status_t trydir(switch_xml_t *, int *, LDAP *, char *, char *, xml_binding_t *);
static switch_status_t do_config(void);
static switch_status_t trysearch(switch_xml_t *pxml, int *xoff, LDAP * ld, char *basedn, char *filter);
void rec(switch_xml_t *, int *, LDAP * ld, char *);
#define XML_LDAP_SYNTAX "[debug_on|debug_off]" #define XML_LDAP_SYNTAX ""
SWITCH_STANDARD_API(xml_ldap_function) SWITCH_STANDARD_API(xml_ldap_function)
{ {
if (session) { return SWITCH_STATUS_FALSE;
return SWITCH_STATUS_FALSE;
}
if (zstr(cmd)) {
goto usage;
}
if (!strcasecmp(cmd, "debug_on")) {
} else if (!strcasecmp(cmd, "debug_off")) {
} else {
goto usage;
}
stream->write_function(stream, "OK\n");
return SWITCH_STATUS_SUCCESS;
usage:
stream->write_function(stream, "USAGE: %s\n", XML_LDAP_SYNTAX);
return SWITCH_STATUS_SUCCESS;
} }
static switch_status_t xml_ldap_result(void *ldap_connection, xml_binding_t *binding, switch_xml_t *xml, int *off, SWITCH_MODULE_LOAD_FUNCTION(mod_xml_ldap_load)
const xml_ldap_query_type_t query_type)
{ {
switch (query_type) { switch_api_interface_t *xml_ldap_api_interface;
case XML_LDAP_DIRECTORY:
return xml_ldap_directory_result(ldap_connection, binding, xml, off);
case XML_LDAP_DIALPLAN: /* connect my internal structure to the blank pointer passed to me */
return xml_ldap_dialplan_result(ldap_connection, binding, xml, off); *module_interface = switch_loadable_module_create_module_interface(pool, modname);
default: SWITCH_ADD_API(xml_ldap_api_interface, "xml_ldap", "XML LDAP", xml_ldap_function, XML_LDAP_SYNTAX);
return SWITCH_STATUS_FALSE; switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_INFO, "XML LDAP module loading...\n");
if (do_config() != SWITCH_STATUS_SUCCESS) {
return SWITCH_STATUS_FALSE;
} }
/* indicate that the module should continue to be loaded */
return SWITCH_STATUS_SUCCESS;
} }
static switch_status_t xml_ldap_dialplan_result(void *ldap_connection, xml_binding_t *binding, switch_xml_t *xml, int *off) SWITCH_MODULE_SHUTDOWN_FUNCTION(mod_xml_ldap_shutdown)
{ {
return SWITCH_STATUS_FALSE; return SWITCH_STATUS_SUCCESS;
} }
static switch_status_t xml_ldap_directory_result(void *ldap_connection, xml_binding_t *binding, switch_xml_t *xml, int *off) static switch_status_t do_config(void)
{ {
struct ldap_c *ldap = ldap_connection; char *cf = "xml_ldap.conf";
switch_xml_t asdf = *xml; switch_xml_t cfg, xml, bindings_tag, binding_tag, param, tran;
switch_xml_t param, variable, params = NULL, variables = NULL; xml_binding_t *binding = NULL;
int i = 0; xml_ldap_attribute_t *attr_list = NULL;
int loff = *off; int x = 0;
for (ldap->entry = ldap_first_entry(ldap->ld, ldap->msg); ldap->entry != NULL; ldap->entry = ldap_next_entry(ldap->ld, ldap->entry)) { if (!(xml = switch_xml_open_cfg(cf, &cfg, NULL))) {
ldap->key = ldap_first_attribute(ldap->ld, ldap->entry, &ldap->berkey); switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "open of %s failed\n", cf);
do { return SWITCH_STATUS_TERM;
ldap->val = ldap_first_attribute(ldap->ld, ldap->entry, &ldap->berval); }
do {
if (strstr(ldap->val, "value")) { if (!(bindings_tag = switch_xml_child(cfg, "bindings"))) {
if (strstr(ldap->val, ldap->key) && strcmp(ldap->val, ldap->key)) { switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Missing <bindings> tag!\n");
if (!strcmp(ldap->key, "param")) { goto done;
params = switch_xml_add_child_d(asdf, "params", loff++); }
} else if (!strcmp(ldap->key, "variable")) { for (binding_tag = switch_xml_child(bindings_tag, "binding"); binding_tag; binding_tag = binding_tag->next) {
variables = switch_xml_add_child_d(asdf, "variables", loff++); char *bname = (char *) switch_xml_attr_soft(binding_tag, "name");
}
if (!(binding = malloc(sizeof(*binding)))) {
ldap->keyvals = ldap_get_values(ldap->ld, ldap->entry, ldap->key); goto done;
ldap->valvals = ldap_get_values(ldap->ld, ldap->entry, ldap->val); }
memset(binding, 0, sizeof(*binding));
if (ldap->keyvals && ldap->valvals) { binding->attr_list = attr_list;
if (ldap_count_values(ldap->valvals) == ldap_count_values(ldap->keyvals)) {
for (i = 0; ldap->keyvals[i] != NULL && ldap->valvals[i] != NULL; i++) { for (param = switch_xml_child(binding_tag, "param"); param; param = param->next) {
if (!strcmp(ldap->key, "param")) {
param = switch_xml_add_child_d(params, "param", loff++); char *var = (char *) switch_xml_attr_soft(param, "name");
switch_xml_set_attr_d(param, "name", ldap->keyvals[i]); char *val = (char *) switch_xml_attr_soft(param, "value");
switch_xml_set_attr_d(param, "value", ldap->valvals[i]);
} else if (!strcmp(ldap->key, "variable")) { if (!strcasecmp(var, "filter")) {
variable = switch_xml_add_child_d(variables, "variable", loff++); binding->bindings = (char *) switch_xml_attr_soft(param, "bindings");
switch_xml_set_attr_d(variable, "name", ldap->keyvals[i]);
switch_xml_set_attr_d(variable, "value", ldap->valvals[i]); if (!strncmp(binding->bindings, "configuration", strlen(binding->bindings))) {
} switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "setting type XML_LDAP_CONFIG\n");
} binding->bt = XML_LDAP_CONFIG;
} else if (!strncmp(binding->bindings, "directory", strlen(binding->bindings))) {
if (ldap->keyvals) { binding->bt = XML_LDAP_DIRECTORY;
ldap_value_free(ldap->keyvals); } else if (!strncmp(binding->bindings, "dialplan", strlen(binding->bindings))) {
} binding->bt = XML_LDAP_DIALPLAN;
} else if (!strncmp(binding->bindings, "phrases", strlen(binding->bindings))) {
if (ldap->valvals) { binding->bt = XML_LDAP_PHRASE;
ldap_value_free(ldap->valvals); }
}
} else { if (val) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Seems the values %d and %d are not the same??\n", binding->filter = strdup(val);
ldap_count_values(ldap->valvals), ldap_count_values(ldap->keyvals)); printf("binding filter %s to %s\n", binding->filter, binding->bindings);
} }
} } else if (!strncasecmp(var, "basedn", strlen(val))) {
} binding->basedn = strdup(val);
} } else if (!strncasecmp(var, "binddn", strlen(val))) {
if (ldap->val) { binding->binddn = strdup(val);
ldap_memfree(ldap->val); } else if (!strncasecmp(var, "bindpass", strlen(val))) {
} binding->bindpass = strdup(val);
} else if (!strncasecmp(var, "url", strlen(val))) {
ldap->val = ldap_next_attribute(ldap->ld, ldap->entry, ldap->berval); binding->url = strdup(val);
}
}
if (binding && binding->bt == XML_LDAP_DIRECTORY) {
attr_list = malloc(sizeof(*attr_list));
attr_list = memset(attr_list, 0, sizeof(*attr_list));
binding->attr_list = attr_list;
param = switch_xml_child(binding_tag, "trans");
for (tran = switch_xml_child(param, "tran"); tran; tran = tran->next) {
char *n = (char *) switch_xml_attr_soft(tran, "name");
char *m = (char *) switch_xml_attr_soft(tran, "mapfrom");
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_NOTICE, " adding map %s => %s\n", m, n);
/* Params */
if (!strncasecmp("id", n, strlen(n))) {
attr_list->type = LDAP_EXTEN_ID;
attr_list->len = strlen(m);
attr_list->val = strdup(m);
attr_list->next = malloc(sizeof(*attr_list));
attr_list->next = memset(attr_list->next, 0, sizeof(*attr_list));
attr_list = attr_list->next;
} else if (!strncasecmp("cidr", n, strlen(n))) {
attr_list->type = LDAP_EXTEN_CIDR;
attr_list->len = strlen(m);
attr_list->val = strdup(m);
attr_list->next = malloc(sizeof(*attr_list));
attr_list->next = memset(attr_list->next, 0, sizeof(*attr_list));
attr_list = attr_list->next;
} else if (!strncasecmp("password", n, strlen(n))) {
attr_list->type = LDAP_EXTEN_PASSWORD;
attr_list->len = strlen(m);
attr_list->val = strdup(m);
attr_list->next = malloc(sizeof(*attr_list));
attr_list->next = memset(attr_list->next, 0, sizeof(*attr_list));
attr_list = attr_list->next;
} else if (!strncasecmp("vm-enabled", n, strlen(n))) {
attr_list->type = LDAP_EXTEN_VM_ENABLED;
attr_list->len = strlen(m);
attr_list->val = strdup(m);
attr_list->next = malloc(sizeof(*attr_list));
attr_list->next = memset(attr_list->next, 0, sizeof(*attr_list));
attr_list = attr_list->next;
} else if (!strncasecmp("vm-password", n, strlen(n))) {
attr_list->type = LDAP_EXTEN_VM_PASSWORD;
attr_list->len = strlen(m);
attr_list->val = strdup(m);
attr_list->next = malloc(sizeof(*attr_list));
attr_list->next = memset(attr_list->next, 0, sizeof(*attr_list));
attr_list = attr_list->next;
} else if (!strncasecmp("vm-mailfrom", n, strlen(n))) {
attr_list->type = LDAP_EXTEN_VM_MAILFROM;
attr_list->len = strlen(m);
attr_list->val = strdup(m);
attr_list->next = malloc(sizeof(*attr_list));
attr_list->next = memset(attr_list->next, 0, sizeof(*attr_list));
attr_list = attr_list->next;
} else if (!strncasecmp("vm-mailto", n, strlen(n))) {
attr_list->type = LDAP_EXTEN_VM_MAILTO;
attr_list->len = strlen(m);
attr_list->val = strdup(m);
attr_list->next = malloc(sizeof(*attr_list));
attr_list->next = memset(attr_list->next, 0, sizeof(*attr_list));
attr_list = attr_list->next;
} else if (!strncasecmp("vm-email-all-messages", n, strlen(n))) {
attr_list->type = LDAP_EXTEN_VM_EMAILMSG;
attr_list->len = strlen(m);
attr_list->val = strdup(m);
attr_list->next = malloc(sizeof(*attr_list));
attr_list->next = memset(attr_list->next, 0, sizeof(*attr_list));
attr_list = attr_list->next;
} else if (!strncasecmp("vm-notify-email-all-messages", n, strlen(n))) {
attr_list->type = LDAP_EXTEN_VM_NOTEMAILMSG;
attr_list->len = strlen(m);
attr_list->val = strdup(m);
attr_list->next = malloc(sizeof(*attr_list));
attr_list->next = memset(attr_list->next, 0, sizeof(*attr_list));
attr_list = attr_list->next;
} else if (!strncasecmp("vm-attach-file", n, strlen(n))) {
attr_list->type = LDAP_EXTEN_VM_ATTACHFILE;
attr_list->len = strlen(m);
attr_list->val = strdup(m);
attr_list->next = malloc(sizeof(*attr_list));
attr_list->next = memset(attr_list->next, 0, sizeof(*attr_list));
attr_list = attr_list->next;
/* Variables */
} else if (!strncasecmp("user_context", n, strlen(n))) {
attr_list->type = LDAP_EXTEN_USER_CONTEXT;
attr_list->len = strlen(m);
attr_list->val = strdup(m);
attr_list->next = malloc(sizeof(*attr_list));
attr_list->next = memset(attr_list->next, 0, sizeof(*attr_list));
attr_list = attr_list->next;
} else if (!strncasecmp("effective_caller_id_name", n, strlen(n))) {
attr_list->type = LDAP_EXTEN_EFF_CLIDNAME;
attr_list->len = strlen(m);
attr_list->val = strdup(m);
attr_list->next = malloc(sizeof(*attr_list));
attr_list->next = memset(attr_list->next, 0, sizeof(*attr_list));
attr_list = attr_list->next;
} else if (!strncasecmp("effective_caller_id_number", n, strlen(n))) {
attr_list->type = LDAP_EXTEN_EFF_CLIDNUM;
attr_list->len = strlen(m);
attr_list->val = strdup(m);
attr_list->next = malloc(sizeof(*attr_list));
attr_list->next = memset(attr_list->next, 0, sizeof(*attr_list));
attr_list = attr_list->next;
} else if (!strncasecmp("accountcode", n, strlen(n))) {
attr_list->type = LDAP_EXTEN_ACCOUNTCODE;
attr_list->len = strlen(m);
attr_list->val = strdup(m);
attr_list->next = malloc(sizeof(*attr_list));
attr_list->next = memset(attr_list->next, 0, sizeof(*attr_list));
attr_list = attr_list->next;
} else if (!strncasecmp("ruleset", n, strlen(n))) {
attr_list->type = LDAP_EXTEN_RULESET;
attr_list->len = strlen(m);
attr_list->val = strdup(m);
attr_list->next = malloc(sizeof(*attr_list));
attr_list->next = memset(attr_list->next, 0, sizeof(*attr_list));
attr_list = attr_list->next;
}
}
attr_list->next = NULL;
}
if (!binding->basedn || !binding->filter || !binding->url) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "You must define \"basedn\", and \"filter\" in mod_xml_ldap.conf.xml\n");
continue;
}
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_NOTICE, "Binding [%s] XML Fetch Function [%s] (%s) [%s]\n",
zstr(bname) ? "N/A" : bname, binding->basedn, binding->filter, binding->bindings ? binding->bindings : "all");
switch_xml_bind_search_function(xml_ldap_search, switch_xml_parse_section_string(bname), binding);
x++;
binding = NULL;
}
} while (ldap->val != NULL); done:
switch_xml_free(xml);
if (ldap->key) {
ldap_memfree(ldap->key);
}
if (ldap->berval) {
ber_free(ldap->berval, 0);
}
ldap->key = ldap_next_attribute(ldap->ld, ldap->entry, ldap->berkey);
} while (ldap->key != NULL);
if (ldap->berkey) {
ber_free(ldap->berkey, 0);
}
}
return SWITCH_STATUS_SUCCESS; return SWITCH_STATUS_SUCCESS;
} }
static switch_xml_t xml_ldap_search(const char *section, const char *tag_name, const char *key_name, const char *key_value, switch_event_t *params, static switch_status_t trydir(switch_xml_t *pxml, int *xoff, LDAP * ld, char *dir_domain, char *dir_exten, xml_binding_t *binding)
void *user_data)
{ {
xml_binding_t *binding = (xml_binding_t *) user_data; switch_status_t ret = SWITCH_STATUS_FALSE;
switch_event_header_t *hi; int off = *xoff;
char *key = NULL;
switch_xml_t xml = NULL, sub = NULL; char *basedn = NULL, *filter = NULL;
struct berval **val = NULL;
struct ldap_c ldap_connection; BerElement *ber = NULL;
struct ldap_c *ldap = &ldap_connection; switch_xml_t xml = *pxml, params = NULL, param = NULL, vars = NULL, cur = NULL;
LDAPMessage *msg, *entry;
int auth_method = LDAP_AUTH_SIMPLE; xml_ldap_attribute_t *attr = NULL;
int desired_version = LDAP_VERSION3; static char *fsattr[] =
xml_ldap_query_type_t query_type; { "id", "cidr", "password", "vm-enabled", "vm-password", "vm-mailfrom", "vm-mailto",
char *dir_exten = NULL, *dir_domain = NULL; "vm-email-all-messages", "vm-notify-email-all-messages", "vm-attach-file",
"user_context", "effective_caller_id_name", "effective_caller_id_number",
char *search_filter = NULL, *search_base = NULL; "accountcode", "ruleset", NULL };
int off = 0, ret = 1;
basedn = switch_mprintf(binding->basedn, dir_domain);
//char *buf; filter = switch_mprintf(binding->filter, dir_exten);
//buf = malloc(4096);
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_NOTICE, "searching in basedn %s with filter %s\n", basedn, filter);
if (!binding) { if ((ldap_search_s(ld, basedn, LDAP_SCOPE_SUB, filter, NULL, 0, &msg) != LDAP_SUCCESS))
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "No bindings...sorry bud returning now\n"); goto cleanup;
return NULL;
} if (ldap_count_entries(ld, msg) > 0) {
ret = SWITCH_STATUS_SUCCESS;
if (!strcmp(section, "configuration")) { xml = switch_xml_add_child_d(xml, "section", off++);
query_type = XML_LDAP_CONFIG; switch_xml_set_attr_d(xml, "name", "directory");
} else if (!strcmp(section, "directory")) {
query_type = XML_LDAP_DIRECTORY; xml = switch_xml_add_child_d(xml, "domain", off++);
} else if (!strcmp(section, "dialplan")) { switch_xml_set_attr_d(xml, "name", dir_domain);
query_type = XML_LDAP_DIALPLAN;
} else if (!strcmp(section, "phrases")) { params = switch_xml_add_child_d(xml, "params", off++);
query_type = XML_LDAP_PHRASE; param = switch_xml_add_child_d(params, "param", off++);
} else if (!strcmp(section, "languages")) { switch_xml_set_attr_d(param, "name", "dial-string");
query_type = XML_LDAP_LANGUAGE; switch_xml_set_attr_d(param, "value", "{^^:sip_invite_domain=${dialed_domain}:presence_id=${dialed_user}@${dialed_domain}}${sofia_contact(*/${dialed_user}@${dialed_domain})}");
} else {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Invalid section\n"); xml = switch_xml_add_child_d(xml, "user", off++);
return NULL;
} params = switch_xml_add_child_d(xml, "params", off++);
vars = switch_xml_add_child_d(xml, "variables", off++);
if (params) {
if ((hi = params->headers)) { for (entry = ldap_first_entry(ld, msg); entry != NULL; entry = ldap_next_entry(ld, entry)) {
for (; hi; hi = hi->next) { switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_NOTICE, "entry searched by filter %s\n", filter);
switch (query_type) {
case XML_LDAP_CONFIG: for (key = ldap_first_attribute(ld, entry, &ber); key != NULL; key = ldap_next_attribute(ld, entry, ber)) {
break;
for (attr = binding->attr_list; attr; attr = attr->next) {
case XML_LDAP_DIRECTORY: if (strlen(key) == attr->len) {
if (!strcmp(hi->name, "user")) { if (!strncasecmp(attr->val, key, strlen(key))) {
dir_exten = strdup(hi->value); val = ldap_get_values_len(ld, entry, key);
} else if (!strcmp(hi->name, "domain")) { if (val != NULL) {
dir_domain = strdup(hi->value); if (ldap_count_values_len(val) > 0 && val[0] != NULL && val[0]->bv_val != NULL) {
} switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_NOTICE, " attribute %s => %s\n", fsattr[attr->type], val[0]->bv_val);
break; if (attr->type < 2) {
switch_xml_set_attr_d(xml, fsattr[attr->type], val[0]->bv_val);
case XML_LDAP_DIALPLAN: } else if (attr->type < 10) {
case XML_LDAP_PHRASE: cur = switch_xml_add_child_d(params, "param", 0);
case XML_LDAP_LANGUAGE: switch_xml_set_attr_d(cur, "name", fsattr[attr->type]);
break; switch_xml_set_attr_d(cur, "value", val[0]->bv_val);
} } else {
cur = switch_xml_add_child_d(vars, "variable", 0);
switch_xml_set_attr_d(cur, "name", fsattr[attr->type]);
switch_xml_set_attr_d(cur, "value", val[0]->bv_val);
}
}
ldap_value_free_len(val);
}
continue;
}
}
}
ldap_memfree(key);
} }
switch (query_type) { ber_free(ber, 0);
case XML_LDAP_CONFIG: }
break;
ldap_msgfree(entry);
case XML_LDAP_DIRECTORY: ldap_msgfree(msg);
if (dir_exten && dir_domain) { } else {
if ((xml = switch_xml_new("directory"))) { ret = SWITCH_STATUS_FALSE;
switch_xml_set_attr_d(xml, "type", "freeswitch/xml"); }
if ((sub = switch_xml_add_child_d(xml, "section", off++))) { cleanup:
switch_xml_set_attr_d(sub, "name", "directory"); switch_safe_free(filter);
} switch_safe_free(basedn)
switch_safe_free(dir_exten);
if ((sub = switch_xml_add_child_d(sub, "domain", off++))) { switch_safe_free(dir_domain);
switch_xml_set_attr_d(sub, "name", dir_domain);
} return ret;
}
if ((sub = switch_xml_add_child_d(sub, "user", off++))) {
switch_xml_set_attr_d(sub, "id", dir_exten);
}
}
search_filter = switch_mprintf(binding->filter, dir_exten); static switch_status_t trysearch(switch_xml_t *pxml, int *xoff, LDAP * ld, char *basedn, char *filter)
search_base = switch_mprintf(binding->basedn, dir_domain); {
switch_status_t ret = SWITCH_STATUS_FALSE;
int off = *xoff;
char *key = NULL;
char *dn = NULL;
char **val = NULL;
BerElement *ber = NULL;
switch_xml_t xml = *pxml;
LDAPMessage *msg, *entry;
free(dir_exten); switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "trying search in base %s with filter %s\n", basedn, filter);
dir_exten = NULL;
free(dir_domain); if ((ldap_search_s(ld, basedn, LDAP_SCOPE_ONE, filter, NULL, 0, &msg) != LDAP_SUCCESS))
dir_domain = NULL; goto cleanup;
} else { if (ldap_count_entries(ld, msg) > 0) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, ret = SWITCH_STATUS_SUCCESS;
"Something bad happened during the query construction phase likely exten(%s) or domain(%s) is null\n", dir_exten, for (entry = ldap_first_entry(ld, msg); entry != NULL; entry = ldap_next_entry(ld, entry)) {
dir_domain);
goto cleanup;
}
break;
case XML_LDAP_DIALPLAN: val = ldap_get_values(ld, entry, "fstag");
if ((xml = switch_xml_new("document"))) { xml = switch_xml_add_child_d(xml, val[0], off);
switch_xml_set_attr_d(xml, "type", "freeswitch/xml"); ldap_value_free(val);
if ((sub = switch_xml_add_child_d(xml, "section", off++))) { for (key = ldap_first_attribute(ld, entry, &ber); key != NULL; key = ldap_next_attribute(ld, entry, ber)) {
switch_xml_set_attr_d(sub, "name", "dialplan");
}
sub = switch_xml_add_child_d(xml, "context", off++); if (!strncasecmp(key, "fstag", strlen(key)) || !strncasecmp(key, "objectclass", strlen(key))) {
ldap_memfree(key);
continue;
} }
break; val = ldap_get_values(ld, entry, key);
switch_xml_set_attr_d(xml, key, val[0]);
case XML_LDAP_PHRASE:
case XML_LDAP_LANGUAGE: ldap_memfree(key);
break; ldap_value_free(val);
} }
} else { ber_free(ber, 0);
goto cleanup;
dn = ldap_get_dn(ld, entry);
rec(&xml, &off, ld, dn);
*xoff = 1;
} }
}
ldap_msgfree(entry);
ldap_msgfree(msg);
}
cleanup:
switch_safe_free(basedn);
switch_safe_free(filter);
switch_safe_free(key);
if ((ldap->ld = (LDAP *) ldap_init(binding->host, LDAP_PORT)) == NULL) { return ret;
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Unable to connect to ldap server.%s\n", binding->host); }
goto cleanup;
}
if (ldap_set_option(ldap->ld, LDAP_OPT_PROTOCOL_VERSION, &desired_version) != LDAP_OPT_SUCCESS) { void rec(switch_xml_t *pxml, int *xoff, LDAP * ld, char *dn)
goto cleanup; {
} int off = *xoff;
char *key;
char **val;
ldap_set_option(ldap->ld, LDAP_OPT_X_SASL_SECPROPS, &ldap->sp); switch_xml_t xml = *pxml, new;
LDAPMessage *msg, *entry;
BerElement *ber;
ldap_search_s(ld, dn, LDAP_SCOPE_ONE, NULL, NULL, 0, &msg);
switch_safe_free(dn);
if (binding->binddn) { if (ldap_count_entries(ld, msg) > 0) {
if (ldap_bind_s(ldap->ld, binding->binddn, binding->bindpass, auth_method) != LDAP_SUCCESS) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Unable to bind to ldap server %s as %s\n", binding->host, binding->binddn);
goto cleanup;
}
} else {
if (ldap_sasl_interactive_bind_s
(ldap->ld, NULL, binding->defaults->mech, NULL, NULL, (unsigned) (intptr_t) LDAP_SASL_SIMPLE, lutil_sasl_interact,
binding->defaults) != LDAP_SUCCESS) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Unable to sasl_bind to ldap server %s as %s\n", binding->host,
binding->defaults->authcid);
goto cleanup;
}
}
if (ldap_search_s(ldap->ld, search_base, LDAP_SCOPE_SUBTREE, search_filter, NULL, 0, &ldap->msg) != LDAP_SUCCESS) { for (entry = ldap_first_entry(ld, msg); entry != NULL; entry = ldap_next_entry(ld, entry)) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Query failed: -b \"%s\" \"%s\"\n", search_base, search_filter);
goto cleanup;
}
if (ldap_count_entries(ldap->ld, ldap->msg) <= 0) { val = ldap_get_values(ld, entry, "fstag");
goto cleanup; new = switch_xml_add_child_d(xml, val[0], off);
} ldap_value_free(val);
if (sub && xml_ldap_result(&ldap_connection, binding, &sub, &off, query_type) != SWITCH_STATUS_SUCCESS) { for (key = ldap_first_attribute(ld, entry, &ber); key != NULL; key = ldap_next_attribute(ld, entry, ber)) {
goto cleanup;
} if (!strncasecmp("fstag", key, 5) || !strncasecmp("objectclass", key, 10)) {
ldap_memfree(key);
ret = 0; continue;
}
cleanup: val = ldap_get_values(ld, entry, key);
if (ldap->msg) { switch_xml_set_attr_d(new, key, val[0]);
ldap_msgfree(ldap->msg); ldap_memfree(key);
} ldap_value_free(val);
}
ber_free(ber, 0);
rec(&new, xoff, ld, ldap_get_dn(ld, entry));
}
ldap_msgfree(entry);
if (ldap->ld) {
ldap_unbind_s(ldap->ld);
} }
switch_safe_free(search_filter); ldap_msgfree(msg);
switch_safe_free(search_base);
//switch_xml_toxml_buf(xml,buf,0,0,1);
//switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Providing:\n%s\n", buf);
if (ret) {
switch_xml_free(xml);
return NULL;
}
return xml;
} }
static switch_xml_t xml_ldap_search(const char *section, const char *tag_name, const char *key_name, const char *key_value, switch_event_t *params,
static switch_status_t do_config(void) void *user_data)
{ {
char *cf = "xml_ldap.conf";
switch_xml_t cfg, xml, bindings_tag, binding_tag, param;
xml_binding_t *binding = NULL;
int x = 0;
if (!(xml = switch_xml_open_cfg(cf, &cfg, NULL))) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Open of %s failed\n", cf);
return SWITCH_STATUS_TERM;
}
if (!(bindings_tag = switch_xml_child(cfg, "bindings"))) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Missing <bindings> tag!\n");
goto done;
}
for (binding_tag = switch_xml_child(bindings_tag, "binding"); binding_tag; binding_tag = binding_tag->next) {
char *bname = (char *) switch_xml_attr_soft(binding_tag, "name");
if (!(binding = malloc(sizeof(*binding)))) {
goto done;
}
memset(binding, 0, sizeof(*binding));
if (!(binding->defaults = malloc(sizeof(lutilSASLdefaults)))) {
goto done;
}
memset(binding->defaults, 0, sizeof(lutilSASLdefaults));
for (param = switch_xml_child(binding_tag, "param"); param; param = param->next) {
char *var = (char *) switch_xml_attr_soft(param, "name"); xml_binding_t *binding = (xml_binding_t *) user_data;
char *val = (char *) switch_xml_attr_soft(param, "value"); switch_event_header_t *hi;
switch_status_t ret = SWITCH_STATUS_FALSE;
if (!strcasecmp(var, "filter")) {
binding->bindings = (char *) switch_xml_attr_soft(param, "bindings"); int desired_version = LDAP_VERSION3;
if (val) { int auth_method = LDAP_AUTH_SIMPLE;
binding->filter = strdup(val);
char *basedn = NULL, *filter = NULL;
char *dir_domain = NULL, *dir_exten = NULL;
LDAP *ld;
switch_xml_t xml = NULL;
int xoff = 0;
char *buf;
buf = malloc(4096);
xml = switch_xml_new("document");
switch_xml_set_attr_d(xml, "type", "freeswitch/xml");
if (params) {
if ((hi = params->headers)) {
for (; hi; hi = hi->next) {
switch (binding->bt) {
case XML_LDAP_CONFIG:
break;
case XML_LDAP_DIRECTORY:
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "from cb got %s=%s\n", hi->name, hi->value);
if (!strncmp(hi->name, "user", strlen(hi->name))) {
dir_exten = strdup(hi->value);
} else if (!strncmp(hi->name, "domain", strlen(hi->name))) {
dir_domain = strdup(hi->value);
}
break;
case XML_LDAP_DIALPLAN:
case XML_LDAP_PHRASE:
break;
} }
} else if (!strcasecmp(var, "basedn")) {
binding->basedn = strdup(val);
} else if (!strcasecmp(var, "binddn")) {
binding->binddn = strdup(val);
} else if (!strcasecmp(var, "bindpass")) {
binding->bindpass = strdup(val);
} else if (!strcasecmp(var, "host")) {
binding->host = strdup(val);
} else if (!strcasecmp(var, "mech")) {
binding->defaults->mech = strdup(val);
} else if (!strcasecmp(var, "realm")) {
binding->defaults->realm = strdup(val);
} else if (!strcasecmp(var, "authcid")) {
binding->defaults->authcid = strdup(val);
} else if (!strcasecmp(var, "authzid")) {
binding->defaults->authzid = strdup(val);
} }
} }
if (!binding->basedn || !binding->filter) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "You must define \"basedn\", and \"filter\" in mod_xml_ldap.conf.xml\n");
continue;
}
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_NOTICE, "Binding [%s] XML Fetch Function [%s] (%s) [%s]\n",
zstr(bname) ? "N/A" : bname, binding->basedn, binding->filter, binding->bindings ? binding->bindings : "all");
switch_xml_bind_search_function(xml_ldap_search, switch_xml_parse_section_string(bname), binding);
x++;
binding = NULL;
} }
if ((ldap_initialize(&ld, binding->url)) != LDAP_SUCCESS)
done: goto cleanup;
switch_xml_free(xml); if ((ldap_set_option(ld, LDAP_OPT_PROTOCOL_VERSION, &desired_version)) != LDAP_SUCCESS)
goto cleanup;
return SWITCH_STATUS_SUCCESS; if ((ldap_bind_s(ld, binding->binddn, binding->bindpass, auth_method)) != LDAP_SUCCESS)
goto cleanup;
switch (binding->bt) {
case XML_LDAP_CONFIG:
xml = switch_xml_add_child_d(xml, "section", xoff++);
switch_xml_set_attr_d(xml, "name", "configuration");
filter = switch_mprintf(binding->filter, key_name, key_value);
basedn = switch_mprintf(binding->basedn, tag_name);
ret = trysearch(&xml, &xoff, ld, basedn, filter);
break;
case XML_LDAP_DIRECTORY:
ret = trydir(&xml, &xoff, ld, dir_domain, dir_exten, binding);
break;
case XML_LDAP_DIALPLAN:
break;
case XML_LDAP_PHRASE:
break;
}
cleanup:
ldap_unbind_s(ld);
switch_xml_toxml_buf(xml, buf, 0, 0, 1);
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG,"XML providing:\n%s\n", buf);
switch_safe_free(buf);
if (ret != SWITCH_STATUS_SUCCESS) {
switch_xml_free(xml);
return NULL;
}
return xml;
} }
SWITCH_MODULE_LOAD_FUNCTION(mod_xml_ldap_load)
{
switch_api_interface_t *xml_ldap_api_interface;
/* connect my internal structure to the blank pointer passed to me */
*module_interface = switch_loadable_module_create_module_interface(pool, modname);
SWITCH_ADD_API(xml_ldap_api_interface, "xml_ldap", "XML LDAP", xml_ldap_function, XML_LDAP_SYNTAX);
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_INFO, "XML LDAP module loading...\n");
if (do_config() != SWITCH_STATUS_SUCCESS) {
return SWITCH_STATUS_FALSE;
}
/* indicate that the module should continue to be loaded */
return SWITCH_STATUS_SUCCESS;
}
SWITCH_MODULE_SHUTDOWN_FUNCTION(mod_xml_ldap_shutdown)
{
return SWITCH_STATUS_SUCCESS;
}
/* For Emacs: /* For Emacs:
* Local Variables: * Local Variables:
* mode:c * mode:c
......
src/mod/xml_int/mod_xml_ldap/mod_xml_ldapv2.c deleted 100644 → 0
浏览文件 @ 8ec7b25c
#include <switch.h>
#include <stdlib.h>
#include <string.h>
#include <lber.h>
#include <ldap.h>
#define PCACHE_TTL 300
#define NCACHE_TTL 900
typedef struct xml_ldap_attribute xml_ldap_attribute_t;
typedef enum {
XML_LDAP_CONFIG = 0,
XML_LDAP_DIRECTORY,
XML_LDAP_DIALPLAN,
XML_LDAP_PHRASE
} xml_ldap_query_type_t;
typedef struct xml_binding {
char *bindings;
xml_ldap_query_type_t bt;
char *url;
char *basedn;
char *binddn;
char *bindpass;
char *filter;
xml_ldap_attribute_t *attr_list;
} xml_binding_t;
typedef enum exten_types {
LDAP_EXTEN_ID = 0,
LDAP_EXTEN_VM_MAILBOX,
LDAP_EXTEN_PASSWORD,
LDAP_EXTEN_VM_PASSWORD,
LDAP_EXTEN_VM_EMAILADDR,
LDAP_EXTEN_VM_EMAILMSG,
LDAP_EXTEN_VM_DELETE,
LDAP_EXTEN_VM_ATTACHAUDIO,
LDAP_EXTEN_NAME,
LDAP_EXTEN_LABEL,
LDAP_EXTEN_AREACODE,
LDAP_EXTEN_CID_EXTNAME,
LDAP_EXTEN_CID_EXTNUM,
LDAP_EXTEN_INTNAME,
LDAP_EXTEN_INTNUM,
LDAP_EXTEN_RECORD_CALLS,
LDAP_EXTEN_ACTIVE,
LDAP_EXTEN_CFWD_REWRITECID,
LDAP_EXTEN_CFWD_ACTIVE,
LDAP_EXTEN_CFWD_DEST,
LDAP_EXTEN_CFWD_BUSYACTIVE,
LDAP_EXTEN_CFWD_BUSYDEST,
LDAP_EXTEN_NOANSWERACTIVE,
LDAP_EXTEN_NOANSWERDEST,
LDAP_EXTEN_NOANSWERSECONDS,
LDAP_EXTEN_PROGRESSAUDIO,
LDAP_EXTEN_ALLOW_OUTOBUND,
LDAP_EXTEN_ALLOW_XFER,
LDAP_EXTEN_HOTLINE_ACTIVE,
LDAP_EXTEN_HOTLINE_DEST,
LDAP_EXTEN_CLASSOFSERVICE
} exten_type_t;
struct xml_ldap_attribute {
exten_type_t type;
uint64_t len;
char *val;
xml_ldap_attribute_t *next;
};
SWITCH_MODULE_LOAD_FUNCTION(mod_xml_ldap_load);
SWITCH_MODULE_SHUTDOWN_FUNCTION(mod_xml_ldap_shutdown);
SWITCH_MODULE_DEFINITION(mod_xml_ldap, mod_xml_ldap_load, mod_xml_ldap_shutdown, NULL);
static switch_xml_t xml_ldap_search(const char *section, const char *tag_name, const char *key_name, const char *key_value, switch_event_t *params,
void *user_data);
static switch_status_t trydir(switch_xml_t *, int *, LDAP *, char *, char *, xml_binding_t *);
static switch_status_t do_config(void);
static switch_status_t trysearch(switch_xml_t *pxml, int *xoff, LDAP * ld, char *basedn, char *filter);
void rec(switch_xml_t *, int *, LDAP * ld, char *);
#define XML_LDAP_SYNTAX ""
SWITCH_STANDARD_API(xml_ldap_function)
{
return SWITCH_STATUS_FALSE;
}
SWITCH_MODULE_LOAD_FUNCTION(mod_xml_ldap_load)
{
switch_api_interface_t *xml_ldap_api_interface;
/* connect my internal structure to the blank pointer passed to me */
*module_interface = switch_loadable_module_create_module_interface(pool, modname);
SWITCH_ADD_API(xml_ldap_api_interface, "xml_ldap", "XML LDAP", xml_ldap_function, XML_LDAP_SYNTAX);
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_INFO, "XML LDAP module loading...\n");
if (do_config() != SWITCH_STATUS_SUCCESS) {
return SWITCH_STATUS_FALSE;
}
/* indicate that the module should continue to be loaded */
return SWITCH_STATUS_SUCCESS;
}
SWITCH_MODULE_SHUTDOWN_FUNCTION(mod_xml_ldap_shutdown)
{
return SWITCH_STATUS_SUCCESS;
}
static switch_status_t do_config(void)
{
char *cf = "xml_ldap.conf";
switch_xml_t cfg, xml, bindings_tag, binding_tag, param, tran;
xml_binding_t *binding = NULL;
xml_ldap_attribute_t *attr_list = NULL;
int x = 0;
if (!(xml = switch_xml_open_cfg(cf, &cfg, NULL))) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "open of %s failed\n", cf);
return SWITCH_STATUS_TERM;
}
if (!(bindings_tag = switch_xml_child(cfg, "bindings"))) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Missing <bindings> tag!\n");
goto done;
}
for (binding_tag = switch_xml_child(bindings_tag, "binding"); binding_tag; binding_tag = binding_tag->next) {
char *bname = (char *) switch_xml_attr_soft(binding_tag, "name");
if (!(binding = malloc(sizeof(*binding)))) {
goto done;
}
memset(binding, 0, sizeof(*binding));
binding->attr_list = attr_list;
for (param = switch_xml_child(binding_tag, "param"); param; param = param->next) {
char *var = (char *) switch_xml_attr_soft(param, "name");
char *val = (char *) switch_xml_attr_soft(param, "value");
if (!strcasecmp(var, "filter")) {
binding->bindings = (char *) switch_xml_attr_soft(param, "bindings");
if (!strncmp(binding->bindings, "configuration", strlen(binding->bindings))) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "setting type XML_LDAP_CONFIG\n");
binding->bt = XML_LDAP_CONFIG;
} else if (!strncmp(binding->bindings, "directory", strlen(binding->bindings))) {
binding->bt = XML_LDAP_DIRECTORY;
} else if (!strncmp(binding->bindings, "dialplain", strlen(binding->bindings))) {
binding->bt = XML_LDAP_DIALPLAN;
} else if (!strncmp(binding->bindings, "phrases", strlen(binding->bindings))) {
binding->bt = XML_LDAP_PHRASE;
}
if (val) {
binding->filter = strdup(val);
printf("binding filter %s to %s\n", binding->filter, binding->bindings);
}
} else if (!strncasecmp(var, "basedn", strlen(val))) {
binding->basedn = strdup(val);
} else if (!strncasecmp(var, "binddn", strlen(val))) {
binding->binddn = strdup(val);
} else if (!strncasecmp(var, "bindpass", strlen(val))) {
binding->bindpass = strdup(val);
} else if (!strncasecmp(var, "url", strlen(val))) {
binding->url = strdup(val);
}
}
if (binding && binding->bt == XML_LDAP_DIRECTORY) {
attr_list = malloc(sizeof(*attr_list));
attr_list = memset(attr_list, 0, sizeof(*attr_list));
binding->attr_list = attr_list;
param = switch_xml_child(binding_tag, "trans");
for (tran = switch_xml_child(param, "tran"); tran; tran = tran->next) {
char *n = (char *) switch_xml_attr_soft(tran, "name");
char *m = (char *) switch_xml_attr_soft(tran, "mapfrom");
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_NOTICE, " adding map %s => %s\n", m, n);
if (!strncasecmp("id", n, strlen(n))) {
attr_list->type = LDAP_EXTEN_ID;
attr_list->len = strlen(m);
attr_list->val = strdup(m);
attr_list->next = malloc(sizeof(*attr_list));
attr_list->next = memset(attr_list->next, 0, sizeof(*attr_list));
attr_list = attr_list->next;
} else if (!strncasecmp("mailbox", n, strlen(n))) {
attr_list->type = LDAP_EXTEN_VM_MAILBOX;
attr_list->len = strlen(m);
attr_list->val = strdup(m);
attr_list->next = malloc(sizeof(*attr_list));
attr_list->next = memset(attr_list->next, 0, sizeof(*attr_list));
attr_list = attr_list->next;
} else if (!strncasecmp("password", n, strlen(n))) {
attr_list->type = LDAP_EXTEN_PASSWORD;
attr_list->len = strlen(m);
attr_list->val = strdup(m);
attr_list->next = malloc(sizeof(*attr_list));
attr_list->next = memset(attr_list->next, 0, sizeof(*attr_list));
attr_list = attr_list->next;
} else if (!strncasecmp("vm-password", n, strlen(n))) {
attr_list->type = LDAP_EXTEN_VM_PASSWORD;
attr_list->len = strlen(m);
attr_list->val = strdup(m);
attr_list->next = malloc(sizeof(*attr_list));
attr_list->next = memset(attr_list->next, 0, sizeof(*attr_list));
attr_list = attr_list->next;
} else if (!strncasecmp("email-addr", n, strlen(n))) {
attr_list->type = LDAP_EXTEN_VM_EMAILADDR;
attr_list->len = strlen(m);
attr_list->val = strdup(m);
attr_list->next = malloc(sizeof(*attr_list));
attr_list->next = memset(attr_list->next, 0, sizeof(*attr_list));
attr_list = attr_list->next;
} else if (!strncasecmp("vm-email-all-messages", n, strlen(n))) {
attr_list->type = LDAP_EXTEN_VM_EMAILMSG;
attr_list->len = strlen(m);
attr_list->val = strdup(m);
attr_list->next = malloc(sizeof(*attr_list));
attr_list->next = memset(attr_list->next, 0, sizeof(*attr_list));
attr_list = attr_list->next;
} else if (!strncasecmp("vm-delete-file", n, strlen(n))) {
attr_list->type = LDAP_EXTEN_VM_DELETE;
attr_list->len = strlen(m);
attr_list->val = strdup(m);
attr_list->next = malloc(sizeof(*attr_list));
attr_list->next = memset(attr_list->next, 0, sizeof(*attr_list));
attr_list = attr_list->next;
} else if (!strncasecmp("vm-attach-file", n, strlen(n))) {
attr_list->type = LDAP_EXTEN_VM_ATTACHAUDIO;
attr_list->len = strlen(m);
attr_list->val = strdup(m);
attr_list->next = malloc(sizeof(*attr_list));
attr_list->next = memset(attr_list->next, 0, sizeof(*attr_list));
attr_list = attr_list->next;
}
}
attr_list->next = NULL;
}
if (!binding->basedn || !binding->filter || !binding->url) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "You must define \"basedn\", and \"filter\" in mod_xml_ldap.conf.xml\n");
continue;
}
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_NOTICE, "Binding [%s] XML Fetch Function [%s] (%s) [%s]\n",
zstr(bname) ? "N/A" : bname, binding->basedn, binding->filter, binding->bindings ? binding->bindings : "all");
switch_xml_bind_search_function(xml_ldap_search, switch_xml_parse_section_string(bname), binding);
x++;
binding = NULL;
}
done:
switch_xml_free(xml);
return SWITCH_STATUS_SUCCESS;
}
static switch_status_t trydir(switch_xml_t *pxml, int *xoff, LDAP * ld, char *dir_domain, char *dir_exten, xml_binding_t *binding)
{
switch_status_t ret = SWITCH_STATUS_FALSE;
int off = *xoff;
char *key = NULL;
char *basedn = NULL, *filter = NULL;
char **val = NULL;
BerElement *ber = NULL;
switch_xml_t xml = *pxml, params = NULL, vars = NULL, cur = NULL;
LDAPMessage *msg, *entry;
static char *fsattr[] =
{ "id", "mailbox", "password", "vm-password", "email-addr", "vm-email-all-messages", "vm-delete-file", "vm-attach-file", NULL };
basedn = switch_mprintf(binding->basedn, dir_domain);
filter = switch_mprintf(binding->filter, dir_exten);
xml_ldap_attribute_t *attr = NULL;
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_NOTICE, "searching in basedn %s with filter %s\n", basedn, filter);
if ((ldap_search_s(ld, basedn, LDAP_SCOPE_SUB, filter, NULL, 0, &msg) != LDAP_SUCCESS))
goto cleanup;
if (ldap_count_entries(ld, msg) > 0) {
ret = SWITCH_STATUS_SUCCESS;
xml = switch_xml_add_child_d(xml, "section", off++);
switch_xml_set_attr_d(xml, "name", "directory");
xml = switch_xml_add_child_d(xml, "domain", off++);
switch_xml_set_attr_d(xml, "name", dir_domain);
xml = switch_xml_add_child_d(xml, "user", off++);
vars = switch_xml_add_child_d(xml, "variables", off++);
params = switch_xml_add_child_d(xml, "params", off++);
for (entry = ldap_first_entry(ld, msg); entry != NULL; entry = ldap_next_entry(ld, entry)) {
for (key = ldap_first_attribute(ld, entry, &ber); key != NULL; key = ldap_next_attribute(ld, entry, ber)) {
for (attr = binding->attr_list; attr; attr = attr->next) {
if (strlen(key) == attr->len) {
if (!strncasecmp(attr->val, key, strlen(key))) {
val = ldap_get_values(ld, entry, key);
if (ldap_count_values(val) == 1) {
if (attr->type < 2) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_NOTICE, "setting %s = %s ", fsattr[attr->type], val[0]);
switch_xml_set_attr_d(xml, fsattr[attr->type], val[0]);
} else if (attr->type < 8) {
cur = switch_xml_add_child_d(params, "param", 0);
switch_xml_set_attr_d(cur, fsattr[attr->type], val[0]);
} else {
cur = switch_xml_add_child_d(vars, "variable", 0);
switch_xml_set_attr_d(cur, fsattr[attr->type], val[0]);
}
} else {
/* multi val attrs */
}
ldap_value_free(val);
continue;
}
}
}
ldap_memfree(key);
}
ber_free(ber, 0);
}
ldap_msgfree(entry);
ldap_msgfree(msg);
} else {
ret = SWITCH_STATUS_FALSE;
}
cleanup:
switch_safe_free(filter);
switch_safe_free(basedn)
switch_safe_free(dir_exten);
switch_safe_free(dir_domain);
return ret;
}
static switch_status_t trysearch(switch_xml_t *pxml, int *xoff, LDAP * ld, char *basedn, char *filter)
{
switch_status_t ret;
int off = *xoff;
char *key = NULL;
char *dn = NULL;
char **val = NULL;
BerElement *ber = NULL;
switch_xml_t xml = *pxml;
LDAPMessage *msg, *entry;
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "trying search in base %s with filter %s\n", basedn, filter);
if ((ldap_search_s(ld, basedn, LDAP_SCOPE_ONE, filter, NULL, 0, &msg) != LDAP_SUCCESS))
goto cleanup;
if (ldap_count_entries(ld, msg) > 0) {
ret = SWITCH_STATUS_SUCCESS;
for (entry = ldap_first_entry(ld, msg); entry != NULL; entry = ldap_next_entry(ld, entry)) {
val = ldap_get_values(ld, entry, "fstag");
xml = switch_xml_add_child_d(xml, val[0], off);
ldap_value_free(val);
for (key = ldap_first_attribute(ld, entry, &ber); key != NULL; key = ldap_next_attribute(ld, entry, ber)) {
if (!strncasecmp(key, "fstag", strlen(key)) || !strncasecmp(key, "objectclass", strlen(key))) {
ldap_memfree(key);
continue;
}
val = ldap_get_values(ld, entry, key);
switch_xml_set_attr_d(xml, key, val[0]);
ldap_memfree(key);
ldap_value_free(val);
}
ber_free(ber, 0);
dn = ldap_get_dn(ld, entry);
rec(&xml, &off, ld, dn);
*xoff = 1;
}
ldap_msgfree(entry);
ldap_msgfree(msg);
} else {
ret = SWITCH_STATUS_FALSE;
}
cleanup:
switch_safe_free(basedn);
switch_safe_free(filter);
switch_safe_free(key);
return ret;
}
void rec(switch_xml_t *pxml, int *xoff, LDAP * ld, char *dn)
{
int off = *xoff;
char *key;
char **val;
switch_xml_t xml = *pxml, new;
LDAPMessage *msg, *entry;
BerElement *ber;
ldap_search_s(ld, dn, LDAP_SCOPE_ONE, NULL, NULL, 0, &msg);
switch_safe_free(dn);
if (ldap_count_entries(ld, msg) > 0) {
for (entry = ldap_first_entry(ld, msg); entry != NULL; entry = ldap_next_entry(ld, entry)) {
val = ldap_get_values(ld, entry, "fstag");
new = switch_xml_add_child_d(xml, val[0], off);
ldap_value_free(val);
for (key = ldap_first_attribute(ld, entry, &ber); key != NULL; key = ldap_next_attribute(ld, entry, ber)) {
if (!strncasecmp("fstag", key, 5) || !strncasecmp("objectclass", key, 10)) {
ldap_memfree(key);
continue;
}
val = ldap_get_values(ld, entry, key);
switch_xml_set_attr_d(new, key, val[0]);
ldap_memfree(key);
ldap_value_free(val);
}
ber_free(ber, 0);
rec(&new, xoff, ld, ldap_get_dn(ld, entry));
}
ldap_msgfree(entry);
}
ldap_msgfree(msg);
}
static switch_xml_t xml_ldap_search(const char *section, const char *tag_name, const char *key_name, const char *key_value, switch_event_t *params,
void *user_data)
{
xml_binding_t *binding = (xml_binding_t *) user_data;
switch_event_header_t *hi;
switch_status_t ret = SWITCH_STATUS_FALSE;
int desired_version = LDAP_VERSION3;
int auth_method = LDAP_AUTH_SIMPLE;
char *basedn = NULL, *filter = NULL;
char *dir_domain = NULL, *dir_exten = NULL;
char *buf;
buf = malloc(4096);
LDAP *ld;
switch_xml_t xml = NULL;
int xoff = 0;
xml = switch_xml_new("document");
switch_xml_set_attr_d(xml, "type", "freeswitch/xml");
if (params) {
if ((hi = params->headers)) {
for (; hi; hi = hi->next) {
switch (binding->bt) {
case XML_LDAP_CONFIG:
break;
case XML_LDAP_DIRECTORY:
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "from cb got %s=%s\n", hi->name, hi->value);
if (!strncmp(hi->name, "user", strlen(hi->name))) {
dir_exten = strdup(hi->value);
} else if (!strncmp(hi->name, "domain", strlen(hi->name))) {
dir_domain = strdup(hi->value);
}
break;
case XML_LDAP_DIALPLAN:
case XML_LDAP_PHRASE:
break;
}
}
}
}
if ((ldap_initialize(&ld, binding->url)) != LDAP_SUCCESS)
goto cleanup;
if ((ldap_set_option(ld, LDAP_OPT_PROTOCOL_VERSION, &desired_version)) != LDAP_SUCCESS)
goto cleanup;
if ((ldap_bind_s(ld, binding->binddn, binding->bindpass, auth_method)) != LDAP_SUCCESS)
goto cleanup;
switch (binding->bt) {
case XML_LDAP_CONFIG:
xml = switch_xml_add_child_d(xml, "section", xoff++);
switch_xml_set_attr_d(xml, "name", "configuration");
filter = switch_mprintf(binding->filter, key_name, key_value);
basedn = switch_mprintf(binding->basedn, tag_name);
ret = trysearch(&xml, &xoff, ld, basedn, filter);
break;
case XML_LDAP_DIRECTORY:
ret = trydir(&xml, &xoff, ld, dir_domain, dir_exten, binding);
break;
case XML_LDAP_DIALPLAN:
break;
case XML_LDAP_PHRASE:
break;
}
cleanup:
ldap_unbind_s(ld);
switch_xml_toxml_buf(xml, buf, 0, 0, 1);
printf("providing:\n%s\n", buf);
switch_safe_free(buf);
if (ret != SWITCH_STATUS_SUCCESS) {
switch_xml_free(xml);
return NULL;
}
return xml;
}
Markdown 格式
0% 或
您添加了 0 人 到此讨论。请谨慎行事。
请先完成此评论的编辑！
请 注册 或者 后发表评论