--- /dev/null
+From fb7c59cafceb35628d40c727dbfa2990335b922a Mon Sep 17 00:00:00 2001
+From: Victor Seva <linuxmaniac@torreviejawireless.org>
+Date: Wed, 17 May 2023 16:37:10 +0200
+Subject: [PATCH] regex: clang-format for coherent indentation and coding style
+
+---
+ src/modules/regex/regex_mod.c | 313 ++++++++++++++++------------------
+ 1 file changed, 150 insertions(+), 163 deletions(-)
+
+--- a/src/modules/regex/regex_mod.c
++++ b/src/modules/regex/regex_mod.c
+@@ -49,9 +49,9 @@ MODULE_VERSION
+ #define START 0
+ #define RELOAD 1
+
+-#define FILE_MAX_LINE 500 /*!< Max line size in the file */
+-#define MAX_GROUPS 20 /*!< Max number of groups */
+-#define GROUP_MAX_SIZE 8192 /*!< Max size of a group */
++#define FILE_MAX_LINE 500 /*!< Max line size in the file */
++#define MAX_GROUPS 20 /*!< Max number of groups */
++#define GROUP_MAX_SIZE 8192 /*!< Max size of a group */
+
+
+ static int regex_init_rpc(void);
+@@ -66,12 +66,12 @@ gen_lock_t *reload_lock;
+ * Module exported parameter variables
+ */
+ static char *file;
+-static int max_groups = MAX_GROUPS;
+-static int group_max_size = GROUP_MAX_SIZE;
+-static int pcre_caseless = 0;
+-static int pcre_multiline = 0;
+-static int pcre_dotall = 0;
+-static int pcre_extended = 0;
++static int max_groups = MAX_GROUPS;
++static int group_max_size = GROUP_MAX_SIZE;
++static int pcre_caseless = 0;
++static int pcre_multiline = 0;
++static int pcre_dotall = 0;
++static int pcre_extended = 0;
+
+
+ /*
+@@ -100,119 +100,117 @@ static void free_shared_memory(void);
+ /*
+ * Script functions
+ */
+-static int w_pcre_match(struct sip_msg* _msg, char* _s1, char* _s2);
+-static int w_pcre_match_group(struct sip_msg* _msg, char* _s1, char* _s2);
++static int w_pcre_match(struct sip_msg *_msg, char *_s1, char *_s2);
++static int w_pcre_match_group(struct sip_msg *_msg, char *_s1, char *_s2);
+
+
+ /*
+ * Exported functions
+ */
+-static cmd_export_t cmds[] =
+-{
+- { "pcre_match", (cmd_function)w_pcre_match, 2, fixup_spve_spve, 0,
+- REQUEST_ROUTE|FAILURE_ROUTE|ONREPLY_ROUTE|BRANCH_ROUTE|LOCAL_ROUTE },
+- { "pcre_match_group", (cmd_function)w_pcre_match_group, 2, fixup_spve_spve, 0,
+- REQUEST_ROUTE|FAILURE_ROUTE|ONREPLY_ROUTE|BRANCH_ROUTE|LOCAL_ROUTE },
+- { "pcre_match_group", (cmd_function)w_pcre_match_group, 1, fixup_spve_null, 0,
+- REQUEST_ROUTE|FAILURE_ROUTE|ONREPLY_ROUTE|BRANCH_ROUTE|LOCAL_ROUTE },
+- { 0, 0, 0, 0, 0, 0 }
+-};
++static cmd_export_t cmds[] = {
++ {"pcre_match", (cmd_function)w_pcre_match, 2, fixup_spve_spve, 0,
++ REQUEST_ROUTE | FAILURE_ROUTE | ONREPLY_ROUTE | BRANCH_ROUTE
++ | LOCAL_ROUTE},
++ {"pcre_match_group", (cmd_function)w_pcre_match_group, 2,
++ fixup_spve_spve, 0,
++ REQUEST_ROUTE | FAILURE_ROUTE | ONREPLY_ROUTE | BRANCH_ROUTE
++ | LOCAL_ROUTE},
++ {"pcre_match_group", (cmd_function)w_pcre_match_group, 1,
++ fixup_spve_null, 0,
++ REQUEST_ROUTE | FAILURE_ROUTE | ONREPLY_ROUTE | BRANCH_ROUTE
++ | LOCAL_ROUTE},
++ {0, 0, 0, 0, 0, 0}};
+
+
+ /*
+ * Exported parameters
+ */
+-static param_export_t params[] = {
+- {"file", PARAM_STRING, &file },
+- {"max_groups", INT_PARAM, &max_groups },
+- {"group_max_size", INT_PARAM, &group_max_size },
+- {"pcre_caseless", INT_PARAM, &pcre_caseless },
+- {"pcre_multiline", INT_PARAM, &pcre_multiline },
+- {"pcre_dotall", INT_PARAM, &pcre_dotall },
+- {"pcre_extended", INT_PARAM, &pcre_extended },
+- {0, 0, 0}
+-};
++static param_export_t params[] = {{"file", PARAM_STRING, &file},
++ {"max_groups", INT_PARAM, &max_groups},
++ {"group_max_size", INT_PARAM, &group_max_size},
++ {"pcre_caseless", INT_PARAM, &pcre_caseless},
++ {"pcre_multiline", INT_PARAM, &pcre_multiline},
++ {"pcre_dotall", INT_PARAM, &pcre_dotall},
++ {"pcre_extended", INT_PARAM, &pcre_extended}, {0, 0, 0}};
+
+
+ /*
+ * Module interface
+ */
+ struct module_exports exports = {
+- "regex", /*!< module name */
+- DEFAULT_DLFLAGS, /*!< dlopen flags */
+- cmds, /*!< exported functions */
+- params, /*!< exported parameters */
+- 0, /*!< exported RPC functions */
+- 0, /*!< exported pseudo-variables */
+- 0, /*!< response handling function */
+- mod_init, /*!< module initialization function */
+- 0, /*!< per-child init function */
+- destroy /*!< destroy function */
++ "regex", /*!< module name */
++ DEFAULT_DLFLAGS, /*!< dlopen flags */
++ cmds, /*!< exported functions */
++ params, /*!< exported parameters */
++ 0, /*!< exported RPC functions */
++ 0, /*!< exported pseudo-variables */
++ 0, /*!< response handling function */
++ mod_init, /*!< module initialization function */
++ 0, /*!< per-child init function */
++ destroy /*!< destroy function */
+ };
+
+
+-
+ /*! \brief
+ * Init module function
+ */
+ static int mod_init(void)
+ {
+- if(regex_init_rpc()<0)
+- {
++ if(regex_init_rpc() < 0) {
+ LM_ERR("failed to register RPC commands\n");
+ return -1;
+ }
+
+ /* Group matching feature */
+- if (file == NULL) {
++ if(file == NULL) {
+ LM_NOTICE("'file' parameter is not set, group matching disabled\n");
+ } else {
+ /* Create and init the lock */
+ reload_lock = lock_alloc();
+- if (reload_lock == NULL) {
++ if(reload_lock == NULL) {
+ LM_ERR("cannot allocate reload_lock\n");
+ goto err;
+ }
+- if (lock_init(reload_lock) == NULL) {
++ if(lock_init(reload_lock) == NULL) {
+ LM_ERR("cannot init the reload_lock\n");
+ lock_dealloc(reload_lock);
+ goto err;
+ }
+
+ /* PCRE options */
+- if (pcre_caseless != 0) {
++ if(pcre_caseless != 0) {
+ LM_DBG("PCRE CASELESS enabled\n");
+ pcre_options = pcre_options | PCRE_CASELESS;
+ }
+- if (pcre_multiline != 0) {
++ if(pcre_multiline != 0) {
+ LM_DBG("PCRE MULTILINE enabled\n");
+ pcre_options = pcre_options | PCRE_MULTILINE;
+ }
+- if (pcre_dotall != 0) {
++ if(pcre_dotall != 0) {
+ LM_DBG("PCRE DOTALL enabled\n");
+ pcre_options = pcre_options | PCRE_DOTALL;
+ }
+- if (pcre_extended != 0) {
++ if(pcre_extended != 0) {
+ LM_DBG("PCRE EXTENDED enabled\n");
+ pcre_options = pcre_options | PCRE_EXTENDED;
+ }
+ LM_DBG("PCRE options: %i\n", pcre_options);
+
+ /* Pointer to pcres */
+- if ((pcres_addr = shm_malloc(sizeof(pcre **))) == 0) {
++ if((pcres_addr = shm_malloc(sizeof(pcre **))) == 0) {
+ LM_ERR("no memory for pcres_addr\n");
+ goto err;
+ }
+
+ /* Integer containing the number of pcres */
+- if ((num_pcres = shm_malloc(sizeof(int))) == 0) {
++ if((num_pcres = shm_malloc(sizeof(int))) == 0) {
+ LM_ERR("no memory for num_pcres\n");
+ goto err;
+ }
+
+ /* Load the pcres */
+ LM_DBG("loading pcres...\n");
+- if (load_pcres(START)) {
++ if(load_pcres(START)) {
+ LM_ERR("failed to load pcres\n");
+ goto err;
+ }
+@@ -251,21 +249,21 @@ static int load_pcres(int action)
+ /* Get the lock */
+ lock_get(reload_lock);
+
+- if (!(f = fopen(file, "r"))) {
++ if(!(f = fopen(file, "r"))) {
+ LM_ERR("could not open file '%s'\n", file);
+ goto err;
+ }
+
+ /* Array containing each pattern in the file */
+- if ((patterns = pkg_malloc(sizeof(char*) * max_groups)) == 0) {
++ if((patterns = pkg_malloc(sizeof(char *) * max_groups)) == 0) {
+ LM_ERR("no more memory for patterns\n");
+ fclose(f);
+ goto err;
+ }
+- memset(patterns, 0, sizeof(char*) * max_groups);
++ memset(patterns, 0, sizeof(char *) * max_groups);
+
+- for (i=0; i<max_groups; i++) {
+- if ((patterns[i] = pkg_malloc(sizeof(char) * group_max_size)) == 0) {
++ for(i = 0; i < max_groups; i++) {
++ if((patterns[i] = pkg_malloc(sizeof(char) * group_max_size)) == 0) {
+ LM_ERR("no more memory for patterns[%d]\n", i);
+ fclose(f);
+ goto err;
+@@ -276,26 +274,27 @@ static int load_pcres(int action)
+ /* Read the file and extract the patterns */
+ memset(line, 0, FILE_MAX_LINE);
+ i = -1;
+- while (fgets(line, FILE_MAX_LINE-4, f) != NULL) {
++ while(fgets(line, FILE_MAX_LINE - 4, f) != NULL) {
+
+ /* Ignore comments and lines starting by space, tab, CR, LF */
+- if(isspace(line[0]) || line[0]=='#') {
++ if(isspace(line[0]) || line[0] == '#') {
+ memset(line, 0, FILE_MAX_LINE);
+ continue;
+ }
+
+ /* First group */
+- if (i == -1 && line[0] != '[') {
+- LM_ERR("first group must be initialized with [0] before any regular expression\n");
++ if(i == -1 && line[0] != '[') {
++ LM_ERR("first group must be initialized with [0] before any "
++ "regular expression\n");
+ fclose(f);
+ goto err;
+ }
+
+ /* New group */
+- if (line[0] == '[') {
++ if(line[0] == '[') {
+ i++;
+ /* Check if there are more patterns than the max value */
+- if (i >= max_groups) {
++ if(i >= max_groups) {
+ LM_ERR("max patterns exceeded\n");
+ fclose(f);
+ goto err;
+@@ -309,14 +308,14 @@ static int load_pcres(int action)
+
+ llen = strlen(line);
+ /* Check if the patter size is too big (aprox) */
+- if (strlen(patterns[i]) + llen >= group_max_size - 4) {
++ if(strlen(patterns[i]) + llen >= group_max_size - 4) {
+ LM_ERR("pattern max file exceeded\n");
+ fclose(f);
+ goto err;
+ }
+
+ /* Append ')' at the end of the line */
+- if (line[llen - 1] == '\n') {
++ if(line[llen - 1] == '\n') {
+ line[llen - 1] = ')';
+ line[llen] = '\n';
+ line[llen + 1] = '\0';
+@@ -328,7 +327,7 @@ static int load_pcres(int action)
+
+ /* Append '(' at the beginning of the line */
+ llen = strlen(patterns[i]);
+- memcpy(patterns[i]+llen, "(", 1);
++ memcpy(patterns[i] + llen, "(", 1);
+ llen++;
+
+ /* Append the line to the current pattern (including the ending 0) */
+@@ -340,16 +339,16 @@ static int load_pcres(int action)
+
+ fclose(f);
+
+- if(num_pcres_tmp==0) {
++ if(num_pcres_tmp == 0) {
+ LM_ERR("no expressions in the file\n");
+ goto err;
+ }
+
+ /* Fix the patterns */
+- for (i=0; i < num_pcres_tmp; i++) {
++ for(i = 0; i < num_pcres_tmp; i++) {
+
+ /* Convert empty groups in unmatcheable regular expression ^$ */
+- if (strlen(patterns[i]) == 1) {
++ if(strlen(patterns[i]) == 1) {
+ patterns[i][0] = '^';
+ patterns[i][1] = '$';
+ patterns[i][2] = '\0';
+@@ -357,13 +356,13 @@ static int load_pcres(int action)
+ }
+
+ /* Delete possible '\n' at the end of the pattern */
+- if (patterns[i][strlen(patterns[i])-1] == '\n') {
+- patterns[i][strlen(patterns[i])-1] = '\0';
++ if(patterns[i][strlen(patterns[i]) - 1] == '\n') {
++ patterns[i][strlen(patterns[i]) - 1] = '\0';
+ }
+
+ /* Replace '\n' with '|' (except at the end of the pattern) */
+- for (j=0; j < strlen(patterns[i]); j++) {
+- if (patterns[i][j] == '\n' && j != strlen(patterns[i])-1) {
++ for(j = 0; j < strlen(patterns[i]); j++) {
++ if(patterns[i][j] == '\n' && j != strlen(patterns[i]) - 1) {
+ patterns[i][j] = '|';
+ }
+ }
+@@ -374,38 +373,38 @@ static int load_pcres(int action)
+
+ /* Log the group patterns */
+ LM_INFO("num groups = %d\n", num_pcres_tmp);
+- for (i=0; i < num_pcres_tmp; i++) {
+- LM_INFO("<group[%d]>%s</group[%d]> (size = %i)\n", i, patterns[i],
+- i, (int)strlen(patterns[i]));
++ for(i = 0; i < num_pcres_tmp; i++) {
++ LM_INFO("<group[%d]>%s</group[%d]> (size = %i)\n", i, patterns[i], i,
++ (int)strlen(patterns[i]));
+ }
+
+ /* Temporal pointer of pcres */
+- if ((pcres_tmp = pkg_malloc(sizeof(pcre *) * num_pcres_tmp)) == 0) {
++ if((pcres_tmp = pkg_malloc(sizeof(pcre *) * num_pcres_tmp)) == 0) {
+ LM_ERR("no more memory for pcres_tmp\n");
+ goto err;
+ }
+- for (i=0; i<num_pcres_tmp; i++) {
++ for(i = 0; i < num_pcres_tmp; i++) {
+ pcres_tmp[i] = NULL;
+ }
+
+ /* Compile the patters */
+- for (i=0; i<num_pcres_tmp; i++) {
++ for(i = 0; i < num_pcres_tmp; i++) {
+
+- pcre_tmp = pcre_compile(patterns[i], pcre_options, &pcre_error,
+- &pcre_erroffset, NULL);
+- if (pcre_tmp == NULL) {
++ pcre_tmp = pcre_compile(
++ patterns[i], pcre_options, &pcre_error, &pcre_erroffset, NULL);
++ if(pcre_tmp == NULL) {
+ LM_ERR("pcre_tmp compilation of '%s' failed at offset %d: %s\n",
+ patterns[i], pcre_erroffset, pcre_error);
+ goto err;
+ }
+ pcre_rc = pcre_fullinfo(pcre_tmp, NULL, PCRE_INFO_SIZE, &pcre_size);
+- if (pcre_rc) {
++ if(pcre_rc) {
+ printf("pcre_fullinfo on compiled pattern[%i] yielded error: %d\n",
+ i, pcre_rc);
+ goto err;
+ }
+
+- if ((pcres_tmp[i] = pkg_malloc(pcre_size)) == 0) {
++ if((pcres_tmp[i] = pkg_malloc(pcre_size)) == 0) {
+ LM_ERR("no more memory for pcres_tmp[%i]\n", i);
+ goto err;
+ }
+@@ -417,22 +416,22 @@ static int load_pcres(int action)
+ }
+
+ /* Copy to shared memory */
+- if (action == RELOAD) {
+- for(i=0; i<*num_pcres; i++) { /* Use the previous num_pcres value */
+- if (pcres[i]) {
++ if(action == RELOAD) {
++ for(i = 0; i < *num_pcres; i++) { /* Use the previous num_pcres value */
++ if(pcres[i]) {
+ shm_free(pcres[i]);
+ }
+ }
+ shm_free(pcres);
+ }
+- if ((pcres = shm_malloc(sizeof(pcre *) * num_pcres_tmp)) == 0) {
++ if((pcres = shm_malloc(sizeof(pcre *) * num_pcres_tmp)) == 0) {
+ LM_ERR("no more memory for pcres\n");
+ goto err;
+ }
+ memset(pcres, 0, sizeof(pcre *) * num_pcres_tmp);
+- for (i=0; i<num_pcres_tmp; i++) {
++ for(i = 0; i < num_pcres_tmp; i++) {
+ pcre_rc = pcre_fullinfo(pcres_tmp[i], NULL, PCRE_INFO_SIZE, &pcre_size);
+- if ((pcres[i] = shm_malloc(pcre_size)) == 0) {
++ if((pcres[i] = shm_malloc(pcre_size)) == 0) {
+ LM_ERR("no more memory for pcres[%i]\n", i);
+ goto err;
+ }
+@@ -442,12 +441,12 @@ static int load_pcres(int action)
+ *pcres_addr = pcres;
+
+ /* Free used memory */
+- for (i=0; i<num_pcres_tmp; i++) {
++ for(i = 0; i < num_pcres_tmp; i++) {
+ pkg_free(pcres_tmp[i]);
+ }
+ pkg_free(pcres_tmp);
+ /* Free allocated slots for unused patterns */
+- for (i = num_pcres_tmp; i < max_groups; i++) {
++ for(i = num_pcres_tmp; i < max_groups; i++) {
+ pkg_free(patterns[i]);
+ }
+ pkg_free(patterns);
+@@ -456,26 +455,26 @@ static int load_pcres(int action)
+ return 0;
+
+ err:
+- if (patterns) {
+- for(i=0; i<max_groups; i++) {
+- if (patterns[i]) {
++ if(patterns) {
++ for(i = 0; i < max_groups; i++) {
++ if(patterns[i]) {
+ pkg_free(patterns[i]);
+ }
+ }
+ pkg_free(patterns);
+ }
+- if (pcres_tmp) {
+- for (i=0; i<num_pcres_tmp; i++) {
+- if (pcres_tmp[i]) {
++ if(pcres_tmp) {
++ for(i = 0; i < num_pcres_tmp; i++) {
++ if(pcres_tmp[i]) {
+ pkg_free(pcres_tmp[i]);
+ }
+ }
+ pkg_free(pcres_tmp);
+ }
+- if (reload_lock) {
++ if(reload_lock) {
+ lock_release(reload_lock);
+ }
+- if (action == START) {
++ if(action == START) {
+ free_shared_memory();
+ }
+ return -1;
+@@ -486,9 +485,9 @@ static void free_shared_memory(void)
+ {
+ int i;
+
+- if (pcres) {
+- for(i=0; i<*num_pcres; i++) {
+- if (pcres[i]) {
++ if(pcres) {
++ for(i = 0; i < *num_pcres; i++) {
++ if(pcres[i]) {
+ shm_free(pcres[i]);
+ }
+ }
+@@ -496,21 +495,21 @@ static void free_shared_memory(void)
+ pcres = NULL;
+ }
+
+- if (num_pcres) {
++ if(num_pcres) {
+ shm_free(num_pcres);
+ num_pcres = NULL;
+ }
+
+- if (pcres_addr) {
++ if(pcres_addr) {
+ shm_free(pcres_addr);
+ pcres_addr = NULL;
+ }
+
+- if (reload_lock) {
++ if(reload_lock) {
+ lock_destroy(reload_lock);
+ lock_dealloc(reload_lock);
+ reload_lock = NULL;
+- }
++ }
+ }
+
+
+@@ -519,32 +518,32 @@ static void free_shared_memory(void)
+ */
+
+ /*! \brief Return true if the argument matches the regular expression parameter */
+-static int ki_pcre_match(sip_msg_t* msg, str* string, str* regex)
++static int ki_pcre_match(sip_msg_t *msg, str *string, str *regex)
+ {
+ pcre *pcre_re = NULL;
+ int pcre_rc;
+ const char *pcre_error;
+ int pcre_erroffset;
+
+- pcre_re = pcre_compile(regex->s, pcre_options, &pcre_error, &pcre_erroffset, NULL);
+- if (pcre_re == NULL) {
++ pcre_re = pcre_compile(
++ regex->s, pcre_options, &pcre_error, &pcre_erroffset, NULL);
++ if(pcre_re == NULL) {
+ LM_ERR("pcre_re compilation of '%s' failed at offset %d: %s\n",
+ regex->s, pcre_erroffset, pcre_error);
+ return -4;
+ }
+
+- pcre_rc = pcre_exec(
+- pcre_re, /* the compiled pattern */
+- NULL, /* no extra data - we didn't study the pattern */
+- string->s, /* the matching string */
+- (int)(string->len), /* the length of the subject */
+- 0, /* start at offset 0 in the string */
+- 0, /* default options */
+- NULL, /* output vector for substring information */
+- 0); /* number of elements in the output vector */
++ pcre_rc = pcre_exec(pcre_re, /* the compiled pattern */
++ NULL, /* no extra data - we didn't study the pattern */
++ string->s, /* the matching string */
++ (int)(string->len), /* the length of the subject */
++ 0, /* start at offset 0 in the string */
++ 0, /* default options */
++ NULL, /* output vector for substring information */
++ 0); /* number of elements in the output vector */
+
+ /* Matching failed: handle error cases */
+- if (pcre_rc < 0) {
++ if(pcre_rc < 0) {
+ switch(pcre_rc) {
+ case PCRE_ERROR_NOMATCH:
+ LM_DBG("'%s' doesn't match '%s'\n", string->s, regex->s);
+@@ -562,28 +561,26 @@ static int ki_pcre_match(sip_msg_t* msg,
+ }
+
+ /*! \brief Return true if the argument matches the regular expression parameter */
+-static int w_pcre_match(struct sip_msg* _msg, char* _s1, char* _s2)
++static int w_pcre_match(struct sip_msg *_msg, char *_s1, char *_s2)
+ {
+ str string;
+ str regex;
+
+- if (_s1 == NULL) {
++ if(_s1 == NULL) {
+ LM_ERR("bad parameters\n");
+ return -2;
+ }
+
+- if (_s2 == NULL) {
++ if(_s2 == NULL) {
+ LM_ERR("bad parameters\n");
+ return -2;
+ }
+
+- if (fixup_get_svalue(_msg, (gparam_p)_s1, &string))
+- {
++ if(fixup_get_svalue(_msg, (gparam_p)_s1, &string)) {
+ LM_ERR("cannot print the format for string\n");
+ return -3;
+ }
+- if (fixup_get_svalue(_msg, (gparam_p)_s2, ®ex))
+- {
++ if(fixup_get_svalue(_msg, (gparam_p)_s2, ®ex)) {
+ LM_ERR("cannot print the format for regex\n");
+ return -3;
+ }
+@@ -592,17 +589,17 @@ static int w_pcre_match(struct sip_msg*
+ }
+
+ /*! \brief Return true if the string argument matches the pattern group parameter */
+-static int ki_pcre_match_group(sip_msg_t* _msg, str* string, int num_pcre)
++static int ki_pcre_match_group(sip_msg_t *_msg, str *string, int num_pcre)
+ {
+ int pcre_rc;
+
+ /* Check if group matching feature is enabled */
+- if (file == NULL) {
++ if(file == NULL) {
+ LM_ERR("group matching is disabled\n");
+ return -2;
+ }
+
+- if (num_pcre >= *num_pcres) {
++ if(num_pcre >= *num_pcres) {
+ LM_ERR("invalid pcre index '%i', there are %i pcres\n", num_pcre,
+ *num_pcres);
+ return -4;
+@@ -610,20 +607,19 @@ static int ki_pcre_match_group(sip_msg_t
+
+ lock_get(reload_lock);
+
+- pcre_rc = pcre_exec(
+- (*pcres_addr)[num_pcre], /* the compiled pattern */
+- NULL, /* no extra data - we didn't study the pattern */
+- string->s, /* the matching string */
+- (int)(string->len), /* the length of the subject */
+- 0, /* start at offset 0 in the string */
+- 0, /* default options */
+- NULL, /* output vector for substring information */
+- 0); /* number of elements in the output vector */
++ pcre_rc = pcre_exec((*pcres_addr)[num_pcre], /* the compiled pattern */
++ NULL, /* no extra data - we didn't study the pattern */
++ string->s, /* the matching string */
++ (int)(string->len), /* the length of the subject */
++ 0, /* start at offset 0 in the string */
++ 0, /* default options */
++ NULL, /* output vector for substring information */
++ 0); /* number of elements in the output vector */
+
+ lock_release(reload_lock);
+
+ /* Matching failed: handle error cases */
+- if (pcre_rc < 0) {
++ if(pcre_rc < 0) {
+ switch(pcre_rc) {
+ case PCRE_ERROR_NOMATCH:
+ LM_DBG("'%s' doesn't match pcres[%i]\n", string->s, num_pcre);
+@@ -640,29 +636,27 @@ static int ki_pcre_match_group(sip_msg_t
+ }
+
+ /*! \brief Return true if the string argument matches the pattern group parameter */
+-static int w_pcre_match_group(struct sip_msg* _msg, char* _s1, char* _s2)
++static int w_pcre_match_group(struct sip_msg *_msg, char *_s1, char *_s2)
+ {
+ str string, group;
+ unsigned int num_pcre = 0;
+
+- if (_s1 == NULL) {
++ if(_s1 == NULL) {
+ LM_ERR("bad parameters\n");
+ return -3;
+ }
+
+- if (_s2 == NULL) {
++ if(_s2 == NULL) {
+ num_pcre = 0;
+ } else {
+- if (fixup_get_svalue(_msg, (gparam_p)_s2, &group))
+- {
++ if(fixup_get_svalue(_msg, (gparam_p)_s2, &group)) {
+ LM_ERR("cannot print the format for second param\n");
+ return -5;
+ }
+ str2int(&group, &num_pcre);
+ }
+
+- if (fixup_get_svalue(_msg, (gparam_p)_s1, &string))
+- {
++ if(fixup_get_svalue(_msg, (gparam_p)_s1, &string)) {
+ LM_ERR("cannot print the format for first param\n");
+ return -5;
+ }
+@@ -676,42 +670,35 @@ static int w_pcre_match_group(struct sip
+ */
+
+ /*! \brief Reload pcres by reading the file again */
+-void regex_rpc_reload(rpc_t* rpc, void* ctx)
++void regex_rpc_reload(rpc_t *rpc, void *ctx)
+ {
+ /* Check if group matching feature is enabled */
+- if (file == NULL) {
++ if(file == NULL) {
+ LM_NOTICE("'file' parameter is not set, group matching disabled\n");
+ rpc->fault(ctx, 500, "Group matching not enabled");
+ return;
+ }
+ LM_INFO("reloading pcres...\n");
+- if (load_pcres(RELOAD)) {
++ if(load_pcres(RELOAD)) {
+ LM_ERR("failed to reload pcres\n");
+ rpc->fault(ctx, 500, "Failed to reload");
+ return;
+ }
+ LM_INFO("reload success\n");
+-
+ }
+
+-static const char* regex_rpc_reload_doc[2] = {
+- "Reload regex file",
+- 0
+-};
++static const char *regex_rpc_reload_doc[2] = {"Reload regex file", 0};
+
+ rpc_export_t regex_rpc_cmds[] = {
+- {"regex.reload", regex_rpc_reload,
+- regex_rpc_reload_doc, 0},
+- {0, 0, 0, 0}
+-};
++ {"regex.reload", regex_rpc_reload, regex_rpc_reload_doc, 0},
++ {0, 0, 0, 0}};
+
+ /**
+ * register RPC commands
+ */
+ static int regex_init_rpc(void)
+ {
+- if (rpc_register_array(regex_rpc_cmds)!=0)
+- {
++ if(rpc_register_array(regex_rpc_cmds) != 0) {
+ LM_ERR("failed to register RPC commands\n");
+ return -1;
+ }
projects / feed / telephony.git / blobdiff