git.sip-router.org Git - sip-router/blob - src/modules/memcached/mcd_var.c

   1 /*
   2  * Copyright (C) 2009, 2013 Henning Westerholt
   3  * Copyright (C) 2013 Charles Chance, sipcentric.com
   4  *
   5  * This file is part of Kamailio, a free SIP server.
   6  *
   7  * Kamailio is free software; you can redistribute it and/or modify
   8  * it under the terms of the GNU General Public License as published by
   9  * the Free Software Foundation; either version 2 of the License, or
  10  * (at your option) any later version
  11  *
  12  * Kamailio is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  15  * GNU General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU General Public License along
  18  * with this program; if not, see <http://www.gnu.org/licenses/>.
  19  */
  20
  21 /*!
  22  * \file
  23  * \brief memcached module
  24  */
  25
  26 #include "mcd_var.h"
  27
  28 #include "memcached.h"
  29 #include "../../core/ut.h"
  30 #include "../../core/mem/mem.h"
  31 #include "../../core/pvapi.h"
  32 #include "../pv/pv_svar.h"
  33 #include "../../core/md5utils.h"
  34
  35
  36 /*!
  37  * \brief Checks for '=>' delimiter in key name string and if present, extracts expiry value.
  38  * \param data string to parse
  39  * \param key output string name
  40  * \param exp output int expiry (if present)
  41  * \return 0 on success, negative on failure
  42  */
  43 static inline int pv_mcd_key_expiry_split_str(str *data, str *key, unsigned int *exp) {
  44         char *p;
  45         str str_exp;
  46         str_exp.s = NULL;
  47         str_exp.len = 0;
  48
  49         if (data == NULL || data->s == NULL || data->len <= 0) {
  50                 LM_ERR("invalid parameters\n");
  51                 return -1;
  52         }
  53
  54         p = data->s;
  55         key->s = p;
  56         key->len = 0;
  57
  58         while(p < data->s + data->len) {
  59                 if (*p == '=') {
  60                         p++;
  61                         if (*p == '>') {
  62                                 break;
  63                         } else {
  64                                 key->len++;
  65                         }
  66                 } else {
  67                         key->len++;
  68                         p++;
  69                 }
  70         }
  71
  72         if (key->len < data->len) {
  73                 /* delimiter is present, try to extract expiry value */
  74                 p++;
  75                 if (p < data->s + data->len) {
  76                         str_exp.s = p;
  77                         str_exp.len = 0;
  78                         while(p<data->s+data->len) {
  79                                 str_exp.len++;
  80                                 p++;
  81                         }
  82                 }
  83                 if (str_exp.len > 0) {
  84                         /* convert to int */
  85                         *exp = atoi(str_exp.s);
  86                 }
  87                 LM_DBG("key is %.*s expiry is %d\n", key->len, key->s, *exp);
  88         }
  89
  90         return 0;
  91 }
  92
  93 /*!
  94  * \brief Checks if the key is avaiable and not too long, hashing it with MD5 if necessary.
  95  * \param msg SIP message
  96  * \param param pseudo-variable input parameter
  97  * \param key output string name
  98  * \param exp output int expiry (if present)
  99  * \return 0 on success, negative on failure
 100  */
 101 static inline int pv_mcd_key_check(struct sip_msg *msg, pv_param_t *param, str * key, unsigned int * exp ) {
 102
 103         str pvn;
 104         str tmp;
 105
 106         static char hash[32];
 107
 108         if (msg == NULL || param == NULL) {
 109                 LM_ERR("bad parameters\n");
 110                 return -1;
 111         }
 112
 113         if (pv_printf_s(msg, param->pvn.u.dname, &pvn) != 0)
 114         {
 115                 LM_ERR("cannot get pv name\n");
 116                 return -1;
 117         }
 118
 119         if (pv_mcd_key_expiry_split_str(&pvn, &tmp, exp) != 0) {
 120                 return -1;
 121         }
 122
 123         if (tmp.len < 250) {
 124                 key->s = tmp.s;
 125                 key->len = tmp.len;
 126         } else {
 127                 LM_DBG("key too long (%d), hash it\n", tmp.len);
 128                 MD5StringArray (hash, &tmp, 1);
 129                 key->s = hash;
 130                 key->len = 32;
 131         }
 132         return 0;
 133 }
 134
 135 /*!
 136  * \brief Helper to get a cached value from memcached
 137  * \param msg SIP message
 138  * \param key value key
 139  * \param return_value returned value
 140  * \param flags returned flags
 141  * \return null on success, negative on failure
 142  */
 143 static int pv_get_mcd_value_helper(struct sip_msg *msg, str *key,
 144                 char **return_value, uint32_t *flags) {
 145
 146         memcached_return rc;
 147         size_t return_value_length;
 148
 149         *return_value = memcached_get(memcached_h, key->s, key->len, &return_value_length, flags, &rc);
 150
 151         if (*return_value == NULL) {
 152                 if (rc == MEMCACHED_NOTFOUND) {
 153                         LM_DBG("key %.*s not found\n", key->len, key->s);
 154                 } else {
 155                         LM_ERR("could not get result for key %.*s - error was '%s'\n", key->len, key->s, memcached_strerror(memcached_h, rc));
 156                 }
 157                 return -1;
 158         }
 159
 160         LM_DBG("result: %s for key %.*s with flag %d\n", *return_value, key->len, key->s, *flags);
 161
 162         return 0;
 163 }
 164
 165 static void pv_free_mcd_value(char** buf) {
 166         if (*buf!=NULL) {
 167                 if (mcd_memory) {
 168                         pkg_free(*buf);
 169                 } else {
 170                         free(*buf);
 171                 }
 172         }
 173 }
 174
 175 /*!
 176  * \brief Get a cached value from memcached
 177  * \param msg SIP message
 178  * \param param parameter
 179  * \param res result
 180  * \return null on success, negative on failure
 181  */
 182 int pv_get_mcd_value(struct sip_msg *msg, pv_param_t *param, pv_value_t *res) {
 183
 184         unsigned int res_int = 0;
 185         str key, res_str;
 186         unsigned int expiry = mcd_expire;
 187
 188         char *return_value;
 189         uint32_t return_flags;
 190
 191         if (pv_mcd_key_check(msg, param, &key, &expiry) < 0) {
 192                 return pv_get_null(msg, param, res);
 193         }
 194
 195         if (res==NULL)
 196                 return pv_get_null(msg, param, res);
 197
 198         if (pv_get_mcd_value_helper(msg, &key, &return_value, &return_flags) < 0) {
 199                 goto errout;
 200         }
 201
 202
 203         res_str.len = strlen(return_value);
 204         res_str.s = return_value;
 205
 206
 207         /* apparently memcached adds whitespaces to the beginning of the value after atomic operations */
 208
 209         trim_len(res_str.len, res_str.s, res_str);
 210
 211         if(return_flags&VAR_VAL_STR || mcd_stringify) {
 212                 res->rs.s = pv_get_buffer();
 213                 res->rs.len = pv_get_buffer_size();
 214                 if(res_str.len>=res->rs.len) {
 215                         LM_ERR("value is too big (%d) - increase pv buffer size\n", res_str.len);
 216                         goto errout;
 217                 }
 218                 memcpy(res->rs.s, res_str.s, res_str.len);
 219                 res->rs.len = res_str.len;
 220                 res->rs.s[res->rs.len] = '\0';
 221                 res->flags = PV_VAL_STR;
 222         } else {
 223                 if (str2int(&res_str, &res_int) < 0) {
 224                         LM_ERR("could not convert string %.*s to integer value\n", res_str.len, res_str.s);
 225                         goto errout;
 226                 }
 227                 res->rs = res_str;
 228                 res->ri = res_int;
 229                 res->flags = PV_VAL_STR|PV_VAL_INT|PV_TYPE_INT;
 230         }
 231
 232         pv_free_mcd_value(&return_value);
 233         return 0;
 234
 235 errout:
 236         pv_free_mcd_value(&return_value);
 237         return pv_get_null(msg, param, res);
 238 }
 239
 240
 241
 242 /*!
 243  * \brief Set a value in the cache of memcached
 244  * \todo Replacement of already existing values is not done atomically at the moment.
 245  * Here the provided replace function should be used.
 246  * \param msg SIP message
 247  * \param param parameter
 248  * \param op not used
 249  * \param val value
 250  * \return 0 on success, -1 on failure
 251  */
 252  int pv_set_mcd_value(struct sip_msg* msg, pv_param_t *param, int op, pv_value_t *val) {
 253
 254         unsigned int val_flag = 0;
 255         str val_str, key;
 256         unsigned int expiry = mcd_expire;
 257
 258         if (pv_mcd_key_check(msg, param, &key, &expiry) < 0)
 259                 return -1;
 260
 261         if (val == NULL || val->flags&PV_VAL_NULL) {
 262                 if (memcached_delete(memcached_h, key.s, key.len, 0) != MEMCACHED_SUCCESS) {
 263                         LM_ERR("could not delete key %.*s\n", param->pvn.u.isname.name.s.len,
 264                                 param->pvn.u.isname.name.s.s);
 265                         return -1;
 266                 }
 267                 LM_DBG("delete key %.*s\n", key.len, key.s);
 268                 return 0;
 269         }
 270
 271         if (val->flags&PV_VAL_INT) {
 272                 val_str.s = int2str(val->ri, &val_str.len);
 273         } else {
 274                 val_str = val->rs;
 275                 val_flag = VAR_VAL_STR;
 276         }
 277
 278         if (mcd_mode == 0) {
 279                 if (memcached_set(memcached_h, key.s, key.len, val_str.s, val_str.len, expiry, val_flag) != MEMCACHED_SUCCESS) {
 280                         LM_ERR("could not set value for key %.*s\n", key.len, key.s);
 281                         return -1;
 282                 }
 283         } else {
 284                 if (memcached_add(memcached_h, key.s, key.len, val_str.s, val_str.len, expiry, val_flag) != MEMCACHED_SUCCESS) {
 285                         LM_ERR("could not add value for key %.*s\n", key.len, key.s);
 286                         return -1;
 287                 }
 288         }
 289         LM_DBG("set value %.*s for key %.*s with flag %d\n", val_str.len, val_str.s, key.len, key.s, val_flag);
 290
 291         return 0;
 292 }
 293
 294
 295 /*!
 296  * \brief Helper function for the memcached atomic operations
 297  * \note The checks on value existence and type are not done atomically, so there is a small
 298  * chance that the later atomic operation fails. This is hard to detect because this function
 299  * don't return a proper result code. Checking for the incremented value is also not possible,
 300  * because in the mean time the value could be incremented from some other client.
 301  * \param msg SIP message
 302  * \param param parameter
 303  * \param op not used
 304  * \param val value
 305  * \param atomic_ops function pointer to the atomic operation from the memcached library
 306  * \return 0 on success, -1 on failure
 307  */
 308 static int pv_mcd_atomic_helper(struct sip_msg* msg, pv_param_t *param, int op, pv_value_t *val,
 309                 memcached_return (* atomic_ops) (memcached_st *mc, const char *key, size_t key_length, uint32_t offset, uint64_t *value)) {
 310
 311         uint64_t value = 0;
 312         str key;
 313         unsigned int expiry = mcd_expire;
 314         char *return_value;
 315         uint32_t return_flags;
 316         memcached_return rc;
 317
 318         if (!(val->flags&PV_VAL_INT)) {
 319                 LM_ERR("invalid value %.*s for atomic operation, strings not allowed\n",
 320                         val->rs.len, val->rs.s);
 321                 return -1;
 322         }
 323
 324         if (pv_mcd_key_check(msg, param, &key, &expiry) < 0)
 325                 return -1;
 326
 327         if (pv_get_mcd_value_helper(msg, &key, &return_value, &return_flags) < 0) {
 328                 pv_free_mcd_value(&return_value);
 329                 return -1;
 330         }
 331
 332         pv_free_mcd_value(&return_value);
 333
 334         if(return_flags&VAR_VAL_STR) {
 335                 LM_ERR("could not do atomic operations on string for key %.*s\n", key.len, key.s);
 336                 return -1;
 337         }
 338
 339         if ((rc = atomic_ops(memcached_h, key.s, key.len, val->ri, &value)) != MEMCACHED_SUCCESS) {
 340                 LM_ERR("error performing atomic operation on key %.*s - %s\n", key.len, key.s, memcached_strerror(memcached_h, rc));
 341                 return -1;
 342         }
 343
 344         return 0;
 345
 346 }
 347
 348
 349 /*!
 350  * \brief Increment a key atomically in the cache
 351  * \param msg SIP message
 352  * \param param parameter
 353  * \param op not used
 354  * \param val value
 355  * \return 0 on success, -1 on failure
 356  */
 357 int inline pv_inc_mcd_value(struct sip_msg* msg, pv_param_t *param, int op, pv_value_t *val) {
 358         return pv_mcd_atomic_helper(msg, param, op, val, memcached_increment);
 359 }
 360
 361
 362 /*!
 363  * \brief Decrement a key atomically in the cache
 364  * \param msg SIP message
 365  * \param param parameter
 366  * \param op not used
 367  * \param val value
 368  * \return 0 on success, -1 on failure
 369  */
 370 int inline pv_dec_mcd_value(struct sip_msg* msg, pv_param_t *param, int op, pv_value_t *val) {
 371         return pv_mcd_atomic_helper(msg, param, op, val, memcached_decrement);
 372 }
 373
 374
 375 /*!
 376  * \brief Set the expire value in the cache of memcached
 377  * \note The memcache library don't provide functions to change the expiration
 378  * time for a certain key after creation, so we need to do a get and set here.
 379  * \param msg SIP message
 380  * \param param parameter
 381  * \param op not used
 382  * \param val value
 383  * \return 0 on success, -1 on failure
 384  */
 385 int pv_set_mcd_expire(struct sip_msg* msg, pv_param_t *param, int op, pv_value_t *val)
 386 {
 387         str key;
 388         unsigned int expiry = mcd_expire;
 389         char *return_value;
 390         uint32_t return_flags;
 391         memcached_return rc;
 392
 393         if (!(val->flags&PV_VAL_INT)) {
 394                 LM_ERR("invalid value %.*s for expire time, strings not allowed\n",
 395                         val->rs.len, val->rs.s);
 396                 return -1;
 397         }
 398
 399         if (pv_mcd_key_check(msg, param, &key, &expiry) < 0)
 400                 return -1;
 401
 402         if (pv_get_mcd_value_helper(msg, &key, &return_value, &return_flags) < 0) {
 403                 goto errout;
 404         }
 405
 406         LM_DBG("set expire time %d for key %.*s with flag %d\n", val->ri, key.len, key.s, return_flags);
 407
 408         if ((rc= memcached_set(memcached_h, key.s, key.len, return_value, strlen(return_value), val->ri, return_flags)) != MEMCACHED_SUCCESS) {
 409                 LM_ERR("could not set expire time %d for key %.*s - error was %s\n", val->ri, key.len, key.s, memcached_strerror(memcached_h, rc));
 410                 goto errout;
 411         }
 412
 413         pv_free_mcd_value(&return_value);
 414         return 0;
 415
 416 errout:
 417         pv_free_mcd_value(&return_value);
 418         return -1;
 419 }
 420
 421
 422 /*!
 423  * \brief Parse the pseudo-variable specification parameter
 424  * \param sp pseudo-variable specification
 425  * \param in parameter string
 426  * \return 0 on success, -1 on failure
 427  */
 428 int pv_parse_mcd_name(pv_spec_p sp, str *in) {
 429
 430         pv_elem_t * tmp = NULL;
 431
 432         if(sp==NULL || in==NULL || in->len<=0)
 433                 return -1;
 434
 435
 436         tmp = pkg_malloc(sizeof(pv_elem_t));
 437         if (tmp == NULL) {
 438                 PKG_MEM_ERROR;
 439                 return -1;
 440         }
 441         memset(tmp, 0, sizeof(pv_elem_t));
 442
 443         if(pv_parse_format(in, &tmp) || tmp==NULL) {
 444                 LM_ERR("wrong format [%.*s]\n", in->len, in->s);
 445                 if(tmp) pkg_free(tmp);
 446                 return -1;
 447         }
 448
 449         sp->pvp.pvn.u.dname = tmp;
 450         sp->pvp.pvn.type = PV_NAME_PVAR;
 451
 452         return 0;
 453 }