ld_session.c

Go to the documentation of this file.

/*
* $Id: ld_session.c 4585 2008-08-06 08:20:30Z klaus_darilion $
*
* Kamailio LDAP Module
*
* Copyright (C) 2007 University of North Carolina
*
* Original author: Christian Schlatter, cs@unc.edu
*
*
* This file is part of Kamailio, a free SIP server.
*
* Kamailio is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version
*
* Kamailio is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
*
* History:
* --------
* 2007-02-18: Initial version
*/


#include <string.h>
#include "ld_session.h"
#include "../../mem/mem.h"
#include "../../sr_module.h"


static struct ld_session* ld_sessions = NULL;
static char ini_key_name[512];

int add_ld_session(char* _name, LDAP* _ldh, dictionary* _d)
{
   struct ld_session* current = ld_sessions;
   struct ld_session* new_lds = NULL;
   char *host_name, *bind_dn, *bind_pwd;
   int client_search_timeout_ms, client_bind_timeout_ms, network_timeout_ms;
   
   new_lds = (struct ld_session*)pkg_malloc(sizeof(struct ld_session));
   if (new_lds == NULL)
   {
      LM_ERR("no memory\n");
      return -1;
   }
   memset( new_lds, 0, sizeof(struct ld_session));

   /* name */
   strncpy(new_lds->name, _name, 255);
   /* handle */
   new_lds->handle = _ldh;
   
   /* host_name */
   host_name = iniparser_getstring(
      _d,
      get_ini_key_name(_name, CFG_N_LDAP_HOST),
      CFG_DEF_HOST_NAME);
   new_lds->host_name = (char*)pkg_malloc(strlen(host_name)+1);
   if (new_lds->host_name == NULL) {
      LM_ERR("no memory\n");
      return -1;
   }
   strcpy(new_lds->host_name, host_name);

   /* version */
   new_lds->version = iniparser_getint(
      _d,
      get_ini_key_name(_name, CFG_N_LDAP_VERSION),
      CFG_DEF_LDAP_VERSION);
   
   /* client_search_timeout */
   client_search_timeout_ms = iniparser_getint(
      _d,
      get_ini_key_name(_name, CFG_N_LDAP_CLIENT_SEARCH_TIMEOUT),
      CFG_DEF_LDAP_CLIENT_SEARCH_TIMEOUT);
   if (client_search_timeout_ms < CFG_LDAP_CLIENT_SEARCH_TIMEOUT_MIN)
   {
      LM_INFO("[%s = %d ms] is below allowed min"
         " [%d ms] - [%s] set to [%d ms]\n",
         CFG_N_LDAP_CLIENT_SEARCH_TIMEOUT,
         client_search_timeout_ms,
         CFG_LDAP_CLIENT_SEARCH_TIMEOUT_MIN,
         CFG_N_LDAP_CLIENT_SEARCH_TIMEOUT,
         CFG_LDAP_CLIENT_SEARCH_TIMEOUT_MIN);
      client_search_timeout_ms = CFG_LDAP_CLIENT_SEARCH_TIMEOUT_MIN;
   }
   new_lds->client_search_timeout.tv_sec = client_search_timeout_ms / 1000;
   new_lds->client_search_timeout.tv_usec =
                           (client_search_timeout_ms % 1000) * 1000;

   /* client_bind_timeout */
   client_bind_timeout_ms = iniparser_getint(
      _d,
      get_ini_key_name(_name, CFG_N_LDAP_CLIENT_BIND_TIMEOUT),
      CFG_DEF_LDAP_CLIENT_BIND_TIMEOUT);
   new_lds->client_bind_timeout.tv_sec = client_bind_timeout_ms / 1000;
   new_lds->client_bind_timeout.tv_usec = 
                           (client_bind_timeout_ms % 1000) * 1000;
   
   /* network_timeout */
   network_timeout_ms = iniparser_getint(
      _d,
      get_ini_key_name(_name, CFG_N_LDAP_NETWORK_TIMEOUT),
      LDAP_NO_LIMIT);
   new_lds->network_timeout.tv_sec = network_timeout_ms / 1000;
   new_lds->network_timeout.tv_usec = (network_timeout_ms % 1000) * 1000;

   /* bind_dn */
   bind_dn = iniparser_getstring(
      _d,
      get_ini_key_name(_name, CFG_N_LDAP_BIND_DN),
      CFG_DEF_LDAP_BIND_DN);
   new_lds->bind_dn = (char*)pkg_malloc(strlen(bind_dn)+1);
   if (new_lds->bind_dn == NULL) {
      LM_ERR("no memory\n");
      return -1;
   }
   strcpy(new_lds->bind_dn, bind_dn);

   /* bind_pwd */
   bind_pwd = iniparser_getstring(
      _d,
      get_ini_key_name(_name, CFG_N_LDAP_BIND_PWD),
      CFG_DEF_LDAP_BIND_PWD);
   new_lds->bind_pwd = (char*)pkg_malloc(strlen(bind_pwd)+1);
   if (new_lds->bind_pwd == NULL) {
      LM_ERR("no memory\n");
      return -1;
   }
   strcpy(new_lds->bind_pwd, bind_pwd);

   /* calculate_ha1 */
   new_lds->calculate_ha1 = iniparser_getboolean(
      _d, 
      get_ini_key_name(_name, CFG_N_CALCULATE_HA1), 
      CFG_DEF_CALCULATE_HA1);
   
   
   if (current == NULL)
   {
      ld_sessions = new_lds;
   } else
   {
      while (current->next != NULL) { current = current->next; };
      current->next = new_lds;
   }

   return 0;
}


struct ld_session* get_ld_session(char* _name)
{
   struct ld_session* current = ld_sessions;
   
   if (_name == NULL)
   {
      LM_ERR("lds_name == NULL\n");
      return NULL;
   }
   while (current != NULL)
   {
      if (strcmp(current->name, _name) == 0)
      {
         return current;
      }
      current = current->next;
   }

   return NULL;
}


int free_ld_sessions(void)
{
   struct ld_session* current = ld_sessions;
   struct ld_session* tmp;

   while (current != NULL)
   {
      tmp = current->next;

      if (current->handle != NULL)
      {
         ldap_unbind_ext(current->handle, NULL, NULL);
      }
      if (current->host_name != NULL)
      {
         pkg_free(current->host_name);
      }
      if (current->bind_dn != NULL)
      {
         pkg_free(current->bind_dn);
      }
      if (current->bind_pwd != NULL)
      {
         pkg_free(current->bind_pwd);
      }
      
      pkg_free(current);
      current = tmp;
   }
   
   ld_sessions = NULL;

   return 0;
}

char* get_ini_key_name(char* _section, char* _key)
{
   sprintf(ini_key_name, "%s:%s", _section, _key);
   return ini_key_name;
}