p
/
xK
1
1
Fork 0
Code Issues 1 Pull Requests Releases 10 Wiki Activity

Rename `struct connection' to `struct client' 

It is shorter and makes more sense.  Also replaced "conn" with "c"
to keep it even more concise, and thus clearer.
This commit is contained in:
Přemysl Eric Janouch 2014-07-14 20:54:47 +02:00
parent cc4ca46cc3
commit b0cf09fb4c
1 changed files with 144 additions and 148 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

292
src/kike.c
View File

@ -219,11 +219,10 @@ enum
IRC_USER_MODE_RX_SERVER_NOTICES = (1 << 4)
};
// TODO: rename to client?
struct connection
struct client
{
struct connection *next; ///< The next link in a chain
struct connection *prev; ///< The previous link in a chain
struct client *next; ///< The next link in a chain
struct client *prev; ///< The previous link in a chain
struct server_context *ctx; ///< Server context
@ -249,7 +248,7 @@ struct connection
};
static void
connection_init (struct connection *self)
client_init (struct client *self)
{
memset (self, 0, sizeof *self);
@ -259,7 +258,7 @@ connection_init (struct connection *self)
}
static void
connection_free (struct connection *self)
client_free (struct client *self)
{
if (!soft_assert (self->socket_fd == -1))
xclose (self->socket_fd);
@ -351,11 +350,11 @@ struct server_context
struct str_map config; ///< Server configuration
int listen_fd; ///< Listening socket FD
struct connection *clients; ///< Client connections
struct client *clients; ///< Clients
SSL_CTX *ssl_ctx; ///< SSL context
char *server_name; ///< Our server name
struct str_map users; ///< Maps nicknames to connections
struct str_map users; ///< Maps nicknames to clients
struct str_map channels; ///< Maps channel names to data
struct str_map handlers; ///< Message handlers
@ -405,11 +404,11 @@ server_context_free (struct server_context *self)
SSL_CTX_free (self->ssl_ctx);
// TODO: terminate the connections properly before this is called
struct connection *link, *tmp;
struct client *link, *tmp;
for (link = self->clients; link; link = tmp)
{
tmp = link->next;
connection_free (link);
client_free (link);
free (link);
}
@ -436,40 +435,40 @@ enum
};
static void
connection_kill (struct connection *conn, const char *reason)
client_kill (struct client *c, const char *reason)
{
// TODO: multicast a QUIT message with `reason' || "Client exited"
(void) reason;
// TODO: do further cleanup if the client has successfully registered etc.
struct server_context *ctx = conn->ctx;
ssize_t i = poller_find_by_fd (&ctx->poller, conn->socket_fd);
struct server_context *ctx = c->ctx;
ssize_t i = poller_find_by_fd (&ctx->poller, c->socket_fd);
if (i != -1)
poller_remove_at_index (&ctx->poller, i);
xclose (conn->socket_fd);
conn->socket_fd = -1;
connection_free (conn);
LIST_UNLINK (ctx->clients, conn);
free (conn);
xclose (c->socket_fd);
c->socket_fd = -1;
client_free (c);
LIST_UNLINK (ctx->clients, c);
free (c);
}
static void
irc_send_str (struct connection *conn, const struct str *s)
irc_send_str (struct client *c, const struct str *s)
{
// TODO: kill the connection above some "SendQ" threshold (careful!)
str_append_data (&conn->write_buffer, s->str,
str_append_data (&c->write_buffer, s->str,
s->len > IRC_MAX_MESSAGE_LENGTH ? IRC_MAX_MESSAGE_LENGTH : s->len);
str_append (&conn->write_buffer, "\r\n");
str_append (&c->write_buffer, "\r\n");
}
static void irc_send (struct connection *conn,
static void irc_send (struct client *c,
const char *format, ...) ATTRIBUTE_PRINTF (2, 3);
static void
irc_send (struct connection *conn, const char *format, ...)
irc_send (struct client *c, const char *format, ...)
{
struct str tmp;
str_init (&tmp);
@ -479,7 +478,7 @@ irc_send (struct connection *conn, const char *format, ...)
str_append_vprintf (&tmp, format, ap);
va_end (ap);
irc_send_str (conn, &tmp);
irc_send_str (c, &tmp);
str_free (&tmp);
}
@ -541,7 +540,7 @@ static const char *g_default_replies[] =
// XXX: this way we cannot typecheck the arguments, so we must be careful
static void
irc_send_reply (struct connection *conn, int id, ...)
irc_send_reply (struct client *c, int id, ...)
{
struct str tmp;
str_init (&tmp);
@ -549,115 +548,112 @@ irc_send_reply (struct connection *conn, int id, ...)
va_list ap;
va_start (ap, id);
str_append_printf (&tmp, ":%s %03d %s ",
conn->ctx->server_name, id, conn->nickname ? conn->nickname : "");
c->ctx->server_name, id, c->nickname ? c->nickname : "");
str_append_vprintf (&tmp,
irc_get_text (conn->ctx, id, g_default_replies[id]), ap);
irc_get_text (c->ctx, id, g_default_replies[id]), ap);
va_end (ap);
irc_send_str (conn, &tmp);
irc_send_str (c, &tmp);
str_free (&tmp);
}
static void
irc_send_motd (struct connection *conn)
irc_send_motd (struct client *c)
{
struct server_context *ctx = conn->ctx;
struct server_context *ctx = c->ctx;
if (!ctx->motd.len)
{
irc_send_reply (conn, IRC_ERR_NOMOTD);
irc_send_reply (c, IRC_ERR_NOMOTD);
return;
}
irc_send_reply (conn, IRC_RPL_MOTDSTART, ctx->server_name);
irc_send_reply (c, IRC_RPL_MOTDSTART, ctx->server_name);
for (size_t i = 0; i < ctx->motd.len; i++)
irc_send_reply (conn, IRC_RPL_MOTD, ctx->motd.vector[i]);
irc_send_reply (conn, IRC_RPL_ENDOFMOTD);
irc_send_reply (c, IRC_RPL_MOTD, ctx->motd.vector[i]);
irc_send_reply (c, IRC_RPL_ENDOFMOTD);
}
static void
irc_try_finish_registration (struct connection *conn)
irc_try_finish_registration (struct client *c)
{
if (!conn->nickname || !conn->username || !conn->realname)
if (!c->nickname || !c->username || !c->realname)
return;
conn->registered = true;
irc_send_reply (conn, IRC_RPL_WELCOME,
conn->nickname, conn->username, conn->hostname);
c->registered = true;
irc_send_reply (c, IRC_RPL_WELCOME, c->nickname, c->username, c->hostname);
irc_send_reply (conn, IRC_RPL_YOURHOST,
conn->ctx->server_name, PROGRAM_VERSION);
irc_send_reply (c, IRC_RPL_YOURHOST, c->ctx->server_name, PROGRAM_VERSION);
// The purpose of this message eludes me
irc_send_reply (conn, IRC_RPL_CREATED, __DATE__);
irc_send_reply (conn, IRC_RPL_MYINFO,
conn->ctx->server_name, PROGRAM_VERSION,
irc_send_reply (c, IRC_RPL_CREATED, __DATE__);
irc_send_reply (c, IRC_RPL_MYINFO, c->ctx->server_name, PROGRAM_VERSION,
IRC_SUPPORTED_USER_MODES, IRC_SUPPORTED_CHAN_MODES);
// Although not strictly required, bots often need this to work
irc_send_motd (conn);
irc_send_motd (c);
}
static void
irc_handle_pass (const struct irc_message *msg, struct connection *conn)
irc_handle_pass (const struct irc_message *msg, struct client *c)
{
if (conn->registered)
irc_send_reply (conn, IRC_ERR_ALREADYREGISTERED);
if (c->registered)
irc_send_reply (c, IRC_ERR_ALREADYREGISTERED);
else if (msg->params.len < 1)
irc_send_reply (conn, IRC_ERR_NEEDMOREPARAMS, msg->command);
irc_send_reply (c, IRC_ERR_NEEDMOREPARAMS, msg->command);
// We have SSL client certificates for this purpose; ignoring
}
static void
irc_handle_nick (const struct irc_message *msg, struct connection *conn)
irc_handle_nick (const struct irc_message *msg, struct client *c)
{
struct server_context *ctx = conn->ctx;
struct server_context *ctx = c->ctx;
if (conn->registered)
if (c->registered)
{
irc_send_reply (conn, IRC_ERR_ALREADYREGISTERED);
irc_send_reply (c, IRC_ERR_ALREADYREGISTERED);
return;
}
if (msg->params.len < 1)
{
irc_send_reply (conn, IRC_ERR_NONICKNAMEGIVEN);
irc_send_reply (c, IRC_ERR_NONICKNAMEGIVEN);
return;
}
const char *nickname = msg->params.vector[0];
if (irc_validate_nickname (nickname) != VALIDATION_OK)
{
irc_send_reply (conn, IRC_ERR_ERRONEOUSNICKNAME, nickname);
irc_send_reply (c, IRC_ERR_ERRONEOUSNICKNAME, nickname);
return;
}
if (str_map_find (&ctx->users, nickname))
{
irc_send_reply (conn, IRC_ERR_NICKNAMEINUSE, nickname);
irc_send_reply (c, IRC_ERR_NICKNAMEINUSE, nickname);
return;
}
if (conn->nickname)
if (c->nickname)
{
str_map_set (&ctx->users, conn->nickname, NULL);
free (conn->nickname);
str_map_set (&ctx->users, c->nickname, NULL);
free (c->nickname);
}
// Allocate the nickname
conn->nickname = xstrdup (nickname);
str_map_set (&ctx->users, nickname, conn);
c->nickname = xstrdup (nickname);
str_map_set (&ctx->users, nickname, c);
irc_try_finish_registration (conn);
irc_try_finish_registration (c);
}
static void
irc_handle_user (const struct irc_message *msg, struct connection *conn)
irc_handle_user (const struct irc_message *msg, struct client *c)
{
if (conn->registered)
if (c->registered)
{
irc_send_reply (conn, IRC_ERR_ALREADYREGISTERED);
irc_send_reply (c, IRC_ERR_ALREADYREGISTERED);
return;
}
if (msg->params.len < 4)
{
irc_send_reply (conn, IRC_ERR_NEEDMOREPARAMS, msg->command);
irc_send_reply (c, IRC_ERR_NEEDMOREPARAMS, msg->command);
return;
}
@ -669,30 +665,30 @@ irc_handle_user (const struct irc_message *msg, struct connection *conn)
if (!irc_is_valid_user (username))
username = "xxx";
free (conn->username);
conn->username = xstrdup (username);
free (conn->realname);
conn->realname = xstrdup (realname);
free (c->username);
c->username = xstrdup (username);
free (c->realname);
c->realname = xstrdup (realname);
unsigned long m;
if (xstrtoul (&m, mode, 10))
{
if (m & 4) conn->mode |= IRC_USER_MODE_RX_WALLOPS;
if (m & 8) conn->mode |= IRC_USER_MODE_INVISIBLE;
if (m & 4) c->mode |= IRC_USER_MODE_RX_WALLOPS;
if (m & 8) c->mode |= IRC_USER_MODE_INVISIBLE;
}
irc_try_finish_registration (conn);
irc_try_finish_registration (c);
}
static void
irc_handle_ping (const struct irc_message *msg, struct connection *conn)
irc_handle_ping (const struct irc_message *msg, struct client *c)
{
// XXX: the RFC is pretty incomprehensible about the exact usage
if (msg->params.len < 1)
irc_send_reply (conn, IRC_ERR_NOORIGIN);
irc_send_reply (c, IRC_ERR_NOORIGIN);
else
irc_send (conn, ":%s PONG :%s",
conn->ctx->server_name, msg->params.vector[0]);
irc_send (c, ":%s PONG :%s",
c->ctx->server_name, msg->params.vector[0]);
}
// -----------------------------------------------------------------------------
@ -701,7 +697,7 @@ struct irc_command
{
const char *name;
bool requires_registration;
void (*handler) (const struct irc_message *, struct connection *);
void (*handler) (const struct irc_message *, struct client *);
};
static void
@ -730,44 +726,44 @@ irc_process_message (const struct irc_message *msg,
(void) raw;
// XXX: we may want to discard everything following a QUIT etc.
// We can set a flag within the connection object.
// We can set a flag within the client object.
// TODO: see RFC 2812 :!
struct connection *conn = user_data;
struct irc_command *cmd = str_map_find (&conn->ctx->handlers, msg->command);
struct client *c = user_data;
struct irc_command *cmd = str_map_find (&c->ctx->handlers, msg->command);
if (!cmd)
irc_send_reply (conn, IRC_ERR_UNKNOWNCOMMAND,
irc_send_reply (c, IRC_ERR_UNKNOWNCOMMAND,
"%s: Unknown command", msg->command);
else if (cmd->requires_registration && !conn->registered)
irc_send_reply (conn, IRC_ERR_NOTREGISTERED);
else if (cmd->requires_registration && !c->registered)
irc_send_reply (c, IRC_ERR_NOTREGISTERED);
else
cmd->handler (msg, conn);
cmd->handler (msg, c);
}
// --- Network I/O -------------------------------------------------------------
static bool
irc_try_read (struct connection *conn)
irc_try_read (struct client *c)
{
struct str *buf = &conn->read_buffer;
struct str *buf = &c->read_buffer;
ssize_t n_read;
while (true)
{
str_ensure_space (buf, 512);
n_read = recv (conn->socket_fd, buf->str + buf->len,
n_read = recv (c->socket_fd, buf->str + buf->len,
buf->alloc - buf->len - 1 /* null byte */, 0);
if (n_read > 0)
{
buf->str[buf->len += n_read] = '\0';
// TODO: discard characters above the 512 character limit
irc_process_buffer (buf, irc_process_message, conn);
irc_process_buffer (buf, irc_process_message, c);
continue;
}
if (n_read == 0)
{
connection_kill (conn, NULL);
client_kill (c, NULL);
return false;
}
@ -777,60 +773,60 @@ irc_try_read (struct connection *conn)
continue;
print_debug ("%s: %s: %s", __func__, "recv", strerror (errno));
connection_kill (conn, strerror (errno));
client_kill (c, strerror (errno));
return false;
}
}
static bool
irc_try_read_ssl (struct connection *conn)
irc_try_read_ssl (struct client *c)
{
if (conn->ssl_tx_want_rx)
if (c->ssl_tx_want_rx)
return true;
struct str *buf = &conn->read_buffer;
conn->ssl_rx_want_tx = false;
struct str *buf = &c->read_buffer;
c->ssl_rx_want_tx = false;
while (true)
{
str_ensure_space (buf, 512);
int n_read = SSL_read (conn->ssl, buf->str + buf->len,
int n_read = SSL_read (c->ssl, buf->str + buf->len,
buf->alloc - buf->len - 1 /* null byte */);
const char *error_info = NULL;
switch (xssl_get_error (conn->ssl, n_read, &error_info))
switch (xssl_get_error (c->ssl, n_read, &error_info))
{
case SSL_ERROR_NONE:
buf->str[buf->len += n_read] = '\0';
// TODO: discard characters above the 512 character limit
irc_process_buffer (buf, irc_process_message, conn);
irc_process_buffer (buf, irc_process_message, c);
continue;
case SSL_ERROR_ZERO_RETURN:
connection_kill (conn, NULL);
client_kill (c, NULL);
return false;
case SSL_ERROR_WANT_READ:
return true;
case SSL_ERROR_WANT_WRITE:
conn->ssl_rx_want_tx = true;
c->ssl_rx_want_tx = true;
return true;
case XSSL_ERROR_TRY_AGAIN:
continue;
default:
print_debug ("%s: %s: %s", __func__, "SSL_read", error_info);
connection_kill (conn, error_info);
client_kill (c, error_info);
return false;
}
}
}
static bool
irc_try_write (struct connection *conn)
irc_try_write (struct client *c)
{
struct str *buf = &conn->write_buffer;
struct str *buf = &c->write_buffer;
ssize_t n_written;
while (buf->len)
{
n_written = send (conn->socket_fd, buf->str, buf->len, 0);
n_written = send (c->socket_fd, buf->str, buf->len, 0);
if (n_written >= 0)
{
str_remove_slice (buf, 0, n_written);
@ -843,43 +839,43 @@ irc_try_write (struct connection *conn)
continue;
print_debug ("%s: %s: %s", __func__, "send", strerror (errno));
connection_kill (conn, strerror (errno));
client_kill (c, strerror (errno));
return false;
}
return true;
}
static bool
irc_try_write_ssl (struct connection *conn)
irc_try_write_ssl (struct client *c)
{
if (conn->ssl_rx_want_tx)
if (c->ssl_rx_want_tx)
return true;
struct str *buf = &conn->write_buffer;
conn->ssl_tx_want_rx = false;
struct str *buf = &c->write_buffer;
c->ssl_tx_want_rx = false;
while (buf->len)
{
int n_written = SSL_write (conn->ssl, buf->str, buf->len);
int n_written = SSL_write (c->ssl, buf->str, buf->len);
const char *error_info = NULL;
switch (xssl_get_error (conn->ssl, n_written, &error_info))
switch (xssl_get_error (c->ssl, n_written, &error_info))
{
case SSL_ERROR_NONE:
str_remove_slice (buf, 0, n_written);
continue;
case SSL_ERROR_ZERO_RETURN:
connection_kill (conn, NULL);
client_kill (c, NULL);
return false;
case SSL_ERROR_WANT_WRITE:
return true;
case SSL_ERROR_WANT_READ:
conn->ssl_tx_want_rx = true;
c->ssl_tx_want_rx = true;
return true;
case XSSL_ERROR_TRY_AGAIN:
continue;
default:
print_debug ("%s: %s: %s", __func__, "SSL_write", error_info);
connection_kill (conn, error_info);
client_kill (c, error_info);
return false;
}
}
@ -887,7 +883,7 @@ irc_try_write_ssl (struct connection *conn)
}
static bool
irc_autodetect_ssl (struct connection *conn)
irc_autodetect_ssl (struct client *c)
{
// Trivial SSL/TLS autodetection. The first block of data returned by
// recv() must be at least three bytes long for this to work reliably,
@ -903,7 +899,7 @@ irc_autodetect_ssl (struct connection *conn)
char buf[3];
start:
switch (recv (conn->socket_fd, buf, sizeof buf, MSG_PEEK))
switch (recv (c->socket_fd, buf, sizeof buf, MSG_PEEK))
{
case 3:
if ((buf[0] & 0x80) && buf[2] == 1)
@ -926,81 +922,81 @@ start:
}
static bool
connection_initialize_ssl (struct connection *conn)
client_initialize_ssl (struct client *c)
{
// SSL support not enabled
if (!conn->ctx->ssl_ctx)
if (!c->ctx->ssl_ctx)
return false;
conn->ssl = SSL_new (conn->ctx->ssl_ctx);
if (!conn->ssl)
c->ssl = SSL_new (c->ctx->ssl_ctx);
if (!c->ssl)
goto error_ssl_1;
if (!SSL_set_fd (conn->ssl, conn->socket_fd))
if (!SSL_set_fd (c->ssl, c->socket_fd))
goto error_ssl_2;
SSL_set_accept_state (conn->ssl);
SSL_set_accept_state (c->ssl);
return true;
error_ssl_2:
SSL_free (conn->ssl);
conn->ssl = NULL;
SSL_free (c->ssl);
c->ssl = NULL;
error_ssl_1:
// XXX: these error strings are really nasty; also there could be
// multiple errors on the OpenSSL stack.
print_debug ("%s: %s: %s", "could not initialize SSL",
conn->hostname, ERR_error_string (ERR_get_error (), NULL));
c->hostname, ERR_error_string (ERR_get_error (), NULL));
return false;
}
static void
on_irc_client_ready (const struct pollfd *pfd, void *user_data)
{
struct connection *conn = user_data;
if (!conn->initialized)
struct client *c = user_data;
if (!c->initialized)
{
hard_assert (pfd->events == POLLIN);
if (irc_autodetect_ssl (conn) && !connection_initialize_ssl (conn))
if (irc_autodetect_ssl (c) && !client_initialize_ssl (c))
{
connection_kill (conn, NULL);
client_kill (c, NULL);
return;
}
conn->initialized = true;
c->initialized = true;
}
int new_events = 0;
if (conn->ssl)
if (c->ssl)
{
// Reads may want to write, writes may want to read, poll() may
// return unexpected things in `revents'... let's try both
if (!irc_try_read_ssl (conn) || !irc_try_write_ssl (conn))
if (!irc_try_read_ssl (c) || !irc_try_write_ssl (c))
return;
new_events |= POLLIN;
if (conn->write_buffer.len || conn->ssl_rx_want_tx)
if (c->write_buffer.len || c->ssl_rx_want_tx)
new_events |= POLLOUT;
// While we're waiting for an opposite event, we ignore the original
if (conn->ssl_rx_want_tx) new_events &= ~POLLIN;
if (conn->ssl_tx_want_rx) new_events &= ~POLLOUT;
if (c->ssl_rx_want_tx) new_events &= ~POLLIN;
if (c->ssl_tx_want_rx) new_events &= ~POLLOUT;
}
else
{
if (!irc_try_read (conn) || !irc_try_write (conn))
if (!irc_try_read (c) || !irc_try_write (c))
return;
new_events |= POLLIN;
if (conn->write_buffer.len)
if (c->write_buffer.len)
new_events |= POLLOUT;
}
hard_assert (new_events != 0);
if (pfd->events != new_events)
poller_set (&conn->ctx->poller, conn->socket_fd, new_events,
(poller_dispatcher_func) on_irc_client_ready, conn);
poller_set (&c->ctx->poller, c->socket_fd, new_events,
(poller_dispatcher_func) on_irc_client_ready, c);
}
static void
on_irc_connection_available (const struct pollfd *pfd, void *user_data)
on_irc_client_available (const struct pollfd *pfd, void *user_data)
{
(void) pfd;
struct server_context *ctx = user_data;
@ -1038,16 +1034,16 @@ on_irc_connection_available (const struct pollfd *pfd, void *user_data)
print_debug ("%s: %s", "getnameinfo", gai_strerror (err));
print_debug ("accepted connection from %s:%s", host, port);
struct connection *conn = xmalloc (sizeof *conn);
connection_init (conn);
conn->socket_fd = fd;
conn->hostname = xstrdup (host);
LIST_PREPEND (ctx->clients, conn);
struct client *c = xmalloc (sizeof *c);
client_init (c);
c->socket_fd = fd;
c->hostname = xstrdup (host);
LIST_PREPEND (ctx->clients, c);
// TODO: set a timeout on the socket, something like 3 minutes, then we
// should terminate the connection.
poller_set (&ctx->poller, conn->socket_fd, POLLIN,
(poller_dispatcher_func) on_irc_client_ready, conn);
poller_set (&ctx->poller, c->socket_fd, POLLIN,
(poller_dispatcher_func) on_irc_client_ready, c);
}
}
@ -1279,7 +1275,7 @@ irc_listen (struct server_context *ctx, struct error **e)
ctx->listen_fd = sockfd;
poller_set (&ctx->poller, ctx->listen_fd, POLLIN,
(poller_dispatcher_func) on_irc_connection_available, ctx);
(poller_dispatcher_func) on_irc_client_available, ctx);
print_status ("listening at %s:%s", real_host, real_port);
return true;