modparam.c

Go to the documentation of this file.

/*
 * $Id: modparam.c 4518 2008-07-28 15:39:28Z henningw $
 *
 * Copyright (C) 2001-2003 FhG Fokus
 *
 * 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:
 * -------
 * 2003-03-20  regex support in modparam (janakj)
 * 2004-03-12  extra flag USE_FUNC_PARAM added to modparam type -
 *             instead of copying the param value, a func is called (bogdan)
 */

/*!
 * \file
 * \brief Module parameter configuration
 */


#include "modparam.h"
#include "dprint.h"
#include "mem/mem.h"
#include <sys/types.h>
#include <regex.h>
#include <string.h>


int set_mod_param_regex(char* regex, char* name, modparam_t type, void* val)
{
   struct sr_module* t;
   param_export_t* param;
   regex_t preg;
   int mod_found, len;
   char* reg;
   int n;

   len = strlen(regex);
   reg = pkg_malloc(len + 2 + 2 + 1);
   if (reg == 0) {
      LM_ERR("no pkg memory left\n");
      return -1;
   }
   reg[0] = '^';
   reg[1] = '(';
   memcpy(reg + 2, regex, len);
   reg[len + 2] = ')';
   reg[len + 3] = '$';
   reg[len + 4] = '\0';
   
   if (regcomp(&preg, reg, REG_EXTENDED | REG_NOSUB | REG_ICASE)) {
      LM_ERR("failed to compile regular expression\n");
      pkg_free(reg);
      return -2;
   }
   
   mod_found = 0;

   for(t = modules; t; t = t->next) {
      if (regexec(&preg, t->exports->name, 0, 0, 0) == 0) {
         LM_DBG("%s matches module %s\n",regex, t->exports->name);
         mod_found = 1;
         for(param=t->exports->params;param && param->name ; param++) {
            if ((strcmp(name, param->name) == 0) &&
            ( PARAM_TYPE_MASK(param->type) == type)) {
               LM_DBG("found <%s> in module %s [%s]\n",
                  name, t->exports->name, t->path);

               if (param->type&USE_FUNC_PARAM) {
                  n = ((param_func_t)(param->param_pointer))(type, val );
                  if (n<0)
                     return -4;
               } else {
                  switch(type) {
                     case STR_PARAM:
                        *((char**)(param->param_pointer)) =
                           strdup((char*)val);
                        break;
                     case INT_PARAM:
                        *((int*)(param->param_pointer)) =
                           (int)(long)val;
                        break;
                  }
               }

               break;
            }
         }
         if (!param || !param->name) {
            LM_ERR("parameter <%s> not found in module <%s>\n",
                name, t->exports->name);
            regfree(&preg);
            pkg_free(reg);
            return -3;
         }
      }
   }

   regfree(&preg);
   if (!mod_found) {
      LM_ERR("no module matching %s found\n|", regex);
      pkg_free(reg);
      return -4;
   }

   pkg_free(reg);
   return 0;
}

---