diff options
| -rw-r--r-- | CMakeLists.txt | 34 | ||||
| -rw-r--r-- | NEWS | 12 | ||||
| -rw-r--r-- | README.adoc | 36 | ||||
| -rw-r--r-- | common.c | 71 | ||||
| -rw-r--r-- | xC-gen-proto-c.awk | 325 | ||||
| -rw-r--r-- | xC-gen-proto-go.awk | 447 | ||||
| -rw-r--r-- | xC-gen-proto.awk | 303 | ||||
| -rw-r--r-- | xC-proto | 120 | ||||
| -rw-r--r-- | xC.c | 785 | ||||
| -rw-r--r-- | xD.c | 39 | ||||
| -rw-r--r-- | xF.c | 172 | ||||
| -rw-r--r-- | xF.svg | 36 | ||||
| -rw-r--r-- | xP/.gitignore | 3 | ||||
| -rw-r--r-- | xP/Makefile | 14 | ||||
| -rw-r--r-- | xP/go.mod | 5 | ||||
| -rw-r--r-- | xP/go.sum | 2 | ||||
| -rw-r--r-- | xP/public/xP.css | 109 | ||||
| -rw-r--r-- | xP/public/xP.js | 188 | ||||
| -rw-r--r-- | xP/xP.example.json | 2 | ||||
| -rw-r--r-- | xP/xP.go | 186 |
20 files changed, 2798 insertions, 91 deletions
diff --git a/CMakeLists.txt b/CMakeLists.txt index 4de1ad2..f678592 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -1,10 +1,12 @@ # Ubuntu 18.04 LTS and OpenBSD 6.4 cmake_minimum_required (VERSION 3.10) -project (xK VERSION 1.5.0 DESCRIPTION "IRC client, daemon and bot" LANGUAGES C) +project (xK VERSION 1.5.0 + DESCRIPTION "IRC daemon, bot, TUI client and X11/web frontends" LANGUAGES C) # Options option (WANT_READLINE "Use GNU Readline for the UI (better)" ON) option (WANT_LIBEDIT "Use BSD libedit for the UI" OFF) +option (WANT_XF "Build xF" OFF) # Moar warnings set (CMAKE_C_STANDARD 99) @@ -143,7 +145,8 @@ set (HAVE_EDITLINE "${WANT_LIBEDIT}") set (HAVE_LUA "${WITH_LUA}") include (GNUInstallDirs) -configure_file (${PROJECT_SOURCE_DIR}/config.h.in ${PROJECT_BINARY_DIR}/config.h) +set (project_config ${PROJECT_BINARY_DIR}/config.h) +configure_file (${PROJECT_SOURCE_DIR}/config.h.in ${project_config}) include_directories (${PROJECT_SOURCE_DIR} ${PROJECT_BINARY_DIR}) # Generate IRC replies--we need a custom target because of the multiple outputs @@ -157,17 +160,40 @@ add_custom_command (OUTPUT xD-replies.c xD.msg COMMENT "Generating files from the list of server numerics") add_custom_target (replies DEPENDS ${PROJECT_BINARY_DIR}/xD-replies.c) +add_custom_command (OUTPUT xC-proto.c + COMMAND env LC_ALL=C awk + -f ${PROJECT_SOURCE_DIR}/xC-gen-proto.awk + -f ${PROJECT_SOURCE_DIR}/xC-gen-proto-c.awk + ${PROJECT_SOURCE_DIR}/xC-proto > xC-proto.c + DEPENDS + ${PROJECT_SOURCE_DIR}/xC-gen-proto.awk + ${PROJECT_SOURCE_DIR}/xC-gen-proto-c.awk + ${PROJECT_SOURCE_DIR}/xC-proto + COMMENT "Generating xC relay protocol code") +add_custom_target (xC-proto DEPENDS ${PROJECT_BINARY_DIR}/xC-proto.c) + # Build foreach (name xB xC xD) - add_executable (${name} ${name}.c ${PROJECT_BINARY_DIR}/config.h) + add_executable (${name} ${name}.c ${project_config}) target_link_libraries (${name} ${project_libraries}) add_threads (${name}) endforeach () add_dependencies (xD replies) -add_dependencies (xC replies) +add_dependencies (xC replies xC-proto) target_link_libraries (xC ${xC_libraries}) +if (WANT_XF) + pkg_check_modules (x11 REQUIRED x11 xrender xft fontconfig) + include_directories (${x11_INCLUDE_DIRS}) + link_directories (${x11_LIBRARY_DIRS}) + + add_executable (xF xF.c ${project_config}) + add_dependencies (xF xC-proto) + target_link_libraries (xF ${x11_LIBRARIES} ${project_libraries}) + add_threads (xF) +endif () + # Tests include (CTest) if (BUILD_TESTING) @@ -1,5 +1,9 @@ Unreleased + * xD: implemented WALLOPS, choosing to make it target even non-operators + + * xC: made it show WALLOPS messages, as PRIVMSG for the server buffer + * xC: all behaviour.* configuration options have been renamed to general.*, with the exception of editor_command/editor, backlog_helper/pager, and backlog_helper_strip_formatting/pager_strip_formatting @@ -10,11 +14,13 @@ Unreleased * xC: normalized editline's history behaviour, making it a viable frontend - * xC: made it show WALLOPS messages, as PRIVMSG for the server buffer - * xC: various bugfixes - * xD: implemented WALLOPS, choosing to make it target even non-operators + * xC: added a relay interface, enabled through the general.relay_bind option + + * Added an experimental X11 frontend for xC called xF + + * Added an experimental web frontend for xC called xP 1.5.0 (2021-12-21) "The Show Must Go On" diff --git a/README.adoc b/README.adoc index 11eb609..559c69d 100644 --- a/README.adoc +++ b/README.adoc @@ -1,9 +1,9 @@ xK == -'xK' (chat kit) is an IRC software suite consisting of a terminal client, -daemon, and bot. It's all you're ever going to need for chatting, -so long as you can make do with slightly minimalist software. +'xK' (chat kit) is an IRC software suite consisting of a daemon, bot, terminal +client, and X11/web frontends for the client. It's all you're ever going to +need for chatting, so long as you can make do with slightly minimalist software. They're all lean on dependencies, and offer a maximally permissive licence. @@ -20,8 +20,18 @@ a powerful configuration system, integrated help, text formatting, automatic message splitting, multiline editing, bracketed paste support, word wrapping that doesn't break links, autocomplete, logging, CTCP queries, auto-away, command aliases, SOCKS proxying, SASL EXTERNAL authentication using TLS client -certificates, or basic support for Lua scripting. As a unique bonus, you can -launch a full text editor from within. +certificates, a remote relay interface, or basic support for Lua scripting. +As a unique bonus, you can launch a full text editor from within. + +xF +-- +The X11 frontend for 'xC', making use of its networked relay interface. +It's currently in development, and is hidden behind a CMake option. + +xP +-- +The web frontend for 'xC', making use of its networked relay interface. +It's currently rather elementary, and can be built from within its directory. xD -- @@ -38,9 +48,8 @@ What it notably doesn't support is online changes to configuration, any limits besides the total number of connections and mode `+l`, or server linking (which also means no services). -This program has been -https://git.janouch.name/p/haven/src/branch/master/hid[ported to Go], -and development continues over there. +This program has been https://git.janouch.name/p/haven/src/branch/master/hid[ +ported to Go] in a different project, and development continues over there. xB -- @@ -60,11 +69,12 @@ a package with the latest development version from Archlinux's AUR. Building -------- -Build dependencies: CMake, pkg-config, asciidoctor or asciidoc, awk, - liberty (included) + -Runtime dependencies: openssl + -Additionally for 'xC': curses, libffi, lua >= 5.3 (optional), - readline >= 6.0 or libedit >= 2013-07-12 +Build-only dependencies: + CMake, pkg-config, asciidoctor or asciidoc, awk, liberty (included) + +Common runtime dependencies: openssl + +Additionally for 'xC': curses, libffi, + + readline >= 6.0 or libedit >= 2013-07-12, lua >= 5.3 (optional) + +Additionally for 'xF': x11, xft $ git clone --recursive https://git.janouch.name/p/xK.git $ mkdir xK/build @@ -1,7 +1,7 @@ /* * common.c: common functionality * - * Copyright (c) 2014 - 2020, Přemysl Eric Janouch <p@janouch.name> + * Copyright (c) 2014 - 2022, Přemysl Eric Janouch <p@janouch.name> * * Permission to use, copy, modify, and/or distribute this software for any * purpose with or without fee is hereby granted. @@ -48,6 +48,66 @@ init_openssl (void) #endif } +static char * +gai_reconstruct_address (struct addrinfo *ai) +{ + char host[NI_MAXHOST] = {}, port[NI_MAXSERV] = {}; + int err = getnameinfo (ai->ai_addr, ai->ai_addrlen, + host, sizeof host, port, sizeof port, + NI_NUMERICHOST | NI_NUMERICSERV); + if (err) + { + print_debug ("%s: %s", "getnameinfo", gai_strerror (err)); + return xstrdup ("?"); + } + return format_host_port_pair (host, port); +} + +static bool +accept_error_is_transient (int err) +{ + // OS kernels may return a wide range of unforeseeable errors. + // Assuming that they're either transient or caused by + // a connection that we've just extracted from the queue. + switch (err) + { + case EBADF: + case EINVAL: + case ENOTSOCK: + case EOPNOTSUPP: + return false; + default: + return true; + } +} + +/// Destructively tokenize an address into a host part, and a port part. +/// The port is only overwritten if that part is found, allowing for defaults. +static const char * +tokenize_host_port (char *address, const char **port) +{ + // Unwrap IPv6 addresses in format_host_port_pair() format. + char *rbracket = strchr (address, ']'); + if (*address == '[' && rbracket) + { + if (rbracket[1] == ':') + { + *port = rbracket + 2; + return *rbracket = 0, address + 1; + } + if (!rbracket[1]) + return *rbracket = 0, address + 1; + } + + char *colon = strchr (address, ':'); + if (colon) + { + *port = colon + 1; + return *colon = 0, address; + } + return address; +} + // --- To be moved to liberty -------------------------------------------------- // FIXME: in xssl_get_error() we rely on error reasons never being NULL (i.e., @@ -74,6 +134,15 @@ xerr_describe_error (void) return reason; } +static struct str +str_from_cstr (const char *cstr) +{ + struct str self; + self.alloc = (self.len = strlen (cstr)) + 1; + self.str = memcpy (xmalloc (self.alloc), cstr, self.alloc); + return self; +} + static ssize_t strv_find (const struct strv *v, const char *s) { diff --git a/xC-gen-proto-c.awk b/xC-gen-proto-c.awk new file mode 100644 index 0000000..e7faef0 --- /dev/null +++ b/xC-gen-proto-c.awk @@ -0,0 +1,325 @@ +# xC-gen-proto-c.awk: C backend for xC-gen-proto.awk. +# +# Copyright (c) 2022, Přemysl Eric Janouch <p@janouch.name> +# SPDX-License-Identifier: 0BSD +# +# Neither *_new() nor *_destroy() functions are provided, because they'd only +# be useful for top-levels, and are merely extra malloc()/free() calls. +# Users are expected to reuse buffers. +# +# Similarly, no constructors are produced--those are easy to write manually. +# +# All arrays are deserialized zero-terminated, so u8<> and i8<> can be directly +# used as C strings. +# +# All types must be able to dispose partially zero values going from the back, +# i.e., in the reverse order of deserialization. + +function define_internal(name, ctype) { + Types[name] = "internal" + CodegenCType[name] = ctype +} + +function define_int(shortname, ctype) { + define_internal(shortname, ctype) + CodegenSerialize[shortname] = \ + "\tstr_pack_" shortname "(w, %s);\n" + CodegenDeserialize[shortname] = \ + "\tif (!msg_unpacker_" shortname "(r, &%s))\n" \ + "\t\treturn false;\n" +} + +function define_sint(size) { define_int("i" size, "int" size "_t") } +function define_uint(size) { define_int("u" size, "uint" size "_t") } + +function codegen_begin() { + define_sint("8") + define_sint("16") + define_sint("32") + define_sint("64") + define_uint("8") + define_uint("16") + define_uint("32") + define_uint("64") + + define_internal("string", "struct str") + CodegenDispose["string"] = "\tstr_free(&%s);\n" + CodegenSerialize["string"] = \ + "\tif (!proto_string_serialize(&%s, w))\n" \ + "\t\treturn false;\n" + CodegenDeserialize["string"] = \ + "\tif (!proto_string_deserialize(&%s, r))\n" \ + "\t\treturn false;\n" + + define_internal("bool", "bool") + CodegenSerialize["bool"] = \ + "\tstr_pack_u8(w, !!%s);\n" + CodegenDeserialize["bool"] = \ + "\t{\n" \ + "\t\tuint8_t v = 0;\n" \ + "\t\tif (!msg_unpacker_u8(r, &v))\n" \ + "\t\t\treturn false;\n" \ + "\t\t%s = !!v;\n" \ + "\t}\n" + + print "// This file directly depends on liberty.c, but doesn't include it." + + print "" + print "static bool" + print "proto_string_serialize(const struct str *s, struct str *w) {" + print "\tif (s->len > UINT32_MAX)" + print "\t\treturn false;" + print "\tstr_pack_u32(w, s->len);" + print "\tstr_append_str(w, s);" + print "\treturn true;" + print "}" + + print "" + print "static bool" + print "proto_string_deserialize(struct str *s, struct msg_unpacker *r) {" + print "\tuint32_t len = 0;" + print "\tif (!msg_unpacker_u32(r, &len))" + print "\t\treturn false;" + print "\tif (msg_unpacker_get_available(r) < len)" + print "\t\treturn false;" + print "\t*s = str_make();" + print "\tstr_append_data(s, r->data + r->offset, len);" + print "\tr->offset += len;" + print "\tif (!utf8_validate (s->str, s->len))" + print "\t\treturn false;" + print "\treturn true;" + print "}" +} + +function codegen_constant(name, value) { + print "" + print "enum { " PrefixUpper name " = " value " };" +} + +function codegen_enum_value(name, subname, value, cg) { + append(cg, "fields", + "\t" PrefixUpper toupper(cameltosnake(name)) "_" subname \ + " = " value ",\n") +} + +function codegen_enum(name, cg, ctype) { + ctype = "enum " PrefixLower cameltosnake(name) + print "" + print ctype " {" + print cg["fields"] "};" + + # XXX: This should also check if it isn't out-of-range for any reason, + # but our usage of sprintf() stands in the way a bit. + CodegenSerialize[name] = "\tstr_pack_i32(w, %s);\n" + CodegenDeserialize[name] = \ + "\t{\n" \ + "\t\tint32_t v = 0;\n" \ + "\t\tif (!msg_unpacker_i32(r, &v) || !v)\n" \ + "\t\t\treturn false;\n" \ + "\t\t%s = v;\n" \ + "\t}\n" + + CodegenCType[name] = ctype + for (i in cg) + delete cg[i] +} + +function codegen_struct_tag(d, cg, f) { + f = "self->" d["name"] + append(cg, "fields", "\t" CodegenCType[d["type"]] " " d["name"] ";\n") + append(cg, "dispose", sprintf(CodegenDispose[d["type"]], f)) + append(cg, "serialize", sprintf(CodegenSerialize[d["type"]], f)) + # Do not deserialize here, that would be out of order. +} + +function codegen_struct_field(d, cg, f, dispose, serialize, deserialize) { + f = "self->" d["name"] + dispose = CodegenDispose[d["type"]] + serialize = CodegenSerialize[d["type"]] + deserialize = CodegenDeserialize[d["type"]] + if (!d["isarray"]) { + append(cg, "fields", "\t" CodegenCType[d["type"]] " " d["name"] ";\n") + append(cg, "dispose", sprintf(dispose, f)) + append(cg, "serialize", sprintf(serialize, f)) + append(cg, "deserialize", sprintf(deserialize, f)) + return + } + + append(cg, "fields", + "\t" CodegenCType["u32"] " " d["name"] "_len;\n" \ + "\t" CodegenCType[d["type"]] " *" d["name"] ";\n") + + if (dispose) + append(cg, "dispose", "\tif (" f ")\n" \ + "\t\tfor (size_t i = 0; i < " f "_len; i++)\n" \ + indent(indent(sprintf(dispose, f "[i]")))) + append(cg, "dispose", "\tfree(" f ");\n") + + append(cg, "serialize", sprintf(CodegenSerialize["u32"], f "_len")) + if (d["type"] == "u8" || d["type"] == "i8") { + append(cg, "serialize", + "\tstr_append_data(w, " f ", " f "_len);\n") + } else if (serialize) { + append(cg, "serialize", + "\tfor (size_t i = 0; i < " f "_len; i++)\n" \ + indent(sprintf(serialize, f "[i]"))) + } + + append(cg, "deserialize", sprintf(CodegenDeserialize["u32"], f "_len") \ + "\tif (!(" f " = calloc(" f "_len + 1, sizeof *" f ")))\n" \ + "\t\treturn false;\n") + if (d["type"] == "u8" || d["type"] == "i8") { + append(cg, "deserialize", + "\tif (msg_unpacker_get_available(r) < " f "_len)\n" \ + "\t\treturn false;\n" \ + "\tmemcpy(" f ", r->data + r->offset, " f "_len);\n" \ + "\tr->offset += " f "_len;\n") + } else if (deserialize) { + append(cg, "deserialize", + "\tfor (size_t i = 0; i < " f "_len; i++)\n" \ + indent(sprintf(deserialize, f "[i]"))) + } +} + +function codegen_struct(name, cg, ctype, funcname) { + ctype = "struct " PrefixLower cameltosnake(name) + print "" + print ctype " {" + print cg["fields"] "};" + + if (cg["dispose"]) { + funcname = PrefixLower cameltosnake(name) "_free" + print "" + print "static void\n" funcname "(" ctype " *self) {" + print cg["dispose"] "}" + + CodegenDispose[name] = "\t" funcname "(&%s);\n" + } + if (cg["serialize"]) { + funcname = PrefixLower cameltosnake(name) "_serialize" + print "" + print "static bool\n" \ + funcname "(\n\t\t" ctype " *self, struct str *w) {" + print cg["serialize"] "\treturn true;" + print "}" + + CodegenSerialize[name] = "\tif (!" funcname "(&%s, w))\n" \ + "\t\treturn false;\n" + } + if (cg["deserialize"]) { + funcname = PrefixLower cameltosnake(name) "_deserialize" + print "" + print "static bool\n" \ + funcname "(\n\t\t" ctype " *self, struct msg_unpacker *r) {" + print cg["deserialize"] "\treturn true;" + print "}" + + CodegenDeserialize[name] = "\tif (!" funcname "(&%s, r))\n" \ + "\t\treturn false;\n" + } + + CodegenCType[name] = ctype + for (i in cg) + delete cg[i] +} + +function codegen_union_tag(d, cg) { + cg["tagtype"] = d["type"] + cg["tagname"] = d["name"] + append(cg, "fields", "\t" CodegenCType[d["type"]] " " d["name"] ";\n") +} + +function codegen_union_struct( \ + name, casename, cg, scg, structname, fieldname, fullcasename) { + # Don't generate obviously useless structs. + fullcasename = toupper(cameltosnake(cg["tagtype"])) "_" casename + if (!scg["dispose"] && !scg["deserialize"]) { + append(cg, "structless", "\tcase " PrefixUpper fullcasename ":\n") + for (i in scg) + delete scg[i] + return + } + + # And thus not all generated structs are present in Types. + structname = name "_" casename + fieldname = tolower(casename) + codegen_struct(structname, scg) + + append(cg, "fields", "\t" CodegenCType[structname] " " fieldname ";\n") + if (CodegenDispose[structname]) + append(cg, "dispose", "\tcase " PrefixUpper fullcasename ":\n" \ + indent(sprintf(CodegenDispose[structname], "self->" fieldname)) \ + "\t\tbreak;\n") + + # With no de/serialization code, this will simply recognize the tag. + append(cg, "serialize", "\tcase " PrefixUpper fullcasename ":\n" \ + indent(sprintf(CodegenSerialize[structname], "self->" fieldname)) \ + "\t\tbreak;\n") + append(cg, "deserialize", "\tcase " PrefixUpper fullcasename ":\n" \ + indent(sprintf(CodegenDeserialize[structname], "self->" fieldname)) \ + "\t\tbreak;\n") +} + +function codegen_union(name, cg, f, ctype, funcname) { + ctype = "union " PrefixLower cameltosnake(name) + print "" + print ctype " {" + print cg["fields"] "};" + + f = "self->" cg["tagname"] + if (cg["dispose"]) { + funcname = PrefixLower cameltosnake(name) "_free" + print "" + print "static void\n" funcname "(" ctype " *self) {" + print "\tswitch (" f ") {" + if (cg["structless"]) + print cg["structless"] \ + indent(sprintf(CodegenDispose[cg["tagtype"]], f)) "\t\tbreak;" + print cg["dispose"] "\tdefault:" + print "\t\tbreak;" + print "\t}" + print "}" + + CodegenDispose[name] = "\t" funcname "(&%s);\n" + } + if (cg["serialize"]) { + funcname = PrefixLower cameltosnake(name) "_serialize" + print "" + print "static bool\n" \ + funcname "(\n\t\t" ctype " *self, struct str *w) {" + print "\tswitch (" f ") {" + if (cg["structless"]) + print cg["structless"] \ + indent(sprintf(CodegenSerialize[cg["tagtype"]], f)) "\t\tbreak;" + print cg["serialize"] "\tdefault:" + print "\t\treturn false;" + print "\t}" + print "\treturn true;" + print "}" + + CodegenSerialize[name] = "\tif (!" funcname "(&%s, w))\n" \ + "\t\treturn false;\n" + } + if (cg["deserialize"]) { + funcname = PrefixLower cameltosnake(name) "_deserialize" + print "" + print "static bool\n" \ + funcname "(\n\t\t" ctype " *self, struct msg_unpacker *r) {" + print sprintf(CodegenDeserialize[cg["tagtype"]], f) + print "\tswitch (" f ") {" + if (cg["structless"]) + print cg["structless"] "\t\tbreak;" + print cg["deserialize"] "\tdefault:" + print "\t\treturn false;" + print "\t}" + print "\treturn true;" + print "}" + + CodegenDeserialize[name] = "\tif (!" funcname "(&%s, r))\n" \ + "\t\treturn false;\n" + } + + CodegenCType[name] = ctype + for (i in cg) + delete cg[i] +} diff --git a/xC-gen-proto-go.awk b/xC-gen-proto-go.awk new file mode 100644 index 0000000..1880de7 --- /dev/null +++ b/xC-gen-proto-go.awk @@ -0,0 +1,447 @@ +# xC-gen-proto-go.awk: Go backend for xC-gen-proto.awk. +# +# Copyright (c) 2022, Přemysl Eric Janouch <p@janouch.name> +# SPDX-License-Identifier: 0BSD +# +# This backend also enables proxying to other endpoints using JSON. + +function define_internal(name, gotype) { + Types[name] = "internal" + CodegenGoType[name] = gotype +} + +function define_sint(size, shortname, gotype) { + shortname = "i" size + gotype = "int" size + define_internal(shortname, gotype) + + if (size == 8) { + CodegenSerialize[shortname] = "\tdata = append(data, uint8(%s))\n" + CodegenDeserialize[shortname] = \ + "\tif len(data) >= 1 {\n" \ + "\t\t%s, data = int8(data[0]), data[1:]\n" \ + "\t} else {\n" \ + "\t\treturn nil, false\n" \ + "\t}\n" + return + } + + CodegenSerialize[shortname] = \ + "\tdata = binary.BigEndian.AppendUint" size "(data, uint" size "(%s))\n" + CodegenDeserialize[shortname] = \ + "\tif len(data) >= " (size / 8) " {\n" \ + "\t\t%s = " gotype "(binary.BigEndian.Uint" size "(data))\n" \ + "\t\tdata = data[" (size / 8) ":]\n" \ + "\t} else {\n" \ + "\t\treturn nil, false\n" \ + "\t}\n" +} + +function define_uint(size, shortname, gotype) { + shortname = "u" size + gotype = "uint" size + define_internal(shortname, gotype) + + # Both byte and uint8 luckily marshal as base64-encoded JSON strings. + if (size == 8) { + CodegenSerialize[shortname] = "\tdata = append(data, %s)\n" + CodegenDeserialize[shortname] = \ + "\tif len(data) >= 1 {\n" \ + "\t\t%s, data = data[0], data[1:]\n" \ + "\t} else {\n" \ + "\t\treturn nil, false\n" \ + "\t}\n" + return + } + + CodegenSerialize[shortname] = \ + "\tdata = binary.BigEndian.AppendUint" size "(data, %s)\n" + CodegenDeserialize[shortname] = \ + "\tif len(data) >= " (size / 8) " {\n" \ + "\t\t%s = binary.BigEndian.Uint" size "(data)\n" \ + "\t\tdata = data[" (size / 8) ":]\n" \ + "\t} else {\n" \ + "\t\treturn nil, false\n" \ + "\t}\n" +} + +function codegen_begin() { + define_sint("8") + define_sint("16") + define_sint("32") + define_sint("64") + define_uint("8") + define_uint("16") + define_uint("32") + define_uint("64") + + define_internal("bool", "bool") + CodegenSerialize["bool"] = \ + "\tif %s {\n" \ + "\t\tdata = append(data, 1)\n" \ + "\t} else {\n" \ + "\t\tdata = append(data, 0)\n" \ + "\t}\n" + CodegenDeserialize["bool"] = \ + "\tif data, ok = protoConsumeBoolFrom(data, &%s); !ok {\n" \ + "\t\treturn nil, ok\n" \ + "\t}\n" + + define_internal("string", "string") + CodegenSerialize["string"] = \ + "\tif data, ok = protoAppendStringTo(data, %s); !ok {\n" \ + "\t\treturn nil, ok\n" \ + "\t}\n" + CodegenDeserialize["string"] = \ + "\tif data, ok = protoConsumeStringFrom(data, &%s); !ok {\n" \ + "\t\treturn nil, ok\n" \ + "\t}\n" + + print "package main" + print "" + print "import (" + print "\t`encoding/binary`" + print "\t`encoding/json`" + print "\t`errors`" + print "\t`math`" + print "\t`strconv`" + print "\t`unicode/utf8`" + print ")" + print "" + + print "// protoConsumeBoolFrom tries to deserialize a boolean value" + print "// from the beginning of a byte stream. When successful," + print "// it returns a subslice with any data that might follow." + print "func protoConsumeBoolFrom(data []byte, b *bool) ([]byte, bool) {" + print "\tif len(data) < 1 {" + print "\t\treturn nil, false" + print "\t}" + print "\tif data[0] != 0 {" + print "\t\t*b = true" + print "\t} else {" + print "\t\t*b = false" + print "\t}" + print "\treturn data[1:], true" + print "}" + print "" + + print "// protoAppendStringTo tries to serialize a string value," + print "// appending it to the end of a byte stream." + print "func protoAppendStringTo(data []byte, s string) ([]byte, bool) {" + print "\tif len(s) > math.MaxUint32 {" + print "\t\treturn nil, false" + print "\t}" + print "\tdata = binary.BigEndian.AppendUint32(data, uint32(len(s)))" + print "\treturn append(data, s...), true" + print "}" + print "" + + print "// protoConsumeStringFrom tries to deserialize a string value" + print "// from the beginning of a byte stream. When successful," + print "// it returns a subslice with any data that might follow." + print "func protoConsumeStringFrom(data []byte, s *string) ([]byte, bool) {" + print "\tif len(data) < 4 {" + print "\t\treturn nil, false" + print "\t}" + print "\tlength := binary.BigEndian.Uint32(data)" + print "\tif data = data[4:]; uint64(len(data)) < uint64(length) {" + print "\t\treturn nil, false" + print "\t}" + print "\t*s = string(data[:length])" + print "\tif !utf8.ValidString(*s) {" + print "\t\treturn nil, false" + print "\t}" + print "\treturn data[length:], true" + print "}" + print "" + + print "// protoUnmarshalEnumJSON converts a JSON fragment to an integer," + print "// ensuring that it's within the expected range of enum values." + print "func protoUnmarshalEnumJSON(data []byte) (int64, error) {" + print "\tvar n int64" + print "\tif err := json.Unmarshal(data, &n); err != nil {" + print "\t\treturn 0, err" + print "\t} else if n > math.MaxInt32 || n < math.MinInt32 {" + print "\t\treturn 0, errors.New(`integer out of range`)" + print "\t} else {" + print "\t\treturn n, nil" + print "\t}" + print "}" + print "" +} + +function codegen_constant(name, value) { + print "const " PrefixCamel snaketocamel(name) " = " value + print "" +} + +function codegen_enum_value(name, subname, value, cg, goname) { + goname = PrefixCamel name snaketocamel(subname) + append(cg, "fields", + "\t" goname " = " value "\n") + append(cg, "stringer", + "\tcase " goname ":\n" \ + "\t\treturn `" snaketocamel(subname) "`\n") + append(cg, "marshal", + goname ",\n") + append(cg, "unmarshal", + "\tcase `" snaketocamel(subname) "`:\n" \ + "\t\t*v = " goname "\n") +} + +function codegen_enum(name, cg, gotype, fields) { + gotype = PrefixCamel name + print "type " gotype " int" + print "" + + print "const (" + print cg["fields"] ")" + print "" + + print "func (v " gotype ") String() string {" + print "\tswitch v {" + print cg["stringer"] "\tdefault:" + print "\t\treturn strconv.Itoa(int(v))" + print "\t}" + print "}" + print "" + + fields = cg["marshal"] + sub(/,\n$/, ":", fields) + gsub(/\n/, "\n\t", fields) + print "func (v " gotype ") MarshalJSON() ([]byte, error) {" + print "\tswitch v {" + print indent("case " fields) + print "\t\treturn json.Marshal(v.String())" + print "\t}" + print "\treturn json.Marshal(int(v))" + print "}" + print "" + + print "func (v *" gotype ") UnmarshalJSON(data []byte) error {" + print "\tvar s string" + print "\tif json.Unmarshal(data, &s) == nil {" + print "\t\t// Handled below." + print "\t} else if n, err := protoUnmarshalEnumJSON(data); err != nil {" + print "\t\treturn err" + print "\t} else {" + print "\t\t*v = " gotype "(n)" + print "\t\treturn nil" + print "\t}" + print "" + print "\tswitch s {" + print cg["unmarshal"] "\tdefault:" + print "\t\treturn errors.New(`unrecognized value: ` + s)" + print "\t}" + print "\treturn nil" + print "}" + print "" + + # XXX: This should also check if it isn't out-of-range for any reason, + # but our usage of sprintf() stands in the way a bit. + CodegenSerialize[name] = \ + "\tdata = binary.BigEndian.AppendUint32(data, uint32(%s))\n" + CodegenDeserialize[name] = \ + "\tif len(data) >= 4 {\n" \ + "\t\t%s = " gotype "(int32(binary.BigEndian.Uint32(data)))\n" \ + "\t\tdata = data[4:]\n" \ + "\t} else {\n" \ + "\t\treturn nil, false\n" \ + "\t}\n" + + CodegenGoType[name] = gotype + for (i in cg) + delete cg[i] +} + +function codegen_struct_field(d, cg, camel, f, serialize, deserialize) { + camel = snaketocamel(d["name"]) + f = "s." camel + serialize = CodegenSerialize[d["type"]] + deserialize = CodegenDeserialize[d["type"]] + if (!d["isarray"]) { + append(cg, "fields", "\t" camel " " CodegenGoType[d["type"]] \ + " `json:\"" decapitalize(camel) "\"`\n") + append(cg, "serialize", sprintf(serialize, f)) + append(cg, "deserialize", sprintf(deserialize, f)) + return + } + + append(cg, "fields", "\t" camel " []" CodegenGoType[d["type"]] \ + " `json:\"" decapitalize(camel) "\"`\n") + + # XXX: This should also check if it isn't out-of-range for any reason. + append(cg, "serialize", + sprintf(CodegenSerialize["u32"], "uint32(len(" f "))")) + if (d["type"] == "u8") { + append(cg, "serialize", + "\tdata = append(data, " f "...)\n") + } else { + append(cg, "serialize", + "\tfor i := 0; i < len(" f "); i++ {\n" \ + indent(sprintf(serialize, f "[i]")) \ + "\t}\n") + } + + append(cg, "deserialize", + "\t{\n" \ + "\t\tvar length uint32\n" \ + indent(sprintf(CodegenDeserialize["u32"], "length"))) + if (d["type"] == "u8") { + append(cg, "deserialize", + "\t\tif uint64(len(data)) < uint64(length) {\n" \ + "\t\t\treturn nil, false\n" \ + "\t\t}\n" \ + "\t\t" f ", data = data[:length], data[length:]\n" \ + "\t}\n") + } else { + append(cg, "deserialize", + "\t\t" f " = make([]" CodegenGoType[d["type"]] ", length)\n" \ + "\t}\n" \ + "\tfor i := 0; i < len(" f "); i++ {\n" \ + indent(sprintf(deserialize, f "[i]")) \ + "\t}\n") + } +} + +function codegen_struct_tag(d, cg, camel, f) { + camel = snaketocamel(d["name"]) + f = "s." camel + append(cg, "fields", "\t" camel " " CodegenGoType[d["type"]] \ + " `json:\"" decapitalize(camel) "\"`\n") + append(cg, "serialize", sprintf(CodegenSerialize[d["type"]], f)) + # Do not deserialize here, that is already done by the containing union. +} + +function codegen_struct(name, cg, gotype) { + gotype = PrefixCamel name + print "type " gotype " struct {\n" cg["fields"] "}\n" + + if (cg["serialize"]) { + print "func (s *" gotype ") AppendTo(data []byte) ([]byte, bool) {" + print "\tok := true" + print cg["serialize"] "\treturn data, ok" + print "}" + print "" + + CodegenSerialize[name] = \ + "\tif data, ok = %s.AppendTo(data); !ok {\n" \ + "\t\treturn nil, ok\n" \ + "\t}\n" + } + if (cg["deserialize"]) { + print "func (s *" gotype ") ConsumeFrom(data []byte) ([]byte, bool) {" + print "\tok := true" + print cg["deserialize"] "\treturn data, ok" + print "}" + print "" + + CodegenDeserialize[name] = \ + "\tif data, ok = %s.ConsumeFrom(data); !ok {\n" \ + "\t\treturn nil, ok\n" \ + "\t}\n" + } + + CodegenGoType[name] = gotype + for (i in cg) + delete cg[i] +} + +function codegen_union_tag(d, cg) { + cg["tagtype"] = d["type"] + cg["tagname"] = d["name"] + # The tag is implied from the type of struct stored in the interface. +} + +function codegen_union_struct(name, casename, cg, scg, structname, init) { + # And thus not all generated structs are present in Types. + structname = name snaketocamel(casename) + codegen_struct(structname, scg) + + init = CodegenGoType[structname] "{" snaketocamel(cg["tagname"]) \ + ": " decapitalize(snaketocamel(cg["tagname"])) "}" + append(cg, "unmarshal", + "\tcase " CodegenGoType[cg["tagtype"]] snaketocamel(casename) ":\n" \ + "\t\ts := " init "\n" \ + "\t\terr = json.Unmarshal(data, &s)\n" \ + "\t\tu.Interface = s\n") + append(cg, "serialize", + "\tcase " CodegenGoType[structname] ":\n" \ + indent(sprintf(CodegenSerialize[structname], "union"))) + append(cg, "deserialize", + "\tcase " CodegenGoType[cg["tagtype"]] snaketocamel(casename) ":\n" \ + "\t\ts := " init "\n" \ + indent(sprintf(CodegenDeserialize[structname], "s")) \ + "\t\tu.Interface = s\n") +} + +function codegen_union(name, cg, gotype, tagfield, tagvar) { + gotype = PrefixCamel name + print "type " gotype " struct {" + print "\tInterface any" + print "}" + print "" + + print "func (u *" gotype ") MarshalJSON() ([]byte, error) {" + print "\treturn json.Marshal(u.Interface)" + print "}" + print "" + + tagfield = snaketocamel(cg["tagname"]) + tagvar = decapitalize(tagfield) + print "func (u *" gotype ") UnmarshalJSON(data []byte) (err error) {" + print "\tvar t struct {" + print "\t\t" tagfield " " CodegenGoType[cg["tagtype"]] \ + " `json:\"" tagvar "\"`" + print "\t}" + print "\tif err := json.Unmarshal(data, &t); err != nil {" + print "\t\treturn err" + print "\t}" + print "" + print "\tswitch " tagvar " := t." tagfield "; " tagvar " {" + print cg["unmarshal"] "\tdefault:" + print "\t\terr = errors.New(`unsupported value: ` + " tagvar ".String())" + print "\t}" + print "\treturn err" + print "}" + print "" + + # XXX: Consider changing the interface into an AppendTo/ConsumeFrom one, + # that would eliminate these type case switches entirely. + # On the other hand, it would make it possible to send unsuitable structs. + print "func (u *" gotype ") AppendTo(data []byte) ([]byte, bool) {" + print "\tok := true" + print "\tswitch union := u.Interface.(type) {" + print cg["serialize"] "\tdefault:" + print "\t\treturn nil, false" + print "\t}" + print "\treturn data, ok" + print "}" + print "" + + CodegenSerialize[name] = \ + "\tif data, ok = %s.AppendTo(data); !ok {\n" \ + "\t\treturn nil, ok\n" \ + "\t}\n" + + print "func (u *" gotype ") ConsumeFrom(data []byte) ([]byte, bool) {" + print "\tok := true" + print "\tvar " tagvar " " CodegenGoType[cg["tagtype"]] + print sprintf(CodegenDeserialize[cg["tagtype"]], tagvar) + print "\tswitch " tagvar " {" + print cg["deserialize"] "\tdefault:" + print "\t\treturn nil, false" + print "\t}" + print "\treturn data, ok" + print "}" + print "" + + CodegenDeserialize[name] = \ + "\tif data, ok = %s.ConsumeFrom(data); !ok {\n" \ + "\t\treturn nil, ok\n" \ + "\t}\n" + + CodegenGoType[name] = gotype + for (i in cg) + delete cg[i] +} diff --git a/xC-gen-proto.awk b/xC-gen-proto.awk new file mode 100644 index 0000000..d5f19fb --- /dev/null +++ b/xC-gen-proto.awk @@ -0,0 +1,303 @@ +# xC-gen-proto.awk: an XDR-derived code generator for network protocols. +# +# Copyright (c) 2022, Přemysl Eric Janouch <p@janouch.name> +# SPDX-License-Identifier: 0BSD +# +# You may read RFC 4506 for context, however it is only a source of inspiration. +# Grammar is easy to deduce from the parser. +# +# Native types: bool, u{8,16,32,64}, i{8,16,32,64}, string +# +# Don't define any new types, unless you hate yourself, then it's okay to do so. +# Both backends are a pain in the arse, for different reasons. +# +# All numbers are encoded in big-endian byte order. +# Booleans are one byte each. +# Strings must be valid UTF-8, use u8<> to lift that restriction. +# String and array lengths are encoded as u32. +# Enumeration values automatically start at 1, and are encoded as i32. +# Any struct or union field may be a variable-length array. +# +# Message framing is done externally, but also happens to prefix u32 lengths. +# +# Usage: env LC_ALL=C awk -v prefix=Relay \ +# -f xC-gen-proto.awk < xC-proto \ +# -f xC-gen-proto-{c,go}.awk > xC-proto.{c,go} | {clang-format,gofmt} + +# --- Utilities ---------------------------------------------------------------- + +function cameltosnake(s) { + while (match(s, /[[:lower:]][[:upper:]]/)) { + s = substr(s, 1, RSTART) "_" \ + tolower(substr(s, RSTART + 1, RLENGTH - 1)) \ + substr(s, RSTART + RLENGTH) + } + return tolower(s) +} + +function snaketocamel(s) { + s = toupper(substr(s, 1, 1)) tolower(substr(s, 2)) + while (match(s, /_[[:alnum:]]/)) { + s = substr(s, 1, RSTART - 1) \ + toupper(substr(s, RSTART + 1, RLENGTH - 1)) \ + substr(s, RSTART + RLENGTH) + } + return s +} + +function decapitalize(s) { + if (match(s, /[[:upper:]][[:lower:]]/)) { + return tolower(substr(s, 1, 1)) substr(s, 2) + } + return s +} + +function indent(s) { + if (!s) + return s + + gsub(/\n/, "\n\t", s) + sub(/\t*$/, "", s) + return "\t" s +} + +function append(a, key, value) { + a[key] = a[key] value +} + +# --- Parsing ------------------------------------------------------------------ + +function fatal(message) { + print "// " FILENAME ":" FNR ": fatal error: " message + print FILENAME ":" FNR ": fatal error: " message > "/dev/stderr" + exit 1 +} + +function skipcomment() { + do { + if (match($0, /[*][/]/)) { + $0 = substr($0, RSTART + RLENGTH) + return + } + } while (getline > 0) + fatal("unterminated block comment") +} + +function nexttoken() { + do { + if (match($0, /^[[:space:]]+/)) { + $0 = substr($0, RLENGTH + 1) + } else if (match($0, /^[/][/].*/)) { + $0 = "" + } else if (match($0, /^[/][*]/)) { + $0 = substr($0, RLENGTH + 1) + skipcomment() + } else if (match($0, /^[[:alpha:]][[:alnum:]_]*/)) { + Token = substr($0, 1, RLENGTH) + $0 = substr($0, RLENGTH + 1) + return Token + } else if (match($0, /^(0[xX][0-9a-fA-F]+|[1-9][0-9]*)/)) { + Token = substr($0, 1, RLENGTH) + $0 = substr($0, RLENGTH + 1) + return Token + } else if (/./) { + Token = substr($0, 1, 1) + $0 = substr($0, 2) + return Token + } + } while (/./ || getline > 0) + Token = "" + return Token +} + +function expect(v) { + if (!v) + fatal("broken expectations at `" Token "' before `" $0 "'") + return v +} + +function accept(what) { + if (Token != what) + return 0 + nexttoken() + return 1 +} + +function identifier( v) { + if (Token !~ /^[[:alpha:]]/) + return 0 + v = Token + nexttoken() + return v +} + +function number( v) { + if (Token !~ /^[0-9]/) + return 0 + v = Token + nexttoken() + return v +} + +function readnumber( ident) { + ident = identifier() + if (!ident) + return expect(number()) + if (!(ident in Consts)) + fatal("unknown constant: " ident) + return Consts[ident] +} + +function defconst( ident, num) { + if (!accept("const")) + return 0 + + ident = expect(identifier()) + expect(accept("=")) + num = readnumber() + if (ident in Consts) + fatal("constant redefined: " ident) + + Consts[ident] = num + codegen_constant(ident, num) + return 1 +} + +function readtype( ident) { + ident = deftype() + if (ident) + return ident + + ident = identifier() + if (!ident) + return 0 + + if (!(ident in Types)) + fatal("unknown type: " ident) + return ident +} + +function defenum( name, ident, value, cg) { + delete cg[0] + + name = expect(identifier()) + expect(accept("{")) + while (!accept("}")) { + ident = expect(identifier()) + value = value + 1 + if (accept("=")) + value = readnumber() + if (!value) + fatal("enumeration values cannot be zero") + expect(accept(",")) + append(EnumValues, name, SUBSEP ident) + if (EnumValues[name, ident]++) + fatal("duplicate enum value: " ident) + codegen_enum_value(name, ident, value, cg) + } + + Types[name] = "enum" + codegen_enum(name, cg) + return name +} + +function readfield(out, nonvoid) { + nonvoid = !accept("void") + if (nonvoid) { + out["type"] = expect(readtype()) + out["name"] = expect(identifier()) + # TODO: Consider supporting XDR's VLA length limits here. + # TODO: Consider supporting XDR's fixed-length syntax for string limits. + out["isarray"] = accept("<") && expect(accept(">")) + } + expect(accept(";")) + return nonvoid +} + +function defstruct( name, d, cg) { + delete d[0] + delete cg[0] + + name = expect(identifier()) + expect(accept("{")) + while (!accept("}")) { + if (readfield(d)) + codegen_struct_field(d, cg) + } + + Types[name] = "struct" + codegen_struct(name, cg) + return name +} + +function defunion( name, tag, tagtype, tagvalue, cg, scg, d, a, i, unseen) { + delete cg[0] + delete scg[0] + delete d[0] + + name = expect(identifier()) + expect(accept("switch")) + expect(accept("(")) + tag["type"] = tagtype = expect(readtype()) + tag["name"] = expect(identifier()) + expect(accept(")")) + + if (Types[tagtype] != "enum") + fatal("not an enum type: " tagtype) + codegen_union_tag(tag, cg) + + split(EnumValues[tagtype], a, SUBSEP) + for (i in a) + unseen[a[i]]++ + + expect(accept("{")) + while (!accept("}")) { + if (accept("case")) { + if (tagvalue) + codegen_union_struct(name, tagvalue, cg, scg) + + tagvalue = expect(identifier()) + expect(accept(":")) + if (!unseen[tagvalue]--) + fatal("no such value or duplicate case: " tagtype "." tagvalue) + codegen_struct_tag(tag, scg) + } else if (tagvalue) { + if (readfield(d)) + codegen_struct_field(d, scg) + } else { + fatal("union fields must fall under a case") + } + } + if (tagvalue) + codegen_union_struct(name, tagvalue, cg, scg) + + # What remains non-zero in unseen[2..] is simply not recognized/allowed. + Types[name] = "union" + codegen_union(name, cg) + return name +} + +function deftype() { + if (accept("enum")) + return defenum() + if (accept("struct")) + return defstruct() + if (accept("union")) + return defunion() + return 0 +} + +BEGIN { + PrefixLower = "relay_" + PrefixUpper = "RELAY_" + PrefixCamel = "Relay" + + print "// Generated by xC-gen-proto.awk. DO NOT MODIFY." + codegen_begin() + + nexttoken() + while (Token != "") { + expect(defconst() || deftype()) + expect(accept(";")) + } +} diff --git a/xC-proto b/xC-proto new file mode 100644 index 0000000..31534d4 --- /dev/null +++ b/xC-proto @@ -0,0 +1,120 @@ +// Backwards-compatible protocol version. +const VERSION = 1; + +// From the frontend to the relay. +struct CommandMessage { + u32 command_seq; + union CommandData switch (enum Command { + HELLO, + PING, + ACTIVE, + BUFFER_COMPLETE, + BUFFER_INPUT, + BUFFER_ACTIVATE, + BUFFER_LOG, + } command) { + case HELLO: + u32 version; + case PING: + void; + case ACTIVE: + void; + case BUFFER_COMPLETE: + string buffer_name; + string text; + u32 position; + case BUFFER_INPUT: + string buffer_name; + string text; + case BUFFER_ACTIVATE: + string buffer_name; + case BUFFER_LOG: + string buffer_name; + } data; +}; + +// From the relay to the frontend. +struct EventMessage { + u32 event_seq; + union EventData switch (enum Event { + PING, + BUFFER_UPDATE, + BUFFER_RENAME, + BUFFER_REMOVE, + BUFFER_ACTIVATE, + BUFFER_LINE, + BUFFER_CLEAR, + ERROR, + RESPONSE, + } event) { + case PING: + void; + case BUFFER_UPDATE: + string buffer_name; + case BUFFER_RENAME: + string buffer_name; + string new; + case BUFFER_REMOVE: + string buffer_name; + case BUFFER_ACTIVATE: + string buffer_name; + case BUFFER_LINE: + string buffer_name; + bool is_unimportant; + bool is_highlight; + enum Rendition { + BARE, + INDENT, + STATUS, + ERROR, + JOIN, + PART, + } rendition; + // Unix timestamp in seconds. + u64 when; + // Broken-up text, with in-band formatting. + union ItemData switch (enum Item { + TEXT, + RESET, + FG_COLOR, + BG_COLOR, + FLIP_BOLD, + FLIP_ITALIC, + FLIP_UNDERLINE, + FLIP_INVERSE, + FLIP_CROSSED_OUT, + FLIP_MONOSPACE, + } kind) { + case TEXT: + string text; + case RESET: + void; + case FG_COLOR: + i16 color; + case BG_COLOR: + i16 color; + case FLIP_BOLD: + case FLIP_ITALIC: + case FLIP_UNDERLINE: + case FLIP_INVERSE: + case FLIP_CROSSED_OUT: + case FLIP_MONOSPACE: + void; + } items<>; + case BUFFER_CLEAR: + string buffer_name; + case ERROR: + u32 command_seq; + string error; + case RESPONSE: + u32 command_seq; + union ResponseData switch (Command command) { + case BUFFER_COMPLETE: + u32 start; + string completions<>; + case BUFFER_LOG: + // UTF-8, but not guaranteed. + u8 log<>; + } data; + } data; +}; @@ -50,6 +50,7 @@ enum #include "common.c" #include "xD-replies.c" +#include "xC-proto.c" #include <math.h> #include <langinfo.h> @@ -1526,6 +1527,7 @@ enum buffer_line_flags BUFFER_LINE_HIGHLIGHT = 1 << 2, ///< The user was highlighted by this }; +// NOTE: This sequence must match up with xC-proto, only one lower. enum buffer_line_rendition { BUFFER_LINE_BARE, ///< Unadorned @@ -1666,6 +1668,50 @@ buffer_destroy (struct buffer *self) REF_COUNTABLE_METHODS (buffer) #define buffer_ref do_not_use_dangerous +// ~~~ Relay ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + +struct client +{ + LIST_HEADER (struct client) + struct app_context *ctx; ///< Application context + + // TODO: Convert this all to TLS, and only TLS, with required client cert. + // That means replacing plumbing functions with the /other/ set from xD. + + int socket_fd; ///< The TCP socket + struct str read_buffer; ///< Unprocessed input + struct str write_buffer; ///< Output yet to be sent out + + uint32_t event_seq; ///< Outgoing message counter + bool initialized; ///< Initial sync took place + + struct poller_fd socket_event; ///< The socket can be read/written to +}; + +static struct client * +client_new (void) +{ + struct client *self = xcalloc (1, sizeof *self); + self->socket_fd = -1; + self->read_buffer = str_make (); + self->write_buffer = str_make (); + return self; +} + +static void +client_destroy (struct client *self) +{ + if (!soft_assert (self->socket_fd == -1)) + xclose (self->socket_fd); + + str_free (&self->read_buffer); + str_free (&self->write_buffer); + free (self); +} + +static void client_kill (struct client *c); +static bool client_process_buffer (struct client *c); + // ~~~ Server ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // The only real purpose of this is to abstract away TLS @@ -2079,10 +2125,19 @@ struct app_context struct str_map servers; ///< Our servers + // Relay: + + int relay_fd; ///< Listening socket FD + struct client *clients; ///< Our relay clients + + /// A single message buffer to prepare all outcoming messages within + struct relay_event_message relay_message; + // Events: struct poller_fd tty_event; ///< Terminal input event struct poller_fd signal_event; ///< Signal FD event + struct poller_fd relay_event; ///< New relay connection available struct poller_timer flush_timer; ///< Flush all open files (e.g. logs) struct poller_timer date_chg_tmr; ///< Print a date change @@ -2129,6 +2184,8 @@ struct app_context char *editor_filename; ///< The file being edited by user int terminal_suspended; ///< Terminal suspension level + // Plugins: + struct plugin *plugins; ///< Loaded plugins struct hook *input_hooks; ///< Input hooks struct hook *irc_hooks; ///< IRC hooks @@ -2197,6 +2254,8 @@ app_context_init (struct app_context *self) self->config = config_make (); poller_init (&self->poller); + self->relay_fd = -1; + self->servers = str_map_make ((str_map_free_fn) server_unref); self->servers.key_xfrm = tolower_ascii_strxfrm; @@ -2223,6 +2282,17 @@ app_context_init (struct app_context *self) } static void +app_context_relay_stop (struct app_context *self) +{ + if (self->relay_fd != -1) + { + poller_fd_reset (&self->relay_event); + xclose (self->relay_fd); + self->relay_fd = -1; + } +} + +static void app_context_free (struct app_context *self) { // Plugins can try to use of the other fields when destroyed @@ -2247,6 +2317,11 @@ app_context_free (struct app_context *self) } str_map_free (&self->buffers_by_name); + app_context_relay_stop (self); + LIST_FOR_EACH (struct client, c, self->clients) + client_kill (c); + relay_event_message_free (&self->relay_message); + str_map_free (&self->servers); poller_free (&self->poller); @@ -2285,6 +2360,7 @@ on_config_show_all_prefixes_change (struct config_item *item) refresh_prompt (ctx); } +static void on_config_relay_bind_change (struct config_item *item); static void on_config_backlog_limit_change (struct config_item *item); static void on_config_attribute_change (struct config_item *item); static void on_config_logging_change (struct config_item *item); @@ -2479,6 +2555,11 @@ static struct config_schema g_config_general[] = .comment = "Plugins to automatically load on start", .type = CONFIG_ITEM_STRING_ARRAY, .validate = config_validate_nonjunk_string }, + { .name = "relay_bind", + .comment = "Address to bind to for a user interface relay point", + .type = CONFIG_ITEM_STRING, + .validate = config_validate_nonjunk_string, + .on_change = on_config_relay_bind_change }, // Buffer history: { .name = "backlog_limit", @@ -2681,6 +2762,418 @@ serialize_configuration (struct config_item *root, struct str *output) config_item_write (root, true, output); } +// --- Relay plumbing ---------------------------------------------------------- + +static void +client_kill (struct client *c) +{ + struct app_context *ctx = c->ctx; + poller_fd_reset (&c->socket_event); + xclose (c->socket_fd); + c->socket_fd = -1; + + LIST_UNLINK (ctx->clients, c); + client_destroy (c); +} + +static bool +client_try_read (struct client *c) +{ + struct str *buf = &c->read_buffer; + ssize_t n_read; + + while ((n_read = read (c->socket_fd, buf->str + buf->len, + buf->alloc - buf->len - 1 /* null byte */)) > 0) + { + buf->len += n_read; + if (!client_process_buffer (c)) + break; + str_reserve (buf, 512); + } + + if (n_read < 0) + { + if (errno == EAGAIN || errno == EINTR) + return true; + + print_debug ("%s: %s: %s", __func__, "read", strerror (errno)); + } + + client_kill (c); + return false; +} + +static bool +client_try_write (struct client *c) +{ + struct str *buf = &c->write_buffer; + ssize_t n_written; + + while (buf->len) + { + n_written = write (c->socket_fd, buf->str, buf->len); + if (n_written >= 0) + { + str_remove_slice (buf, 0, n_written); + continue; + } + if (errno == EAGAIN || errno == EINTR) + return true; + + print_debug ("%s: %s: %s", __func__, "write", strerror (errno)); + client_kill (c); + return false; + } + return true; +} + +// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + +static void +client_update_poller (struct client *c, const struct pollfd *pfd) +{ + int new_events = POLLIN; + if (c->write_buffer.len) + new_events |= POLLOUT; + + hard_assert (new_events != 0); + if (!pfd || pfd->events != new_events) + poller_fd_set (&c->socket_event, new_events); +} + +static void +on_client_ready (const struct pollfd *pfd, void *user_data) +{ + struct client *c = user_data; + if (client_try_read (c) && client_try_write (c)) + client_update_poller (c, pfd); +} + +static bool +relay_try_fetch_client (struct app_context *ctx, int listen_fd) +{ + // XXX: `struct sockaddr_storage' is not the most portable thing + struct sockaddr_storage peer; + socklen_t peer_len = sizeof peer; + + int fd = accept (listen_fd, (struct sockaddr *) &peer, &peer_len); + if (fd == -1) + { + if (errno == EAGAIN || errno == EWOULDBLOCK) + return false; + if (errno == EINTR) + return true; + + if (accept_error_is_transient (errno)) + print_warning ("%s: %s", "accept", strerror (errno)); + else + print_fatal ("%s: %s", "accept", strerror (errno)); + return true; + } + + hard_assert (peer_len <= sizeof peer); + set_blocking (fd, false); + set_cloexec (fd); + + // We already buffer our output, so reduce latencies. + int yes = 1; + soft_assert (setsockopt (fd, IPPROTO_TCP, TCP_NODELAY, + &yes, sizeof yes) != -1); + + struct client *c = client_new (); + c->ctx = ctx; + c->socket_fd = fd; + LIST_PREPEND (ctx->clients, c); + + c->socket_event = poller_fd_make (&c->ctx->poller, c->socket_fd); + c->socket_event.dispatcher = (poller_fd_fn) on_client_ready; + c->socket_event.user_data = c; + + client_update_poller (c, NULL); + return true; +} + +static void +on_relay_client_available (const struct pollfd *pfd, void *user_data) +{ + struct app_context *ctx = user_data; + while (relay_try_fetch_client (ctx, pfd->fd)) + ; +} + +// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + +static int +relay_listen (struct addrinfo *ai, struct error **e) +{ + int fd = socket (ai->ai_family, ai->ai_socktype, ai->ai_protocol); + if (fd == -1) + { + error_set (e, "socket: %s", strerror (errno)); + return -1; + } + + set_cloexec (fd); + + int yes = 1; + soft_assert (setsockopt (fd, SOL_SOCKET, SO_KEEPALIVE, + &yes, sizeof yes) != -1); + soft_assert (setsockopt (fd, SOL_SOCKET, SO_REUSEADDR, + &yes, sizeof yes) != -1); + + if (bind (fd, ai->ai_addr, ai->ai_addrlen)) + error_set (e, "bind: %s", strerror (errno)); + else if (listen (fd, 16 /* arbitrary number */)) + error_set (e, "listen: %s", strerror (errno)); + else + return fd; + + xclose (fd); + return -1; +} + +static int +relay_listen_with_context (struct addrinfo *ai, struct error **e) +{ + char *address = gai_reconstruct_address (ai); + print_debug ("binding to `%s'", address); + + struct error *error = NULL; + int fd = relay_listen (ai, &error); + if (fd == -1) + { + error_set (e, "binding to `%s' failed: %s", address, error->message); + error_free (error); + } + free (address); + return fd; +} + +static bool +relay_start (struct app_context *ctx, char *address, struct error **e) +{ + const char *port = NULL, *host = tokenize_host_port (address, &port); + if (!port || !*port) + return error_set (e, "missing port"); + + struct addrinfo hints = {}, *result = NULL; + hints.ai_socktype = SOCK_STREAM; + hints.ai_flags = AI_PASSIVE; + + int err = getaddrinfo (*host ? host : NULL, port, &hints, &result); + if (err) + { + return error_set (e, "failed to resolve `%s', port `%s': %s: %s", + host, port, "getaddrinfo", gai_strerror (err)); + } + + // Just try the first one, disregarding IPv4/IPv6 ordering. + int fd = relay_listen_with_context (result, e); + freeaddrinfo (result); + if (fd == -1) + return false; + + set_blocking (fd, false); + + struct poller_fd *event = &ctx->relay_event; + *event = poller_fd_make (&ctx->poller, fd); + event->dispatcher = (poller_fd_fn) on_relay_client_available; + event->user_data = ctx; + + ctx->relay_fd = fd; + poller_fd_set (event, POLLIN); + return true; +} + +static void +on_config_relay_bind_change (struct config_item *item) +{ + struct app_context *ctx = item->user_data; + char *value = item->value.string.str; + app_context_relay_stop (ctx); + if (!value) + return; + + struct error *e = NULL; + char *address = xstrdup (value); + if (!relay_start (ctx, address, &e)) + { + // TODO: Try to make sure this finds its way to the global buffer. + print_error ("%s: %s", item->schema->name, e->message); + error_free (e); + } + free (address); +} + +// --- Relay output ------------------------------------------------------------ + +static void +relay_send (struct client *c) +{ + struct relay_event_message *m = &c->ctx->relay_message; + m->event_seq = c->event_seq++; + + // TODO: Also don't try sending anything if half-closed. + if (!c->initialized || c->socket_fd == -1) + return; + + // liberty has msg_{reader,writer} already, but they use 8-byte lengths. + size_t frame_len_pos = c->write_buffer.len, frame_len = 0; + str_pack_u32 (&c->write_buffer, 0); + if (!relay_event_message_serialize (m, &c->write_buffer) + || (frame_len = c->write_buffer.len - frame_len_pos - 4) > UINT32_MAX) + { + print_error ("serialization failed, killing client"); + client_kill (c); + return; + } + + uint32_t len = htonl (frame_len); + memcpy (c->write_buffer.str + frame_len_pos, &len, sizeof len); + client_update_poller (c, NULL); +} + +static void +relay_broadcast (struct app_context *ctx) +{ + LIST_FOR_EACH (struct client, c, ctx->clients) + relay_send (c); +} + +static struct relay_event_message * +relay_prepare (struct app_context *ctx) +{ + struct relay_event_message *m = &ctx->relay_message; + relay_event_message_free (m); + memset (m, 0, sizeof *m); + return m; +} + +static void +relay_prepare_ping (struct app_context *ctx) +{ + relay_prepare (ctx)->data.event = RELAY_EVENT_PING; +} + +static void +relay_prepare_buffer_update (struct app_context *ctx, struct buffer *buffer) +{ + struct relay_event_message *m = relay_prepare (ctx); + struct relay_event_data_buffer_update *e = &m->data.buffer_update; + e->event = RELAY_EVENT_BUFFER_UPDATE; + e->buffer_name = str_from_cstr (buffer->name); +} + +static void +relay_prepare_buffer_rename (struct app_context *ctx, struct buffer *buffer, + const char *new_name) +{ + struct relay_event_message *m = relay_prepare (ctx); + struct relay_event_data_buffer_rename *e = &m->data.buffer_rename; + e->event = RELAY_EVENT_BUFFER_RENAME; + e->buffer_name = str_from_cstr (buffer->name); + e->new = str_from_cstr (new_name); +} + +static void +relay_prepare_buffer_remove (struct app_context *ctx, struct buffer *buffer) +{ + struct relay_event_message *m = relay_prepare (ctx); + struct relay_event_data_buffer_remove *e = &m->data.buffer_remove; + e->event = RELAY_EVENT_BUFFER_REMOVE; + e->buffer_name = str_from_cstr (buffer->name); +} + +static void +relay_prepare_buffer_activate (struct app_context *ctx, struct buffer *buffer) +{ + struct relay_event_message *m = relay_prepare (ctx); + struct relay_event_data_buffer_activate *e = &m->data.buffer_activate; + e->event = RELAY_EVENT_BUFFER_ACTIVATE; + e->buffer_name = str_from_cstr (buffer->name); +} + +static void +relay_prepare_buffer_line (struct app_context *ctx, struct buffer *buffer, + struct buffer_line *line) +{ + struct relay_event_message *m = relay_prepare (ctx); + struct relay_event_data_buffer_line *e = &m->data.buffer_line; + e->event = RELAY_EVENT_BUFFER_LINE; + e->buffer_name = str_from_cstr (buffer->name); + e->is_unimportant = !!(line->flags & BUFFER_LINE_UNIMPORTANT); + e->is_highlight = !!(line->flags & BUFFER_LINE_HIGHLIGHT); + e->rendition = 1 + line->r; + e->when = line->when; + + size_t len = 0; + for (size_t i = 0; line->items[i].type; i++) + len++; + + // XXX: This way helps xP's JSON conversion, but is super annoying for us. + union relay_item_data *p = e->items = xcalloc (len * 6, sizeof *e->items); + for (struct formatter_item *i = line->items; len--; i++) + { + switch (i->type) + { + case FORMATTER_ITEM_TEXT: + p->text.text = str_from_cstr (i->text); + (p++)->kind = RELAY_ITEM_TEXT; + break; + case FORMATTER_ITEM_ATTR: + // For future consideration. + (p++)->kind = RELAY_ITEM_RESET; + break; + case FORMATTER_ITEM_FG_COLOR: + p->fg_color.color = i->color; + (p++)->kind = RELAY_ITEM_FG_COLOR; + break; + case FORMATTER_ITEM_BG_COLOR: + p->bg_color.color = i->color; + (p++)->kind = RELAY_ITEM_BG_COLOR; + break; + case FORMATTER_ITEM_SIMPLE: + if (i->attribute & TEXT_BOLD) + (p++)->kind = RELAY_ITEM_FLIP_BOLD; + if (i->attribute & TEXT_ITALIC) + (p++)->kind = RELAY_ITEM_FLIP_ITALIC; + if (i->attribute & TEXT_UNDERLINE) + (p++)->kind = RELAY_ITEM_FLIP_UNDERLINE; + if (i->attribute & TEXT_INVERSE) + (p++)->kind = RELAY_ITEM_FLIP_INVERSE; + if (i->attribute & TEXT_CROSSED_OUT) + (p++)->kind = RELAY_ITEM_FLIP_CROSSED_OUT; + if (i->attribute & TEXT_MONOSPACE) + (p++)->kind = RELAY_ITEM_FLIP_MONOSPACE; + break; + default: + break; + } + } + + e->items_len = p - e->items; +} + +static void +relay_prepare_buffer_clear (struct app_context *ctx, + struct buffer *buffer) +{ + struct relay_event_message *m = relay_prepare (ctx); + struct relay_event_data_buffer_clear *e = &m->data.buffer_clear; + e->event = RELAY_EVENT_BUFFER_CLEAR; + e->buffer_name = str_from_cstr (buffer->name); +} + +static void +relay_prepare_error (struct app_context *ctx, uint32_t seq, const char *message) +{ + struct relay_event_message *m = relay_prepare (ctx); + struct relay_event_data_error *e = &m->data.error; + e->event = RELAY_EVENT_ERROR; + e->command_seq = seq; + e->error = str_from_cstr (message); +} + // --- Terminal output --------------------------------------------------------- /// Default colour pair @@ -4089,6 +4582,9 @@ log_formatter (struct app_context *ctx, struct buffer *buffer, if (buffer->log_file) buffer_line_write_to_log (ctx, line, buffer->log_file); + relay_prepare_buffer_line (ctx, buffer, line); + relay_broadcast (ctx); + bool unseen_pm = buffer->type == BUFFER_PM && buffer != ctx->current_buffer && !(flags & BUFFER_LINE_UNIMPORTANT); @@ -4302,6 +4798,9 @@ buffer_add (struct app_context *ctx, struct buffer *buffer) buffer_open_log_file (ctx, buffer); + relay_prepare_buffer_update (ctx, buffer); + relay_broadcast (ctx); + // Normally this doesn't cause changes in the prompt but a prompt hook // could decide to show some information for all buffers nonetheless refresh_prompt (ctx); @@ -4328,6 +4827,9 @@ buffer_remove (struct app_context *ctx, struct buffer *buffer) if (buffer->type == BUFFER_SERVER) buffer->server->buffer = NULL; + relay_prepare_buffer_remove (ctx, buffer); + relay_broadcast (ctx); + str_map_set (&ctx->buffers_by_name, buffer->name, NULL); LIST_UNLINK_WITH_TAIL (ctx->buffers, ctx->buffers_tail, buffer); buffer_unref (buffer); @@ -4457,6 +4959,9 @@ buffer_activate (struct app_context *ctx, struct buffer *buffer) ctx->last_buffer = ctx->current_buffer; ctx->current_buffer = buffer; + relay_prepare_buffer_activate (ctx, buffer); + relay_broadcast (ctx); + refresh_prompt (ctx); } @@ -4491,12 +4996,19 @@ buffer_merge (struct app_context *ctx, merged->lines_tail = start->prev; merged->lines_count -= n; - // And append them to current lines in the buffer + // Append them to current lines in the buffer buffer->lines_tail->next = start; start->prev = buffer->lines_tail; buffer->lines_tail = tail; buffer->lines_count += n; + // And since there is no log_*() call, send them to relays manually + LIST_FOR_EACH (struct buffer_line, line, start) + { + relay_prepare_buffer_line (ctx, buffer, line); + relay_broadcast (ctx); + } + log_full (ctx, NULL, buffer, BUFFER_LINE_SKIP_FILE, BUFFER_LINE_STATUS, "End of merged content"); } @@ -4511,6 +5023,9 @@ buffer_rename (struct app_context *ctx, hard_assert (!collision); + relay_prepare_buffer_rename (ctx, buffer, new_name); + relay_broadcast (ctx); + str_map_set (&ctx->buffers_by_name, buffer->name, NULL); str_map_set (&ctx->buffers_by_name, new_name, buffer); @@ -4524,13 +5039,16 @@ buffer_rename (struct app_context *ctx, } static void -buffer_clear (struct buffer *buffer) +buffer_clear (struct app_context *ctx, struct buffer *buffer) { LIST_FOR_EACH (struct buffer_line, iter, buffer->lines) buffer_line_destroy (iter); buffer->lines = buffer->lines_tail = NULL; buffer->lines_count = 0; + + relay_prepare_buffer_clear (ctx, buffer); + relay_broadcast (ctx); } static struct buffer * @@ -5947,29 +6465,6 @@ irc_finish_connection (struct server *s, int socket, const char *hostname) refresh_prompt (s->ctx); } -/// Unwrap IPv6 addresses in format_host_port_pair() format -static void -irc_split_host_port (char *s, char **host, char **port) -{ - *host = s; - *port = "6667"; - - char *right_bracket = strchr (s, ']'); - if (s[0] == '[' && right_bracket) - { - *right_bracket = '\0'; - *host = s + 1; - s = right_bracket + 1; - } - - char *colon = strchr (s, ':'); - if (colon) - { - *colon = '\0'; - *port = colon + 1; - } -} - // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - static void @@ -6019,8 +6514,8 @@ irc_setup_connector (struct server *s, const struct strv *addresses) for (size_t i = 0; i < addresses->len; i++) { - char *host, *port; - irc_split_host_port (addresses->vector[i], &host, &port); + const char *port = "6667", + *host = tokenize_host_port (addresses->vector[i], &port); connector_add_target (connector, host, port); } } @@ -6062,9 +6557,8 @@ irc_setup_connector_socks (struct server *s, const struct strv *addresses, for (size_t i = 0; i < addresses->len; i++) { - char *host, *port; - irc_split_host_port (addresses->vector[i], &host, &port); - + const char *port = "6667", + *host = tokenize_host_port (addresses->vector[i], &port); if (!socks_connector_add_target (connector, host, port, e)) return false; } @@ -7644,7 +8138,7 @@ irc_on_registered (struct server *s, const char *nickname) if (command) { log_server_debug (s, "Executing \"#s\"", command); - process_input_utf8 (s->ctx, s->buffer, command, 0); + (void) process_input_utf8 (s->ctx, s->buffer, command, 0); } int64_t command_delay = get_config_integer (s->config, "command_delay"); @@ -8230,6 +8724,24 @@ irc_handle_rpl_isupport (struct server *s, const struct irc_message *msg) // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - static void +irc_adjust_motd (char **motd) +{ + // Heuristic, force MOTD to be monospace in graphical frontends. + if (!strchr (*motd, '\x11')) + { + struct str s = str_make (); + str_append_c (&s, '\x11'); + for (const char *p = *motd; *p; p++) + { + str_append_c (&s, *p); + if (*p == '\x0f') + str_append_c (&s, '\x11'); + } + cstr_set (motd, str_steal (&s)); + } +} + +static void irc_process_numeric (struct server *s, const struct irc_message *msg, unsigned long numeric) { @@ -8251,6 +8763,10 @@ irc_process_numeric (struct server *s, if (msg->params.len == 2) irc_try_parse_welcome_for_userhost (s, msg->params.vector[1]); break; + case IRC_RPL_MOTD: + if (copy.len) + irc_adjust_motd (©.vector[0]); + break; case IRC_RPL_ISUPPORT: irc_handle_rpl_isupport (s, msg); break; @@ -9248,7 +9764,7 @@ lua_buffer_execute (lua_State *L) struct lua_weak *wrapper = lua_weak_deref (L, &lua_buffer_info); struct buffer *buffer = wrapper->object; const char *line = lua_plugin_check_utf8 (L, 2); - process_input_utf8 (wrapper->plugin->ctx, buffer, line, 0); + (void) process_input_utf8 (wrapper->plugin->ctx, buffer, line, 0); return 0; } @@ -11304,7 +11820,7 @@ handle_command_buffer (struct handler_args *a) show_buffers_list (ctx); else if (!strcasecmp_ascii (action, "clear")) { - buffer_clear (a->buffer); + buffer_clear (ctx, a->buffer); if (a->buffer == ctx->current_buffer) buffer_print_backlog (ctx, a->buffer); } @@ -12926,8 +13442,8 @@ complete_set_value_array (struct config_item *item, const char *word, cstr_split (item->value.string.str, ",", false, &items); for (size_t i = 0; i < items.len; i++) { - struct str wrapped = str_make (), serialized = str_make (); - str_append (&wrapped, items.vector[i]); + struct str wrapped = str_from_cstr (items.vector[i]); + struct str serialized = str_make (); config_item_write_string (&serialized, &wrapped); str_free (&wrapped); @@ -13546,6 +14062,25 @@ on_display_backlog_nowrap (int count, int key, void *user_data) return display_backlog (user_data, FLUSH_OPT_NOWRAP); } +static FILE * +open_log_path (struct app_context *ctx, struct buffer *buffer, const char *path) +{ + FILE *fp = fopen (path, "rb"); + if (!fp) + { + log_global_error (ctx, + "Failed to open `#l': #l", path, strerror (errno)); + return NULL; + } + + if (buffer->log_file) + // The regular flush will log any error eventually + (void) fflush (buffer->log_file); + + set_cloexec (fileno (fp)); + return fp; +} + static bool on_display_full_log (int count, int key, void *user_data) { @@ -13555,20 +14090,13 @@ on_display_full_log (int count, int key, void *user_data) struct buffer *buffer = ctx->current_buffer; char *path = buffer_get_log_path (buffer); - FILE *full_log = fopen (path, "rb"); + FILE *full_log = open_log_path (ctx, buffer, path); if (!full_log) { - log_global_error (ctx, "Failed to open log file for #s: #l", - ctx->current_buffer->name, strerror (errno)); free (path); return false; } - if (buffer->log_file) - // The regular flush will log any error eventually - (void) fflush (buffer->log_file); - - set_cloexec (fileno (full_log)); launch_pager (ctx, fileno (full_log), buffer->name, path); fclose (full_log); free (path); @@ -14601,6 +15129,177 @@ init_poller_events (struct app_context *ctx) ctx->input_event.user_data = ctx; } +// --- Relay processing -------------------------------------------------------- + +// XXX: This could be below completion code if reset_autoaway() was higher up. + +// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + +static void +client_resync (struct client *c) +{ + LIST_FOR_EACH (struct buffer, buffer, c->ctx->buffers) + { + relay_prepare_buffer_update (c->ctx, buffer); + relay_send (c); + + LIST_FOR_EACH (struct buffer_line, line, buffer->lines) + { + relay_prepare_buffer_line (c->ctx, buffer, line); + relay_send (c); + } + } + + relay_prepare_buffer_activate (c->ctx, c->ctx->current_buffer); + relay_send (c); +} + +static const char * +client_message_buffer_name (const struct relay_command_message *m) +{ + switch (m->data.command) + { + case RELAY_COMMAND_BUFFER_COMPLETE: + return m->data.buffer_input.buffer_name.str; + case RELAY_COMMAND_BUFFER_INPUT: + return m->data.buffer_input.buffer_name.str; + case RELAY_COMMAND_BUFFER_ACTIVATE: + return m->data.buffer_activate.buffer_name.str; + case RELAY_COMMAND_BUFFER_LOG: + return m->data.buffer_log.buffer_name.str; + default: + return NULL; + } +} + +static void +client_process_buffer_log + (struct client *c, uint32_t seq, struct buffer *buffer) +{ + struct relay_event_message *m = relay_prepare (c->ctx); + struct relay_event_data_response *e = &m->data.response; + e->event = RELAY_EVENT_RESPONSE; + e->command_seq = seq; + e->data.command = RELAY_COMMAND_BUFFER_LOG; + + char *path = buffer_get_log_path (buffer); + FILE *fp = open_log_path (c->ctx, buffer, path); + if (fp) + { + struct str log = str_make (); + char buf[BUFSIZ]; + size_t len; + while ((len = fread (buf, 1, sizeof buf, fp))) + str_append_data (&log, buf, len); + if (ferror (fp)) + log_global_error (c->ctx, "Failed to read `#l': #l", + path, strerror (errno)); + + // On overflow, it will later fail serialization. + e->data.buffer_log.log_len = MIN (UINT32_MAX, log.len); + e->data.buffer_log.log = (uint8_t *) str_steal (&log); + fclose (fp); + } + + // XXX: We log failures to the global buffer, + // so the client just receives nothing if there is no log file. + + free (path); + relay_send (c); +} + +static bool +client_process_message (struct client *c, + struct msg_unpacker *r, struct relay_command_message *m) +{ + if (!relay_command_message_deserialize (m, r) + || msg_unpacker_get_available (r)) + { + print_error ("deserialization failed, killing client"); + return false; + } + + const char *buffer_name = client_message_buffer_name (m); + struct buffer *buffer = NULL; + if (buffer_name && !(buffer = buffer_by_name (c->ctx, buffer_name))) + { + relay_prepare_error (c->ctx, m->command_seq, "Unknown buffer"); + relay_send (c); + return true; + } + + switch (m->data.command) + { + case RELAY_COMMAND_HELLO: + if (m->data.hello.version != RELAY_VERSION) + { + // TODO: This should send back an error message and shut down. + print_error ("protocol version mismatch, killing client"); + return false; + } + c->initialized = true; + client_resync (c); + break; + case RELAY_COMMAND_PING: + relay_prepare_ping (c->ctx); + relay_send (c); + break; + case RELAY_COMMAND_ACTIVE: + reset_autoaway (c->ctx); + break; + case RELAY_COMMAND_BUFFER_COMPLETE: + // TODO: Run the completion machinery. + relay_prepare_error (c->ctx, m->command_seq, "Not implemented"); + relay_send (c); + break; + case RELAY_COMMAND_BUFFER_INPUT: + (void) process_input_utf8 (c->ctx, + buffer, m->data.buffer_input.text.str, 0); + break; + case RELAY_COMMAND_BUFFER_ACTIVATE: + buffer_activate (c->ctx, buffer); + break; + case RELAY_COMMAND_BUFFER_LOG: + client_process_buffer_log (c, m->command_seq, buffer); + break; + default: + print_warning ("unhandled client command"); + relay_prepare_error (c->ctx, m->command_seq, "Unknown command"); + relay_send (c); + } + return true; +} + +static bool +client_process_buffer (struct client *c) +{ + struct str *buf = &c->read_buffer; + size_t offset = 0; + while (true) + { + uint32_t frame_len = 0; + struct msg_unpacker r = + msg_unpacker_make (buf->str + offset, buf->len - offset); + if (!msg_unpacker_u32 (&r, &frame_len)) + break; + + r.len = MIN (r.len, sizeof frame_len + frame_len); + if (msg_unpacker_get_available (&r) < frame_len) + break; + + struct relay_command_message m = {}; + bool ok = client_process_message (c, &r, &m); + relay_command_message_free (&m); + if (!ok) + return false; + + offset += r.offset; + } + + str_remove_slice (buf, 0, offset); + return true; +} + // --- Tests ------------------------------------------------------------------- // The application is quite monolithic and can only be partially unit-tested. @@ -853,8 +853,6 @@ client_send_str (struct client *c, const struct str *s) str_append_data (&c->write_buffer, s->str, MIN (s->len, IRC_MAX_MESSAGE_LENGTH)); str_append (&c->write_buffer, "\r\n"); - // XXX: we might want to move this elsewhere, so that it doesn't get called - // as often; it's going to cause a lot of syscalls with epoll. client_update_poller (c, NULL); // Technically we haven't sent it yet but that's a minor detail @@ -3095,6 +3093,7 @@ irc_try_read (struct client *c) { buf->str[buf->len += n_read] = '\0'; // TODO: discard characters above the 512 character limit + // FIXME: we should probably discard the data if closing_link irc_process_buffer (buf, irc_process_message, c); continue; } @@ -3136,6 +3135,7 @@ irc_try_read_tls (struct client *c) case SSL_ERROR_NONE: buf->str[buf->len += n_read] = '\0'; // TODO: discard characters above the 512 character limit + // FIXME: we should probably discard the data if closing_link irc_process_buffer (buf, irc_process_message, c); continue; case SSL_ERROR_ZERO_RETURN: @@ -3421,16 +3421,10 @@ irc_try_fetch_client (struct server_context *ctx, int listen_fd) if (errno == EINTR) return true; - if (errno == EBADF - || errno == EINVAL - || errno == ENOTSOCK - || errno == EOPNOTSUPP) + if (accept_error_is_transient (errno)) + print_warning ("%s: %s", "accept", strerror (errno)); + else print_fatal ("%s: %s", "accept", strerror (errno)); - - // OS kernels may return a wide range of unforeseeable errors. - // Assuming that they're either transient or caused by - // a connection that we've just extracted from the queue. - print_warning ("%s: %s", "accept", strerror (errno)); return true; } @@ -3814,10 +3808,9 @@ irc_lock_pid_file (struct server_context *ctx, struct error **e) } static int -irc_listen (struct addrinfo *gai_iter) +irc_listen (struct addrinfo *ai) { - int fd = socket (gai_iter->ai_family, - gai_iter->ai_socktype, gai_iter->ai_protocol); + int fd = socket (ai->ai_family, ai->ai_socktype, ai->ai_protocol); if (fd == -1) return -1; set_cloexec (fd); @@ -3831,21 +3824,13 @@ irc_listen (struct addrinfo *gai_iter) #if defined SOL_IPV6 && defined IPV6_V6ONLY // Make NULL always bind to both IPv4 and IPv6, irrespectively of the order // of results; only INADDR6_ANY seems to be affected by this - if (gai_iter->ai_family == AF_INET6) + if (ai->ai_family == AF_INET6) soft_assert (setsockopt (fd, SOL_IPV6, IPV6_V6ONLY, &yes, sizeof yes) != -1); #endif - char host[NI_MAXHOST], port[NI_MAXSERV]; - host[0] = port[0] = '\0'; - int err = getnameinfo (gai_iter->ai_addr, gai_iter->ai_addrlen, - host, sizeof host, port, sizeof port, - NI_NUMERICHOST | NI_NUMERICSERV); - if (err) - print_debug ("%s: %s", "getnameinfo", gai_strerror (err)); - - char *address = format_host_port_pair (host, port); - if (bind (fd, gai_iter->ai_addr, gai_iter->ai_addrlen)) + char *address = gai_reconstruct_address (ai); + if (bind (fd, ai->ai_addr, ai->ai_addrlen)) print_error ("bind to %s failed: %s", address, strerror (errno)); else if (listen (fd, 16 /* arbitrary number */)) print_error ("listen on %s failed: %s", address, strerror (errno)); @@ -3865,12 +3850,12 @@ static void irc_listen_resolve (struct server_context *ctx, const char *host, const char *port, struct addrinfo *gai_hints) { - struct addrinfo *gai_result, *gai_iter; + struct addrinfo *gai_result = NULL, *gai_iter = NULL; int err = getaddrinfo (host, port, gai_hints, &gai_result); if (err) { char *address = format_host_port_pair (host, port); - print_error ("bind to %s failed: %s: %s", + print_error ("binding to %s failed: %s: %s", address, "getaddrinfo", gai_strerror (err)); free (address); return; @@ -0,0 +1,172 @@ +/* + * xF.c: a toothless IRC client frontend + * + * Copyright (c) 2022, Přemysl Eric Janouch <p@janouch.name> + * + * Permission to use, copy, modify, and/or distribute this software for any + * purpose with or without fee is hereby granted. + * + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES + * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY + * SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION + * OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN + * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + * + */ + +#include "config.h" +#define PROGRAM_NAME "xF" + +#include "common.c" +#include "xC-proto.c" + +#include <X11/Xatom.h> +#include <X11/Xlib.h> +#include <X11/keysym.h> +#include <X11/XKBlib.h> +#include <X11/Xft/Xft.h> + +// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + +static struct +{ + bool polling; + struct connector connector; + int socket; +} +g; + +static void +on_connector_connecting (void *user_data, const char *address) +{ + (void) user_data; + print_status ("connecting to %s...", address); +} + +static void +on_connector_error (void *user_data, const char *error) +{ + (void) user_data; + print_status ("connection failed: %s", error); +} + +static void +on_connector_failure (void *user_data) +{ + (void) user_data; + exit_fatal ("giving up"); +} + +static void +on_connector_connected (void *user_data, int socket, const char *hostname) +{ + (void) user_data; + (void) hostname; + g.polling = false; + g.socket = socket; +} + +static void +protocol_test (const char *host, const char *port) +{ + struct poller poller = {}; + poller_init (&poller); + + connector_init (&g.connector, &poller); + g.connector.on_connecting = on_connector_connecting; + g.connector.on_error = on_connector_error; + g.connector.on_connected = on_connector_connected; + g.connector.on_failure = on_connector_failure; + + connector_add_target (&g.connector, host, port); + + g.polling = true; + while (g.polling) + poller_run (&poller); + + connector_free (&g.connector); + + struct str s = str_make (); + str_pack_u32 (&s, 0); + struct relay_command_message m = {}; + m.data.hello.command = RELAY_COMMAND_HELLO; + m.data.hello.version = RELAY_VERSION; + if (!relay_command_message_serialize (&m, &s)) + exit_fatal ("serialization failed"); + + uint32_t len = htonl (s.len - sizeof len); + memcpy (s.str, &len, sizeof len); + if (errno = 0, write (g.socket, s.str, s.len) != (ssize_t) s.len) + exit_fatal ("short send or error: %s", strerror (errno)); + + char buf[1 << 20] = ""; + while (errno = 0, read (g.socket, &len, sizeof len) == sizeof len) + { + len = ntohl (len); + if (errno = 0, read (g.socket, buf, MIN (len, sizeof buf)) != len) + exit_fatal ("short read or error: %s", strerror (errno)); + + struct msg_unpacker r = msg_unpacker_make (buf, len); + struct relay_event_message m = {}; + if (!relay_event_message_deserialize (&m, &r)) + exit_fatal ("deserialization failed"); + if (msg_unpacker_get_available (&r)) + exit_fatal ("trailing data"); + + printf ("event: %d\n", m.data.event); + relay_event_message_free (&m); + } + exit_fatal ("short read or error: %s", strerror (errno)); +} + +// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + +int +main (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" }, + { 0, NULL, NULL, 0, NULL } + }; + + struct opt_handler oh = opt_handler_make (argc, argv, opts, + "HOST:PORT", "X11 frontend for xC."); + + int c; + while ((c = opt_handler_get (&oh)) != -1) + switch (c) + { + case 'h': + opt_handler_usage (&oh, stdout); + exit (EXIT_SUCCESS); + case 'V': + printf (PROGRAM_NAME " " PROGRAM_VERSION "\n"); + exit (EXIT_SUCCESS); + default: + print_error ("wrong options"); + opt_handler_usage (&oh, stderr); + exit (EXIT_FAILURE); + } + + argc -= optind; + argv += optind; + if (argc != 1) + { + opt_handler_usage (&oh, stderr); + exit (EXIT_FAILURE); + } + opt_handler_free (&oh); + + char *address = xstrdup (argv[0]); + const char *port = NULL, *host = tokenize_host_port (address, &port); + if (!port) + exit_fatal ("missing port number/service name"); + + // TODO: Actually implement an X11-based user interface. + protocol_test (host, port); + return 0; +} @@ -0,0 +1,36 @@ +<?xml version="1.0" encoding="UTF-8" standalone="no"?> +<svg version="1.1" width="48" height="48" viewBox="0 0 48 48" + xmlns:xlink="http://www.w3.org/1999/xlink" + xmlns="http://www.w3.org/2000/svg" + xmlns:svg="http://www.w3.org/2000/svg"> + + <defs> + <linearGradient id="background" x1="0" y1="0" x2="1" y2="1"> + <stop stop-color="#808080" offset="0" /> + <stop stop-color="#000000" offset="1" /> + </linearGradient> + <!-- librsvg screws up the filter's orientation in a weird way + otherwise a larger blur value would look better --> + <filter id="shadow" color-interpolation-filters="sRGB"> + <feOffset dy="0.5" /> + <feGaussianBlur stdDeviation="0.5" /> + <feComposite in2="SourceGraphic" operator="in" /> + </filter> + <clipPath id="clip"> + <rect x="-7" y="-10" width="14" height="20" /> + </clipPath> + </defs> + + <circle cx="24" cy="24" r="20" + fill="url(#background)" stroke="#404040" stroke-width="2" /> + + <g transform="rotate(-45 24 24)" filter="url(#shadow)"> + <path d="m 12,25 h 24 v 11 h -5 v -8 h -4.5 v 6 h -5 v -6 h -9.5 z" + fill="#ffffff" /> + <g stroke-width="4" transform="translate(24, 16)" clip-path="url(#clip)" + stroke="#ffffff"> + <line x1="-8" x2="8" y1="-5" y2="5" /> + <line x1="-8" x2="8" y1="5" y2="-5" /> + </g> + </g> +</svg> diff --git a/xP/.gitignore b/xP/.gitignore new file mode 100644 index 0000000..68c09f0 --- /dev/null +++ b/xP/.gitignore @@ -0,0 +1,3 @@ +/xP +/proto.go +/public/mithril.js diff --git a/xP/Makefile b/xP/Makefile new file mode 100644 index 0000000..3c52146 --- /dev/null +++ b/xP/Makefile @@ -0,0 +1,14 @@ +.POSIX: +.SUFFIXES: + +outputs = xP proto.go public/mithril.js +all: $(outputs) + +xP: xP.go proto.go + go build -o $@ +proto.go: ../xC-gen-proto.awk ../xC-gen-proto-go.awk ../xC-proto + awk -f ../xC-gen-proto.awk -f ../xC-gen-proto-go.awk ../xC-proto > $@ +public/mithril.js: + curl -Lo $@ https://unpkg.com/mithril/mithril.js +clean: + rm -f $(outputs) diff --git a/xP/go.mod b/xP/go.mod new file mode 100644 index 0000000..7d4369e --- /dev/null +++ b/xP/go.mod @@ -0,0 +1,5 @@ +module janouch.name/xK + +go 1.18 + +require golang.org/x/net v0.0.0-20210805182204-aaa1db679c0d diff --git a/xP/go.sum b/xP/go.sum new file mode 100644 index 0000000..cd5264f --- /dev/null +++ b/xP/go.sum @@ -0,0 +1,2 @@ +golang.org/x/net v0.0.0-20210805182204-aaa1db679c0d h1:20cMwl2fHAzkJMEA+8J4JgqBQcQGzbisXo31MIeenXI= +golang.org/x/net v0.0.0-20210805182204-aaa1db679c0d/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y= diff --git a/xP/public/xP.css b/xP/public/xP.css new file mode 100644 index 0000000..9a98c13 --- /dev/null +++ b/xP/public/xP.css @@ -0,0 +1,109 @@ +body { + margin: 0; + padding: 0; + font-family: sans-serif; +} + +.xP { + height: 100vh; + display: flex; + flex-direction: column; + overflow: hidden; +} + +.title, .status { + background: #f8f8f8; + border-bottom: 1px solid #ccc; + padding: .05rem .3rem; +} + +.middle { + flex: auto; + display: flex; + flex-direction: row; + overflow: hidden; +} + +.list { + overflow-y: auto; + border-right: 1px solid #ccc; + min-width: 10rem; +} +.item { + padding: .05rem .3rem; + cursor: default; +} +.item.active { + font-weight: bold; +} + +/* Only Firefox currently supports align-content: safe end, thus this. */ +.buffer-container { + flex: auto; + display: flex; + flex-direction: column; + overflow: hidden; +} +.filler { + flex: auto; +} +.buffer { + display: grid; + grid-template-columns: max-content auto; + overflow-y: auto; +} + +.date { + padding: .3rem; + grid-column: span 2; + font-weight: bold; +} +.time { + padding: .1rem .3rem; + background: #f8f8f8; + color: #bbb; + border-right: 1px solid #ccc; +} +.mark { + padding-right: .3rem; + text-align: center; + display: inline-block; + min-width: 2rem; +} +.mark.error { + color: red; +} +.mark.join { + color: green; +} +.mark.part { + color: red; +} +.content { + padding: .1rem .3rem; + white-space: pre-wrap; +} +.content span.b { + font-weight: bold; +} +.content span.i { + font-style: italic; +} +.content span.u { + text-decoration: underline; +} +.content span.s { + text-decoration: line-through; +} +.content span.m { + font-family: monospace; +} + +.status { + border-top: 2px solid #fff; +} + +textarea { + padding: .05rem .3rem; + font-family: inherit; +} diff --git a/xP/public/xP.js b/xP/public/xP.js new file mode 100644 index 0000000..4eebb7a --- /dev/null +++ b/xP/public/xP.js @@ -0,0 +1,188 @@ +// TODO: Probably reset state on disconnect, and indicate to user. +let socket = new WebSocket(proxy) + +let commandSeq = 0 +function send(command) { + socket.send(JSON.stringify({commandSeq: ++commandSeq, data: command})) +} + +socket.onopen = function(event) { + send({command: 'Hello', version: 1}) +} + +let buffers = new Map() +let bufferCurrent = undefined + +socket.onmessage = function(event) { + console.log(event.data) + + let e = JSON.parse(event.data).data + switch (e.event) { + case 'BufferUpdate': + { + let b = buffers.get(e.bufferName) + if (b === undefined) { + b = {lines: []} + buffers.set(e.bufferName, b) + } + // TODO: Update any buffer properties. + break + } + case 'BufferRename': + buffers.set(e.new, buffers.get(e.bufferName)) + buffers.delete(e.bufferName) + break + case 'BufferRemove': + buffers.delete(e.bufferName) + break + case 'BufferActivate': + bufferCurrent = e.bufferName + // TODO: Somehow scroll to the end of it immediately. + // TODO: Focus the textarea. + break + case 'BufferLine': + { + let b = buffers.get(e.bufferName) + if (b !== undefined) + b.lines.push({when: e.when, rendition: e.rendition, items: e.items}) + break + } + case 'BufferClear': + { + let b = buffers.get(e.bufferName) + if (b !== undefined) + b.lines.length = 0 + break + } + } + + m.redraw() +} + +let BufferList = { + view: vnode => { + let items = [] + buffers.forEach((b, name) => { + let attrs = { + onclick: e => { + send({command: 'BufferActivate', bufferName: name}) + }, + } + if (name == bufferCurrent) + attrs.class = 'active' + items.push(m('.item', attrs, name)) + }) + return m('.list', {}, items) + }, +} + +let Content = { + view: vnode => { + let line = vnode.children[0] + let content = [] + switch (line.rendition) { + case 'Indent': content.push(m('span.mark', {}, '')); break + case 'Status': content.push(m('span.mark', {}, '–')); break + case 'Error': content.push(m('span.mark.error', {}, '⚠')); break + case 'Join': content.push(m('span.mark.join', {}, '→')); break + case 'Part': content.push(m('span.mark.part', {}, '←')); break + } + + let classes = new Set() + let flip = c => { + if (classes.has(c)) + classes.delete(c) + else + classes.add(c) + } + line.items.forEach(item => { + // TODO: Colours. + switch (item.kind) { + case 'Text': + // TODO: Detect and transform links. + content.push(m('span', { + class: Array.from(classes.keys()).join(' '), + }, item.text)) + break + case 'Reset': + classes.clear() + break + case 'FlipBold': flip('b'); break + case 'FlipItalic': flip('i'); break + case 'FlipUnderline': flip('u'); break + case 'FlipInverse': flip('i'); break + case 'FlipCrossedOut': flip('s'); break + case 'FlipMonospace': flip('m'); break + } + }) + return m('.content', {}, content) + }, +} + +let Buffer = { + view: vnode => { + let lines = [] + let b = buffers.get(bufferCurrent) + if (b === undefined) + return + + let lastDateMark = undefined + b.lines.forEach(line => { + let date = new Date(line.when * 1000) + let dateMark = date.toLocaleDateString() + if (dateMark !== lastDateMark) { + lines.push(m('.date', {}, dateMark)) + lastDateMark = dateMark + } + + lines.push(m('.time', {}, date.toLocaleTimeString())) + lines.push(m(Content, {}, line)) + }) + return m('.buffer-container', {}, [ + m('.filler'), + m('.buffer', {}, lines), + ]) + }, +} + +// TODO: This should be remembered across buffer switches, +// and we'll probably have to intercept /all/ key presses. +let Input = { + view: vnode => { + return m('textarea', { + rows: 1, + onkeydown: e => { + // TODO: And perhaps on other actions, too. + send({command: 'Active'}) + if (e.keyCode !== 13) + return + + send({ + command: 'BufferInput', + bufferName: bufferCurrent, + text: e.currentTarget.value, + }) + e.preventDefault() + e.currentTarget.value = '' + }, + }) + }, +} + +let Main = { + view: vnode => { + return m('.xP', {}, [ + m('.title', {}, "xP"), + m('.middle', {}, [m(BufferList), m(Buffer)]), + m('.status', {}, bufferCurrent), + m(Input), + ]) + }, +} + +// TODO: Buffer names should work as routes. +window.addEventListener('load', () => { + m.route(document.body, '/', { + '/': Main, + }) +}) diff --git a/xP/xP.example.json b/xP/xP.example.json new file mode 100644 index 0000000..2c63c08 --- /dev/null +++ b/xP/xP.example.json @@ -0,0 +1,2 @@ +{ +} diff --git a/xP/xP.go b/xP/xP.go new file mode 100644 index 0000000..9b5df8f --- /dev/null +++ b/xP/xP.go @@ -0,0 +1,186 @@ +package main + +import ( + "context" + "encoding/binary" + "encoding/json" + "fmt" + "html/template" + "io" + "log" + "net" + "net/http" + "os" + "time" + + "golang.org/x/net/websocket" +) + +var ( + addressBind string + addressConnect string +) + +func clientToRelay( + ctx context.Context, ws *websocket.Conn, conn net.Conn) bool { + var j string + if err := websocket.Message.Receive(ws, &j); err != nil { + log.Println("Command receive failed: " + err.Error()) + return false + } + + log.Printf("?> %s\n", j) + + var m RelayCommandMessage + if err := json.Unmarshal([]byte(j), &m); err != nil { + log.Println("Command unmarshalling failed: " + err.Error()) + return false + } + + b, ok := m.AppendTo(make([]byte, 4)) + if !ok { + log.Println("Command serialization failed") + return false + } + binary.BigEndian.PutUint32(b[:4], uint32(len(b)-4)) + if _, err := conn.Write(b); err != nil { + log.Println("Command send failed: " + err.Error()) + return false + } + + log.Printf("-> %v\n", b) + return true +} + +func relayToClient( + ctx context.Context, ws *websocket.Conn, conn net.Conn) bool { + var length uint32 + if err := binary.Read(conn, binary.BigEndian, &length); err != nil { + log.Println("Event receive failed: " + err.Error()) + return false + } + b := make([]byte, length) + if _, err := io.ReadFull(conn, b); err != nil { + log.Println("Event receive failed: " + err.Error()) + return false + } + + log.Printf("<? %v\n", b) + + var m RelayEventMessage + if after, ok := m.ConsumeFrom(b); !ok { + log.Println("Event deserialization failed") + return false + } else if len(after) != 0 { + log.Println("Event deserialization failed: trailing data") + return false + } + + j, err := json.Marshal(&m) + if err != nil { + log.Println("Event marshalling failed: " + err.Error()) + return false + } + if err := websocket.Message.Send(ws, string(j)); err != nil { + log.Println("Event send failed: " + err.Error()) + return false + } + + log.Printf("<- %s\n", j) + return true +} + +func errorToClient(ws *websocket.Conn, err error) bool { + j, err := json.Marshal(&RelayEventMessage{ + EventSeq: 0, + Data: RelayEventData{ + Interface: RelayEventDataError{ + Event: RelayEventError, + CommandSeq: 0, + Error: err.Error(), + }, + }, + }) + if err != nil { + log.Println("Event marshalling failed: " + err.Error()) + return false + } + if err := websocket.Message.Send(ws, string(j)); err != nil { + log.Println("Event send failed: " + err.Error()) + return false + } + return true +} + +func handleWebSocket(ws *websocket.Conn) { + conn, err := net.Dial("tcp", addressConnect) + if err != nil { + errorToClient(ws, err) + return + } + + // We don't need to intervene, so it's just two separate pipes so far. + ctx, cancel := context.WithCancel(ws.Request().Context()) + go func() { + for clientToRelay(ctx, ws, conn) { + } + cancel() + }() + go func() { + for relayToClient(ctx, ws, conn) { + } + cancel() + }() + <-ctx.Done() +} + +var staticHandler = http.FileServer(http.Dir(".")) + +var page = template.Must(template.New("/").Parse(`<!DOCTYPE html> +<html> +<head> + <title>xP</title> + <meta charset="utf-8" /> + <link rel="stylesheet" href="xP.css" /> +</head> +<body> + <script src="mithril.js"> + </script> + <script> + let proxy = '{{ . }}' + </script> + <script src="xP.js"> + </script> +</body> +</html>`)) + +func handleDefault(w http.ResponseWriter, r *http.Request) { + if r.URL.Path != "/" { + staticHandler.ServeHTTP(w, r) + return + } + + wsURI := fmt.Sprintf("ws://%s/ws", r.Host) + if err := page.Execute(w, wsURI); err != nil { + log.Println("Template execution failed: " + err.Error()) + } +} + +func main() { + if len(os.Args) != 3 { + log.Fatalf("usage: %s BIND CONNECT\n", os.Args[0]) + } + + addressBind, addressConnect = os.Args[1], os.Args[2] + + http.Handle("/ws", websocket.Handler(handleWebSocket)) + http.Handle("/", http.HandlerFunc(handleDefault)) + + s := &http.Server{ + Addr: addressBind, + ReadTimeout: 60 * time.Second, + WriteTimeout: 60 * time.Second, + MaxHeaderBytes: 32 << 10, + } + log.Fatal(s.ListenAndServe()) +} |
