From da7d1962c7f05cdaebd4f57f818abda95dba1e82 Mon Sep 17 00:00:00 2001 From: Victor Seva Date: Wed, 17 May 2023 16:36:56 +0200 Subject: [PATCH] memcached: clang-format for coherent indentation and coding style --- src/modules/memcached/mcd_var.c | 187 ++++++++++++++++++------------ src/modules/memcached/mcd_var.h | 12 +- src/modules/memcached/memcached.c | 166 +++++++++++++------------- src/modules/memcached/memcached.h | 4 +- 4 files changed, 208 insertions(+), 161 deletions(-) diff --git a/src/modules/memcached/mcd_var.c b/src/modules/memcached/mcd_var.c index 3c12e9c44fd..04b2f9261aa 100644 --- a/src/modules/memcached/mcd_var.c +++ b/src/modules/memcached/mcd_var.c @@ -40,13 +40,15 @@ * \param exp output int expiry (if present) * \return 0 on success, negative on failure */ -static inline int pv_mcd_key_expiry_split_str(str *data, str *key, unsigned int *exp) { +static inline int pv_mcd_key_expiry_split_str( + str *data, str *key, unsigned int *exp) +{ char *p; str str_exp; str_exp.s = NULL; str_exp.len = 0; - if (data == NULL || data->s == NULL || data->len <= 0) { + if(data == NULL || data->s == NULL || data->len <= 0) { LM_ERR("invalid parameters\n"); return -1; } @@ -56,31 +58,31 @@ static inline int pv_mcd_key_expiry_split_str(str *data, str *key, unsigned int key->len = 0; while(p < data->s + data->len) { - if (*p == '=') { + if(*p == '=') { p++; - if (*p == '>') { + if(*p == '>') { break; } else { key->len++; } } else { - key->len++; + key->len++; p++; } } - if (key->len < data->len) { + if(key->len < data->len) { /* delimiter is present, try to extract expiry value */ p++; - if (p < data->s + data->len) { + if(p < data->s + data->len) { str_exp.s = p; str_exp.len = 0; - while(ps+data->len) { + while(p < data->s + data->len) { str_exp.len++; p++; } } - if (str_exp.len > 0) { + if(str_exp.len > 0) { /* convert to int */ *exp = atoi(str_exp.s); } @@ -98,34 +100,35 @@ static inline int pv_mcd_key_expiry_split_str(str *data, str *key, unsigned int * \param exp output int expiry (if present) * \return 0 on success, negative on failure */ -static inline int pv_mcd_key_check(struct sip_msg *msg, pv_param_t *param, str * key, unsigned int * exp ) { +static inline int pv_mcd_key_check( + struct sip_msg *msg, pv_param_t *param, str *key, unsigned int *exp) +{ str pvn; str tmp; static char hash[32]; - if (msg == NULL || param == NULL) { + if(msg == NULL || param == NULL) { LM_ERR("bad parameters\n"); return -1; } - if (pv_printf_s(msg, param->pvn.u.dname, &pvn) != 0) - { + if(pv_printf_s(msg, param->pvn.u.dname, &pvn) != 0) { LM_ERR("cannot get pv name\n"); return -1; } - if (pv_mcd_key_expiry_split_str(&pvn, &tmp, exp) != 0) { + if(pv_mcd_key_expiry_split_str(&pvn, &tmp, exp) != 0) { return -1; } - if (tmp.len < 250) { + if(tmp.len < 250) { key->s = tmp.s; key->len = tmp.len; } else { LM_DBG("key too long (%d), hash it\n", tmp.len); - MD5StringArray (hash, &tmp, 1); + MD5StringArray(hash, &tmp, 1); key->s = hash; key->len = 32; } @@ -140,31 +143,36 @@ static inline int pv_mcd_key_check(struct sip_msg *msg, pv_param_t *param, str * * \param flags returned flags * \return null on success, negative on failure */ -static int pv_get_mcd_value_helper(struct sip_msg *msg, str *key, - char **return_value, uint32_t *flags) { +static int pv_get_mcd_value_helper( + struct sip_msg *msg, str *key, char **return_value, uint32_t *flags) +{ memcached_return rc; size_t return_value_length; - *return_value = memcached_get(memcached_h, key->s, key->len, &return_value_length, flags, &rc); + *return_value = memcached_get( + memcached_h, key->s, key->len, &return_value_length, flags, &rc); - if (*return_value == NULL) { - if (rc == MEMCACHED_NOTFOUND) { + if(*return_value == NULL) { + if(rc == MEMCACHED_NOTFOUND) { LM_DBG("key %.*s not found\n", key->len, key->s); } else { - LM_ERR("could not get result for key %.*s - error was '%s'\n", key->len, key->s, memcached_strerror(memcached_h, rc)); + LM_ERR("could not get result for key %.*s - error was '%s'\n", + key->len, key->s, memcached_strerror(memcached_h, rc)); } return -1; } - LM_DBG("result: %s for key %.*s with flag %d\n", *return_value, key->len, key->s, *flags); + LM_DBG("result: %s for key %.*s with flag %d\n", *return_value, key->len, + key->s, *flags); return 0; } -static void pv_free_mcd_value(char** buf) { - if (*buf!=NULL) { - if (mcd_memory) { +static void pv_free_mcd_value(char **buf) +{ + if(*buf != NULL) { + if(mcd_memory) { pkg_free(*buf); } else { free(*buf); @@ -179,23 +187,24 @@ static void pv_free_mcd_value(char** buf) { * \param res result * \return null on success, negative on failure */ -int pv_get_mcd_value(struct sip_msg *msg, pv_param_t *param, pv_value_t *res) { +int pv_get_mcd_value(struct sip_msg *msg, pv_param_t *param, pv_value_t *res) +{ unsigned int res_int = 0; str key, res_str; unsigned int expiry = mcd_expire; - char *return_value; + char *return_value; uint32_t return_flags; - if (pv_mcd_key_check(msg, param, &key, &expiry) < 0) { + if(pv_mcd_key_check(msg, param, &key, &expiry) < 0) { return pv_get_null(msg, param, res); } - if (res==NULL) + if(res == NULL) return pv_get_null(msg, param, res); - if (pv_get_mcd_value_helper(msg, &key, &return_value, &return_flags) < 0) { + if(pv_get_mcd_value_helper(msg, &key, &return_value, &return_flags) < 0) { goto errout; } @@ -208,11 +217,12 @@ int pv_get_mcd_value(struct sip_msg *msg, pv_param_t *param, pv_value_t *res) { trim_len(res_str.len, res_str.s, res_str); - if(return_flags&VAR_VAL_STR || mcd_stringify) { + if(return_flags & VAR_VAL_STR || mcd_stringify) { res->rs.s = pv_get_buffer(); res->rs.len = pv_get_buffer_size(); - if(res_str.len>=res->rs.len) { - LM_ERR("value is too big (%d) - increase pv buffer size\n", res_str.len); + if(res_str.len >= res->rs.len) { + LM_ERR("value is too big (%d) - increase pv buffer size\n", + res_str.len); goto errout; } memcpy(res->rs.s, res_str.s, res_str.len); @@ -220,13 +230,14 @@ int pv_get_mcd_value(struct sip_msg *msg, pv_param_t *param, pv_value_t *res) { res->rs.s[res->rs.len] = '\0'; res->flags = PV_VAL_STR; } else { - if (str2int(&res_str, &res_int) < 0) { - LM_ERR("could not convert string %.*s to integer value\n", res_str.len, res_str.s); + if(str2int(&res_str, &res_int) < 0) { + LM_ERR("could not convert string %.*s to integer value\n", + res_str.len, res_str.s); goto errout; } res->rs = res_str; res->ri = res_int; - res->flags = PV_VAL_STR|PV_VAL_INT|PV_TYPE_INT; + res->flags = PV_VAL_STR | PV_VAL_INT | PV_TYPE_INT; } pv_free_mcd_value(&return_value); @@ -238,7 +249,6 @@ int pv_get_mcd_value(struct sip_msg *msg, pv_param_t *param, pv_value_t *res) { } - /*! * \brief Set a value in the cache of memcached * \todo Replacement of already existing values is not done atomically at the moment. @@ -249,44 +259,53 @@ int pv_get_mcd_value(struct sip_msg *msg, pv_param_t *param, pv_value_t *res) { * \param val value * \return 0 on success, -1 on failure */ - int pv_set_mcd_value(struct sip_msg* msg, pv_param_t *param, int op, pv_value_t *val) { +int pv_set_mcd_value( + struct sip_msg *msg, pv_param_t *param, int op, pv_value_t *val) +{ unsigned int val_flag = 0; str val_str, key; unsigned int expiry = mcd_expire; - if (pv_mcd_key_check(msg, param, &key, &expiry) < 0) + if(pv_mcd_key_check(msg, param, &key, &expiry) < 0) return -1; - if (val == NULL || val->flags&PV_VAL_NULL) { - if (memcached_delete(memcached_h, key.s, key.len, 0) != MEMCACHED_SUCCESS) { - LM_ERR("could not delete key %.*s\n", param->pvn.u.isname.name.s.len, - param->pvn.u.isname.name.s.s); + if(val == NULL || val->flags & PV_VAL_NULL) { + if(memcached_delete(memcached_h, key.s, key.len, 0) + != MEMCACHED_SUCCESS) { + LM_ERR("could not delete key %.*s\n", + param->pvn.u.isname.name.s.len, + param->pvn.u.isname.name.s.s); return -1; } LM_DBG("delete key %.*s\n", key.len, key.s); return 0; } - if (val->flags&PV_VAL_INT) { + if(val->flags & PV_VAL_INT) { val_str.s = int2str(val->ri, &val_str.len); } else { val_str = val->rs; val_flag = VAR_VAL_STR; } - if (mcd_mode == 0) { - if (memcached_set(memcached_h, key.s, key.len, val_str.s, val_str.len, expiry, val_flag) != MEMCACHED_SUCCESS) { + if(mcd_mode == 0) { + if(memcached_set(memcached_h, key.s, key.len, val_str.s, val_str.len, + expiry, val_flag) + != MEMCACHED_SUCCESS) { LM_ERR("could not set value for key %.*s\n", key.len, key.s); return -1; } } else { - if (memcached_add(memcached_h, key.s, key.len, val_str.s, val_str.len, expiry, val_flag) != MEMCACHED_SUCCESS) { + if(memcached_add(memcached_h, key.s, key.len, val_str.s, val_str.len, + expiry, val_flag) + != MEMCACHED_SUCCESS) { LM_ERR("could not add value for key %.*s\n", key.len, key.s); return -1; } } - LM_DBG("set value %.*s for key %.*s with flag %d\n", val_str.len, val_str.s, key.len, key.s, val_flag); + LM_DBG("set value %.*s for key %.*s with flag %d\n", val_str.len, val_str.s, + key.len, key.s, val_flag); return 0; } @@ -305,8 +324,11 @@ int pv_get_mcd_value(struct sip_msg *msg, pv_param_t *param, pv_value_t *res) { * \param atomic_ops function pointer to the atomic operation from the memcached library * \return 0 on success, -1 on failure */ -static int pv_mcd_atomic_helper(struct sip_msg* msg, pv_param_t *param, int op, pv_value_t *val, - memcached_return (* atomic_ops) (memcached_st *mc, const char *key, size_t key_length, uint32_t offset, uint64_t *value)) { +static int pv_mcd_atomic_helper(struct sip_msg *msg, pv_param_t *param, int op, + pv_value_t *val, + memcached_return (*atomic_ops)(memcached_st *mc, const char *key, + size_t key_length, uint32_t offset, uint64_t *value)) +{ uint64_t value = 0; str key; @@ -315,34 +337,36 @@ static int pv_mcd_atomic_helper(struct sip_msg* msg, pv_param_t *param, int op, uint32_t return_flags; memcached_return rc; - if (!(val->flags&PV_VAL_INT)) { + if(!(val->flags & PV_VAL_INT)) { LM_ERR("invalid value %.*s for atomic operation, strings not allowed\n", - val->rs.len, val->rs.s); + val->rs.len, val->rs.s); return -1; } - if (pv_mcd_key_check(msg, param, &key, &expiry) < 0) + if(pv_mcd_key_check(msg, param, &key, &expiry) < 0) return -1; - if (pv_get_mcd_value_helper(msg, &key, &return_value, &return_flags) < 0) { + if(pv_get_mcd_value_helper(msg, &key, &return_value, &return_flags) < 0) { pv_free_mcd_value(&return_value); return -1; } pv_free_mcd_value(&return_value); - if(return_flags&VAR_VAL_STR) { - LM_ERR("could not do atomic operations on string for key %.*s\n", key.len, key.s); + if(return_flags & VAR_VAL_STR) { + LM_ERR("could not do atomic operations on string for key %.*s\n", + key.len, key.s); return -1; } - if ((rc = atomic_ops(memcached_h, key.s, key.len, val->ri, &value)) != MEMCACHED_SUCCESS) { - LM_ERR("error performing atomic operation on key %.*s - %s\n", key.len, key.s, memcached_strerror(memcached_h, rc)); + if((rc = atomic_ops(memcached_h, key.s, key.len, val->ri, &value)) + != MEMCACHED_SUCCESS) { + LM_ERR("error performing atomic operation on key %.*s - %s\n", key.len, + key.s, memcached_strerror(memcached_h, rc)); return -1; } return 0; - } @@ -354,7 +378,9 @@ static int pv_mcd_atomic_helper(struct sip_msg* msg, pv_param_t *param, int op, * \param val value * \return 0 on success, -1 on failure */ -int inline pv_inc_mcd_value(struct sip_msg* msg, pv_param_t *param, int op, pv_value_t *val) { +int inline pv_inc_mcd_value( + struct sip_msg *msg, pv_param_t *param, int op, pv_value_t *val) +{ return pv_mcd_atomic_helper(msg, param, op, val, memcached_increment); } @@ -367,7 +393,9 @@ int inline pv_inc_mcd_value(struct sip_msg* msg, pv_param_t *param, int op, pv_v * \param val value * \return 0 on success, -1 on failure */ -int inline pv_dec_mcd_value(struct sip_msg* msg, pv_param_t *param, int op, pv_value_t *val) { +int inline pv_dec_mcd_value( + struct sip_msg *msg, pv_param_t *param, int op, pv_value_t *val) +{ return pv_mcd_atomic_helper(msg, param, op, val, memcached_decrement); } @@ -382,7 +410,8 @@ int inline pv_dec_mcd_value(struct sip_msg* msg, pv_param_t *param, int op, pv_v * \param val value * \return 0 on success, -1 on failure */ -int pv_set_mcd_expire(struct sip_msg* msg, pv_param_t *param, int op, pv_value_t *val) +int pv_set_mcd_expire( + struct sip_msg *msg, pv_param_t *param, int op, pv_value_t *val) { str key; unsigned int expiry = mcd_expire; @@ -390,23 +419,27 @@ int pv_set_mcd_expire(struct sip_msg* msg, pv_param_t *param, int op, pv_value_t uint32_t return_flags; memcached_return rc; - if (!(val->flags&PV_VAL_INT)) { + if(!(val->flags & PV_VAL_INT)) { LM_ERR("invalid value %.*s for expire time, strings not allowed\n", - val->rs.len, val->rs.s); + val->rs.len, val->rs.s); return -1; } - if (pv_mcd_key_check(msg, param, &key, &expiry) < 0) + if(pv_mcd_key_check(msg, param, &key, &expiry) < 0) return -1; - if (pv_get_mcd_value_helper(msg, &key, &return_value, &return_flags) < 0) { + if(pv_get_mcd_value_helper(msg, &key, &return_value, &return_flags) < 0) { goto errout; } - LM_DBG("set expire time %ld for key %.*s with flag %d\n", val->ri, key.len, key.s, return_flags); + LM_DBG("set expire time %ld for key %.*s with flag %d\n", val->ri, key.len, + key.s, return_flags); - if ((rc= memcached_set(memcached_h, key.s, key.len, return_value, strlen(return_value), val->ri, return_flags)) != MEMCACHED_SUCCESS) { - LM_ERR("could not set expire time %ld for key %.*s - error was %s\n", val->ri, key.len, key.s, memcached_strerror(memcached_h, rc)); + if((rc = memcached_set(memcached_h, key.s, key.len, return_value, + strlen(return_value), val->ri, return_flags)) + != MEMCACHED_SUCCESS) { + LM_ERR("could not set expire time %ld for key %.*s - error was %s\n", + val->ri, key.len, key.s, memcached_strerror(memcached_h, rc)); goto errout; } @@ -425,24 +458,26 @@ int pv_set_mcd_expire(struct sip_msg* msg, pv_param_t *param, int op, pv_value_t * \param in parameter string * \return 0 on success, -1 on failure */ -int pv_parse_mcd_name(pv_spec_p sp, str *in) { +int pv_parse_mcd_name(pv_spec_p sp, str *in) +{ - pv_elem_t * tmp = NULL; + pv_elem_t *tmp = NULL; - if(sp==NULL || in==NULL || in->len<=0) + if(sp == NULL || in == NULL || in->len <= 0) return -1; tmp = pkg_malloc(sizeof(pv_elem_t)); - if (tmp == NULL) { + if(tmp == NULL) { PKG_MEM_ERROR; return -1; } memset(tmp, 0, sizeof(pv_elem_t)); - if(pv_parse_format(in, &tmp) || tmp==NULL) { + if(pv_parse_format(in, &tmp) || tmp == NULL) { LM_ERR("wrong format [%.*s]\n", in->len, in->s); - if(tmp) pkg_free(tmp); + if(tmp) + pkg_free(tmp); return -1; } diff --git a/src/modules/memcached/mcd_var.h b/src/modules/memcached/mcd_var.h index 22e55632d7c..7b988d75fd8 100644 --- a/src/modules/memcached/mcd_var.h +++ b/src/modules/memcached/mcd_var.h @@ -47,7 +47,8 @@ int pv_get_mcd_value(struct sip_msg *msg, pv_param_t *param, pv_value_t *res); * \param val value * \return 0 on success, -1 on failure */ -int pv_set_mcd_value(struct sip_msg* msg, pv_param_t *param, int op, pv_value_t *val); +int pv_set_mcd_value( + struct sip_msg *msg, pv_param_t *param, int op, pv_value_t *val); /*! @@ -58,7 +59,8 @@ int pv_set_mcd_value(struct sip_msg* msg, pv_param_t *param, int op, pv_value_t * \param val value * \return 0 on success, -1 on failure */ -int pv_inc_mcd_value(struct sip_msg* msg, pv_param_t *param, int op, pv_value_t *val); +int pv_inc_mcd_value( + struct sip_msg *msg, pv_param_t *param, int op, pv_value_t *val); /*! @@ -69,7 +71,8 @@ int pv_inc_mcd_value(struct sip_msg* msg, pv_param_t *param, int op, pv_value_t * \param val value * \return 0 on success, -1 on failure */ -int pv_dec_mcd_value(struct sip_msg* msg, pv_param_t *param, int op, pv_value_t *val); +int pv_dec_mcd_value( + struct sip_msg *msg, pv_param_t *param, int op, pv_value_t *val); /*! @@ -82,7 +85,8 @@ int pv_dec_mcd_value(struct sip_msg* msg, pv_param_t *param, int op, pv_value_t * \param val value * \return 0 on success, -1 on failure */ -int pv_set_mcd_expire(struct sip_msg* msg, pv_param_t *param, int op, pv_value_t *val); +int pv_set_mcd_expire( + struct sip_msg *msg, pv_param_t *param, int op, pv_value_t *val); /*! diff --git a/src/modules/memcached/memcached.c b/src/modules/memcached/memcached.c index f1a2b2d86ae..6bb6d5b305d 100644 --- a/src/modules/memcached/memcached.c +++ b/src/modules/memcached/memcached.c @@ -37,7 +37,7 @@ MODULE_VERSION /*! server string */ -char* mcd_srv_str = "localhost:11211"; +char *mcd_srv_str = "localhost:11211"; /*! cache (default) expire time in seconds */ unsigned int mcd_expire = 0; /*! cache storage mode, set or add */ @@ -63,47 +63,32 @@ static void mod_destroy(void); * Exported pseudo-variables */ static pv_export_t mod_pvs[] = { - { {"mct", sizeof("mct")-1}, PVT_OTHER, pv_get_mcd_value, pv_set_mcd_value, - pv_parse_mcd_name, 0, 0, 0 }, - { {"mcinc", sizeof("mcinc")-1}, PVT_OTHER, pv_get_mcd_value, pv_inc_mcd_value, - pv_parse_mcd_name, 0, 0, 0 }, - { {"mcdec", sizeof("mcdec")-1}, PVT_OTHER, pv_get_mcd_value, pv_dec_mcd_value, - pv_parse_mcd_name, 0, 0, 0 }, - { {"mctex", sizeof("mctex")-1}, PVT_OTHER, pv_get_null, pv_set_mcd_expire, - pv_parse_mcd_name, 0, 0, 0 }, - { {0, 0}, 0, 0, 0, 0, 0, 0, 0 } -}; + {{"mct", sizeof("mct") - 1}, PVT_OTHER, pv_get_mcd_value, + pv_set_mcd_value, pv_parse_mcd_name, 0, 0, 0}, + {{"mcinc", sizeof("mcinc") - 1}, PVT_OTHER, pv_get_mcd_value, + pv_inc_mcd_value, pv_parse_mcd_name, 0, 0, 0}, + {{"mcdec", sizeof("mcdec") - 1}, PVT_OTHER, pv_get_mcd_value, + pv_dec_mcd_value, pv_parse_mcd_name, 0, 0, 0}, + {{"mctex", sizeof("mctex") - 1}, PVT_OTHER, pv_get_null, + pv_set_mcd_expire, pv_parse_mcd_name, 0, 0, 0}, + {{0, 0}, 0, 0, 0, 0, 0, 0, 0}}; /*! * Exported parameters */ -static param_export_t params[] = { - {"servers", PARAM_STRING, &mcd_srv_str }, - {"expire", INT_PARAM, &mcd_expire }, - {"timeout", INT_PARAM, &mcd_timeout }, - {"mode", INT_PARAM, &mcd_mode }, - {"memory", INT_PARAM, &mcd_memory }, - {"stringify", INT_PARAM, &mcd_stringify }, - {0, 0, 0} -}; +static param_export_t params[] = {{"servers", PARAM_STRING, &mcd_srv_str}, + {"expire", INT_PARAM, &mcd_expire}, + {"timeout", INT_PARAM, &mcd_timeout}, {"mode", INT_PARAM, &mcd_mode}, + {"memory", INT_PARAM, &mcd_memory}, + {"stringify", INT_PARAM, &mcd_stringify}, {0, 0, 0}}; /*! * Module interface */ -struct module_exports exports = { - "memcached", - DEFAULT_DLFLAGS, - 0, - params, - 0, - mod_pvs, - 0, - mod_init, - 0, - mod_destroy -}; +struct module_exports exports = {"memcached", DEFAULT_DLFLAGS, 0, params, 0, + mod_pvs, 0, mod_init, 0, mod_destroy}; /*! @@ -114,9 +99,10 @@ struct module_exports exports = { * \note pkg_free does not allow NULL pointer as standard free, therefore we check it here * \see pkg_free */ -static inline void mcd_free(memcached_st *ptr, void *mem, void *context) { - if (mem) - pkg_free(mem); +static inline void mcd_free(memcached_st *ptr, void *mem, void *context) +{ + if(mem) + pkg_free(mem); } /*! @@ -126,9 +112,10 @@ static inline void mcd_free(memcached_st *ptr, void *mem, void *context) { * \note pkg_free does not allow NULL pointer as standard free, therefore we check it here * \see pkg_free */ - static inline void mcd_free_compat(memcached_st *ptr, void *mem) { - if (mem) - pkg_free(mem); +static inline void mcd_free_compat(memcached_st *ptr, void *mem) +{ + if(mem) + pkg_free(mem); } @@ -140,7 +127,9 @@ static inline void mcd_free(memcached_st *ptr, void *mem, void *context) { * \return allocated memory, or NULL on failure * \see pkg_malloc */ -static inline void* mcd_malloc(memcached_st *ptr, const size_t size, void *context) { +static inline void *mcd_malloc( + memcached_st *ptr, const size_t size, void *context) +{ return pkg_malloc(size); } @@ -151,8 +140,9 @@ static inline void* mcd_malloc(memcached_st *ptr, const size_t size, void *conte * \return allocated memory, or NULL on failure * \see pkg_malloc */ - static inline void* mcd_malloc_compat(memcached_st *ptr, const size_t size) { - return pkg_malloc(size); +static inline void *mcd_malloc_compat(memcached_st *ptr, const size_t size) +{ + return pkg_malloc(size); } @@ -165,8 +155,10 @@ static inline void* mcd_malloc(memcached_st *ptr, const size_t size, void *conte * \return allocated memory, or NULL on failure * \see pkg_realloc */ -static inline void* mcd_realloc(memcached_st *ptr, void *mem, const size_t size, void *context) { - return pkg_realloc(mem, size); +static inline void *mcd_realloc( + memcached_st *ptr, void *mem, const size_t size, void *context) +{ + return pkg_realloc(mem, size); } /*! @@ -177,8 +169,10 @@ static inline void* mcd_realloc(memcached_st *ptr, void *mem, const size_t size, * \return allocated memory, or NULL on failure * \see pkg_realloc */ -static inline void* mcd_realloc_compat(memcached_st *ptr, void *mem, const size_t size) { - return pkg_realloc(mem, size); +static inline void *mcd_realloc_compat( + memcached_st *ptr, void *mem, const size_t size) +{ + return pkg_realloc(mem, size); } @@ -192,10 +186,12 @@ static inline void* mcd_realloc_compat(memcached_st *ptr, void *mem, const size_ * \see pkg_malloc * \todo this is not optimal, use internal calloc implemention which is not exported yet */ -static inline void * mcd_calloc(memcached_st *ptr, size_t nelem, const size_t elsize, void *context) { - void* tmp = NULL; +static inline void *mcd_calloc( + memcached_st *ptr, size_t nelem, const size_t elsize, void *context) +{ + void *tmp = NULL; tmp = pkg_malloc(nelem * elsize); - if (tmp != NULL) { + if(tmp != NULL) { memset(tmp, 0, nelem * elsize); } return tmp; @@ -210,13 +206,15 @@ static inline void * mcd_calloc(memcached_st *ptr, size_t nelem, const size_t el * \see pkg_malloc * \todo this is not optimal, use internal calloc implemention which is not exported yet */ -static inline void * mcd_calloc_compat(memcached_st *ptr, size_t nelem, const size_t elsize) { - void* tmp = NULL; - tmp = pkg_malloc(nelem * elsize); - if (tmp != NULL) { - memset(tmp, 0, nelem * elsize); - } - return tmp; +static inline void *mcd_calloc_compat( + memcached_st *ptr, size_t nelem, const size_t elsize) +{ + void *tmp = NULL; + tmp = pkg_malloc(nelem * elsize); + if(tmp != NULL) { + memset(tmp, 0, nelem * elsize); + } + return tmp; } @@ -241,23 +239,24 @@ static inline memcached_server_fn mcd_check_connection(const memcached_st *ptr, * \brief Module initialization function * \return 0 on success, -1 on failure */ -static int mod_init(void) { +static int mod_init(void) +{ char *server, *port; unsigned int len = 0; memcached_return rc; struct memcached_server_st *svt; - if ((port = strchr(mcd_srv_str, ':')) != NULL) { + if((port = strchr(mcd_srv_str, ':')) != NULL) { port = port + 1; len = strlen(mcd_srv_str) - strlen(port) - 1; } else { LM_DBG("no port definition, using default port\n"); port = "11211"; - len = strlen(mcd_srv_str) ; + len = strlen(mcd_srv_str); } - server = pkg_malloc(len+1); - if (server == NULL) { + server = pkg_malloc(len + 1); + if(server == NULL) { PKG_MEM_ERROR; return -1; } @@ -266,30 +265,35 @@ static int mod_init(void) { server[len] = '\0'; memcached_h = memcached_create(NULL); - if (memcached_h == NULL) { + if(memcached_h == NULL) { LM_ERR("could not create memcached structure\n"); pkg_free(server); return -1; } LM_DBG("allocated new server handle at %p", memcached_h); - if (mcd_memory == 1) { - LM_INFO("Use internal kamailio memory manager for memcached client library\n"); + if(mcd_memory == 1) { + LM_INFO("Use internal kamailio memory manager for memcached client " + "library\n"); #if LIBMEMCACHED_VERSION_HEX >= 0x00038000 - rc = memcached_set_memory_allocators(memcached_h, (memcached_malloc_fn)mcd_malloc, - (memcached_free_fn)mcd_free, (memcached_realloc_fn)mcd_realloc, - (memcached_calloc_fn)mcd_calloc, NULL); + rc = memcached_set_memory_allocators(memcached_h, + (memcached_malloc_fn)mcd_malloc, (memcached_free_fn)mcd_free, + (memcached_realloc_fn)mcd_realloc, + (memcached_calloc_fn)mcd_calloc, NULL); #else - rc = memcached_set_memory_allocators(memcached_h, (memcached_malloc_function)mcd_malloc_compat, - (memcached_free_function)mcd_free_compat, (memcached_realloc_function)mcd_realloc_compat, - (memcached_calloc_function)mcd_calloc_compat); + rc = memcached_set_memory_allocators(memcached_h, + (memcached_malloc_function)mcd_malloc_compat, + (memcached_free_function)mcd_free_compat, + (memcached_realloc_function)mcd_realloc_compat, + (memcached_calloc_function)mcd_calloc_compat); #endif - if (rc == MEMCACHED_SUCCESS) { + if(rc == MEMCACHED_SUCCESS) { LM_DBG("memory manager callbacks set\n"); } else { - LM_ERR("memory manager callbacks not set, returned %s.\n", memcached_strerror(memcached_h, rc)); + LM_ERR("memory manager callbacks not set, returned %s.\n", + memcached_strerror(memcached_h, rc)); pkg_free(server); return -1; } @@ -298,7 +302,7 @@ static int mod_init(void) { } svt = memcached_server_list_append(servers, server, atoi(port), &rc); - if(svt==NULL) { + if(svt == NULL) { LM_ERR("failed to append server\n"); if(servers) { memcached_server_list_free(servers); @@ -309,16 +313,19 @@ static int mod_init(void) { } servers = svt; - if (memcached_behavior_set(memcached_h, MEMCACHED_BEHAVIOR_CONNECT_TIMEOUT, mcd_timeout) != MEMCACHED_SUCCESS) { + if(memcached_behavior_set( + memcached_h, MEMCACHED_BEHAVIOR_CONNECT_TIMEOUT, mcd_timeout) + != MEMCACHED_SUCCESS) { LM_ERR("could not set server connection timeout\n"); pkg_free(server); return -1; } rc = memcached_server_push(memcached_h, servers); - if (rc == MEMCACHED_SUCCESS) { + if(rc == MEMCACHED_SUCCESS) { LM_DBG("added server list to structure\n"); } else { - LM_ERR("attempt to add server list to structure returned %s.\n", memcached_strerror(memcached_h, rc)); + LM_ERR("attempt to add server list to structure returned %s.\n", + memcached_strerror(memcached_h, rc)); pkg_free(server); return -1; } @@ -337,11 +344,12 @@ static int mod_init(void) { /*! * \brief Module shutdown function */ -static void mod_destroy(void) { - if (servers != NULL) +static void mod_destroy(void) +{ + if(servers != NULL) memcached_server_list_free(servers); /* Crash on shutdown with internal memory manager, even if we disable the mm callbacks */ - if (mcd_memory != 1 && memcached_h != NULL) - memcached_free(memcached_h); + if(mcd_memory != 1 && memcached_h != NULL) + memcached_free(memcached_h); } diff --git a/src/modules/memcached/memcached.h b/src/modules/memcached/memcached.h index cd35f5d69c0..7279524b741 100644 --- a/src/modules/memcached/memcached.h +++ b/src/modules/memcached/memcached.h @@ -29,7 +29,7 @@ #define MEMCACHED_H /*! server string */ -extern char* mcd_srv_str; +extern char *mcd_srv_str; /*! cache expire time in seconds */ extern unsigned int mcd_expire; /*! cache storage mode, set or add */ @@ -41,7 +41,7 @@ extern unsigned int mcd_memory; /*! stringify all values retrieved from memcached */ extern unsigned int mcd_stringify; /*! memcached handle */ -extern struct memcached_st* memcached_h; +extern struct memcached_st *memcached_h; /*! memcached server list */ extern struct memcached_server_st *servers;