aboutsummaryrefslogtreecommitdiff
diff options
context:
space:
mode:
-rw-r--r--autistdraw.c419
-rw-r--r--utils.c216
2 files changed, 603 insertions, 32 deletions
diff --git a/autistdraw.c b/autistdraw.c
index 3e7b6c4..f6dd2ec 100644
--- a/autistdraw.c
+++ b/autistdraw.c
@@ -34,10 +34,21 @@
#include "config.h"
#include "utils.c"
-#define PALETTE_WIDTH 9 ///< Width of the palette
-#define TOP_BAR_CUTOFF 3 ///< Height of the top bar
+#define PALETTE_WIDTH 9 ///< Width of the palette
+#define TOP_BAR_CUTOFF 3 ///< Height of the top bar
-#define BITMAP_BLOCK_SIZE 50 ///< Step for extending bitmap size
+#define BITMAP_BLOCK_SIZE 50 ///< Step for extending bitmap size
+
+#define PROTOCOL_VERSION 1 ///< Network protocol version
+
+enum
+{
+ MESSAGE_HELLO, ///< Server/client hello
+ MESSAGE_GET_BITMAP, ///< Request bitmap data
+ MESSAGE_PUT_POINT, ///< Request to place a point
+
+ MESSAGE_COUNT ///< Total number of messages
+};
typedef enum network_mode network_mode_t;
enum network_mode
@@ -47,12 +58,20 @@ enum network_mode
NETWORK_MODE_CLIENT ///< We're a client
};
+typedef struct write_req write_req_t;
+struct write_req
+{
+ uv_write_t req; ///< libuv write request
+ uv_buf_t buf; ///< The data to be written
+};
+
typedef struct client client_t;
struct client
{
LIST_HEADER (client_t)
uv_tcp_t handle; ///< TCP connection handle
+ struct msg_reader msg_reader; ///< Client message reader
};
typedef struct app_context app_context_t;
@@ -70,6 +89,7 @@ struct app_context
// Client:
uv_tcp_t server_fd; ///< Connection to the server
+ struct msg_reader msg_reader; ///< Server message reader
// Server:
uv_tcp_t listen_fd; ///< Listening FD
@@ -98,20 +118,14 @@ struct app_context
uint8_t current_color_right; ///< Right mouse button color
};
+static void remove_client (app_context_t *app, client_t *client);
+static void on_server_disconnected (app_context_t *app);
+
static void
app_init (app_context_t *self)
{
memset (self, 0, sizeof *self);
-}
-
-static void
-remove_client (app_context_t *app, client_t *client)
-{
- // TODO: cancel any write requests?
- // XXX: should we unref it?
- uv_close ((uv_handle_t *) &client->handle, NULL);
- LIST_UNLINK (app->clients, client);
- free (client);
+ msg_reader_init (&self->msg_reader);
}
static void
@@ -120,12 +134,151 @@ app_free (app_context_t *self)
if (self->tk)
termo_destroy (self->tk);
while (self->clients)
+ // XXX: we probably shouldn't do this from here
remove_client (self, self->clients);
free (self->bitmap);
+ msg_reader_free (&self->msg_reader);
+}
+
+// --- Server-client messaging -------------------------------------------------
+
+static write_req_t *
+flush_writer (struct msg_writer *writer)
+{
+ size_t len;
+ void *data = msg_writer_flush (writer, &len);
+ write_req_t *req = xcalloc (1, sizeof *req);
+ req->buf = uv_buf_init (data, len);
+ return req;
+}
+
+static void
+on_data_written_to_client (uv_write_t *req, int status)
+{
+ write_req_t *wr = (write_req_t *) req;
+ app_context_t *app = req->handle->loop->data;
+ client_t *client = req->data;
+
+ if (status)
+ // Write failed
+ remove_client (app, client);
+
+ free (wr->buf.base);
+ free (wr);
+}
+
+static void
+flush_writer_to_client (struct msg_writer *writer, client_t *client)
+{
+ write_req_t *wr = flush_writer (writer);
+ wr->req.data = client;
+ (void) uv_write (&wr->req, (uv_stream_t *) &client->handle,
+ &wr->buf, 1, on_data_written_to_client);
+ // XXX: should we put the request on a list so that we can get rid of it?
}
static void
+on_data_written_to_server (uv_write_t *req, int status)
+{
+ write_req_t *wr = (write_req_t *) req;
+ app_context_t *app = req->handle->loop->data;
+
+ if (status)
+ // Write failed
+ on_server_disconnected (app);
+
+ free (wr->buf.base);
+ free (wr);
+}
+
+static void
+flush_writer_to_server (struct msg_writer *writer, app_context_t *app)
+{
+ write_req_t *wr = flush_writer (writer);
+ (void) uv_write (&wr->req, (uv_stream_t *) &app->server_fd,
+ &wr->buf, 1, on_data_written_to_server);
+ // XXX: should we put the request on a list so that we can get rid of it?
+}
+
+static void
+send_draw_point_response (client_t *client, int x, int y, uint8_t color)
+{
+ struct msg_writer writer;
+ msg_writer_init (&writer);
+ msg_writer_u8 (&writer, MESSAGE_PUT_POINT);
+ msg_writer_i32 (&writer, x);
+ msg_writer_i32 (&writer, y);
+ msg_writer_u8 (&writer, color);
+
+ flush_writer_to_client (&writer, client);
+}
+
+static void
+send_draw_point_request (app_context_t *app, int x, int y, uint8_t color)
+{
+ struct msg_writer writer;
+ msg_writer_init (&writer);
+ msg_writer_u8 (&writer, MESSAGE_PUT_POINT);
+ msg_writer_i32 (&writer, x);
+ msg_writer_i32 (&writer, y);
+ msg_writer_u8 (&writer, color);
+
+ flush_writer_to_server (&writer, app);
+}
+
+static void
+send_hello_request (app_context_t *app)
+{
+ struct msg_writer writer;
+ msg_writer_init (&writer);
+ msg_writer_u8 (&writer, MESSAGE_HELLO);
+ msg_writer_u8 (&writer, PROTOCOL_VERSION);
+
+ flush_writer_to_server (&writer, app);
+}
+
+static void
+send_hello_response (client_t *client)
+{
+ struct msg_writer writer;
+ msg_writer_init (&writer);
+ msg_writer_u8 (&writer, MESSAGE_HELLO);
+ msg_writer_u8 (&writer, PROTOCOL_VERSION);
+
+ flush_writer_to_client (&writer, client);
+}
+
+static void
+send_get_bitmap_request (app_context_t *app)
+{
+ struct msg_writer writer;
+ msg_writer_init (&writer);
+ msg_writer_u8 (&writer, MESSAGE_GET_BITMAP);
+
+ flush_writer_to_server (&writer, app);
+}
+
+static void
+send_get_bitmap_response (client_t *client, app_context_t *app)
+{
+ struct msg_writer writer;
+ msg_writer_init (&writer);
+ msg_writer_u8 (&writer, MESSAGE_GET_BITMAP);
+ msg_writer_i32 (&writer, app->bitmap_x);
+ msg_writer_i32 (&writer, app->bitmap_y);
+ msg_writer_u64 (&writer, app->bitmap_w);
+ msg_writer_u64 (&writer, app->bitmap_h);
+
+ msg_writer_blob (&writer, app->bitmap,
+ app->bitmap_w * app->bitmap_h * sizeof *app->bitmap);
+
+ flush_writer_to_client (&writer, client);
+}
+
+// --- Server-client messaging -------------------------------------------------
+
+static void
display (const char *format, ...)
{
va_list ap;
@@ -306,6 +459,11 @@ draw_point (app_context_t *app, int x, int y, uint8_t color)
addch (app->palette[color]);
refresh ();
}
+
+ // Broadcast the clients about the event
+ if (app->mode == NETWORK_MODE_SERVER)
+ for (client_t *iter = app->clients; iter; iter = iter->next)
+ send_draw_point_response (iter, x, y, color);
}
// --- Exports -----------------------------------------------------------------
@@ -538,7 +696,8 @@ on_key (app_context_t *app, termo_key_t *key)
if (event != TERMO_MOUSE_PRESS && event != TERMO_MOUSE_DRAG)
return true;
- if (button == 2)
+ // Middle mouse button, or Ctrl + left mouse button, moves the canvas
+ if (button == 2 || (button == 1 && key->modifiers == TERMO_KEYMOD_CTRL))
{
if (event == TERMO_MOUSE_DRAG)
{
@@ -568,7 +727,12 @@ on_key (app_context_t *app, termo_key_t *key)
int canvas_y = app->corner_y + screen_y - TOP_BAR_CUTOFF;
if (screen_y >= TOP_BAR_CUTOFF)
- draw_point (app, canvas_x, canvas_y, *color);
+ {
+ if (app->mode == NETWORK_MODE_CLIENT)
+ send_draw_point_request (app, canvas_x, canvas_y, *color);
+ else
+ draw_point (app, canvas_x, canvas_y, *color);
+ }
else if (screen_y > 0 && event != TERMO_MOUSE_DRAG)
{
int pair = (float) screen_x / COLS * PALETTE_WIDTH;
@@ -650,44 +814,231 @@ app_uv_allocator (uv_handle_t *handle, size_t suggested_size, uv_buf_t *buf)
buf->len = sizeof app->read_buf;
}
+// --- Client-specific stuff ---------------------------------------------------
+
+typedef void (*server_handler_fn) (app_context_t *, struct msg_unpacker *);
+
static void
-on_server_data (uv_stream_t *stream, ssize_t nread, const uv_buf_t *buf)
+on_server_disconnected (app_context_t *app)
+{
+ // TODO: cancel any write requests?
+ // XXX: should we unref it?
+ uv_close ((uv_handle_t *) &app->server_fd, NULL);
+
+ display ("Disconnected!");
+ beep (); // Beep beep! Made a boo-boo.
+
+ // Let the user save the picture at least.
+ // Also prevents us from trying to use the dead server handle.
+ app->mode = NETWORK_MODE_STANDALONE;
+}
+
+static void
+on_server_hello (app_context_t *app, struct msg_unpacker *unpacker)
+{
+ (void) app;
+
+ uint8_t version;
+ if (!msg_unpacker_u8 (unpacker, &version))
+ return;
+
+ if (version != PROTOCOL_VERSION)
+ // XXX: possibly incompatible version, disconnect?
+ return;
+}
+
+static void
+on_server_get_bitmap (app_context_t *app, struct msg_unpacker *unpacker)
+{
+ int32_t x, y;
+ uint64_t w, h;
+ if (!msg_unpacker_i32 (unpacker, &x)
+ || !msg_unpacker_i32 (unpacker, &y)
+ || !msg_unpacker_u64 (unpacker, &w)
+ || !msg_unpacker_u64 (unpacker, &h))
+ return;
+
+ // TODO: employ at least some RLE encoding
+ size_t size = w * h * sizeof *app->bitmap;
+ if ((h && w > SIZE_MAX / h) || w > SIZE_MAX || h > SIZE_MAX)
+ return;
+
+ const void *data;
+ if (!msg_unpacker_blob (unpacker, &data, size))
+ return;
+
+ free (app->bitmap);
+ app->bitmap = memcpy (xcalloc (1, size), data, size);
+ app->bitmap_x = x;
+ app->bitmap_y = y;
+ app->bitmap_w = w;
+ app->bitmap_h = h;
+
+ redraw_canvas (app);
+}
+
+static void
+on_server_put_point (app_context_t *app, struct msg_unpacker *unpacker)
{
- (void) buf;
+ int32_t x, y;
+ uint8_t color;
+
+ if (!msg_unpacker_i32 (unpacker, &x)
+ || !msg_unpacker_i32 (unpacker, &y)
+ || !msg_unpacker_u8 (unpacker, &color))
+ return;
+ draw_point (app, x, y, color);
+}
+
+static void
+on_server_data (uv_stream_t *stream, ssize_t nread, const uv_buf_t *buf)
+{
app_context_t *app = stream->loop->data;
if (nread == UV_EOF || nread < 0)
{
- // TODO: cancel any write requests?
- // XXX: should we unref it?
- uv_close ((uv_handle_t *) &app->server_fd, NULL);
+ on_server_disconnected (app);
+ return;
+ }
- display ("Disconnected!");
- beep (); // Beep beep! Made a boo-boo.
+ msg_reader_feed (&app->msg_reader, buf->base, nread);
- // Let the user save the picture at least.
- // Also prevents us from trying to use the dead server handle.
- app->mode = NETWORK_MODE_STANDALONE;
- return;
+ static const server_handler_fn handlers[MESSAGE_COUNT] =
+ {
+ [MESSAGE_HELLO] = on_server_hello,
+ [MESSAGE_GET_BITMAP] = on_server_get_bitmap,
+ [MESSAGE_PUT_POINT] = on_server_put_point,
+ };
+
+ void *msg;
+ size_t len;
+ while ((msg = msg_reader_get (&app->msg_reader, &len)))
+ {
+ struct msg_unpacker unpacker;
+ msg_unpacker_init (&unpacker, msg, len);
+
+ uint8_t type;
+ if (!msg_unpacker_u8 (&unpacker, &type)
+ || type >= MESSAGE_COUNT)
+ // XXX: unknown message, disconnect?
+ continue;
+
+ server_handler_fn handler = handlers[type];
+ if (!handler)
+ // XXX: unknown message, disconnect?
+ continue;
+
+ handler (app, &unpacker);
+
+ if (msg_unpacker_get_available (&unpacker) > 0)
+ // XXX: overlong message, disconnect?
+ continue;
}
+}
+
+// --- Server-specific stuff ---------------------------------------------------
+
+typedef bool (*client_handler_fn)
+ (app_context_t *, client_t *, struct msg_unpacker *);
+
+static void
+remove_client (app_context_t *app, client_t *client)
+{
+ // TODO: cancel any write requests?
+ // XXX: should we unref it?
+ uv_close ((uv_handle_t *) &client->handle, NULL);
+ LIST_UNLINK (app->clients, client);
+ msg_reader_free (&client->msg_reader);
+ free (client);
+}
+
+static bool
+on_client_hello (app_context_t *app, client_t *client,
+ struct msg_unpacker *unpacker)
+{
+ (void) app;
- // TODO: process the data
+ uint8_t version;
+ if (!msg_unpacker_u8 (unpacker, &version)
+ || version != PROTOCOL_VERSION)
+ // Nope, I don't like you
+ return false;
+
+ send_hello_response (client);
+ return true;
+}
+
+static bool
+on_client_get_bitmap (app_context_t *app, client_t *client,
+ struct msg_unpacker *unpacker)
+{
+ (void) unpacker;
+
+ send_get_bitmap_response (client, app);
+ return true;
+}
+
+static bool
+on_client_put_point (app_context_t *app, client_t *client,
+ struct msg_unpacker *unpacker)
+{
+ (void) client;
+
+ int32_t x, y;
+ uint8_t color;
+ if (!msg_unpacker_i32 (unpacker, &x)
+ || !msg_unpacker_i32 (unpacker, &y)
+ || !msg_unpacker_u8 (unpacker, &color))
+ return false;
+
+ // The function takes care of broadcasting to all the other clients,
+ // as well as back to the original sender
+ draw_point (app, x, y, color);
+ return true;
}
static void
on_client_data (uv_stream_t *stream, ssize_t nread, const uv_buf_t *buf)
{
- (void) buf;
-
app_context_t *app = stream->loop->data;
client_t *client = stream->data;
if (nread == UV_EOF || nread < 0)
+ goto disconnect; // Connection closed or error
+
+ msg_reader_feed (&client->msg_reader, buf->base, nread);
+
+ static const client_handler_fn handlers[MESSAGE_COUNT] =
{
- remove_client (app, client);
- return;
+ [MESSAGE_HELLO] = on_client_hello,
+ [MESSAGE_GET_BITMAP] = on_client_get_bitmap,
+ [MESSAGE_PUT_POINT] = on_client_put_point,
+ };
+
+ void *msg;
+ size_t len;
+ while ((msg = msg_reader_get (&client->msg_reader, &len)))
+ {
+ struct msg_unpacker unpacker;
+ msg_unpacker_init (&unpacker, msg, len);
+
+ uint8_t type;
+ if (!msg_unpacker_u8 (&unpacker, &type))
+ goto disconnect; // Invalid message
+ if (type >= MESSAGE_COUNT)
+ goto disconnect; // Unknown message
+
+ client_handler_fn handler = handlers[type];
+ if (!handler)
+ goto disconnect; // Unknown message
+ if (!handler (app, client, &unpacker))
+ goto disconnect; // Invalid message
+ if (msg_unpacker_get_available (&unpacker) > 0)
+ goto disconnect; // Overlong message data
}
+ return;
- // TODO: process the data
+disconnect:
+ remove_client (app, client);
}
static void
@@ -708,6 +1059,7 @@ on_new_client (uv_stream_t *server, int status)
goto free_handle;
client->handle.data = client;
+ msg_reader_init (&client->msg_reader);
LIST_PREPEND (app->clients, client);
return;
@@ -907,6 +1259,9 @@ initialize_client (app_context_t *app, struct addrinfo *address)
"error", "initialization failed", uv_strerror (err));
exit (EXIT_FAILURE);
}
+
+ send_hello_request (app);
+ send_get_bitmap_request (app);
}
static void
diff --git a/utils.c b/utils.c
index e1580e0..f7c8fad 100644
--- a/utils.c
+++ b/utils.c
@@ -216,6 +216,20 @@ str_append_printf (struct str *self, const char *fmt, ...)
return size;
}
+static void
+str_remove_slice (struct str *self, size_t start, size_t length)
+{
+ size_t end = start + length;
+ if (end > self->len)
+ end = self->len;
+ memmove (self->str + start, self->str + end, self->len - end);
+ self->str[self->len -= length] = '\0';
+
+ // Shrink the string if the allocation becomes way too large
+ if (self->alloc >= STR_SHRINK_THRESHOLD && self->len < (self->alloc >> 2))
+ self->str = xrealloc (self->str, self->alloc >>= 2);
+}
+
// --- Utilities ---------------------------------------------------------------
static bool
@@ -270,6 +284,208 @@ xstrtoul (unsigned long *out, const char *s, int base)
return errno == 0 && !*end && end != s;
}
+// --- Message reader ----------------------------------------------------------
+
+struct msg_reader
+{
+ struct str buf; ///< Input buffer
+ uint64_t offset; ///< Current offset in the buffer
+};
+
+static void
+msg_reader_init (struct msg_reader *self)
+{
+ str_init (&self->buf);
+ self->offset = 0;
+}
+
+static void
+msg_reader_free (struct msg_reader *self)
+{
+ str_free (&self->buf);
+}
+
+static void
+msg_reader_compact (struct msg_reader *self)
+{
+ str_remove_slice (&self->buf, 0, self->offset);
+ self->offset = 0;
+}
+
+static void
+msg_reader_feed (struct msg_reader *self, const void *data, size_t len)
+{
+ // TODO: have some mechanism to prevent flooding
+ msg_reader_compact (self);
+ str_append_data (&self->buf, data, len);
+}
+
+static void *
+msg_reader_get (struct msg_reader *self, size_t *len)
+{
+ // Try to read in the length of the message
+ if (self->offset + sizeof (uint64_t) > self->buf.len)
+ return NULL;
+
+ uint8_t *x = (uint8_t *) self->buf.str + self->offset;
+ uint64_t msg_len
+ = (uint64_t) x[0] << 56 | (uint64_t) x[1] << 48
+ | (uint64_t) x[2] << 40 | (uint64_t) x[3] << 32
+ | (uint64_t) x[4] << 24 | (uint64_t) x[5] << 16
+ | (uint64_t) x[6] << 8 | (uint64_t) x[7];
+
+ if (msg_len < sizeof msg_len)
+ {
+ // The message is shorter than its header
+ // TODO: have some mechanism to report errors
+ return NULL;
+ }
+
+ if (self->offset + msg_len < self->offset)
+ {
+ // Trying to read an insane amount of data but whatever
+ msg_reader_compact (self);
+ return NULL;
+ }
+
+ // Check if we've got the full message in the buffer and return it
+ if (self->offset + msg_len > self->buf.len)
+ return NULL;
+
+ // We have to subtract the header from the reported length
+ void *data = self->buf.str + self->offset + sizeof msg_len;
+ self->offset += msg_len;
+ *len = msg_len - sizeof msg_len;
+ return data;
+}
+
+// --- Message unpacker --------------------------------------------------------
+
+struct msg_unpacker
+{
+ const char *data;
+ size_t offset;
+ size_t len;
+};
+
+static void
+msg_unpacker_init (struct msg_unpacker *self, const void *data, size_t len)
+{
+ self->data = data;
+ self->len = len;
+ self->offset = 0;
+}
+
+static size_t
+msg_unpacker_get_available (struct msg_unpacker *self)
+{
+ return self->len - self->offset;
+}
+
+static bool
+msg_unpacker_blob (struct msg_unpacker *self, const void **data, size_t len)
+{
+ if (self->len - self->offset < len)
+ return false;
+ *data = self->data + self->offset;
+ self->offset += len;
+ return true;
+}
+
+#define UNPACKER_INT_BEGIN \
+ if (self->len - self->offset < sizeof *value) \
+ return false; \
+ uint8_t *x = (uint8_t *) self->data + self->offset; \
+ self->offset += sizeof *value;
+
+static bool
+msg_unpacker_u8 (struct msg_unpacker *self, uint8_t *value)
+{
+ UNPACKER_INT_BEGIN
+ *value = x[0];
+ return true;
+}
+
+static bool
+msg_unpacker_i32 (struct msg_unpacker *self, int32_t *value)
+{
+ UNPACKER_INT_BEGIN
+ *value
+ = (uint32_t) x[0] << 24 | (uint32_t) x[1] << 16
+ | (uint32_t) x[2] << 8 | (uint32_t) x[3];
+ return true;
+}
+
+static bool
+msg_unpacker_u64 (struct msg_unpacker *self, uint64_t *value)
+{
+ UNPACKER_INT_BEGIN
+ *value
+ = (uint64_t) x[0] << 56 | (uint64_t) x[1] << 48
+ | (uint64_t) x[2] << 40 | (uint64_t) x[3] << 32
+ | (uint64_t) x[4] << 24 | (uint64_t) x[5] << 16
+ | (uint64_t) x[6] << 8 | (uint64_t) x[7];
+ return true;
+}
+
+#undef UNPACKER_INT_BEGIN
+
+// --- Message packer and writer -----------------------------------------------
+
+struct msg_writer
+{
+ struct str buf; ///< Holds the message data
+};
+
+static void
+msg_writer_init (struct msg_writer *self)
+{
+ str_init (&self->buf);
+ // Placeholder for message length
+ str_append_data (&self->buf, "\x00\x00\x00\x00" "\x00\x00\x00\x00", 8);
+}
+
+static void
+msg_writer_blob (struct msg_writer *self, const void *data, size_t len)
+{
+ str_append_data (&self->buf, data, len);
+}
+
+static void
+msg_writer_u8 (struct msg_writer *self, uint8_t x)
+{
+ str_append_data (&self->buf, &x, 1);
+}
+
+static void
+msg_writer_i32 (struct msg_writer *self, int32_t x)
+{
+ uint32_t u = x;
+ uint8_t tmp[4] = { u >> 24, u >> 16, u >> 8, u };
+ str_append_data (&self->buf, tmp, sizeof tmp);
+}
+
+static void
+msg_writer_u64 (struct msg_writer *self, uint64_t x)
+{
+ uint8_t tmp[8] =
+ { x >> 56, x >> 48, x >> 40, x >> 32, x >> 24, x >> 16, x >> 8, x };
+ str_append_data (&self->buf, tmp, sizeof tmp);
+}
+
+static void *
+msg_writer_flush (struct msg_writer *self, size_t *len)
+{
+ // Update the message length
+ uint64_t x = self->buf.len;
+ uint8_t tmp[8] =
+ { x >> 56, x >> 48, x >> 40, x >> 32, x >> 24, x >> 16, x >> 8, x };
+ memcpy (self->buf.str, tmp, sizeof tmp);
+
+ *len = x;
+ return str_steal (&self->buf);
+}
+
// --- Option handler ----------------------------------------------------------
// Simple wrapper for the getopt_long API to make it easier to use and maintain.