diff options
| -rw-r--r-- | autistdraw.c | 419 | ||||
| -rw-r--r-- | utils.c | 216 |
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 @@ -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. |