diff options
| -rw-r--r-- | autistdraw.c | 309 | ||||
| -rw-r--r-- | utils.c | 71 |
2 files changed, 372 insertions, 8 deletions
diff --git a/autistdraw.c b/autistdraw.c index 3938855..3e7b6c4 100644 --- a/autistdraw.c +++ b/autistdraw.c @@ -39,6 +39,22 @@ #define BITMAP_BLOCK_SIZE 50 ///< Step for extending bitmap size +typedef enum network_mode network_mode_t; +enum network_mode +{ + NETWORK_MODE_STANDALONE, ///< No networking taking place + NETWORK_MODE_SERVER, ///< We're the server + NETWORK_MODE_CLIENT ///< We're a client +}; + +typedef struct client client_t; +struct client +{ + LIST_HEADER (client_t) + + uv_tcp_t handle; ///< TCP connection handle +}; + typedef struct app_context app_context_t; struct app_context { @@ -49,6 +65,16 @@ struct app_context uv_timer_t tty_timer; ///< TTY timeout timer uv_signal_t winch_watcher; ///< SIGWINCH watcher + network_mode_t mode; ///< Networking mode + char read_buf[8192]; ///< Global read buffer for libuv + + // Client: + uv_tcp_t server_fd; ///< Connection to the server + + // Server: + uv_tcp_t listen_fd; ///< Listening FD + client_t *clients; ///< Client connections + chtype palette[2 * 9]; ///< Attribute palette uint8_t *bitmap; ///< Canvas data for drawing @@ -79,10 +105,22 @@ app_init (app_context_t *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); +} + +static void app_free (app_context_t *self) { if (self->tk) termo_destroy (self->tk); + while (self->clients) + remove_client (self, self->clients); free (self->bitmap); } @@ -465,7 +503,7 @@ export_irc (app_context_t *app) fclose (fp); } -// ----------------------------------------------------------------------------- +// --- Event handlers ---------------------------------------------------------- static bool on_key (app_context_t *app, termo_key_t *key) @@ -602,14 +640,158 @@ on_tty_readable (uv_poll_t *handle, int status, int events) } static void -parse_program_arguments (app_context_t *app, int argc, char **argv) +app_uv_allocator (uv_handle_t *handle, size_t suggested_size, uv_buf_t *buf) +{ + // Let's just use a single "global" buffer + (void) suggested_size; + + app_context_t *app = handle->loop->data; + buf->base = app->read_buf; + buf->len = sizeof app->read_buf; +} + +static void +on_server_data (uv_stream_t *stream, ssize_t nread, const uv_buf_t *buf) +{ + (void) 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); + + 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; + return; + } + + // TODO: process the data +} + +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) + { + remove_client (app, client); + return; + } + + // TODO: process the data +} + +static void +on_new_client (uv_stream_t *server, int status) +{ + app_context_t *app = server->loop->data; + if (status) + return; + + int err; + client_t *client = xcalloc (1, sizeof *client); + if ((err = uv_tcp_init (server->loop, &client->handle))) + goto free_client; + if ((err = uv_accept (server, (uv_stream_t *) &client->handle)) + || (err = uv_read_start ((uv_stream_t *) &client->handle, + app_uv_allocator, on_client_data))) + // XXX: do we need to un-accept? + goto free_handle; + + client->handle.data = client; + LIST_PREPEND (app->clients, client); + return; + +free_handle: + uv_close ((uv_handle_t *) &client->handle, NULL); + // XXX: should we unref it? +free_client: + free (client); +} + +// --- Program startup --------------------------------------------------------- + +typedef struct app_options app_options_t; +struct app_options +{ + struct addrinfo *client_address; ///< Address to connect to + struct addrinfo *server_address; ///< Address to listen at +}; + +static void +app_options_init (app_options_t *self) { - (void) app; + memset (self, 0, sizeof *self); +} +static void +app_options_free (app_options_t *self) +{ + if (self->client_address) freeaddrinfo (self->client_address); + if (self->server_address) freeaddrinfo (self->server_address); +} + +static struct addrinfo * +parse_address (const char *address, int flags) +{ + char address_copy[strlen (address) + 1]; + strcpy (address_copy, address); + + char *colon = strrchr (address_copy, ':'); + if (!colon) + { + fprintf (stderr, "error: no port number specified in `%s'\n", address); + return false; + } + + char *host = address_copy, *service = colon + 1; + + if (host == colon) + host = NULL; + else if (host < colon && *host == '[' && colon[-1] == ']') + { + // Remove IPv6 RFC 2732-style [] brackets from the host, if present. + // This also makes it possible to take the usage string literally. :)) + host++; + colon[-1] = '\0'; + } + else + *colon = '\0'; + + struct addrinfo *result, hints = + { + .ai_socktype = SOCK_STREAM, + .ai_protocol = IPPROTO_TCP, + .ai_flags = flags, + }; + int err = getaddrinfo (host, service, &hints, &result); + if (err) + { + fprintf (stderr, "error: cannot resolve `%s', port `%s': %s\n", + host, service, gai_strerror (err)); + return false; + } + return result; +} + +static void +parse_program_arguments (app_options_t *options, int argc, char **argv) +{ static const struct opt opts[] = { { 'h', "help", NULL, 0, "display this help and exit" }, { 'V', "version", NULL, 0, "output version information and exit" }, + { 's', "server", "[ADDRESS]:PORT", 0, "start a server" }, + { 'c', "client", "[ADDRESS]:PORT", 0, "connect to a server" }, { 0, NULL, NULL, 0, NULL } }; @@ -627,12 +809,39 @@ parse_program_arguments (app_context_t *app, int argc, char **argv) case 'V': printf (PROJECT_NAME " " PROJECT_VERSION "\n"); exit (EXIT_SUCCESS); + case 's': + if (options->server_address) + { + fprintf (stderr, "%s: %s\n", + "error", "cannot specify multiple listening addresses"); + exit (EXIT_FAILURE); + } + if (!(options->server_address = parse_address (optarg, AI_PASSIVE))) + exit (EXIT_FAILURE); + break; + case 'c': + if (options->client_address) + { + fprintf (stderr, "%s: %s\n", + "error", "cannot specify multiple addresses to connect to"); + exit (EXIT_FAILURE); + } + if (!(options->client_address = parse_address (optarg, 0))) + exit (EXIT_FAILURE); + break; default: - fprintf (stderr, "%s: %s", "error", "wrong options"); + fprintf (stderr, "%s: %s\n", "error", "wrong options"); opt_handler_usage (&oh, stderr); exit (EXIT_FAILURE); } + if (options->client_address && options->server_address) + { + fprintf (stderr, "%s: %s\n", + "error", "cannot be both a server and a client"); + exit (EXIT_FAILURE); + } + argc -= optind; argv += optind; @@ -645,6 +854,77 @@ parse_program_arguments (app_context_t *app, int argc, char **argv) opt_handler_free (&oh); } +static void +initialize_client (app_context_t *app, struct addrinfo *address) +{ + app->mode = NETWORK_MODE_CLIENT; + + int sock_fd, err; + for (; address; address = address->ai_next) + { + sock_fd = socket (address->ai_family, + address->ai_socktype, address->ai_protocol); + if (sock_fd == -1) + continue; + + char host_buf[NI_MAXHOST], serv_buf[NI_MAXSERV]; + err = getnameinfo (address->ai_addr, address->ai_addrlen, + host_buf, sizeof host_buf, serv_buf, sizeof serv_buf, + NI_NUMERICHOST | NI_NUMERICSERV); + if (err) + { + fprintf (stderr, "%s: %s: %s\n", + "error", "getnameinfo", gai_strerror (err)); + fprintf (stderr, "connecting...\n"); + } + else + { + char *x = format_host_port_pair (host_buf, serv_buf); + fprintf (stderr, "connecting to %s...\n", x); + free (x); + } + + if (!connect (sock_fd, address->ai_addr, address->ai_addrlen)) + break; + + xclose (sock_fd); + } + + if (!address) + { + fprintf (stderr, "%s: %s\n", "error", "connection failed"); + exit (EXIT_FAILURE); + } + + set_blocking (sock_fd, false); + if ((err = uv_tcp_init (uv_default_loop (), &app->server_fd)) + || (err = uv_tcp_open (&app->server_fd, sock_fd)) + || (err = uv_tcp_keepalive (&app->server_fd, true, 30)) + || (err = uv_read_start ((uv_stream_t *) &app->server_fd, + app_uv_allocator, on_server_data))) + { + fprintf (stderr, "%s: %s: %s\n", + "error", "initialization failed", uv_strerror (err)); + exit (EXIT_FAILURE); + } +} + +static void +initialize_server (app_context_t *app, struct addrinfo *address) +{ + app->mode = NETWORK_MODE_SERVER; + + int err; + if ((err = uv_tcp_init (uv_default_loop (), &app->listen_fd)) + || (err = uv_tcp_bind (&app->listen_fd, address->ai_addr, 0)) + || (err = uv_listen ((uv_stream_t *) &app->listen_fd, 10, on_new_client))) + { + fprintf (stderr, "%s: %s: %s\n", + "error", "initialization failed", uv_strerror (err)); + exit (EXIT_FAILURE); + } +} + int main (int argc, char *argv[]) { @@ -653,12 +933,25 @@ main (int argc, char *argv[]) app_context_t app; app_init (&app); - parse_program_arguments (&app, argc, argv); + + app_options_t options; + app_options_init (&options); + parse_program_arguments (&options, argc, argv); + + if (options.client_address) + initialize_client (&app, options.client_address); + else if (options.server_address) + initialize_server (&app, options.server_address); + else + app.mode = NETWORK_MODE_STANDALONE; + + app_options_free (&options); termo_t *tk = termo_new (STDIN_FILENO, NULL, 0); if (!tk) { - fprintf (stderr, "Cannot allocate termo instance\n"); + fprintf (stderr, "%s: %s\n", + "error", "cannot allocate termo instance\n"); exit (EXIT_FAILURE); } @@ -669,7 +962,7 @@ main (int argc, char *argv[]) // Set up curses for our drawing needs if (!initscr () || nonl () == ERR || curs_set (0) == ERR) { - fprintf (stderr, "Cannot initialize curses\n"); + fprintf (stderr, "%s: %s\n", "error", "cannot initialize curses"); exit (EXIT_FAILURE); } @@ -694,8 +987,8 @@ main (int argc, char *argv[]) uv_run (loop, UV_RUN_DEFAULT); endwin (); - uv_loop_close (loop); app_free (&app); + uv_loop_close (loop); return 0; } @@ -34,6 +34,9 @@ #define N_ELEMENTS(a) (sizeof (a) / sizeof ((a)[0])) +#define BLOCK_START do { +#define BLOCK_END } while (0) + // --- Safe memory management -------------------------------------------------- // When a memory allocation fails and we need the memory, we're usually pretty @@ -76,6 +79,31 @@ xrealloc (void *o, size_t n) return p; } +// --- Double-linked list helpers ---------------------------------------------- + +#define LIST_HEADER(type) \ + type *next; \ + type *prev; + +#define LIST_PREPEND(head, link) \ + BLOCK_START \ + (link)->prev = NULL; \ + (link)->next = (head); \ + if ((link)->next) \ + (link)->next->prev = (link); \ + (head) = (link); \ + BLOCK_END + +#define LIST_UNLINK(head, link) \ + BLOCK_START \ + if ((link)->prev) \ + (link)->prev->next = (link)->next; \ + else \ + (head) = (link)->next; \ + if ((link)->next) \ + (link)->next->prev = (link)->prev; \ + BLOCK_END + // --- Dynamically allocated strings ------------------------------------------- // Basically a string builder to abstract away manual memory management. @@ -191,6 +219,49 @@ str_append_printf (struct str *self, const char *fmt, ...) // --- Utilities --------------------------------------------------------------- static bool +set_blocking (int fd, bool blocking) +{ + int flags = fcntl (fd, F_GETFL); + bool prev = !(flags & O_NONBLOCK); + if (blocking) + flags &= ~O_NONBLOCK; + else + flags |= O_NONBLOCK; + return prev; +} + +static void +xclose (int fd) +{ + while (close (fd) == -1) + if (errno != EINTR) + break; +} + +static char *xstrdup_printf (const char *, ...) ATTRIBUTE_PRINTF (1, 2); + +static char * +xstrdup_printf (const char *format, ...) +{ + va_list ap; + struct str tmp; + str_init (&tmp); + va_start (ap, format); + str_append_vprintf (&tmp, format, ap); + va_end (ap); + return str_steal (&tmp); +} + +static char * +format_host_port_pair (const char *host, const char *port) +{ + // IPv6 addresses mess with the "colon notation"; let's go with RFC 2732 + if (strchr (host, ':')) + return xstrdup_printf ("[%s]:%s", host, port); + return xstrdup_printf ("%s:%s", host, port); +} + +static bool xstrtoul (unsigned long *out, const char *s, int base) { char *end; |