void
relay_config_change_network_allowed_ips (void *data,
struct t_config_option *option)
{
const char *allowed_ips;
/* make C compiler happy */
(void) data;
(void) option;
if (relay_config_regex_allowed_ips)
{
regfree (relay_config_regex_allowed_ips);
free (relay_config_regex_allowed_ips);
relay_config_regex_allowed_ips = NULL;
}
allowed_ips = weechat_config_string (relay_config_network_allowed_ips);
if (allowed_ips && allowed_ips[0])
{
relay_config_regex_allowed_ips = malloc (sizeof (*relay_config_regex_allowed_ips));
if (relay_config_regex_allowed_ips)
{
if (weechat_string_regcomp (relay_config_regex_allowed_ips,
allowed_ips,
REG_EXTENDED | REG_ICASE) != 0)
{
free (relay_config_regex_allowed_ips);
relay_config_regex_allowed_ips = NULL;
}
}
}
}
char *
irc_color_decode_ansi (const char *string, int keep_colors)
{
struct t_irc_color_ansi_state ansi_state;
/* allocate/compile regex if needed (first call) */
if (!irc_color_regex_ansi)
{
irc_color_regex_ansi = malloc (sizeof (*irc_color_regex_ansi));
if (!irc_color_regex_ansi)
return NULL;
if (weechat_string_regcomp (irc_color_regex_ansi,
weechat_info_get ("color_ansi_regex", NULL),
REG_EXTENDED) != 0)
{
free (irc_color_regex_ansi);
irc_color_regex_ansi = NULL;
return NULL;
}
}
ansi_state.keep_colors = keep_colors;
ansi_state.bold = 0;
ansi_state.underline = 0;
ansi_state.italic = 0;
return weechat_string_replace_regex (string, irc_color_regex_ansi,
"$0", '$',
&irc_color_decode_ansi_cb,
&ansi_state);
}
struct t_irc_ignore *
irc_ignore_new (const char *mask, const char *server, const char *channel)
{
struct t_irc_ignore *new_ignore;
regex_t *regex;
if (!mask || !mask[0])
return NULL;
regex = malloc (sizeof (*regex));
if (!regex)
return NULL;
if (weechat_string_regcomp (regex, mask,
REG_EXTENDED | REG_ICASE | REG_NOSUB) != 0)
{
free (regex);
return NULL;
}
new_ignore = malloc (sizeof (*new_ignore));
if (new_ignore)
{
new_ignore->number = (last_irc_ignore) ? last_irc_ignore->number + 1 : 1;
new_ignore->mask = strdup (mask);
new_ignore->regex_mask = regex;
new_ignore->server = (server) ? strdup (server) : strdup ("*");
new_ignore->channel = (channel) ? strdup (channel) : strdup ("*");
/* add ignore to ignore list */
new_ignore->prev_ignore = last_irc_ignore;
if (irc_ignore_list)
last_irc_ignore->next_ignore = new_ignore;
else
irc_ignore_list = new_ignore;
last_irc_ignore = new_ignore;
new_ignore->next_ignore = NULL;
}
return new_ignore;
}
int
trigger_regex_split (const char *str_regex,
int *regex_count, struct t_trigger_regex **regex)
{
const char *ptr_regex, *pos, *pos_replace, *pos_replace_end;
const char *pos_next_regex;
char *delimiter, *str_regex_escaped;
int rc, index, length_delimiter;
struct t_trigger_regex *new_regex;
rc = 0;
delimiter = NULL;
str_regex_escaped = NULL;
if (!regex_count || !regex)
goto end;
/* remove any existing regex */
trigger_regex_free (regex_count, regex);
if (!str_regex || !str_regex[0])
goto end;
/* min 3 chars, for example: "/a/" */
if (strlen (str_regex) < 3)
goto format_error;
/* parse regular expressions in the option */
ptr_regex = str_regex;
while (ptr_regex && ptr_regex[0])
{
if (delimiter)
{
free (delimiter);
delimiter = NULL;
}
/* search the delimiter (which can be more than one char) */
pos = weechat_utf8_next_char (ptr_regex);
while (pos[0] && (weechat_utf8_charcmp (ptr_regex, pos) == 0))
{
pos = weechat_utf8_next_char (pos);
}
if (!pos[0])
goto format_error;
delimiter = weechat_strndup (ptr_regex, pos - ptr_regex);
if (!delimiter)
goto memory_error;
length_delimiter = strlen (delimiter);
ptr_regex = pos;
if (!ptr_regex[0])
goto format_error;
/* search the start of replacement string */
pos_replace = strstr (ptr_regex, delimiter);
if (!pos_replace)
goto format_error;
/* search the end of replacement string */
pos_replace_end = strstr (pos_replace + length_delimiter, delimiter);
new_regex = realloc (*regex,
(*regex_count + 1) * sizeof ((*regex)[0]));
if (!new_regex)
goto memory_error;
*regex = new_regex;
(*regex_count)++;
index = *regex_count - 1;
/* initialize new regex */
(*regex)[index].variable = NULL;
(*regex)[index].str_regex = NULL;
(*regex)[index].regex = NULL;
(*regex)[index].replace = NULL;
(*regex)[index].replace_escaped = NULL;
/* set string with regex */
(*regex)[index].str_regex = weechat_strndup (ptr_regex,
pos_replace - ptr_regex);
if (!(*regex)[index].str_regex)
goto memory_error;
str_regex_escaped = weechat_string_convert_escaped_chars ((*regex)[index].str_regex);
if (!str_regex_escaped)
goto memory_error;
/* set regex */
(*regex)[index].regex = malloc (sizeof (*(*regex)[index].regex));
if (!(*regex)[index].regex)
goto memory_error;
if (weechat_string_regcomp ((*regex)[index].regex,
str_regex_escaped,
REG_EXTENDED | REG_ICASE) != 0)
{
free ((*regex)[index].regex);
(*regex)[index].regex = NULL;
goto compile_error;
}
/* set replace and replace_eval */
(*regex)[index].replace = (pos_replace_end) ?
weechat_strndup (pos_replace + length_delimiter,
pos_replace_end - pos_replace - length_delimiter) :
strdup (pos_replace + length_delimiter);
if (!(*regex)[index].replace)
goto memory_error;
(*regex)[index].replace_escaped =
weechat_string_convert_escaped_chars ((*regex)[index].replace);
if (!(*regex)[index].replace_escaped)
goto memory_error;
if (!pos_replace_end)
break;
/* set variable (optional) */
ptr_regex = pos_replace_end + length_delimiter;
if (!ptr_regex[0])
break;
if (ptr_regex[0] == ' ')
pos_next_regex = ptr_regex;
else
{
pos_next_regex = strchr (ptr_regex, ' ');
(*regex)[index].variable = (pos_next_regex) ?
weechat_strndup (ptr_regex, pos_next_regex - ptr_regex) :
strdup (ptr_regex);
if (!(*regex)[index].variable)
goto memory_error;
}
if (!pos_next_regex)
break;
/* skip spaces before next regex */
ptr_regex = pos_next_regex + 1;
while (ptr_regex[0] == ' ')
{
ptr_regex++;
}
}
goto end;
format_error:
rc = -1;
goto end;
compile_error:
rc = -2;
goto end;
memory_error:
rc = -3;
goto end;
end:
if (delimiter)
free (delimiter);
if (str_regex_escaped)
free (str_regex_escaped);
if (rc < 0)
trigger_regex_free (regex_count, regex);
return rc;
}
struct t_rmodifier *
rmodifier_new (const char *name, const char *modifiers, const char *str_regex,
const char *groups)
{
struct t_rmodifier *new_rmodifier, *ptr_rmodifier;
regex_t *regex;
if (!name || !name[0] || !modifiers || !modifiers[0]
|| !str_regex || !str_regex[0])
{
return NULL;
}
regex = malloc (sizeof (*regex));
if (!regex)
return NULL;
if (weechat_string_regcomp (regex, str_regex,
REG_EXTENDED | REG_ICASE) != 0)
{
weechat_printf (NULL,
_("%s%s: error compiling regular expression \"%s\""),
weechat_prefix ("error"), RMODIFIER_PLUGIN_NAME,
str_regex);
free (regex);
return NULL;
}
ptr_rmodifier = rmodifier_search (name);
if (ptr_rmodifier)
rmodifier_free (ptr_rmodifier);
new_rmodifier = malloc (sizeof (*new_rmodifier));
if (new_rmodifier)
{
new_rmodifier->name = strdup (name);
new_rmodifier->hooks = NULL;
new_rmodifier->modifiers = strdup (modifiers);
new_rmodifier->str_regex = strdup (str_regex);
new_rmodifier->regex = regex;
new_rmodifier->groups = strdup ((groups) ? groups : "");
/* create modifiers */
rmodifier_hook_modifiers (new_rmodifier);
if (rmodifier_list)
{
/* add rmodifier to end of list */
new_rmodifier->prev_rmodifier = last_rmodifier;
new_rmodifier->next_rmodifier = NULL;
last_rmodifier->next_rmodifier = new_rmodifier;
last_rmodifier = new_rmodifier;
}
else
{
new_rmodifier->prev_rmodifier = NULL;
new_rmodifier->next_rmodifier = NULL;
rmodifier_list = new_rmodifier;
last_rmodifier = new_rmodifier;
}
rmodifier_count++;
}
return new_rmodifier;
}
