memcached: handle error cases and alloc enough for null termination
[sip-router] / 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 }