res/res_config_ldap.c

   1 /*
   2  * Asterisk -- A telephony toolkit for Linux.
   3  *
   4  * Copyright (C) 2005, Oxymium sarl
   5  * Manuel Guesdon <mguesdon@oxymium.net> - LDAP RealTime Driver Author/Adaptor
   6  *
   7  * Copyright (C) 2007, Digium, Inc.
   8  * Russell Bryant <russell@digium.com>
   9  *
  10  * See http://www.asterisk.org for more information about
  11  * the Asterisk project. Please do not directly contact
  12  * any of the maintainers of this project for assistance;
  13  * the project provides a web site, mailing lists and IRC
  14  * channels for your use.
  15  *
  16  * This program is free software, distributed under the terms of
  17  * the GNU General Public License Version 2. See the LICENSE file
  18  * at the top of the source tree.
  19  *
  20  */
  21
  22 /*! \file
  23  *
  24  * \brief ldap plugin for portable configuration engine (ARA)
  25  *
  26  * \author Mark Spencer <markster@digium.com>
  27  * \author Manuel Guesdon
  28  * \author Carl-Einar Thorner <cthorner@voicerd.com>
  29  * \author Russell Bryant <russell@digium.com>
  30  *
  31  * \arg http://www.openldap.org
  32  */
  33
  34 /*** MODULEINFO
  35         <depend>ldap</depend>
  36  ***/
  37
  38 #include "asterisk.h"
  39
  40 #include <stdlib.h>
  41 #include <string.h>
  42 #include <ctype.h>
  43 #include <stdio.h>
  44 #include <ldap.h>
  45
  46 ASTERISK_FILE_VERSION(__FILE__, "$Revision$")
  47
  48 #include "asterisk/channel.h"
  49 #include "asterisk/logger.h"
  50 #include "asterisk/config.h"
  51 #include "asterisk/module.h"
  52 #include "asterisk/lock.h"
  53 #include "asterisk/options.h"
  54 #include "asterisk/cli.h"
  55 #include "asterisk/utils.h"
  56 #include "asterisk/strings.h"
  57 #include "asterisk/pbx.h"
  58 #include "asterisk/linkedlists.h"
  59
  60 #define RES_CONFIG_LDAP_CONF "res_ldap.conf"
  61
  62 AST_MUTEX_DEFINE_STATIC(ldap_lock);
  63
  64 static LDAP *ldapConn;
  65 static char url[512];
  66 static char user[512];
  67 static char pass[50];
  68 static char basedn[512];
  69 static int version = 3;
  70 static time_t connect_time;
  71
  72 static int parse_config(void);
  73 static int ldap_reconnect(void);
  74 static char *realtime_ldap_status(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a);
  75
  76 struct category_and_metric {
  77         const char *name;
  78         int metric;
  79         const char *variable_name;
  80         const char *variable_value;
  81         int var_metric; /*!< For organizing variables (particularly includes and switch statments) within a context */
  82 };
  83
  84 /*! \brief Table configuration */
  85 struct ldap_table_config {
  86         char *table_name;                 /*!< table name */
  87         char *additional_filter;          /*!< additional filter        */
  88         struct ast_variable *attributes;  /*!< attribute names conversion */
  89         struct ast_variable *delimiters;  /*!< the current delimiter is semicolon, so we are not using this variable */
  90         AST_LIST_ENTRY(ldap_table_config) entry;
  91 };
  92
  93 /*! \brief Should be locked before using it */
  94 static AST_LIST_HEAD_NOLOCK_STATIC(table_configs, ldap_table_config);
  95 static struct ldap_table_config *base_table_config;
  96 static struct ldap_table_config *static_table_config;
  97
  98 static struct ast_cli_entry ldap_cli[] = {
  99         AST_CLI_DEFINE(realtime_ldap_status, "Shows connection information for the LDAP RealTime driver"),
 100 };
 101
 102 /*! \brief Create a new table_config */
 103 static struct ldap_table_config *table_config_new(const char *table_name)
 104 {
 105         struct ldap_table_config *p;
 106
 107         if (!(p = ast_calloc(1, sizeof(*p))))
 108                 return NULL;
 109
 110         if (table_name) {
 111                 if (!(p->table_name = ast_strdup(table_name))) {
 112                         free(p);
 113                         return NULL;
 114                 }
 115         }
 116
 117         return p;
 118 }
 119
 120 /*! \brief Find a table_config - Should be locked before using it
 121  *  \note This function assumes ldap_lock to be locked. */
 122 static struct ldap_table_config *table_config_for_table_name(const char *table_name)
 123 {
 124         struct ldap_table_config *c = NULL;
 125
 126         AST_LIST_TRAVERSE(&table_configs, c, entry) {
 127                 if (!strcmp(c->table_name, table_name))
 128                         break;
 129         }
 130
 131         return c;
 132 }
 133
 134 /*! \brief Find variable by name */
 135 static struct ast_variable *variable_named(struct ast_variable *var, const char *name)
 136 {
 137         for (; var; var = var->next) {
 138                 if (!strcasecmp(name, var->name))
 139                         break;
 140         }
 141
 142         return var;
 143 }
 144
 145 /*! \brief for the semicolon delimiter
 146         \param somestr - pointer to a string
 147
 148         \return number of occurances of the delimiter(semicolon)
 149  */
 150 static int semicolon_count_str(const char *somestr)
 151 {
 152         int count = 0;
 153
 154         for (; *somestr; somestr++) {
 155                 if (*somestr == ';')
 156                         count++;
 157         }
 158
 159         return count;
 160 }
 161
 162 /* takes a linked list of \a ast_variable variables, finds the one with the name variable_value
 163  * and returns the number of semicolons in the value for that \a ast_variable
 164  */
 165 static int semicolon_count_var(struct ast_variable *var)
 166 {
 167         struct ast_variable *var_value = variable_named(var, "variable_value");
 168
 169         if (!var_value)
 170                 return 0;
 171
 172         ast_debug(1, "LINE(%d) semicolon_count_var: %s\n", __LINE__, var_value->value);
 173
 174         return semicolon_count_str(var_value->value);
 175 }
 176
 177 /*! \brief add attribute to table config - Should be locked before using it */
 178 static void ldap_table_config_add_attribute(struct ldap_table_config *table_config,
 179         const char *attribute_name, const char *attribute_value)
 180 {
 181         struct ast_variable *var;
 182
 183         if (ast_strlen_zero(attribute_name) || ast_strlen_zero(attribute_value))
 184                 return;
 185
 186         if (!(var = ast_variable_new(attribute_name, attribute_value, table_config->table_name)))
 187                 return;
 188
 189         if (table_config->attributes)
 190                 var->next = table_config->attributes;
 191         table_config->attributes = var;
 192 }
 193
 194 /*! \brief Free table_config
 195  *  \note assumes ldap_lock to be locked */
 196 static void table_configs_free(void)
 197 {
 198         struct ldap_table_config *c;
 199
 200         while ((c = AST_LIST_REMOVE_HEAD(&table_configs, entry))) {
 201                 if (c->table_name)
 202                         free(c->table_name);
 203                 if (c->additional_filter)
 204                         free(c->additional_filter);
 205                 if (c->attributes)
 206                         ast_variables_destroy(c->attributes);
 207                 free(c);
 208         }
 209
 210         base_table_config = NULL;
 211         static_table_config = NULL;
 212 }
 213
 214 /*! \brief Convert variable name to ldap attribute name - Should be locked before using it */
 215 static const char *convert_attribute_name_to_ldap(struct ldap_table_config *table_config,
 216         const char *attribute_name)
 217 {
 218         int i = 0;
 219         struct ldap_table_config *configs[] = { table_config, base_table_config };
 220
 221         for (i = 0; i < ARRAY_LEN(configs); i++) {
 222                 struct ast_variable *attribute;
 223
 224                 if (!configs[i])
 225                         continue;
 226
 227                 attribute = configs[i]->attributes;
 228                 for (; attribute; attribute = attribute->next) {
 229                         if (!strcasecmp(attribute_name, attribute->name))
 230                                 return attribute->value;
 231                 }
 232         }
 233
 234         return attribute_name;
 235 }
 236
 237 /*! \brief Convert ldap attribute name to variable name - Should be locked before using it */
 238 static const char *convert_attribute_name_from_ldap(struct ldap_table_config *table_config,
 239                                                     const char *attribute_name)
 240 {
 241         int i = 0;
 242         struct ldap_table_config *configs[] = { table_config, base_table_config };
 243
 244         for (i = 0; i < ARRAY_LEN(configs); i++) {
 245                 struct ast_variable *attribute;
 246
 247                 if (!configs[i])
 248                         continue;
 249
 250                 attribute = configs[i]->attributes;
 251                 for (; attribute; attribute = attribute->next) {
 252                         if (strcasecmp(attribute_name, attribute->value) == 0)
 253                                 return attribute->name;
 254                 }
 255         }
 256
 257         return attribute_name;
 258 }
 259
 260 /*! \brief Get variables from ldap entry attributes - Should be locked before using it
 261  * \return a linked list of ast_variable variables.
 262  **/
 263 static struct ast_variable *realtime_ldap_entry_to_var(struct ldap_table_config *table_config,
 264         LDAPMessage *ldap_entry)
 265 {
 266         BerElement *ber = NULL;
 267         struct ast_variable *var = NULL;
 268         struct ast_variable *prev = NULL;
 269         int is_delimited = 0;
 270         int i = 0;
 271         char *ldap_attribute_name;
 272         struct berval *value;
 273         int pos = 0;
 274
 275         ldap_attribute_name = ldap_first_attribute(ldapConn, ldap_entry, &ber);
 276
 277         while (ldap_attribute_name) {
 278                 struct berval **values = NULL;
 279                 const char *attribute_name = convert_attribute_name_from_ldap(table_config, ldap_attribute_name);
 280                 int is_realmed_password_attribute = strcasecmp(attribute_name, "md5secret") == 0;
 281
 282                 values = ldap_get_values_len(ldapConn, ldap_entry, ldap_attribute_name); /* these are freed at the end */
 283                 if (values) {
 284                         struct berval **v = values;
 285
 286                         while (*v) {
 287                                 value = *v;
 288                                 ast_debug(2, "LINE(%d) attribute_name: %s LDAP value: %s\n", __LINE__, attribute_name, value->bv_val);
 289                                 if (is_realmed_password_attribute) {
 290                                         if (!strncasecmp(value->bv_val, "{md5}", 5))
 291                                                 value->bv_val += 5;
 292                                         else
 293                                                 value->bv_val = NULL;
 294                                         ast_debug(2, "md5: %s\n", value->bv_val);
 295                                 }
 296                                 if (value->bv_val) {
 297                                         /* ok, so looping through all delimited values except the last one (not, last character is not delimited...) */
 298                                         if (is_delimited) {
 299                                                 i = 0;
 300                                                 pos = 0;
 301                                                 while (!ast_strlen_zero(value->bv_val + i)) {
 302                                                         if (value->bv_val[i] == ';'){
 303                                                                 value->bv_val[i] = '\0';
 304                                                                 if (prev) {
 305                                                                         prev->next = ast_variable_new(attribute_name, &value->bv_val[pos], table_config->table_name);
 306                                                                         if (prev->next) {
 307                                                                                 prev = prev->next;
 308                                                                         }
 309                                                                 } else {
 310                                                                         prev = var = ast_variable_new(attribute_name, &value->bv_val[pos], table_config->table_name);
 311                                                                 }
 312                                                                 pos = i + 1;
 313                                                         }
 314                                                         i++;
 315                                                 }
 316                                         }
 317                                         /* for the last delimited value or if the value is not delimited: */
 318                                         if (prev) {
 319                                                 prev->next = ast_variable_new(attribute_name, &value->bv_val[pos], table_config->table_name);
 320                                                 if (prev->next) {
 321                                                         prev = prev->next;
 322                                                 }
 323                                         } else {
 324                                                 prev = var = ast_variable_new(attribute_name, &value->bv_val[pos], table_config->table_name);
 325                                         }
 326                                 }
 327                                 v++;
 328                         }
 329                         ldap_value_free_len(values);
 330                 }
 331                 ldap_attribute_name = ldap_next_attribute(ldapConn, ldap_entry, ber);
 332         }
 333         ber_free(ber, 0);
 334
 335         return var;
 336 }
 337
 338 /*! \brief Get variables from ldap entry attributes - Should be locked before using it
 339  *
 340  * The results are freed outside this function so is the \a vars array.
 341  *
 342  * \return \a vars - an array of ast_variable variables terminated with a null.
 343  **/
 344 static struct ast_variable **realtime_ldap_result_to_vars(struct ldap_table_config *table_config,
 345         LDAPMessage *ldap_result, unsigned int *entries_count_ptr)
 346 {
 347         struct ast_variable **vars;
 348         int i = 0;
 349         int tot_count = 0;
 350         int entry_index = 0;
 351         LDAPMessage *ldap_entry = NULL;
 352         BerElement *ber = NULL;
 353         struct ast_variable *var = NULL;
 354         struct ast_variable *prev = NULL;
 355         int is_delimited = 0;
 356         char *delim_value = NULL;
 357         int delim_tot_count = 0;
 358         int delim_count = 0;
 359
 360         /* First find the total count */
 361         ldap_entry = ldap_first_entry(ldapConn, ldap_result);
 362
 363         for (tot_count = 0; ldap_entry; tot_count++){
 364                 tot_count += semicolon_count_var(realtime_ldap_entry_to_var(table_config, ldap_entry));
 365                 ldap_entry = ldap_next_entry(ldapConn, ldap_entry);
 366         }
 367
 368         if (entries_count_ptr)
 369                 *entries_count_ptr = tot_count;
 370         /* Now that we have the total count we allocate space and create the variables
 371          * Remember that each element in vars is a linked list that points to realtime variable.
 372          * If the we are dealing with a static realtime variable we create a new element in the \a vars array for each delimited
 373          * value in \a variable_value; otherwise, we keep \a vars static and increase the length of the linked list of variables in the array element.
 374          * This memory must be freed outside of this function. */
 375         vars = ast_calloc(sizeof(struct ast_variable *), tot_count + 1);
 376
 377         ldap_entry = ldap_first_entry(ldapConn, ldap_result);
 378
 379         i = 0;
 380
 381         /* For each static realtime variable we may create several entries in the \a vars array if it's delimited */
 382         for (entry_index = 0; ldap_entry; ) {
 383                 int pos = 0;
 384                 delim_value = NULL;
 385                 delim_tot_count = 0;
 386                 delim_count = 0;
 387
 388                 do { /* while delim_count */
 389
 390                         /* Starting new static var */
 391                         char *ldap_attribute_name = ldap_first_attribute(ldapConn, ldap_entry, &ber);
 392                         struct berval *value;
 393                         while (ldap_attribute_name) {
 394
 395                                 const char *attribute_name =
 396                                         convert_attribute_name_from_ldap(table_config, ldap_attribute_name);
 397                                 int is_realmed_password_attribute = strcasecmp(attribute_name, "md5secret") == 0;
 398                                 struct berval **values = NULL;
 399
 400                                 values = ldap_get_values_len(ldapConn, ldap_entry, ldap_attribute_name);
 401                                 if (values) {
 402                                         struct berval **v = values;
 403
 404                                         while (*v) {
 405                                                 value = *v;
 406                                                 if (is_realmed_password_attribute) {
 407                                                         if (strncasecmp(value->bv_val, "{md5}", 5) == 0)
 408                                                                 value->bv_val += 5;
 409                                                         else
 410                                                                 value->bv_val = NULL;
 411                                                         ast_debug(2, "md5: %s\n", value->bv_val);
 412                                                 }
 413                                                 if (value->bv_val) {
 414                                                         if (delim_value == NULL
 415                                                                 && !is_realmed_password_attribute
 416                                                                 && (static_table_config != table_config || strcmp(attribute_name, "variable_value") == 0)) {
 417
 418                                                                 delim_value = ast_strdup(value->bv_val);
 419
 420                                                                 if ((delim_tot_count = semicolon_count_str(delim_value)) > 0) {
 421                                                                         ast_debug(4, "LINE(%d) is delimited %d times: %s\n", __LINE__, delim_tot_count, delim_value);
 422                                                                         is_delimited = 1;
 423                                                                 }
 424                                                         }
 425
 426                                                         if (is_delimited != 0
 427                                                                 && !is_realmed_password_attribute
 428                                                                 && (static_table_config != table_config || strcmp(attribute_name, "variable_value") == 0) ){
 429                                                                 /* for non-Static RealTime, first */
 430
 431                                                                 i = pos;
 432                                                                 while (!ast_strlen_zero(value->bv_val + i)) {
 433                                                                         ast_debug(4, "LINE(%d) DELIM pos: %d i: %d\n", __LINE__, pos, i);
 434                                                                         if (delim_value[i] == ';') {
 435                                                                                 delim_value[i] = '\0';
 436
 437                                                                                 ast_debug(2, "LINE(%d) DELIM - attribute_name: %s value: %s pos: %d\n", __LINE__, attribute_name, &delim_value[pos], pos);
 438
 439                                                                                 if (prev) {
 440                                                                                         prev->next = ast_variable_new(attribute_name, &delim_value[pos], table_config->table_name);
 441                                                                                         if (prev->next) {
 442                                                                                                 prev = prev->next;
 443                                                                                         }
 444                                                                                 } else {
 445                                                                                         prev = var = ast_variable_new(attribute_name, &delim_value[pos], table_config->table_name);
 446                                                                                 }
 447                                                                                 pos = i + 1;
 448
 449                                                                                 if (static_table_config == table_config) {
 450                                                                                         break;
 451                                                                                 }
 452                                                                         }
 453                                                                         i++;
 454                                                                 }
 455                                                                 if (ast_strlen_zero(value->bv_val + i)) {
 456                                                                         ast_debug(4, "LINE(%d) DELIM pos: %d i: %d delim_count: %d\n", __LINE__, pos, i, delim_count);
 457                                                                         /* Last delimited value */
 458                                                                         ast_debug(4, "LINE(%d) DELIM - attribute_name: %s value: %s pos: %d\n", __LINE__, attribute_name, &delim_value[pos], pos);
 459                                                                         if (prev) {
 460                                                                                 prev->next = ast_variable_new(attribute_name, &delim_value[pos], table_config->table_name);
 461                                                                                 if (prev->next) {
 462                                                                                         prev = prev->next;
 463                                                                                 }
 464                                                                         } else {
 465                                                                                 prev = var = ast_variable_new(attribute_name, &delim_value[pos], table_config->table_name);
 466                                                                         }
 467                                                                         /* Remembering to free memory */
 468                                                                         is_delimited = 0;
 469                                                                         pos = 0;
 470                                                                         free(delim_value);
 471                                                                         delim_value = NULL;
 472                                                                 }
 473
 474                                                                 ast_debug(4, "LINE(%d) DELIM pos: %d i: %d\n", __LINE__, pos, i);
 475                                                         } else {
 476                                                                 /* not delimited */
 477                                                                 if (delim_value) {
 478                                                                         free(delim_value);
 479                                                                         delim_value = NULL;
 480                                                                 }
 481                                                                 ast_debug(2, "LINE(%d) attribute_name: %s value: %s\n", __LINE__, attribute_name, value->bv_val);
 482
 483                                                                 if (prev) {
 484                                                                         prev->next = ast_variable_new(attribute_name, value->bv_val, table_config->table_name);
 485                                                                         if (prev->next) {
 486                                                                                 prev = prev->next;
 487                                                                         }
 488                                                                 } else {
 489                                                                         prev = var = ast_variable_new(attribute_name, value->bv_val, table_config->table_name);
 490                                                                 }
 491                                                         }
 492                                                 }
 493                                                 v++;
 494                                         } /*!< while(*v) */
 495                                         ldap_value_free_len(values);
 496                                 }/*!< if (values) */
 497                                 ldap_attribute_name = ldap_next_attribute(ldapConn, ldap_entry, ber);
 498                         } /*!< while (ldap_attribute_name) */
 499                         ber_free(ber, 0);
 500                         if (static_table_config == table_config) {
 501                                 if (option_debug > 2) {
 502                                         const struct ast_variable *tmpdebug = variable_named(var, "variable_name");
 503                                         const struct ast_variable *tmpdebug2 = variable_named(var, "variable_value");
 504                                         if (tmpdebug && tmpdebug2) {
 505                                                 ast_debug(3, "LINE(%d) Added to vars - %s = %s\n", __LINE__, tmpdebug->value, tmpdebug2->value);
 506                                         }
 507                                 }
 508                                 vars[entry_index++] = var;
 509                                 prev = NULL;
 510                         }
 511
 512                         delim_count++;
 513                 } while (delim_count <= delim_tot_count && static_table_config == table_config);
 514
 515                 if (static_table_config != table_config) {
 516                         ast_debug(3, "LINE(%d) Added to vars - non static\n", __LINE__);
 517
 518                         vars[entry_index++] = var;
 519                         prev = NULL;
 520                 }
 521                 ldap_entry = ldap_next_entry(ldapConn, ldap_entry);
 522         } /*!< end for loop over ldap_entry */
 523
 524         return vars;
 525 }
 526
 527
 528 static int is_ldap_connect_error(int err)
 529 {
 530         return (err == LDAP_SERVER_DOWN
 531                         || err == LDAP_TIMEOUT || err == LDAP_CONNECT_ERROR);
 532 }
 533
 534 /*! \brief Get LDAP entry by dn and return attributes as variables  - Should be locked before using it
 535         This is used for setting the default values of an object(i.e., with accountBaseDN)
 536 */
 537 static struct ast_variable *ldap_loadentry(struct ldap_table_config *table_config,
 538                                            const char *dn)
 539 {
 540         if (!table_config) {
 541                 ast_log(LOG_ERROR, "No table config\n");
 542                 return NULL;
 543         } else {
 544                 struct ast_variable **vars = NULL;
 545                 struct ast_variable *var = NULL;
 546                 int result = -1;
 547                 LDAPMessage *ldap_result = NULL;
 548                 int tries = 0;
 549
 550                 ast_debug(2, "ldap_loadentry dn=%s\n", dn);
 551
 552                 do {
 553                         result = ldap_search_ext_s(ldapConn, dn, LDAP_SCOPE_BASE,
 554                                            "(objectclass=*)", NULL, 0, NULL, NULL, NULL, LDAP_NO_LIMIT, &ldap_result);
 555                         if (result != LDAP_SUCCESS && is_ldap_connect_error(result)) {
 556                                 ast_log(LOG_WARNING,
 557                                         "Failed to query database. Try %d/3\n",
 558                                         tries + 1);
 559                                 tries++;
 560                                 if (tries < 3) {
 561                                         usleep(500000L * tries);
 562                                         if (ldapConn) {
 563                                                 ldap_unbind_ext_s(ldapConn, NULL, NULL);
 564                                                 ldapConn = NULL;
 565                                         }
 566                                         if (!ldap_reconnect())
 567                                                 break;
 568                                 }
 569                         }
 570                 } while (result != LDAP_SUCCESS && tries < 3 && is_ldap_connect_error(result));
 571
 572                 if (result != LDAP_SUCCESS) {
 573                         ast_log(LOG_WARNING,
 574                                         "Failed to query database. Check debug for more info.\n");
 575                         ast_debug(2, "dn=%s\n", dn);
 576                         ast_debug(2, "Query Failed because: %s\n",
 577                                 ldap_err2string(result));
 578                         ast_mutex_unlock(&ldap_lock);
 579                         return NULL;
 580                 } else {
 581                         int num_entry = 0;
 582                         unsigned int *entries_count_ptr = NULL; /*!< not using this */
 583                         if ((num_entry = ldap_count_entries(ldapConn, ldap_result)) > 0) {
 584                                 ast_debug(3, "num_entry: %d\n", num_entry);
 585
 586                                 vars = realtime_ldap_result_to_vars(table_config, ldap_result, entries_count_ptr);
 587                                 if (num_entry > 1)
 588                                         ast_log(LOG_WARNING, "More than one entry for dn=%s. Take only 1st one\n", dn);
 589                         } else {
 590                                 ast_log(LOG_WARNING, "Could not find any entry dn=%s.\n", dn);
 591                         }
 592                 }
 593                 ldap_msgfree(ldap_result);
 594
 595                 /* Chopping \a vars down to one variable */
 596                 if (vars != NULL) {
 597                         struct ast_variable **p = vars;
 598                         p++;
 599                         var = *p;
 600                         while (var) {
 601                                 ast_variables_destroy(var);
 602                                 p++;
 603                         }
 604                         vars = ast_realloc(vars, sizeof(struct ast_variable *));
 605                 }
 606
 607                 var = *vars;
 608
 609                 return var;
 610         }
 611 }
 612
 613 /*! \brief caller should free returned pointer */
 614 static char *substituted(struct ast_channel *channel, const char *string)
 615 {
 616 #define MAXRESULT       2048
 617         char *ret_string = NULL;
 618
 619         if (!ast_strlen_zero(string)) {
 620                 ret_string = ast_calloc(1, MAXRESULT);
 621                 pbx_substitute_variables_helper(channel, string, ret_string, MAXRESULT - 1);
 622         }
 623         ast_debug(2, "substituted: string: '%s' => '%s' \n",
 624                 string, ret_string);
 625         return ret_string;
 626 }
 627
 628 /*! \brief caller should free returned pointer */
 629 static char *cleaned_basedn(struct ast_channel *channel, const char *basedn)
 630 {
 631         char *cbasedn = NULL;
 632         if (basedn) {
 633                 char *p = NULL;
 634                 cbasedn = substituted(channel, basedn);
 635                 if (*cbasedn == '"') {
 636                         cbasedn++;
 637                         if (!ast_strlen_zero(cbasedn)) {
 638                                 int len = strlen(cbasedn);
 639                                 if (cbasedn[len - 1] == '"')
 640                                         cbasedn[len - 1] = '\0';
 641
 642                         }
 643                 }
 644                 p = cbasedn;
 645                 while (*p) {
 646                         if (*p == '|')
 647                                 *p = ',';
 648                         p++;
 649                 }
 650         }
 651         ast_debug(2, "basedn: '%s' => '%s' \n", basedn, cbasedn);
 652         return cbasedn;
 653 }
 654
 655 /*! \brief Replace \<search\> by \<by\> in string. No check is done on string allocated size ! */
 656 static int replace_string_in_string(char *string, const char *search, const char *by)
 657 {
 658         int search_len = strlen(search);
 659         int by_len = strlen(by);
 660         int replaced = 0;
 661         char *p = strstr(string, search);
 662         if (p) {
 663                 replaced = 1;
 664                 while (p) {
 665                         if (by_len == search_len)
 666                                 memcpy(p, by, by_len);
 667                         else {
 668                                 memmove(p + by_len, p + search_len,
 669                                                 strlen(p + search_len) + 1);
 670                                 memcpy(p, by, by_len);
 671                         }
 672                         p = strstr(p + by_len, search);
 673                 }
 674         }
 675         return replaced;
 676 }
 677
 678 /*! \brief Append a name=value filter string. The filter string can grow. */
 679 static void append_var_and_value_to_filter(struct ast_str **filter,
 680         struct ldap_table_config *table_config,
 681         const char *name, const char *value)
 682 {
 683         char *new_name = NULL;
 684         char *new_value = NULL;
 685         char *like_pos = strstr(name, " LIKE");
 686
 687         ast_debug(2, "name='%s' value='%s'\n", name, value);
 688
 689         if (like_pos) {
 690                 int len = like_pos - name;
 691                 name = new_name = ast_strdupa(name);
 692                 new_name[len] = '\0';
 693                 value = new_value = ast_strdupa(value);
 694                 replace_string_in_string(new_value, "\\_", "_");
 695                 replace_string_in_string(new_value, "%", "*");
 696         }
 697
 698         name = convert_attribute_name_to_ldap(table_config, name);
 699
 700         ast_str_append(filter, 0, "(%s=%s)", name, value);
 701 }
 702
 703 /*! \brief LDAP base function
 704  * \return a null terminated array of ast_variable (one per entry) or NULL if no entry is found or if an error occured
 705  * caller should free the returned array and ast_variables
 706  * \param entries_count_ptr is a pointer to found entries count (can be NULL)
 707  * \param basedn is the base DN
 708  * \param table_name is the table_name (used dor attribute convertion and additional filter)
 709  * \param ap contains null terminated list of pairs name/value
 710 */
 711 static struct ast_variable **realtime_ldap_base_ap(unsigned int *entries_count_ptr,
 712         const char *basedn, const char *table_name, va_list ap)
 713 {
 714         struct ast_variable **vars = NULL;
 715         const char *newparam = NULL;
 716         const char *newval = NULL;
 717         struct ldap_table_config *table_config = NULL;
 718         char *clean_basedn = cleaned_basedn(NULL, basedn);
 719         struct ast_str *filter = NULL;
 720         int tries = 0;
 721         int result = 0;
 722         LDAPMessage *ldap_result = NULL;
 723
 724         if (!table_name) {
 725                 ast_log(LOG_WARNING, "No table_name specified.\n");
 726                 ast_free(clean_basedn);
 727                 return NULL;
 728         }
 729
 730         if (!(filter = ast_str_create(80))) {
 731                 ast_free(clean_basedn);
 732                 return NULL;
 733         }
 734
 735         /* Get the first parameter and first value in our list of passed paramater/value pairs  */
 736         newparam = va_arg(ap, const char *);
 737         newval = va_arg(ap, const char *);
 738
 739         if (!newparam || !newval) {
 740                 ast_log(LOG_WARNING, "Realtime retrieval requires at least 1 parameter"
 741                         " and 1 value to search on.\n");
 742                 ast_free(filter);
 743                 ast_free(clean_basedn);
 744                 return NULL;
 745         }
 746
 747         ast_mutex_lock(&ldap_lock);
 748
 749         /* We now have our complete statement; Lets connect to the server and execute it.  */
 750         if (!ldap_reconnect()) {
 751                 ast_mutex_unlock(&ldap_lock);
 752                 ast_free(filter);
 753                 ast_free(clean_basedn);
 754                 return NULL;
 755         }
 756
 757         table_config = table_config_for_table_name(table_name);
 758         if (!table_config) {
 759                 ast_log(LOG_WARNING, "No table named '%s'.\n", table_name);
 760                 ast_mutex_unlock(&ldap_lock);
 761                 ast_free(filter);
 762                 ast_free(clean_basedn);
 763                 return NULL;
 764         }
 765
 766         ast_str_append(&filter, 0, "(&");
 767
 768         if (table_config && table_config->additional_filter)
 769                 ast_str_append(&filter, 0, "%s", table_config->additional_filter);
 770         if (table_config != base_table_config && base_table_config &&
 771                 base_table_config->additional_filter) {
 772                 ast_str_append(&filter, 0, "%s", base_table_config->additional_filter);
 773         }
 774
 775         /* Create the first part of the query using the first parameter/value pairs we just extracted */
 776         /*   If there is only 1 set, then we have our query. Otherwise, loop thru the list and concat */
 777
 778         append_var_and_value_to_filter(&filter, table_config, newparam, newval);
 779         while ((newparam = va_arg(ap, const char *))) {
 780                 newval = va_arg(ap, const char *);
 781                 append_var_and_value_to_filter(&filter, table_config, newparam, newval);
 782         }
 783         ast_str_append(&filter, 0, ")");
 784
 785         do {
 786                 /* freeing ldap_result further down */
 787                 result = ldap_search_ext_s(ldapConn, clean_basedn,
 788                                   LDAP_SCOPE_SUBTREE, filter->str, NULL, 0, NULL, NULL, NULL, LDAP_NO_LIMIT,
 789                                   &ldap_result);
 790                 if (result != LDAP_SUCCESS && is_ldap_connect_error(result)) {
 791                         ast_log(LOG_DEBUG, "Failed to query database. Try %d/10\n",
 792                                 tries + 1);
 793                         if (++tries < 10) {
 794                                 usleep(1);
 795                                 if (ldapConn) {
 796                                         ldap_unbind_ext_s(ldapConn, NULL, NULL);
 797                                         ldapConn = NULL;
 798                                 }
 799                                 if (!ldap_reconnect())
 800                                         break;
 801                         }
 802                 }
 803         } while (result != LDAP_SUCCESS && tries < 10 && is_ldap_connect_error(result));
 804
 805         if (result != LDAP_SUCCESS) {
 806                 ast_log(LOG_WARNING, "Failed to query database. Check debug for more info.\n");
 807                 ast_log(LOG_WARNING, "Query: %s\n", filter->str);
 808                 ast_log(LOG_WARNING, "Query Failed because: %s\n", ldap_err2string(result));
 809         } else {
 810                 /* this is where we create the variables from the search result
 811                  * freeing this \a vars outside this function */
 812                 if (ldap_count_entries(ldapConn, ldap_result) > 0) {
 813                         /* is this a static var or some other? they are handled different for delimited values */
 814                         vars = realtime_ldap_result_to_vars(table_config, ldap_result, entries_count_ptr);
 815                 } else {
 816                         ast_log(LOG_WARNING, "Could not find any entry matching %s in base dn %s.\n",
 817                                 filter->str, clean_basedn);
 818                 }
 819
 820                 ldap_msgfree(ldap_result);
 821
 822                 /* TODO: get the default variables from the accountBaseDN, not implemented with delimited values */
 823                 if (vars) {
 824                         struct ast_variable **p = vars;
 825                         while (*p) {
 826                                 struct ast_variable *append_var = NULL;
 827                                 struct ast_variable *tmp = *p;
 828                                 while (tmp) {
 829                                         if (strcasecmp(tmp->name, "accountBaseDN") == 0) {
 830                                                 /* Get the variable to compare with for the defaults */
 831                                                 struct ast_variable *base_var = ldap_loadentry(table_config, tmp->value);
 832
 833                                                 while (base_var) {
 834                                                         struct ast_variable *next = base_var->next;
 835                                                         struct ast_variable *test_var = *p;
 836                                                         int base_var_found = 0;
 837
 838                                                         /* run throught the default values and fill it inn if it is missing */
 839                                                         while (test_var) {
 840                                                                 if (strcasecmp(test_var->name, base_var->name) == 0) {
 841                                                                         base_var_found = 1;
 842                                                                         break;
 843                                                                 } else
 844                                                                         test_var = test_var->next;
 845                                                         }
 846                                                         if (base_var_found) {
 847                                                                 base_var->next = NULL;
 848                                                                 ast_variables_destroy(base_var);
 849                                                                 base_var = next;
 850                                                         } else {
 851                                                                 if (append_var)
 852                                                                         base_var->next = append_var;
 853                                                                 else
 854                                                                         base_var->next = NULL;
 855                                                                 append_var = base_var;
 856                                                                 base_var = next;
 857                                                         }
 858                                                 }
 859                                         }
 860                                         if (!tmp->next && append_var) {
 861                                                 tmp->next = append_var;
 862                                                 tmp = NULL;
 863                                         } else
 864                                                 tmp = tmp->next;
 865                                 }
 866                                 p++;
 867                         }
 868                 }
 869         }
 870
 871         if (filter)
 872                 ast_free(filter);
 873
 874         if (clean_basedn)
 875                 ast_free(clean_basedn);
 876
 877         ast_mutex_unlock(&ldap_lock);
 878
 879         return vars;
 880 }
 881
 882 /*! \brief same as realtime_ldap_base_ap but take variable arguments count list */
 883 static struct ast_variable **realtime_ldap_base(unsigned int *entries_count_ptr,
 884         const char *basedn, const char *table_name, ...)
 885 {
 886         struct ast_variable **vars = NULL;
 887         va_list ap;
 888
 889         va_start(ap, table_name);
 890         vars = realtime_ldap_base_ap(entries_count_ptr, basedn, table_name, ap);
 891         va_end(ap);
 892
 893         return vars;
 894 }
 895
 896 /*! \brief See Asterisk doc
 897 *
 898 * For Realtime Dynamic(i.e., switch, queues, and directory) -- I think
 899 */
 900 static struct ast_variable *realtime_ldap(const char *basedn,
 901                                           const char *table_name, va_list ap)
 902 {
 903         struct ast_variable **vars = realtime_ldap_base_ap(NULL, basedn, table_name, ap);
 904         struct ast_variable *var = NULL;
 905
 906         if (vars) {
 907                 struct ast_variable *last_var = NULL;
 908                 struct ast_variable **p = vars;
 909                 while (*p) {
 910                         if (last_var) {
 911                                 while (last_var->next)
 912                                         last_var = last_var->next;
 913                                 last_var->next = *p;
 914                         } else {
 915                                 var = *p;
 916                                 last_var = var;
 917                         }
 918                         p++;
 919                 }
 920                 free(vars);
 921         }
 922         return var;
 923 }
 924
 925 /*! \brief See Asterisk doc
 926 *
 927 * this function will be called for the switch statment if no match is found with the realtime_ldap function(i.e. it is a failover);
 928 * however, the ast_load_realtime wil match on wildcharacters also depending on what the mode is set to
 929 * this is an area of asterisk that could do with a lot of modification
 930 * I think this function returns Realtime dynamic objects
 931 */
 932 static struct ast_config *realtime_multi_ldap(const char *basedn,
 933       const char *table_name, va_list ap)
 934 {
 935         struct ast_variable **vars =
 936                 realtime_ldap_base_ap(NULL, basedn, table_name, ap);
 937         struct ast_config *cfg = NULL;
 938
 939         if (vars) {
 940                 cfg = ast_config_new();
 941                 if (!cfg) {
 942                         ast_log(LOG_WARNING, "Out of memory!\n");
 943                 } else {
 944                         struct ast_variable **p = vars;
 945
 946                         while (*p) {
 947                                 struct ast_category *cat = NULL;
 948                                 cat = ast_category_new("", table_name, -1);
 949                                 if (!cat) {
 950                                         ast_log(LOG_WARNING, "Out of memory!\n");
 951                                         break;
 952                                 } else {
 953                                         struct ast_variable *var = *p;
 954                                         while (var) {
 955                                                 struct ast_variable *next = var->next;
 956                                                 var->next = NULL;
 957                                                 ast_variable_append(cat, var);
 958                                                 var = next;
 959                                         }
 960                                 }
 961                                 ast_category_append(cfg, cat);
 962                                 p++;
 963                         }
 964                 }
 965                 free(vars);
 966         }
 967         return cfg;
 968
 969 }
 970
 971 /*!
 972  * \brief Sorting alogrithm for qsort to find the order of the variables \a a and \a b
 973  * \param a pointer to category_and_metric struct
 974  * \param b pointer to category_and_metric struct
 975  *
 976  * \retval -1 for if b is greater
 977  * \retval 0 zero for equal
 978  * \retval 1 if a is greater
 979  */
 980 static int compare_categories(const void *a, const void *b)
 981 {
 982         const struct category_and_metric *as = a;
 983         const struct category_and_metric *bs = b;
 984
 985         if (as->metric < bs->metric)
 986                 return -1;
 987         else if (as->metric > bs->metric)
 988                 return 1;
 989         else if (as->metric == bs->metric && strcmp(as->name, bs->name) != 0)
 990                 return strcmp(as->name, bs->name);
 991
 992         /* if the metric and the category name is the same, we check the variable metric */
 993         if (as->var_metric < bs->var_metric)
 994                 return -1;
 995         else if (as->var_metric > bs->var_metric)
 996                 return 1;
 997
 998         return 0;
 999 }
1000
1001 /*! \brief See Asterisk doc
1002  *
1003 *       This is for Static Realtime (again: I think...)
1004 *
1005 *       load the configuration stuff for the .conf files
1006 *       called on a reload
1007 */
1008 static struct ast_config *config_ldap(const char *basedn, const char *table_name,
1009         const char *file, struct ast_config *cfg, struct ast_flags config_flags, const char *sugg_incl, const char *who_asked)
1010 {
1011         unsigned int vars_count = 0;
1012         struct ast_variable **vars;
1013         int i = 0;
1014         struct ast_variable *new_v = NULL;
1015         struct ast_category *cur_cat = NULL;
1016         const char *last_category = NULL;
1017         int last_category_metric = 0;
1018         struct category_and_metric *categories;
1019         struct ast_variable **p;
1020
1021         if (ast_strlen_zero(file) || !strcasecmp(file, RES_CONFIG_LDAP_CONF)) {
1022                 ast_log(LOG_WARNING, "Cannot configure myself.\n");
1023                 return NULL;
1024         }
1025
1026         vars = realtime_ldap_base(&vars_count, basedn, table_name, "filename",
1027                                 file, "commented", "FALSE", NULL);
1028
1029         if (!vars) {
1030                 ast_log(LOG_WARNING, "Could not find config '%s' in database.\n", file);
1031                 return NULL;
1032         }
1033
1034         /*!\note Since the items come back in random order, they need to be sorted
1035          * first, and since the data could easily exceed stack size, this is
1036          * allocated from the heap.
1037          */
1038         if (!(categories = ast_calloc(sizeof(*categories), vars_count)))
1039                 return NULL;
1040
1041         for (vars_count = 0, p = vars; *p; p++) {
1042                 struct ast_variable *category = variable_named(*p, "category");
1043                 struct ast_variable *cat_metric = variable_named(*p, "cat_metric");
1044                 struct ast_variable *var_name = variable_named(*p, "variable_name");
1045                 struct ast_variable *var_val = variable_named(*p, "variable_value");
1046                 struct ast_variable *var_metric = variable_named(*p, "var_metric");
1047                 struct ast_variable *dn = variable_named(*p, "dn");
1048
1049                 ast_debug(1, "category: %s\n", category->value);
1050                 ast_debug(1, "var_name: %s\n", var_name->value);
1051                 ast_debug(1, "var_val: %s\n", var_val->value);
1052                 ast_debug(1, "cat_metric: %s\n", cat_metric->value);
1053
1054                 if (!category) {
1055                         ast_log(LOG_ERROR,
1056                                         "No category name in entry '%s'  for file '%s'.\n",
1057                                         (dn ? dn->value : "?"), file);
1058                 } else if (!cat_metric) {
1059                         ast_log(LOG_ERROR,
1060                                         "No category metric in entry '%s'(category: %s) for file '%s'.\n",
1061                                         (dn ? dn->value : "?"), category->value, file);
1062                 } else if (!var_metric) {
1063                         ast_log(LOG_ERROR,
1064                                         "No variable metric in entry '%s'(category: %s) for file '%s'.\n",
1065                                         (dn ? dn->value : "?"), category->value, file);
1066                 } else if (!var_name) {
1067                         ast_log(LOG_ERROR,
1068                                         "No variable name in entry '%s' (category: %s metric: %s) for file '%s'.\n",
1069                                         (dn ? dn->value : "?"), category->value,
1070                                         cat_metric->value, file);
1071                 } else if (!var_val) {
1072                         ast_log(LOG_ERROR,
1073                                         "No variable value in entry '%s' (category: %s metric: %s variable: %s) for file '%s'.\n",
1074                                         (dn ? dn->value : "?"), category->value,
1075                                         cat_metric->value, var_name->value, file);
1076                 } else {
1077                         categories[vars_count].name = category->value;
1078                         categories[vars_count].metric = atoi(cat_metric->value);
1079                         categories[vars_count].variable_name = var_name->value;
1080                         categories[vars_count].variable_value = var_val->value;
1081                         categories[vars_count].var_metric = atoi(var_metric->value);
1082                         vars_count++;
1083                 }
1084         }
1085
1086         qsort(categories, vars_count, sizeof(*categories), compare_categories);
1087
1088         for (i = 0; i < vars_count; i++) {
1089                 if (!strcmp(categories[i].variable_name, "#include")) {
1090                         struct ast_flags config_flags = { 0 };
1091                         if (!ast_config_internal_load(categories[i].variable_value, cfg, config_flags, "", who_asked))
1092                                 break;
1093                         continue;
1094                 }
1095
1096                 if (!last_category || strcmp(last_category, categories[i].name) ||
1097                         last_category_metric != categories[i].metric) {
1098                         cur_cat = ast_category_new(categories[i].name, table_name, -1);
1099                         if (!cur_cat)
1100                                 break;
1101                         last_category = categories[i].name;
1102                         last_category_metric = categories[i].metric;
1103                         ast_category_append(cfg, cur_cat);
1104                 }
1105
1106                 if (!(new_v = ast_variable_new(categories[i].variable_name, categories[i].variable_value, table_name)))
1107                         break;
1108
1109                 ast_variable_append(cur_cat, new_v);
1110         }
1111
1112         free(vars);
1113         free(categories);
1114
1115         return cfg;
1116 }
1117
1118 /* \brief Function to update a set of values in ldap
1119 static
1120 */
1121 static int update_ldap(const char *basedn, const char *table_name, const char *attribute,
1122         const char *lookup, va_list ap)
1123 {
1124         int error = 0;
1125         LDAPMessage *ldap_entry = NULL;
1126         LDAPMod **ldap_mods;
1127         const char *newparam = NULL;
1128         const char *newval = NULL;
1129         char *dn;
1130         int num_entries = 0;
1131         int i = 0;
1132         int mods_size = 0;
1133         int mod_exists = 0;
1134         struct ldap_table_config *table_config = NULL;
1135         char *clean_basedn = NULL;
1136         struct ast_str *filter = NULL;
1137         int tries = 0;
1138         int result = 0;
1139         LDAPMessage *ldap_result = NULL;
1140
1141         if (!table_name) {
1142                 ast_log(LOG_WARNING, "No table_name specified.\n");
1143                 return -1;
1144         }
1145
1146         if (!(filter = ast_str_create(80)))
1147                 return -1;
1148
1149         if (!attribute || !lookup) {
1150                 ast_log(LOG_WARNING,
1151                                 "LINE(%d): search parameters are empty.\n", __LINE__);
1152                 return -1;
1153         }
1154         ast_mutex_lock(&ldap_lock);
1155
1156         /* We now have our complete statement; Lets connect to the server and execute it.  */
1157         if (!ldap_reconnect()) {
1158                 ast_mutex_unlock(&ldap_lock);
1159                 return -1;
1160         }
1161
1162         table_config = table_config_for_table_name(table_name);
1163         if (!table_config) {
1164                 ast_log(LOG_WARNING, "No table named '%s'.\n", table_name);
1165                 ast_mutex_unlock(&ldap_lock);
1166                 return -1;
1167         }
1168
1169         clean_basedn = cleaned_basedn(NULL, basedn);
1170
1171         /* Create the filter with the table additional filter and the parameter/value pairs we were given */
1172         ast_str_append(&filter, 0, "(&");
1173         if (table_config && table_config->additional_filter) {
1174                 ast_str_append(&filter, 0, "%s", table_config->additional_filter);
1175         }
1176         if (table_config != base_table_config && base_table_config
1177                 && base_table_config->additional_filter) {
1178                 ast_str_append(&filter, 0, "%s", base_table_config->additional_filter);
1179         }
1180         append_var_and_value_to_filter(&filter, table_config, attribute, lookup);
1181         ast_str_append(&filter, 0, ")");
1182
1183         /* Create the modification array with the parameter/value pairs we were given,
1184          * if there are several parameters with the same name, we collect them into
1185          * one parameter/value pair and delimit them with a semicolon */
1186         newparam = va_arg(ap, const char *);
1187         newparam = convert_attribute_name_to_ldap(table_config, newparam);
1188         newval = va_arg(ap, const char *);
1189         if (!newparam || !newval) {
1190                 ast_log(LOG_WARNING,
1191                                 "LINE(%d): need at least one paramter to modify.\n", __LINE__);
1192                 return -1;
1193         }
1194
1195         mods_size = 2; /* one for the first param/value pair and one for the the terminating NULL */
1196         ldap_mods = ast_calloc(sizeof(LDAPMod *), mods_size);
1197         ldap_mods[0] = ast_calloc(1, sizeof(LDAPMod));
1198
1199         ldap_mods[0]->mod_op = LDAP_MOD_REPLACE;
1200         ldap_mods[0]->mod_type = ast_calloc(sizeof(char), strlen(newparam) + 1);
1201         strcpy(ldap_mods[0]->mod_type, newparam);
1202
1203         ldap_mods[0]->mod_values = ast_calloc(sizeof(char), 2);
1204         ldap_mods[0]->mod_values[0] = ast_calloc(sizeof(char), strlen(newval) + 1);
1205         strcpy(ldap_mods[0]->mod_values[0], newval);
1206
1207         while ((newparam = va_arg(ap, const char *))) {
1208                 newparam = convert_attribute_name_to_ldap(table_config, newparam);
1209                 newval = va_arg(ap, const char *);
1210                 mod_exists = 0;
1211
1212                 for (i = 0; i < mods_size - 1; i++) {
1213                         if (ldap_mods[i]&& !strcmp(ldap_mods[i]->mod_type, newparam)) {
1214                                 /* We have the parameter allready, adding the value as a semicolon delimited value */
1215                                 ldap_mods[i]->mod_values[0] = ast_realloc(ldap_mods[i]->mod_values[0], sizeof(char) * (strlen(ldap_mods[i]->mod_values[0]) + strlen(newval) + 2));
1216                                 strcat(ldap_mods[i]->mod_values[0], ";");
1217                                 strcat(ldap_mods[i]->mod_values[0], newval);
1218                                 mod_exists = 1;
1219                                 break;
1220                         }
1221                 }
1222
1223                 /* create new mod */
1224                 if (!mod_exists) {
1225                         mods_size++;
1226                         ldap_mods = ast_realloc(ldap_mods, sizeof(LDAPMod *) * mods_size);
1227                         ldap_mods[mods_size - 1] = NULL;
1228                         ldap_mods[mods_size - 2] = ast_calloc(1, sizeof(LDAPMod));
1229
1230                         ldap_mods[mods_size - 2]->mod_op = LDAP_MOD_REPLACE;
1231
1232                         ldap_mods[mods_size - 2]->mod_type = ast_calloc(sizeof(char), strlen(newparam) + 1);
1233                         strcpy(ldap_mods[mods_size - 2]->mod_type, newparam);
1234
1235                         ldap_mods[mods_size - 2]->mod_values = ast_calloc(sizeof(char *), 2);
1236                         ldap_mods[mods_size - 2]->mod_values[0] = ast_calloc(sizeof(char), strlen(newval) + 1);
1237                         strcpy(ldap_mods[mods_size - 2]->mod_values[0], newval);
1238                 }
1239         }
1240         /* freeing ldap_mods further down */
1241
1242         do {
1243                 /* freeing ldap_result further down */
1244                 result = ldap_search_ext_s(ldapConn, clean_basedn,
1245                                   LDAP_SCOPE_SUBTREE, filter->str, NULL, 0, NULL, NULL, NULL, LDAP_NO_LIMIT,
1246                                   &ldap_result);
1247                 if (result != LDAP_SUCCESS && is_ldap_connect_error(result)) {
1248                         ast_log(LOG_WARNING, "Failed to query database. Try %d/3\n",
1249                                 tries + 1);
1250                         tries++;
1251                         if (tries < 3) {
1252                                 usleep(500000L * tries);
1253                                 if (ldapConn) {
1254                                         ldap_unbind_ext_s(ldapConn, NULL, NULL);
1255                                         ldapConn = NULL;
1256                                 }
1257                                 if (!ldap_reconnect())
1258                                         break;
1259                         }
1260                 }
1261         } while (result != LDAP_SUCCESS && tries < 3 && is_ldap_connect_error(result));
1262
1263         if (result != LDAP_SUCCESS) {
1264                 ast_log(LOG_WARNING, "Failed to query directory. Check debug for more info.\n");
1265                 ast_log(LOG_WARNING, "Query: %s\n", filter->str);
1266                 ast_log(LOG_WARNING, "Query Failed because: %s\n",
1267                         ldap_err2string(result));
1268
1269                 ast_mutex_unlock(&ldap_lock);
1270                 if (filter)
1271                         free(filter);
1272                 if (clean_basedn)
1273                         free(clean_basedn);
1274                 ldap_msgfree(ldap_result);
1275                 ldap_mods_free(ldap_mods, 0);
1276                 return -1;
1277         }
1278         /* Ready to update */
1279         if ((num_entries = ldap_count_entries(ldapConn, ldap_result)) > 0) {
1280                 ast_debug(3, "LINE(%d) Modifying %s=%s hits: %d\n", __LINE__, attribute, lookup, num_entries);
1281                 for (i = 0; option_debug > 2 && i < mods_size - 1; i++)
1282                         ast_debug(3, "LINE(%d) %s=%s \n", __LINE__, ldap_mods[i]->mod_type, ldap_mods[i]->mod_values[0]);
1283
1284                 ldap_entry = ldap_first_entry(ldapConn, ldap_result);
1285
1286                 for (i = 0; ldap_entry; i++) {
1287                         dn = ldap_get_dn(ldapConn, ldap_entry);
1288                         if ((error = ldap_modify_ext_s(ldapConn, dn, ldap_mods, NULL, NULL)) != LDAP_SUCCESS)
1289                                 ast_log(LOG_ERROR, "Couldn't modify dn:%s because %s", dn, ldap_err2string(error));
1290
1291                         ldap_entry = ldap_next_entry(ldapConn, ldap_entry);
1292                 }
1293         }
1294
1295         ast_mutex_unlock(&ldap_lock);
1296         if (filter)
1297                 free(filter);
1298         if (clean_basedn)
1299                 free(clean_basedn);
1300         ldap_msgfree(ldap_result);
1301         ldap_mods_free(ldap_mods, 0);
1302         return num_entries;
1303 }
1304
1305 static struct ast_config_engine ldap_engine = {
1306         .name = "ldap",
1307         .load_func = config_ldap,
1308         .realtime_func = realtime_ldap,
1309         .realtime_multi_func = realtime_multi_ldap,
1310         .update_func = update_ldap
1311 };
1312
1313 static int load_module(void)
1314 {
1315         if (parse_config() < 0) {
1316                 ast_log(LOG_NOTICE, "Cannot load LDAP RealTime driver.\n");
1317                 return 0;
1318         }
1319
1320         ast_mutex_lock(&ldap_lock);
1321
1322         if (!ldap_reconnect())
1323                 ast_log(LOG_WARNING, "Couldn't establish connection. Check debug.\n");
1324
1325         ast_config_engine_register(&ldap_engine);
1326         ast_verb(1, "LDAP RealTime driver loaded.\n");
1327         ast_cli_register_multiple(ldap_cli, sizeof(ldap_cli) / sizeof(struct ast_cli_entry));
1328
1329         ast_mutex_unlock(&ldap_lock);
1330
1331         return 0;
1332 }
1333
1334 static int unload_module(void)
1335 {
1336         /* Aquire control before doing anything to the module itself. */
1337         ast_mutex_lock(&ldap_lock);
1338
1339         table_configs_free();
1340
1341         if (ldapConn) {
1342                 ldap_unbind_ext_s(ldapConn, NULL, NULL);
1343                 ldapConn = NULL;
1344         }
1345         ast_cli_unregister_multiple(ldap_cli, sizeof(ldap_cli) / sizeof(struct ast_cli_entry));
1346         ast_config_engine_deregister(&ldap_engine);
1347         ast_verb(1, "LDAP RealTime unloaded.\n");
1348
1349         /* Unlock so something else can destroy the lock. */
1350         ast_mutex_unlock(&ldap_lock);
1351
1352         return 0;
1353 }
1354
1355 static int reload(void)
1356 {
1357         /* Aquire control before doing anything to the module itself. */
1358         ast_mutex_lock(&ldap_lock);
1359
1360         if (ldapConn) {
1361                 ldap_unbind_ext_s(ldapConn, NULL, NULL);
1362                 ldapConn = NULL;
1363         }
1364
1365         if (parse_config() < 0) {
1366                 ast_log(LOG_NOTICE, "Cannot reload LDAP RealTime driver.\n");
1367                 ast_mutex_unlock(&ldap_lock);
1368                 return 0;
1369         }
1370
1371         if (!ldap_reconnect())
1372                 ast_log(LOG_WARNING, "Couldn't establish connection. Check debug.\n");
1373
1374         ast_verb(2, "LDAP RealTime reloaded.\n");
1375
1376         /* Done reloading. Release lock so others can now use driver. */
1377         ast_mutex_unlock(&ldap_lock);
1378
1379         return 0;
1380 }
1381
1382 int parse_config(void)
1383 {
1384         struct ast_config *config;
1385         struct ast_flags config_flags = {0};
1386         const char *s, *host;
1387         int port;
1388         char *category_name = NULL;
1389
1390         config = ast_config_load(RES_CONFIG_LDAP_CONF, config_flags);
1391
1392         if (!config) {
1393                 ast_log(LOG_WARNING, "Cannot load configuration %s\n", RES_CONFIG_LDAP_CONF);
1394                 return -1;
1395         }
1396
1397         if (!(s = ast_variable_retrieve(config, "_general", "user"))) {
1398                 ast_log(LOG_WARNING, "No directory user found, anonymous binding as default.\n");
1399                 user[0] = '\0';
1400         } else
1401                 ast_copy_string(user, s, sizeof(user));
1402
1403         if (!(s = ast_variable_retrieve(config, "_general", "pass"))) {
1404                 ast_log(LOG_WARNING, "No directory password found, using 'asterisk' as default.\n");
1405                 ast_copy_string(pass, "asterisk", sizeof(pass) - 1);
1406         } else
1407                 ast_copy_string(pass, s, sizeof(pass));
1408
1409         /* URL is preferred, use host and port if not found */
1410         if ((s = ast_variable_retrieve(config, "_general", "url"))) {
1411                 ast_copy_string(url, s, sizeof(url));
1412         } else if ((host = ast_variable_retrieve(config, "_general", "host"))) {
1413                 if (!(s = ast_variable_retrieve(config, "_general", "port")) || sscanf(s, "%d", &port) != 1) {
1414                         ast_log(LOG_NOTICE, "No directory port found, using 389 as default.\n");
1415                         port = 389;
1416                 }
1417
1418                 snprintf(url, sizeof(url), "ldap://%s:%d", host, port);
1419         } else {
1420                 ast_log(LOG_ERROR, "No directory URL or host found.\n");
1421                 ast_config_destroy(config);
1422                 return -1;
1423         }
1424
1425         if (!(s = ast_variable_retrieve(config, "_general", "basedn"))) {
1426                 ast_log(LOG_ERROR, "No LDAP base dn found, using 'asterisk' as default.\n");
1427                 basedn[0] = '\0';
1428         } else
1429                 ast_copy_string(basedn, s, sizeof(basedn));
1430
1431         if (!(s = ast_variable_retrieve(config, "_general", "version")) || !(s = ast_variable_retrieve(config, "_general", "protocol"))) {
1432                 ast_log(LOG_NOTICE, "No explicit LDAP version found, using 3 as default.\n");
1433                 version = 3;
1434         } else if (sscanf(s, "%d", &version) != 1 || version < 1 || version > 6) {
1435                 ast_log(LOG_WARNING, "Invalid LDAP version '%s', using 3 as default.\n", s);
1436                 version = 3;
1437         }
1438
1439         table_configs_free();
1440
1441         while ((category_name = ast_category_browse(config, category_name))) {
1442                 int is_general = (strcasecmp(category_name, "_general") == 0);
1443                 int is_config = (strcasecmp(category_name, "config") == 0); /*!< using the [config] context for Static RealTime */
1444                 struct ast_variable *var = ast_variable_browse(config, category_name);
1445
1446                 if (var) {
1447                         struct ldap_table_config *table_config =
1448                                 table_config_for_table_name(category_name);
1449                         if (!table_config) {
1450                                 table_config = table_config_new(category_name);
1451                                 AST_LIST_INSERT_HEAD(&table_configs, table_config, entry);
1452                                 if (is_general)
1453                                         base_table_config = table_config;
1454                                 if (is_config)
1455                                         static_table_config = table_config;
1456                         }
1457                         for (; var; var = var->next) {
1458                                 if (!strcasecmp(var->name, "additionalFilter"))
1459                                         table_config->additional_filter = strdup(var->value);
1460                                 else
1461                                         ldap_table_config_add_attribute(table_config, var->name, var->value);
1462                         }
1463                 }
1464         }
1465
1466         ast_config_destroy(config);
1467
1468         return 1;
1469 }
1470
1471 /*! \note ldap_lock should have been locked before calling this function. */
1472 static int ldap_reconnect(void)
1473 {
1474         int bind_result = 0;
1475         struct berval cred;
1476
1477         if (ldapConn) {
1478                 ast_debug(2, "Everything seems fine.\n");
1479                 return 1;
1480         }
1481
1482         if (ast_strlen_zero(url)) {
1483                 ast_log(LOG_ERROR, "Not enough parameters to connect to ldap database\n");
1484                 return 0;
1485         }
1486
1487         if (LDAP_SUCCESS != ldap_initialize(&ldapConn, url)) {
1488                 ast_log(LOG_ERROR, "Failed to init ldap connection to '%s'. Check debug for more info.\n", url);
1489                 return 0;
1490         }
1491
1492         if (LDAP_OPT_SUCCESS != ldap_set_option(ldapConn, LDAP_OPT_PROTOCOL_VERSION, &version)) {
1493                 ast_log(LOG_WARNING, "Unable to set LDAP protocol version to %d, falling back to default.\n", version);
1494         }
1495
1496         if (!ast_strlen_zero(user)) {
1497                 ast_debug(2, "bind to '%s' as user '%s'\n", url, user);
1498                 cred.bv_val = (char *) pass;
1499                 cred.bv_len = strlen(pass);
1500                 bind_result = ldap_sasl_bind_s(ldapConn, user, LDAP_SASL_SIMPLE, &cred, NULL, NULL, NULL);
1501         } else {
1502                 ast_debug(2, "bind %s anonymously\n", url);
1503                 bind_result = ldap_sasl_bind_s(ldapConn, NULL, LDAP_SASL_SIMPLE, NULL, NULL, NULL, NULL);
1504         }
1505         if (bind_result == LDAP_SUCCESS) {
1506                 ast_debug(2, "Successfully connected to database.\n");
1507                 connect_time = time(NULL);
1508                 return 1;
1509         } else {
1510                 ast_log(LOG_WARNING, "bind failed: %s\n", ldap_err2string(bind_result));
1511                 ldap_unbind_ext_s(ldapConn, NULL, NULL);
1512                 ldapConn = NULL;
1513                 return 0;
1514         }
1515 }
1516
1517 static char *realtime_ldap_status(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
1518 {
1519         char status[256], status2[100] = "";
1520         int ctime = time(NULL) - connect_time;
1521
1522         switch (cmd) {
1523         case CLI_INIT:
1524                 e->command = "realtime ldap status";
1525                 e->usage =
1526                         "Usage: realtime ldap status\n"
1527                         "               Shows connection information for the LDAP RealTime driver\n";
1528                 return NULL;
1529         case CLI_GENERATE:
1530                 return NULL;
1531         }
1532
1533         if (!ldapConn)
1534                 return CLI_FAILURE;
1535
1536         if (!ast_strlen_zero(url))
1537                 snprintf(status, sizeof(status), "Connected to '%s', baseDN %s", url, basedn);
1538
1539         if (!ast_strlen_zero(user))
1540                 snprintf(status2, sizeof(status2), " with username %s", user);
1541
1542         if (ctime > 31536000) {
1543                 ast_cli(a->fd, "%s%s for %d years, %d days, %d hours, %d minutes, %d seconds.\n",
1544                                 status, status2, ctime / 31536000,
1545                                 (ctime % 31536000) / 86400, (ctime % 86400) / 3600,
1546                                 (ctime % 3600) / 60, ctime % 60);
1547         } else if (ctime > 86400) {
1548                 ast_cli(a->fd, "%s%s for %d days, %d hours, %d minutes, %d seconds.\n",
1549                                 status, status2, ctime / 86400, (ctime % 86400) / 3600,
1550                                 (ctime % 3600) / 60, ctime % 60);
1551         } else if (ctime > 3600) {
1552                 ast_cli(a->fd, "%s%s for %d hours, %d minutes, %d seconds.\n",
1553                                 status, status2, ctime / 3600, (ctime % 3600) / 60,
1554                                 ctime % 60);
1555         } else if (ctime > 60) {
1556                 ast_cli(a->fd, "%s%s for %d minutes, %d seconds.\n", status, status2,
1557                                         ctime / 60, ctime % 60);
1558         } else {
1559                 ast_cli(a->fd, "%s%s for %d seconds.\n", status, status2, ctime);
1560         }
1561
1562         return CLI_SUCCESS;
1563 }
1564
1565 AST_MODULE_INFO(ASTERISK_GPL_KEY, AST_MODFLAG_GLOBAL_SYMBOLS, "LDAP realtime interface",
1566         .load = load_module,
1567         .unload = unload_module,
1568         .reload = reload,
1569 );