static void address_free(Address *addr) {
if (!addr)
return;
text_regex_free(addr->regex);
address_free(addr->left);
address_free(addr->right);
free(addr);
}
void
evpaxos_config_free(struct evpaxos_config* config)
{
int i;
for (i = 0; i < config->proposers_count; ++i)
address_free(&config->proposers[i]);
for (i = 0; i < config->acceptors_count; ++i)
address_free(&config->acceptors[i]);
free(config);
}
void networkinterface_free(NetworkInterface* interface) {
MAGIC_ASSERT(interface);
/* unref all packets sitting in our input buffer */
while(interface->inBuffer && !g_queue_is_empty(interface->inBuffer)) {
Packet* packet = g_queue_pop_head(interface->inBuffer);
packet_unref(packet);
}
g_queue_free(interface->inBuffer);
/* unref all sockets wanting to send */
while(interface->rrQueue && !g_queue_is_empty(interface->rrQueue)) {
Socket* socket = g_queue_pop_head(interface->rrQueue);
descriptor_unref(socket);
}
g_queue_free(interface->rrQueue);
priorityqueue_free(interface->fifoQueue);
g_hash_table_destroy(interface->boundSockets);
address_free(interface->address);
if(interface->pcapFile) {
fclose(interface->pcapFile);
}
MAGIC_CLEAR(interface);
g_free(interface);
}
/**
* address_native_set - Set an Address config item by Address object - Implements ::cst_native_set()
*/
static int address_native_set(const struct ConfigSet *cs, void *var,
const struct ConfigDef *cdef, intptr_t value,
struct Buffer *err)
{
if (!cs || !var || !cdef)
return CSR_ERR_CODE; /* LCOV_EXCL_LINE */
int rc;
if (cdef->validator)
{
rc = cdef->validator(cs, cdef, value, err);
if (CSR_RESULT(rc) != CSR_SUCCESS)
return rc | CSR_INV_VALIDATOR;
}
address_free(var);
struct Address *addr = address_dup((struct Address *) value);
rc = CSR_SUCCESS;
if (!addr)
rc |= CSR_SUC_EMPTY;
*(struct Address **) var = addr;
return rc;
}
void _socket_free(sock *sock)
{
if (sock->laddr != NULL)
{
address_free(sock->laddr);
}
if (sock->raddr != NULL)
{
address_free(sock->raddr);
}
#ifdef HAVE_SSL
if (sock->sslstate != SSL_OFF)
{
SSL_free(sock->ssl);
}
#endif
irc_free(sock);
}
/**
* address_destroy - Destroy an Address object - Implements ::cst_destroy()
*/
static void address_destroy(const struct ConfigSet *cs, void *var, const struct ConfigDef *cdef)
{
if (!cs || !var || !cdef)
return; /* LCOV_EXCL_LINE */
struct Address **a = var;
if (!*a)
return;
address_free(a);
}
static CONF_HANDLER(conf_address6)
{
char *s = config_get_string(n, NULL);
if (s == NULL)
{
return CONFIG_BAD;
}
if (local6 != NULL)
{
address_free(local);
}
local6 = address_make(s, 0);
return CONFIG_OK;
}
static void command_free(Command *cmd) {
if (!cmd)
return;
for (Command *c = cmd->cmd, *next; c; c = next) {
next = c->next;
command_free(c);
}
for (const char **args = cmd->argv; *args; args++)
free((void*)*args);
address_free(cmd->address);
text_regex_free(cmd->regex);
free(cmd);
}
static bool test_native_set(struct ConfigSet *cs, struct Buffer *err)
{
log_line(__func__);
struct Address *a = address_new("*****@*****.**");
const char *name = "Ilama";
char *addr = NULL;
bool result = false;
mutt_buffer_reset(err);
int rc = cs_str_native_set(cs, name, (intptr_t) a, err);
if (!TEST_CHECK(CSR_RESULT(rc) == CSR_SUCCESS))
{
TEST_MSG("%s\n", err->data);
goto tbns_out;
}
addr = VarIlama ? VarIlama->mailbox : NULL;
if (!TEST_CHECK(mutt_str_strcmp(addr, a->mailbox) == 0))
{
TEST_MSG("Value of %s wasn't changed\n", name);
goto tbns_out;
}
TEST_MSG("%s = '%s', set by '%s'\n", name, NONULL(addr), a->mailbox);
name = "Jackfruit";
mutt_buffer_reset(err);
rc = cs_str_native_set(cs, name, 0, err);
if (!TEST_CHECK(CSR_RESULT(rc) == CSR_SUCCESS))
{
TEST_MSG("%s\n", err->data);
goto tbns_out;
}
if (!TEST_CHECK(VarJackfruit == NULL))
{
TEST_MSG("Value of %s wasn't changed\n", name);
goto tbns_out;
}
addr = VarJackfruit ? VarJackfruit->mailbox : NULL;
TEST_MSG("%s = '%s', set by NULL\n", name, NONULL(addr));
log_line(__func__);
result = true;
tbns_out:
address_free(&a);
return result;
}
static bool test_validator(struct ConfigSet *cs, struct Buffer *err)
{
log_line(__func__);
char *addr = NULL;
struct Address *a = address_new("*****@*****.**");
bool result = false;
const char *name = "Nectarine";
mutt_buffer_reset(err);
int rc = cs_str_string_set(cs, name, "*****@*****.**", err);
if (TEST_CHECK(CSR_RESULT(rc) == CSR_SUCCESS))
{
TEST_MSG("%s\n", err->data);
}
else
{
TEST_MSG("%s\n", err->data);
goto tv_out;
}
addr = VarNectarine ? VarNectarine->mailbox : NULL;
TEST_MSG("Address: %s = %s\n", name, NONULL(addr));
mutt_buffer_reset(err);
rc = cs_str_native_set(cs, name, IP a, err);
if (TEST_CHECK(CSR_RESULT(rc) == CSR_SUCCESS))
{
TEST_MSG("%s\n", err->data);
}
else
{
TEST_MSG("%s\n", err->data);
goto tv_out;
}
addr = VarNectarine ? VarNectarine->mailbox : NULL;
TEST_MSG("Native: %s = %s\n", name, NONULL(addr));
name = "Olive";
mutt_buffer_reset(err);
rc = cs_str_string_set(cs, name, "*****@*****.**", err);
if (TEST_CHECK(CSR_RESULT(rc) == CSR_SUCCESS))
{
TEST_MSG("%s\n", err->data);
}
else
{
TEST_MSG("%s\n", err->data);
goto tv_out;
}
addr = VarOlive ? VarOlive->mailbox : NULL;
TEST_MSG("Address: %s = %s\n", name, NONULL(addr));
mutt_buffer_reset(err);
rc = cs_str_native_set(cs, name, IP a, err);
if (TEST_CHECK(CSR_RESULT(rc) == CSR_SUCCESS))
{
TEST_MSG("%s\n", err->data);
}
else
{
TEST_MSG("%s\n", err->data);
goto tv_out;
}
addr = VarOlive ? VarOlive->mailbox : NULL;
TEST_MSG("Native: %s = %s\n", name, NONULL(addr));
name = "Papaya";
mutt_buffer_reset(err);
rc = cs_str_string_set(cs, name, "*****@*****.**", err);
if (TEST_CHECK(CSR_RESULT(rc) != CSR_SUCCESS))
{
TEST_MSG("Expected error: %s\n", err->data);
}
else
{
TEST_MSG("%s\n", err->data);
goto tv_out;
}
addr = VarPapaya ? VarPapaya->mailbox : NULL;
TEST_MSG("Address: %s = %s\n", name, NONULL(addr));
mutt_buffer_reset(err);
rc = cs_str_native_set(cs, name, IP a, err);
if (TEST_CHECK(CSR_RESULT(rc) != CSR_SUCCESS))
{
TEST_MSG("Expected error: %s\n", err->data);
}
else
{
TEST_MSG("%s\n", err->data);
goto tv_out;
}
addr = VarPapaya ? VarPapaya->mailbox : NULL;
TEST_MSG("Native: %s = %s\n", name, NONULL(addr));
result = true;
tv_out:
address_free(&a);
log_line(__func__);
return result;
}
static Address *address_parse_simple(Vis *vis, const char **s, enum SamError *err) {
skip_spaces(s);
Address addr = {
.type = **s,
.regex = NULL,
.number = 0,
.left = NULL,
.right = NULL,
};
switch (addr.type) {
case '#': /* character #n */
(*s)++;
addr.number = parse_number(s);
break;
case '0': case '1': case '2': case '3': case '4': /* line n */
case '5': case '6': case '7': case '8': case '9':
addr.type = 'l';
addr.number = parse_number(s);
break;
case '/': /* regexp forwards */
case '?': /* regexp backwards */
addr.regex = parse_regex(vis, s);
if (!addr.regex) {
*err = SAM_ERR_REGEX;
return NULL;
}
break;
case '$': /* end of file */
case '.':
case '+':
case '-':
case '%':
(*s)++;
break;
default:
return NULL;
}
if ((addr.right = address_parse_simple(vis, s, err))) {
switch (addr.right->type) {
case '.':
case '$':
return NULL;
case '#':
case 'l':
case '/':
case '?':
if (addr.type != '+' && addr.type != '-') {
Address *plus = address_new();
if (!plus) {
address_free(addr.right);
return NULL;
}
plus->type = '+';
plus->right = addr.right;
addr.right = plus;
}
break;
}
}
Address *ret = address_new();
if (!ret) {
address_free(addr.right);
return NULL;
}
*ret = addr;
return ret;
}
static Address *address_parse_compound(Vis *vis, const char **s, enum SamError *err) {
Address addr = { 0 }, *left = address_parse_simple(vis, s, err), *right = NULL;
skip_spaces(s);
addr.type = **s;
switch (addr.type) {
case ',': /* a1,a2 */
case ';': /* a1;a2 */
(*s)++;
right = address_parse_compound(vis, s, err);
if (right && (right->type == ',' || right->type == ';') && !right->left) {
*err = SAM_ERR_ADDRESS;
goto fail;
}
break;
default:
return left;
}
addr.left = left;
addr.right = right;
Address *ret = address_new();
if (ret) {
*ret = addr;
return ret;
}
fail:
address_free(left);
address_free(right);
return NULL;
}
