Bump liberty, make use of its new asciiman.awk

It's visible enough.

.clang-format

@@ -0,0 +1,32 @@
+# clang-format is fairly limited, and these rules are approximate:
+#  - array initializers can get terribly mangled with clang-format 12.0,
+#  - sometimes it still aligns with space characters,
+#  - struct name NL { NL ... NL } NL name; is unachievable.
+BasedOnStyle: GNU
+ColumnLimit: 80
+IndentWidth: 4
+TabWidth: 4
+UseTab: ForContinuationAndIndentation
+BreakBeforeBraces: Allman
+SpaceAfterCStyleCast: true
+AlignAfterOpenBracket: DontAlign
+AlignOperands: DontAlign
+AlignConsecutiveMacros: Consecutive
+AllowAllArgumentsOnNextLine: false
+AllowAllParametersOfDeclarationOnNextLine: false
+IndentGotoLabels: false
+
+# IncludeCategories has some potential, but it may also break the build.
+# Note that the documentation says the value should be "Never".
+SortIncludes: false
+
+# This is a compromise, it generally works out aesthetically better.
+BinPackArguments: false
+
+# Unfortunately, this can't be told to align to column 40 or so.
+SpacesBeforeTrailingComments: 2
+
+# liberty-specific macro body wrappers.
+MacroBlockBegin: "BLOCK_START"
+MacroBlockEnd: "BLOCK_END"
+ForEachMacros: ["LIST_FOR_EACH"]

.gitignore

@@ -3,7 +3,9 @@
 
 # Qt Creator files
 /CMakeLists.txt.user*
-/uirc3.config
-/uirc3.files
-/uirc3.creator*
-/uirc3.includes
+/xK.config
+/xK.files
+/xK.creator*
+/xK.includes
+/xK.cflags
+/xK.cxxflags

.gitmodules

@@ -1,3 +1,3 @@
 [submodule "liberty"]
 	path = liberty
-	url = git://github.com/pjanouch/liberty.git
+	url = https://git.janouch.name/p/liberty.git

.travis.yml

@@ -1,39 +0,0 @@
-language: c
-notifications:
- irc:
-  channels: "anathema.irc.so#anathema"
-  use_notice: true
-  skip_join: true
-env:
- global:
-  - secure: "ck6keK5tTbVCN7VGyKglS890hjovUNt2zyOydiyFtQDciaB/rvEwkKy4anMCEdZHFpGAPE9iBmNYaGUsD1Y+KifhhImVMbuThe2D8MLv5crSLRheYPbbmhO8MWPAxmQnuQhpwsUKZlHvUfX8nh+d0juNdqXklvhVml78Gi99QFw="
- matrix:
-  - readline=ON libedit=OFF
-  - readline=OFF libedit=ON
-addons:
- coverity_scan:
-  project:
-   name: "pjanouch/uirc3"
-   description: "Experimental IRC client, daemon and bot"
-  notification_email: p.janouch@gmail.com
-  build_command_prepend: "cmake .. -DCMAKE_BUILD_TYPE=Release"
-  build_command: "make"
-  branch_pattern: coverity_scan
-compiler:
- - clang
- - gcc
-before_install:
- # We need this PPA for a recent version of libedit
- - sudo add-apt-repository ppa:ondrej/php5-5.6 -y
- - sudo apt-get update -qq
-install:
- - sudo apt-get install -y help2man libedit-dev expect
-before_script:
- - mkdir build
- - cd build
-script:
- - cmake .. -DCMAKE_INSTALL_PREFIX=/usr
-   -DWANT_READLINE=$readline -DWANT_LIBEDIT=$libedit
- - make
- - cpack -G DEB
- - ../test

CMakeLists.txt

@@ -1,149 +1,294 @@
-project (uirc3 C)
-cmake_minimum_required (VERSION 2.8.5)
+# Ubuntu 18.04 LTS and OpenBSD 6.4
+cmake_minimum_required (VERSION 3.10)
+project (xK VERSION 1.5.0
+	DESCRIPTION "IRC daemon, bot, TUI client and its web frontend" 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
-if ("${CMAKE_C_COMPILER_ID}" MATCHES "GNU" OR CMAKE_COMPILER_IS_GNUC)
+set (CMAKE_C_STANDARD 99)
+set (CMAKE_C_STANDARD_REQUIRED ON)
+set (CMAKE_C_EXTENSIONS OFF)
+
+if ("${CMAKE_C_COMPILER_ID}" MATCHES "GNU" OR CMAKE_COMPILER_IS_GNUCC)
 	# -Wunused-function is pretty annoying here, as everything is static
-	set (CMAKE_C_FLAGS "-std=c99 -Wall -Wextra -Wno-unused-function")
-endif ("${CMAKE_C_COMPILER_ID}" MATCHES "GNU" OR CMAKE_COMPILER_IS_GNUC)
+	set (CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wall -Wextra -Wno-unused-function")
+endif ()
 
 # Version
-set (project_VERSION_MAJOR "0")
-set (project_VERSION_MINOR "9")
-set (project_VERSION_PATCH "0")
+set (project_version "${PROJECT_VERSION}")
 
-set (project_VERSION "${project_VERSION_MAJOR}")
-set (project_VERSION "${project_VERSION}.${project_VERSION_MINOR}")
-set (project_VERSION "${project_VERSION}.${project_VERSION_PATCH}")
+# Try to append commit ID if it follows a version tag.  It might be nicer if
+# we could also detect dirty worktrees but that's very hard to get right.
+# If we didn't need this for CPack, we could use add_custom_command to generate
+# a version source/include file.
+find_package (Git)
+set (git_head "${PROJECT_SOURCE_DIR}/.git/HEAD")
+if (GIT_FOUND AND EXISTS "${git_head}")
+	configure_file ("${git_head}" git-head.tag COPYONLY)
+	file (READ "${git_head}" git_head_content)
+	if (git_head_content MATCHES "^ref: ([^\r\n]+)")
+		set (git_ref "${PROJECT_SOURCE_DIR}/.git/${CMAKE_MATCH_1}")
+		if (EXISTS "${git_ref}")
+			configure_file ("${git_ref}" git-ref.tag COPYONLY)
+		endif ()
+	endif ()
+
+	execute_process (COMMAND ${GIT_EXECUTABLE} describe --tags --match v*
+		WORKING_DIRECTORY ${PROJECT_SOURCE_DIR}
+		RESULT_VARIABLE git_describe_result
+		OUTPUT_VARIABLE git_describe OUTPUT_STRIP_TRAILING_WHITESPACE)
+	if (NOT git_describe_result)
+		string (REGEX REPLACE "^v" "" project_version "${git_describe}")
+	endif ()
+endif ()
+
+# Dashes make filenames confusing and upset packaging software
+string (REPLACE "-" "+" project_version_safe "${project_version}")
 
 # Dependencies
-find_package (Curses)
+set (CMAKE_MODULE_PATH ${PROJECT_SOURCE_DIR}/liberty/cmake)
+include (AddThreads)
+
 find_package (PkgConfig REQUIRED)
 pkg_check_modules (libssl REQUIRED libssl libcrypto)
-pkg_check_modules (ncursesw ncursesw)
-
-if ("${CMAKE_SYSTEM_NAME}" MATCHES "BSD")
-	# iconv() doesn't have to be present in libc
-	# FIXME: detect if we need the library independently on the platform
-	list (APPEND project_libraries iconv)
-	# Need this for SIGWINCH; our POSIX version macros make it undefined
-	add_definitions (-D__BSD_VISIBLE=1)
-endif ("${CMAKE_SYSTEM_NAME}" MATCHES "BSD")
-
-# -lpthread is only there for debugging (gdb & errno)
-# -lrt is only for glibc < 2.17
-list (APPEND project_libraries ${libssl_LIBRARIES} rt pthread)
+list (APPEND project_libraries ${libssl_LIBRARIES})
 include_directories (${libssl_INCLUDE_DIRS})
 link_directories (${libssl_LIBRARY_DIRS})
 
+if ("${CMAKE_SYSTEM_NAME}" MATCHES "BSD")
+	# Need this for SIGWINCH in FreeBSD and OpenBSD respectively;
+	# our POSIX version macros make it undefined
+	add_definitions (-D__BSD_VISIBLE=1 -D_BSD_SOURCE=1)
+elseif (APPLE)
+	add_definitions (-D_DARWIN_C_SOURCE)
+endif ()
+
+# -lrt is only for glibc < 2.17
+# -liconv may or may not be a part of libc
+# -lm may or may not be a part of libc
+foreach (extra iconv rt m)
+	find_library (extra_lib_${extra} ${extra})
+	if (extra_lib_${extra})
+		list (APPEND project_libraries ${extra_lib_${extra}})
+	endif ()
+endforeach ()
+
+include (CheckCSourceRuns)
+set (CMAKE_REQUIRED_LIBRARIES ${project_libraries})
+get_property (CMAKE_REQUIRED_INCLUDES
+	DIRECTORY "${PROJECT_SOURCE_DIR}" PROPERTY INCLUDE_DIRECTORIES)
+CHECK_C_SOURCE_RUNS ("#include <iconv.h>
+	int main () { return iconv_open (\"UTF-8//TRANSLIT\", \"ISO-8859-1\")
+		== (iconv_t) -1; }" ICONV_ACCEPTS_TRANSLIT)
+
+# Dependencies for xC
+pkg_check_modules (libffi REQUIRED libffi)
+list (APPEND xC_libraries ${libffi_LIBRARIES})
+include_directories (${libffi_INCLUDE_DIRS})
+link_directories (${libffi_LIBRARY_DIRS})
+
+# XXX: other Lua versions may be acceptable, don't know yet
+pkg_search_module (lua lua53 lua5.3 lua-5.3 lua54 lua5.4 lua-5.4 lua>=5.3)
+option (WITH_LUA "Enable support for Lua plugins" ${lua_FOUND})
+
+if (WITH_LUA)
+	if (NOT lua_FOUND)
+		message (FATAL_ERROR "Lua library not found")
+	endif ()
+
+	list (APPEND xC_libraries ${lua_LIBRARIES})
+	include_directories (${lua_INCLUDE_DIRS})
+	link_directories (${lua_LIBRARY_DIRS})
+endif ()
+
+find_package (Curses)
+pkg_check_modules (ncursesw ncursesw)
 if (ncursesw_FOUND)
-	list (APPEND project_libraries ${ncursesw_LIBRARIES})
+	list (APPEND xC_libraries ${ncursesw_LIBRARIES})
 	include_directories (${ncursesw_INCLUDE_DIRS})
 elseif (CURSES_FOUND)
-	list (APPEND project_libraries ${CURSES_LIBRARY})
+	list (APPEND xC_libraries ${CURSES_LIBRARY})
 	include_directories (${CURSES_INCLUDE_DIR})
-else (CURSES_FOUND)
+else ()
 	message (SEND_ERROR "Curses not found")
-endif (ncursesw_FOUND)
+endif ()
 
 if ((WANT_READLINE AND WANT_LIBEDIT) OR (NOT WANT_READLINE AND NOT WANT_LIBEDIT))
 	message (SEND_ERROR "You have to choose either GNU Readline or libedit")
 elseif (WANT_READLINE)
-	list (APPEND project_libraries readline)
+	pkg_check_modules (readline readline)
+
+	# OpenBSD's default readline is too old
+	if ("${CMAKE_SYSTEM_NAME}" MATCHES "OpenBSD")
+		include_directories (${OPENBSD_LOCALBASE}/include/ereadline)
+		list (APPEND xC_libraries ereadline)
+	elseif (readline_FOUND)
+		list (APPEND xC_libraries ${readline_LIBRARIES})
+		include_directories (${readline_INCLUDE_DIRS})
+		link_directories (${readline_LIBRARY_DIRS})
+	else ()
+		list (APPEND xC_libraries readline)
+	endif ()
 elseif (WANT_LIBEDIT)
 	pkg_check_modules (libedit REQUIRED libedit)
-	list (APPEND project_libraries ${libedit_LIBRARIES})
+	list (APPEND xC_libraries ${libedit_LIBRARIES})
 	include_directories (${libedit_INCLUDE_DIRS})
-endif ((WANT_READLINE AND WANT_LIBEDIT) OR (NOT WANT_READLINE AND NOT WANT_LIBEDIT))
+endif ()
 
 # Generate a configuration file
-if (WANT_READLINE)
-	set (HAVE_READLINE 1)
-endif (WANT_READLINE)
-
-if (WANT_LIBEDIT)
-	set (HAVE_EDITLINE 1)
-endif (WANT_LIBEDIT)
+set (HAVE_READLINE "${WANT_READLINE}")
+set (HAVE_EDITLINE "${WANT_LIBEDIT}")
+set (HAVE_LUA      "${WITH_LUA}")
 
 include (GNUInstallDirs)
-set (plugin_dir ${CMAKE_INSTALL_LIBDIR}/${PROJECT_NAME})
-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})
 
-# Project source files
-set (common_sources)
-set (common_headers ${PROJECT_BINARY_DIR}/config.h)
-
-add_custom_command (OUTPUT kike-replies.c kike.msg
-	COMMAND ${PROJECT_SOURCE_DIR}/kike-gen-replies.sh
-		> kike-replies.c < ${PROJECT_SOURCE_DIR}/kike-replies
-	DEPENDS ${PROJECT_SOURCE_DIR}/kike-replies
+# Generate IRC replies--we need a custom target because of the multiple outputs
+add_custom_command (OUTPUT xD-replies.c xD.msg
+	COMMAND env LC_ALL=C awk
+		-f ${PROJECT_SOURCE_DIR}/xD-gen-replies.awk
+		${PROJECT_SOURCE_DIR}/xD-replies > xD-replies.c
+	DEPENDS
+		${PROJECT_SOURCE_DIR}/xD-gen-replies.awk
+		${PROJECT_SOURCE_DIR}/xD-replies
 	COMMENT "Generating files from the list of server numerics")
-set_source_files_properties (${PROJECT_BINARY_DIR}/kike-replies.c
-	PROPERTIES HEADER_FILE_ONLY TRUE)
+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
-add_executable (zyklonb zyklonb.c ${common_sources} ${common_headers})
-target_link_libraries (zyklonb ${project_libraries})
+foreach (name xB xC xD)
+	add_executable (${name} ${name}.c ${project_config})
+	target_link_libraries (${name} ${project_libraries})
+	add_threads (${name})
+endforeach ()
 
-add_executable (degesch degesch.c kike-replies.c
-	${common_sources} ${common_headers})
-target_link_libraries (degesch ${project_libraries})
+add_dependencies (xD replies)
+add_dependencies (xC replies xC-proto)
+target_link_libraries (xC ${xC_libraries})
 
-add_executable (kike kike.c kike-replies.c ${common_sources} ${common_headers})
-target_link_libraries (kike ${project_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)
+	add_executable (test-xC $<TARGET_PROPERTY:xC,SOURCES>)
+	set_target_properties (test-xC PROPERTIES COMPILE_DEFINITIONS TESTING)
+	target_link_libraries (test-xC $<TARGET_PROPERTY:xC,LINK_LIBRARIES>)
+	add_threads (test-xC)
+	add_dependencies (test-xC replies)
+
+	add_test (NAME test-xC COMMAND test-xC)
+	add_test (NAME custom-static-analysis
+		COMMAND ${PROJECT_SOURCE_DIR}/test-static)
+endif ()
+
+# Various clang-based diagnostics, loads of fake positives and spam
+file (GLOB clang_tidy_sources *.c)
+set (clang_tidy_checks misc-* readability-*
+	-readability-braces-around-statements
+	-readability-named-parameter)
+string (REPLACE ";" "," clang_tidy_checks "${clang_tidy_checks}")
+
+set (CMAKE_EXPORT_COMPILE_COMMANDS ON)
+add_custom_target (clang-tidy
+	COMMAND clang-tidy -p ${PROJECT_BINARY_DIR} -checks=${clang_tidy_checks}
+		${clang_tidy_sources} 1>&2
+	USES_TERMINAL
+	WORKING_DIRECTORY ${PROJECT_SOURCE_DIR})
 
 # Installation
-install (TARGETS zyklonb degesch kike DESTINATION ${CMAKE_INSTALL_BINDIR})
+install (TARGETS xB xC xD DESTINATION ${CMAKE_INSTALL_BINDIR})
 install (FILES LICENSE DESTINATION ${CMAKE_INSTALL_DOCDIR})
+install (DIRECTORY plugins/xB/
+	DESTINATION ${CMAKE_INSTALL_DATADIR}/xB/plugins USE_SOURCE_PERMISSIONS)
+install (DIRECTORY plugins/xC/
+	DESTINATION ${CMAKE_INSTALL_DATADIR}/xC/plugins)
 
-foreach (plugin coin eval script youtube ${plugins})
-	install (FILES plugins/${plugin} DESTINATION ${plugin_dir})
-endforeach (plugin)
+# Generate documentation from text markup
+find_program (ASCIIDOCTOR_EXECUTABLE asciidoctor)
+find_program (A2X_EXECUTABLE a2x)
+if (NOT ASCIIDOCTOR_EXECUTABLE AND NOT A2X_EXECUTABLE)
+	message (WARNING "Neither asciidoctor nor a2x were found, "
+		"falling back to a substandard manual page generator")
+endif ()
 
-# Generate documentation from program help
-find_program (HELP2MAN_EXECUTABLE help2man)
-if (NOT HELP2MAN_EXECUTABLE)
-	message (FATAL_ERROR "help2man not found")
-endif (NOT HELP2MAN_EXECUTABLE)
-
-foreach (page zyklonb degesch kike)
+foreach (page xB xC xD)
 	set (page_output "${PROJECT_BINARY_DIR}/${page}.1")
 	list (APPEND project_MAN_PAGES "${page_output}")
-	add_custom_command (OUTPUT ${page_output}
-		COMMAND ${HELP2MAN_EXECUTABLE} -N
-			"${PROJECT_BINARY_DIR}/${page}" -o ${page_output}
-		DEPENDS ${page}
-		COMMENT "Generating man page for ${page}" VERBATIM)
-endforeach (page)
+	if (ASCIIDOCTOR_EXECUTABLE)
+		add_custom_command (OUTPUT ${page_output}
+			COMMAND ${ASCIIDOCTOR_EXECUTABLE} -b manpage
+				-a release-version=${project_version}
+				-o "${page_output}"
+				"${PROJECT_SOURCE_DIR}/${page}.adoc"
+			DEPENDS ${page}.adoc
+			COMMENT "Generating man page for ${page}" VERBATIM)
+	elseif (A2X_EXECUTABLE)
+		add_custom_command (OUTPUT ${page_output}
+			COMMAND ${A2X_EXECUTABLE} --doctype manpage --format manpage
+				-a release-version=${project_version}
+				-D "${PROJECT_BINARY_DIR}"
+				"${PROJECT_SOURCE_DIR}/${page}.adoc"
+			DEPENDS ${page}.adoc
+			COMMENT "Generating man page for ${page}" VERBATIM)
+	else ()
+		set (ASCIIMAN ${PROJECT_SOURCE_DIR}/liberty/tools/asciiman.awk)
+		add_custom_command (OUTPUT ${page_output}
+			COMMAND env LC_ALL=C awk -f ${ASCIIMAN}
+				"${PROJECT_SOURCE_DIR}/${page}.adoc" > ${page_output}
+			DEPENDS ${page}.adoc ${ASCIIMAN}
+			COMMENT "Generating man page for ${page}" VERBATIM)
+	endif ()
+endforeach ()
 
 add_custom_target (docs ALL DEPENDS ${project_MAN_PAGES})
 
 foreach (page ${project_MAN_PAGES})
-	string (REGEX MATCH "\\.([0-9])" manpage_suffix "${page}")
+	string (REGEX MATCH "\\.([0-9])$" manpage_suffix "${page}")
 	install (FILES "${page}"
 		DESTINATION "${CMAKE_INSTALL_MANDIR}/man${CMAKE_MATCH_1}")
-endforeach (page)
+endforeach ()
 
 # CPack
-set (CPACK_PACKAGE_DESCRIPTION_SUMMARY "Experimental IRC client, daemon and bot")
-set (CPACK_PACKAGE_VERSION ${project_VERSION})
-set (CPACK_PACKAGE_VENDOR "Premysl Janouch")
-set (CPACK_PACKAGE_CONTACT "Přemysl Janouch <p.janouch@gmail.com>")
+set (CPACK_PACKAGE_VERSION "${project_version_safe}")
+set (CPACK_PACKAGE_VENDOR "Premysl Eric Janouch")
+set (CPACK_PACKAGE_CONTACT "Přemysl Eric Janouch <p@janouch.name>")
 set (CPACK_RESOURCE_FILE_LICENSE "${PROJECT_SOURCE_DIR}/LICENSE")
 
 set (CPACK_GENERATOR "TGZ;ZIP")
 set (CPACK_PACKAGE_FILE_NAME
-	"${PROJECT_NAME}-${project_VERSION}-${CMAKE_SYSTEM_NAME}-${CMAKE_SYSTEM_PROCESSOR}")
-set (CPACK_PACKAGE_INSTALL_DIRECTORY "${PROJECT_NAME}-${project_VERSION}")
+	"${PROJECT_NAME}-${project_version_safe}-${CMAKE_SYSTEM_NAME}-${CMAKE_SYSTEM_PROCESSOR}")
+set (CPACK_PACKAGE_INSTALL_DIRECTORY "${PROJECT_NAME}-${project_version_safe}")
 
 set (CPACK_SOURCE_GENERATOR "TGZ;ZIP")
 set (CPACK_SOURCE_IGNORE_FILES "/\\\\.git;/build;/CMakeLists.txt.user")
-set (CPACK_SOURCE_PACKAGE_FILE_NAME "${PROJECT_NAME}-${project_VERSION}")
+set (CPACK_SOURCE_PACKAGE_FILE_NAME "${PROJECT_NAME}-${project_version_safe}")
 
 set (CPACK_SET_DESTDIR TRUE)
 include (CPack)

LICENSE

@@ -1,8 +1,7 @@
-Copyright (c) 2014 - 2015, Přemysl Janouch <p.janouch@gmail.com>
+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, provided that the above
-copyright notice and this permission notice appear in all copies.
+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

NEWS

@@ -0,0 +1,330 @@
+2.0.0 (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
+
+ * xC: all attributes.* configuration options have been made abstract in
+   a subset of the git-config(1) format, and renamed to theme.*,
+   with the exception of attributes.reset, which has no replacement
+
+ * xC: replaced behaviour.save_on_quit with general.autosave
+
+ * xC: improved pager integration capabilities
+
+ * xC: unsolicited JOINs will no longer automatically activate the buffer
+
+ * xC: made Readline insert the longest common completion prefix first,
+   and prevented the possible-completions command from duplicating the prompt
+
+ * xC: normalized editline's history behaviour, making it a viable frontend
+
+ * xC: various bugfixes
+
+ * xC: added a relay interface, enabled through the general.relay_bind option
+
+ * Added a web frontend for xC called xP
+
+
+1.5.0 (2021-12-21) "The Show Must Go On"
+
+ * xC: made it possible to pass the cursor position to external editors,
+   in particular VIM and Emacs
+
+ * xC: started quoting text coming from bracketed pastes,
+   to minimize the risk of trying to execute filesystem paths as commands
+
+ * xC: fixed to work with post-2021-08-29 editline
+
+ * xC: extended editline's autocomplete to show all options
+
+ * utm-filter.lua: added Facebook's tracking parameter to the filter
+
+
+1.4.0 (2021-10-06) "Call Me Scruffy Scruffington"
+
+ * xC: made message autosplitting respect text formatting
+
+ * xC: fixed displaying IRC colours above 16
+
+ * xC: offer IRCnet as an IRC network to connect to,
+   rather than the lunatic new Freenode
+
+ * xD: started bumping the soft limit on file descriptors to the hard one
+
+
+1.3.0 (2021-08-07) "New World Order"
+
+ * xC: made nick autocompletion offer recent speakers first
+
+ * All binaries have been renamed to something even sillier,
+   and all references in the source tree have been redacted;
+   this represents a major incompatible change for all plugins;
+   configuration and program data have to be adjusted manually
+
+
+1.2.0 (2021-07-08) "There Are Other Countries As Well"
+
+ * xC: added a /squery command for IRCnet
+
+ * xC: added trivial support for SASL EXTERNAL, enabled by adding "sasl"
+   to the respective server's "capabilities" list
+
+ * xC: now supporting IRCv3.2 capability negotiation, including CAP DEL
+
+ * xC: added support for IRCv3 chghost
+
+ * xC: /deop and /devoice without arguments will use the client's user
+
+ * xC: /set +=/-= now treats its argument as a string array
+
+ * xC: made "/help /command" work the same way as "/help command" does
+
+ * xC: /ban and /unban don't mangle extended bans anymore
+
+ * xC: joining new channels no longer switches to their buffer automatically
+   if the current input line isn't empty
+
+ * censor.lua: now stripping colours from censored messages;
+   their attributes are also configurable rather than always black on black
+
+
+1.1.0 (2020-10-31) "What Do You Mean By 'This Isn't Germany'?"
+
+ * xC: made fancy-prompt.lua work with libedit
+
+ * xD: fixed a regression with an unspecified "bind_host"
+
+ * Miscellaneous minor improvements
+
+
+1.0.0 (2020-10-29) "We're Finally There!"
+
+ * Coming with real manual pages instead of help2man-generated stubs
+
+ * xC: added support for more IRC colours and strike-through text (M-m x)
+
+ * xC: now tolerating all UTF-8 messages cut off by the server
+
+ * xC: disabled "behaviour.backlog_helper_strip_formatting" by default
+   since the relevant issue with ACS terminfo entries has been resolved
+
+ * xC: enabled word wrapping in the backlog by default
+
+ * xC: made the unread marker span the whole line, with a configurable
+   character; the previous behaviour can be obtained by setting it empty
+
+ * xC: fixed the prompt not showing back up after exiting a backlog helper
+   when an external event has provoked an attempt to change it
+
+ * xC: now watching fellow channel users' away status when the server
+   supports the away-notify capability; indicated by italicised nicknames
+
+ * xC: added a plugin to highlight prime numbers in incoming messages
+
+ * xD: make sure an unspecified "bind_host" binds to both IPv4 and IPv6
+
+ * xB: install plugins to /usr/share and look for them in XDG data dirs
+
+ * Miscellaneous little fixes
+
+
+0.9.8 (2020-09-02) "Yep, Still Using It"
+
+ * xC: fixed a crash and prompt attribute output in libedit 20191231-3.1,
+   though users are officially discouraged from using this library
+
+ * xC: fixed Lua 5.4 build, so far the support is experimental
+
+ * Miscellaneous little fixes
+
+
+0.9.7 (2018-10-21) "Business as Usual"
+
+ * xD: fix wildcard handling in WHOIS
+
+ * xD: properly handle STATS without parametetrs
+
+ * xD: abort earlier when an invalid mode character is detected while
+   processing channel MODE messages
+
+ * xD: do not send NICK notifications when the nickname doesn't really change
+
+ * xD: fix hostname string verification (only used for "server_name")
+
+
+0.9.6 (2018-06-22) "I've Been Sitting Here All This Time"
+
+ * Code has been relicensed to 0BSD and moved to a private git hosting
+
+ * Fix LibreSSL compatibility
+
+ * xC: a second /disconnect cuts the connection by force
+
+ * xC: send a QUIT message to the IRC server on Ctrl-C
+
+ * xC: add a Slack plugin (even though the gateway's now defunct)
+
+ * xC: show an error message on log write failure
+
+ * xC: fix parsing of literal IPv6 addresses with port numbers
+
+ * xC: fix some error messages
+
+ * xC: workaround a Readline bug in the fancy-prompt.lua plugin
+
+ * xD: fix two memory leaks
+
+ * xD: improve error handling for incoming connections
+
+ * xD: disable TLS session reuse
+
+
+0.9.5 (2016-12-30) "It's Time"
+
+ * Better support for the KILL command
+
+ * xC: export many more fields to the Lua API, add a prompt hook
+
+ * xC: show channel user count in the prompt
+
+ * xC: allow hiding join/part messages and other noise (Meta-Shift-H)
+
+ * xC: allow autojoining channels with keys
+
+ * xC: rejoin channels with keys on reconnect
+
+ * xC: make /query without arguments just open the buffer
+
+ * xC: add a censor plugin
+
+ * xC: die on configuration parse errors
+
+ * xC: request channel modes also on rejoin
+
+ * xC: don't show remembered channel modes on parted channels
+
+ * xC: fix highlight detection in colored text
+
+ * xC: fix CTCP handling for the real world and don't decode X-QUOTEs
+
+ * xC: add support for OpenSSL 1.1.0
+
+
+0.9.4 (2016-04-28) "Oops"
+
+ * xC: fix crash on characters invalid in Windows-1252
+
+ * xC: add an auto-rejoin plugin
+
+ * xC: better date change messages with customizable formatting;
+   now also used in the backlog, so it looks closer to regular output
+
+ * xB: add a calc plugin providing a basic Scheme REPL
+
+ * xB: add a seen plugin
+
+ * xD, xB: use pledge(2) on OpenBSD
+
+
+0.9.3 (2016-03-27) "Doesn't Even Suck"
+
+ * Use TLS Server Name Indication when connecting to servers
+
+ * xC: now we erase the screen before displaying buffers
+
+ * xC: implemented word wrapping in buffers
+
+ * xC: added autocomplete for /topic
+
+ * xC: Lua API was improved and extended
+
+ * xC: added a basic last.fm "now playing" plugin
+
+ * xC: backlog limit was made configurable
+
+ * xC: allow changing the list of IRC capabilities to use if available
+
+ * xC: optimize buffer memory usage
+
+ * xC: added logging of messages sent from /quote and plugins
+
+ * xC: M-! and M-a to go to the next buffer in order with a highlight
+   or new activity respectively
+
+ * xC: added --format for previewing things like MOTD files
+
+ * xC: added /buffer goto supporting case insensitive partial matches
+
+ * xD: add support for IRCv3.2 server-time
+
+ * xB: plugins now run in a dedicated data directory
+
+ * xB: added a factoids plugin
+
+ * Remote addresses are now resolved asynchronously
+
+ * Various bugfixes
+
+
+0.9.2 (2015-12-31)
+
+ * xC: added rudimentary support for Lua scripting
+
+ * xC: added detection of pasting, so that it doesn't trigger other
+   keyboard shortcuts, such as for autocomplete
+
+ * xC: added auto-away capability
+
+ * xC: added an /oper command
+
+ * xC: libedit backend works again
+ 
+ * xC: added capability to edit the input line using VISUAL/EDITOR
+
+ * xC: added Meta-Tab to switch to the last used buffer
+
+ * xC: correctly respond to stopping and resuming (SIGTSTP)
+
+ * xC: fixed decoding of text formatting
+
+ * xC: unseen PMs now show up as highlights
+
+ * xC: various bugfixes
+
+
+0.9.1 (2015-09-25)
+
+ * All "ssl" options have been renamed to "tls"
+
+ * The project now builds on OpenBSD
+
+ * Pulled in kqueue support
+
+ * xC: added backlog/scrollback functionality using less(1)
+
+ * xC: made showing the entire set of channel mode user prefixes optional
+
+ * xC: nicknames in /names are now ordered
+
+ * xC: nicknames now use the 256-color terminal palette if available
+
+ * xC: now we skip entries in the "addresses" list that can't be resolved
+   to an address, along with displaying a more helpful message
+
+ * xC: joins, parts, nick changes and quits don't count as new buffer
+   activity anymore
+
+ * xC: added Meta-H to open the full log file
+
+ * xC: various bugfixes and little improvements
+
+
+0.9.0 (2015-07-23)
+
+ * Initial release
+

README

@@ -1,127 +0,0 @@
-uirc3
-=====
-The unethical IRC trinity.  This project consists of an experimental IRC client,
-daemon, and bot.  It's all you're ever going to need for chatting.
-
-All of them have these potentially interesting properties:
- - full IPv6 support
- - TLS support, including client certificates
- - minimal dependencies
- - very compact and easy to hack on
- - permissive license
-
-degesch
--------
-The IRC client.  It is largely defined by being built on top of GNU Readline.
-Its interface should however feel familiar for weechat or irssi users.
-
-This is the youngest and largest application within the project.  It has most of
-the stuff you'd expect of an IRC client, such as being able to set up multiple
-servers, powerful configuration system, integrated help, mIRC text formatting,
-CTCP queries, automatic splitting of overlong messages, autocomplete, logging
-to file, and command aliases.
-
-kike
-----
-The IRC daemon.  It is designed to be used as a regular user application rather
-than a system-wide daemon.  If all you want is a decent, minimal IRCd for
-a small network of respectful users (or bots), or testing, this one will do it.
-
-Notable features:
- - TLS autodetection (why doesn't everyone have this?)
- - IRCop authentication through TLS client certificates
- - epoll support on Linux; it should be able to handle quite a number of users
- - partial IRCv3 support
-
-Not supported:
- - server linking (which also means no services); I consider existing protocols
-   for this purpose ugly and tricky to implement correctly
- - online changes to configuration; the config system from degesch could be used
- - limits of almost any kind, just connections and mode +l
-
-ZyklonB
--------
-The IRC bot.  It builds upon the concept of my other VitaminA IRC bot.  The main
-characteristic of these two bots is that they run plugins as coprocesses, which
-allows for enhanced reliability and programming language freedom.
-
-While originally intended to be a simple C99 rewrite of the original bot, which
-was written in the GNU dialect of AWK, it fairly quickly became a playground
-where I added everything that seemed nice, and it eventually got me into writing
-the rest of this package.
-
-Notable features:
- - resilient against crashes, server disconnects and timeouts
- - SOCKS support (even though socksify can add that easily to any program)
-
-Building
---------
-Build dependencies: CMake, pkg-config, help2man, awk, sh, liberty (included)
-Runtime dependencies: openssl, curses (degesch),
-                      readline or libedit >= 2013-07-12 (degesch)
-
- $ git clone https://github.com/pjanouch/uirc3.git
- $ git submodule init
- $ git submodule update
- $ mkdir build
- $ cd build
- $ cmake .. -DCMAKE_INSTALL_PREFIX=/usr -DCMAKE_BUILD_TYPE=Debug \
-            -DWANT_READLINE=ON -DWANT_LIBEDIT=OFF
- $ make
-
-To install the application, you can do either the usual:
- # make install
-
-Or you can try telling CMake to make a package for you.  For Debian it is:
- $ cpack -G DEB
- # dpkg -i uirc3-*.deb
-
-Note that for versions of CMake before 2.8.9, you need to prefix cpack with
-`fakeroot' or file ownership will end up wrong.
-
-Running
--------
-`degesch' has in-program configuration.  Just run it and read the instructions.
-
-For the rest you might want to generate a configuration file:
- $ zyklonb --write-default-config
- $ kike --write-default-config
-
-After making any necessary edits to the file (there are comments to aid you in
-doing that), simply run the appropriate program with no arguments:
- $ zyklonb
- $ kike
-
-`ZyklonB' stays running in the foreground, therefore I recommend launching it
-inside a Screen or tmux session.
-
-`kike', on the other hand, immediately forks into the background.  Use the PID
-file or something like `killall' if you want to terminate it.  You can run it
-as a `forking' type systemd user service.
-
-Client Certificates
--------------------
-`kike' uses SHA1 fingerprints of TLS client certificates to authenticate users.
-To get the fingerprint from a certificate file in the required form, use:
- $ openssl x509 -in public.pem -outform DER | sha1sum
-
-Contributing and Support
-------------------------
-Use this project's GitHub to report any bugs, request features, or submit pull
-requests.  If you want to discuss this project, or maybe just hang out with
-the developer, feel free to join me at irc://anathema.irc.so, channel #anathema.
-
-Disclaimer
-----------
-I am not an antisemitist, I'm just being an offensive asshole with the naming.
-And no, I'm not going to change the names.
-
-License
--------
-`uirc3' is written by Přemysl Janouch <p.janouch@gmail.com>.
-
-You may use the software under the terms of the ISC license, the text of which
-is included within the package, or, at your option, you may relicense the work
-under the MIT or the Modified BSD License, as listed at the following site:
-
-http://www.gnu.org/licenses/license-list.html

README.adoc

@@ -0,0 +1,210 @@
+xK
+==
+
+'xK' (chat kit) is an IRC software suite consisting of a daemon, bot, terminal
+client, and a web frontend 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.
+
+xC
+--
+The IRC client, and the core of 'xK'.  It is largely defined by building on top
+of GNU Readline or BSD Editline that have been hacked to death.  Its interface
+should feel somewhat familiar for weechat or irssi users.
+
+image::xC.webp[align="center"]
+
+It has most features you'd expect of an IRC client, such as being multiserver,
+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, a remote relay interface, or basic support for Lua scripting.
+As a unique bonus, you can launch a full text editor from within.
+
+xP
+--
+The web frontend for 'xC', making use of its networked relay interface.
+It intentionally differs in that it uses a sans-serif font, and it shows
+the list of all buffers in a side panel.  Otherwise it is a near replica,
+including link:xC.adoc#_key_bindings[keyboard shortcuts].
+
+image::xP.webp[align="center"]
+
+xD
+--
+The IRC daemon.  It is designed for use as a regular user application rather
+than a system-wide daemon, and follows the XDG Base Directory Specification.
+If all you want is a decent, minimal IRCd for testing purposes or a small
+network of respectful users (or bots), this one will do it just fine.
+
+It autodetects TLS on incoming connections (I'm still wondering why everyone
+doesn't have this), authenticates operators via TLS client certificate
+fingerprints, and supports a number of IRCv3 capabilities.
+
+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] in a different project, and development continues over there.
+
+xB
+--
+The IRC bot.  While originally intended to be a simple rewrite of my old GNU AWK
+bot in C, it fairly quickly became a playground, and it eventually got me into
+writing the rest of this package.
+
+Its main characteristic is that it runs plugins as coprocesses, allowing for
+enhanced reliability and programming language freedom.  Moreover, it recovers
+from any crashes, and offers native SOCKS support (even though socksify can add
+that easily to any program).
+
+Packages
+--------
+Regular releases are sporadic.  git master should be stable enough.  You can get
+a package with the latest development version from Archlinux's AUR.
+
+Building
+--------
+Build-only dependencies: CMake, pkg-config, awk, liberty (included),
+ asciidoctor or asciidoc (recommended but optional) +
+Common runtime dependencies: openssl +
+Additionally for 'xC': curses, libffi, readline >= 6.0 or libedit >= 2013-07-12,
+ lua >= 5.3 (optional) +
+
+ $ git clone --recursive https://git.janouch.name/p/xK.git
+ $ mkdir xK/build
+ $ cd xK/build
+ $ cmake .. -DCMAKE_INSTALL_PREFIX=/usr -DCMAKE_BUILD_TYPE=RelWithDebInfo \
+            -DWANT_READLINE=ON -DWANT_LIBEDIT=OFF -DWITH_LUA=ON
+ $ make
+
+To install the application, you can do either the usual:
+
+ # make install
+
+Or you can try telling CMake to make a package for you:
+
+ $ cpack -G DEB  # also supported: RPM, FreeBSD
+ # dpkg -i xK-*.deb
+
+Usage
+-----
+'xC' has in-program configuration.  Just run it and read the instructions.
+Consult its link:xC.adoc[man page] for details about the interface.
+
+For the rest you might want to generate a configuration file:
+
+ $ xB --write-default-config
+ $ xD --write-default-config
+
+After making any necessary edits to the file (there are comments to aid you in
+doing that), simply run the appropriate program with no arguments:
+
+ $ xB
+ $ xD
+
+'xB' stays running in the foreground, therefore I recommend launching it inside
+a Screen or tmux session.
+
+'xD', on the other hand, immediately forks into the background.  Use the PID
+file or something like `killall` if you want to terminate it.  You can run it
+as a `forking` type systemd user service.
+
+xP
+~~
+The precondition for running 'xC' frontends is enabling its relay interface:
+
+ /set general.relay_bind = "127.0.0.1:9000"
+
+To build the web server, you'll need to install the Go compiler, and run `make`
+from the _xP_ directory.  Then start it from the _public_ subdirectory,
+and navigate to the adress you gave it as its first argument--in the following
+example, that would be http://localhost:8080[]:
+
+ $ ../xP 127.0.0.1:8080 127.0.0.1:9000
+
+For remote use, it's recommended to put 'xP' behind a reverse proxy, with TLS,
+and some form of HTTP authentication.  Pass the external URL of the WebSocket
+endpoint as the third command line argument in this case.
+
+Client Certificates
+-------------------
+'xC' will use the SASL EXTERNAL method to authenticate using the TLS client
+certificate specified by the respective server's `tls_cert` option if you add
+`sasl` to the `capabilities` option and the server supports this.
+
+'xD' uses SHA-1 fingerprints of TLS client certificates to authenticate users.
+To get the fingerprint from a certificate file in the required form, use:
+
+ $ openssl x509 -in public.pem -outform DER | sha1sum
+
+Custom Key Bindings in xC
+-------------------------
+The default and preferred frontend used in 'xC' is GNU Readline.  This means
+that you can change your bindings by editing '~/.inputrc'.  For example:
+
+....
+# Preload with system-wide settings
+$include /etc/inputrc
+
+# Make M-left and M-right reorder buffers
+$if xC
+"\e\e[C": move-buffer-right
+"\e\e[D": move-buffer-left
+$endif
+....
+
+Consult the source code and the GNU Readline manual for a list of available
+functions.  Also refer to the latter for the exact syntax of this file.
+Beware that you can easily break the program if you're not careful.
+
+How do I make xC look like the screenshot?
+------------------------------------------
+With the defaults, 'xC' doesn't look too fancy because I don't want to have
+a hard dependency on either Lua for the bundled script that provides an easily
+adjustable enhanced prompt, or on 256-colour terminals.  Moreover, it's nearly
+impossible to come up with a colour theme that would work well with both
+black-on-white and white-on-black terminals, or anything wild in between.
+
+Assuming that your build supports Lua plugins, and that you have a decent,
+properly set-up terminal emulator, it suffices to run:
+
+ /set general.pager = Press Tab here and change +Gb to +Gb1d
+ /set general.date_change_line = "%a %e %b %Y"
+ /set general.plugin_autoload += "fancy-prompt.lua"
+ /set theme.userhost = "109"
+ /set theme.join = "108"
+ /set theme.part = "138"
+ /set theme.external = "248"
+ /set theme.timestamp = "250 255"
+ /set theme.read_marker = "202"
+
+Configuration profiles
+----------------------
+Even though the applications don't directly support configuration profiles,
+they conform to the XDG standard, and thus you can change the location they
+load configuration from via XDG_CONFIG_HOME (normally '~/.config') and the
+location where store their data via XDG_DATA_HOME (normally '~/.local/share').
+
+It would be relatively easy to make the applications assume whatever name you
+run them under (for example by using symbolic links), and load different
+configurations accordingly, but I consider it rather messy and unnecessary.
+
+Contributing and Support
+------------------------
+Use https://git.janouch.name/p/xK to report any bugs, request features,
+or submit pull requests.  `git send-email` is tolerated.  If you want to discuss
+the project, feel free to join me at ircs://irc.janouch.name, channel #dev.
+
+Bitcoin donations are accepted at: 12r5uEWEgcHC46xd64tt3hHt9EUvYYDHe9
+
+License
+-------
+This software is released under the terms of the 0BSD license, the text of which
+is included within the package along with the list of authors.
+
+Note that 'xC' becomes GPL-licensed when you link it against GNU Readline,
+but that is not a concern of this source package.  The licenses are compatible.

config.h.in

@@ -1,10 +1,15 @@
 #ifndef CONFIG_H
 #define CONFIG_H
 
-#define PROGRAM_VERSION "${project_VERSION}"
-#define PLUGIN_DIR "${CMAKE_INSTALL_PREFIX}/${plugin_dir}"
+#define PROGRAM_VERSION "${project_version}"
+
+// We use the XDG Base Directory Specification, but may be installed anywhere.
+#define PROJECT_DATADIR "${CMAKE_INSTALL_FULL_DATADIR}"
 
 #cmakedefine HAVE_READLINE
 #cmakedefine HAVE_EDITLINE
+#cmakedefine HAVE_LUA
+
+#cmakedefine01 ICONV_ACCEPTS_TRANSLIT
 
 #endif  // ! CONFIG_H

kike-gen-replies.sh

@@ -1,28 +0,0 @@
-#!/bin/sh
-LC_ALL=C exec awk '
-	BEGIN {
-		# The message catalog is a by-product
-		msg = "kike.msg"
-		print "$quote \"" > msg;
-		print "$set 1" > msg;
-	}
-	/^[0-9]+ *IRC_(ERR|RPL)_[A-Z]+ *".*"$/ {
-		match($0, /".*"/);
-		ids[$1] = $2;
-		texts[$2] = substr($0, RSTART, RLENGTH);
-		print $1 " " texts[$2] > msg
-	}
-	END {
-		printf("enum\n{")
-		for (i in ids) {
-			if (seen_first)
-				printf(",")
-			seen_first = 1
-			printf("\n\t%s = %s", ids[i], i)
-		}
-		print "\n};\n"
-		print "static const char *g_default_replies[] =\n{"
-		for (i in ids)
-			print "\t[" ids[i] "] = " texts[ids[i]] ","
-		print "};"
-	}'

plugins/xB/calc

@@ -0,0 +1,241 @@
+#!/usr/bin/env guile
+
+  xB calc plugin, basic Scheme evaluator
+
+  Copyright 2016 Přemysl Eric Janouch
+  See the file LICENSE for licensing information.
+
+!#
+
+(import (rnrs (6)))
+(use-modules ((rnrs) :version (6)))
+
+; --- Message parsing ----------------------------------------------------------
+
+(define-record-type message (fields prefix command params))
+(define (parse-message line)
+  (let f ([parts '()] [chars (string->list line)])
+    (define (take-word w chars)
+      (if (or (null? chars) (eqv? (car chars) #\x20))
+        (f (cons (list->string (reverse w)) parts)
+           (if (null? chars) chars (cdr chars)))
+        (take-word (cons (car chars) w) (cdr chars))))
+    (if (null? chars)
+      (let ([data (reverse parts)])
+        (when (< (length data) 2)
+          (error 'parse-message "invalid message"))
+        (make-message (car data) (cadr data) (cddr data)))
+      (if (null? parts)
+        (if (eqv? (car chars) #\:)
+          (take-word '() (cdr chars))
+          (f (cons #f parts) chars))
+        (if (eqv? (car chars) #\:)
+          (f (cons (list->string (cdr chars)) parts) '())
+          (take-word '() chars))))))
+
+; --- Utilities ----------------------------------------------------------------
+
+(define (display-exception e port)
+  (define (puts . x)
+    (for-all (lambda (a) (display a port)) x)
+    (newline port))
+
+  (define (record-fields rec)
+    (let* ([rtd (record-rtd rec)]
+           [v (record-type-field-names rtd)]
+           [len (vector-length v)])
+      (map (lambda (k i) (cons k ((record-accessor rtd i) rec)))
+        (vector->list v)
+        (let c ([i len] [ls '()])
+          (if (= i 0) ls (c (- i 1) (cons (- i 1) ls)))))))
+
+  (puts "Caught " (record-type-name (record-rtd e)))
+  (for-all
+    (lambda (subtype)
+      (puts "  " (record-type-name (record-rtd subtype)))
+      (for-all
+        (lambda (field) (puts "    " (car field) ": " (cdr field)))
+        (record-fields subtype)))
+    (simple-conditions e)))
+
+; XXX - we have to work around Guile's lack of proper eol-style support
+(define xc (make-transcoder (latin-1-codec) 'lf 'replace))
+(define irc-input-port (transcoded-port (standard-input-port) xc))
+(define irc-output-port (transcoded-port (standard-output-port) xc))
+
+(define (send . message)
+  (for-all (lambda (x) (display x irc-output-port)) message)
+  (display #\return irc-output-port)
+  (newline irc-output-port)
+  (flush-output-port irc-output-port))
+
+(define (get-line-crlf port)
+  (define line (get-line port))
+  (if (eof-object? line) line
+    (let ([len (string-length line)])
+      (if (and (> len 0) (eqv? (string-ref line (- len 1)) #\return))
+        (substring line 0 (- len 1)) line))))
+
+(define (get-config name)
+  (send "XB get_config :" name)
+  (car (message-params (parse-message (get-line-crlf irc-input-port)))))
+
+(define (extract-nick prefix)
+  (do ([i 0 (+ i 1)] [len (string-length prefix)])
+      ([or (= i len) (char=? #\! (string-ref prefix i))]
+       [substring prefix 0 i])))
+
+(define (string-after s start)
+  (let ([s-len (string-length s)] [with-len (string-length start)])
+    (and (>= s-len with-len)
+         (string=? (substring s 0 with-len) start)
+         (substring s with-len s-len))))
+
+; --- Calculator ---------------------------------------------------------------
+
+; Evaluator derived from the example in The Scheme Programming Language.
+;
+; Even though EVAL with a carefully crafted environment would also do a good
+; job at sandboxing, it would probably be impossible to limit execution time...
+
+(define (env-new formals actuals env)
+  (cond [(null? formals) env]
+        [(symbol? formals) (cons (cons formals actuals) env)]
+        [else (cons (cons (car formals) (car actuals))
+                    (env-new (cdr formals) (cdr actuals) env))]))
+(define (env-lookup var env) (cdr (assq var env)))
+(define (env-assign var val env) (set-cdr! (assq var env) val))
+
+(define (check-reductions r)
+  (if (= (car r) 0)
+    (error 'check-reductions "reduction limit exceeded")
+    (set-car! r (- (car r) 1))))
+
+; TODO - think about implementing more syntactical constructs,
+;   however there's not much point in having anything else in a calculator...
+(define (exec expr r env)
+  (check-reductions r)
+  (cond [(symbol? expr) (env-lookup expr env)]
+        [(pair? expr)
+         (case (car expr)
+           [(quote) (cadr expr)]
+           [(lambda) (lambda vals
+                       (let ([env (env-new (cadr expr) vals env)])
+                         (let loop ([exprs (cddr expr)])
+                           (if (null? (cdr exprs))
+                             (exec (car exprs) r env)
+                             (begin (exec (car exprs) r env)
+                                    (loop (cdr exprs)))))))]
+           [(if) (if (exec (cadr expr) r env)
+                   (exec (caddr expr) r env)
+                   (exec (cadddr expr) r env))]
+           [(set!) (env-assign (cadr expr) (exec (caddr expr) r env) env)]
+           [else (apply (exec (car expr) r env)
+                        (map (lambda (x) (exec x r env)) (cdr expr)))])]
+        [else expr]))
+
+(define-syntax forward
+  (syntax-rules ()
+    [(_) '()]
+    [(_ a b ...) (cons (cons (quote a) a) (forward b ...))]))
+
+; ...which can't prevent me from simply importing most of the standard library
+(define base-library
+  (forward
+    ; Equivalence, procedure predicate, booleans
+    eqv? eq? equal? procedure? boolean? boolean=? not
+    ; numbers, numerical input and output
+    number? complex? real? rational? integer?  exact? inexact? exact inexact
+    real-valued? rational-valued? integer-valued? number->string string->number
+    ; Arithmetic
+    = < > <= >= zero? positive? negative? odd? even? finite? infinite? nan?
+    min max + * - / abs div-and-mod div mod div0-and-mod0 div0 mod0
+    gcd lcm numerator denominator floor ceiling truncate round
+    rationalize exp log sin cos tan asin acos atan sqrt expt
+    make-rectangular make-polar real-part imag-part magnitude angle
+    ; Pairs and lists
+    map for-each cons car cdr caar cadr cdar cddr
+    caaar caadr cadar caddr cdaar cdadr cddar cdddr
+    caaaar caaadr caadar caaddr cadaar cadadr caddar cadddr
+    cdaaar cdaadr cdadar cdaddr cddaar cddadr cdddar cddddr
+    pair? null? list? list length append reverse list-tail list-ref
+    ; Symbols
+    symbol? symbol=? symbol->string string->symbol
+    ; Characters
+    char? char=? char<? char>? char<=? char>=?  char->integer integer->char
+    ; Strings; XXX - omitted make-string - can cause OOM
+    string? string=? string<? string>? string<=? string>=?
+    string string-length string-ref substring
+    string-append string->list list->string string-for-each string-copy
+    ; Vectors; XXX - omitted make-vector - can cause OOM
+    vector? vector vector-length vector-ref vector-set!
+    vector->list list->vector vector-fill! vector-map vector-for-each
+    ; Control features
+    apply call/cc values call-with-values dynamic-wind))
+(define extended-library
+  (forward
+    char-upcase char-downcase char-titlecase char-foldcase
+    char-ci=? char-ci<? char-ci>? char-ci<=? char-ci>=?
+    char-alphabetic? char-numeric? char-whitespace?
+    char-upper-case? char-lower-case? char-title-case?
+    string-upcase string-downcase string-titlecase string-foldcase
+    string-ci=? string-ci<? string-ci>? string-ci<=? string-ci>=?
+    find for-all exists filter partition fold-left fold-right
+    remp remove remv remq memp member memv memq assp assoc assv assq cons*
+    list-sort vector-sort vector-sort!
+    bitwise-not bitwise-and bitwise-ior bitwise-xor bitwise-if
+    bitwise-bit-count bitwise-length bitwise-first-bit-set bitwise-bit-set?
+    bitwise-copy-bit bitwise-bit-field bitwise-copy-bit-field
+    bitwise-arithmetic-shift bitwise-rotate-bit-field bitwise-reverse-bit-field
+    bitwise-arithmetic-shift-left bitwise-arithmetic-shift-right
+    set-car! set-cdr! string-set! string-fill!))
+(define (interpret expr)
+  (exec expr '(2000) (append base-library extended-library)))
+
+; We could show something a bit nicer but it would be quite Guile-specific
+(define (error-string e)
+  (map (lambda (x) (string-append " " (symbol->string x)))
+    (filter (lambda (x) (not (member x '(&who &message &irritants &guile))))
+      (map (lambda (x) (record-type-name (record-rtd x)))
+        (simple-conditions e)))))
+
+(define (calc input respond)
+  (define (stringify x)
+    (call-with-string-output-port (lambda (port) (write x port))))
+  (guard (e [else (display-exception e (current-error-port))
+                  (apply respond "caught" (error-string e))])
+    (let* ([input (open-string-input-port input)]
+           [data (let loop ()
+                   (define datum (get-datum input))
+                   (if (eof-object? datum) '() (cons datum (loop))))])
+      (call-with-values
+        (lambda () (interpret (list (append '(lambda ()) data))))
+        (lambda message
+          (for-all (lambda (x) (respond (stringify x))) message))))))
+
+; --- Main loop ----------------------------------------------------------------
+
+(define prefix (get-config "prefix"))
+(send "XB register")
+
+(define (process msg)
+  (when (string-ci=? (message-command msg) "PRIVMSG")
+    (let* ([nick (extract-nick (message-prefix msg))]
+           [target (car (message-params msg))]
+           [response-begin
+             (apply string-append "PRIVMSG "
+               (if (memv (string-ref target 0) (string->list "#&!+"))
+                 `(,target " :" ,nick ": ") `(,nick " :")))]
+           [respond (lambda args (apply send response-begin args))]
+           [text (cadr (message-params msg))]
+           [input (or (string-after text (string-append prefix "calc "))
+                      (string-after text (string-append prefix "= ")))])
+      (when input (calc input respond)))))
+
+(let main-loop ()
+  (define line (get-line-crlf irc-input-port))
+  (unless (eof-object? line)
+    (guard (e [else (display-exception e (current-error-port))])
+      (unless (string=? "" line)
+        (process (parse-message line))))
+    (main-loop)))

plugins/xB/coin

@@ -1,8 +1,8 @@
 #!/usr/bin/env tclsh
 #
-# ZyklonB coin plugin, random number-based utilities
+# xB coin plugin, random number-based utilities
 #
-# Copyright 2012, 2014 Přemysl Janouch
+# Copyright 2012, 2014 Přemysl Eric Janouch
 # See the file LICENSE for licensing information.
 #
 
@@ -37,7 +37,7 @@ proc parse {line} {
 
 proc get_config {key} {
 	global msg
-	puts "ZYKLONB get_config :$key"
+	puts "XB get_config :$key"
 	gets stdin line
 	parse $line
 	return [lindex $msg(param) 0]
@@ -53,7 +53,7 @@ fconfigure stdin -translation crlf -encoding iso8859-1
 fconfigure stdout -translation crlf -encoding iso8859-1
 
 set prefix [get_config prefix]
-puts "ZYKLONB register"
+puts "XB register"
 
 set eightball [list \
 	"It is certain" \

plugins/xB/eval

@@ -1,8 +1,8 @@
 #!/usr/bin/awk -f
 #
-# ZyklonB eval plugin, LISP-like expression evaluator
+# xB eval plugin, LISP-like expression evaluator
 #
-# Copyright 2013, 2014 Přemysl Janouch
+# Copyright 2013, 2014 Přemysl Eric Janouch
 # See the file LICENSE for licensing information.
 #
 
@@ -15,7 +15,7 @@ BEGIN \
 
 	prefix = get_config("prefix")
 
-	print "ZYKLONB register"
+	print "XB register"
 	fflush("")
 
 	# All functions have to be in this particular array
@@ -258,7 +258,7 @@ function process_end ()
 
 function get_config (key)
 {
-	print "ZYKLONB get_config :" key
+	print "XB get_config :" key
 	fflush("")
 
 	getline

plugins/xB/factoids

@@ -0,0 +1,177 @@
+#!/usr/bin/env perl
+#
+# xB factoids plugin
+#
+# Copyright 2016 Přemysl Eric Janouch <p@janouch.name>
+# See the file LICENSE for licensing information.
+#
+
+use strict;
+use warnings;
+use Text::Wrap;
+
+# --- IRC protocol -------------------------------------------------------------
+
+binmode STDIN;  select STDIN;  $| = 1; $/ = "\r\n";
+binmode STDOUT; select STDOUT; $| = 1; $\ = "\r\n";
+
+sub parse ($) {
+	chomp (my $line = shift);
+	return undef unless my ($nick, $user, $host, $command, $args) = ($line =~
+		qr/^(?::([^! ]*)(?:!([^@]*)@([^ ]*))? +)?([^ ]+)(?: +(.*))?$/o);
+	return {nick => $nick, user => $user, host => $host, command => $command,
+		args => defined $args ? [$args =~ /:?((?<=:).*|[^ ]+) */og] : []};
+}
+
+sub bot_print {
+	print "XB print :${\shift}";
+}
+
+# --- Initialization -----------------------------------------------------------
+
+my %config;
+for my $name (qw(prefix)) {
+	print "XB get_config :$name";
+	$config{$name} = (parse <STDIN>)->{args}->[0];
+}
+
+print "XB register";
+
+# --- Database -----------------------------------------------------------------
+# Simple map of (factoid_name => [definitions]); all factoids are separated
+# by newlines and definitions by carriage returns.  Both disallowed in IRC.
+
+sub db_load {
+	local $/ = "\n";
+	my ($path) = @_;
+	open my $db, "<", $path or return {};
+
+	my %entries;
+	while (<$db>) {
+		chomp;
+		my @defs = split "\r";
+		$entries{shift @defs} = \@defs;
+	}
+	\%entries
+}
+
+sub db_save {
+	local $\ = "\n";
+	my ($path, $ref) = @_;
+	my $path_new = "$path.new";
+	open my $db, ">", $path_new or die "db save failed: $!";
+
+	my %entries = %$ref;
+	print $db join "\r", ($_, @{$entries{$_}}) for keys %entries;
+	close $db;
+	rename $path_new, $path or die "db save failed: $!";
+}
+
+# --- Factoids -----------------------------------------------------------------
+
+my $db_path = 'factoids.db';
+my %db = %{db_load $db_path};
+
+sub learn {
+	my ($respond, $input) = @_;
+	return &$respond("usage: <name> = <definition>")
+		unless $input =~ /^([^=]+?)(?:\s+(\d+))?\s*=\s*(.+?)\s*$/;
+
+	my ($name, $number, $definition) = ($1, $2, $3);
+	return &$respond("trailing numbers in names are disallowed")
+		if defined $2;
+	$db{$name} = [] unless exists $db{$name};
+
+	my $entries = $db{$name};
+	return &$respond("duplicate definition")
+		if grep { lc $_ eq lc $definition } @$entries;
+
+	push @$entries, $definition;
+	&$respond("saved as #${\scalar @$entries}");
+	db_save $db_path, \%db;
+}
+
+sub check_number {
+	my ($respond, $name, $number) = @_;
+	my $entries = $db{$name};
+	if ($number > @$entries) {
+		&$respond(qq/"$name" has only ${\scalar @$entries} definitions/);
+	} elsif (not $number) {
+		&$respond("number must not be zero");
+	} else {
+		return 1;
+	}
+	return 0;
+}
+
+sub forget {
+	my ($respond, $input) = @_;
+	return &$respond("usage: <name> <number>")
+		unless $input =~ /^([^=]+?)\s+(\d+)\s*$/;
+
+	my ($name, $number) = ($1, int($2));
+	return &$respond(qq/"$name" is undefined/)
+		unless exists $db{$name};
+
+	my $entries = $db{$name};
+	return unless check_number $respond, $name, $number;
+
+	splice @$entries, --$number, 1;
+	&$respond("forgotten");
+	db_save $db_path, \%db;
+}
+
+sub whatis {
+	my ($respond, $input) = @_;
+	return &$respond("usage: <name> [<number>]")
+		unless $input =~ /^([^=]+?)(?:\s+(\d+))?\s*$/;
+
+	my ($name, $number) = ($1, $2);
+	return &$respond(qq/"$name" is undefined/)
+		unless exists $db{$name};
+
+	my $entries = $db{$name};
+	if (defined $number) {
+		return unless check_number $respond, $name, $number;
+		&$respond(qq/"$name" is #$number $entries->[$number - 1]/);
+	} else {
+		my $i = 1;
+		my $definition = join ", ", map { "#${\$i++} $_" } @{$entries};
+		&$respond(qq/"$name" is $definition/);
+	}
+}
+
+sub wildcard {
+	my ($respond, $input) = @_;
+	$input =~ /=/ ? learn(@_) : whatis(@_);
+}
+
+my %commands = (
+	'learn'  => \&learn,
+	'forget' => \&forget,
+	'whatis' => \&whatis,
+	'??'     => \&wildcard,
+);
+
+# --- Input loop ---------------------------------------------------------------
+
+while (my $line = <STDIN>) {
+	my %msg = %{parse $line};
+	my @args = @{$msg{args}};
+
+	# This plugin only bothers to respond to PRIVMSG messages
+	next unless $msg{command} eq 'PRIVMSG' and @args >= 2
+		and my ($cmd, $input) = $args[1] =~ /^$config{prefix}(\S+)\s*(.*)/;
+
+	# So far the only reaction is a PRIVMSG back to the sender, so all the
+	# handlers need is a response callback and all arguments to the command
+	my ($target => $quote) = ($args[0] =~ /^[#+&!]/)
+		? ($args[0] => "$msg{nick}: ") : ($msg{nick} => '');
+	# Wrap all responses so that there's space for our prefix in the message
+	my $respond = sub {
+		local ($Text::Wrap::columns, $Text::Wrap::unexpand) = 400, 0;
+		my $start = "PRIVMSG $target :$quote";
+		print for split "\n", wrap $start, $start, shift;
+	};
+	&{$commands{$cmd}}($respond, $input) if exists($commands{$cmd});
+}

plugins/xB/pomodoro

@@ -1,9 +1,9 @@
 #!/usr/bin/env ruby
 # coding: utf-8
 #
-# ZyklonB pomodoro plugin
+# xB pomodoro plugin
 #
-# Copyright 2015 Přemysl Janouch
+# Copyright 2015 Přemysl Eric Janouch
 # See the file LICENSE for licensing information.
 #
 
@@ -206,7 +206,7 @@ def parse (line)
 end
 
 def bot_print (what)
-	print "ZYKLONB print :#{what}"
+	print "XB print :#{what}"
 end
 
 # --- Initialization -----------------------------------------------------------
@@ -215,12 +215,12 @@ end
 # To read it from anywhere else, it has to be done asynchronously
 $config = {}
 [:prefix].each do |name|
-	print "ZYKLONB get_config :#{name}"
+	print "XB get_config :#{name}"
 	_, _, _, _, args = *parse($stdin.gets.chomp)
 	$config[name] = args[0]
 end
 
-print "ZYKLONB register"
+print "XB register"
 
 # --- Plugin logic -------------------------------------------------------------
 

plugins/xB/script

@@ -1,8 +1,8 @@
 #!/usr/bin/tcc -run -lm
 //
-// ZyklonB scripting plugin, using a custom stack-based language
+// xB scripting plugin, using a custom stack-based language
 //
-// Copyright 2014 Přemysl Janouch
+// Copyright 2014 Přemysl Eric Janouch
 // See the file LICENSE for licensing information.
 //
 // Just compile this file as usual (sans #!) if you don't feel like using TCC.
@@ -1964,12 +1964,12 @@ read_message (void)
 
 // --- Interfacing with the bot ------------------------------------------------
 
-#define BOT_PRINT "ZYKLONB print :script: "
+#define BOT_PRINT "XB print :script: "
 
 static const char *
 get_config (const char *key)
 {
-	printf ("ZYKLONB get_config :%s\r\n", key);
+	printf ("XB get_config :%s\r\n", key);
 	struct message *msg = read_message ();
 	if (!msg || msg->n_params <= 0)
 		exit (EXIT_FAILURE);
@@ -2298,7 +2298,7 @@ main (int argc, char *argv[])
 		printf (BOT_PRINT "%s\r\n", "runtime library initialization failed");
 
 	g_prefix = strdup (get_config ("prefix"));
-	printf ("ZYKLONB register\r\n");
+	printf ("XB register\r\n");
 	struct message *msg;
 	while ((msg = read_message ()))
 		process_message (msg);

plugins/xB/seen

@@ -0,0 +1,160 @@
+#!/usr/bin/env lua
+--
+-- xB seen plugin
+--
+-- Copyright 2016 Přemysl Eric Janouch <p@janouch.name>
+-- See the file LICENSE for licensing information.
+--
+
+function parse (line)
+	local msg = { params = {} }
+	line = line:match ("[^\r]*")
+	for start, word in line:gmatch ("()([^ ]+)") do
+		local colon = word:match ("^:(.*)")
+		if start == 1 and colon then
+			msg.prefix = colon
+		elseif not msg.command then
+			msg.command = word
+		elseif colon then
+			table.insert (msg.params, line:sub (start + 1))
+			break
+		elseif start ~= #line then
+			table.insert (msg.params, word)
+		end
+	end
+	return msg
+end
+
+function get_config (name)
+	io.write ("XB get_config :", name, "\r\n")
+	return parse (io.read ()).params[1]
+end
+
+-- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+
+io.output ():setvbuf ('line')
+local prefix = get_config ('prefix')
+io.write ("XB register\r\n")
+
+local db = {}
+local db_filename = "seen.db"
+local db_garbage = 0
+
+function remember (who, where, when, what)
+	if not db[who] then db[who] = {} end
+	if db[who][where] then db_garbage = db_garbage + 1 end
+	db[who][where] = { tonumber (when), what }
+end
+
+-- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+
+local db_file, e = io.open (db_filename, "a+")
+if not db_file then error ("cannot open database: " .. e, 0) end
+
+function db_store (who, where, when, what)
+	db_file:write (string.format
+		(":%s %s %s %s :%s\n", who, "PRIVMSG", where, when, what))
+end
+
+function db_compact ()
+	db_file:close ()
+
+	-- Unfortunately, default Lua doesn't have anything like mkstemp()
+	local db_tmpname = db_filename .. "." .. os.time ()
+	db_file, e = io.open (db_tmpname, "a+")
+	if not db_file then error ("cannot save database: " .. e, 0) end
+
+	for who, places in pairs (db) do
+		for where, data in pairs (places) do
+			db_store (who, where, data[1], data[2])
+		end
+	end
+	db_file:flush ()
+
+	local ok, e = os.rename (db_tmpname, db_filename)
+	if not ok then error ("cannot save database: " .. e, 0) end
+	db_garbage = 0
+end
+
+for line in db_file:lines () do
+	local msg = parse (line)
+	remember (msg.prefix, table.unpack (msg.params))
+end
+
+-- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+
+function seen (who, where, args)
+	local respond = function (...)
+		local privmsg = function (target, ...)
+			io.write ("PRIVMSG ", target, " :", table.concat { ... }, "\r\n")
+		end
+		if where:match ("^[#&!+]") then
+			privmsg (where, who, ": ", ...)
+		else
+			privmsg (who, ...)
+		end
+	end
+
+	local whom, e, garbage = args:match ("^(%S+)()%s*(.*)")
+	if not whom or #garbage ~= 0 then
+		return respond ("usage: <name>")
+	elseif who:lower () == whom:lower () then
+		return respond ("I can see you right now.")
+	end
+
+	local top = {}
+	-- That is, * acts like a wildcard, otherwise everything is escaped
+	local pattern = "^" .. whom:gsub ("[%^%$%(%)%%%.%[%]%+%-%?]", "%%%0")
+		:gsub ("%*", ".*"):lower () .. "$"
+	for name, places in pairs (db) do
+		if places[where] and name:lower ():match (pattern) then
+			local when, what = table.unpack (places[where])
+			table.insert (top, { name = name, when = when, what = what })
+		end
+	end
+	if #top == 0 then
+		return respond ("I have not seen \x02" .. whom .. "\x02 here.")
+	end
+
+	-- Get all matching nicknames ordered from the most recently active
+	-- and make the list case insensitive (remove older duplicates)
+	table.sort (top, function (a, b) return a.when > b.when end)
+	for i = #top, 2, -1 do
+		if top[i - 1].name:lower () == top[i].name:lower () then
+			table.remove (top, i)
+		end
+	end
+
+	-- Hopefully the formatting mess will disrupt highlights in clients
+	for i = 1, math.min (#top, 3) do
+		local name = top[i].name:gsub ("^.", "%0\x02\x02")
+		respond (string.format ("\x02%s\x02 -> %s -> %s",
+			name, os.date ("%c", top[i].when), top[i].what))
+	end
+end
+
+function handle (msg)
+	local who = msg.prefix:match ("^[^!@]*")
+	local where, what = table.unpack (msg.params)
+	local when = os.time ()
+
+	local what_log = what:gsub ("^\x01ACTION", "*"):gsub ("\x01$", "")
+	remember (who, where, when, what_log)
+	db_store (who, where, when, what_log)
+
+	-- Comment out to reduce both disk load and reliability
+	db_file:flush ()
+
+	if db_garbage > 5000 then db_compact () end
+
+	if what:sub (1, #prefix) == prefix then
+		local command = what:sub (#prefix + 1)
+		local name, e = command:match ("^(%S+)%s*()")
+		if name == 'seen' then seen (who, where, command:sub (e)) end
+	end
+end
+
+for line in io.lines () do
+	local msg = parse (line)
+	if msg.command == "PRIVMSG" then handle (msg) end
+end

plugins/xB/seen-import-xC.pl

@@ -0,0 +1,39 @@
+#!/usr/bin/env perl
+# Creates a database for the "seen" plugin from logs for xC.
+# The results may not be completely accurate but are good for jumpstarting.
+# Usage: ./seen-import-xC.pl LOG-FILE... > seen.db
+
+use strict;
+use warnings;
+use File::Basename;
+use Time::Piece;
+
+my $db = {};
+for (@ARGV) {
+	my $where = (basename($_) =~ /\.(.*).log/)[0];
+	unless ($where) {
+		print STDERR "Invalid filename: $_\n";
+		next;
+	}
+
+	open my $fh, '<', $_ or die "Failed to open log file: $!";
+	while (<$fh>) {
+		my ($when, $who, $who_action, $what) =
+			/^(.{19}) (?:<[~&@%+]*(.*?)>| \*  (\S+)) (.*)/;
+		next unless $when;
+
+		if ($who_action) {
+			$who = $who_action;
+			$what = "* $what";
+		}
+		$db->{$who}->{$where} =
+			[Time::Piece->strptime($when, "%Y-%m-%d %T")->epoch, $what];
+	}
+}
+
+while (my ($who, $places) = each %$db) {
+	while (my ($where, $data) = each %$places) {
+		my ($when, $what) = @$data;
+		print ":$who PRIVMSG $where $when :$what\n";
+	}
+}

plugins/xB/youtube

@@ -1,8 +1,8 @@
 #!/usr/bin/env python3
 #
-# ZyklonB YouTube plugin, displaying info about YouTube links
+# xB YouTube plugin, displaying info about YouTube links
 #
-# Copyright 2014 - 2015, Přemysl Janouch <p.janouch@gmail.com>
+# Copyright 2014 - 2015, Přemysl Eric Janouch <p@janouch.name>
 # See the file LICENSE for licensing information.
 #
 
@@ -27,12 +27,12 @@ class Plugin:
 		return (nick, user, host, command, args)
 
 	def get_config (self, key):
-		print ("ZYKLONB get_config :%s" % key)
+		print ("XB get_config :%s" % key)
 		(_, _, _, _, args) = self.parse (sys.stdin.readline ())
 		return args[0]
 
 	def bot_print (self, what):
-		print ('ZYKLONB print :%s' % what)
+		print ('XB print :%s' % what)
 
 class YouTube (Plugin):
 	re_videos = [re.compile (x) for x in [
@@ -98,7 +98,7 @@ class YouTube (Plugin):
 		if self.youtube_api_key == "":
 			self.bot_print ("youtube: missing `youtube_api_key'")
 
-		print ("ZYKLONB register")
+		print ("XB register")
 
 		for line in sys.stdin:
 			self.process_line (line)

plugins/xC/auto-rejoin.lua

@@ -0,0 +1,48 @@
+--
+-- auto-rejoin.lua: join back automatically when someone kicks you
+--
+-- Copyright (c) 2016, 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.
+--
+
+local timeout
+xC.setup_config {
+	timeout = {
+		type = "integer",
+		comment = "auto rejoin timeout",
+		default = "0",
+
+		on_change = function (v)
+			timeout = v
+		end,
+		validate = function (v)
+			if v < 0 then error ("timeout must not be negative", 0) end
+		end,
+	},
+}
+
+async, await = xC.async, coroutine.yield
+xC.hook_irc (function (hook, server, line)
+	local msg = xC.parse (line)
+	if msg.command ~= "KICK" then return line end
+
+	local who = msg.prefix:match ("^[^!]*")
+	local channel, whom = table.unpack (msg.params)
+	if who ~= whom and whom == server.user.nickname then
+		async.go (function ()
+			await (async.timer_ms (timeout * 1000))
+			server:send ("JOIN " .. channel)
+		end)
+	end
+	return line
+end)

plugins/xC/censor.lua

@@ -0,0 +1,90 @@
+--
+-- censor.lua: black out certain users' messages
+--
+-- Copyright (c) 2016 - 2021, 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.
+--
+
+local to_pattern = function (mask)
+	if not mask:match ("!") then mask = mask .. "!*" end
+	if not mask:match ("@") then mask = mask .. "@*" end
+
+	-- That is, * acts like a wildcard, otherwise everything is escaped
+	return "^" .. mask:gsub ("[%^%$%(%)%%%.%[%]%+%-%?]", "%%%0")
+		:gsub ("%*", ".*") .. "$"
+end
+
+local patterns = {}
+local read_masks = function (v)
+	patterns = {}
+	local add = function (who, where)
+		local channels = patterns[who] or {}
+		table.insert (channels, where)
+		patterns[who] = channels
+	end
+	for item in v:lower ():gmatch ("[^,]+") do
+		local who, where = item:match ("^([^/]+)/*(.*)")
+		if who then add (to_pattern (who), where == "" or where) end
+	end
+end
+
+local quote
+xC.setup_config {
+	masks = {
+		type = "string_array",
+		default = "\"\"",
+		comment = "user masks (optionally \"/#channel\") to censor",
+		on_change = read_masks
+	},
+	quote = {
+		type = "string",
+		default = "\"\\x0301,01\"",
+		comment = "formatting prefix for censored messages",
+		on_change = function (v) quote = v end
+	},
+}
+
+local decolor = function (text)
+	local rebuilt, last = {""}, 1
+	for start in text:gmatch ('()\x03') do
+		table.insert (rebuilt, text:sub (last, start - 1))
+		local sub = text:sub (start + 1)
+		last = start + (sub:match ('^%d%d?,%d%d?()') or sub:match ('^%d?%d?()'))
+	end
+	return table.concat (rebuilt) .. text:sub (last)
+end
+
+local censor = function (line)
+	-- Taking a shortcut to avoid lengthy message reassembly
+	local start, text = line:match ("^(.- PRIVMSG .- :)(.*)$")
+	local ctcp, rest = text:match ("^(\x01%g+ )(.*)")
+	text = ctcp and ctcp .. quote .. decolor (rest) or quote .. decolor (text)
+	return start .. text
+end
+
+xC.hook_irc (function (hook, server, line)
+	local msg = xC.parse (line)
+	if msg.command ~= "PRIVMSG" then return line end
+
+	local channel = msg.params[1]:lower ()
+	for who, where in pairs (patterns) do
+		if msg.prefix:lower ():match (who) then
+			for _, x in pairs (where) do
+				if x == true or x == channel then
+					return censor (line)
+				end
+			end
+		end
+	end
+	return line
+end)

plugins/xC/fancy-prompt.lua

@@ -0,0 +1,113 @@
+--
+-- fancy-prompt.lua: the fancy multiline prompt you probably want
+--
+-- Copyright (c) 2016 - 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.
+--
+-- Beware that it is a hack and only goes about 90% of the way, which is why
+-- this functionality is only available as a plugin in the first place
+-- (well, and also for customizability).
+--
+-- The biggest problem is that the way we work with Readline is incompatible
+-- with multiline prompts, and normal newlines just don't work.  This is being
+-- circumvented by using an overflowing single-line prompt with a specially
+-- crafted character in the rightmost column that prevents the bar's background
+-- from spilling all over the last line.
+--
+-- There is also a problem with C-r search rendering not clearing out the
+-- background but to really fix that mode, we'd have to fully reimplement it
+-- since its alternative prompt very often gets overriden by accident anyway.
+
+xC.hook_prompt (function (hook)
+	local current = xC.current_buffer
+	local chan = current.channel
+	local s = current.server
+
+	local bg_color = "255"
+	local current_n = 0
+	local active = ""
+	for i, buffer in ipairs (xC.buffers) do
+		if buffer == current then
+			current_n = i
+		elseif buffer.new_messages_count ~= buffer.new_unimportant_count then
+			active = active .. ","
+			if buffer.highlighted then
+				active = active .. "!"
+				bg_color = "224"
+			end
+			active = active .. i
+		end
+	end
+	local x = current_n .. ":" .. current.name
+	if chan and chan.users_len ~= 0 then
+		local params = ""
+		for mode, param in pairs (chan.param_modes) do
+			params = params .. " +" .. mode .. " " .. param
+		end
+		local modes = chan.no_param_modes .. params:sub (3)
+		if modes ~= "" then
+			x = x .. "(+" .. modes .. ")"
+		end
+		x = x .. "{" .. chan.users_len .. "}"
+	end
+	if current.hide_unimportant then
+		x = x .. "<H>"
+	end
+	if active ~= "" then
+		x = x .. " (" .. active:sub (2) .. ")"
+	end
+
+	-- Readline 7.0.003 seems to be broken and completely corrupts the prompt.
+	-- However 8.0.004 seems to be fine with these, as is libedit 20191231-3.1.
+	--x = x:gsub("[\128-\255]", "?")
+
+	-- Align to the terminal's width and apply formatting, including the hack.
+	local lines, cols = xC.get_screen_size ()
+	local trailing, width = " ", xC.measure (x)
+	while cols > 0 and width >= cols do
+		x = x:sub (1, utf8.offset (x, -1) - 1)
+		trailing, width = ">", xC.measure (x)
+	end
+
+	x = "\x01\x1b[0;4;1;38;5;16m\x1b[48;5;" .. bg_color .. "m\x02" ..
+		x .. string.rep (" ", cols - width - 1) ..
+		"\x01\x1b[0;4;1;7;38;5;" .. bg_color .. "m\x02" ..
+		trailing .. "\x01\x1b[0;1m\x02"
+
+	local user_prefix = function (chan, user)
+		for i, chan_user in ipairs (chan.users) do
+			if chan_user.user == user then return chan_user.prefixes end
+		end
+		return ""
+	end
+	if s then
+		x = x .. "["
+		local state = s.state
+		if state == "disconnected" or state == "connecting" then
+			x = x .. "(" .. state .. ")"
+		elseif state ~= "registered" then
+			x = x .. "(unregistered)"
+		else
+			local user, modes = s.user, s.user_mode
+			if chan then x = x .. user_prefix (chan, user) end
+			x = x .. user.nickname
+			if modes ~= "" then x = x .. "(" .. modes .. ")" end
+		end
+		x = x .. "] "
+	else
+		-- There needs to be at least one character so that the cursor
+		-- doesn't get damaged by our hack in that last column
+		x = x .. "> "
+	end
+	return x
+end)

plugins/xC/last-fm.lua

@@ -0,0 +1,178 @@
+--
+-- last-fm.lua: "now playing" feature using the last.fm API
+--
+-- Dependencies: lua-cjson (from luarocks e.g.)
+--
+-- I call this style closure-oriented programming
+--
+-- Copyright (c) 2016, 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.
+--
+
+local cjson = require "cjson"
+
+-- Setup configuration to load last.fm API credentials from
+local user, api_key
+xC.setup_config {
+	user    = {
+		type = "string",
+		comment = "last.fm username",
+		on_change = function (v) user    = v end
+	},
+	api_key = {
+		type = "string",
+		comment = "last.fm API key",
+		on_change = function (v) api_key = v end
+	},
+}
+
+-- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+
+-- Generic error reporting
+local report_error = function (buffer, error)
+	buffer:log ("last-fm error: " .. error)
+end
+
+-- Process data return by the server and extract the now playing song
+local process = function (buffer, data, action)
+	-- There's no reasonable Lua package to parse HTTP that I could find
+	local s, e, v, status, message = string.find (data, "(%S+) (%S+) .+\r\n")
+	if not s then return "server returned unexpected data" end
+	if status ~= "200" then return status .. " " .. message end
+
+	local s, e = string.find (data, "\r\n\r\n")
+	if not s then return "server returned unexpected data" end
+
+	local parser = cjson.new ()
+	data = parser.decode (string.sub (data, e + 1))
+	if not data.recenttracks or not data.recenttracks.track then
+		return "invalid response" end
+
+	-- Need to make some sense of the XML automatically converted to JSON
+	local text_of = function (node)
+		if type (node) ~= "table" then return node end
+		return node["#text"] ~= "" and node["#text"] or nil
+	end
+
+	local name, artist, album
+	for i, track in ipairs (data.recenttracks.track) do
+		if track["@attr"] and track["@attr"].nowplaying then
+			if track.name   then name   = text_of (track.name)   end
+			if track.artist then artist = text_of (track.artist) end
+			if track.album  then album  = text_of (track.album)  end
+		end
+	end
+
+	if not name then
+		action (false)
+	else
+		local np = "\"" .. name .. "\""
+		if artist then np = np .. " by "   .. artist end
+		if album  then np = np .. " from " .. album  end
+		action (np)
+	end
+end
+
+-- Set up the connection and make the request
+local on_connected = function (buffer, c, host, action)
+	-- Buffer data in the connection object
+	c.data = ""
+	c.on_data = function (data)
+		c.data = c.data .. data
+	end
+
+	-- And process it after we receive everything
+	c.on_eof = function ()
+		error = process (buffer, c.data, action)
+		if error then report_error (buffer, error) end
+		c:close ()
+	end
+	c.on_error = function (e)
+		report_error (buffer, e)
+	end
+
+	-- Make the unencrypted HTTP request
+	local url = "/2.0/?method=user.getrecenttracks&user=" .. user ..
+		"&limit=1&api_key=" .. api_key .. "&format=json"
+	c:send ("GET " .. url .. " HTTP/1.1\r\n")
+	c:send ("User-agent: last-fm.lua\r\n")
+	c:send ("Host: " .. host .. "\r\n")
+	c:send ("Connection: close\r\n")
+	c:send ("\r\n")
+end
+
+-- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+
+-- Avoid establishing more than one connection at a time
+local running
+
+-- Initiate a connection to last.fm servers
+async, await = xC.async, coroutine.yield
+local make_request = function (buffer, action)
+	if not user or not api_key then
+		report_error (buffer, "configuration is incomplete")
+		return
+	end
+
+	if running then running:cancel () end
+	running = async.go (function ()
+		local c, host, e = await (async.dial ("ws.audioscrobbler.com", 80))
+		if e then
+			report_error (buffer, e)
+		else
+			on_connected (buffer, c, host, action)
+		end
+		running = nil
+	end)
+end
+
+-- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+
+local now_playing
+
+local tell_song = function (buffer)
+	if now_playing == nil then
+		buffer:log ("last-fm: I don't know what you're listening to")
+	elseif not now_playing then
+		buffer:log ("last-fm: not playing anything right now")
+	else
+		buffer:log ("last-fm: now playing: " .. now_playing)
+	end
+end
+
+local send_song = function (buffer)
+	if not now_playing then
+		tell_song (buffer)
+	else
+		buffer:execute ("/me is listening to " .. now_playing)
+	end
+end
+
+-- Hook input to simulate new commands
+xC.hook_input (function (hook, buffer, input)
+	if input == "/np" then
+		make_request (buffer, function (np)
+			now_playing = np
+			send_song (buffer)
+		end)
+	elseif input == "/np?" then
+		make_request (buffer, function (np)
+			now_playing = np
+			tell_song (buffer)
+		end)
+	elseif input == "/np!" then
+		send_song (buffer)
+	else
+		return input
+	end
+end)

plugins/xC/ping-timeout.lua

@@ -0,0 +1,32 @@
+--
+-- ping-timeout.lua: ping timeout readability enhancement plugin
+--
+-- Copyright (c) 2015 - 2016, 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.
+--
+
+xC.hook_irc (function (hook, server, line)
+	local msg = xC.parse (line)
+	local start, timeout = line:match ("^(.* :Ping timeout:) (%d+) seconds$")
+	if msg.command ~= "QUIT" or not start then
+		return line
+	end
+
+	local minutes = timeout // 60
+	if minutes == 0 then
+		return line
+	end
+
+	local seconds = timeout % 60
+	return ("%s %d minutes, %d seconds"):format (start, minutes, seconds)
+end)

plugins/xC/prime.lua

@@ -0,0 +1,68 @@
+--
+-- prime.lua: highlight prime numbers in messages
+--
+-- Copyright (c) 2020, 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.
+--
+
+local smallest, highlight = 0, "\x1f"
+xC.setup_config {
+	smallest = {
+		type = "integer",
+		default = "0",
+		comment = "smallest number to scan for primality",
+		on_change = function (v) smallest = math.max (v, 2) end
+	},
+	highlight = {
+		type = "string",
+		default = "\"\\x1f\"",
+		comment = "the attribute to use for highlights",
+		on_change = function (v) highlight = v end
+	},
+}
+
+-- The prime test is actually very fast, so there is no DoS concern
+local do_intercolour = function (text)
+	return tostring (text:gsub ("%f[%w_]%d+", function (n)
+		if tonumber (n) < smallest then return nil end
+		for i = 2, n ^ (1 / 2) do if (n % i) == 0 then return nil end end
+		return highlight .. n .. highlight
+	end))
+end
+
+local do_interlink = function (text)
+	local rebuilt, last = {""}, 1
+	for start in text:gmatch ('()\x03') do
+		table.insert (rebuilt, do_intercolour (text:sub (last, start - 1)))
+		local sub = text:sub (start + 1)
+		last = start + (sub:match ('^%d%d?,%d%d?()') or sub:match ('^%d?%d?()'))
+		table.insert (rebuilt, text:sub (start, last - 1))
+	end
+	return table.concat (rebuilt) .. do_intercolour (text:sub (last))
+end
+
+local do_message = function (text)
+	local rebuilt, last = {""}, 1
+	for run, link, endpos in text:gmatch ('(.-)(%f[%g]https?://%g+)()') do
+		last = endpos
+		table.insert (rebuilt, do_interlink (run) .. link)
+	end
+	return table.concat (rebuilt) .. do_interlink (text:sub (last))
+end
+
+-- XXX: sadly it won't typically highlight primes in our own messages,
+-- unless IRCv3 echo-message is on
+xC.hook_irc (function (hook, server, line)
+	local start, message = line:match ("^(.- PRIVMSG .- :)(.*)$")
+	return message and start .. do_message (message) or line
+end)

plugins/xC/slack.lua

@@ -0,0 +1,147 @@
+--
+-- slack.lua: try to fix up UX when using the Slack IRC gateway
+--
+-- Copyright (c) 2017, 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.
+--
+
+local servers = {}
+local read_servers = function (v)
+	servers = {}
+	for name in v:lower ():gmatch "[^,]+" do
+		servers[name] = true
+	end
+end
+
+-- This is a reverse list of Slack's automatic emoji, noseless forms
+local unemojify, emoji, emoji_default = false, {}, {
+	heart                        = "<3",
+	broken_heart                 = "</3",
+	sunglasses                   = "8)",
+	anguished                    = "D:",
+	cry                          = ":'(",
+	monkey_face                  = ":o)",
+	kiss                         = ":*",
+	smiley                       = "=)",
+	smile                        = ":D",
+	wink                         = ";)",
+	laughing                     = ":>",
+	neutral_face                 = ":|",
+	open_mouth                   = ":o",
+	angry                        = ">:(",
+	slightly_smiling_face        = ":)",
+	disappointed                 = ":(",
+	confused                     = ":/",
+	stuck_out_tongue             = ":p",
+	stuck_out_tongue_winking_eye = ";p",
+}
+local load_emoji = function (extra)
+	emoji = {}
+	for k, v in pairs (emoji_default) do emoji[k] = v end
+	for k, v in extra:gmatch "([^,]+) ([^,]+)" do emoji[k] = v end
+end
+
+xC.setup_config {
+	servers = {
+		type = "string_array",
+		default = "\"\"",
+		comment = "list of server names that are Slack IRC gateways",
+		on_change = read_servers
+	},
+	unemojify = {
+		type = "boolean",
+		default = "true",
+		comment = "convert emoji to normal ASCII emoticons",
+		on_change = function (v) unemojify = v end
+	},
+	extra_emoji = {
+		type = "string_array",
+		default = "\"grinning :)),joy :'),innocent o:),persevere >_<\"",
+		comment = "overrides or extra emoji for unemojify",
+		on_change = function (v) load_emoji (v) end
+	}
+}
+
+-- We can handle external messages about what we've supposedly sent just fine,
+-- so let's get rid of that "[username] some message sent from the web UI" crap
+xC.hook_irc (function (hook, server, line)
+	local msg, us = xC.parse (line), server.user
+	if not servers[server.name] or msg.command ~= "PRIVMSG" or not us
+		or msg.params[1]:lower () ~= us.nickname:lower () then return line end
+
+	-- Taking a shortcut to avoid lengthy message reassembly
+	local quoted_nick = us.nickname:gsub ("[%^%$%(%)%%%.%[%]%*%+%-%?]", "%%%0")
+	local text = line:match ("^.- PRIVMSG .- :%[" .. quoted_nick .. "%] (.*)$")
+	if not text then return line end
+	return ":" .. us.nickname .. "!" .. server.irc_user_host .. " PRIVMSG "
+		.. msg.prefix:match "^[^!@]*" .. " :" .. text
+end)
+
+-- Unfuck emoji and :nick!nick@irc.tinyspeck.com MODE #channel +v nick : active
+xC.hook_irc (function (hook, server, line)
+	if not servers[server.name] then return line end
+	if unemojify then
+		local start, text = line:match ("^(.- PRIVMSG .- :)(.*)$")
+		if start then return start .. text:gsub (":([a-z_]+):", function (name)
+			if emoji[name] then return emoji[name] end
+			return ":" .. name .. ":"
+		end) end
+	end
+	return line:gsub ("^(:%S+ MODE .+) : .*", "%1")
+end)
+
+-- The gateway simply ignores the NAMES command altogether
+xC.hook_input (function (hook, buffer, input)
+	if not buffer.channel or not servers[buffer.server.name]
+		or not input:match "^/names%s*$" then return input end
+
+	local users = buffer.channel.users
+	table.sort (users, function (a, b)
+		if a.prefixes > b.prefixes then return true end
+		if a.prefixes < b.prefixes then return false end
+		return a.user.nickname < b.user.nickname
+	end)
+
+	local names = "Users on " .. buffer.channel.name .. ":"
+	for i, chan_user in ipairs (users) do
+		names = names .. " " .. chan_user.prefixes .. chan_user.user.nickname
+	end
+	buffer:log (names)
+end)
+
+xC.hook_completion (function (hook, data, word)
+	local chan = xC.current_buffer.channel
+	local server = xC.current_buffer.server
+	if not chan or not servers[server.name] then return end
+
+	-- In /commands there is typically no desire at all to add the at sign
+	if data.location == 1 and data.words[1]:match "^/" then return end
+
+	-- Handle both when the at sign is already there and when it is not
+	local needle = word:gsub ("^@", ""):lower ()
+
+	local t = {}
+	local try = function (name)
+		if data.location == 0 then name = name .. ":" end
+		if name:sub (1, #needle):lower () == needle then
+			table.insert (t, "@" .. name)
+		end
+	end
+	for _, chan_user in ipairs (chan.users) do
+		try (chan_user.user.nickname)
+	end
+	for _, special in ipairs { "channel", "here" } do
+		try (special)
+	end
+	return t
+end)

plugins/xC/thin-cursor.lua

@@ -0,0 +1,27 @@
+--
+-- thin-cursor.lua: set a thin cursor
+--
+-- Copyright (c) 2016, 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.
+--
+-- If tmux doesn't work, add the following to its configuration:
+--   set -as terminal-overrides ',*:Ss=\E[%p1%d q:Se=\E[2 q'
+-- Change the "2" as per http://invisible-island.net/xterm/ctlseqs/ctlseqs.html
+
+local out = io.output ()
+out:write ("\x1b[6 q"):flush ()
+
+-- By registering a global variable, we get notified about plugin unload
+x = setmetatable ({}, { __gc = function ()
+	out:write ("\x1b[2 q"):flush ()
+end })

plugins/xC/utm-filter.lua

@@ -0,0 +1,66 @@
+--
+-- utm-filter.lua: filter out Google Analytics bullshit etc. from URLs
+--
+-- Copyright (c) 2015 - 2021, 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.
+--
+
+-- A list of useless URL parameters that don't affect page function
+local banned = {
+	gclid        = 1,
+
+	-- Alas, Facebook no longer uses this parameter, see:
+	-- https://news.ycombinator.com/item?id=32117489
+	fbclid       = 1,
+
+	utm_source   = 1,
+	utm_medium   = 1,
+	utm_term     = 1,
+	utm_content  = 1,
+	utm_campaign = 1,
+}
+
+-- Go through a parameter list and throw out any banned elements
+local do_args = function (args)
+	local filtered = {}
+	for part in args:gmatch ("[^&]+") do
+		if not banned[part:match ("^[^=]*")] then
+			table.insert (filtered, part)
+		end
+	end
+	return table.concat (filtered, "&")
+end
+
+-- Filter parameters in both the query and the fragment part of an URL
+local do_single_url = function (url)
+	return url:gsub ('^([^?#]*)%?([^#]*)', function (start, query)
+		local clean = do_args (query)
+		return #clean > 0 and start .. "?" .. clean or start
+	end, 1):gsub ('^([^#]*)#(.*)', function (start, fragment)
+		local clean = do_args (fragment)
+		return #clean > 0 and start .. "#" .. clean or start
+	end, 1)
+end
+
+local do_text = function (text)
+	return text:gsub ('%f[%g]https?://%g+', do_single_url)
+end
+
+xC.hook_irc (function (hook, server, line)
+	local start, message = line:match ("^(.* :)(.*)$")
+	return message and start .. do_text (message) or line
+end)
+
+xC.hook_input (function (hook, buffer, input)
+	return do_text (input)
+end)

test

@@ -1,14 +1,14 @@
 #!/usr/bin/expect -f
-# Very basic end-to-end testing for Travis CI
+# Very basic end-to-end testing for CI
 
 # Run the daemon to test against
-system ./kike --write-default-cfg
-spawn ./kike -d
+system ./xD --write-default-cfg
+spawn ./xD -d
 
 # 10 seconds is a bit too much
 set timeout 5
 
-spawn ./degesch
+spawn ./xC
 
 # Fuck this Tcl shit, I want the exit code
 expect_after {

test-nick-colors

@@ -0,0 +1,26 @@
+#!/bin/sh
+# Check whether the terminal colours filtered by our algorithm are legible
+export example=$(
+	tcc "-run -lm" - <<-END
+	#include <stddef.h>
+	#include <stdio.h>
+	#include <math.h>
+
+	#define N_ELEMENTS(a) (sizeof (a) / sizeof ((a)[0]))
+
+	$(perl -0777 -ne 'print $& if /^.*?\nfilter_color(?s:.*?)^}$/m' \
+		"$(dirname "$0")"/xC.c)
+
+	void main () {
+		size_t len = 0;
+		int *table = filter_color_cube_for_acceptable_nick_colors (&len);
+		for (size_t i = 0; i < len; i++)
+			printf ("<@\\x1b[38;5;%dmIRCuser\\x1b[m> I'm typing!\n", table[i]);
+	}
+	END
+)
+
+# Both should give acceptable results,
+# which results in a bad compromise that the main author himself needs
+xterm -bg black -fg white -e 'echo $example; cat' &
+xterm -bg white -fg black -e 'echo $example; cat' &

test-static

@@ -0,0 +1,14 @@
+#!/bin/sh
+# We don't use printf's percent notation with our custom logging mechanism,
+# so the compiler cannot check it for us like it usually does
+perl -n0777 - "$(dirname "$0")"/xC.c <<-'END'
+	while (/\blog_[^ ]+\s*\([^"()]*"[^"]*%[^%][^"]*"/gm) {
+		my ($p, $m) = ($`, $&);
+		printf "$ARGV:%d: suspicious log format string: %s...\n",
+			(1 + $p =~ tr/\n//), ($m =~ s/\s+/ /rg);
+		$status = 1;
+	}
+	END {
+		exit $status;
+	}
+END

xB.adoc

@@ -0,0 +1,104 @@
+xB(1)
+=====
+:doctype: manpage
+:manmanual: xK Manual
+:mansource: xK {release-version}
+
+Name
+----
+xB - modular IRC bot
+
+Synopsis
+--------
+*xB* [_OPTION_]...
+
+Description
+-----------
+*xB* is a modular IRC bot with a programming language-agnostic plugin
+architecture based on co-processes.
+
+Options
+-------
+*-d*, *--debug*::
+	Print more information to help debug various issues.
+
+*-h*, *--help*::
+	Display a help message and exit.
+
+*-V*, *--version*::
+	Output version information and exit.
+
+*--write-default-cfg*[**=**__PATH__]::
+	Write a configuration file with defaults, show its path and exit.
++
+The file will be appropriately commented.
+
+Commands
+--------
+The bot accepts the following commands when they either appear quoted by the
+*prefix* string on a channel or unquoted as a private message sent directly
+to the bot, on the condition that the sending user matches the *admin*
+regular expression or that it is left unset:
+
+*quote* [_message_]::
+	Forwards the message to the IRC server as-is.
+*quit* [_reason_]::
+	Quits the IRC server, with an optional reason string.
+*status*::
+	Sends back a report about its state and all loaded plugins.
+*load* _plugin_[, _plugin_]...::
+	Tries to load the given plugins.
+*unload* _plugin_[, _plugin_]...::
+	Tries to unload the given plugins.
+*reload* _plugin_[, _plugin_]...::
+	The same as *unload* immediately followed by *load*.
+
+Plugins
+-------
+Plugins communicate with the bot over their standard input and output streams
+using the IRC protocol.  (Caveat: the standard C library doesn't automatically
+flush FILE streams for pipes on newlines.)  A special *XB* command is introduced
+for RPC, with the following subcommands:
+
+*XB get_config* __key__::
+	Request the value of the given configuration option.  If no such option
+	exists, the value will be empty.  The response will be delivered in
+	the following format:
++
+....
+XB :value
+....
++
+This is particularly useful for retrieving the *prefix* string.
+
+*XB print* _message_::
+	Make the bot print the _message_ on its standard output.
+
+*XB register*::
+	Once a plugin issues this command, it will start receiving all of the bot's
+	incoming IRC traffic, which includes data from the initialization period.
+
+All other commands will be forwarded directly to the IRC server.
+
+Files
+-----
+*xB* follows the XDG Base Directory Specification.
+
+_~/.config/xB/xB.conf_::
+	The bot's configuration file.  Use the *--write-default-cfg* option
+	to create a new one for editing.
+
+_~/.local/share/xB/_::
+	The initial working directory for plugins, in which they may create private
+	databases or other files as needed.
+
+_~/.local/share/xB/plugins/_::
+_/usr/local/share/xB/plugins/_::
+_/usr/share/xB/plugins/_::
+	Plugins are searched for in these directories, in order, unless
+	the *plugin_dir* configuration option overrides this.
+
+Reporting bugs
+--------------
+Use https://git.janouch.name/p/xK to report bugs, request features,
+or submit pull requests.

xB.c

@@ -1,11 +1,10 @@
 /*
- * zyklonb.c: the experimental IRC bot
+ * xB.c: a modular IRC bot
  *
- * Copyright (c) 2014 - 2015, Přemysl Janouch <p.janouch@gmail.com>
+ * Copyright (c) 2014 - 2020, 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, provided that the above
- * copyright notice and this permission notice appear in all copies.
+ * 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
@@ -18,25 +17,25 @@
  */
 
 #include "config.h"
-#define PROGRAM_NAME "ZyklonB"
+#define PROGRAM_NAME "xB"
 
 #include "common.c"
 
 // --- Configuration (application-specific) ------------------------------------
 
-static struct config_item g_config_table[] =
+static struct simple_config_item g_config_table[] =
 {
-	{ "nickname",        "ZyklonB",         "IRC nickname"                   },
+	{ "nickname",        "xB",              "IRC nickname"                   },
 	{ "username",        "bot",             "IRC user name"                  },
-	{ "realname",        "ZyklonB IRC bot", "IRC real name/e-mail"           },
+	{ "realname",        "xB IRC bot",      "IRC real name/e-mail"           },
 
 	{ "irc_host",        NULL,              "Address of the IRC server"      },
 	{ "irc_port",        "6667",            "Port of the IRC server"         },
-	{ "ssl",             "off",             "Whether to use SSL"             },
-	{ "ssl_cert",        NULL,              "Client SSL certificate (PEM)"   },
-	{ "ssl_verify",      "on",              "Whether to verify certificates" },
-	{ "ssl_ca_file",     NULL,              "OpenSSL CA bundle file"         },
-	{ "ssl_ca_path",     NULL,              "OpenSSL CA bundle path"         },
+	{ "tls",             "off",             "Whether to use TLS"             },
+	{ "tls_cert",        NULL,              "Client TLS certificate (PEM)"   },
+	{ "tls_verify",      "on",              "Whether to verify certificates" },
+	{ "tls_ca_file",     NULL,              "OpenSSL CA bundle file"         },
+	{ "tls_ca_path",     NULL,              "OpenSSL CA bundle path"         },
 	{ "autojoin",        NULL,              "Channels to join on start"      },
 	{ "reconnect",       "on",              "Whether to reconnect on error"  },
 	{ "reconnect_delay", "5",               "Time between reconnecting"      },
@@ -49,7 +48,7 @@ static struct config_item g_config_table[] =
 	{ "prefix",          ":",               "The prefix for bot commands"    },
 	{ "admin",           NULL,              "Host mask for administrators"   },
 	{ "plugins",         NULL,              "The plugins to load on startup" },
-	{ "plugin_dir",      PLUGIN_DIR,        "Where to search for plugins"    },
+	{ "plugin_dir",      NULL,              "Plugin search path override"    },
 	{ "recover",         "on",              "Whether to re-launch on crash"  },
 
 	{ NULL,              NULL,              NULL                             }
@@ -82,22 +81,22 @@ struct plugin
 	struct str write_buffer;            ///< Output yet to be sent out
 };
 
-static void
-plugin_init (struct plugin *self)
+static struct plugin *
+plugin_new (void)
 {
-	memset (self, 0, sizeof *self);
-
+	struct plugin *self = xcalloc (1, sizeof *self);
 	self->pid = -1;
-	str_init (&self->queued_output);
+	self->queued_output = str_make ();
 
 	self->read_fd = -1;
-	str_init (&self->read_buffer);
+	self->read_buffer = str_make ();
 	self->write_fd = -1;
-	str_init (&self->write_buffer);
+	self->write_buffer = str_make ();
+	return self;
 }
 
 static void
-plugin_free (struct plugin *self)
+plugin_destroy (struct plugin *self)
 {
 	soft_assert (self->pid == -1);
 	free (self->name);
@@ -112,6 +111,8 @@ plugin_free (struct plugin *self)
 
 	if (!self->initialized)
 		str_free (&self->queued_output);
+
+	free (self);
 }
 
 // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
@@ -151,34 +152,33 @@ static void on_irc_reconnect_timeout (void *user_data);
 static void
 bot_context_init (struct bot_context *self)
 {
-	str_map_init (&self->config);
-	self->config.free = free;
-	load_config_defaults (&self->config, g_config_table);
+	self->config = str_map_make (free);
+	simple_config_load_defaults (&self->config, g_config_table);
 	self->admin_re = NULL;
 
 	self->irc_fd = -1;
-	str_init (&self->read_buffer);
+	self->read_buffer = str_make ();
 	self->irc_registered = false;
 
 	self->ssl = NULL;
 	self->ssl_ctx = NULL;
 
 	self->plugins = NULL;
-	str_map_init (&self->plugins_by_name);
+	self->plugins_by_name = str_map_make (NULL);
 
 	poller_init (&self->poller);
 	self->quitting = false;
 	self->polling = false;
 
-	poller_timer_init (&self->timeout_tmr, &self->poller);
+	self->timeout_tmr = poller_timer_make (&self->poller);
 	self->timeout_tmr.dispatcher = on_irc_timeout;
 	self->timeout_tmr.user_data = self;
 
-	poller_timer_init (&self->ping_tmr, &self->poller);
+	self->ping_tmr = poller_timer_make (&self->poller);
 	self->ping_tmr.dispatcher = on_irc_ping_timeout;
 	self->ping_tmr.user_data = self;
 
-	poller_timer_init (&self->reconnect_tmr, &self->poller);
+	self->reconnect_tmr = poller_timer_make (&self->poller);
 	self->reconnect_tmr.dispatcher = on_irc_reconnect_timeout;
 	self->reconnect_tmr.user_data = self;
 }
@@ -192,18 +192,13 @@ bot_context_free (struct bot_context *self)
 	str_free (&self->read_buffer);
 
 	// TODO: terminate the plugins properly before this is called
-	struct plugin *link, *tmp;
-	for (link = self->plugins; link; link = tmp)
-	{
-		tmp = link->next;
-		plugin_free (link);
-		free (link);
-	}
+	LIST_FOR_EACH (struct plugin, link, self->plugins)
+		plugin_destroy (link);
 
 	if (self->irc_fd != -1)
 	{
-		xclose (self->irc_fd);
 		poller_fd_reset (&self->irc_event);
+		xclose (self->irc_fd);
 	}
 	if (self->ssl)
 		SSL_free (self->ssl);
@@ -271,8 +266,7 @@ irc_send (struct bot_context *ctx, const char *format, ...)
 		return false;
 
 	va_start (ap, format);
-	struct str str;
-	str_init (&str);
+	struct str str = str_make ();
 	str_append_vprintf (&str, format, ap);
 	str_append (&str, "\r\n");
 	va_end (ap);
@@ -285,7 +279,7 @@ irc_send (struct bot_context *ctx, const char *format, ...)
 		if (SSL_write (ctx->ssl, str.str, str.len) != (int) str.len)
 		{
 			print_debug ("%s: %s: %s", __func__, "SSL_write",
-				ERR_error_string (ERR_get_error (), NULL));
+				xerr_describe_error ());
 			result = false;
 		}
 	}
@@ -309,8 +303,54 @@ irc_get_boolean_from_config
 	if (set_boolean_if_valid (value, str))
 		return true;
 
-	error_set (e, "invalid configuration value for `%s'", name);
-	return false;
+	return error_set (e, "invalid configuration value for `%s'", name);
+}
+
+static bool
+irc_initialize_ca_set (SSL_CTX *ssl_ctx, const char *file, const char *path,
+	struct error **e)
+{
+	ERR_clear_error ();
+
+	if (file || path)
+	{
+		if (SSL_CTX_load_verify_locations (ssl_ctx, file, path))
+			return true;
+
+		return error_set (e, "%s: %s",
+			"failed to set locations for the CA certificate bundle",
+			xerr_describe_error ());
+	}
+
+	if (!SSL_CTX_set_default_verify_paths (ssl_ctx))
+		return error_set (e, "%s: %s",
+			"couldn't load the default CA certificate bundle",
+			xerr_describe_error ());
+	return true;
+}
+
+static bool
+irc_initialize_ca (struct bot_context *ctx, struct error **e)
+{
+	const char *ca_file = str_map_find (&ctx->config, "tls_ca_file");
+	const char *ca_path = str_map_find (&ctx->config, "tls_ca_path");
+
+	char *full_file = ca_file
+		? resolve_filename (ca_file, resolve_relative_config_filename) : NULL;
+	char *full_path = ca_path
+		? resolve_filename (ca_path, resolve_relative_config_filename) : NULL;
+
+	bool ok = false;
+	if      (ca_file && !full_file)
+		error_set (e, "couldn't find the CA bundle file");
+	else if (ca_path && !full_path)
+		error_set (e, "couldn't find the CA bundle path");
+	else
+		ok = irc_initialize_ca_set (ctx->ssl_ctx, full_file, full_path, e);
+
+	free (full_file);
+	free (full_path);
+	return ok;
 }
 
 static bool
@@ -320,50 +360,29 @@ irc_initialize_ssl_ctx (struct bot_context *ctx, struct error **e)
 	SSL_CTX_set_options (ctx->ssl_ctx, SSL_OP_NO_SSLv2 | SSL_OP_NO_SSLv3);
 
 	bool verify;
-	if (!irc_get_boolean_from_config (ctx, "ssl_verify", &verify, e))
+	if (!irc_get_boolean_from_config (ctx, "tls_verify", &verify, e))
 		return false;
 	SSL_CTX_set_verify (ctx->ssl_ctx,
 		verify ? SSL_VERIFY_PEER : SSL_VERIFY_NONE, NULL);
 
-	const char *ca_file = str_map_find (&ctx->config, "ca_file");
-	const char *ca_path = str_map_find (&ctx->config, "ca_path");
-
 	struct error *error = NULL;
-	if (ca_file || ca_path)
+	if (!irc_initialize_ca (ctx, &error))
 	{
-		if (SSL_CTX_load_verify_locations (ctx->ssl_ctx, ca_file, ca_path))
-			return true;
+		if (verify)
+		{
+			error_propagate (e, error);
+			return false;
+		}
 
-		error_set (&error, "%s: %s",
-			"failed to set locations for the CA certificate bundle",
-			ERR_reason_error_string (ERR_get_error ()));
-		goto ca_error;
+		// Only inform the user if we're not actually verifying
+		print_warning ("%s", error->message);
+		error_free (error);
 	}
-
-	if (!SSL_CTX_set_default_verify_paths (ctx->ssl_ctx))
-	{
-		error_set (&error, "%s: %s",
-			"couldn't load the default CA certificate bundle",
-			ERR_reason_error_string (ERR_get_error ()));
-		goto ca_error;
-	}
-	return true;
-
-ca_error:
-	if (verify)
-	{
-		error_propagate (e, error);
-		return false;
-	}
-
-	// Only inform the user if we're not actually verifying
-	print_warning ("%s", error->message);
-	error_free (error);
 	return true;
 }
 
 static bool
-irc_initialize_ssl (struct bot_context *ctx, struct error **e)
+irc_initialize_tls (struct bot_context *ctx, struct error **e)
 {
 	const char *error_info = NULL;
 	ctx->ssl_ctx = SSL_CTX_new (SSLv23_client_method ());
@@ -376,18 +395,18 @@ irc_initialize_ssl (struct bot_context *ctx, struct error **e)
 	if (!ctx->ssl)
 		goto error_ssl_2;
 
-	const char *ssl_cert = str_map_find (&ctx->config, "ssl_cert");
-	if (ssl_cert)
+	const char *tls_cert = str_map_find (&ctx->config, "tls_cert");
+	if (tls_cert)
 	{
 		char *path = resolve_filename
-			(ssl_cert, resolve_relative_config_filename);
+			(tls_cert, resolve_relative_config_filename);
 		if (!path)
-			print_error ("%s: %s", "cannot open file", ssl_cert);
+			print_error ("%s: %s", "cannot open file", tls_cert);
 		// XXX: perhaps we should read the file ourselves for better messages
 		else if (!SSL_use_certificate_file (ctx->ssl, path, SSL_FILETYPE_PEM)
 			|| !SSL_use_PrivateKey_file (ctx->ssl, path, SSL_FILETYPE_PEM))
-			print_error ("%s: %s", "setting the SSL client certificate failed",
-				ERR_error_string (ERR_get_error (), NULL));
+			print_error ("%s: %s", "setting the TLS client certificate failed",
+				xerr_describe_error ());
 		free (path);
 	}
 
@@ -414,12 +433,9 @@ error_ssl_2:
 	SSL_CTX_free (ctx->ssl_ctx);
 	ctx->ssl_ctx = NULL;
 error_ssl_1:
-	// XXX: these error strings are really nasty; also there could be
-	//   multiple errors on the OpenSSL stack.
 	if (!error_info)
-		error_info = ERR_error_string (ERR_get_error (), NULL);
-	error_set (e, "%s: %s", "could not initialize SSL", error_info);
-	return false;
+		error_info = xerr_describe_error ();
+	return error_set (e, "%s: %s", "could not initialize TLS", error_info);
 }
 
 static bool
@@ -432,11 +448,8 @@ irc_establish_connection (struct bot_context *ctx,
 
 	int err = getaddrinfo (host, port, &gai_hints, &gai_result);
 	if (err)
-	{
-		error_set (e, "%s: %s: %s",
-			"connection failed", "getaddrinfo", gai_strerror (err));
-		return false;
-	}
+		return error_set (e, "%s: %s: %s", "connection failed",
+			"getaddrinfo", gai_strerror (err));
 
 	int sockfd;
 	for (gai_iter = gai_result; gai_iter; gai_iter = gai_iter->ai_next)
@@ -477,10 +490,7 @@ irc_establish_connection (struct bot_context *ctx,
 	freeaddrinfo (gai_result);
 
 	if (!gai_iter)
-	{
-		error_set (e, "connection failed");
-		return false;
-	}
+		return error_set (e, "connection failed");
 
 	ctx->irc_fd = sockfd;
 	return true;
@@ -490,7 +500,7 @@ irc_establish_connection (struct bot_context *ctx,
 
 static int g_signal_pipe[2];            ///< A pipe used to signal... signals
 
-static struct str_vector
+static struct strv
 	g_original_argv,                    ///< Original program arguments
 	g_recovery_env;                     ///< Environment for re-exec recovery
 
@@ -635,6 +645,9 @@ recovery_handler (int signum, siginfo_t *info, void *context)
 			"signal received", signal_name);
 	*g_startup_reason_location = buf;
 
+	// Avoid annoying resource intensive infinite loops by sleeping for a bit
+	(void) sleep (1);
+
 	// TODO: maybe pregenerate the path, see the following for some other ways
 	//   that would be illegal to do from within a signal handler:
 	//     http://stackoverflow.com/a/1024937
@@ -662,8 +675,8 @@ recovery_handler (int signum, siginfo_t *info, void *context)
 static void
 prepare_recovery_environment (void)
 {
-	str_vector_init (&g_recovery_env);
-	str_vector_add_vector (&g_recovery_env, environ);
+	g_recovery_env = strv_make ();
+	strv_append_vector (&g_recovery_env, environ);
 
 	// Prepare a location within the environment where we will put the startup
 	// (or maybe rather restart) reason in case of an irrecoverable error.
@@ -680,7 +693,7 @@ prepare_recovery_environment (void)
 	else
 	{
 		g_startup_reason_location = g_recovery_env.vector + g_recovery_env.len;
-		str_vector_add (&g_recovery_env, "");
+		strv_append (&g_recovery_env, "");
 	}
 }
 
@@ -722,7 +735,7 @@ setup_recovery_handler (struct bot_context *ctx, struct error **e)
 // --- Plugins -----------------------------------------------------------------
 
 /// The name of the special IRC command for interprocess communication
-static const char *plugin_ipc_command = "ZYKLONB";
+static const char *plugin_ipc_command = "XB";
 
 static struct plugin *
 plugin_find_by_pid (struct bot_context *ctx, pid_t pid)
@@ -942,7 +955,7 @@ on_plugin_readable (const struct pollfd *fd, struct plugin *plugin)
 	struct str *buf = &plugin->read_buffer;
 	while (true)
 	{
-		str_ensure_space (buf, 512 + 1);
+		str_reserve (buf, 512 + 1);
 		ssize_t n_read = read (fd->fd, buf->str + buf->len,
 			buf->alloc - buf->len - 1);
 
@@ -1001,101 +1014,145 @@ is_valid_plugin_name (const char *name)
 	return true;
 }
 
-static bool
-plugin_load (struct bot_context *ctx, const char *name, struct error **e)
+static char *
+plugin_resolve_relative_filename (const char *filename)
 {
+	struct strv paths = strv_make ();
+	get_xdg_data_dirs (&paths);
+	strv_append (&paths, PROJECT_DATADIR);
+	char *result = resolve_relative_filename_generic
+		(&paths, PROGRAM_NAME "/plugins/", filename);
+	strv_free (&paths);
+	return result;
+}
+
+static struct plugin *
+plugin_launch (struct bot_context *ctx, const char *name, struct error **e)
+{
+	char *path = NULL;
 	const char *plugin_dir = str_map_find (&ctx->config, "plugin_dir");
-	if (!plugin_dir)
+	if (plugin_dir)
 	{
-		error_set (e, "plugin directory not set");
-		return false;
+		// resolve_relative_filename_generic() won't accept relative paths,
+		// so just keep the old behaviour and expect the file to exist.
+		// We could use resolve_filename() on "plugin_dir" with paths=getcwd().
+		path = xstrdup_printf ("%s/%s", plugin_dir, name);
 	}
-
-	if (!is_valid_plugin_name (name))
+	else if (!(path = plugin_resolve_relative_filename (name)))
 	{
-		error_set (e, "invalid plugin name");
-		return false;
-	}
-
-	if (str_map_find (&ctx->plugins_by_name, name))
-	{
-		error_set (e, "the plugin has already been loaded");
-		return false;
+		error_set (e, "plugin not found");
+		goto fail_0;
 	}
 
 	int stdin_pipe[2];
 	if (pipe (stdin_pipe) == -1)
 	{
-		error_set (e, "%s: %s: %s",
-			"failed to load the plugin", "pipe", strerror (errno));
-		goto fail_1;
+		error_set (e, "%s: %s", "pipe", strerror (errno));
+		goto fail_0;
 	}
 
 	int stdout_pipe[2];
 	if (pipe (stdout_pipe) == -1)
 	{
-		error_set (e, "%s: %s: %s",
-			"failed to load the plugin", "pipe", strerror (errno));
-		goto fail_2;
+		error_set (e, "%s: %s", "pipe", strerror (errno));
+		goto fail_1;
 	}
 
+	struct str work_dir = str_make ();
+	get_xdg_home_dir (&work_dir, "XDG_DATA_HOME", ".local/share");
+	str_append_printf (&work_dir, "/%s", PROGRAM_NAME);
+
+	if (!mkdir_with_parents (work_dir.str, e))
+		goto fail_2;
+
 	set_cloexec (stdin_pipe[1]);
 	set_cloexec (stdout_pipe[0]);
 
 	pid_t pid = fork ();
 	if (pid == -1)
 	{
-		error_set (e, "%s: %s: %s",
-			"failed to load the plugin", "fork", strerror (errno));
-		goto fail_3;
+		error_set (e, "%s: %s", "fork", strerror (errno));
+		goto fail_2;
 	}
 
 	if (pid == 0)
 	{
 		// Redirect the child's stdin and stdout to the pipes
-		hard_assert (dup2 (stdin_pipe[0],  STDIN_FILENO)  != -1);
-		hard_assert (dup2 (stdout_pipe[1], STDOUT_FILENO) != -1);
+		if (dup2 (stdin_pipe[0], STDIN_FILENO) == -1
+		 || dup2 (stdout_pipe[1], STDOUT_FILENO) == -1)
+		{
+			print_error ("%s: %s: %s", "failed to load the plugin",
+				"dup2", strerror (errno));
+			_exit (EXIT_FAILURE);
+		}
+		if (chdir (work_dir.str))
+		{
+			print_error ("%s: %s: %s", "failed to load the plugin",
+				"chdir", strerror (errno));
+			_exit (EXIT_FAILURE);
+		}
 
 		xclose (stdin_pipe[0]);
 		xclose (stdout_pipe[1]);
 
-		struct str pathname;
-		str_init (&pathname);
-		str_append (&pathname, plugin_dir);
-		str_append_c (&pathname, '/');
-		str_append (&pathname, name);
-
 		// Restore some of the signal handling
 		signal (SIGPIPE, SIG_DFL);
 
-		char *const argv[] = { pathname.str, NULL };
+		char *argv[] = { path, NULL };
 		execve (argv[0], argv, environ);
 
 		// We will collect the failure later via SIGCHLD
-		print_error ("%s: %s: %s",
-			"failed to load the plugin", "exec", strerror (errno));
+		print_error ("%s: %s: %s", "failed to load the plugin",
+			"exec", strerror (errno));
 		_exit (EXIT_FAILURE);
 	}
 
+	str_free (&work_dir);
+	free (path);
+
 	xclose (stdin_pipe[0]);
 	xclose (stdout_pipe[1]);
 
-	set_blocking (stdout_pipe[0], false);
-	set_blocking (stdin_pipe[1], false);
-
-	struct plugin *plugin = xmalloc (sizeof *plugin);
-	plugin_init (plugin);
+	struct plugin *plugin = plugin_new ();
 	plugin->ctx = ctx;
 	plugin->pid = pid;
 	plugin->name = xstrdup (name);
 	plugin->read_fd = stdout_pipe[0];
 	plugin->write_fd = stdin_pipe[1];
+	return plugin;
 
-	poller_fd_init (&plugin->read_event, &ctx->poller, plugin->read_fd);
+fail_2:
+	str_free (&work_dir);
+	xclose (stdout_pipe[0]);
+	xclose (stdout_pipe[1]);
+fail_1:
+	xclose (stdin_pipe[0]);
+	xclose (stdin_pipe[1]);
+fail_0:
+	free (path);
+	return NULL;
+}
+
+static bool
+plugin_load (struct bot_context *ctx, const char *name, struct error **e)
+{
+	if (!is_valid_plugin_name (name))
+		return error_set (e, "invalid plugin name");
+	if (str_map_find (&ctx->plugins_by_name, name))
+		return error_set (e, "the plugin has already been loaded");
+
+	struct plugin *plugin;
+	if (!(plugin = plugin_launch (ctx, name, e)))
+		return false;
+
+	set_blocking (plugin->read_fd, false);
+	set_blocking (plugin->write_fd, false);
+
+	plugin->read_event = poller_fd_make (&ctx->poller, plugin->read_fd);
 	plugin->read_event.dispatcher = (poller_fd_fn) on_plugin_readable;
 	plugin->read_event.user_data = plugin;
 
-	poller_fd_init (&plugin->write_event, &ctx->poller, plugin->write_fd);
+	plugin->write_event = poller_fd_make (&ctx->poller, plugin->write_fd);
 	plugin->write_event.dispatcher = (poller_fd_fn) on_plugin_writable;
 	plugin->write_event.user_data = plugin;
 
@@ -1104,15 +1161,6 @@ plugin_load (struct bot_context *ctx, const char *name, struct error **e)
 
 	poller_fd_set (&plugin->read_event, POLLIN);
 	return true;
-
-fail_3:
-	xclose (stdout_pipe[0]);
-	xclose (stdout_pipe[1]);
-fail_2:
-	xclose (stdin_pipe[0]);
-	xclose (stdin_pipe[1]);
-fail_1:
-	return false;
 }
 
 static bool
@@ -1121,10 +1169,7 @@ plugin_unload (struct bot_context *ctx, const char *name, struct error **e)
 	struct plugin *plugin = str_map_find (&ctx->plugins_by_name, name);
 
 	if (!plugin)
-	{
-		error_set (e, "no such plugin is loaded");
-		return false;
-	}
+		return error_set (e, "no such plugin is loaded");
 
 	plugin_zombify (plugin);
 
@@ -1140,10 +1185,8 @@ plugin_load_all_from_config (struct bot_context *ctx)
 	if (!plugin_list)
 		return;
 
-	struct str_vector plugins;
-	str_vector_init (&plugins);
-
-	cstr_split_ignore_empty (plugin_list, ',', &plugins);
+	struct strv plugins = strv_make ();
+	cstr_split (plugin_list, ",", true, &plugins);
 	for (size_t i = 0; i < plugins.len; i++)
 	{
 		char *name = cstr_strip_in_place (plugins.vector[i], " ");
@@ -1156,7 +1199,7 @@ plugin_load_all_from_config (struct bot_context *ctx)
 		}
 	}
 
-	str_vector_free (&plugins);
+	strv_free (&plugins);
 }
 
 // --- Main program ------------------------------------------------------------
@@ -1181,13 +1224,13 @@ parse_bot_command (const char *s, const char *command, const char **following)
 }
 
 static void
-split_bot_command_argument_list (const char *arguments, struct str_vector *out)
+split_bot_command_argument_list (const char *arguments, struct strv *out)
 {
-	cstr_split_ignore_empty (arguments, ',', out);
+	cstr_split (arguments, ",", true, out);
 	for (size_t i = 0; i < out->len; )
 	{
 		if (!*cstr_strip_in_place (out->vector[i], " \t"))
-			str_vector_remove (out, i);
+			strv_remove (out, i);
 		else
 			i++;
 	}
@@ -1223,10 +1266,8 @@ respond_to_user (struct bot_context *ctx, const struct irc_message *msg,
 	strncpy (nick, msg->prefix, sizeof nick - 1);
 	nick[sizeof nick - 1] = '\0';
 
-	struct str text;
 	va_list ap;
-
-	str_init (&text);
+	struct str text = str_make ();
 	va_start (ap, format);
 	str_append_vprintf (&text, format, ap);
 	va_end (ap);
@@ -1287,9 +1328,7 @@ process_plugin_reload (struct bot_context *ctx,
 static char *
 make_status_report (struct bot_context *ctx)
 {
-	struct str report;
-	str_init (&report);
-
+	struct str report = str_make ();
 	const char *reason = getenv (g_startup_reason_str);
 	if (!reason)
 		reason = "launched normally";
@@ -1334,8 +1373,7 @@ process_privmsg (struct bot_context *ctx, const struct irc_message *msg)
 		return;
 
 	const char *following;
-	struct str_vector list;
-	str_vector_init (&list);
+	struct strv list = strv_make ();
 
 	if (parse_bot_command (text, "quote", &following))
 		// This seems to replace tons of random stupid commands
@@ -1375,7 +1413,7 @@ process_privmsg (struct bot_context *ctx, const struct irc_message *msg)
 			process_plugin_unload (ctx, msg, list.vector[i]);
 	}
 
-	str_vector_free (&list);
+	strv_free (&list);
 }
 
 static void
@@ -1444,7 +1482,7 @@ enum irc_read_result
 };
 
 static enum irc_read_result
-irc_fill_read_buffer_ssl (struct bot_context *ctx, struct str *buf)
+irc_fill_read_buffer_tls (struct bot_context *ctx, struct str *buf)
 {
 	int n_read;
 start:
@@ -1552,13 +1590,11 @@ on_irc_disconnected (struct bot_context *ctx)
 		ctx->ssl_ctx = NULL;
 	}
 
+	poller_fd_reset (&ctx->irc_event);
 	xclose (ctx->irc_fd);
 	ctx->irc_fd = -1;
 	ctx->irc_registered = false;
 
-	ctx->irc_event.closed = true;
-	poller_fd_reset (&ctx->irc_event);
-
 	// TODO: inform plugins about the disconnect event
 
 	// All of our timers have lost their meaning now
@@ -1608,12 +1644,12 @@ on_irc_readable (const struct pollfd *fd, struct bot_context *ctx)
 	struct str *buf = &ctx->read_buffer;
 	enum irc_read_result (*fill_buffer)(struct bot_context *, struct str *)
 		= ctx->ssl
-		? irc_fill_read_buffer_ssl
+		? irc_fill_read_buffer_tls
 		: irc_fill_read_buffer;
 	bool disconnected = false;
 	while (true)
 	{
-		str_ensure_space (buf, 512);
+		str_reserve (buf, 512);
 		switch (fill_buffer (ctx, buf))
 		{
 		case IRC_READ_AGAIN:
@@ -1662,8 +1698,10 @@ struct irc_socks_data
 };
 
 static void
-irc_on_socks_connected (void *user_data, int socket)
+irc_on_socks_connected (void *user_data, int socket, const char *hostname)
 {
+	(void) hostname;
+
 	struct irc_socks_data *data = user_data;
 	data->ctx->irc_fd = socket;
 	data->succeeded = true;
@@ -1721,6 +1759,8 @@ irc_establish_connection_socks (struct bot_context *ctx,
 			str_map_find (&ctx->config, "socks_password"));
 		while (data.polling)
 			poller_run (poller);
+		if (!data.succeeded)
+			error_set (e, "connection failed");
 	}
 
 	socks_connector_free (connector);
@@ -1749,13 +1789,10 @@ irc_connect (struct bot_context *ctx, struct error **e)
 	// TODO: again, get rid of `struct error' in here.  The question is: how
 	//   do we tell our caller that he should not try to reconnect?
 	if (!irc_host)
-	{
-		error_set (e, "no hostname specified in configuration");
-		return false;
-	}
+		return error_set (e, "no hostname specified in configuration");
 
-	bool use_ssl;
-	if (!irc_get_boolean_from_config (ctx, "ssl", &use_ssl, e))
+	bool use_tls;
+	if (!irc_get_boolean_from_config (ctx, "tls", &use_tls, e))
 		return false;
 
 	bool connected = socks_host
@@ -1765,7 +1802,7 @@ irc_connect (struct bot_context *ctx, struct error **e)
 	if (!connected)
 		return false;
 
-	if (use_ssl && !irc_initialize_ssl (ctx, e))
+	if (use_tls && !irc_initialize_tls (ctx, e))
 	{
 		xclose (ctx->irc_fd);
 		ctx->irc_fd = -1;
@@ -1773,7 +1810,7 @@ irc_connect (struct bot_context *ctx, struct error **e)
 	}
 	print_status ("connection established");
 
-	poller_fd_init (&ctx->irc_event, &ctx->poller, ctx->irc_fd);
+	ctx->irc_event = poller_fd_make (&ctx->poller, ctx->irc_fd);
 	ctx->irc_event.dispatcher = (poller_fd_fn) on_irc_readable;
 	ctx->irc_event.user_data = ctx;
 
@@ -1798,9 +1835,8 @@ parse_config (struct bot_context *ctx, struct error **e)
 	hard_assert (delay_str != NULL);  // We have a default value for this
 	if (!xstrtoul (&ctx->reconnect_delay, delay_str, 10))
 	{
-		error_set (e, "invalid configuration value for `%s'",
-			"reconnect_delay");
-		return false;
+		return error_set (e,
+			"invalid configuration value for `%s'", "reconnect_delay");
 	}
 
 	hard_assert (!ctx->admin_re);
@@ -1825,7 +1861,7 @@ on_plugin_death (struct plugin *plugin, int status)
 	struct bot_context *ctx = plugin->ctx;
 
 	// TODO: callbacks on children death, so that we may tell the user
-	//       "plugin `name' died like a dirty jewish pig"; use `status'
+	//       "plugin `name' died"; use `status'
 	if (!plugin->is_zombie && WIFSIGNALED (status))
 	{
 		const char *notes = "";
@@ -1855,8 +1891,7 @@ on_plugin_death (struct plugin *plugin, int status)
 	plugin->read_fd = -1;
 
 	LIST_UNLINK (ctx->plugins, plugin);
-	plugin_free (plugin);
-	free (plugin);
+	plugin_destroy (plugin);
 
 	// Living child processes block us from quitting
 	try_finish_quit (ctx);
@@ -1934,8 +1969,8 @@ on_signal_pipe_readable (const struct pollfd *fd, struct bot_context *ctx)
 int
 main (int argc, char *argv[])
 {
-	str_vector_init (&g_original_argv);
-	str_vector_add_vector (&g_original_argv, argv);
+	g_original_argv = strv_make ();
+	strv_append_vector (&g_original_argv, argv);
 
 	static const struct opt opts[] =
 	{
@@ -1948,8 +1983,8 @@ main (int argc, char *argv[])
 		{ 0, NULL, NULL, 0, NULL }
 	};
 
-	struct opt_handler oh;
-	opt_handler_init (&oh, argc, argv, opts, NULL, "Experimental IRC bot.");
+	struct opt_handler oh =
+		opt_handler_make (argc, argv, opts, NULL, "Modular IRC bot.");
 
 	int c;
 	while ((c = opt_handler_get (&oh)) != -1)
@@ -1965,7 +2000,7 @@ main (int argc, char *argv[])
 		printf (PROGRAM_NAME " " PROGRAM_VERSION "\n");
 		exit (EXIT_SUCCESS);
 	case 'w':
-		call_write_default_config (optarg, g_config_table);
+		call_simple_config_write_default (optarg, g_config_table);
 		exit (EXIT_SUCCESS);
 	default:
 		print_error ("wrong options");
@@ -1977,18 +2012,13 @@ main (int argc, char *argv[])
 
 	print_status (PROGRAM_NAME " " PROGRAM_VERSION " starting");
 	setup_signal_handlers ();
-
-	SSL_library_init ();
-	atexit (EVP_cleanup);
-	SSL_load_error_strings ();
-	// XXX: ERR_load_BIO_strings()?  Anything else?
-	atexit (ERR_free_strings);
+	init_openssl ();
 
 	struct bot_context ctx;
 	bot_context_init (&ctx);
 
 	struct error *e = NULL;
-	if (!read_config_file (&ctx.config, &e)
+	if (!simple_config_update_from_file (&ctx.config, &e)
 	 || !setup_recovery_handler (&ctx, &e))
 	{
 		print_error ("%s", e->message);
@@ -1996,11 +2026,17 @@ main (int argc, char *argv[])
 		exit (EXIT_FAILURE);
 	}
 
-	poller_fd_init (&ctx.signal_event, &ctx.poller, g_signal_pipe[0]);
+	ctx.signal_event = poller_fd_make (&ctx.poller, g_signal_pipe[0]);
 	ctx.signal_event.dispatcher = (poller_fd_fn) on_signal_pipe_readable;
 	ctx.signal_event.user_data = &ctx;
 	poller_fd_set (&ctx.signal_event, POLLIN);
 
+#if OpenBSD >= 201605
+	// cpath is for creating the plugin home directory
+	if (pledge ("stdio rpath cpath inet proc exec", NULL))
+		exit_fatal ("%s: %s", "pledge", strerror (errno));
+#endif
+
 	plugin_load_all_from_config (&ctx);
 	if (!parse_config (&ctx, &e)
 	 || !irc_connect (&ctx, &e))
@@ -2022,7 +2058,7 @@ main (int argc, char *argv[])
 		poller_run (&ctx.poller);
 
 	bot_context_free (&ctx);
-	str_vector_free (&g_original_argv);
+	strv_free (&g_original_argv);
 	return EXIT_SUCCESS;
 }
 

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_i8(w, %s);\n"
+	CodegenDeserialize[name] = \
+		"\t{\n" \
+		"\t\tint8_t v = 0;\n" \
+		"\t\tif (!msg_unpacker_i8(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]
+}

xC-gen-proto-go.awk

@@ -0,0 +1,519 @@
+# 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)
+
+	CodegenAppendJSON[shortname] = \
+		"\tb = strconv.AppendInt(b, int64(%s), 10)\n"
+	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) {
+	# Both []byte and []uint8 luckily marshal as base64-encoded JSON strings,
+	# so there's no need to rename the type as an exception.
+	shortname = "u" size
+	gotype = "uint" size
+	define_internal(shortname, gotype)
+
+	CodegenAppendJSON[shortname] = \
+		"\tb = strconv.AppendUint(b, uint64(%s), 10)\n"
+	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")
+	CodegenAppendJSON["bool"] = \
+		"\tb = strconv.AppendBool(b, %s)\n"
+	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/base64`"
+	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.MaxInt8 || n < math.MinInt8 {"
+	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 " int8"
+	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 ""
+
+	CodegenIsMarshaler[name] = 1
+	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 []byte(`\"` + v.String() + `\"`), nil"
+	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 = append(data, uint8(%s))\n"
+	CodegenDeserialize[name] = \
+		"\tif len(data) >= 1 {\n" \
+		"\t\t%s, data = " gotype "(data[0]), data[1:]\n" \
+		"\t} else {\n" \
+		"\t\treturn nil, false\n" \
+		"\t}\n"
+
+	CodegenGoType[name] = gotype
+	for (i in cg)
+		delete cg[i]
+}
+
+function codegen_marshal(type, f,    marshal) {
+	if (CodegenAppendJSON[type])
+		return sprintf(CodegenAppendJSON[type], f)
+
+	# Complex types are json.Marshalers, there's no need to json.Marshal(&f).
+	if (CodegenIsMarshaler[type])
+		marshal = f ".MarshalJSON()"
+	else
+		marshal = "json.Marshal(" f ")"
+
+	return \
+		"\tif j, err := " marshal "; err != nil {\n" \
+		"\t\treturn nil, err\n" \
+		"\t} else {\n" \
+		"\t\tb = append(b, j...)\n" \
+		"\t}\n"
+}
+
+function codegen_struct_field_marshal(d, cg,    camel, f, marshal) {
+	camel = snaketocamel(d["name"])
+	f = "s." camel
+	if (!d["isarray"]) {
+		append(cg, "marshal",
+			"\tb = append(b, `,\"" decapitalize(camel) "\":`...)\n" \
+			codegen_marshal(d["type"], f))
+		return
+	}
+
+	# Note that we do not produce `null` for nil slices, unlike encoding/json.
+	# And arrays never get deserialized as such.
+	if (d["type"] == "u8") {
+		append(cg, "marshal",
+			"\tb = append(b, `,\"" decapitalize(camel) "\":\"`...)\n" \
+			"\tb = append(b, base64.StdEncoding.EncodeToString(" f ")...)\n" \
+			"\tb = append(b, '\"')\n")
+		return
+	}
+
+	append(cg, "marshal",
+		"\tb = append(b, `,\"" decapitalize(camel) "\":[`...)\n" \
+		"\tfor i := 0; i < len(" f "); i++ {\n" \
+		"\t\tif i > 0 {\n" \
+		"\t\t\tb = append(b, ',')\n" \
+		"\t\t}\n" \
+		indent(codegen_marshal(d["type"], f "[i]")) \
+		"\t}\n" \
+		"\tb = append(b, ']')\n")
+}
+
+function codegen_struct_field(d, cg,    camel, f, serialize, deserialize) {
+	codegen_struct_field_marshal(d, cg)
+
+	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) {
+	codegen_struct_field_marshal(d, cg)
+
+	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["marshal"]) {
+		CodegenIsMarshaler[name] = 1
+		print "func (s *" gotype ") MarshalJSON() ([]byte, error) {"
+		print "\tb := []byte{}"
+		print cg["marshal"] "\tb[0] = '{'"
+		print "\treturn append(b, '}'), nil"
+		print "}"
+		print ""
+	}
+
+	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 ""
+
+	# This cannot be a pointer method, it wouldn't work recursively.
+	CodegenIsMarshaler[name] = 1
+	print "func (u " gotype ") MarshalJSON() ([]byte, error) {"
+	print "\treturn u.Interface.(json.Marshaler).MarshalJSON()"
+	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]
+}

xC-gen-proto-js.awk

@@ -0,0 +1,223 @@
+# xC-gen-proto-js.awk: Javascript backend for xC-gen-proto.awk.
+#
+# Copyright (c) 2022, Přemysl Eric Janouch <p@janouch.name>
+# SPDX-License-Identifier: 0BSD
+#
+# This backend is currently for decoding the binary format only.
+# (JSON is way too expensive to process and transfer.)
+#
+# Import the resulting script as a Javascript module.
+
+function define_internal(name) {
+	Types[name] = "internal"
+}
+
+function define_sint(size,    shortname) {
+	shortname = "i" size
+	define_internal(shortname)
+	CodegenDeserialize[shortname] = "\t%s = r." shortname "()\n"
+
+	print ""
+	print "\t" shortname "() {"
+	if (size == "64") {
+		# XXX: 2^53 - 1 must be enough for anyone.  BigInts are a PITA.
+		print "\t\tconst " shortname \
+			" = Number(this.getBigInt" size "(this.offset))"
+	} else {
+		print "\t\tconst " shortname " = this.getInt" size "(this.offset)"
+	}
+	print "\t\tthis.offset += " (size / 8)
+	print "\t\treturn " shortname
+	print "\t}"
+}
+
+function define_uint(size,    shortname) {
+	shortname = "u" size
+	define_internal(shortname)
+	CodegenDeserialize[shortname] = "\t%s = r." shortname "()\n"
+
+	print ""
+	print "\t" shortname "() {"
+	if (size == "64") {
+		# XXX: 2^53 - 1 must be enough for anyone.  BigInts are a PITA.
+		print "\t\tconst " shortname \
+			" = Number(this.getBigUint" size "(this.offset))"
+	} else {
+		print "\t\tconst " shortname " = this.getUint" size "(this.offset)"
+	}
+	print "\t\tthis.offset += " (size / 8)
+	print "\t\treturn " shortname
+	print "\t}"
+}
+
+function codegen_begin() {
+	print "export class Reader extends DataView {"
+	print "\tconstructor() {"
+	print "\t\tsuper(...arguments)"
+	print "\t\tthis.offset = 0"
+	print "\t\tthis.decoder = new TextDecoder('utf-8', {fatal: true})"
+	print "\t}"
+	print ""
+	print "\tget empty() {"
+	print "\t\treturn this.byteLength <= this.offset"
+	print "\t}"
+	print ""
+	print "\trequire(len) {"
+	print "\t\tif (this.byteLength - this.offset < len)"
+	print "\t\t\tthrow `Premature end of data`"
+	print "\t\treturn this.byteOffset + this.offset"
+	print "\t}"
+
+	define_internal("string")
+	CodegenDeserialize["string"] = "\t%s = r.string()\n"
+
+	print ""
+	print "\tstring() {"
+	print "\t\tconst len = this.getUint32(this.offset)"
+	print "\t\tthis.offset += 4"
+	print "\t\tconst array = new Uint8Array("
+	print "\t\t\tthis.buffer, this.require(len), len)"
+	print "\t\tthis.offset += len"
+	print "\t\treturn this.decoder.decode(array)"
+	print "\t}"
+
+	define_internal("bool")
+	CodegenDeserialize["bool"] = "\t%s = r.bool()\n"
+
+	print ""
+	print "\tbool() {"
+	print "\t\tconst u8 = this.getUint8(this.offset)"
+	print "\t\tthis.offset += 1"
+	print "\t\treturn u8 != 0"
+	print "\t}"
+
+	define_sint("8")
+	define_sint("16")
+	define_sint("32")
+	define_sint("64")
+	define_uint("8")
+	define_uint("16")
+	define_uint("32")
+	define_uint("64")
+
+	print "}"
+}
+
+function codegen_constant(name, value) {
+	print ""
+	print "export const " decapitalize(snaketocamel(name)) " = " value
+}
+
+function codegen_enum_value(name, subname, value, cg) {
+	append(cg, "fields", "\t" snaketocamel(subname) ": " value ",\n")
+}
+
+function codegen_enum(name, cg) {
+	print ""
+	print "export const " name " = Object.freeze({"
+	print cg["fields"] "})"
+
+	CodegenDeserialize[name] = "\t%s = r.i8()\n"
+	for (i in cg)
+		delete cg[i]
+}
+
+function codegen_struct_field(d, cg,    camel, f, deserialize) {
+	camel = decapitalize(snaketocamel(d["name"]))
+	f = "s." camel
+	append(cg, "fields", "\t" camel "\n")
+
+	deserialize = CodegenDeserialize[d["type"]]
+	if (!d["isarray"]) {
+		append(cg, "deserialize", sprintf(deserialize, f))
+		return
+	}
+
+	append(cg, "deserialize",
+		"\t{\n" \
+		indent(sprintf(CodegenDeserialize["u32"], "const len")))
+	if (d["type"] == "u8") {
+		append(cg, "deserialize",
+			"\t\t" f " = new Uint8Array(\n" \
+			"\t\t\tr.buffer, r.require(len), len)\n" \
+			"\t\tr.offset += len\n" \
+			"\t}\n")
+		return
+	}
+	if (d["type"] == "i8") {
+		append(cg, "deserialize",
+			"\t\t" f " = new Int8Array(\n" \
+			"\t\t\tr.buffer, r.require(len), len)\n" \
+			"\t\tr.offset += len\n" \
+			"\t}\n")
+		return
+	}
+
+	append(cg, "deserialize",
+		"\t\t" f " = new Array(len)\n" \
+		"\t}\n" \
+		"\tfor (let i = 0; i < " f ".length; i++)\n" \
+		indent(sprintf(deserialize, f "[i]")))
+}
+
+function codegen_struct_tag(d, cg) {
+	append(cg, "fields", "\t" decapitalize(snaketocamel(d["name"])) "\n")
+	# Do not deserialize here, that is already done by the containing union.
+}
+
+function codegen_struct(name, cg) {
+	print ""
+	print "export class " name " {"
+	print cg["fields"] cg["methods"]
+	print "\tstatic deserialize(r) {"
+	print "\t\tconst s = new " name "()"
+	print indent(cg["deserialize"]) "\t\treturn s"
+	print "\t}"
+	print "}"
+
+	CodegenDeserialize[name] = "\t%s = " name ".deserialize(r)\n"
+	for (i in cg)
+		delete cg[i]
+}
+
+function codegen_union_tag(d, cg) {
+	cg["tagtype"] = d["type"]
+	cg["tagname"] = d["name"]
+}
+
+function codegen_union_struct(name, casename, cg, scg,     structname) {
+	append(scg, "methods",
+		"\n" \
+		"\tconstructor() {\n" \
+		"\t\tthis." decapitalize(snaketocamel(cg["tagname"])) \
+			" = " cg["tagtype"] "." snaketocamel(casename) "\n" \
+		"\t}\n")
+
+	# And thus not all generated structs are present in Types.
+	structname = name snaketocamel(casename)
+	codegen_struct(structname, scg)
+
+	append(cg, "deserialize",
+		"\tcase " cg["tagtype"] "." snaketocamel(casename) ":\n" \
+		"\t{\n" \
+		indent(sprintf(CodegenDeserialize[structname], "const s")) \
+		"\t\treturn s\n" \
+		"\t}\n")
+}
+
+function codegen_union(name, cg,    tagvar) {
+	tagvar = decapitalize(snaketocamel(cg["tagname"]))
+
+	print ""
+	print "export function deserialize" name "(r) {"
+	print sprintf(CodegenDeserialize[cg["tagtype"]], "const " tagvar) \
+		"\tswitch (" tagvar ") {"
+	print cg["deserialize"] "\tdefault:"
+	print "\t\tthrow `Unknown " cg["tagtype"] " (${tagvar})`"
+	print "\t}"
+	print "}"
+
+	CodegenDeserialize[name] = "\t%s = deserialize" name "(r)\n"
+	for (i in cg)
+		delete cg[i]
+}

xC-gen-proto.awk

@@ -0,0 +1,305 @@
+# 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.
+# Backends tend to be 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 i8.
+# Any struct or union field may be a variable-length array.
+#
+# Message framing is done externally, but also happens to prefix u32 lengths,
+# unless this role is already filled by, e.g., WebSocket.
+#
+# Usage: env LC_ALL=C awk -f xC-gen-proto.awk -f xC-gen-proto-{c,go,js}.awk \
+#  xC-proto > xC-proto.{c,go,js} | {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")
+		if (value < -128 || value > 127)
+			fatal("enumeration value out of range")
+		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(";"))
+	}
+}

xC-proto

@@ -0,0 +1,206 @@
+// Backwards-compatible protocol version.
+const VERSION = 1;
+
+// From the frontend to the relay.
+struct CommandMessage {
+	// The command sequence number will be repeated in responses
+	// in the respective fields.
+	u32 command_seq;
+	union CommandData switch (enum Command {
+		HELLO,
+		ACTIVE,
+		BUFFER_ACTIVATE,
+		BUFFER_INPUT,
+		BUFFER_TOGGLE_UNIMPORTANT,
+		PING_RESPONSE,
+		PING,
+		BUFFER_COMPLETE,
+		BUFFER_LOG,
+	} command) {
+	// If the version check succeeds, the client will receive
+	// an initial stream of SERVER_UPDATE, BUFFER_UPDATE, BUFFER_STATS,
+	// BUFFER_LINE, and finally a BUFFER_ACTIVATE message.
+	case HELLO:
+		u32 version;
+	case ACTIVE:
+		void;
+	case BUFFER_ACTIVATE:
+		string buffer_name;
+	case BUFFER_INPUT:
+		string buffer_name;
+		string text;
+	// XXX: Perhaps this should rather be handled through a /buffer command.
+	case BUFFER_TOGGLE_UNIMPORTANT:
+		string buffer_name;
+	case PING_RESPONSE:
+		u32 event_seq;
+
+	// Only these commands may produce Event.RESPONSE, as below,
+	// but any command may produce an error.
+	case PING:
+		void;
+	case BUFFER_COMPLETE:
+		string buffer_name;
+		string text;
+		u32 position;
+	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_LINE,
+		BUFFER_UPDATE,
+		BUFFER_STATS,
+		BUFFER_RENAME,
+		BUFFER_REMOVE,
+		BUFFER_ACTIVATE,
+		BUFFER_CLEAR,
+		SERVER_UPDATE,
+		SERVER_RENAME,
+		SERVER_REMOVE,
+		ERROR,
+		RESPONSE,
+	} event) {
+	case PING:
+		void;
+
+	case BUFFER_LINE:
+		string buffer_name;
+		// Whether the line should also be displayed in the active buffer.
+		bool leak_to_active;
+		bool is_unimportant;
+		bool is_highlight;
+		enum Rendition {
+			BARE,
+			INDENT,
+			STATUS,
+			ERROR,
+			JOIN,
+			PART,
+			ACTION,
+		} rendition;
+		// Unix timestamp in milliseconds.
+		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_UPDATE:
+		string buffer_name;
+		bool hide_unimportant;
+		union BufferContext switch (enum BufferKind {
+			GLOBAL,
+			SERVER,
+			CHANNEL,
+			PRIVATE_MESSAGE,
+		} kind) {
+		case GLOBAL:
+			void;
+		case SERVER:
+			string server_name;
+		case CHANNEL:
+			string server_name;
+			ItemData topic<>;
+			// This includes parameters, separated by spaces.
+			string modes;
+		case PRIVATE_MESSAGE:
+			string server_name;
+		} context;
+	case BUFFER_STATS:
+		string buffer_name;
+		// These are cumulative, even for lines flushed out from buffers.
+		// Updates to these values aren't broadcasted, thus handle:
+		//  - BUFFER_LINE by bumping/setting them as appropriate,
+		//  - BUFFER_ACTIVATE by clearing them for the previous buffer
+		//    (this way, they can be used to mark unread messages).
+		u32 new_messages;
+		u32 new_unimportant_messages;
+		bool highlighted;
+	case BUFFER_RENAME:
+		string buffer_name;
+		string new;
+	case BUFFER_REMOVE:
+		string buffer_name;
+	case BUFFER_ACTIVATE:
+		string buffer_name;
+	case BUFFER_CLEAR:
+		string buffer_name;
+
+	case SERVER_UPDATE:
+		string server_name;
+		union ServerData switch (enum ServerState {
+			DISCONNECTED,
+			CONNECTING,
+			CONNECTED,
+			REGISTERED,
+			DISCONNECTING,
+		} state) {
+		case DISCONNECTED:
+		case CONNECTING:
+		case CONNECTED:
+			void;
+		case REGISTERED:
+			string user;
+			string user_modes;
+		// Theoretically, we could also send user information in this state,
+		// but we'd have to duplicate both fields.
+		case DISCONNECTING:
+			void;
+		} data;
+	case SERVER_RENAME:
+		// Buffers aren't sent updates for in this circumstance,
+		// as that wouldn't be sufficiently atomic anyway.
+		string server_name;
+		string new;
+	case SERVER_REMOVE:
+		string server_name;
+
+	// Restriction: command_seq strictly follows the sequence received
+	// by the relay, across both of these replies.
+	case ERROR:
+		u32 command_seq;
+		string error;
+	case RESPONSE:
+		u32 command_seq;
+		union ResponseData switch (Command command) {
+		case PING:
+			void;
+		case BUFFER_COMPLETE:
+			u32 start;
+			string completions<>;
+		case BUFFER_LOG:
+			// UTF-8, but not guaranteed.
+			u8 log<>;
+		} data;
+	} data;
+};

xC.adoc

@@ -0,0 +1,127 @@
+xC(1)
+=====
+:doctype: manpage
+:manmanual: xK Manual
+:mansource: xK {release-version}
+
+Name
+----
+xC - terminal-based IRC client
+
+Synopsis
+--------
+*xC* [_OPTION_]...
+
+Description
+-----------
+*xC* is a scriptable IRC client for the command line.  On the first run it will
+welcome you with an introductory message.  Should you ever get lost, use the
+*/help* command to obtain more information on commands or options.
+
+Options
+-------
+*-f*, *--format*::
+	Format IRC text from the standard input, converting colour sequences and
+	other formatting marks to ANSI codes retrieved from the *terminfo*(5)
+	database:
++
+....
+printf '\x02bold\x02\n' | xC -f
+....
++
+This feature may be used to preview server MOTD files.
+
+*-h*, *--help*::
+	Display a help message and exit.
+
+*-V*, *--version*::
+	Output version information and exit.
+
+Key bindings
+------------
+Most key bindings are inherited from the frontend in use, which is either GNU
+Readline or BSD editline.  A few of them, however, are special to the IRC client
+or assume a different function.  This is a list of all local overrides and
+their respective function names:
+
+*M-p*::
+	Go up in history for this buffer (normally mapped to *C-p*).
+*M-n*::
+	Go down in history for this buffer (normally mapped to *C-n*).
+*C-p*, *F5*: *previous-buffer*::
+	Switch to the previous buffer in order.
+*C-n*, *F6*: *next-buffer*::
+	Switch to the next buffer in order.
+*M-TAB*: *switch-buffer*::
+	Switch to the last buffer, i.e., the one you were in before.
+*M-0*, *M-1*, ..., *M-9*: *goto-buffer*::
+	Go to the N-th buffer (normally sets a repeat counter).
+	Since there is no buffer number zero, *M-0* goes to the tenth one.
+*M-!*: *goto-highlight*::
+	Go to the first following buffer with an unseen highlight.
+*M-a*: *goto-activity*::
+	Go to the first following buffer with unseen activity.
+*PageUp*: *display-backlog*::
+	Show the in-memory backlog for this buffer using *general.pager*,
+	which is almost certainly the *less*(1) program.
+*M-h*: *display-full-log*::
+	Show the log file for this buffer using *general.pager*.
+*M-H*: *toggle-unimportant*::
+	Hide all join, part and quit messages, as well as all channel mode changes
+	that only relate to user channel modes.  Intended to reduce noise in
+	channels with lots of people.
+*M-e*: *edit-input*::
+	Run an editor on the command line, making it easy to edit multiline
+	messages.  Remember to save the file before exit.
+*M-m*: *insert-attribute*::
+	The next key will be interpreted as a formatting mark to insert:
+	*c* for colours (optionally followed by numbers for the foreground
+	and background), *i* for italics, *b* for bold text, *u* for underlined,
+	*s* for struck-through, *m* for monospace, *v* for inverse text,
+	and *o* resets all formatting.
+*C-l*: *redraw-screen*::
+	Should there be any issues with the display, this will clear the terminal
+	screen and redraw all information.
+
+Additionally, *C-w* and *C-u* in editline behave the same as they would in
+Readline or the "vi" command mode, even though the "emacs" mode is enabled
+by default.
+
+Bindings can be customized in your _.inputrc_ or _.editrc_ file.  Both libraries
+support conditional execution based on the program name.  Beware that it is easy
+to make breaking changes.
+
+Environment
+-----------
+*VISUAL*, *EDITOR*::
+	The editor program to be launched by the *edit-input* function.
+	If neither variable is set, it defaults to *vi*(1).
+
+Files
+-----
+*xC* follows the XDG Base Directory Specification.
+
+_~/.config/xC/xC.conf_::
+	The program's configuration file.  Preferrably use internal facilities, such
+	as the */set* command, to make changes in it.
+
+_~/.local/share/xC/logs/_::
+	When enabled by *general.logging*, log files are stored here.
+
+_~/.local/share/xC/plugins/_::
+_/usr/local/share/xC/plugins/_::
+_/usr/share/xC/plugins/_::
+	Plugins are searched for in these directories, in order.
+
+Bugs
+----
+The editline (libedit) frontend may exhibit some unexpected behaviour.
+
+Reporting bugs
+--------------
+Use https://git.janouch.name/p/xK to report bugs, request features,
+or submit pull requests.
+
+See also
+--------
+*less*(1), *readline*(3) or *editline*(7)

xD-gen-replies.awk

@@ -0,0 +1,29 @@
+#!/usr/bin/awk -f
+BEGIN {
+	# The message catalog is a by-product
+	msg = "xD.msg"
+	print "$quote \"" > msg;
+	print "$set 1" > msg;
+}
+
+/^[0-9]+ *IRC_(ERR|RPL)_[A-Z]+ *".*"$/ {
+	match($0, /".*"/);
+	ids[$1] = $2;
+	texts[$2] = substr($0, RSTART, RLENGTH);
+	print $1 " " texts[$2] > msg
+}
+
+END {
+	printf("enum\n{")
+	for (i in ids) {
+		if (seen_first)
+			printf(",")
+		seen_first = 1
+		printf("\n\t%s = %s", ids[i], i)
+	}
+	print "\n};\n"
+	print "static const char *g_default_replies[] =\n{"
+	for (i in ids)
+		print "\t[" ids[i] "] = " texts[ids[i]] ","
+	print "};"
+}

xD-replies

@@ -85,3 +85,9 @@
 482 IRC_ERR_CHANOPRIVSNEEDED "%s :You're not channel operator"
 501 IRC_ERR_UMODEUNKNOWNFLAG ":Unknown MODE flag"
 502 IRC_ERR_USERSDONTMATCH ":Cannot change mode for other users"
+902 IRC_ERR_NICKLOCKED ":You must use a nick assigned to you"
+903 IRC_RPL_SASLSUCCESS ":SASL authentication successful"
+904 IRC_ERR_SASLFAIL ":SASL authentication failed"
+905 IRC_ERR_SASLTOOLONG ":SASL message too long"
+906 IRC_ERR_SASLABORTED ":SASL authentication aborted"
+907 IRC_ERR_SASLALREADY ":You have already authenticated using SASL"

xD.adoc

@@ -0,0 +1,53 @@
+xD(1)
+=====
+:doctype: manpage
+:manmanual: xK Manual
+:mansource: xK {release-version}
+
+Name
+----
+xD - IRC daemon
+
+Synopsis
+--------
+*xD* [_OPTION_]...
+
+Description
+-----------
+*xD* is a basic IRC daemon for single-server networks, suitable for testing
+and private use.  When run without a configuration file, it will start listening
+on the standard port 6667 and the "any" address.
+
+Options
+-------
+*-d*, *--debug*::
+	Do not daemonize, print more information on the standard error stream
+	to help debug various issues.
+
+*-h*, *--help*::
+	Display a help message and exit.
+
+*-V*, *--version*::
+	Output version information and exit.
+
+*--write-default-cfg*[**=**__PATH__]::
+	Write a configuration file with defaults, show its path and exit.
++
+The file will be appropriately commented.
++
+When no _PATH_ is specified, it will be created in the user's home directory,
+contrary to what you might expect from a server.
+
+Files
+-----
+*xD* follows the XDG Base Directory Specification.
+
+_~/.config/xD/xD.conf_::
+_/etc/xdg/xD/xD.conf_::
+	The daemon's configuration file.  Use the *--write-default-cfg* option
+	to create a new one for editing.
+
+Reporting bugs
+--------------
+Use https://git.janouch.name/p/xK to report bugs, request features,
+or submit pull requests.

xF.c

@@ -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;
+}

xF.svg

@@ -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>

xP/.gitignore

@@ -0,0 +1,4 @@
+/xP
+/proto.go
+/public/proto.js
+/public/mithril.js

xP/Makefile

@@ -0,0 +1,18 @@
+.POSIX:
+.SUFFIXES:
+
+outputs = xP proto.go public/proto.js public/mithril.js
+all: $(outputs) public/ircfmt.woff2
+
+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/proto.js: ../xC-gen-proto.awk ../xC-gen-proto-js.awk ../xC-proto
+	awk -f ../xC-gen-proto.awk -f ../xC-gen-proto-js.awk ../xC-proto > $@
+public/ircfmt.woff2: gen-ircfmt.awk
+	awk -v Output=$@ -f gen-ircfmt.awk
+public/mithril.js:
+	curl -Lo $@ https://unpkg.com/mithril/mithril.js
+clean:
+	rm -f $(outputs)

xP/gen-ircfmt.awk

@@ -0,0 +1,89 @@
+# gen-ircfmt.awk: generate a supplementary font for IRC formatting characters
+#
+# Copyright (c) 2022, Přemysl Eric Janouch <p@janouch.name>
+# SPDX-License-Identifier: 0BSD
+#
+# Usage: awk -v Output=static/ircfmt.woff2 -f gen-ircfmt.awk
+# Clean up SVG byproducts yourself.
+
+BEGIN {
+	if (!Output) {
+		print "Error: you must specify the output filename"
+		exit 1
+	}
+}
+
+function glyph(name, code, path,    filename, actions, cmd) {
+	filename = Output "." name ".svg"
+
+	# Inkscape still does a terrible job at the stroke-to-path conversion.
+	actions = \
+		"select-by-id:group;" \
+		"selection-ungroup;" \
+		"select-clear;" \
+		"select-by-id:path;" \
+		"object-stroke-to-path;" \
+		"select-by-id:clip;" \
+		"path-intersection;" \
+		"select-all;" \
+		"path-combine;" \
+		"export-overwrite;" \
+		"export-filename:" filename ";" \
+		"export-do"
+
+	# These dimensions fit FontForge defaults, and happen to work well.
+	cmd = "inkscape --pipe --actions='" actions "'"
+	print "<?xml version='1.0' encoding='UTF-8' standalone='no'?>\n" \
+		"<svg version='1.1' xmlns='http://www.w3.org/2000/svg'\n" \
+		" width='1000' height='1000' viewBox='0 0 1000 1000'>\n" \
+		"  <rect x='0' y='0' width='1000' height='1000' />\n" \
+		"  <g id='group' transform='translate(200 200) scale(60, 60)'>\n" \
+		"    <rect id='clip' x='0' y='0' width='10' height='10' />\n" \
+		"    <path id='path' stroke-width='2' fill='none' stroke='#fff'\n" \
+		"     d='" path "' />\n" \
+		"  </g>\n" \
+		"</svg>\n" | cmd
+	close(cmd)
+
+	print "Select(0u" code ")\n" \
+		"Import('" filename "')" | FontForge
+}
+
+BEGIN {
+	FontForge = "fontforge -lang=ff -"
+	print "New()" | FontForge
+
+	# Designed a 10x10 raster, going for maximum simplicity.
+	glyph("B", "02", "m 6,5 c 0,0 2,0 2,2 0,2 -2,2 -2,2 h -3 v -8 h 2.5 c 0,0 2,0 2,2 0,2 -2,2 -2,2 h -2 Z")
+	glyph("C", "03", "m 7.6,7 A 3,4 0 0 1 4.25,8.875 3,4 0 0 1 2,5 3,4 0 0 1 4.25,1.125 3,4 0 0 1 7.6,3")
+	glyph("I", "1D", "m 3,9 h 4 m 0,-8 h -4 m 2,-1 v 10")
+	glyph("M", "11", "m 2,10 v -10 l 3,6 3,-6 v 10")
+	glyph("O", "0F", "m 1,9 l 8,-8 M 2,5 a 3,3 0 1 0 6,0 3,3 0 1 0 -6,0 z")
+	#glyph("R", "0F", "m 3,10 v -9 h 2 c 0,0 2.5,0 2.5,2.5 0,2.5 -2.5,2.5 -2.5,2.5 h -2 2.5 l 2.5,4.5")
+	glyph("S", "1E", "m 7.5,3 c 0,-1 -1,-2 -2.5,-2 -1.5,0 -2.5,1 -2.5,2 0,3 5,1 5,4 0,1 -1,2 -2.5,2 -1.5,0 -2.5,-1 -2.5,-2")
+	glyph("U", "1F", "m 2.5,0 v 6.5 c 0,1.5 1,2.5 2.5,2.5 1.5,0 2.5,-1 2.5,-2.5 v -6.5")
+	glyph("V", "16", "m 2,-1 3,11 3,-11")
+
+	# In practice, your typical browser font will overshoot its em box,
+	# so to make the display more cohesive, we need to do the same.
+	# Sadly, sf->use_typo_metrics can't be unset from FontForge script--
+	# this is necessary to prevent the caret from jumping upon the first
+	# inserted non-formatting character in xP's textarea.
+	# https://iamvdo.me/en/blog/css-font-metrics-line-height-and-vertical-align
+	print "SelectAll()\n" \
+		"Scale(115, 115, 0, 0)\n" \
+		"SetOS2Value('WinAscentIsOffset', 1)\n" \
+		"SetOS2Value('WinDescentIsOffset', 1)\n" \
+		"SetOS2Value('HHeadAscentIsOffset', 1)\n" \
+		"SetOS2Value('HHeadDescentIsOffset', 1)\n" \
+		"CorrectDirection()\n" \
+		"AutoWidth(100)\n" \
+		"AutoHint()\n" \
+		"AddExtrema()\n" \
+		"RoundToInt()\n" \
+		"SetFontNames('IRCFormatting-Regular'," \
+		" 'IRC Formatting', 'IRC Formatting Regular', 'Regular'," \
+		" 'Copyright (c) 2022, Premysl Eric Janouch')\n" \
+		"Generate('" Output "')\n" | FontForge
+	close(FontForge)
+}

xP/go.mod

@@ -0,0 +1,10 @@
+module janouch.name/xK/xP
+
+go 1.18
+
+require nhooyr.io/websocket v1.8.7
+
+require (
+	github.com/klauspost/compress v1.15.9 // indirect
+	golang.org/x/sys v0.0.0-20210423082822-04245dca01da // indirect
+)

xP/go.sum

@@ -0,0 +1,62 @@
+github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
+github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
+github.com/gin-contrib/sse v0.1.0 h1:Y/yl/+YNO8GZSjAhjMsSuLt29uWRFHdHYUb5lYOV9qE=
+github.com/gin-contrib/sse v0.1.0/go.mod h1:RHrZQHXnP2xjPF+u1gW/2HnVO7nvIa9PG3Gm+fLHvGI=
+github.com/gin-gonic/gin v1.6.3 h1:ahKqKTFpO5KTPHxWZjEdPScmYaGtLo8Y4DMHoEsnp14=
+github.com/gin-gonic/gin v1.6.3/go.mod h1:75u5sXoLsGZoRN5Sgbi1eraJ4GU3++wFwWzhwvtwp4M=
+github.com/go-playground/assert/v2 v2.0.1/go.mod h1:VDjEfimB/XKnb+ZQfWdccd7VUvScMdVu0Titje2rxJ4=
+github.com/go-playground/locales v0.13.0 h1:HyWk6mgj5qFqCT5fjGBuRArbVDfE4hi8+e8ceBS/t7Q=
+github.com/go-playground/locales v0.13.0/go.mod h1:taPMhCMXrRLJO55olJkUXHZBHCxTMfnGwq/HNwmWNS8=
+github.com/go-playground/universal-translator v0.17.0 h1:icxd5fm+REJzpZx7ZfpaD876Lmtgy7VtROAbHHXk8no=
+github.com/go-playground/universal-translator v0.17.0/go.mod h1:UkSxE5sNxxRwHyU+Scu5vgOQjsIJAF8j9muTVoKLVtA=
+github.com/go-playground/validator/v10 v10.2.0 h1:KgJ0snyC2R9VXYN2rneOtQcw5aHQB1Vv0sFl1UcHBOY=
+github.com/go-playground/validator/v10 v10.2.0/go.mod h1:uOYAAleCW8F/7oMFd6aG0GOhaH6EGOAJShg8Id5JGkI=
+github.com/gobwas/httphead v0.0.0-20180130184737-2c6c146eadee h1:s+21KNqlpePfkah2I+gwHF8xmJWRjooY+5248k6m4A0=
+github.com/gobwas/httphead v0.0.0-20180130184737-2c6c146eadee/go.mod h1:L0fX3K22YWvt/FAX9NnzrNzcI4wNYi9Yku4O0LKYflo=
+github.com/gobwas/pool v0.2.0 h1:QEmUOlnSjWtnpRGHF3SauEiOsy82Cup83Vf2LcMlnc8=
+github.com/gobwas/pool v0.2.0/go.mod h1:q8bcK0KcYlCgd9e7WYLm9LpyS+YeLd8JVDW6WezmKEw=
+github.com/gobwas/ws v1.0.2 h1:CoAavW/wd/kulfZmSIBt6p24n4j7tHgNVCjsfHVNUbo=
+github.com/gobwas/ws v1.0.2/go.mod h1:szmBTxLgaFppYjEmNtny/v3w89xOydFnnZMcgRRu/EM=
+github.com/golang/protobuf v1.3.3/go.mod h1:vzj43D7+SQXF/4pzW/hwtAqwc6iTitCiVSaWz5lYuqw=
+github.com/golang/protobuf v1.3.5 h1:F768QJ1E9tib+q5Sc8MkdJi1RxLTbRcTf8LJV56aRls=
+github.com/golang/protobuf v1.3.5/go.mod h1:6O5/vntMXwX2lRkT1hjjk0nAC1IDOTvTlVgjlRvqsdk=
+github.com/google/go-cmp v0.4.0 h1:xsAVV57WRhGj6kEIi8ReJzQlHHqcBYCElAvkovg3B/4=
+github.com/google/go-cmp v0.4.0/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
+github.com/google/gofuzz v1.0.0/go.mod h1:dBl0BpW6vV/+mYPU4Po3pmUjxk6FQPldtuIdl/M65Eg=
+github.com/gorilla/websocket v1.4.1 h1:q7AeDBpnBk8AogcD4DSag/Ukw/KV+YhzLj2bP5HvKCM=
+github.com/gorilla/websocket v1.4.1/go.mod h1:YR8l580nyteQvAITg2hZ9XVh4b55+EU/adAjf1fMHhE=
+github.com/json-iterator/go v1.1.9 h1:9yzud/Ht36ygwatGx56VwCZtlI/2AD15T1X2sjSuGns=
+github.com/json-iterator/go v1.1.9/go.mod h1:KdQUCv79m/52Kvf8AW2vK1V8akMuk1QjK/uOdHXbAo4=
+github.com/klauspost/compress v1.10.3/go.mod h1:aoV0uJVorq1K+umq18yTdKaF57EivdYsUV+/s2qKfXs=
+github.com/klauspost/compress v1.15.9 h1:wKRjX6JRtDdrE9qwa4b/Cip7ACOshUI4smpCQanqjSY=
+github.com/klauspost/compress v1.15.9/go.mod h1:PhcZ0MbTNciWF3rruxRgKxI5NkcHHrHUDtV4Yw2GlzU=
+github.com/leodido/go-urn v1.2.0 h1:hpXL4XnriNwQ/ABnpepYM/1vCLWNDfUNts8dX3xTG6Y=
+github.com/leodido/go-urn v1.2.0/go.mod h1:+8+nEpDfqqsY+g338gtMEUOtuK+4dEMhiQEgxpxOKII=
+github.com/mattn/go-isatty v0.0.12 h1:wuysRhFDzyxgEmMf5xjvJ2M9dZoWAXNNr5LSBS7uHXY=
+github.com/mattn/go-isatty v0.0.12/go.mod h1:cbi8OIDigv2wuxKPP5vlRcQ1OAZbq2CE4Kysco4FUpU=
+github.com/modern-go/concurrent v0.0.0-20180228061459-e0a39a4cb421 h1:ZqeYNhU3OHLH3mGKHDcjJRFFRrJa6eAM5H+CtDdOsPc=
+github.com/modern-go/concurrent v0.0.0-20180228061459-e0a39a4cb421/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q=
+github.com/modern-go/reflect2 v0.0.0-20180701023420-4b7aa43c6742 h1:Esafd1046DLDQ0W1YjYsBW+p8U2u7vzgW2SQVmlNazg=
+github.com/modern-go/reflect2 v0.0.0-20180701023420-4b7aa43c6742/go.mod h1:bx2lNnkwVCuqBIxFjflWJWanXIb3RllmbCylyMrvgv0=
+github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
+github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
+github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI=
+github.com/stretchr/testify v1.4.0/go.mod h1:j7eGeouHqKxXV5pUuKE4zz7dFj8WfuZ+81PSLYec5m4=
+github.com/ugorji/go v1.1.7 h1:/68gy2h+1mWMrwZFeD1kQialdSzAb432dtpeJ42ovdo=
+github.com/ugorji/go v1.1.7/go.mod h1:kZn38zHttfInRq0xu/PH0az30d+z6vm202qpg1oXVMw=
+github.com/ugorji/go/codec v1.1.7 h1:2SvQaVZ1ouYrrKKwoSk2pzd4A9evlKJb9oTL+OaLUSs=
+github.com/ugorji/go/codec v1.1.7/go.mod h1:Ax+UKWsSmolVDwsd+7N3ZtXu+yMGCf907BLYF3GoBXY=
+golang.org/x/sys v0.0.0-20200116001909-b77594299b42/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20210423082822-04245dca01da h1:b3NXsE2LusjYGGjL5bxEVZZORm/YEFFrWFjR8eFrw/c=
+golang.org/x/sys v0.0.0-20210423082822-04245dca01da/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/text v0.3.2/go.mod h1:bEr9sfX3Q8Zfm5fL9x+3itogRgK3+ptLWKqgva+5dAk=
+golang.org/x/time v0.0.0-20191024005414-555d28b269f0/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ=
+golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
+golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543 h1:E7g+9GITq07hpfrRu66IVDexMakfv52eLZ2CXBWiKr4=
+golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
+gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
+gopkg.in/yaml.v2 v2.2.2/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
+gopkg.in/yaml.v2 v2.2.8 h1:obN1ZagJSUGI0Ek/LBmuj4SNLPfIny3KsKFopxRdj10=
+gopkg.in/yaml.v2 v2.2.8/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
+nhooyr.io/websocket v1.8.7 h1:usjR2uOr/zjjkVMy0lW+PPohFok7PCow5sDjLgX4P4g=
+nhooyr.io/websocket v1.8.7/go.mod h1:B70DZP8IakI65RVQ51MsWP/8jndNma26DVA/nFSCgW0=

xP/public/xP.css

@@ -0,0 +1,257 @@
+@font-face {
+	src: url('ircfmt.woff2') format('woff2');
+	font-family: 'IRC Formatting';
+	font-weight: normal;
+	font-style: normal;
+}
+body {
+	margin: 0;
+	padding: 0;
+	/* Firefox only renders C0 within the textarea, why? */
+	font-family: 'IRC Formatting', sans-serif;
+	font-size: clamp(0.5rem, 2vw, 1rem);
+}
+.xP {
+	display: flex;
+	flex-direction: column;
+	overflow: hidden;
+	height: 100vh;
+	/* https://caniuse.com/viewport-unit-variants */
+	height: 100dvh;
+}
+
+.overlay {
+	padding: .6em .9em;
+	background: #eee;
+	border: 1px outset #eee;
+	position: absolute;
+	left: 50%;
+	top: 50%;
+	transform: translate(-50%, -50%);
+	text-align: center;
+	z-index: 1;
+}
+.title, .status {
+	padding: .05em .3em;
+	background: #eee;
+
+	display: flex;
+	justify-content: space-between;
+	align-items: baseline;
+	column-gap: .3em;
+
+	position: relative;
+	border-top: 3px solid #ccc;
+	border-bottom: 2px solid #888;
+}
+.title {
+	/* To approximate right-aligned space-between. */
+	flex-direction: row-reverse;
+}
+.title:before, .status:before {
+	content: " ";
+	position: absolute;
+	left: 0;
+	right: 0;
+	height: 2px;
+	top: -2px;
+	background: #fff;
+}
+.title:after, .status:after {
+	content: " ";
+	position: absolute;
+	left: 0;
+	right: 0;
+	height: 1px;
+	bottom: -1px;
+	background: #ccc;
+}
+
+.toolbar {
+	display: flex;
+	align-items: baseline;
+	margin-right: -.3em;
+}
+.indicator {
+	margin: 0 .3em;
+}
+button {
+	font: inherit;
+	background: transparent;
+	border: 1px solid transparent;
+	padding: 0 .3em;
+}
+button:focus {
+	border: 1px dotted #000;
+}
+button:hover {
+	border-left: 1px solid #fff;
+	border-top: 1px solid #fff;
+	border-right: 1px solid #888;
+	border-bottom: 1px solid #888;
+}
+button:hover:active {
+	border-left: 1px solid #888;
+	border-top: 1px solid #888;
+	border-right: 1px solid #fff;
+	border-bottom: 1px solid #fff;
+}
+
+.middle {
+	flex: auto;
+	display: flex;
+	flex-direction: row;
+	overflow: hidden;
+}
+
+.list {
+	overflow-y: auto;
+	border-right: 2px solid #ccc;
+	min-width: 10em;
+	flex-shrink: 0;
+}
+.item {
+	padding: .05em .3em;
+	cursor: default;
+}
+.item.highlighted {
+	color: #ff5f00;
+}
+.item.activity {
+	font-weight: bold;
+}
+.item.current {
+	font-style: italic;
+	background: #eee;
+}
+
+/* Only Firefox currently supports align-content: safe end, thus this. */
+.buffer-container {
+	flex: auto;
+	display: flex;
+	flex-direction: column;
+	overflow: hidden;
+	position: relative;
+}
+.filler {
+	flex: auto;
+}
+.buffer {
+	display: grid;
+	grid-template-columns: max-content minmax(0, 1fr);
+	overflow-y: auto;
+}
+.log {
+	font-family: monospace;
+	overflow-y: auto;
+}
+.log, .content, .completions {
+	/* Note: https://bugs.chromium.org/p/chromium/issues/detail?id=1261435 */
+	white-space: break-spaces;
+	overflow-wrap: break-word;
+}
+.log, .buffer .content {
+	padding: .1em .3em;
+}
+
+.leaked {
+	opacity: 50%;
+}
+.date {
+	padding: .3em;
+	grid-column: span 2;
+	font-weight: bold;
+}
+.unread {
+	grid-column: span 2;
+	border-top: 1px solid #ff5f00;
+}
+.time {
+	padding: .1em .3em;
+	background: #f8f8f8;
+	color: #bbb;
+	border-right: 1px solid #ccc;
+}
+.time.hidden:after {
+	border-top: .2em dotted #ccc;
+	display: block;
+	width: 50%;
+	margin: 0 auto;
+	content: "";
+}
+.mark {
+	padding-right: .3em;
+	text-align: center;
+	display: inline-block;
+	min-width: 2em;
+}
+.mark.error {
+	color: red;
+}
+.mark.join {
+	color: green;
+}
+.mark.part {
+	color: red;
+}
+.mark.action {
+	color: darkred;
+}
+.content .b {
+	font-weight: bold;
+}
+.content .i {
+	font-style: italic;
+}
+.content .u {
+	text-decoration: underline;
+}
+.content .s {
+	text-decoration: line-through;
+}
+.content .m {
+	font-family: monospace;
+}
+
+.completions {
+	position: absolute;
+	left: 0;
+	right: 0;
+	bottom: 0;
+	background: #fff;
+	padding: .05em .3em;
+	border-top: 1px solid #888;
+
+	max-height: 50%;
+	display: flex;
+	flex-flow: column wrap;
+	column-gap: .6em;
+	overflow-x: auto;
+}
+.input {
+	flex-shrink: 0;
+	border: 2px inset #eee;
+	overflow: hidden;
+	resize: vertical;
+	display: flex;
+}
+.input:focus-within {
+	border-color: #ff5f00;
+}
+.prompt {
+	padding: .05em .3em;
+	border-right: 1px solid #ccc;
+	background: #f8f8f8;
+	font-weight: bold;
+}
+textarea {
+	font: inherit;
+	padding: .05em .3em;
+	margin: 0;
+	border: 0;
+	flex-grow: 1;
+	resize: none;
+}
+textarea:focus {
+	outline: none;
+}

xP/xP.go

@@ -0,0 +1,299 @@
+// Copyright (c) 2022, Přemysl Eric Janouch <p@janouch.name>
+// SPDX-License-Identifier: 0BSD
+
+package main
+
+import (
+	"bufio"
+	"context"
+	"encoding/binary"
+	"encoding/json"
+	"flag"
+	"fmt"
+	"html/template"
+	"io"
+	"log"
+	"net"
+	"net/http"
+	"os"
+	"time"
+
+	"nhooyr.io/websocket"
+)
+
+var (
+	debug = flag.Bool("debug", false, "enable debug output")
+
+	addressBind    string
+	addressConnect string
+	addressWS      string
+)
+
+// -----------------------------------------------------------------------------
+
+func relayReadFrame(r io.Reader) []byte {
+	var length uint32
+	if err := binary.Read(r, binary.BigEndian, &length); err != nil {
+		log.Println("Event receive failed: " + err.Error())
+		return nil
+	}
+	b := make([]byte, length)
+	if _, err := io.ReadFull(r, b); err != nil {
+		log.Println("Event receive failed: " + err.Error())
+		return nil
+	}
+
+	if *debug {
+		log.Printf("<? %v\n", b)
+
+		var m RelayEventMessage
+		if after, ok := m.ConsumeFrom(b); !ok {
+			log.Println("Event deserialization failed")
+			return nil
+		} else if len(after) != 0 {
+			log.Println("Event deserialization failed: trailing data")
+			return nil
+		}
+
+		j, err := m.MarshalJSON()
+		if err != nil {
+			log.Println("Event marshalling failed: " + err.Error())
+			return nil
+		}
+
+		log.Printf("<- %s\n", j)
+	}
+	return b
+}
+
+func relayMakeReceiver(ctx context.Context, conn net.Conn) <-chan []byte {
+	// The usual event message rarely gets above 1 kilobyte,
+	// thus this is set to buffer up at most 1 megabyte or so.
+	p := make(chan []byte, 1000)
+	r := bufio.NewReaderSize(conn, 65536)
+	go func() {
+		defer close(p)
+		for {
+			j := relayReadFrame(r)
+			if j == nil {
+				return
+			}
+			select {
+			case p <- j:
+			case <-ctx.Done():
+				return
+			}
+		}
+	}()
+	return p
+}
+
+func relayWriteJSON(conn net.Conn, j []byte) bool {
+	var m RelayCommandMessage
+	if err := json.Unmarshal(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
+	}
+
+	if *debug {
+		log.Printf("-> %v\n", b)
+	}
+	return true
+}
+
+// -----------------------------------------------------------------------------
+
+func clientReadJSON(ctx context.Context, ws *websocket.Conn) []byte {
+	t, j, err := ws.Read(ctx)
+	if err != nil {
+		log.Println("Command receive failed: " + err.Error())
+		return nil
+	}
+	if t != websocket.MessageText {
+		log.Println(
+			"Command receive failed: " + "binary messages are not supported")
+		return nil
+	}
+
+	if *debug {
+		log.Printf("?> %s\n", j)
+	}
+	return j
+}
+
+func clientWriteBinary(ctx context.Context, ws *websocket.Conn, b []byte) bool {
+	if err := ws.Write(ctx, websocket.MessageBinary, b); err != nil {
+		log.Println("Event send failed: " + err.Error())
+		return false
+	}
+	return true
+}
+
+func clientWriteError(ctx context.Context, ws *websocket.Conn, err error) bool {
+	b, ok := (&RelayEventMessage{
+		EventSeq: 0,
+		Data: RelayEventData{
+			Interface: RelayEventDataError{
+				Event:      RelayEventError,
+				CommandSeq: 0,
+				Error:      err.Error(),
+			},
+		},
+	}).AppendTo(nil)
+	if ok {
+		log.Println("Event serialization failed")
+		return false
+	}
+	return clientWriteBinary(ctx, ws, b)
+}
+
+func handleWS(w http.ResponseWriter, r *http.Request) {
+	ws, err := websocket.Accept(w, r, &websocket.AcceptOptions{
+		InsecureSkipVerify: true,
+		// Note that Safari can be broken with compression.
+		CompressionMode: websocket.CompressionContextTakeover,
+		// This is for the payload; set higher to avoid overhead.
+		CompressionThreshold: 64 << 10,
+	})
+	if err != nil {
+		log.Println("Client rejected: " + err.Error())
+		return
+	}
+	defer ws.Close(websocket.StatusGoingAway, "Goodbye")
+
+	ctx, cancel := context.WithCancel(r.Context())
+	defer cancel()
+
+	conn, err := net.Dial("tcp", addressConnect)
+	if err != nil {
+		log.Println("Connection failed: " + err.Error())
+		clientWriteError(ctx, ws, err)
+		return
+	}
+	defer conn.Close()
+
+	// To decrease latencies, events are received and decoded in parallel
+	// to their sending, and we try to batch them together.
+	relayFrames := relayMakeReceiver(ctx, conn)
+	batchFrames := func() []byte {
+		batch, ok := <-relayFrames
+		if !ok {
+			return nil
+		}
+	Batch:
+		for {
+			select {
+			case b, ok := <-relayFrames:
+				if !ok {
+					break Batch
+				}
+				batch = append(batch, b...)
+			default:
+				break Batch
+			}
+		}
+		return batch
+	}
+
+	// We don't need to intervene, so it's just two separate pipes so far.
+	go func() {
+		defer cancel()
+		for {
+			j := clientReadJSON(ctx, ws)
+			if j == nil {
+				return
+			}
+			relayWriteJSON(conn, j)
+		}
+	}()
+	go func() {
+		defer cancel()
+		for {
+			b := batchFrames()
+			if b == nil {
+				return
+			}
+			clientWriteBinary(ctx, ws, b)
+		}
+	}()
+	<-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" />
+	<meta name="viewport" content="width=device-width, initial-scale=1">
+	<link rel="stylesheet" href="xP.css" />
+</head>
+<body>
+	<script src="mithril.js">
+	</script>
+	<script>
+	let proxy = '{{ . }}'
+	</script>
+	<script type="module" src="xP.js">
+	</script>
+</body>
+</html>`))
+
+func handleDefault(w http.ResponseWriter, r *http.Request) {
+	if r.URL.Path != "/" {
+		staticHandler.ServeHTTP(w, r)
+		return
+	}
+
+	wsURI := addressWS
+	if wsURI == "" {
+		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() {
+	flag.Usage = func() {
+		fmt.Fprintf(flag.CommandLine.Output(),
+			"Usage: %s [OPTION...] BIND CONNECT [WSURI]\n\n", os.Args[0])
+		flag.PrintDefaults()
+	}
+
+	flag.Parse()
+	if flag.NArg() < 2 || flag.NArg() > 3 {
+		flag.Usage()
+		os.Exit(1)
+	}
+
+	addressBind, addressConnect = flag.Arg(0), flag.Arg(1)
+	if flag.NArg() > 2 {
+		addressWS = flag.Arg(2)
+	}
+
+	http.Handle("/ws", http.HandlerFunc(handleWS))
+	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())
+}