git.sip-router.org Git - kamailio/blob - src/modules/alias_db/alias_db.c

   1 /*
   2  * ALIAS_DB Module
   3  *
   4  * Copyright (C) 2017 Daniel-Constantin Mierla (asipto.com)
   5  * Copyright (C) 2004 Voice Sistem SRL
   6  *
   7  * This file is part of a module for Kamailio, a free SIP server.
   8  *
   9  * Kamailio is free software; you can redistribute it and/or modify
  10  * it under the terms of the GNU General Public License as published by
  11  * the Free Software Foundation; either version 2 of the License, or
  12  * (at your option) any later version
  13  *
  14  * Kamailio is distributed in the hope that it will be useful,
  15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17  * GNU General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU General Public License
  20  * along with this program; if not, write to the Free Software
  21  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
  22  *
  23  */
  24
  25
  26 #include <stdio.h>
  27 #include <string.h>
  28 #include "../../core/sr_module.h"
  29 #include "../../lib/srdb1/db.h"
  30 #include "../../core/dprint.h"
  31 #include "../../core/error.h"
  32 #include "../../core/mem/mem.h"
  33 #include "../../core/ut.h"
  34 #include "../../core/mod_fix.h"
  35 #include "../../core/kemi.h"
  36
  37 #include "alookup.h"
  38 #include "api.h"
  39
  40 MODULE_VERSION
  41
  42
  43 /* Module destroy function prototype */
  44 static void destroy(void);
  45
  46
  47 /* Module child-init function prototype */
  48 static int child_init(int rank);
  49
  50
  51 /* Module initialization function prototype */
  52 static int mod_init(void);
  53
  54 /* Fixup function */
  55 static int lookup_fixup(void** param, int param_no);
  56 static int find_fixup(void** param, int param_no);
  57
  58 static int w_alias_db_lookup1(struct sip_msg* _msg, char* _table, char* p2);
  59 static int w_alias_db_lookup2(struct sip_msg* _msg, char* _table, char* flags);
  60 static int w_alias_db_find3(struct sip_msg* _msg, char* _table, char* _in,
  61                 char* _out);
  62 static int w_alias_db_find4(struct sip_msg* _msg, char* _table, char* _in,
  63                 char* _out, char* flags);
  64
  65
  66 /* Module parameter variables */
  67 static str db_url       = str_init(DEFAULT_RODB_URL);
  68 str user_column         = str_init("username");
  69 str domain_column       = str_init("domain");
  70 str alias_user_column   = str_init("alias_username");
  71 str alias_domain_column = str_init("alias_domain");
  72 str domain_prefix       = {NULL, 0};
  73 int alias_db_use_domain = 0;
  74 int ald_append_branches = 0;
  75
  76 db1_con_t* db_handle;   /* Database connection handle */
  77 db_func_t adbf;  /* DB functions */
  78
  79 /* Exported functions */
  80 static cmd_export_t cmds[] = {
  81         {"alias_db_lookup", (cmd_function)w_alias_db_lookup1, 1, lookup_fixup, 0,
  82                 REQUEST_ROUTE|FAILURE_ROUTE},
  83         {"alias_db_lookup", (cmd_function)w_alias_db_lookup2, 2, lookup_fixup, 0,
  84                 REQUEST_ROUTE|FAILURE_ROUTE},
  85         {"alias_db_find", (cmd_function)w_alias_db_find3, 3, find_fixup, 0,
  86                 REQUEST_ROUTE|FAILURE_ROUTE|ONREPLY_ROUTE|BRANCH_ROUTE|LOCAL_ROUTE},
  87         {"alias_db_find", (cmd_function)w_alias_db_find4, 4, find_fixup, 0,
  88                 REQUEST_ROUTE|FAILURE_ROUTE|ONREPLY_ROUTE|BRANCH_ROUTE|LOCAL_ROUTE},
  89         {"bind_alias_db",   (cmd_function)bind_alias_db, 1, 0, 0,
  90                 0},
  91         {0, 0, 0, 0, 0, 0}
  92 };
  93
  94
  95 /* Exported parameters */
  96 static param_export_t params[] = {
  97         {"db_url",              PARAM_STR, &db_url        },
  98         {"user_column",         PARAM_STR, &user_column   },
  99         {"domain_column",       PARAM_STR, &domain_column },
 100         {"alias_user_column",   PARAM_STR, &alias_user_column   },
 101         {"alias_domain_column", PARAM_STR, &alias_domain_column },
 102         {"use_domain",          INT_PARAM, &alias_db_use_domain },
 103         {"domain_prefix",       PARAM_STR, &domain_prefix },
 104         {"append_branches",     INT_PARAM, &ald_append_branches   },
 105         {0, 0, 0}
 106 };
 107
 108
 109 /* Module interface */
 110 struct module_exports exports = {
 111         "alias_db",
 112         DEFAULT_DLFLAGS,/* dlopen flags */
 113         cmds,           /* Exported functions */
 114         params,         /* exported params */
 115         0,              /*·exported·RPC·methods·*/
 116         0,              /* exported pseudo-variables */
 117         0,              /* response·function */
 118         mod_init,       /* initialization·module */
 119         child_init,     /* per-child·init·function */
 120         destroy         /* destroy function */
 121 };
 122
 123
 124 static int alias_flags_fixup(void** param)
 125 {
 126         char *c;
 127         unsigned int flags;
 128
 129         c = (char*)*param;
 130         flags = 0;
 131
 132         if(alias_db_use_domain) {
 133                 flags |= ALIAS_DOMAIN_FLAG;
 134         }
 135
 136         while (*c) {
 137                 switch (*c)
 138                 {
 139                         case 'd':
 140                         case 'D':
 141                                 flags &= ~ALIAS_DOMAIN_FLAG;
 142                                 break;
 143                         case 'r':
 144                         case 'R':
 145                                 flags |= ALIAS_REVERSE_FLAG;
 146                                 break;
 147                         case 'u':
 148                         case 'U':
 149                                 flags |= ALIAS_DOMAIN_FLAG;
 150                                 break;
 151                         default:
 152                                 LM_ERR("unsupported flag '%c'\n",*c);
 153                                 return -1;
 154                 }
 155                 c++;
 156         }
 157         pkg_free(*param);
 158         *param = (void*)(unsigned long)flags;
 159         return 0;
 160 }
 161
 162
 163 static int lookup_fixup(void** param, int param_no)
 164 {
 165         if (param_no==1)
 166         {
 167                 /* string or pseudo-var - table name */
 168                 return fixup_spve_null(param, 1);
 169         } else if (param_no==2) {
 170                 /* string - flags ? */
 171                 return alias_flags_fixup(param);
 172         } else {
 173                 LM_CRIT(" invalid number of params %d \n",param_no);
 174                 return -1;
 175         }
 176 }
 177
 178
 179 static int find_fixup(void** param, int param_no)
 180 {
 181         pv_spec_t *sp;
 182
 183         if (param_no==1)
 184         {
 185                 /* string or pseudo-var - table name */
 186                 return fixup_spve_null(param, 1);
 187         } else if(param_no==2) {
 188                 /* pseudo-var - source URI */
 189                 return fixup_pvar_null(param, 1);
 190         } else if(param_no==3) {
 191                 /* pvar (AVP or VAR) - destination URI */
 192                 if (fixup_pvar_null(param, 1))
 193                         return E_CFG;
 194                 sp = (pv_spec_t*)*param;
 195                 if (sp->type!=PVT_AVP && sp->type!=PVT_SCRIPTVAR)
 196                 {
 197                         LM_ERR("PV type %d (param 3) cannot be written\n", sp->type);
 198                         pv_spec_free(sp);
 199                         return E_CFG;
 200                 }
 201                 return 0;
 202         } else if (param_no==4) {
 203                 /* string - flags  ? */
 204                 return alias_flags_fixup(param);
 205         } else {
 206                 LM_CRIT(" invalid number of params %d \n",param_no);
 207                 return -1;
 208         }
 209 }
 210
 211
 212 /**
 213  *
 214  */
 215 static int child_init(int rank)
 216 {
 217         if (rank==PROC_INIT || rank==PROC_MAIN || rank==PROC_TCP_MAIN)
 218                 return 0; /* do nothing for the main process */
 219
 220         db_handle = adbf.init(&db_url);
 221         if (!db_handle)
 222         {
 223                 LM_ERR("unable to connect database\n");
 224                 return -1;
 225         }
 226         return 0;
 227
 228 }
 229
 230
 231 /**
 232  *
 233  */
 234 static int mod_init(void)
 235 {
 236         /* Find a database module */
 237         if (db_bind_mod(&db_url, &adbf))
 238         {
 239                 LM_ERR("unable to bind database module\n");
 240                 return -1;
 241         }
 242         if (!DB_CAPABILITY(adbf, DB_CAP_QUERY))
 243         {
 244                 LM_CRIT("database modules does not "
 245                         "provide all functions needed by alias_db module\n");
 246                 return -1;
 247         }
 248
 249         return 0;
 250 }
 251
 252
 253 /**
 254  *
 255  */
 256 static void destroy(void)
 257 {
 258         if (db_handle) {
 259                 adbf.close(db_handle);
 260                 db_handle = 0;
 261         }
 262 }
 263
 264 static int w_alias_db_lookup1(struct sip_msg* _msg, char* _table, char* p2)
 265 {
 266         str table_s;
 267         unsigned long flags;
 268
 269         flags = 0;
 270         if(alias_db_use_domain) {
 271                 flags |= ALIAS_DOMAIN_FLAG;
 272         }
 273
 274         if(_table==NULL || fixup_get_svalue(_msg, (gparam_p)_table, &table_s)!=0) {
 275                 LM_ERR("invalid table parameter\n");
 276                 return -1;
 277         }
 278
 279         return alias_db_lookup_ex(_msg, table_s, flags);
 280 }
 281
 282 static int w_alias_db_lookup2(struct sip_msg* _msg, char* _table, char* flags)
 283 {
 284         str table_s;
 285
 286         if(_table==NULL || fixup_get_svalue(_msg, (gparam_p)_table, &table_s)!=0) {
 287                 LM_ERR("invalid table parameter\n");
 288         return -1;
 289         }
 290
 291         return alias_db_lookup_ex(_msg, table_s, (unsigned long)flags);
 292 }
 293
 294 static int w_alias_db_find3(struct sip_msg* _msg, char* _table, char* _in,
 295                 char* _out)
 296 {
 297         str table_s;
 298         unsigned long flags;
 299
 300         flags = 0;
 301         if(alias_db_use_domain) {
 302                 flags |= ALIAS_DOMAIN_FLAG;
 303         }
 304
 305         if(_table==NULL || fixup_get_svalue(_msg, (gparam_p)_table, &table_s)!=0) {
 306                 LM_ERR("invalid table parameter\n");
 307                 return -1;
 308         }
 309
 310         return alias_db_find(_msg, table_s, _in, _out, (char*)flags);
 311 }
 312
 313 static int w_alias_db_find4(struct sip_msg* _msg, char* _table, char* _in,
 314                 char* _out, char* flags)
 315 {
 316         str table_s;
 317
 318         if(_table==NULL || fixup_get_svalue(_msg, (gparam_p)_table, &table_s)!=0) {
 319                 LM_ERR("invalid table parameter\n");
 320                 return -1;
 321         }
 322
 323         return alias_db_find(_msg, table_s, _in, _out, flags);
 324 }
 325
 326 int bind_alias_db(struct alias_db_binds *pxb)
 327 {
 328         if (pxb == NULL) {
 329                 LM_WARN("bind_alias_db: Cannot load alias_db API into a NULL pointer\n");
 330                 return -1;
 331         }
 332
 333         pxb->alias_db_lookup = alias_db_lookup;
 334         pxb->alias_db_lookup_ex = alias_db_lookup_ex;
 335         pxb->alias_db_find = alias_db_find;
 336         return 0;
 337 }
 338
 339 /**
 340  *
 341  */
 342 static int ki_alias_db_lookup(sip_msg_t* msg, str* stable)
 343 {
 344         unsigned long flags;
 345
 346         flags = 0;
 347         if(alias_db_use_domain) {
 348                 flags |= ALIAS_DOMAIN_FLAG;
 349         }
 350
 351         return alias_db_lookup_ex(msg, *stable, flags);
 352 }
 353
 354 /**
 355  *
 356  */
 357 static int ki_alias_db_lookup_ex(sip_msg_t* msg, str* stable, str* sflags)
 358 {
 359         unsigned long flags;
 360         int i;
 361
 362         flags = 0;
 363         if(alias_db_use_domain) {
 364                 flags |= ALIAS_DOMAIN_FLAG;
 365         }
 366         for(i=0; i<sflags->len; i++) {
 367                 switch (sflags->s[i])
 368                 {
 369                         case 'd':
 370                         case 'D':
 371                                 flags &= ~ALIAS_DOMAIN_FLAG;
 372                                 break;
 373                         case 'r':
 374                         case 'R':
 375                                 flags |= ALIAS_REVERSE_FLAG;
 376                                 break;
 377                         case 'u':
 378                         case 'U':
 379                                 flags |= ALIAS_DOMAIN_FLAG;
 380                                 break;
 381                         default:
 382                                 LM_ERR("unsupported flag '%c' - ignoring\n", sflags->s[i]);
 383                                 break;
 384                 }
 385         }
 386
 387         return alias_db_lookup_ex(msg, *stable, flags);
 388 }
 389
 390 /**
 391  *
 392  */
 393 /* clang-format off */
 394 static sr_kemi_t sr_kemi_alias_db_exports[] = {
 395         { str_init("alias_db"), str_init("lookup"),
 396                 SR_KEMIP_INT, ki_alias_db_lookup,
 397                 { SR_KEMIP_STR, SR_KEMIP_NONE, SR_KEMIP_NONE,
 398                         SR_KEMIP_NONE, SR_KEMIP_NONE, SR_KEMIP_NONE }
 399         },
 400         { str_init("alias_db"), str_init("lookup_ex"),
 401                 SR_KEMIP_INT, ki_alias_db_lookup_ex,
 402                 { SR_KEMIP_STR, SR_KEMIP_STR, SR_KEMIP_NONE,
 403                         SR_KEMIP_NONE, SR_KEMIP_NONE, SR_KEMIP_NONE }
 404         },
 405
 406         { {0, 0}, {0, 0}, 0, NULL, { 0, 0, 0, 0, 0, 0 } }
 407 };
 408 /* clang-format on */
 409
 410 /**
 411  *
 412  */
 413 int mod_register(char *path, int *dlflags, void *p1, void *p2)
 414 {
 415         sr_kemi_modules_add(sr_kemi_alias_db_exports);
 416         return 0;
 417 }