p
/
xK
1
1
Fork 0
Code Issues 1 Pull Requests Releases 9 Wiki Activity

Compare commits

base: p:master
Branches Tags
p:master
p:v1.5.0
p:v1.4.0
p:v1.3.0
p:v1.2.0
p:v1.1.0
p:v1.0.0
p:v0.9.8
p:v0.9.7
p:v0.9.6
p:v0.9.5
p:v0.9.4
p:v0.9.3
p:v0.9.2
p:v0.9.1
p:v0.9
..
compare: p:v0.9.6
Branches Tags
p:master
p:v1.5.0
p:v1.4.0
p:v1.3.0
p:v1.2.0
p:v1.1.0
p:v1.0.0
p:v0.9.8
p:v0.9.7
p:v0.9.6
p:v0.9.5
p:v0.9.4
p:v0.9.3
p:v0.9.2
p:v0.9.1
p:v0.9

No commits in common. "master" and "v0.9.6" have entirely different histories.
master ... v0.9.6

82 changed files with 1682 additions and 15263 deletions
Show Stats Expand all files Collapse all files

32
.clang-format
View File

@ -1,32 +0,0 @@
# 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"]

10
.gitignore vendored
View File

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

242
CMakeLists.txt
View File

@ -1,32 +1,22 @@
# Ubuntu 18.04 LTS and OpenBSD 6.4
cmake_minimum_required (VERSION 3.10)
file (READ xK-version project_version)
configure_file (xK-version xK-version.tag COPYONLY)
string (STRIP "${project_version}" project_version)
project (xK VERSION "${project_version}"
DESCRIPTION "IRC daemon, bot, TUI client and its web frontend" LANGUAGES C)
project (uirc3 C)
cmake_minimum_required (VERSION 2.8.11)
# Options
option (WANT_READLINE "Use GNU Readline for the UI (better)" ON)
option (WANT_LIBEDIT "Use BSD libedit for the UI" OFF)
option (WANT_XF "Build xF" OFF)
# Moar warnings
set (CMAKE_C_STANDARD 99)
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 "${CMAKE_C_FLAGS} -Wall -Wextra -Wno-unused-function")
endif ()
set (wdisabled "-Wno-unused-function")
set (CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -std=c99 -Wall -Wextra ${wdisabled}")
endif ("${CMAKE_C_COMPILER_ID}" MATCHES "GNU" OR CMAKE_COMPILER_IS_GNUCC)
# Version
set (project_version "0.9.6")
# 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}")
@ -36,8 +26,8 @@ if (GIT_FOUND AND EXISTS "${git_head}")
set (git_ref "${PROJECT_SOURCE_DIR}/.git/${CMAKE_MATCH_1}")
if (EXISTS "${git_ref}")
configure_file ("${git_ref}" git-ref.tag COPYONLY)
endif ()
endif ()
endif (EXISTS "${git_ref}")
endif (git_head_content MATCHES "^ref: ([^\r\n]+)")
execute_process (COMMAND ${GIT_EXECUTABLE} describe --tags --match v*
WORKING_DIRECTORY ${PROJECT_SOURCE_DIR}
@ -45,8 +35,8 @@ if (GIT_FOUND AND EXISTS "${git_head}")
OUTPUT_VARIABLE git_describe OUTPUT_STRIP_TRAILING_WHITESPACE)
if (NOT git_describe_result)
string (REGEX REPLACE "^v" "" project_version "${git_describe}")
endif ()
endif ()
endif (NOT git_describe_result)
endif (GIT_FOUND AND EXISTS "${git_head}")
# Dashes make filenames confusing and upset packaging software
string (REPLACE "-" "+" project_version_safe "${project_version}")
@ -62,22 +52,21 @@ include_directories (${libssl_INCLUDE_DIRS})
link_directories (${libssl_LIBRARY_DIRS})
if ("${CMAKE_SYSTEM_NAME}" MATCHES "BSD")
include_directories (/usr/local/include)
link_directories (/usr/local/lib)
# 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 ()
endif ("${CMAKE_SYSTEM_NAME}" MATCHES "BSD")
# -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)
foreach (extra iconv rt)
find_library (extra_lib_${extra} ${extra})
if (extra_lib_${extra})
list (APPEND project_libraries ${extra_lib_${extra}})
endif ()
endforeach ()
endif (extra_lib_${extra})
endforeach (extra)
include (CheckCSourceRuns)
set (CMAKE_REQUIRED_LIBRARIES ${project_libraries})
@ -87,59 +76,53 @@ 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
# Dependencies for degesch
pkg_check_modules (libffi REQUIRED libffi)
list (APPEND xC_libraries ${libffi_LIBRARIES})
list (APPEND degesch_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)
# FIXME: other Lua versions may be acceptable, don't know yet
pkg_search_module (lua lua53 lua5.3 lua-5.3 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 ()
endif (NOT lua_FOUND)
list (APPEND xC_libraries ${lua_LIBRARIES})
list (APPEND degesch_libraries ${lua_LIBRARIES})
include_directories (${lua_INCLUDE_DIRS})
link_directories (${lua_LIBRARY_DIRS})
endif ()
endif (WITH_LUA)
find_package (Curses)
pkg_check_modules (ncursesw ncursesw)
if (ncursesw_FOUND)
list (APPEND xC_libraries ${ncursesw_LIBRARIES})
list (APPEND degesch_libraries ${ncursesw_LIBRARIES})
include_directories (${ncursesw_INCLUDE_DIRS})
elseif (CURSES_FOUND)
list (APPEND xC_libraries ${CURSES_LIBRARY})
list (APPEND degesch_libraries ${CURSES_LIBRARY})
include_directories (${CURSES_INCLUDE_DIR})
else ()
else (CURSES_FOUND)
message (SEND_ERROR "Curses not found")
endif ()
endif (ncursesw_FOUND)
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)
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 ()
include_directories (/usr/local/include/ereadline)
list (APPEND degesch_libraries ereadline)
else ("${CMAKE_SYSTEM_NAME}" MATCHES "OpenBSD")
list (APPEND degesch_libraries readline)
endif ("${CMAKE_SYSTEM_NAME}" MATCHES "OpenBSD")
elseif (WANT_LIBEDIT)
pkg_check_modules (libedit REQUIRED libedit)
list (APPEND xC_libraries ${libedit_LIBRARIES})
list (APPEND degesch_libraries ${libedit_LIBRARIES})
include_directories (${libedit_INCLUDE_DIRS})
endif ()
endif ((WANT_READLINE AND WANT_LIBEDIT) OR (NOT WANT_READLINE AND NOT WANT_LIBEDIT))
# Generate a configuration file
set (HAVE_READLINE "${WANT_READLINE}")
@ -147,69 +130,59 @@ set (HAVE_EDITLINE "${WANT_LIBEDIT}")
set (HAVE_LUA "${WITH_LUA}")
include (GNUInstallDirs)
set (project_config ${PROJECT_BINARY_DIR}/config.h)
configure_file (${PROJECT_SOURCE_DIR}/config.h.in ${project_config})
# ZyklonB is currently an odd duck but degesch follows normal XDG rules
set (zyklonb_plugin_dir ${CMAKE_INSTALL_LIBDIR}/zyklonb/plugins)
configure_file (${PROJECT_SOURCE_DIR}/config.h.in ${PROJECT_BINARY_DIR}/config.h)
include_directories (${PROJECT_SOURCE_DIR} ${PROJECT_BINARY_DIR})
# 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")
add_custom_target (replies DEPENDS ${PROJECT_BINARY_DIR}/xD-replies.c)
# Project source files
set (common_sources)
set (common_headers ${PROJECT_BINARY_DIR}/config.h)
add_custom_command (OUTPUT xC-proto.c
COMMAND env LC_ALL=C awk
-f ${PROJECT_SOURCE_DIR}/liberty/tools/lxdrgen.awk
-f ${PROJECT_SOURCE_DIR}/liberty/tools/lxdrgen-c.awk
-v PrefixCamel=Relay
${PROJECT_SOURCE_DIR}/xC.lxdr > xC-proto.c
DEPENDS
${PROJECT_SOURCE_DIR}/liberty/tools/lxdrgen.awk
${PROJECT_SOURCE_DIR}/liberty/tools/lxdrgen-c.awk
${PROJECT_SOURCE_DIR}/xC.lxdr
COMMENT "Generating xC relay protocol code" VERBATIM)
add_custom_target (xC-proto DEPENDS ${PROJECT_BINARY_DIR}/xC-proto.c)
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
COMMENT "Generating files from the list of server numerics")
set_source_files_properties (${PROJECT_BINARY_DIR}/kike-replies.c
PROPERTIES HEADER_FILE_ONLY TRUE)
# Build
foreach (name xB xC xD)
add_executable (${name} ${name}.c ${project_config})
target_link_libraries (${name} ${project_libraries})
add_threads (${name})
endforeach ()
add_executable (zyklonb zyklonb.c ${common_sources} ${common_headers})
target_link_libraries (zyklonb ${project_libraries})
add_threads (zyklonb)
add_dependencies (xD replies)
add_dependencies (xC replies xC-proto)
target_link_libraries (xC ${xC_libraries})
add_executable (degesch degesch.c kike-replies.c
${common_sources} ${common_headers})
target_link_libraries (degesch ${project_libraries} ${degesch_libraries})
add_threads (degesch)
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 ()
add_executable (kike kike.c kike-replies.c ${common_sources} ${common_headers})
target_link_libraries (kike ${project_libraries})
add_threads (kike)
# Tests
function (make_tests_for target_name)
get_target_property (sources ${target_name} SOURCES)
get_target_property (libraries ${target_name} LINK_LIBRARIES)
get_target_property (options ${target_name} COMPILE_OPTIONS)
set (test test-${target_name})
add_executable (${test} ${sources})
target_link_libraries (${test} ${libraries})
set_target_properties (${test} PROPERTIES
COMPILE_DEFINITIONS TESTING
COMPILE_OPTIONS "${options}")
add_test (NAME ${test} COMMAND ${test})
endfunction (make_tests_for)
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)
make_tests_for (degesch)
add_test (NAME custom-static-analysis
COMMAND ${PROJECT_SOURCE_DIR}/test-static)
endif ()
endif (BUILD_TESTING)
# Various clang-based diagnostics, loads of fake positives and spam
file (GLOB clang_tidy_sources *.c)
@ -226,50 +199,28 @@ add_custom_target (clang-tidy
WORKING_DIRECTORY ${PROJECT_SOURCE_DIR})
# Installation
install (TARGETS xB xC xD DESTINATION ${CMAKE_INSTALL_BINDIR})
install (TARGETS zyklonb degesch kike 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)
install (DIRECTORY plugins/zyklonb/
DESTINATION ${zyklonb_plugin_dir} USE_SOURCE_PERMISSIONS)
install (DIRECTORY plugins/degesch/
DESTINATION ${CMAKE_INSTALL_DATADIR}/degesch/plugins)
# 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 xB xC xD)
foreach (page zyklonb degesch kike)
set (page_output "${PROJECT_BINARY_DIR}/${page}.1")
list (APPEND project_MAN_PAGES "${page_output}")
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 asciidoc-release-version=${project_version}
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_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)
add_custom_target (docs ALL DEPENDS ${project_MAN_PAGES})
@ -277,12 +228,13 @@ foreach (page ${project_MAN_PAGES})
string (REGEX MATCH "\\.([0-9])$" manpage_suffix "${page}")
install (FILES "${page}"
DESTINATION "${CMAKE_INSTALL_MANDIR}/man${CMAKE_MATCH_1}")
endforeach ()
endforeach (page)
# CPack
set (CPACK_PACKAGE_DESCRIPTION_SUMMARY "Experimental IRC client, daemon and bot")
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_PACKAGE_VENDOR "Premysl Janouch")
set (CPACK_PACKAGE_CONTACT "Přemysl Janouch <p@janouch.name>")
set (CPACK_RESOURCE_FILE_LICENSE "${PROJECT_SOURCE_DIR}/LICENSE")
set (CPACK_GENERATOR "TGZ;ZIP")

2
LICENSE
View File

@ -1,4 +1,4 @@
Copyright (c) 2014 - 2024, Přemysl Eric Janouch <p@janouch.name>
Copyright (c) 2014 - 2018, Přemysl Janouch <p@janouch.name>
Permission to use, copy, modify, and/or distribute this software for any
purpose with or without fee is hereby granted.

297
NEWS
View File

@ -1,280 +1,111 @@
2.0.0 (Unreleased)
* xD: now using SHA-256 for client certificate fingerprints
* 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
* Added a Win32 frontend for xC called xW
* Added a Cocoa frontend for xC called xM
* Added a Go port of xD called xS
* Added a simple notifier called xN
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
* degesch: a second /disconnect cuts the connection by force
* xC: send a QUIT message to the IRC server on Ctrl-C
* degesch: send a QUIT message to the IRC server on Ctrl-C
* xC: add a Slack plugin (even though the gateway's now defunct)
* degesch: add a Slack plugin (even though the gateway's now defunct)
* xC: show an error message on log write failure
* degesch: show an error message on log write failure
* xC: fix parsing of literal IPv6 addresses with port numbers
* degesch: fix parsing of literal IPv6 addresses with port numbers
* xC: fix some error messages
* degesch: fix some error messages
* xC: workaround a Readline bug in the fancy-prompt.lua plugin
* degesch: workaround a Readline bug in the fancy-prompt.lua plugin
* xD: fix two memory leaks
* kike: fix two memory leaks
* xD: improve error handling for incoming connections
* kike: improve error handling for incoming connections
* xD: disable TLS session reuse
* kike: 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
* degesch: export many more fields to the Lua API, add a prompt hook
* xC: show channel user count in the prompt
* degesch: show channel user count in the prompt
* xC: allow hiding join/part messages and other noise (Meta-Shift-H)
* degesch: allow hiding join/part messages and other noise (Meta-Shift-H)
* xC: allow autojoining channels with keys
* degesch: allow autojoining channels with keys
* xC: rejoin channels with keys on reconnect
* degesch: rejoin channels with keys on reconnect
* xC: make /query without arguments just open the buffer
* degesch: make /query without arguments just open the buffer
* xC: add a censor plugin
* degesch: add a censor plugin
* xC: die on configuration parse errors
* degesch: die on configuration parse errors
* xC: request channel modes also on rejoin
* degesch: request channel modes also on rejoin
* xC: don't show remembered channel modes on parted channels
* degesch: don't show remembered channel modes on parted channels
* xC: fix highlight detection in colored text
* degesch: fix highlight detection in colored text
* xC: fix CTCP handling for the real world and don't decode X-QUOTEs
* degesch: fix CTCP handling for the real world and don't decode X-QUOTEs
* xC: add support for OpenSSL 1.1.0
* degesch: add support for OpenSSL 1.1.0
0.9.4 (2016-04-28) "Oops"
* xC: fix crash on characters invalid in Windows-1252
* degesch: fix crash on characters invalid in Windows-1252
* xC: add an auto-rejoin plugin
* degesch: add an auto-rejoin plugin
* xC: better date change messages with customizable formatting;
* degesch: 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
* ZyklonB: add a calc plugin providing a basic Scheme REPL
* xB: add a seen plugin
* ZyklonB: add a seen plugin
* xD, xB: use pledge(2) on OpenBSD
* kike, ZyklonB: 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
* degesch: now we erase the screen before displaying buffers
* xC: implemented word wrapping in buffers
* degesch: implemented word wrapping in buffers
* xC: added autocomplete for /topic
* degesch: added autocomplete for /topic
* xC: Lua API was improved and extended
* degesch: Lua API was improved and extended
* xC: added a basic last.fm "now playing" plugin
* degesch: added a basic last.fm "now playing" plugin
* xC: backlog limit was made configurable
* degesch: backlog limit was made configurable
* xC: allow changing the list of IRC capabilities to use if available
* degesch: allow changing the list of IRC capabilities to use if available
* xC: optimize buffer memory usage
* degesch: optimize buffer memory usage
* xC: added logging of messages sent from /quote and plugins
* degesch: 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
* degesch: 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
* degesch: added --format for previewing things like MOTD files
* xC: added /buffer goto supporting case insensitive partial matches
* degesch: added /buffer goto supporting case insensitive partial matches
* xD: add support for IRCv3.2 server-time
* kike: add support for IRCv3.2 server-time
* xB: plugins now run in a dedicated data directory
* ZyklonB: plugins now run in a dedicated data directory
* xB: added a factoids plugin
* ZyklonB: added a factoids plugin
* Remote addresses are now resolved asynchronously
@ -283,28 +114,28 @@
0.9.2 (2015-12-31)
* xC: added rudimentary support for Lua scripting
* degesch: added rudimentary support for Lua scripting
* xC: added detection of pasting, so that it doesn't trigger other
* degesch: added detection of pasting, so that it doesn't trigger other
keyboard shortcuts, such as for autocomplete
* xC: added auto-away capability
* degesch: added auto-away capability
* xC: added an /oper command
* degesch: added an /oper command
* xC: libedit backend works again
* degesch: libedit backend works again
* xC: added capability to edit the input line using VISUAL/EDITOR
* degesch: added capability to edit the input line using VISUAL/EDITOR
* xC: added Meta-Tab to switch to the last used buffer
* degesch: added Meta-Tab to switch to the last used buffer
* xC: correctly respond to stopping and resuming (SIGTSTP)
* degesch: correctly respond to stopping and resuming (SIGTSTP)
* xC: fixed decoding of text formatting
* degesch: fixed decoding of text formatting
* xC: unseen PMs now show up as highlights
* degesch: unseen PMs now show up as highlights
* xC: various bugfixes
* degesch: various bugfixes
0.9.1 (2015-09-25)
@ -315,23 +146,23 @@
* Pulled in kqueue support
* xC: added backlog/scrollback functionality using less(1)
* degesch: added backlog/scrollback functionality using less(1)
* xC: made showing the entire set of channel mode user prefixes optional
* degesch: made showing the entire set of channel mode user prefixes optional
* xC: nicknames in /names are now ordered
* degesch: nicknames in /names are now ordered
* xC: nicknames now use the 256-color terminal palette if available
* degesch: nicknames now use the 256-color terminal palette if available
* xC: now we skip entries in the "addresses" list that can't be resolved
* degesch: 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
* degesch: joins, parts, nick changes and quits don't count as new buffer
activity anymore
* xC: added Meta-H to open the full log file
* degesch: added Meta-H to open the full log file
* xC: various bugfixes and little improvements
* degesch: various bugfixes and little improvements
0.9.0 (2015-07-23)

259
README.adoc
View File

@ -1,219 +1,162 @@
xK
==
uirc3
=====
:compact-option:
'xK' (chat kit) is an IRC software suite consisting of a daemon, bot, notifier,
terminal client, and web/Windows/macOS frontends for the client. It's all
you're ever going to need for chatting, so long as you can make do with slightly
minimalist software.
The [line-through]#unethical# edgy IRC trinity. This project consists of an
experimental IRC client, daemon, and bot. It's all you're ever going to need
for chatting, as long as you can make do with minimalist software.
They're all lean on dependencies, and offer a maximally permissive licence.
All of them have these potentially interesting properties:
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.
- IPv6 support
- TLS support, including client certificates
- lean on dependencies (with the exception of 'degesch')
- compact and arguably easy to hack on
- permissive license
image::xC.webp[align="center"]
degesch
-------
The IRC client. It is largely defined by being built on top of GNU Readline
that has been hacked to death. Its interface should feel somewhat familiar for
weechat or irssi users.
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.
image::degesch.png[align="center"]
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].
This is the 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,
a powerful configuration system, integrated help, text formatting, CTCP queries,
automatic splitting of overlong messages, autocomplete, logging to file,
auto-away, command aliases and basic support for Lua scripting.
image::xP.webp[align="center"]
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
testing purposes or a small network of respectful users (or bots), this one will
do it just fine.
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.
Notable features:
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.
- TLS autodetection (why doesn't everyone have this?), using secure defaults
- IRCop authentication via TLS client certificates
- epoll/kqueue support; this means that it should be able to handle quite
a number of concurrent user connections
- partial IRCv3 support
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).
Not supported:
xS
--
The IRC daemon again, this time ported to Go, additionally supporting WEBIRC,
and thus ideal for pairing with, e.g.,
https://github.com/kiwiirc/webircgateway[].
Any further development, such as P10 or TS6 linking for IRC services,
or plugin support for arbitrary bridges, will happen here.
- server linking (which also means no services); I consider existing protocols
for this purpose ugly and tricky to implement correctly; I've also found no
use for this feature yet
- online changes to configuration; the configuration system from degesch could
be used to implement this feature if needed
- limits of almost any kind, just connections and mode `+l`
xN
--
The IRC notifier, should you ever need to send automated messages from a script.
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.
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.
While originally intended to be a simple rewrite of the original AWK bot in C,
it fairly quickly became a playground, and it eventually got me into writing
the rest of the 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).
It survives crashes, server disconnects and timeouts, and also has 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 using Arch Linux's
https://aur.archlinux.org/packages/xk-git[AUR],
or as a https://git.janouch.name/p/nixexprs[Nix derivation].
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) +
Build dependencies: CMake, pkg-config, help2man, awk, sh, liberty (included) +
Runtime dependencies: openssl +
Additionally for degesch: curses, libffi, lua >= 5.3 (optional),
readline >= 6.0 or libedit >= 2013-07-12
$ 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
$ git clone --recursive https://git.janouch.name/p/uirc3.git
$ mkdir uirc3/build
$ cd uirc3/build
$ cmake .. -DCMAKE_INSTALL_PREFIX=/usr -DCMAKE_BUILD_TYPE=Debug \
-DWANT_READLINE=ON -DWANT_LIBEDIT=OFF -DWANT_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:
Or you can try telling CMake to make a package for you. For Debian it is:
$ cpack -G DEB # also supported: RPM, FreeBSD
# dpkg -i xK-*.deb
$ cpack -G DEB
# dpkg -i uirc3-*.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.
'degesch' has in-program configuration. Just run it and read the instructions.
For the rest you might want to generate a configuration file:
$ xB --write-default-config
$ xD --write-default-config
$ 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:
$ xB
$ xD
$ zyklonb
$ kike
'xB' stays running in the foreground, therefore I recommend launching it inside
a Screen or tmux session.
'ZyklonB' 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
'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.
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.
xW
~~
The Win32 frontend is a separate CMake subproject that should be compiled
using MinGW-w64. To avoid having to specify the relay address each time you
run it, create a shortcut for the executable and include the address in its
_Target_ field:
C:\...\xW.exe 127.0.0.1 9000
It works reasonably well starting with Windows 7.
xM
~~
The Cocoa frontend is a separate CMake subproject that requires Xcode to build.
It is currently not that usable. The relay address can either be passed on
the command line, or preset in the _defaults_ database:
$ defaults write name.janouch.xM relayHost 127.0.0.1
$ defaults write name.janouch.xM relayPort 9000
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.
'kike' uses SHA1 fingerprints of TLS client certificates to authenticate users.
To get the fingerprint from a certificate file in the required form, use:
'xD' and 'xS' use SHA-256 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 | sha256sum
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:
$ openssl x509 -in public.pem -outform DER | sha1sum
Custom Key Bindings in degesch
------------------------------
The default and preferred frontend used in 'degesch' 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
$if degesch
"\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.
How do I make degesch look like the screenshot?
-----------------------------------------------
First of all, you must build it with Lua support. With the defaults, degesch
doesn't look very fancy because some things are rather hackish, and I also don't
want to depend on UTF-8 or 256color terminals in the code. In addition to that,
I appear to be one of the few people who use black on white terminals.
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"
/set behaviour.date_change_line = "%a %e %b %Y"
/set behaviour.plugin_autoload += "fancy-prompt.lua,thin-cursor.lua"
/set behaviour.backlog_helper = "LESSSECURE=1 less -R +Gb -Ps'Backlog ?ltlines %lt-%lb?L/%L. .?e(END):?pB%pB\\%..'"
/set behaviour.backlog_helper_strip_formatting = off
/set attributes.reset = "\x1b[0m"
/set attributes.userhost = "\x1b[38;5;109m"
/set attributes.join = "\x1b[38;5;108m"
/set attributes.part = "\x1b[38;5;138m"
/set attributes.external = "\x1b[38;5;248m"
/set attributes.timestamp = "\x1b[48;5;255m\x1b[38;5;250m"
Configuration profiles
----------------------
@ -228,7 +171,7 @@ 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,
Use https://git.janouch.name/p/uirc3 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.
@ -239,5 +182,5 @@ 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.
Note that 'degesch' technically becomes GPL-licensed when you statically link it
against GNU Readline, but that is not a concern of this source package.

173
common.c
View File

@ -1,7 +1,7 @@
/*
* common.c: common functionality
*
* Copyright (c) 2014 - 2022, Přemysl Eric Janouch <p@janouch.name>
* Copyright (c) 2014 - 2015, Přemysl Janouch <p@janouch.name>
*
* Permission to use, copy, modify, and/or distribute this software for any
* purpose with or without fee is hereby granted.
@ -22,11 +22,11 @@
#define LIBERTY_WANT_PROTO_IRC
#ifdef WANT_SYSLOG_LOGGING
#define print_fatal_data ((void *) LOG_ERR)
#define print_error_data ((void *) LOG_ERR)
#define print_warning_data ((void *) LOG_WARNING)
#define print_status_data ((void *) LOG_INFO)
#define print_debug_data ((void *) LOG_DEBUG)
#define print_fatal_data ((void *) LOG_ERR)
#define print_error_data ((void *) LOG_ERR)
#define print_warning_data ((void *) LOG_WARNING)
#define print_status_data ((void *) LOG_INFO)
#define print_debug_data ((void *) LOG_DEBUG)
#endif // WANT_SYSLOG_LOGGING
#include "liberty/liberty.c"
@ -48,99 +48,13 @@ init_openssl (void)
#endif
}
static char *
gai_reconstruct_address (struct addrinfo *ai)
{
char host[NI_MAXHOST] = {}, port[NI_MAXSERV] = {};
int err = getnameinfo (ai->ai_addr, ai->ai_addrlen,
host, sizeof host, port, sizeof port,
NI_NUMERICHOST | NI_NUMERICSERV);
if (err)
{
print_debug ("%s: %s", "getnameinfo", gai_strerror (err));
return xstrdup ("?");
}
return format_host_port_pair (host, port);
}
static bool
accept_error_is_transient (int err)
{
// OS kernels may return a wide range of unforeseeable errors.
// Assuming that they're either transient or caused by
// a connection that we've just extracted from the queue.
switch (err)
{
case EBADF:
case EINVAL:
case ENOTSOCK:
case EOPNOTSUPP:
return false;
default:
return true;
}
}
/// Destructively tokenize an address into a host part, and a port part.
/// The port is only overwritten if that part is found, allowing for defaults.
static const char *
tokenize_host_port (char *address, const char **port)
{
// Unwrap IPv6 addresses in format_host_port_pair() format.
char *rbracket = strchr (address, ']');
if (*address == '[' && rbracket)
{
if (rbracket[1] == ':')
{
*port = rbracket + 2;
return *rbracket = 0, address + 1;
}
if (!rbracket[1])
return *rbracket = 0, address + 1;
}
char *colon = strchr (address, ':');
if (colon)
{
*port = colon + 1;
return *colon = 0, address;
}
return address;
}
// --- To be moved to liberty --------------------------------------------------
// FIXME: in xssl_get_error() we rely on error reasons never being NULL (i.e.,
// all loaded), which isn't very robust.
// TODO: check all places where this is used and see if we couldn't gain better
// information by piecing together some other subset of data from the error
// stack. Most often, this is used in an error_set() context, which would
// allow us to allocate memory instead of returning static strings.
static const char *
xerr_describe_error (void)
static void
cstr_set (char **s, char *new)
{
unsigned long err = ERR_get_error ();
if (!err)
return "undefined error";
const char *reason = ERR_reason_error_string (err);
do
// Not thread-safe, not a concern right now--need a buffer
print_debug ("%s", ERR_error_string (err, NULL));
while ((err = ERR_get_error ()));
if (!reason)
return "cannot retrieve error description";
return reason;
}
static struct str
str_from_cstr (const char *cstr)
{
struct str self;
self.alloc = (self.len = strlen (cstr)) + 1;
self.str = memcpy (xmalloc (self.alloc), cstr, self.alloc);
return self;
free (*s);
*s = new;
}
static ssize_t
@ -156,15 +70,60 @@ static time_t
unixtime_msec (long *msec)
{
#ifdef _POSIX_TIMERS
struct timespec tp;
hard_assert (clock_gettime (CLOCK_REALTIME, &tp) != -1);
*msec = tp.tv_nsec / 1000000;
struct timespec tp;
hard_assert (clock_gettime (CLOCK_REALTIME, &tp) != -1);
*msec = tp.tv_nsec / 1000000;
#else // ! _POSIX_TIMERS
struct timeval tp;
hard_assert (gettimeofday (&tp, NULL) != -1);
*msec = tp.tv_usec / 1000;
struct timeval tp;
hard_assert (gettimeofday (&tp, NULL) != -1);
*msec = tp.tv_usec / 1000;
#endif // ! _POSIX_TIMERS
return tp.tv_sec;
return tp.tv_sec;
}
/// This differs from the non-unique version in that we expect the filename
/// to be something like a pattern for mkstemp(), so the resulting path can
/// reside in a system-wide directory with no risk of a conflict.
static char *
resolve_relative_runtime_unique_filename (const char *filename)
{
const char *runtime_dir = getenv ("XDG_RUNTIME_DIR");
const char *tmpdir = getenv ("TMPDIR");
struct str path = str_make ();
if (runtime_dir && *runtime_dir == '/')
str_append (&path, runtime_dir);
else if (tmpdir && *tmpdir == '/')
str_append (&path, tmpdir);
else
str_append (&path, "/tmp");
str_append_printf (&path, "/%s/%s", PROGRAM_NAME, filename);
// Try to create the file's ancestors;
// typically the user will want to immediately create a file in there
const char *last_slash = strrchr (path.str, '/');
if (last_slash && last_slash != path.str)
{
char *copy = xstrndup (path.str, last_slash - path.str);
(void) mkdir_with_parents (copy, NULL);
free (copy);
}
return str_steal (&path);
}
static bool
xwrite (int fd, const char *data, size_t len, struct error **e)
{
size_t written = 0;
while (written < len)
{
ssize_t res = write (fd, data + written, len - written);
if (res >= 0)
written += res;
else if (errno != EINTR)
return error_set (e, "%s", strerror (errno));
}
return true;
}
// --- Logging -----------------------------------------------------------------
@ -329,7 +288,7 @@ struct socks_connector
SOCKS_DATA_CB (socks_4a_finish)
{
uint8_t null = 0, status = 0;
uint8_t null, status;
hard_assert (msg_unpacker_u8 (unpacker, &null));
hard_assert (msg_unpacker_u8 (unpacker, &status));
@ -432,7 +391,7 @@ SOCKS_DATA_CB (socks_5_request_domain)
SOCKS_DATA_CB (socks_5_request_finish)
{
uint8_t version = 0, status = 0, reserved = 0, type = 0;
uint8_t version, status, reserved, type;
hard_assert (msg_unpacker_u8 (unpacker, &version));
hard_assert (msg_unpacker_u8 (unpacker, &status));
hard_assert (msg_unpacker_u8 (unpacker, &reserved));
@ -509,7 +468,7 @@ socks_5_request_start (struct socks_connector *self)
SOCKS_DATA_CB (socks_5_userpass_finish)
{
uint8_t version = 0, status = 0;
uint8_t version, status;
hard_assert (msg_unpacker_u8 (unpacker, &version));
hard_assert (msg_unpacker_u8 (unpacker, &status));
@ -544,7 +503,7 @@ socks_5_userpass_start (struct socks_connector *self)
SOCKS_DATA_CB (socks_5_auth_finish)
{
uint8_t version = 0, method = 0;
uint8_t version, method;
hard_assert (msg_unpacker_u8 (unpacker, &version));
hard_assert (msg_unpacker_u8 (unpacker, &method));

4
config.h.in
View File

@ -2,9 +2,7 @@
#define CONFIG_H
#define PROGRAM_VERSION "${project_version}"
// We use the XDG Base Directory Specification, but may be installed anywhere.
#define PROJECT_DATADIR "${CMAKE_INSTALL_FULL_DATADIR}"
#define ZYKLONB_PLUGIN_DIR "${CMAKE_INSTALL_PREFIX}/${zyklonb_plugin_dir}"
#cmakedefine HAVE_READLINE
#cmakedefine HAVE_EDITLINE

4420
xC.c → degesch.c
View File

File diff suppressed because it is too large Load Diff

BIN
degesch.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 8.9 KiB

28
kike-gen-replies.sh Executable file
View File

@ -0,0 +1,28 @@
#!/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 "};"
}'

6
xD-replies → kike-replies
View File

@ -85,9 +85,3 @@
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"

231
xD.c → kike.c
View File

@ -1,7 +1,7 @@
/*
* xD.c: an IRC daemon
* kike.c: the experimental IRC daemon
*
* Copyright (c) 2014 - 2022, Přemysl Eric Janouch <p@janouch.name>
* Copyright (c) 2014 - 2016, Přemysl Janouch <p@janouch.name>
*
* Permission to use, copy, modify, and/or distribute this software for any
* purpose with or without fee is hereby granted.
@ -17,14 +17,12 @@
*/
#include "config.h"
#define PROGRAM_NAME "xD"
#define PROGRAM_NAME "kike"
#define WANT_SYSLOG_LOGGING
#include "common.c"
#include "xD-replies.c"
#include "kike-replies.c"
#include <nl_types.h>
#include <sys/resource.h>
enum { PIPE_READ, PIPE_WRITE };
@ -49,10 +47,10 @@ static struct simple_config_item g_config_table[] =
{ "tls_key", NULL, "Server TLS private key (PEM)" },
{ "tls_ciphers", DEFAULT_CIPHERS, "OpenSSL cipher list" },
{ "operators", NULL, "IRCop TLS client cert. SHA-256 fingerprints" },
{ "operators", NULL, "IRCop TLS cert. fingerprints" },
{ "max_connections", "0", "Global connection limit" },
{ "ping_interval", "180", "Interval between PINGs (sec)" },
{ "ping_interval", "180", "Interval between PING's (sec)" },
{ NULL, NULL, NULL }
};
@ -196,8 +194,7 @@ irc_validate_to_str (enum validation_result result)
}
// Anything to keep it as short as possible
// "shortname" from RFC 2812 doesn't work how its author thought it would.
#define SN "[0-9A-Za-z](-*[0-9A-Za-z])*"
#define SN "[0-9A-Za-z][-0-9A-Za-z]*[0-9A-Za-z]*"
#define N4 "[0-9]{1,3}"
#define N6 "[0-9ABCDEFabcdef]{1,}"
@ -236,13 +233,6 @@ irc_is_valid_host (const char *host)
|| irc_is_valid_hostaddr (host);
}
// TODO: currently, we are almost encoding-agnostic (strings just need to be
// ASCII-compatible). We should at least have an option to enforce a specific
// encoding, such as UTF-8. Note that with Unicode we should not allow all
// character clasess and exclude the likes of \pM with the goal of enforcing
// NFC-normalized identifiers--utf8proc is a good candidate library to handle
// the categorization and validation.
static bool
irc_is_valid_user (const char *user)
{
@ -296,7 +286,7 @@ irc_is_valid_user_mask (const char *mask)
static bool
irc_is_valid_fingerprint (const char *fp)
{
return irc_regex_match ("^[a-fA-F0-9]{64}$", fp);
return irc_regex_match ("^[a-fA-F0-9]{40}$", fp);
}
// --- Clients (equals users) --------------------------------------------------
@ -616,8 +606,7 @@ struct server_context
{
int *listen_fds; ///< Listening socket FD's
struct poller_fd *listen_events; ///< New connections available
size_t listen_len; ///< Number of listening sockets
size_t listen_alloc; ///< How many we've allocated
size_t n_listen_fds; ///< Number of listening sockets
time_t started; ///< When has the server been started
@ -698,7 +687,7 @@ server_context_free (struct server_context *self)
{
str_map_free (&self->config);
for (size_t i = 0; i < self->listen_len; i++)
for (size_t i = 0; i < self->n_listen_fds; i++)
{
poller_fd_reset (&self->listen_events[i]);
xclose (self->listen_fds[i]);
@ -749,12 +738,12 @@ irc_initiate_quit (struct server_context *ctx)
{
print_status ("shutting down");
for (size_t i = 0; i < ctx->listen_len; i++)
for (size_t i = 0; i < ctx->n_listen_fds; i++)
{
poller_fd_reset (&ctx->listen_events[i]);
xclose (ctx->listen_fds[i]);
}
ctx->listen_len = 0;
ctx->n_listen_fds = 0;
for (struct client *iter = ctx->clients; iter; iter = iter->next)
if (!iter->closing_link)
@ -853,6 +842,8 @@ client_send_str (struct client *c, const struct str *s)
str_append_data (&c->write_buffer, s->str,
MIN (s->len, IRC_MAX_MESSAGE_LENGTH));
str_append (&c->write_buffer, "\r\n");
// XXX: we might want to move this elsewhere, so that it doesn't get called
// as often; it's going to cause a lot of syscalls with epoll.
client_update_poller (c, NULL);
// Technically we haven't sent it yet but that's a minor detail
@ -1005,8 +996,8 @@ client_get_ssl_cert_fingerprint (struct client *c)
if (i2d_X509 (peer_cert, &p) < 0)
return NULL;
unsigned char hash[SHA256_DIGEST_LENGTH];
SHA256 (cert, cert_len, hash);
unsigned char hash[SHA_DIGEST_LENGTH];
SHA1 (cert, cert_len, hash);
struct str fingerprint = str_make ();
for (size_t i = 0; i < sizeof hash; i++)
@ -1437,10 +1428,6 @@ irc_handle_nick (const struct irc_message *msg, struct client *c)
if (client && client != c)
RETURN_WITH_REPLY (c, IRC_ERR_NICKNAMEINUSE, nickname);
// Nothing to do here, let's not annoy roommates
if (c->nickname && !strcmp (c->nickname, nickname))
return;
if (c->registered)
{
client_add_to_whowas (c);
@ -1459,7 +1446,8 @@ irc_handle_nick (const struct irc_message *msg, struct client *c)
cstr_set (&c->nickname, xstrdup (nickname));
str_map_set (&ctx->users, nickname, c);
irc_try_finish_registration (c);
if (!c->registered)
irc_try_finish_registration (c);
}
static void
@ -1480,7 +1468,6 @@ irc_handle_user (const struct irc_message *msg, struct client *c)
cstr_set (&c->username, xstrdup (username));
cstr_set (&c->realname, xstrdup (realname));
c->mode = 0;
unsigned long m;
if (xstrtoul (&m, mode, 10))
@ -2007,11 +1994,10 @@ irc_handle_chan_mode_change
mode_processor_step (&p, '+');
while (*mode_string)
if (!mode_processor_step (&p, *mode_string++))
goto done_processing;
break;
}
// TODO: limit to three changes with parameter per command
done_processing:
if (p.added.len || p.removed.len)
{
struct str message = str_make ();
@ -2460,12 +2446,12 @@ irc_handle_whois (const struct irc_message *msg, struct client *c)
{
struct str_map_iter iter = str_map_iter_make (&c->ctx->users);
bool found = false;
while ((target = str_map_iter_next (&iter)))
if (!irc_fnmatch (mask, target->nickname))
{
irc_send_whois_reply (c, target);
found = true;
}
while ((target = str_map_iter_next (&iter))
&& !irc_fnmatch (mask, target->nickname))
{
irc_send_whois_reply (c, target);
found = true;
}
if (!found)
irc_send_reply (c, IRC_ERR_NOSUCHNICK, mask);
}
@ -2729,7 +2715,7 @@ irc_try_join (struct client *c, const char *channel_name, const char *key)
else if (channel_get_user (chan, c))
return;
bool invited_by_chanop = !!str_map_find (&c->invites, channel_name);
bool invited_by_chanop = str_map_find (&c->invites, channel_name);
if ((chan->modes & IRC_CHAN_MODE_INVITE_ONLY)
&& !client_in_mask_list (c, &chan->invite_list)
&& !invited_by_chanop)
@ -2895,9 +2881,9 @@ irc_handle_stats_uptime (struct client *c)
static void
irc_handle_stats (const struct irc_message *msg, struct client *c)
{
char query = 0;
if (msg->params.len > 0)
query = *msg->params.vector[0];
char query;
if (msg->params.len < 1 || !(query = *msg->params.vector[0]))
RETURN_WITH_REPLY (c, IRC_ERR_NEEDMOREPARAMS, msg->command);
if (msg->params.len > 1 && !irc_is_this_me (c->ctx, msg->params.vector[1]))
RETURN_WITH_REPLY (c, IRC_ERR_NOSUCHSERVER, msg->params.vector[1]);
if (!(c->mode & IRC_USER_MODE_OPERATOR))
@ -2910,7 +2896,7 @@ irc_handle_stats (const struct irc_message *msg, struct client *c)
case 'u': irc_handle_stats_uptime (c); break;
}
irc_send_reply (c, IRC_RPL_ENDOFSTATS, query ? query : '*');
irc_send_reply (c, IRC_RPL_ENDOFSTATS, query);
}
static void
@ -2930,29 +2916,6 @@ irc_handle_links (const struct irc_message *msg, struct client *c)
irc_send_reply (c, IRC_RPL_ENDOFLINKS, mask);
}
static void
irc_handle_wallops (const struct irc_message *msg, struct client *c)
{
if (msg->params.len < 1)
RETURN_WITH_REPLY (c, IRC_ERR_NEEDMOREPARAMS, msg->command);
if (!(c->mode & IRC_USER_MODE_OPERATOR))
RETURN_WITH_REPLY (c, IRC_ERR_NOPRIVILEGES);
const char *message = msg->params.vector[0];
// Our interpretation: anonymize the sender,
// and target all users who want to receive these messages
struct str_map_iter iter = str_map_iter_make (&c->ctx->users);
struct client *target;
while ((target = str_map_iter_next (&iter)))
{
if (target != c && !(target->mode & IRC_USER_MODE_RX_WALLOPS))
continue;
client_send (target, ":%s WALLOPS :%s", c->ctx->server_name, message);
}
}
static void
irc_handle_kill (const struct irc_message *msg, struct client *c)
{
@ -3015,7 +2978,6 @@ irc_register_handlers (struct server_context *ctx)
{ "ADMIN", true, irc_handle_admin, 0, 0 },
{ "STATS", true, irc_handle_stats, 0, 0 },
{ "LINKS", true, irc_handle_links, 0, 0 },
{ "WALLOPS", true, irc_handle_wallops, 0, 0 },
{ "MODE", true, irc_handle_mode, 0, 0 },
{ "PRIVMSG", true, irc_handle_privmsg, 0, 0 },
@ -3047,6 +3009,8 @@ static void
irc_process_message (const struct irc_message *msg,
const char *raw, void *user_data)
{
(void) raw;
struct client *c = user_data;
if (c->closing_link)
return;
@ -3086,14 +3050,13 @@ irc_try_read (struct client *c)
while (true)
{
str_reserve (buf, 512);
n_read = read (c->socket_fd, buf->str + buf->len,
buf->alloc - buf->len - 1 /* null byte */);
n_read = recv (c->socket_fd, buf->str + buf->len,
buf->alloc - buf->len - 1 /* null byte */, 0);
if (n_read > 0)
{
buf->str[buf->len += n_read] = '\0';
// TODO: discard characters above the 512 character limit
// FIXME: we should probably discard the data if closing_link
irc_process_buffer (buf, irc_process_message, c);
continue;
}
@ -3108,7 +3071,7 @@ irc_try_read (struct client *c)
if (errno == EINTR)
continue;
print_debug ("%s: %s: %s", __func__, "read", strerror (errno));
print_debug ("%s: %s: %s", __func__, "recv", strerror (errno));
client_kill (c, strerror (errno));
return false;
}
@ -3135,7 +3098,6 @@ irc_try_read_tls (struct client *c)
case SSL_ERROR_NONE:
buf->str[buf->len += n_read] = '\0';
// TODO: discard characters above the 512 character limit
// FIXME: we should probably discard the data if closing_link
irc_process_buffer (buf, irc_process_message, c);
continue;
case SSL_ERROR_ZERO_RETURN:
@ -3164,7 +3126,7 @@ irc_try_write (struct client *c)
while (buf->len)
{
n_written = write (c->socket_fd, buf->str, buf->len);
n_written = send (c->socket_fd, buf->str, buf->len, 0);
if (n_written >= 0)
{
str_remove_slice (buf, 0, n_written);
@ -3176,7 +3138,7 @@ irc_try_write (struct client *c)
if (errno == EINTR)
continue;
print_debug ("%s: %s: %s", __func__, "write", strerror (errno));
print_debug ("%s: %s: %s", __func__, "send", strerror (errno));
client_kill (c, strerror (errno));
return false;
}
@ -3288,7 +3250,7 @@ error_ssl_3:
SSL_free (c->ssl);
c->ssl = NULL;
error_ssl_2:
error_info = xerr_describe_error ();
error_info = ERR_reason_error_string (ERR_get_error ());
error_ssl_1:
print_debug ("could not initialize TLS for %s: %s", c->address, error_info);
return false;
@ -3421,10 +3383,16 @@ irc_try_fetch_client (struct server_context *ctx, int listen_fd)
if (errno == EINTR)
return true;
if (accept_error_is_transient (errno))
print_warning ("%s: %s", "accept", strerror (errno));
else
if (errno == EBADF
|| errno == EINVAL
|| errno == ENOTSOCK
|| errno == EOPNOTSUPP)
print_fatal ("%s: %s", "accept", strerror (errno));
// OS kernels may return a wide range of unforeseeable errors.
// Assuming that they're either transient or caused by
// a connection that we've just extracted from the queue.
print_warning ("%s: %s", "accept", strerror (errno));
return true;
}
@ -3561,7 +3529,7 @@ irc_initialize_ssl_ctx (struct server_context *ctx,
if (!ctx->ssl_ctx)
{
error_set (e, "%s: %s", "could not initialize TLS",
xerr_describe_error ());
ERR_reason_error_string (ERR_get_error ()));
return false;
}
SSL_CTX_set_verify (ctx->ssl_ctx,
@ -3591,11 +3559,11 @@ irc_initialize_ssl_ctx (struct server_context *ctx,
error_set (e, "failed to select any cipher from the cipher list");
else if (!SSL_CTX_use_certificate_chain_file (ctx->ssl_ctx, cert_path))
error_set (e, "%s: %s", "setting the TLS certificate failed",
xerr_describe_error ());
ERR_reason_error_string (ERR_get_error ()));
else if (!SSL_CTX_use_PrivateKey_file
(ctx->ssl_ctx, key_path, SSL_FILETYPE_PEM))
error_set (e, "%s: %s", "setting the TLS private key failed",
xerr_describe_error ());
ERR_reason_error_string (ERR_get_error ()));
else
// TODO: SSL_CTX_check_private_key()? It has probably already been
// checked by SSL_CTX_use_PrivateKey_file() above.
@ -3701,35 +3669,26 @@ irc_initialize_motd (struct server_context *ctx, struct error **e)
return true;
}
static bool
irc_parse_config_unsigned (const char *name, const char *value, unsigned *out,
unsigned long min, unsigned long max, struct error **e)
{
unsigned long ul;
hard_assert (value != NULL);
if (!xstrtoul (&ul, value, 10) || ul > max || ul < min)
{
error_set (e, "invalid configuration value for `%s': %s",
name, "the number is invalid or out of range");
return false;
}
*out = ul;
return true;
}
/// This function handles values that require validation before their first use,
/// or some kind of a transformation (such as conversion to an integer) needs
/// to be done before they can be used directly.
static bool
irc_parse_config (struct server_context *ctx, struct error **e)
{
unsigned long ul;
#define PARSE_UNSIGNED(name, min, max) \
irc_parse_config_unsigned (#name, str_map_find (&ctx->config, #name), \
&ctx->name, min, max, e)
const char *name = str_map_find (&ctx->config, #name); \
hard_assert (name != NULL); \
if (!xstrtoul (&ul, name, 10) || ul > max || ul < min) \
{ \
error_set (e, "invalid configuration value for `%s': %s", \
#name, "the number is invalid or out of range"); \
return false; \
} \
ctx->name = ul
if (!PARSE_UNSIGNED (ping_interval, 1, UINT_MAX)
|| !PARSE_UNSIGNED (max_connections, 0, UINT_MAX))
return false;
PARSE_UNSIGNED (ping_interval, 1, UINT_MAX);
PARSE_UNSIGNED (max_connections, 0, UINT_MAX);
bool result = true;
struct strv fingerprints = strv_make ();
@ -3808,9 +3767,10 @@ irc_lock_pid_file (struct server_context *ctx, struct error **e)
}
static int
irc_listen (struct addrinfo *ai)
irc_listen (struct addrinfo *gai_iter)
{
int fd = socket (ai->ai_family, ai->ai_socktype, ai->ai_protocol);
int fd = socket (gai_iter->ai_family,
gai_iter->ai_socktype, gai_iter->ai_protocol);
if (fd == -1)
return -1;
set_cloexec (fd);
@ -3821,16 +3781,16 @@ irc_listen (struct addrinfo *ai)
soft_assert (setsockopt (fd, SOL_SOCKET, SO_REUSEADDR,
&yes, sizeof yes) != -1);
#if defined SOL_IPV6 && defined IPV6_V6ONLY
// Make NULL always bind to both IPv4 and IPv6, irrespectively of the order
// of results; only INADDR6_ANY seems to be affected by this
if (ai->ai_family == AF_INET6)
soft_assert (setsockopt (fd, SOL_IPV6, IPV6_V6ONLY,
&yes, sizeof yes) != -1);
#endif
char host[NI_MAXHOST], port[NI_MAXSERV];
host[0] = port[0] = '\0';
int err = getnameinfo (gai_iter->ai_addr, gai_iter->ai_addrlen,
host, sizeof host, port, sizeof port,
NI_NUMERICHOST | NI_NUMERICSERV);
if (err)
print_debug ("%s: %s", "getnameinfo", gai_strerror (err));
char *address = gai_reconstruct_address (ai);
if (bind (fd, ai->ai_addr, ai->ai_addrlen))
char *address = format_host_port_pair (host, port);
if (bind (fd, gai_iter->ai_addr, gai_iter->ai_addrlen))
print_error ("bind to %s failed: %s", address, strerror (errno));
else if (listen (fd, 16 /* arbitrary number */))
print_error ("listen on %s failed: %s", address, strerror (errno));
@ -3850,12 +3810,12 @@ static void
irc_listen_resolve (struct server_context *ctx,
const char *host, const char *port, struct addrinfo *gai_hints)
{
struct addrinfo *gai_result = NULL, *gai_iter = NULL;
struct addrinfo *gai_result, *gai_iter;
int err = getaddrinfo (host, port, gai_hints, &gai_result);
if (err)
{
char *address = format_host_port_pair (host, port);
print_error ("binding to %s failed: %s: %s",
print_error ("bind to %s failed: %s: %s",
address, "getaddrinfo", gai_strerror (err));
free (address);
return;
@ -3864,20 +3824,18 @@ irc_listen_resolve (struct server_context *ctx,
int fd;
for (gai_iter = gai_result; gai_iter; gai_iter = gai_iter->ai_next)
{
if (ctx->listen_len == ctx->listen_alloc)
break;
if ((fd = irc_listen (gai_iter)) == -1)
continue;
set_blocking (fd, false);
struct poller_fd *event = &ctx->listen_events[ctx->listen_len];
struct poller_fd *event = &ctx->listen_events[ctx->n_listen_fds];
*event = poller_fd_make (&ctx->poller, fd);
event->dispatcher = (poller_fd_fn) on_irc_client_available;
event->user_data = ctx;
ctx->listen_fds[ctx->listen_len++] = fd;
ctx->listen_fds[ctx->n_listen_fds++] = fd;
poller_fd_set (event, POLLIN);
break;
}
freeaddrinfo (gai_result);
}
@ -3897,20 +3855,13 @@ irc_setup_listen_fds (struct server_context *ctx, struct error **e)
struct strv ports = strv_make ();
cstr_split (bind_port, ",", true, &ports);
// For C and simplicity's sake let's assume that the host will resolve
// to at most two different addresses: IPv4 and IPv6 in case it is NULL
ctx->listen_alloc = ports.len * 2;
ctx->listen_fds =
xcalloc (ctx->listen_alloc, sizeof *ctx->listen_fds);
ctx->listen_events =
xcalloc (ctx->listen_alloc, sizeof *ctx->listen_events);
ctx->listen_fds = xcalloc (ports.len, sizeof *ctx->listen_fds);
ctx->listen_events = xcalloc (ports.len, sizeof *ctx->listen_events);
for (size_t i = 0; i < ports.len; i++)
irc_listen_resolve (ctx, bind_host, ports.vector[i], &gai_hints);
strv_free (&ports);
if (!ctx->listen_len)
if (!ctx->n_listen_fds)
{
error_set (e, "%s: %s",
"network setup failed", "no ports to listen on");
@ -3995,21 +3946,6 @@ daemonize (struct server_context *ctx)
poller_post_fork (&ctx->poller);
}
static void
setup_limits (void)
{
struct rlimit limit;
if (getrlimit (RLIMIT_NOFILE, &limit))
{
print_warning ("%s: %s", "getrlimit", strerror (errno));
return;
}
limit.rlim_cur = limit.rlim_max;
if (setrlimit (RLIMIT_NOFILE, &limit))
print_warning ("%s: %s", "setrlimit", strerror (errno));
}
int
main (int argc, char *argv[])
{
@ -4028,7 +3964,7 @@ main (int argc, char *argv[])
};
struct opt_handler oh =
opt_handler_make (argc, argv, opts, NULL, "IRC daemon.");
opt_handler_make (argc, argv, opts, NULL, "Experimental IRC daemon.");
int c;
while ((c = opt_handler_get (&oh)) != -1)
@ -4056,7 +3992,6 @@ main (int argc, char *argv[])
print_status (PROGRAM_NAME " " PROGRAM_VERSION " starting");
setup_signal_handlers ();
setup_limits ();
init_openssl ();
struct server_context ctx;

2
liberty

@ -1 +1 @@
Subproject commit f04cc2c61e1a00db4d1af1bb55ca7e20b9c3db23
Subproject commit bb30c7d86ef7b165c5e00cc8e0ad2e3e85b9e617

10
plugins/xC/auto-rejoin.lua → plugins/degesch/auto-rejoin.lua
View File

@ -1,7 +1,7 @@
--
-- auto-rejoin.lua: join back automatically when someone kicks you
--
-- Copyright (c) 2016, Přemysl Eric Janouch <p@janouch.name>
-- Copyright (c) 2016, Přemysl Janouch <p@janouch.name>
--
-- Permission to use, copy, modify, and/or distribute this software for any
-- purpose with or without fee is hereby granted.
@ -16,7 +16,7 @@
--
local timeout
xC.setup_config {
degesch.setup_config {
timeout = {
type = "integer",
comment = "auto rejoin timeout",
@ -31,9 +31,9 @@ xC.setup_config {
},
}
async, await = xC.async, coroutine.yield
xC.hook_irc (function (hook, server, line)
local msg = xC.parse (line)
async, await = degesch.async, coroutine.yield
degesch.hook_irc (function (hook, server, line)
local msg = degesch.parse (line)
if msg.command ~= "KICK" then return line end
local who = msg.prefix:match ("^[^!]*")

29
plugins/xC/censor.lua → plugins/degesch/censor.lua
View File

@ -1,7 +1,7 @@
--
-- censor.lua: black out certain users' messages
--
-- Copyright (c) 2016 - 2021, Přemysl Eric Janouch <p@janouch.name>
-- Copyright (c) 2016, Přemysl Janouch <p@janouch.name>
--
-- Permission to use, copy, modify, and/or distribute this software for any
-- purpose with or without fee is hereby granted.
@ -38,42 +38,25 @@ local read_masks = function (v)
end
end
local quote
xC.setup_config {
degesch.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 start, text = line:match ("^(.- PRIVMSG .-:)(.*)$")
local ctcp, rest = text:match ("^(\x01%g+ )(.*)")
text = ctcp and ctcp .. quote .. decolor (rest) or quote .. decolor (text)
text = ctcp and ctcp .. "\x0301,01" .. rest or "\x0301,01" .. text
return start .. text
end
xC.hook_irc (function (hook, server, line)
local msg = xC.parse (line)
degesch.hook_irc (function (hook, server, line)
local msg = degesch.parse (line)
if msg.command ~= "PRIVMSG" then return line end
local channel = msg.params[1]:lower ()

45
plugins/xC/fancy-prompt.lua → plugins/degesch/fancy-prompt.lua
View File

@ -1,7 +1,7 @@
--
-- fancy-prompt.lua: the fancy multiline prompt you probably want
--
-- Copyright (c) 2016 - 2022, Přemysl Eric Janouch <p@janouch.name>
-- Copyright (c) 2016, Přemysl Janouch <p@janouch.name>
--
-- Permission to use, copy, modify, and/or distribute this software for any
-- purpose with or without fee is hereby granted.
@ -28,19 +28,19 @@
-- 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
degesch.hook_prompt (function (hook)
local current = degesch.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
for i, buffer in ipairs (degesch.buffers) do
if buffer == current then
current_n = i
elseif buffer.new_messages_count ~= buffer.new_unimportant_count then
active = active .. ","
if active ~= "" then active = active .. "," end
if buffer.highlighted then
active = active .. "!"
bg_color = "224"
@ -48,6 +48,7 @@ xC.hook_prompt (function (hook)
active = active .. i
end
end
if active ~= "" then active = "(" .. active .. ")" end
local x = current_n .. ":" .. current.name
if chan and chan.users_len ~= 0 then
local params = ""
@ -55,34 +56,24 @@ xC.hook_prompt (function (hook)
params = params .. " +" .. mode .. " " .. param
end
local modes = chan.no_param_modes .. params:sub (3)
if modes ~= "" then
x = x .. "(+" .. modes .. ")"
end
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
if current.hide_unimportant then x = x .. "<H>" 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]", "?")
local lines, cols = degesch.get_screen_size ()
x = x .. " " .. active .. string.rep (" ", cols)
-- 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
-- Readline seems to be broken and completely corrupts the prompt
-- (tested on 7.0.003 Archlinux, 7.0-5 Debian buster)
x = x:gsub("[\128-\255]", "?")
-- Cut off extra characters and apply formatting, including the hack.
-- Note that this doesn't count with full-width or zero-width characters.
local overflow = utf8.offset (x, cols - 1)
if overflow then x = x:sub (1, overflow) 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"
x .. "\x01\x1b[0;4;1;7;38;5;" .. bg_color .. "m\x02 \x01\x1b[0;1m\x02"
local user_prefix = function (chan, user)
for i, chan_user in ipairs (chan.users) do

8
plugins/xC/last-fm.lua → plugins/degesch/last-fm.lua
View File

@ -5,7 +5,7 @@
--
-- I call this style closure-oriented programming
--
-- Copyright (c) 2016, Přemysl Eric Janouch <p@janouch.name>
-- Copyright (c) 2016, Přemysl Janouch <p@janouch.name>
--
-- Permission to use, copy, modify, and/or distribute this software for any
-- purpose with or without fee is hereby granted.
@ -23,7 +23,7 @@ local cjson = require "cjson"
-- Setup configuration to load last.fm API credentials from
local user, api_key
xC.setup_config {
degesch.setup_config {
user = {
type = "string",
comment = "last.fm username",
@ -117,7 +117,7 @@ end
local running
-- Initiate a connection to last.fm servers
async, await = xC.async, coroutine.yield
async, await = degesch.async, coroutine.yield
local make_request = function (buffer, action)
if not user or not api_key then
report_error (buffer, "configuration is incomplete")
@ -159,7 +159,7 @@ local send_song = function (buffer)
end
-- Hook input to simulate new commands
xC.hook_input (function (hook, buffer, input)
degesch.hook_input (function (hook, buffer, input)
if input == "/np" then
make_request (buffer, function (np)
now_playing = np

6
plugins/xC/ping-timeout.lua → plugins/degesch/ping-timeout.lua
View File

@ -1,7 +1,7 @@
--
-- ping-timeout.lua: ping timeout readability enhancement plugin
--
-- Copyright (c) 2015 - 2016, Přemysl Eric Janouch <p@janouch.name>
-- Copyright (c) 2015 - 2016, Přemysl Janouch <p@janouch.name>
--
-- Permission to use, copy, modify, and/or distribute this software for any
-- purpose with or without fee is hereby granted.
@ -15,8 +15,8 @@
-- CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
--
xC.hook_irc (function (hook, server, line)
local msg = xC.parse (line)
degesch.hook_irc (function (hook, server, line)
local msg = degesch.parse (line)
local start, timeout = line:match ("^(.* :Ping timeout:) (%d+) seconds$")
if msg.command ~= "QUIT" or not start then
return line

20
plugins/xC/slack.lua → plugins/degesch/slack.lua
View File

@ -1,7 +1,7 @@
--
-- slack.lua: try to fix up UX when using the Slack IRC gateway
--
-- Copyright (c) 2017, Přemysl Eric Janouch <p@janouch.name>
-- Copyright (c) 2017, Přemysl Janouch <p@janouch.name>
--
-- Permission to use, copy, modify, and/or distribute this software for any
-- purpose with or without fee is hereby granted.
@ -51,7 +51,7 @@ local load_emoji = function (extra)
for k, v in extra:gmatch "([^,]+) ([^,]+)" do emoji[k] = v end
end
xC.setup_config {
degesch.setup_config {
servers = {
type = "string_array",
default = "\"\"",
@ -74,8 +74,8 @@ xC.setup_config {
-- 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
degesch.hook_irc (function (hook, server, line)
local msg, us = degesch.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
@ -88,10 +88,10 @@ xC.hook_irc (function (hook, server, line)
end)
-- Unfuck emoji and :nick!nick@irc.tinyspeck.com MODE #channel +v nick : active
xC.hook_irc (function (hook, server, line)
degesch.hook_irc (function (hook, server, line)
if not servers[server.name] then return line end
if unemojify then
local start, text = line:match ("^(.- PRIVMSG .- :)(.*)$")
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 .. ":"
@ -101,7 +101,7 @@ xC.hook_irc (function (hook, server, line)
end)
-- The gateway simply ignores the NAMES command altogether
xC.hook_input (function (hook, buffer, input)
degesch.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
@ -119,9 +119,9 @@ xC.hook_input (function (hook, buffer, input)
buffer:log (names)
end)
xC.hook_completion (function (hook, data, word)
local chan = xC.current_buffer.channel
local server = xC.current_buffer.server
degesch.hook_completion (function (hook, data, word)
local chan = degesch.current_buffer.channel
local server = degesch.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

2
plugins/xC/thin-cursor.lua → plugins/degesch/thin-cursor.lua
View File

@ -1,7 +1,7 @@
--
-- thin-cursor.lua: set a thin cursor
--
-- Copyright (c) 2016, Přemysl Eric Janouch <p@janouch.name>
-- Copyright (c) 2016, Přemysl Janouch <p@janouch.name>
--
-- Permission to use, copy, modify, and/or distribute this software for any
-- purpose with or without fee is hereby granted.

12
plugins/xC/utm-filter.lua → plugins/degesch/utm-filter.lua
View File

@ -1,7 +1,7 @@
--
-- utm-filter.lua: filter out Google Analytics bullshit etc. from URLs
-- utm-filter.lua: filter out Google Analytics bullshit from URLs
--
-- Copyright (c) 2015 - 2021, Přemysl Eric Janouch <p@janouch.name>
-- Copyright (c) 2015, Přemysl Janouch <p@janouch.name>
--
-- Permission to use, copy, modify, and/or distribute this software for any
-- purpose with or without fee is hereby granted.
@ -19,10 +19,6 @@
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,
@ -56,11 +52,11 @@ local do_text = function (text)
return text:gsub ('%f[%g]https?://%g+', do_single_url)
end
xC.hook_irc (function (hook, server, line)
degesch.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)
degesch.hook_input (function (hook, buffer, input)
return do_text (input)
end)

68
plugins/xC/prime.lua
View File

@ -1,68 +0,0 @@
--
-- 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)

8
plugins/xB/calc → plugins/zyklonb/calc
View File

@ -1,8 +1,8 @@
#!/usr/bin/env guile
xB calc plugin, basic Scheme evaluator
ZyklonB calc plugin, basic Scheme evaluator
Copyright 2016 Přemysl Eric Janouch
Copyright 2016 Přemysl Janouch
See the file LICENSE for licensing information.
!#
@ -77,7 +77,7 @@
(substring line 0 (- len 1)) line))))
(define (get-config name)
(send "XB get_config :" name)
(send "ZYKLONB get_config :" name)
(car (message-params (parse-message (get-line-crlf irc-input-port)))))
(define (extract-nick prefix)
@ -216,7 +216,7 @@
; --- Main loop ----------------------------------------------------------------
(define prefix (get-config "prefix"))
(send "XB register")
(send "ZYKLONB register")
(define (process msg)
(when (string-ci=? (message-command msg) "PRIVMSG")

8
plugins/xB/coin → plugins/zyklonb/coin
View File

@ -1,8 +1,8 @@
#!/usr/bin/env tclsh
#
# xB coin plugin, random number-based utilities
# ZyklonB coin plugin, random number-based utilities
#
# Copyright 2012, 2014 Přemysl Eric Janouch
# Copyright 2012, 2014 Přemysl Janouch
# See the file LICENSE for licensing information.
#
@ -37,7 +37,7 @@ proc parse {line} {
proc get_config {key} {
global msg
puts "XB get_config :$key"
puts "ZYKLONB 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 "XB register"
puts "ZYKLONB register"
set eightball [list \
"It is certain" \

8
plugins/xB/eval → plugins/zyklonb/eval
View File

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

10
plugins/xB/factoids → plugins/zyklonb/factoids
View File

@ -1,8 +1,8 @@
#!/usr/bin/env perl
#
# xB factoids plugin
# ZyklonB factoids plugin
#
# Copyright 2016 Přemysl Eric Janouch <p@janouch.name>
# Copyright 2016 Přemysl Janouch <p@janouch.name>
# See the file LICENSE for licensing information.
#
@ -24,18 +24,18 @@ sub parse ($) {
}
sub bot_print {
print "XB print :${\shift}";
print "ZYKLONB print :${\shift}";
}
# --- Initialization -----------------------------------------------------------
my %config;
for my $name (qw(prefix)) {
print "XB get_config :$name";
print "ZYKLONB get_config :$name";
$config{$name} = (parse <STDIN>)->{args}->[0];
}
print "XB register";
print "ZYKLONB register";
# --- Database -----------------------------------------------------------------
# Simple map of (factoid_name => [definitions]); all factoids are separated

10
plugins/xB/pomodoro → plugins/zyklonb/pomodoro
View File

@ -1,9 +1,9 @@
#!/usr/bin/env ruby
# coding: utf-8
#
# xB pomodoro plugin
# ZyklonB pomodoro plugin
#
# Copyright 2015 Přemysl Eric Janouch
# Copyright 2015 Přemysl Janouch
# See the file LICENSE for licensing information.
#
@ -206,7 +206,7 @@ def parse (line)
end
def bot_print (what)
print "XB print :#{what}"
print "ZYKLONB 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 "XB get_config :#{name}"
print "ZYKLONB get_config :#{name}"
_, _, _, _, args = *parse($stdin.gets.chomp)
$config[name] = args[0]
end
print "XB register"
print "ZYKLONB register"
# --- Plugin logic -------------------------------------------------------------

10
plugins/xB/script → plugins/zyklonb/script
View File

@ -1,8 +1,8 @@
#!/usr/bin/tcc -run -lm
//
// xB scripting plugin, using a custom stack-based language
// ZyklonB scripting plugin, using a custom stack-based language
//
// Copyright 2014 Přemysl Eric Janouch
// Copyright 2014 Přemysl 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 "XB print :script: "
#define BOT_PRINT "ZYKLONB print :script: "
static const char *
get_config (const char *key)
{
printf ("XB get_config :%s\r\n", key);
printf ("ZYKLONB 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 ("XB register\r\n");
printf ("ZYKLONB register\r\n");
struct message *msg;
while ((msg = read_message ()))
process_message (msg);

8
plugins/xB/seen → plugins/zyklonb/seen
View File

@ -1,8 +1,8 @@
#!/usr/bin/env lua
--
-- xB seen plugin
-- ZyklonB seen plugin
--
-- Copyright 2016 Přemysl Eric Janouch <p@janouch.name>
-- Copyright 2016 Přemysl Janouch <p@janouch.name>
-- See the file LICENSE for licensing information.
--
@ -26,7 +26,7 @@ function parse (line)
end
function get_config (name)
io.write ("XB get_config :", name, "\r\n")
io.write ("ZYKLONB get_config :", name, "\r\n")
return parse (io.read ()).params[1]
end
@ -34,7 +34,7 @@ end
io.output ():setvbuf ('line')
local prefix = get_config ('prefix')
io.write ("XB register\r\n")
io.write ("ZYKLONB register\r\n")
local db = {}
local db_filename = "seen.db"

4
plugins/xB/seen-import-xC.pl → plugins/zyklonb/seen-import-degesch.pl
View File

@ -1,7 +1,7 @@
#!/usr/bin/env perl
# Creates a database for the "seen" plugin from logs for xC.
# Creates a database for the "seen" plugin from logs for degesch.
# The results may not be completely accurate but are good for jumpstarting.
# Usage: ./seen-import-xC.pl LOG-FILE... > seen.db
# Usage: ./seen-import-degesch.pl LOG-FILE... > seen.db
use strict;
use warnings;

10
plugins/xB/youtube → plugins/zyklonb/youtube
View File

@ -1,8 +1,8 @@
#!/usr/bin/env python3
#
# xB YouTube plugin, displaying info about YouTube links
# ZyklonB YouTube plugin, displaying info about YouTube links
#
# Copyright 2014 - 2015, Přemysl Eric Janouch <p@janouch.name>
# Copyright 2014 - 2015, Přemysl 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 ("XB get_config :%s" % key)
print ("ZYKLONB get_config :%s" % key)
(_, _, _, _, args) = self.parse (sys.stdin.readline ())
return args[0]
def bot_print (self, what):
print ('XB print :%s' % what)
print ('ZYKLONB 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 ("XB register")
print ("ZYKLONB register")
for line in sys.stdin:
self.process_line (line)

12
test
View File

@ -1,16 +1,14 @@
#!/usr/bin/expect -f
# Very basic end-to-end testing for CI
set tempdir [exec mktemp -d]
set ::env(XDG_CONFIG_HOME) $tempdir
# Very basic end-to-end testing for Travis CI
# Run the daemon to test against
system ./xD --write-default-cfg
spawn ./xD -d
system ./kike --write-default-cfg
spawn ./kike -d
# 10 seconds is a bit too much
set timeout 5
spawn ./xC
spawn ./degesch
# Fuck this Tcl shit, I want the exit code
expect_after {
@ -29,7 +27,7 @@ expect "Option changed"
send "/disconnect\n"
expect "]"
send "/connect\n"
expect "Welcome to"
expect "Connection established"
# Try some chatting
send "/join #test\n"

26
test-nick-colors
View File

@ -1,26 +0,0 @@
#!/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' &

14
test-static
View File

@ -1,16 +1,8 @@
#!/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.
#
# In clang-query terms, the string we're interested in can be found through:
# set traversal IgnoreUnlessSpelledInSource
# set output dump
# match callExpr(callee(functionDecl(
# hasName("log_full"))),
# hasArgument(5, stringLiteral().bind("format")))
# However, the tool is too restricted to be useful in a shell script.
perl -n0777 - "$(dirname "$0")"/xC.c <<-'END'
while (/\blog_[^ ]+\s*\([^"()]*"[^"]*%\w[^"]*"/gm) {
# so the compiler cannot check it for us like it usually does
perl -n0777 - "$(dirname "$0")"/degesch.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);

104
xB.adoc
View File

@ -1,104 +0,0 @@
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.

127
xC.adoc
View File

@ -1,127 +0,0 @@
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)

210
xC.lxdr
View File

@ -1,210 +0,0 @@
// 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_INPUT,
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_INPUT:
string buffer_name;
string text;
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;
};

BIN
xC.webp
View File

Binary file not shown.
Side by Side

Before

Width:  |  Height:  |  Size: 34 KiB

29
xD-gen-replies.awk
View File

@ -1,29 +0,0 @@
#!/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 "};"
}

53
xD.adoc
View File

@ -1,53 +0,0 @@
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.

172
xF.c
View File

@ -1,172 +0,0 @@
/*
* 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;
}

34
xF.svg
View File

@ -1,34 +0,0 @@
<?xml version="1.0" encoding="UTF-8" standalone="no"?>
<svg version="1.1" width="48" height="48" viewBox="0 0 48 48"
xmlns="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>
Side by Side

Before

Width:  |  Height:  |  Size: 1.2 KiB

1
xK-version
View File

@ -1 +0,0 @@
1.5.0

45
xM/CMakeLists.txt
View File

@ -1,45 +0,0 @@
# Swift language support
cmake_minimum_required (VERSION 3.15)
file (READ ../xK-version project_version)
configure_file (../xK-version xK-version.tag COPYONLY)
string (STRIP "${project_version}" project_version)
# There were two issues when building this from the main CMakeLists.txt:
# a) renaming main.swift to xM.swift requires removing top-level statements,
# b) there is a "redefinition of module 'FFI'" error.
project (xM VERSION "${project_version}"
DESCRIPTION "Cocoa frontend for xC" LANGUAGES Swift)
set (root "${PROJECT_SOURCE_DIR}/..")
add_custom_command (OUTPUT xC-proto.swift
COMMAND env LC_ALL=C awk
-f ${root}/liberty/tools/lxdrgen.awk
-f ${root}/liberty/tools/lxdrgen-swift.awk
-v PrefixCamel=Relay
${root}/xC.lxdr > xC-proto.swift
DEPENDS
${root}/liberty/tools/lxdrgen.awk
${root}/liberty/tools/lxdrgen-swift.awk
${root}/xC.lxdr
COMMENT "Generating xC relay protocol code" VERBATIM)
set (MACOSX_BUNDLE_GUI_IDENTIFIER name.janouch.${PROJECT_NAME})
set (MACOSX_BUNDLE_ICON_FILE xM.icns)
# Avoid including binary files in the repository by generating icons in code.
# sips(1) + Javascript + iconutil(1) could probably also be used.
find_program (SWIFT_EXECUTABLE swift REQUIRED)
set (icon "${PROJECT_BINARY_DIR}/${MACOSX_BUNDLE_ICON_FILE}")
add_custom_command (OUTPUT "${icon}"
COMMAND ${SWIFT_EXECUTABLE} "${PROJECT_SOURCE_DIR}/gen-icon.swift" "${icon}"
DEPENDS gen-icon.swift
COMMENT "Generating xM application icon" VERBATIM)
set_source_files_properties ("${icon}" PROPERTIES
MACOSX_PACKAGE_LOCATION Resources)
# Other requirements: macOS 10.14 for Network, and macOS 11 for Logger.
set (CMAKE_Swift_LANGUAGE_VERSION 5)
add_executable (xM MACOSX_BUNDLE
main.swift "${icon}" "${PROJECT_BINARY_DIR}/xC-proto.swift")

96
xM/gen-icon.swift
View File

@ -1,96 +0,0 @@
// gen-icon.swift: generate a program icon for xM in the Apple icon format
//
// Copyright (c) 2023, Přemysl Eric Janouch <p@janouch.name>
// SPDX-License-Identifier: 0BSD
//
// NSGraphicsContext mostly just weirdly wraps over Quartz,
// so we do it all in Quartz directly.
import CoreGraphics
import Foundation
import ImageIO
import UniformTypeIdentifiers
// Apple uses something that's close to a "quintic superellipse" in their icons,
// but doesn't quite match. Either way, it looks better than rounded rectangles.
func addSquircle(context: CGContext, bounds: CGRect) {
context.move(to: CGPoint(x: bounds.maxX, y: bounds.midY))
for theta in stride(from: 0.0, to: .pi * 2, by: .pi / 1e4) {
let x = pow(abs(cos(theta)), 2 / 5.0) * bounds.width / 2
* CGFloat(signOf: cos(theta), magnitudeOf: 1) + bounds.midX
let y = pow(abs(sin(theta)), 2 / 5.0) * bounds.height / 2
* CGFloat(signOf: sin(theta), magnitudeOf: 1) + bounds.midY
context.addLine(to: CGPoint(x: x, y: y))
}
context.closePath()
}
func drawIcon(scale: CGFloat) -> CGImage? {
let size = CGSizeMake(1024, 1024)
let colorspace = CGColorSpaceCreateDeviceRGB()
let context = CGContext(data: nil,
width: Int(size.width * scale), height: Int(size.height * scale),
bitsPerComponent: 8, bytesPerRow: 0, space: colorspace,
bitmapInfo: CGImageAlphaInfo.premultipliedLast.rawValue)!
context.scaleBy(x: scale, y: scale)
let bounds = CGRectMake(100, 100, size.width - 200, size.height - 200)
addSquircle(context: context, bounds: bounds)
let squircle = context.path!
// Gradients don't draw shadows, so draw it separately.
context.saveGState()
context.setShadow(offset: CGSizeMake(0, -12).applying(context.ctm),
blur: 28 * scale, color: CGColor(gray: 0, alpha: 0.5))
context.setFillColor(CGColor(red: 1, green: 0x55p-8, blue: 0, alpha: 1))
context.fillPath()
context.restoreGState()
context.saveGState()
context.addPath(squircle)
context.clip()
context.drawLinearGradient(
CGGradient(colorsSpace: colorspace, colors: [
CGColor(red: 1, green: 0x00p-8, blue: 0, alpha: 1),
CGColor(red: 1, green: 0xaap-8, blue: 0, alpha: 1)
] as CFArray, locations: [0, 1])!,
start: CGPointMake(0, 100), end: CGPointMake(0, size.height - 100),
options: CGGradientDrawingOptions(rawValue: 0))
context.restoreGState()
context.move(to: CGPoint(x: size.width * 0.30, y: size.height * 0.30))
context.addLine(to: CGPoint(x: size.width * 0.30, y: size.height * 0.70))
context.addLine(to: CGPoint(x: size.width * 0.575, y: size.height * 0.425))
context.move(to: CGPoint(x: size.width * 0.70, y: size.height * 0.30))
context.addLine(to: CGPoint(x: size.width * 0.70, y: size.height * 0.70))
context.addLine(to: CGPoint(x: size.width * 0.425, y: size.height * 0.425))
context.setLineWidth(80)
context.setLineCap(.round)
context.setLineJoin(.round)
context.setStrokeColor(CGColor.white)
context.strokePath()
return context.makeImage()
}
if CommandLine.arguments.count != 2 {
print("Usage: \(CommandLine.arguments.first!) OUTPUT.icns")
exit(EXIT_FAILURE)
}
let filename = CommandLine.arguments[1]
let macOSSizes: Array<CGFloat> = [16, 32, 128, 256, 512]
let icns = CGImageDestinationCreateWithURL(
URL(fileURLWithPath: filename) as CFURL,
UTType.icns.identifier as CFString, macOSSizes.count * 2, nil)!
for size in macOSSizes {
CGImageDestinationAddImage(icns, drawIcon(scale: size / 1024.0)!, nil)
CGImageDestinationAddImage(icns, drawIcon(scale: size / 1024.0 * 2)!, [
kCGImagePropertyDPIWidth: 144,
kCGImagePropertyDPIHeight: 144,
] as CFDictionary)
}
if !CGImageDestinationFinalize(icns) {
print("ICNS finalization failed.")
exit(EXIT_FAILURE)
}

1372
xM/main.swift
View File

File diff suppressed because it is too large Load Diff

3
xN/.gitignore vendored
View File

@ -1,3 +0,0 @@
/xN
/xN.1
/irc.go

21
xN/Makefile
View File

@ -1,21 +0,0 @@
.POSIX:
.SUFFIXES:
AWK = env LC_ALL=C awk
outputs = irc.go xN xN.1
all: $(outputs)
# If we want to keep module dependencies separate, we don't have many options.
# Symlinking seems to work good enough.
irc.go: ../xS/irc.go
ln -sf ../xS/irc.go $@
xN: xN.go ../xK-version irc.go
go build -ldflags "-X 'main.projectVersion=$$(cat ../xK-version)'" -o $@
xN.1: ../xK-version ../liberty/tools/asciiman.awk xN.adoc
env "asciidoc-release-version=$$(cat ../xK-version)" \
$(AWK) -f ../liberty/tools/asciiman.awk xN.adoc > $@
test: all
go test
clean:
rm -f $(outputs)

3
xN/go.mod
View File

@ -1,3 +0,0 @@
module janouch.name/xK/xN
go 1.19

86
xN/xN.adoc
View File

@ -1,86 +0,0 @@
xN(1)
=====
:doctype: manpage
:manmanual: xK Manual
:mansource: xK {release-version}
Name
----
xN - IRC notifier
Synopsis
--------
*xN* [_OPTION_]... IRC-URL...
Description
-----------
*xN* is a simple IRC notifier, sending the text it receives on its standard
input to all IRC targets specified by its command line arguments.
The input text is forced to validate as UTF-8, and it is _not_ split
automatically to comply with the maximum IRC message length.
Thus, make sure to make the lines short, or they will be trimmed by the servers.
*xN* does not attempt to appease flood detectors.
Options
-------
*-debug*::
Print incoming IRC traffic, which may help in debugging any issues.
*-version*::
Output version information and exit.
URL format
----------
*xN* accepts URLs describing IRC users and channels, roughly as specified by
the Internet Draft _draft-butcher-irc-url-04.txt_. Note, however, that close
to no validation is done on these, and you should not pass URLs from untrusted
sources, so as to avoid command or parameter injection.
Any provided username will be propagated to the nickname, username,
and realname. The default value for these is the name of your system user.
As an extension, you may use the following options:
*skipjoin*::
Do not JOIN channels before sending messages to them.
This requires channels to allow external messages
(which are disabled by channel mode *+n*).
*usenotice*::
Send a NOTICE rather than a PRIVMSG, which distinguishes automated messages,
and is more appropriate for bots.
Examples
--------
$ uptime | xN 'irc://uptime@localhost/%23watch?skipjoin&usenotice'
Send *uptime*(1) information as an external notice to channel *#watch*
on the local server, using the standard port *6667*.
$ fortune -s | xN ircs://ohayou@irc.libera.chat/john,isuser
Greet user *john* with a fortune for this day. In compliance with _RFC 7194_,
the default TLS port is assumed to be *6697*.
$ xN 'ircs://agent:Password123@irc.cia.gov:1337/#hq?key=123456' <<EOF
The red fox trots quietly at midnight.
EOF
Connect over TLS to *irc.cia.gov* on port *1337*, use *Password123*
as the server password, register as user *agent*,
join channel *#hq* using the channel key *123456*,
and send a very secret message.
Reporting bugs
--------------
Use https://git.janouch.name/p/xK to report bugs, request features,
or submit pull requests.
See also
--------
_Uniform Resource Locator Schemes for Internet Relay Chat Entities_,
https://datatracker.ietf.org/doc/html/draft-butcher-irc-url-04[].
_Default Port for Internet Relay Chat (IRC) via TLS/SSL_,
https://datatracker.ietf.org/doc/html/rfc7194[].

279
xN/xN.go
View File

@ -1,279 +0,0 @@
//
// Copyright (c) 2024, 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.
//
// xN is a simple IRC notifier.
package main
import (
"bufio"
"bytes"
"crypto/tls"
"errors"
"flag"
"fmt"
"io"
"log"
"net"
"net/url"
"os"
"os/user"
"strconv"
"strings"
)
const projectName = "xN"
var projectVersion = "?"
var debugMode = false
type parameters struct {
conn net.Conn // underlying network connection
username string // nickname + username + realname
password string // server password
target string // where to send text
isuser bool // the target is a user rather than a channel
chankey string // channel key
skipjoin bool // whether to send external messages to channels
usenotice bool // whether to use NOTICE rather than PRIVMSG
message []string // lines of the message to send
}
func (p *parameters) send(command string, args ...string) error {
var buf bytes.Buffer
buf.WriteString(command)
for i, arg := range args {
buf.WriteRune(' ')
if i+1 == len(args) {
buf.WriteRune(':')
}
buf.WriteString(arg)
}
buf.WriteString("\r\n")
_, err := p.conn.Write(buf.Bytes())
return err
}
const (
rplWELCOME = "001"
errNICKNAMEINUSE = "433"
)
func notify(p *parameters) error {
// The intro should comfortably fit in the TCP send buffer whole.
if p.password != "" {
p.send("PASS", p.password)
}
p.send("USER", p.username, "0", "*", p.username)
p.send("NICK", p.username)
scanner, nickCounter, issue := bufio.NewScanner(p.conn), 1, ""
for scanner.Scan() {
if debugMode {
log.Println(scanner.Text())
}
m := ircParseMessage(scanner.Text())
switch m.command {
case "PING":
p.send("PONG", m.params...)
case rplWELCOME:
if !p.isuser && !p.skipjoin {
if p.chankey != "" {
p.send("JOIN", p.target, p.chankey)
} else {
p.send("JOIN", p.target)
}
}
for _, line := range p.message {
if p.usenotice {
p.send("NOTICE", p.target, line)
} else {
p.send("PRIVMSG", p.target, line)
}
}
p.send("QUIT")
case errNICKNAMEINUSE:
p.send("NICK", fmt.Sprintf("%s%d", p.username, nickCounter))
nickCounter++
default:
// Prevent hanging on unsuccessful registrations.
numeric, _ := strconv.Atoi(m.command)
if numeric >= 400 && numeric <= 599 {
if len(m.params) > 1 {
issue = strings.Join(m.params[1:], " ")
} else {
issue = strings.Join(m.params, " ")
}
p.send("QUIT")
}
}
}
if err := scanner.Err(); err != nil {
return err
}
if issue != "" {
return errors.New(issue)
}
return nil
}
func parse(rawURL string, text []byte) (
p parameters, connect func() (net.Conn, error), err error) {
u, err := url.Parse(rawURL)
if err != nil {
return p, nil, err
} else if !u.IsAbs() || u.Opaque != "" {
return p, nil, errors.New("need an absolute URL")
} else if u.Path == "/" && u.Fragment != "" {
// Try to handle the common but degenerate case.
fragment := "%23" + u.Fragment
u.Fragment, u.RawFragment = "", ""
if u, err = url.Parse(u.String() + fragment); err != nil {
return p, nil, err
}
}
// Figure out registration details.
p.username = projectName
if u, _ := user.Current(); u != nil {
p.username = u.Username
}
if u.User.Username() != "" {
p.username = u.User.Username()
}
p.password, _ = u.User.Password()
// Figure out the target, which for our intents must accept messages.
path, _ := strings.CutPrefix(u.Path, "/")
elements := strings.Split(path, ",")
if path == "" || elements[0] == "" {
return p, nil, errors.New("unspecified entity")
}
// The last entity type wins.
p.target, p.isuser = elements[0], false
for _, typ := range elements[1:] {
switch typ {
case "isuser":
p.isuser = true
case "ischannel":
p.isuser = false
case "isserver":
// We do not support network names, and this is the default.
default:
return p, nil, errors.New("unsupported type: " + typ)
}
}
if p.isuser {
if i := strings.IndexAny(p.target, "!@"); i != -1 {
p.target = p.target[:i]
}
} else if !strings.HasPrefix(p.target, "#") {
// TODO(p): We should consult RPL_ISUPPORT rather than guess,
// though other prefixes are rare.
p.target = "#" + p.target
}
// Note that the draft RFC wants these to be case-insensitive.
p.chankey = u.Query().Get("key")
// Being able to skip channel join is our own requirement and invention,
// as are notices (names taken from Travis CI configuration).
p.skipjoin = u.Query().Has("skipjoin")
p.usenotice = u.Query().Has("usenotice")
// Ensure valid LF-separated UTF-8, and split it at lines.
sanitized := strings.ReplaceAll(string([]rune(string(text))), "\r", "\n")
for _, line := range strings.Split(sanitized, "\n") {
if line != "" {
p.message = append(p.message, line)
}
}
hostname, port := u.Hostname(), u.Port()
switch u.Scheme {
case "irc":
if port == "" {
port = "6667"
}
connect = func() (net.Conn, error) {
return net.Dial("tcp", net.JoinHostPort(hostname, port))
}
case "ircs":
if port == "" {
port = "6697"
}
connect = func() (net.Conn, error) {
return tls.Dial("tcp", net.JoinHostPort(hostname, port), nil)
}
default:
err = errors.New("unsupported scheme: " + u.Scheme)
}
return
}
// notifyByURL sends the given text to the IRC server specified by a URL.
// See draft-butcher-irc-url-04.txt for the URL scheme specification
// this function loosely follows.
func notifyByURL(rawURL string, text []byte) error {
p, connect, err := parse(rawURL, text)
if p.conn, err = connect(); err != nil {
return err
}
defer p.conn.Close()
return notify(&p)
}
func main() {
flag.BoolVar(&debugMode, "debug", false, "run in verbose debug mode")
version := flag.Bool("version", false, "show version and exit")
flag.Usage = func() {
f := flag.CommandLine.Output()
fmt.Fprintf(f, "Usage: %s [OPTION]... URL...\n", os.Args[0])
flag.PrintDefaults()
}
flag.Parse()
if flag.NArg() < 1 {
flag.Usage()
os.Exit(2)
}
if *version {
fmt.Printf("%s %s\n", projectName, projectVersion)
return
}
text, err := io.ReadAll(os.Stdin)
if err != nil {
log.Fatalln(err)
}
status := 0
for _, rawURL := range flag.Args() {
if err := notifyByURL(rawURL, text); err != nil {
status = 1
var ue *url.Error
if errors.As(err, &ue) {
log.Println(err)
} else {
log.Printf("notify %q: %s\n", rawURL, err)
}
}
}
os.Exit(status)
}

98
xN/xN_test.go
View File

@ -1,98 +0,0 @@
//
// Copyright (c) 2024, 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.
//
package main
import "testing"
func TestParseURL(t *testing.T) {
for _, rawURL := range []string{
`irc:server/channel`,
`irc://server/channel,isnetwork`,
`ircs://ssl.ircnet.io`,
`ircs://ssl.ircnet.io/`,
`http://server/path`,
} {
if _, _, err := parse(rawURL, nil); err == nil {
t.Errorf("%q should not parse\n", rawURL)
}
}
for _, test := range []struct {
rawURL string
p parameters
}{
{
rawURL: `irc://uptime@localhost/%23watch?skipjoin&usenotice`,
p: parameters{
username: "uptime",
target: "#watch",
skipjoin: true,
usenotice: true,
},
},
{
rawURL: `ircs://ohayou@irc.libera.chat/john,isuser,isserver`,
p: parameters{
username: "ohayou",
target: "john",
isuser: true,
},
},
{
rawURL: `ircs://agent:Password123@irc.cia.gov:1337/#hq?key=123456`,
p: parameters{
username: "agent",
password: "Password123",
target: "#hq",
chankey: "123456",
},
},
} {
p, _, err := parse(test.rawURL, nil)
if err != nil {
t.Errorf("%q should parse, got: %s\n", test.rawURL, err)
continue
}
if p.username != test.p.username {
t.Errorf("%q: username: %v ≠ %v\n",
test.rawURL, p.username, test.p.username)
}
if p.password != test.p.password {
t.Errorf("%q: password: %v ≠ %v\n",
test.rawURL, p.password, test.p.password)
}
if p.target != test.p.target {
t.Errorf("%q: target: %v ≠ %v\n",
test.rawURL, p.target, test.p.target)
}
if p.isuser != test.p.isuser {
t.Errorf("%q: isuser: %v ≠ %v\n",
test.rawURL, p.isuser, test.p.isuser)
}
if p.chankey != test.p.chankey {
t.Errorf("%q: chankey: %v ≠ %v\n",
test.rawURL, p.chankey, test.p.chankey)
}
if p.skipjoin != test.p.skipjoin {
t.Errorf("%q: skipjoin: %v ≠ %v\n",
test.rawURL, p.skipjoin, test.p.skipjoin)
}
if p.usenotice != test.p.usenotice {
t.Errorf("%q: usenotice: %v ≠ %v\n",
test.rawURL, p.usenotice, test.p.usenotice)
}
}
}

BIN
xP.webp
View File

Binary file not shown.
Side by Side

Before

Width:  |  Height:  |  Size: 42 KiB

4
xP/.gitignore vendored
View File

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

21
xP/Makefile
View File

@ -1,21 +0,0 @@
.POSIX:
.SUFFIXES:
AWK = env LC_ALL=C awk
tools = ../liberty/tools
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: $(tools)/lxdrgen.awk $(tools)/lxdrgen-go.awk ../xC.lxdr
$(AWK) -f $(tools)/lxdrgen.awk -f $(tools)/lxdrgen-go.awk \
-v PrefixCamel=Relay ../xC.lxdr > $@
public/proto.js: $(tools)/lxdrgen.awk $(tools)/lxdrgen-mjs.awk ../xC.lxdr
$(AWK) -f $(tools)/lxdrgen.awk -f $(tools)/lxdrgen-mjs.awk ../xC.lxdr > $@
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)

89
xP/gen-ircfmt.awk
View File

@ -1,89 +0,0 @@
# 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)
}

10
xP/go.mod
View File

@ -1,10 +0,0 @@
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
)

62
xP/go.sum
View File

@ -1,62 +0,0 @@
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=

BIN
xP/public/ircfmt.woff2
View File

Binary file not shown.

260
xP/public/xP.css
View File

@ -1,260 +0,0 @@
@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:hover {
background: #f8f8f8;
}
.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;
}

1190
xP/public/xP.js
View File

File diff suppressed because it is too large Load Diff

308
xP/xP.go
View File

@ -1,308 +0,0 @@
// 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"
"strings"
"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) {
opts := &websocket.AcceptOptions{
InsecureSkipVerify: true,
CompressionMode: websocket.CompressionContextTakeover,
// This is for the payload; set higher to avoid overhead.
CompressionThreshold: 64 << 10,
}
// AppleWebKit can be broken with compression.
if agent := r.UserAgent(); strings.Contains(agent, " Version/") &&
(strings.HasPrefix(agent, "Mozilla/5.0 (Macintosh; ") ||
strings.HasPrefix(agent, "Mozilla/5.0 (iPhone; ")) {
opts.CompressionMode = websocket.CompressionDisabled
}
ws, err := websocket.Accept(w, r, opts)
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.Fatalln(s.ListenAndServe())
}

3
xS/.gitignore vendored
View File

@ -1,3 +0,0 @@
/xS
/xS-replies.go
/xS.1

18
xS/Makefile
View File

@ -1,18 +0,0 @@
.POSIX:
.SUFFIXES:
AWK = env LC_ALL=C awk
outputs = xS xS-replies.go xS.1
all: $(outputs)
xS: xS.go ../xK-version xS-replies.go
go build -ldflags "-X 'main.projectVersion=$$(cat ../xK-version)'" -o $@
xS-replies.go: xS-gen-replies.awk xS-replies
$(AWK) -f xS-gen-replies.awk xS-replies > $@
xS.1: ../xK-version ../liberty/tools/asciiman.awk xS.adoc
env "asciidoc-release-version=$$(cat ../xK-version)" \
$(AWK) -f ../liberty/tools/asciiman.awk xS.adoc > $@
test: all
go test
clean:
rm -f $(outputs)

3
xS/go.mod
View File

@ -1,3 +0,0 @@
module janouch.name/xK/xS
go 1.19

132
xS/irc.go
View File

@ -1,132 +0,0 @@
package main
import (
"path/filepath"
"regexp"
"strings"
)
func ircToLower(c byte) byte {
switch c {
case '[':
return '{'
case ']':
return '}'
case '\\':
return '|'
case '~':
return '^'
}
if c >= 'A' && c <= 'Z' {
return c + ('a' - 'A')
}
return c
}
func ircToUpper(c byte) byte {
switch c {
case '{':
return '['
case '}':
return ']'
case '|':
return '\\'
case '^':
return '~'
}
if c >= 'a' && c <= 'z' {
return c - ('a' - 'A')
}
return c
}
// Convert identifier to a canonical form for case-insensitive comparisons.
// ircToUpper is used so that statically initialized maps can be in uppercase.
func ircToCanon(ident string) string {
var canon []byte
for _, c := range []byte(ident) {
canon = append(canon, ircToUpper(c))
}
return string(canon)
}
func ircEqual(s1, s2 string) bool {
return ircToCanon(s1) == ircToCanon(s2)
}
func ircFnmatch(pattern string, s string) bool {
pattern, s = ircToCanon(pattern), ircToCanon(s)
// FIXME: This should not support [] ranges and handle '/' specially.
// We could translate the pattern to a regular expression.
matched, _ := filepath.Match(pattern, s)
return matched
}
var reMsg = regexp.MustCompile(
`^(?:@([^ ]*) +)?(?::([^! ]*)(?:!([^@]*)@([^ ]*))? +)?([^ ]+)(.*)?$`)
var reArgs = regexp.MustCompile(`:.*| [^: ][^ ]*`)
type message struct {
tags map[string]string // IRC 3.2 message tags
nick string // optional nickname
user string // optional username
host string // optional hostname or IP address
command string // command name
params []string // arguments
}
func ircUnescapeMessageTag(value string) string {
var buf []byte
escape := false
for i := 0; i < len(value); i++ {
if escape {
switch value[i] {
case ':':
buf = append(buf, ';')
case 's':
buf = append(buf, ' ')
case 'r':
buf = append(buf, '\r')
case 'n':
buf = append(buf, '\n')
default:
buf = append(buf, value[i])
}
escape = false
} else if value[i] == '\\' {
escape = true
} else {
buf = append(buf, value[i])
}
}
return string(buf)
}
func ircParseMessageTags(tags string, out map[string]string) {
for _, tag := range strings.Split(tags, ";") {
if tag == "" {
// Ignore empty.
} else if equal := strings.IndexByte(tag, '='); equal < 0 {
out[tag] = ""
} else {
out[tag[:equal]] = ircUnescapeMessageTag(tag[equal+1:])
}
}
}
func ircParseMessage(line string) *message {
m := reMsg.FindStringSubmatch(line)
if m == nil {
return nil
}
msg := message{nil, m[2], m[3], m[4], m[5], nil}
if m[1] != "" {
msg.tags = make(map[string]string)
ircParseMessageTags(m[1], msg.tags)
}
for _, x := range reArgs.FindAllString(m[6], -1) {
msg.params = append(msg.params, x[1:])
}
return &msg
}

20
xS/xS-gen-replies.awk
View File

@ -1,20 +0,0 @@
#!/usr/bin/awk -f
/^[0-9]+ *(ERR|RPL)_[A-Z]+ *".*"$/ {
match($0, /".*"/)
ids[$1] = $2
texts[$2] = substr($0, RSTART, RLENGTH)
}
END {
print "package main"
print ""
print "const ("
for (i in ids)
printf("\t%s = %s\n", ids[i], i)
print ")"
print ""
print "var defaultReplies = map[int]string{"
for (i in ids)
print "\t" ids[i] ": " texts[ids[i]] ","
print "}"
}

87
xS/xS-replies
View File

@ -1,87 +0,0 @@
1 RPL_WELCOME ":Welcome to the Internet Relay Network %s!%s@%s"
2 RPL_YOURHOST ":Your host is %s, running version %s"
3 RPL_CREATED ":This server was created %s"
4 RPL_MYINFO "%s %s %s %s"
5 RPL_ISUPPORT "%s :are supported by this server"
211 RPL_STATSLINKINFO "%s %d %d %d %d %d %d"
212 RPL_STATSCOMMANDS "%s %d %d %d"
219 RPL_ENDOFSTATS "%c :End of STATS report"
221 RPL_UMODEIS "+%s"
242 RPL_STATSUPTIME ":Server Up %d days %d:%02d:%02d"
251 RPL_LUSERCLIENT ":There are %d users and %d services on %d servers"
252 RPL_LUSEROP "%d :operator(s) online"
253 RPL_LUSERUNKNOWN "%d :unknown connection(s)"
254 RPL_LUSERCHANNELS "%d :channels formed"
255 RPL_LUSERME ":I have %d clients and %d servers"
301 RPL_AWAY "%s :%s"
302 RPL_USERHOST ":%s"
303 RPL_ISON ":%s"
305 RPL_UNAWAY ":You are no longer marked as being away"
306 RPL_NOWAWAY ":You have been marked as being away"
311 RPL_WHOISUSER "%s %s %s * :%s"
312 RPL_WHOISSERVER "%s %s :%s"
313 RPL_WHOISOPERATOR "%s :is an IRC operator"
314 RPL_WHOWASUSER "%s %s %s * :%s"
315 RPL_ENDOFWHO "%s :End of WHO list"
317 RPL_WHOISIDLE "%s %d :seconds idle"
318 RPL_ENDOFWHOIS "%s :End of WHOIS list"
319 RPL_WHOISCHANNELS "%s :%s"
322 RPL_LIST "%s %d :%s"
323 RPL_LISTEND ":End of LIST"
324 RPL_CHANNELMODEIS "%s +%s"
329 RPL_CREATIONTIME "%s %d"
331 RPL_NOTOPIC "%s :No topic is set"
332 RPL_TOPIC "%s :%s"
333 RPL_TOPICWHOTIME "%s %s %d"
341 RPL_INVITING "%s %s"
346 RPL_INVITELIST "%s %s"
347 RPL_ENDOFINVITELIST "%s :End of channel invite list"
348 RPL_EXCEPTLIST "%s %s"
349 RPL_ENDOFEXCEPTLIST "%s :End of channel exception list"
351 RPL_VERSION "%s.%d %s :%s"
352 RPL_WHOREPLY "%s %s %s %s %s %s :%d %s"
353 RPL_NAMREPLY "%c %s :%s"
364 RPL_LINKS "%s %s :%d %s"
365 RPL_ENDOFLINKS "%s :End of LINKS list"
366 RPL_ENDOFNAMES "%s :End of NAMES list"
367 RPL_BANLIST "%s %s"
368 RPL_ENDOFBANLIST "%s :End of channel ban list"
369 RPL_ENDOFWHOWAS "%s :End of WHOWAS"
372 RPL_MOTD ":- %s"
375 RPL_MOTDSTART ":- %s Message of the day - "
376 RPL_ENDOFMOTD ":End of MOTD command"
391 RPL_TIME "%s :%s"
401 ERR_NOSUCHNICK "%s :No such nick/channel"
402 ERR_NOSUCHSERVER "%s :No such server"
403 ERR_NOSUCHCHANNEL "%s :No such channel"
404 ERR_CANNOTSENDTOCHAN "%s :Cannot send to channel"
406 ERR_WASNOSUCHNICK "%s :There was no such nickname"
409 ERR_NOORIGIN ":No origin specified"
410 ERR_INVALIDCAPCMD "%s :%s"
411 ERR_NORECIPIENT ":No recipient given (%s)"
412 ERR_NOTEXTTOSEND ":No text to send"
421 ERR_UNKNOWNCOMMAND "%s: Unknown command"
422 ERR_NOMOTD ":MOTD File is missing"
423 ERR_NOADMININFO "%s :No administrative info available"
431 ERR_NONICKNAMEGIVEN ":No nickname given"
432 ERR_ERRONEOUSNICKNAME "%s :Erroneous nickname"
433 ERR_NICKNAMEINUSE "%s :Nickname is already in use"
441 ERR_USERNOTINCHANNEL "%s %s :They aren't on that channel"
442 ERR_NOTONCHANNEL "%s :You're not on that channel"
443 ERR_USERONCHANNEL "%s %s :is already on channel"
445 ERR_SUMMONDISABLED ":SUMMON has been disabled"
446 ERR_USERSDISABLED ":USERS has been disabled"
451 ERR_NOTREGISTERED ":You have not registered"
461 ERR_NEEDMOREPARAMS "%s :Not enough parameters"
462 ERR_ALREADYREGISTERED ":Unauthorized command (already registered)"
467 ERR_KEYSET "%s :Channel key already set"
471 ERR_CHANNELISFULL "%s :Cannot join channel (+l)"
472 ERR_UNKNOWNMODE "%c :is unknown mode char to me for %s"
473 ERR_INVITEONLYCHAN "%s :Cannot join channel (+i)"
474 ERR_BANNEDFROMCHAN "%s :Cannot join channel (+b)"
475 ERR_BADCHANNELKEY "%s :Cannot join channel (+k)"
476 ERR_BADCHANMASK "%s :Bad Channel Mask"
481 ERR_NOPRIVILEGES ":Permission Denied- You're not an IRC operator"
482 ERR_CHANOPRIVSNEEDED "%s :You're not channel operator"
501 ERR_UMODEUNKNOWNFLAG ":Unknown MODE flag"
502 ERR_USERSDONTMATCH ":Cannot change mode for other users"

57
xS/xS.adoc
View File

@ -1,57 +0,0 @@
xS(1)
=====
:doctype: manpage
:manmanual: xK Manual
:mansource: xK {release-version}
Name
----
xS - IRC daemon
Synopsis
--------
*xS* [_OPTION_]...
Description
-----------
*xS* 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
-------
*-debug*::
Do not daemonize, print more information on the standard error stream
to help debug various issues.
*-systemd*::
Log using the format specified in *sd-daemon*(3).
*-h*, *-help*::
Display a help message and exit.
*-version*::
Output version information and exit.
*-writedefaultcfg*::
Write a configuration file with defaults, show its path and exit.
+
The file will be appropriately commented.
Files
-----
*xS* follows the XDG Base Directory Specification.
_~/.config/xS/xS.conf_::
_/etc/xdg/xS/xS.conf_::
The daemon's configuration file. Use the *-writedefaultcfg* 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.
See also
--------
*sd-daemon*(3)

3399
xS/xS.go
View File

File diff suppressed because it is too large Load Diff

168
xS/xS_test.go
View File

@ -1,168 +0,0 @@
//
// Copyright (c) 2015 - 2018, 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.
//
package main
import (
"crypto/tls"
"net"
"os"
"reflect"
"syscall"
"testing"
)
func TestSplitString(t *testing.T) {
var splitStringTests = []struct {
s, delims string
ignoreEmpty bool
result []string
}{
{",a,,bc", ",", false, []string{"", "a", "", "bc"}},
{",a,,bc", ",", true, []string{"a", "bc"}},
{"a,;bc,", ",;", false, []string{"a", "", "bc", ""}},
{"a,;bc,", ",;", true, []string{"a", "bc"}},
{"", ",", false, []string{""}},
{"", ",", true, nil},
}
for i, d := range splitStringTests {
got := splitString(d.s, d.delims, d.ignoreEmpty)
if !reflect.DeepEqual(got, d.result) {
t.Errorf("case %d: %v should be %v\n", i, got, d.result)
}
}
}
func socketpair() (*os.File, *os.File, error) {
pair, err := syscall.Socketpair(syscall.AF_UNIX, syscall.SOCK_STREAM, 0)
if err != nil {
return nil, nil, err
}
// See go #24331, this makes 1.11 use the internal poller
// while there wasn't a way to achieve that before.
if err := syscall.SetNonblock(int(pair[0]), true); err != nil {
return nil, nil, err
}
if err := syscall.SetNonblock(int(pair[1]), true); err != nil {
return nil, nil, err
}
fa := os.NewFile(uintptr(pair[0]), "a")
if fa == nil {
return nil, nil, os.ErrInvalid
}
fb := os.NewFile(uintptr(pair[1]), "b")
if fb == nil {
fa.Close()
return nil, nil, os.ErrInvalid
}
return fa, fb, nil
}
func TestDetectTLS(t *testing.T) {
detectTLSFromFunc := func(t *testing.T, writer func(net.Conn)) bool {
// net.Pipe doesn't use file descriptors, we need a socketpair.
sockA, sockB, err := socketpair()
if err != nil {
t.Fatal(err)
}
defer sockA.Close()
defer sockB.Close()
fcB, err := net.FileConn(sockB)
if err != nil {
t.Fatal(err)
}
go writer(fcB)
fcA, err := net.FileConn(sockA)
if err != nil {
t.Fatal(err)
}
sc, err := fcA.(syscall.Conn).SyscallConn()
if err != nil {
t.Fatal(err)
}
return detectTLS(sc)
}
t.Run("SSL_2.0", func(t *testing.T) {
if !detectTLSFromFunc(t, func(fc net.Conn) {
// The obsolete, useless, unsupported SSL 2.0 record format.
_, _ = fc.Write([]byte{0x80, 0x01, 0x01})
}) {
t.Error("could not detect SSL")
}
})
t.Run("crypto_tls", func(t *testing.T) {
if !detectTLSFromFunc(t, func(fc net.Conn) {
conn := tls.Client(fc, &tls.Config{InsecureSkipVerify: true})
_ = conn.Handshake()
}) {
t.Error("could not detect TLS")
}
})
t.Run("text", func(t *testing.T) {
if detectTLSFromFunc(t, func(fc net.Conn) {
_, _ = fc.Write([]byte("ПРЕВЕД"))
}) {
t.Error("detected UTF-8 as TLS")
}
})
t.Run("EOF", func(t *testing.T) {
type connCloseWriter interface {
net.Conn
CloseWrite() error
}
if detectTLSFromFunc(t, func(fc net.Conn) {
_ = fc.(connCloseWriter).CloseWrite()
}) {
t.Error("detected EOF as TLS")
}
})
}
func TestIRC(t *testing.T) {
msg := ircParseMessage(
`@first=a\:\s\r\n\\;2nd :srv hi there :good m8 :how are you?`)
if !reflect.DeepEqual(msg.tags, map[string]string{
"first": "a; \r\n\\",
"2nd": "",
}) {
t.Error("tags parsed incorrectly")
}
if msg.nick != "srv" || msg.user != "" || msg.host != "" {
t.Error("server name parsed incorrectly")
}
if msg.command != "hi" {
t.Error("command name parsed incorrectly")
}
if !reflect.DeepEqual(msg.params,
[]string{"there", "good m8 :how are you?"}) {
t.Error("params parsed incorrectly")
}
if !ircEqual("[fag]^", "{FAG}~") {
t.Error("string case comparison not according to RFC 2812")
}
// TODO: More tests.
}

11
xW/.clang-format
View File

@ -1,11 +0,0 @@
BasedOnStyle: LLVM
ColumnLimit: 80
IndentWidth: 4
TabWidth: 4
UseTab: ForContinuationAndIndentation
AlwaysBreakAfterReturnType: AllDefinitions
BreakBeforeBraces: Linux
SpaceAfterCStyleCast: true
AlignAfterOpenBracket: DontAlign
AlignOperands: DontAlign
SpacesBeforeTrailingComments: 2

85
xW/CMakeLists.txt
View File

@ -1,85 +0,0 @@
# The last version with Windows XP support is 3.13, we want to keep that
cmake_minimum_required (VERSION 3.10)
file (READ ../xK-version project_version)
configure_file (../xK-version xK-version.tag COPYONLY)
string (STRIP "${project_version}" project_version)
# This is an entirely separate CMake project--the main executables only build
# on Windows within Cygwin, and this Windows executable only builds on Linux
# cross-compiled, so you'd want to build them independently anyway.
project (xW VERSION "${project_version}"
DESCRIPTION "Win32 frontend for xC" LANGUAGES CXX)
set (CMAKE_CXX_STANDARD 17)
add_definitions (-DUNICODE -D_UNICODE)
add_compile_options ("$<$<CXX_COMPILER_ID:MSVC>:/utf-8>")
add_compile_options ("$<$<CXX_COMPILER_ID:GNU>:-Wall;-Wextra>")
add_compile_options ("$<$<CXX_COMPILER_ID:Clang>:-Wall;-Wextra>")
add_link_options ("$<$<CXX_COMPILER_ID:GNU>:-static;-municode>")
add_link_options ("$<$<CXX_COMPILER_ID:Clang>:-static;-municode>")
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})
# Produce a beep sample
if (NOT ${CMAKE_VERSION} VERSION_LESS 3.18.0)
set (find_program_REQUIRE REQUIRED)
endif ()
find_program (sox_EXECUTABLE sox ${find_program_REQUIRE})
add_custom_command (OUTPUT beep.wav
COMMAND ${sox_EXECUTABLE} -b 16 -Dr 44100 -n beep.wav
synth 0.1 0 25 triangle 800 vol 0.5 fade t 0 -0 0.005 pad 0 0.05
COMMENT "Generating a beep sample" VERBATIM)
# Rasterize SVG icons
set (root "${PROJECT_SOURCE_DIR}/..")
set (CMAKE_MODULE_PATH ${root}/liberty/cmake)
include (IconUtils)
set (icon_ico_list)
foreach (icon xW xW-highlighted)
set (icon_png_list)
foreach (icon_size 16 32 48)
icon_to_png (${icon} ${PROJECT_SOURCE_DIR}/${icon}.svg
${icon_size} ${PROJECT_BINARY_DIR}/icons icon_png)
list (APPEND icon_png_list ${icon_png})
endforeach ()
icon_to_png (${icon} ${PROJECT_SOURCE_DIR}/${icon}.svg
256 ${PROJECT_BINARY_DIR}/icons icon_png)
set (icon_ico ${PROJECT_BINARY_DIR}/${icon}.ico)
icon_for_win32 (${icon_ico} "${icon_png_list}" "${icon_png}")
list (APPEND icon_ico_list ${icon_ico})
endforeach ()
set_property (SOURCE xW.rc
APPEND PROPERTY OBJECT_DEPENDS ${icon_ico_list} beep.wav)
# Build the main executable and link it
find_program (awk_EXECUTABLE awk ${find_program_REQUIRE})
add_custom_command (OUTPUT xC-proto.cpp
COMMAND ${CMAKE_COMMAND} -E env LC_ALL=C ${awk_EXECUTABLE}
-f ${root}/liberty/tools/lxdrgen.awk
-f ${root}/liberty/tools/lxdrgen-cpp.awk
-v PrefixCamel=Relay
${root}/xC.lxdr > xC-proto.cpp
DEPENDS
${root}/liberty/tools/lxdrgen.awk
${root}/liberty/tools/lxdrgen-cpp.awk
${root}/xC.lxdr
COMMENT "Generating xC relay protocol code" VERBATIM)
add_custom_target (xC-proto DEPENDS ${PROJECT_BINARY_DIR}/xC-proto.cpp)
add_executable (xW WIN32 xW.cpp xW.rc xW.manifest ${project_config}
${root}/liberty/tools/lxdrgen-cpp-win32.cpp)
target_link_libraries (xW comctl32 ws2_32 winmm)
add_dependencies (xW xC-proto)
# At least with MinGW, this is a fully independent portable executable
install (TARGETS xW DESTINATION .)
set (CPACK_GENERATOR ZIP)
include (CPack)

14
xW/config.h.in
View File

@ -1,14 +0,0 @@
#ifndef CONFIG_H
#define CONFIG_H
#define PROJECT_NAME "${PROJECT_NAME}"
#define PROJECT_VERSION "${project_version}"
#define PROJECT_DESCRIPTION "${PROJECT_DESCRIPTION}"
#define PROJECT_AUTHOR "Přemysl Eric Janouch"
#define PROJECT_MAJOR (${PROJECT_VERSION_MAJOR}-0)
#define PROJECT_MINOR (${PROJECT_VERSION_MINOR}-0)
#define PROJECT_PATCH (${PROJECT_VERSION_PATCH}-0)
#define PROJECT_TWEAK (${PROJECT_VERSION_TWEAK}-0)
#endif // ! CONFIG_H

24
xW/xW-highlighted.svg
View File

@ -1,24 +0,0 @@
<?xml version="1.0" encoding="UTF-8" standalone="no"?>
<svg version="1.1" width="48" height="48" viewBox="0 0 48 48"
xmlns="http://www.w3.org/2000/svg">
<defs>
<clipPath id="outer">
<rect x="-1" y="-0.15" width="5" height="3.30" />
</clipPath>
<clipPath id="inner">
<rect x="-1" y="0" width="5" height="3" />
</clipPath>
</defs>
<g transform="translate(6, 6) scale(12)" stroke-linecap="square">
<g clip-path="url(#outer)">
<path stroke="#ffffff" stroke-width="1.5" d="M 0.5,0 2.5,3" />
<path stroke="#ffffff" stroke-width="1.5" d="M 0.5,3 2.5,0" />
</g>
<g clip-path="url(#inner)">
<path stroke="#ff0000" stroke-width="0.9" d="M 0.5,0 2.5,3" />
<path stroke="#ff0000" stroke-width="0.9" d="M 0.5,3 2.5,0" />
</g>
</g>
</svg>
Side by Side

Before

Width:  |  Height:  |  Size: 806 B

18
xW/xW-resources.h
View File

@ -1,18 +0,0 @@
#define IDI_ICON 1
#define IDI_HIGHLIGHTED 2
#define IDR_BEEP 3
#define IDA_ACCELERATORS 10
// Named after input_add_functions() in xC.
#define ID_PREVIOUS_BUFFER 11
#define ID_NEXT_BUFFER 12
#define ID_SWITCH_BUFFER 13
#define ID_GOTO_HIGHLIGHT 14
#define ID_GOTO_ACTIVITY 15
#define ID_TOGGLE_UNIMPORTANT 16
#define ID_DISPLAY_FULL_LOG 17
#define IDD_CONNECT 20
#define IDC_STATIC 21
#define IDC_HOST 22
#define IDC_PORT 23

1998
xW/xW.cpp
View File

File diff suppressed because it is too large Load Diff

25
xW/xW.manifest
View File

@ -1,25 +0,0 @@
<?xml version="1.0" encoding="UTF-8" standalone="yes" ?>
<assembly xmlns="urn:schemas-microsoft-com:asm.v1" manifestVersion="1.0">
<assemblyIdentity name="xW" version="1.0.0.0" type="win32" />
<dependency>
<dependentAssembly>
<assemblyIdentity name="Microsoft.Windows.Common-Controls"
version="6.0.0.0" type="win32" processorArchitecture="*"
publicKeyToken="6595b64144ccf1df" language="*" />
</dependentAssembly>
</dependency>
<compatibility xmlns="urn:schemas-microsoft-com:compatibility.v1">
<application>
<!-- Windows 10 -->
<supportedOS Id="{8e0f7a12-bfb3-4fe8-b9a5-48fd50a15a9a}" />
<!-- Windows 8.1 -->
<supportedOS Id="{1f676c76-80e1-4239-95bb-83d0f6d0da78}" />
<!-- Windows 8 -->
<supportedOS Id="{4a2f28e3-53b9-4441-ba9c-d69d4a4a6e38}" />
<!-- Windows 7 -->
<supportedOS Id="{35138b9a-5d96-4fbd-8e2d-a2440225f93a}" />
<!-- Windows Vista -->
<supportedOS Id="{e2011457-1546-43c5-a5fe-008deee3d3f0}" />
</application>
</compatibility>
</assembly>

80
xW/xW.rc
View File

@ -1,80 +0,0 @@
#include <windows.h>
#include "xW-resources.h"
// https://devblogs.microsoft.com/oldnewthing/20190607-00/?p=102569
// For UTF-8 literals to work in both MinGW and Microsoft resource compilers,
// the pragma needs to be in this file, and before they're included.
#pragma code_page(65001)
#include "config.h"
// Beware of this madness https://gitlab.kitware.com/cmake/cmake/-/issues/23066
CREATEPROCESS_MANIFEST_RESOURCE_ID RT_MANIFEST "xW.manifest"
IDI_ICON ICON "xW.ico"
IDI_HIGHLIGHTED ICON "xW-highlighted.ico"
IDR_BEEP WAVE "beep.wav"
IDA_ACCELERATORS ACCELERATORS
BEGIN
"^p", ID_PREVIOUS_BUFFER
"^n", ID_NEXT_BUFFER
VK_F5, ID_PREVIOUS_BUFFER, VIRTKEY
VK_F6, ID_NEXT_BUFFER, VIRTKEY
VK_PRIOR, ID_PREVIOUS_BUFFER, CONTROL, VIRTKEY
VK_NEXT, ID_NEXT_BUFFER, CONTROL, VIRTKEY
VK_TAB, ID_SWITCH_BUFFER, CONTROL, VIRTKEY
// These are proper, but llvm-rc won't accept them (GitHub #64002).
#ifndef __clang__
"!", ID_GOTO_HIGHLIGHT, ALT
"a", ID_GOTO_ACTIVITY, ALT
"H", ID_TOGGLE_UNIMPORTANT, ALT
"h", ID_DISPLAY_FULL_LOG, ALT
#endif
END
// https://devblogs.microsoft.com/oldnewthing/20050204-00/?p=36523
// https://devblogs.microsoft.com/oldnewthing/20050207-00/?p=36513
//
// Note that this is still not the right font to use in newest Windows,
// that would be 9pt Segoe UI, as described in:
// https://learn.microsoft.com/en-us/windows/win32/uxguide/vis-fonts
// or even better yet, NONCLIENTMETRICS::lfMessageFont.
IDD_CONNECT DIALOGEX 0, 0, 150, 64
STYLE DS_SHELLFONT | DS_MODALFRAME | DS_CENTER \
| WS_POPUP | WS_CAPTION | WS_SYSMENU
CAPTION "Connect to Relay"
FONT 8, "MS Shell Dlg", 400 /*FW_NORMAL*/, 0 /*FALSE*/, 0x1 /*DEFAULT_CHARSET*/
BEGIN
LTEXT "&Host:", IDC_STATIC, 7, 10, 18, 8
EDITTEXT IDC_HOST, 39, 7, 104, 14, ES_AUTOHSCROLL
LTEXT "&Port:", IDC_STATIC, 7, 28, 18, 8
EDITTEXT IDC_PORT, 39, 25, 104, 14, ES_AUTOHSCROLL
DEFPUSHBUTTON "&Connect", IDOK, 39, 43, 50, 14
PUSHBUTTON "E&xit", IDCANCEL, 93, 43, 50, 14
END
VS_VERSION_INFO VERSIONINFO
FILEVERSION PROJECT_MAJOR, PROJECT_MINOR, PROJECT_PATCH, PROJECT_TWEAK
PRODUCTVERSION PROJECT_MAJOR, PROJECT_MINOR, PROJECT_PATCH, PROJECT_TWEAK
FILETYPE VFT_APP
BEGIN
BLOCK "StringFileInfo"
BEGIN
BLOCK "040904B0"
BEGIN
VALUE "CompanyName", PROJECT_AUTHOR
VALUE "FileDescription", PROJECT_DESCRIPTION
VALUE "FileVersion", PROJECT_VERSION
VALUE "InternalName", PROJECT_NAME
VALUE "LegalCopyright", PROJECT_AUTHOR
VALUE "OriginalFilename", PROJECT_NAME ".exe"
VALUE "ProductName", PROJECT_NAME
VALUE "ProductVersion", PROJECT_VERSION
END
END
BLOCK "VarFileInfo"
BEGIN
VALUE "Translation", 0x409, 1200
END
END

24
xW/xW.svg
View File

@ -1,24 +0,0 @@
<?xml version="1.0" encoding="UTF-8" standalone="no"?>
<svg version="1.1" width="48" height="48" viewBox="0 0 48 48"
xmlns="http://www.w3.org/2000/svg">
<defs>
<clipPath id="outer">
<rect x="-1" y="-0.15" width="5" height="3.30" />
</clipPath>
<clipPath id="inner">
<rect x="-1" y="0" width="5" height="3" />
</clipPath>
</defs>
<g transform="translate(6, 6) scale(12)" stroke-linecap="square">
<g clip-path="url(#outer)">
<path stroke="#ffffff" stroke-width="1.5" d="M 0.5,0 2.5,3" />
<path stroke="#ffffff" stroke-width="1.5" d="M 0.5,3 2.5,0" />
</g>
<g clip-path="url(#inner)">
<path stroke="#000000" stroke-width="0.2" d="M 0,0 2,3 M 1,0 3,3" />
<path stroke="#ff6600" stroke-width="0.3" d="M 0,3 2,0 M 1,3 3,0" />
</g>
</g>
</svg>
Side by Side

Before

Width:  |  Height:  |  Size: 818 B

68
xB.c → zyklonb.c
View File

@ -1,7 +1,7 @@
/*
* xB.c: a modular IRC bot
* zyklonb.c: the experimental IRC bot
*
* Copyright (c) 2014 - 2020, Přemysl Eric Janouch <p@janouch.name>
* Copyright (c) 2014 - 2016, Přemysl Janouch <p@janouch.name>
*
* Permission to use, copy, modify, and/or distribute this software for any
* purpose with or without fee is hereby granted.
@ -17,7 +17,8 @@
*/
#include "config.h"
#define PROGRAM_NAME "xB"
#define PROGRAM_NAME "ZyklonB"
#define PLUGIN_DIR ZYKLONB_PLUGIN_DIR
#include "common.c"
@ -25,9 +26,9 @@
static struct simple_config_item g_config_table[] =
{
{ "nickname", "xB", "IRC nickname" },
{ "nickname", "ZyklonB", "IRC nickname" },
{ "username", "bot", "IRC user name" },
{ "realname", "xB IRC bot", "IRC real name/e-mail" },
{ "realname", "ZyklonB IRC bot", "IRC real name/e-mail" },
{ "irc_host", NULL, "Address of the IRC server" },
{ "irc_port", "6667", "Port of the IRC server" },
@ -48,7 +49,7 @@ static struct simple_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", NULL, "Plugin search path override" },
{ "plugin_dir", PLUGIN_DIR, "Where to search for plugins" },
{ "recover", "on", "Whether to re-launch on crash" },
{ NULL, NULL, NULL }
@ -279,7 +280,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",
xerr_describe_error ());
ERR_error_string (ERR_get_error (), NULL));
result = false;
}
}
@ -319,13 +320,13 @@ irc_initialize_ca_set (SSL_CTX *ssl_ctx, const char *file, const char *path,
return error_set (e, "%s: %s",
"failed to set locations for the CA certificate bundle",
xerr_describe_error ());
ERR_reason_error_string (ERR_get_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 ());
ERR_reason_error_string (ERR_get_error ()));
return true;
}
@ -406,7 +407,7 @@ irc_initialize_tls (struct bot_context *ctx, struct error **e)
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 TLS client certificate failed",
xerr_describe_error ());
ERR_error_string (ERR_get_error (), NULL));
free (path);
}
@ -433,8 +434,10 @@ 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 = xerr_describe_error ();
error_info = ERR_error_string (ERR_get_error (), NULL);
return error_set (e, "%s: %s", "could not initialize TLS", error_info);
}
@ -735,7 +738,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 = "XB";
static const char *plugin_ipc_command = "ZYKLONB";
static struct plugin *
plugin_find_by_pid (struct bot_context *ctx, pid_t pid)
@ -1009,46 +1012,26 @@ is_valid_plugin_name (const char *name)
if (!*name)
return false;
for (const char *p = name; *p; p++)
if (!isgraph ((uint8_t) *p) || *p == '/')
if (!isgraph (*p) || *p == '/')
return false;
return true;
}
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)
{
// 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);
}
else if (!(path = plugin_resolve_relative_filename (name)))
{
error_set (e, "plugin not found");
goto fail_0;
error_set (e, "plugin directory not set");
return NULL;
}
int stdin_pipe[2];
if (pipe (stdin_pipe) == -1)
{
error_set (e, "%s: %s", "pipe", strerror (errno));
goto fail_0;
return NULL;
}
int stdout_pipe[2];
@ -1098,7 +1081,7 @@ plugin_launch (struct bot_context *ctx, const char *name, struct error **e)
// Restore some of the signal handling
signal (SIGPIPE, SIG_DFL);
char *argv[] = { path, NULL };
char *argv[] = { xstrdup_printf ("%s/%s", plugin_dir, name), NULL };
execve (argv[0], argv, environ);
// We will collect the failure later via SIGCHLD
@ -1108,7 +1091,6 @@ plugin_launch (struct bot_context *ctx, const char *name, struct error **e)
}
str_free (&work_dir);
free (path);
xclose (stdin_pipe[0]);
xclose (stdout_pipe[1]);
@ -1128,8 +1110,6 @@ fail_2:
fail_1:
xclose (stdin_pipe[0]);
xclose (stdin_pipe[1]);
fail_0:
free (path);
return NULL;
}
@ -1213,7 +1193,7 @@ parse_bot_command (const char *s, const char *command, const char **following)
s += command_len;
// Expect a word boundary, so that we don't respond to invalid things
if (isalnum ((uint8_t) *s))
if (isalnum (*s))
return false;
// Ignore any initial spaces; the rest is the command's argument
@ -1861,7 +1841,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"; use `status'
// "plugin `name' died like a dirty jewish pig"; use `status'
if (!plugin->is_zombie && WIFSIGNALED (status))
{
const char *notes = "";
@ -1984,7 +1964,7 @@ main (int argc, char *argv[])
};
struct opt_handler oh =
opt_handler_make (argc, argv, opts, NULL, "Modular IRC bot.");
opt_handler_make (argc, argv, opts, NULL, "Experimental IRC bot.");
int c;
while ((c = opt_handler_get (&oh)) != -1)