void
add_conversation (address_t * src_address, address_t * dst_address,
guint16 src_port, guint16 dst_port, const gchar * data)
{
conversation_t *conv = NULL;
const gchar *old_data = NULL;
if (!src_address || !dst_address)
{
g_my_critical("NULL ptr in add_conversation");
return;
}
/* Make sure there is not one such conversation */
if ((old_data = find_conversation (src_address, dst_address,
src_port, dst_port)))
{
if (!strcmp (old_data, data))
g_my_critical
("Conflicting conversations %s:%d-%s:%d in add_conversation",
address_to_str (src_address), src_port,
address_to_str (dst_address), dst_port);
else
g_my_debug
("Conversation %s:%d-%s:%d %s already exists in add_conversation",
address_to_str (src_address), src_port,
address_to_str (dst_address), dst_port, data);
return;
}
g_my_debug ("Adding new conversation %s:%d-%s:%d %s",
address_to_str (src_address), src_port,
address_to_str (dst_address), dst_port, data);
conv = g_malloc (sizeof (conversation_t));
g_assert(conv);
address_copy(&conv->src_address, src_address);
address_copy(&conv->dst_address, dst_address);
conv->src_port = src_port;
conv->dst_port = dst_port;
conv->data = g_strdup (data);
conversations = g_list_prepend (conversations, conv);
n_conversations++;
} /* add_conversation */
sock *socket_listen(sock_address *src, int flags)
{
sock *s = (sock *) irc_malloc(sizeof(sock));
memset(s, 0, sizeof(sock));
#ifdef HAVE_SSL
if (flags & SOCKET_SSL)
{
if (ctx == NULL)
{
_socket_free(s);
return NULL;
}
s->sslstate = SSL_IDLE;
}
#endif
s->flags = flags;
if (flags & SOCKET_DGRAM)
{
s->fd = socket(src->addr->sa_family,SOCK_DGRAM,0);
}
else
{
s->fd = socket(src->addr->sa_family,SOCK_STREAM,0);
}
if (s->fd == -1)
{
_socket_free(s);
return NULL;
}
fcntl(s->fd, F_SETFL, O_NONBLOCK);
if (bind(s->fd, src->addr, src->len))
{
close(s->fd);
_socket_free(s);
return NULL;
}
s->laddr = address_copy(src);
if (!(flags & SOCKET_DGRAM))
{
if (listen(s->fd, 100))
{
close(s->fd);
_socket_free(s);
return NULL;
}
}
fds[s->fd] = s;
return s;
}
static int
parse_line(struct evpaxos_config* c, char* line)
{
int rv;
char* tok;
char* sep = " ";
struct option* opt;
line = strtrim(line);
tok = strsep(&line, sep);
if (strcasecmp(tok, "a") == 0 || strcasecmp(tok, "acceptor") == 0) {
if (c->acceptors_count >= MAX_N_OF_PROPOSERS) {
paxos_log_error("Number of acceptors exceded maximum of: %d\n",
MAX_N_OF_PROPOSERS);
return 0;
}
struct address* addr = &c->acceptors[c->acceptors_count++];
return parse_address(line, addr);
}
if (strcasecmp(tok, "p") == 0 || strcasecmp(tok, "proposer") == 0) {
if (c->proposers_count >= MAX_N_OF_PROPOSERS) {
paxos_log_error("Number of proposers exceded maximum of: %d\n",
MAX_N_OF_PROPOSERS);
return 0;
}
struct address* addr = &c->proposers[c->proposers_count++];
return parse_address(line, addr);
}
if (strcasecmp(tok, "l") == 0 || strcasecmp(tok, "learner") == 0) {
if (c->learners_count >= MAX_N_OF_PROPOSERS) {
paxos_log_error("Number of learners exceded maximum of: %d\n",
MAX_N_OF_PROPOSERS);
return 0;
}
struct address* addr = &c->learners[c->learners_count++];
return parse_address(line, addr);
}
if (strcasecmp(tok, "r") == 0 || strcasecmp(tok, "replica") == 0) {
if (c->proposers_count >= MAX_N_OF_PROPOSERS ||
c->acceptors_count >= MAX_N_OF_PROPOSERS ) {
paxos_log_error("Number of replicas exceded maximum of: %d\n",
MAX_N_OF_PROPOSERS);
return 0;
}
struct address* pro_addr = &c->proposers[c->proposers_count++];
struct address* acc_addr = &c->acceptors[c->acceptors_count++];
int rv = parse_address(line, pro_addr);
address_copy(pro_addr, acc_addr);
return rv;
}
line = strtrim(line);
opt = lookup_option(tok);
if (opt == NULL)
return 0;
switch (opt->type) {
case option_boolean:
rv = parse_boolean(line, opt->value);
if (rv == 0) paxos_log_error("Expected 'yes' or 'no'\n");
break;
case option_integer:
rv = parse_integer(line, opt->value);
if (rv == 0) paxos_log_error("Expected number\n");
break;
case option_string:
rv = parse_string(line, opt->value);
if (rv == 0) paxos_log_error("Expected string\n");
break;
case option_verbosity:
rv = parse_verbosity(line, opt->value);
if (rv == 0) paxos_log_error("Expected quiet, error, info, or debug\n");
break;
case option_backend:
rv = parse_backend(line, opt->value);
if (rv == 0) paxos_log_error("Expected memory, bdb or lmdb\n");
break;
case option_bytes:
rv = parse_bytes(line, opt->value);
if (rv == 0) paxos_log_error("Expected number of bytes.\n");
}
return rv;
}
sock *socket_accept(sock *listensock)
{
sock *s;
struct sockaddr_storage ss;
int ss_len = sizeof(ss);
sock_address sa;
int fd = accept(listensock->fd, (struct sockaddr *) &ss, &ss_len);
if (fd < 0)
{
return NULL;
}
fcntl(fd, F_SETFL, O_NONBLOCK);
s = (sock *) irc_malloc(sizeof(sock));
memset(s, 0, sizeof(sock));
s->fd = fd;
s->raddr = (sock_address *) irc_malloc(sizeof(sock_address));
#ifdef AF_INET6
if ((ss.ss_family == AF_INET6) && IN6_IS_ADDR_V4MAPPED(&((struct sockaddr_in6 *) &ss)->sin6_addr))
{
s->raddr->addr = (struct sockaddr *) irc_malloc(sizeof(struct sockaddr_in));
s->raddr->len = sizeof(struct sockaddr_in);
s->raddr->addr->sa_family = AF_INET;
((struct sockaddr_in *) s->raddr->addr)->sin_port = ((struct sockaddr_in6 *) &ss)->sin6_port;
memcpy(&((struct sockaddr_in *) s->raddr->addr)->sin_addr,
&((struct sockaddr_in6 *) &ss)->sin6_addr.s6_addr[12],
sizeof(struct in_addr));
}
else
{
#endif
s->raddr->addr = (struct sockaddr *) irc_malloc(ss_len);
s->raddr->len = ss_len;
memcpy(s->raddr->addr, &ss, ss_len);
#ifdef AF_INET6
}
#endif
if (getsockname(s->fd, (struct sockaddr *) &ss, &ss_len))
{
s->laddr = address_copy(listensock->laddr);
}
else
{
sa.addr = (struct sockaddr *) &ss;
sa.len = ss_len;
s->laddr = address_copy(&sa);
}
fds[s->fd] = s;
#ifdef HAVE_SSL
if (listensock->sslstate == SSL_IDLE)
{
s->ssl = SSL_new(ctx);
SSL_set_fd (s->ssl, s->fd);
s->sslstate = SSL_ACCEPT;
_socket_checkssl(s, SSL_accept(s->ssl));
}
#endif
return s;
}
sock *socket_connect(sock_address *src, sock_address *dst, int flags)
{
sock *s = (sock *) irc_malloc(sizeof(sock));
struct sockaddr_storage ss;
int ss_len = sizeof(ss);
sock_address sa;
memset(s, 0, sizeof(sock));
#ifdef HAVE_SSL
if (flags & SOCKET_SSL)
{
if (ctx == NULL)
{
_socket_free(s);
return NULL;
}
s->sslstate = SSL_CONNECT;
}
#endif
s->flags = flags;
if (flags & SOCKET_DGRAM)
{
s->fd = socket(dst->addr->sa_family,SOCK_DGRAM,0);
}
else
{
s->fd = socket(dst->addr->sa_family,SOCK_STREAM,0);
}
if (s->fd == -1)
{
_socket_free(s);
return NULL;
}
fcntl(s->fd, F_SETFL, O_NONBLOCK);
if (src == NULL)
{
switch (dst->addr->sa_family)
{
case AF_INET:
src = local;
break;
#ifdef AF_INET6
case AF_INET6:
src = local6;
break;
#endif
}
}
if (src != NULL)
{
if (bind(s->fd, src->addr, src->len))
{
close(s->fd);
_socket_free(s);
return NULL;
}
}
if (connect(s->fd, dst->addr, dst->len) && errno != EINPROGRESS)
{
close(s->fd);
_socket_free(s);
return NULL;
}
s->raddr = address_copy(dst);
if (getsockname(s->fd, (struct sockaddr *) &ss, &ss_len))
{
close(s->fd);
_socket_free(s);
return NULL;
}
sa.addr = (struct sockaddr *) &ss;
sa.len = ss_len;
s->laddr = address_copy(&sa);
fds[s->fd] = s;
#ifdef HAVE_SSL
if (s->sslstate == SSL_CONNECT)
{
s->ssl = SSL_new(ctx);
SSL_set_fd (s->ssl, s->fd);
_socket_monitor(s->fd, MONITOR_WRITE);
}
#endif
return s;
}
