What changed, and why it matters
This commit swaps Monero's command-line input library from the external GNU readline to a vendored copy of linenoise. It is primarily a build-system and dependency-maintenance change. The new library is included directly in the repository, so Monero no longer relies on the system's readline/ncurses packages. There is no direct evidence in the commit message or diff that this fixes a specific security vulnerability; it looks like a routine dependency replacement.
Treat as a normal dependency migration. Review the vendored linenoise code for terminal-handling bugs, memory-management issues, and UTF-8 parsing defects before relying on it in release builds. Monitor upstream linenoise for security fixes and keep the vendored copy updated.
Security signals we found
Dependency swap from dynamically-linked GNU readline to vendored linenoise reduces supply-chain exposure to readline/ncurses vulnerabilities
New strip_unsafe_bytes() helper removes C0/C1 control characters from returned input lines
Vendored linenoise is a large new C attack surface (~2,500 lines) handling terminal escape sequences, UTF-8, and paste buffers
No explicit security bug or CVE is referenced in the commit or supplied references
Evidence from the diff
The merge replaces GNU readline with a vendored linenoise (commit a473823) across CMake, depends, Docker, CI, and epee’s readline_buffer implementation. The old readline/ncurses package recipes and FindReadline.cmake are removed; external/linenoise is added and linked into epee_readline. readline_buffer.cpp is rewritten to use linenoise’s multiplexed API (EditStart/EditFeed/EditStop), adds a strip_unsafe_bytes() filter for control characters, and adjusts prompt coloring. No CVE, advisory, or vendor security statement is present in the supplied materials.
Changed components
contrib/epee/src/readline_buffer.cppcontrib/epee/include/readline_buffer.hcontrib/epee/include/console_handler.hexternal/linenoise/linenoise.cexternal/linenoise/linenoise.hexternal/linenoise/CMakeLists.txtCMakeLists.txtcontrib/depends build recipesInspect captured patch +2939 / −7022
### .github/workflows/build.yml
@@ -117,7 +117,7 @@ jobs:
image: archlinux:latest
steps:
- name: install dependencies
- run: pacman -Syyu --noconfirm base-devel git rust cmake boost boost-libs openssl zeromq unbound libsodium readline expat gtest python3 doxygen graphviz hidapi libusb protobuf ccache
+ run: pacman -Syyu --noconfirm base-devel git rust cmake boost boost-libs openssl zeromq unbound libsodium expat gtest python3 doxygen graphviz hidapi libusb protobuf ccache
- name: configure git
run: git config --global --add safe.directory '*'
- uses: actions/checkout@v5
### CMakeLists.txt
@@ -651,6 +651,11 @@ endfunction ()
add_subdirectory(external)
+# Final setup for linenoise
+if(NOT WIN32)
+ include_directories(${CMAKE_CURRENT_SOURCE_DIR}/external/linenoise)
+endif()
+
# Final setup for libunbound
include_directories(${UNBOUND_INCLUDE_DIR})
@@ -876,6 +881,9 @@ include(CheckTrezor)
# external/ is added before the hardening flags are computed
# apply them to its input-facing C libraries
set_property(TARGET polyseed_static utf8proc APPEND_STRING PROPERTY COMPILE_FLAGS " ${C_SECURITY_FLAGS}")
+ if(TARGET linenoise)
+ set_property(TARGET linenoise APPEND_STRING PROPERTY COMPILE_FLAGS " ${C_SECURITY_FLAGS}")
+ endif()
# With GCC 6.1.1 the compiled binary malfunctions due to aliasing. Until that
# is fixed in the code (Issue #847), force compiler to be conservative.
@@ -1016,25 +1024,7 @@ if ((CMAKE_CXX_COMPILER_ID STREQUAL "GNU") AND (CMAKE_CXX_COMPILER_VERSION VERSI
list(APPEND EXTRA_LIBRARIES "stdc++fs")
endif()
-if(NOT OPENBSD)
- option(USE_READLINE "Build with GNU readline support." ON)
-endif()
-if(USE_READLINE AND NOT DEPENDS)
- find_package(Readline)
- if(READLINE_FOUND AND GNU_READLINE_FOUND)
- add_definitions(-DHAVE_READLINE)
- include_directories(${Readline_INCLUDE_DIR})
- message(STATUS "Found readline library at: ${Readline_ROOT_DIR}")
- set(EPEE_READLINE epee_readline)
- else()
- message(STATUS "Could not find GNU readline library so building without readline support")
- endif()
-elseif(USE_READLINE AND DEPENDS AND NOT MINGW)
- find_path(Readline_INCLUDE_PATH readline/readline.h)
- find_library(Readline_LIBRARY readline)
- find_library(Terminfo_LIBRARY tinfo)
- set(Readline_LIBRARY "${Readline_LIBRARY};${Terminfo_LIBRARY}")
- set(GNU_READLINE_LIBRARY ${Readline_LIBRARY})
+if(NOT WIN32 AND NOT OPENBSD)
add_definitions(-DHAVE_READLINE)
set(EPEE_READLINE epee_readline)
endif()
### Dockerfile
@@ -4,20 +4,18 @@ COPY --from=stagex/core-openssl:sx2026.06.0@sha256:5fbecea19913b8c9bb2e5976b0383
COPY --from=stagex/core-ca-certificates:sx2026.06.0@sha256:ea7076d1bb83693fa4766c9cbd8132e59ac0981799fd8b58961c245cd360b66d . /
COPY --from=stagex/user-patch:sx2026.06.0@sha256:1d4428893f0ea9abfabc1fb5e365c5593fe10c6ed8ffc592d6528157a4299942 . /
COPY --from=stagex/core-cmake:sx2026.06.0@sha256:626a3fdf157efacd00c3ceb0529ae80dde1072d64fa1925aafe9819bebc92047 . /
-COPY --from=stagex/core-ncurses:sx2026.06.0@sha256:90cc5d029c5073405f9db39c88b9509b8959bbd8f19d8cd02c20e9350cc40254 . /
COPY --from=stagex/pallet-rust:sx2026.06.0@sha256:59d4d0c9e232a05ecb99348f7216b521af1b914a430059dbdb9130018f2afde1 . /
ENV TARGET="x86_64-pc-linux-musl"
WORKDIR /monero
COPY . .
-RUN make -C contrib/depends -j$(nproc) download-linux NO_WALLET=1 NO_READLINE=1
+RUN make -C contrib/depends -j$(nproc) download-linux NO_WALLET=1
-RUN make -C contrib/depends -j$(nproc) HOST="${TARGET}" NO_WALLET=1 NO_READLINE=1
+RUN make -C contrib/depends -j$(nproc) HOST="${TARGET}" NO_WALLET=1
RUN cmake --toolchain "contrib/depends/${TARGET}/share/toolchain.cmake" -S . -B build \
-DSTACK_TRACE=OFF \
- -DUSE_READLINE=OFF \
-DUSE_DEVICE_TREZOR=OFF \
-DSTATIC_FLAGS="-static-pie" && \
cmake --build build --target daemon --parallel $(nproc)
### README.md
@@ -148,7 +148,6 @@ The following table summarizes the tools and libraries required to build. A few
| libunbound | 1.4.16 | NO | `libunbound-dev` | `unbound` | `unbound-devel` | `unbound-devel` | NO | DNS resolver |
| libsodium | ? | NO | `libsodium-dev` | `libsodium` | `libsodium-devel` | `libsodium-devel` | NO | cryptography |
| libunwind | any | NO | `libunwind-dev` | `libunwind` | `libunwind-devel` | `libunwind-devel` | YES | Stack traces |
-| libreadline | 6.3.0 | NO | `libreadline-dev` | `readline` | `readline-devel` | `readline-devel` | YES | Input editing |
| GTest | 1.5 | YES | `libgtest-dev` | `gtest` | `gtest-devel` | `gtest-devel` | YES | Test suite |
| ccache | any | NO | `ccache` | `ccache` | `ccache` | `ccache` | YES | Compil. cache |
| Doxygen | any | NO | `doxygen` | `doxygen` | `doxygen` | `doxygen` | YES | Documentation |
@@ -162,23 +161,23 @@ The following table summarizes the tools and libraries required to build. A few
Install all dependencies at once on Debian/Ubuntu:
```
-sudo apt update && sudo apt install build-essential cmake pkg-config libssl-dev libzmq3-dev libunbound-dev libsodium-dev libunwind-dev libreadline-dev libhidapi-dev libusb-1.0-0-dev libprotobuf-dev protobuf-compiler libboost-chrono-dev libboost-date-time-dev libboost-filesystem-dev libboost-locale-dev libboost-program-options-dev libboost-regex-dev libboost-serialization-dev libboost-system-dev libboost-thread-dev python3 ccache doxygen graphviz git curl
+sudo apt update && sudo apt install build-essential cmake pkg-config libssl-dev libzmq3-dev libunbound-dev libsodium-dev libunwind-dev libhidapi-dev libusb-1.0-0-dev libprotobuf-dev protobuf-compiler libboost-chrono-dev libboost-date-time-dev libboost-filesystem-dev libboost-locale-dev libboost-program-options-dev libboost-regex-dev libboost-serialization-dev libboost-system-dev libboost-thread-dev python3 ccache doxygen graphviz git curl
```
Install all dependencies at once on Arch:
```
-sudo pacman -Syu --needed base-devel cmake boost boost-libs openssl zeromq unbound libsodium libunwind readline python ccache doxygen graphviz hidapi libusb protobuf rust
+sudo pacman -Syu --needed base-devel cmake boost boost-libs openssl zeromq unbound libsodium libunwind python ccache doxygen graphviz hidapi libusb protobuf rust
```
Install all dependencies at once on Fedora:
```
-sudo dnf install gcc gcc-c++ cmake pkgconf boost-devel openssl-devel zeromq-devel unbound-devel libsodium-devel libunwind-devel readline-devel ccache doxygen graphviz hidapi-devel libusb1-devel protobuf-devel protobuf-compiler rust cargo
+sudo dnf install gcc gcc-c++ cmake pkgconf boost-devel openssl-devel zeromq-devel unbound-devel libsodium-devel libunwind-devel ccache doxygen graphviz hidapi-devel libusb1-devel protobuf-devel protobuf-compiler rust cargo
```
Install all dependencies at once on openSUSE:
```
-sudo zypper ref && sudo zypper in cppzmq-devel libboost_chrono-devel libboost_date_time-devel libboost_filesystem-devel libboost_locale-devel libboost_program_options-devel libboost_regex-devel libboost_serialization-devel libboost_system-devel libboost_thread-devel libsodium-devel libunwind-devel unbound-devel cmake doxygen ccache fdupes gcc-c++ libevent-devel libopenssl-devel pkgconf-pkg-config readline-devel patterns-devel-C-C++-devel_C_C++ rust cargo
+sudo zypper ref && sudo zypper in cppzmq-devel libboost_chrono-devel libboost_date_time-devel libboost_filesystem-devel libboost_locale-devel libboost_program_options-devel libboost_regex-devel libboost_serialization-devel libboost_system-devel libboost_thread-devel libsodium-devel libunwind-devel unbound-devel cmake doxygen ccache fdupes gcc-c++ libevent-devel libopenssl-devel pkgconf-pkg-config patterns-devel-C-C++-devel_C_C++ rust cargo
```
Install all dependencies at once on macOS with the provided Brewfile:
@@ -390,7 +389,7 @@ Then you need to increase the data ulimit size to 2GB and try again: `ulimit -d
### On NetBSD:
-Check that the dependencies are present: `pkg_info -c libexecinfo boost-headers boost-libs protobuf readline libusb1 zeromq git-base pkgconf gmake cmake | more`, and install any that are reported missing, using `pkg_add` or from your pkgsrc tree. Readline is optional but worth having.
+Check that the dependencies are present: `pkg_info -c libexecinfo boost-headers boost-libs protobuf libusb1 zeromq git-base pkgconf gmake cmake | more`, and install any that are reported missing, using `pkg_add` or from your pkgsrc tree.
Third-party dependencies are usually under `/usr/pkg/`, but if you have a custom setup, adjust the "/usr/pkg" (below) accordingly.
### cmake/FindReadline.cmake
@@ -1,90 +0,0 @@
-# - Try to find readline include dirs and libraries
-#
-# Usage of this module as follows:
-#
-# find_package(Readline)
-#
-# Variables used by this module, they can change the default behaviour and need
-# to be set before calling find_package:
-#
-# Readline_ROOT_DIR Set this variable to the root installation of
-# readline if the module has problems finding the
-# proper installation path.
-#
-# Variables defined by this module:
-#
-# READLINE_FOUND System has readline, include and lib dirs found
-# GNU_READLINE_FOUND Version of readline found is GNU readline, not libedit!
-# LIBEDIT_FOUND Version of readline found is libedit, not GNU readline!
-# Readline_INCLUDE_DIR The readline include directories.
-# Readline_LIBRARY The readline library.
-# GNU_READLINE_LIBRARY The GNU readline library or empty string.
-# LIBEDIT_LIBRARY The libedit library or empty string.
-
-find_path(Readline_ROOT_DIR
- NAMES include/readline/readline.h
- HINTS /usr/local/opt/readline/ /opt/homebrew/opt/readline/ /opt/local/ /usr/local/ /usr/
-)
-
-find_path(Readline_INCLUDE_DIR
- NAMES readline/readline.h
- PATHS ${Readline_ROOT_DIR}/include
- NO_DEFAULT_PATH
-)
-
-find_library(Readline_LIBRARY
- NAMES readline
- PATHS ${Readline_ROOT_DIR}/lib
- NO_DEFAULT_PATH
-)
-
-find_library(Termcap_LIBRARY
- NAMES tinfo termcap ncursesw ncurses cursesw curses
-)
-
-if(Readline_INCLUDE_DIR AND Readline_LIBRARY)
- set(READLINE_FOUND TRUE)
-else(Readline_INCLUDE_DIR AND Readline_LIBRARY)
- FIND_LIBRARY(Readline_LIBRARY NAMES readline PATHS Readline_ROOT_DIR)
- include(FindPackageHandleStandardArgs)
- FIND_PACKAGE_HANDLE_STANDARD_ARGS(Readline DEFAULT_MSG Readline_INCLUDE_DIR Readline_LIBRARY )
- MARK_AS_ADVANCED(Readline_INCLUDE_DIR Readline_LIBRARY)
-endif(Readline_INCLUDE_DIR AND Readline_LIBRARY)
-
-mark_as_advanced(
- Readline_ROOT_DIR
- Readline_INCLUDE_DIR
- Readline_LIBRARY
-)
-
-set(CMAKE_REQUIRED_INCLUDES ${Readline_INCLUDE_DIR})
-set(CMAKE_REQUIRED_LIBRARIES ${Readline_LIBRARY})
-
-include(CheckFunctionExists)
-check_function_exists(rl_copy_text HAVE_COPY_TEXT)
-check_function_exists(rl_filename_completion_function HAVE_COMPLETION_FUNCTION)
-
-if(NOT HAVE_COMPLETION_FUNCTION)
- if (Readline_LIBRARY)
- set(CMAKE_REQUIRED_LIBRARIES ${Readline_LIBRARY} ${Termcap_LIBRARY})
- endif(Readline_LIBRARY)
- check_function_exists(rl_copy_text HAVE_COPY_TEXT_TC)
- check_function_exists(rl_filename_completion_function HAVE_COMPLETION_FUNCTION_TC)
- set(HAVE_COMPLETION_FUNCTION ${HAVE_COMPLETION_FUNCTION_TC})
- set(HAVE_COPY_TEXT ${HAVE_COPY_TEXT_TC})
- if(HAVE_COMPLETION_FUNCTION)
- set(Readline_LIBRARY ${Readline_LIBRARY} ${Termcap_LIBRARY})
- endif(HAVE_COMPLETION_FUNCTION)
-endif(NOT HAVE_COMPLETION_FUNCTION)
-
-set(LIBEDIT_LIBRARY "")
-set(GNU_READLINE_LIBRARY "")
-
-if(HAVE_COMPLETION_FUNCTION AND HAVE_COPY_TEXT)
- set(GNU_READLINE_FOUND TRUE)
- set(GNU_READLINE_LIBRARY ${Readline_LIBRARY})
-elseif(READLINE_FOUND AND NOT HAVE_COPY_TEXT)
- set(LIBEDIT_FOUND TRUE)
- set(LIBEDIT_LIBRARY ${Readline_LIBRARY})
-endif(HAVE_COMPLETION_FUNCTION AND HAVE_COPY_TEXT)
-
### contrib/brew/Brewfile
@@ -15,7 +15,6 @@ brew "hidapi"
brew "zmq"
brew "unbound"
brew "libsodium"
-brew "readline"
brew "ccache"
brew "doxygen"
brew "graphviz"
### contrib/depends/Makefile
@@ -12,7 +12,6 @@ C_STANDARD ?= c11
CXX_STANDARD ?= c++17
NO_WALLET ?=
-NO_READLINE ?=
BUILD = $(shell ./config.guess)
HOST ?= $(BUILD)
@@ -116,12 +115,10 @@ build_id_string:=$(realpath $(GUIX_ENVIRONMENT))
$(host_arch)_$(host_os)_id_string:=$(realpath $(GUIX_ENVIRONMENT))
endif
-readline_packages_$(NO_READLINE) = $(readline_packages)
-
wallet_packages_$(NO_WALLET) = $(wallet_packages)
wallet_native_packages_$(NO_WALLET) = $(wallet_native_packages)
-packages += $($(host_arch)_$(host_os)_packages) $($(host_os)_packages) $(wallet_packages_) $(readline_packages_)
+packages += $($(host_arch)_$(host_os)_packages) $($(host_os)_packages) $(wallet_packages_)
native_packages += $($(host_arch)_$(host_os)_native_packages) $($(host_os)_native_packages) $(wallet_native_packages_)
all_packages = $(packages) $(native_packages)
### contrib/depends/packages/darwin_sdk.mk
@@ -4,11 +4,7 @@ $(package)_download_path=https://bitcoincore.org/depends-sources/sdks
$(package)_file_name=Xcode-12.2-12B45b-extracted-SDK-with-libcxx-headers.tar.gz
$(package)_sha256_hash=df75d30ecafc429e905134333aeae56ac65fac67cb4182622398fd717df77619
-# Prevent clang from including readline headers from the SDK. We statically link
-# our own version of readline.
-
define $(package)_stage_cmds
mkdir -p $($(package)_staging_prefix_dir)/SDK &&\
- rm -rf usr/include/readline && \
mv * $($(package)_staging_prefix_dir)/SDK
endef
### contrib/depends/packages/ncurses.mk
@@ -1,64 +0,0 @@
-package=ncurses
-$(package)_version=6.1
-$(package)_download_path=https://ftp.gnu.org/gnu/ncurses
-$(package)_file_name=$(package)-$($(package)_version).tar.gz
-$(package)_sha256_hash=aa057eeeb4a14d470101eff4597d5833dcef5965331be3528c08d99cebaa0d17
-$(package)_patches=fallback.c
-
-define $(package)_set_vars
- $(package)_build_opts=CC="$($(package)_cc)"
- $(package)_config_env=cf_cv_ar_flags=""
- $(package)_config_opts=--prefix=$(host_prefix)
- $(package)_config_opts+=--disable-shared
- $(package)_config_opts+=--with-build-cc=$(build_CC)
- $(package)_config_opts+=--without-debug
- $(package)_config_opts+=--without-ada
- $(package)_config_opts+=--without-cxx-binding
- $(package)_config_opts+=--without-cxx
- $(package)_config_opts+=--without-ticlib
- $(package)_config_opts+=--without-tic
- $(package)_config_opts+=--without-progs
- $(package)_config_opts+=--without-tests
- $(package)_config_opts+=--without-tack
- $(package)_config_opts+=--without-manpages
- $(package)_config_opts+=--with-termlib=tinfo
- $(package)_config_opts+=--disable-tic-depends
- $(package)_config_opts+=--disable-big-strings
- $(package)_config_opts+=--disable-ext-colors
- $(package)_config_opts+=--enable-pc-files
- $(package)_config_opts+=--host=$(HOST)
- $(pacakge)_config_opts+=--without-shared
- $(pacakge)_config_opts+=--without-pthread
- $(pacakge)_config_opts+=--disable-rpath
- $(pacakge)_config_opts+=--disable-colorfgbg
- $(pacakge)_config_opts+=--disable-ext-mouse
- $(pacakge)_config_opts+=--disable-symlinks
- $(pacakge)_config_opts+=--enable-warnings
- $(pacakge)_config_opts+=--enable-assertions
- $(package)_config_opts+=--with-default-terminfo-dir=/etc/_terminfo_
- $(package)_config_opts+=--with-terminfo-dirs=/etc/_terminfo_
- $(pacakge)_config_opts+=--enable-database
- $(pacakge)_config_opts+=--enable-sp-funcs
- $(pacakge)_config_opts+=--disable-term-driver
- $(pacakge)_config_opts+=--enable-interop
- $(pacakge)_config_opts+=--enable-widec
- $(package)_build_opts=CFLAGS="$($(package)_cflags) $($(package)_cppflags) -fPIC"
-endef
-
-define $(package)_preprocess_cmds
- cp -f $(BASEDIR)/config.guess $(BASEDIR)/config.sub . && \
- cp $($(package)_patch_dir)/fallback.c ncurses
-endef
-
-define $(package)_config_cmds
- $($(package)_autoconf)
-endef
-
-define $(package)_build_cmds
- $(MAKE) $($(package)_build_opts) V=1
-endef
-
-define $(package)_stage_cmds
- $(MAKE) install.libs DESTDIR=$($(package)_staging_dir)
-endef
-
### contrib/depends/packages/packages.mk
@@ -1,10 +1,6 @@
native_packages :=
packages := boost openssl zeromq unbound sodium
-ifneq ($(host_os),mingw32)
-readline_packages += ncurses readline
-endif
-
wallet_native_packages := native_protobuf
wallet_packages = protobuf
### contrib/depends/packages/readline.mk
@@ -1,33 +0,0 @@
-package=readline
-$(package)_version=8.0
-$(package)_download_path=https://ftp.gnu.org/gnu/readline
-$(package)_file_name=$(package)-$($(package)_version).tar.gz
-$(package)_sha256_hash=e339f51971478d369f8a053a330a190781acb9864cf4c541060f12078948e461
-$(package)_dependencies=ncurses
-
-define $(package)_set_vars
- $(package)_build_opts=CC="$($(package)_cc)"
- $(package)_config_opts+=--prefix=$(host_prefix)
- $(package)_config_opts+=--exec-prefix=$(host_prefix)
- $(package)_config_opts+=--host=$(HOST)
- $(package)_config_opts+=--disable-shared --with-curses
- $(package)_config_opts_release=--disable-debug-mode
- $(package)_build_opts=CFLAGS="$($(package)_cflags) $($(package)_cppflags) -fPIC"
-endef
-
-define $(package)_preprocess_cmds
- cp -f $(BASEDIR)/config.guess $(BASEDIR)/config.sub support
-endef
-
-define $(package)_config_cmds
- $($(package)_autoconf)
-endef
-
-define $(package)_build_cmds
- $(MAKE) $($(package)_build_opts)
-endef
-
-define $(package)_stage_cmds
- $(MAKE) install DESTDIR=$($(package)_staging_dir) prefix=$(host_prefix) exec-prefix=$(host_prefix)
-endef
-
### contrib/depends/patches/ncurses/fallback.c
[binary or diff unavailable]
### contrib/depends/toolchain.cmake.in
@@ -18,11 +18,6 @@ SET(CMAKE_FIND_ROOT_PATH @prefix@ /usr)
SET(ENV{PKG_CONFIG_PATH} @prefix@/lib/pkgconfig)
-SET(Readline_ROOT_DIR @prefix@)
-SET(Readline_INCLUDE_DIR @prefix@/include)
-SET(Readline_LIBRARY @prefix@/lib/libreadline.a)
-SET(Terminfo_LIBRARY @prefix@/lib/libtinfo.a)
-
SET(LIBUSB-1.0_LIBRARY @prefix@/lib/libusb-1.0.a)
SET(LIBUDEV_LIBRARY @prefix@/lib/libudev.a)
### contrib/epee/include/console_handler.h
@@ -342,10 +342,10 @@ namespace epee
if (!prompt.empty())
{
#ifdef HAVE_READLINE
- std::string color_prompt = "\001\033[1;33m\002" + prompt;
+ std::string color_prompt = "\033[1;33m" + prompt;
if (' ' != prompt.back())
color_prompt += " ";
- color_prompt += "\001\033[0m\002";
+ color_prompt += "\033[0m";
m_stdin_reader.get_readline_buffer().set_prompt(color_prompt);
#else
epee::set_console_color(epee::console_color_yellow, true);
### contrib/epee/include/readline_buffer.h
@@ -17,7 +17,7 @@ namespace rdln
{
return m_cout_buf != NULL;
}
- linestatus get_line(std::string& line) const;
+ linestatus get_line(std::string& line);
void set_prompt(const std::string& prompt);
static void add_completion(const std::string& command);
static const std::vector<std::string>& get_completions();
@@ -27,7 +27,6 @@ namespace rdln
private:
std::streambuf* m_cout_buf;
- size_t m_prompt_length;
static std::vector<std::string>& completion_commands();
};
@@ -43,4 +42,3 @@ namespace rdln
void clear_screen();
}
-
### contrib/epee/src/CMakeLists.txt
@@ -40,7 +40,7 @@ monero_add_library(epee byte_slice.cpp byte_stream.cpp hex.cpp abstract_http_cli
${EPEE_HEADERS_PUBLIC}
)
-if (USE_READLINE AND (GNU_READLINE_FOUND OR (DEPENDS AND NOT MINGW)))
+if (EPEE_READLINE)
monero_add_library(epee_readline readline_buffer.cpp)
endif()
@@ -55,7 +55,7 @@ if (BUILD_GUI_DEPS)
endif()
install(TARGETS epee
ARCHIVE DESTINATION ${lib_folder})
- if (USE_READLINE AND GNU_READLINE_FOUND)
+ if (EPEE_READLINE)
install(TARGETS epee_readline
ARCHIVE DESTINATION ${lib_folder})
endif()
@@ -73,13 +73,13 @@ target_link_libraries(epee
PRIVATE
${EXTRA_LIBRARIES})
-if (USE_READLINE AND (GNU_READLINE_FOUND OR (DEPENDS AND NOT MINGW)))
+if (EPEE_READLINE)
target_link_libraries(epee_readline
PUBLIC
easylogging
${Boost_SYSTEM_LIBRARY}
PRIVATE
- ${GNU_READLINE_LIBRARY})
+ linenoise)
endif()
target_include_directories(epee
### contrib/epee/src/readline_buffer.cpp
@@ -1,23 +1,127 @@
#include "readline_buffer.h"
-#include <readline/readline.h>
-#include <readline/history.h>
+#include <linenoise.h>
#include <iostream>
-#include <memory>
+#include <cerrno>
+#include <csignal>
+#include <cstdlib>
+#include <cstdio>
+#include <chrono>
+#include <thread>
+#include <system_error>
+#include <poll.h>
+#include <sys/ioctl.h>
+#include <unistd.h>
#include <boost/thread/mutex.hpp>
#include <boost/thread/lock_guard.hpp>
+#include <boost/thread/lock_types.hpp>
#include <boost/algorithm/string.hpp>
-static bool same_as_last_line(const std::string&);
-static void install_line_handler();
-static void remove_line_handler();
+namespace
+{
+ rdln::readline_buffer* current = NULL;
+
+ std::string strip_unsafe_bytes(const std::string& line)
+ {
+ std::string out;
+ out.reserve(line.size());
+ for (size_t i = 0; i < line.size(); )
+ {
+ const unsigned char c = static_cast<unsigned char>(line[i]);
+ if (c == 0xC2 && i + 1 < line.size())
+ {
+ const unsigned char c1 = static_cast<unsigned char>(line[i + 1]);
+ if (c1 >= 0x80 && c1 <= 0x9F) { i += 2; continue; } // UTF-8 encoded C1 control
+ }
+ if ((c < 0x20 && c != '\n') || c == 0x7F) { ++i; continue; } // C0 (keep \n) / DEL
+ out += line[i];
+ ++i;
+ }
+ return out;
+ }
+}
+
+static const size_t LINE_BUFFER_MAX = 1024 * 1024;
static boost::mutex sync_mutex;
-static rdln::linestatus line_stat;
-static char *the_line;
+static linenoiseState line_state;
+static bool editing_active = false;
+static bool tty_editing = false;
+static std::string current_prompt;
-namespace
+static void completion_callback(const char* buf, linenoiseCompletions* lc)
{
- rdln::readline_buffer* current = NULL;
+ const std::string text(buf);
+
+ // Completing an empty line would let TAB, Enter run "exit".
+ if (text.empty() || text.find(' ') != std::string::npos) return;
+
+ for (const std::string& cmd : rdln::readline_buffer::get_completions())
+ {
+ if (cmd.compare(0, text.size(), text) == 0)
+ linenoiseAddCompletion(lc, (cmd + " ").c_str());
+ }
+}
+
+// linenoise only reads the terminal width when editing starts.
+static void update_columns()
+{
+ struct winsize ws;
+ if (tty_editing && ioctl(STDOUT_FILENO, TIOCGWINSZ, &ws) == 0 && ws.ws_col)
+ line_state.cols = ws.ws_col;
+}
+
+static void begin_edit()
+{
+ if (editing_active) return;
+
+ char* buf = line_state.buf;
+ size_t buflen = line_state.buflen + 1;
+ bool allocated = false;
+ if (!buf)
+ {
+ buflen = 4096;
+ buf = static_cast<char*>(malloc(buflen));
+ if (!buf) return;
+ allocated = true;
+ }
+
+ if (linenoiseEditStart(&line_state, -1, -1, buf, buflen, current_prompt.c_str()) == 0)
+ {
+ editing_active = true;
+ line_state.buflen_max = LINE_BUFFER_MAX;
+ }
+ else if (allocated)
+ {
+ free(buf);
+ }
+}
+
+static void end_edit()
+{
+ if (!editing_active) return;
+ linenoiseEditStop(&line_state);
+ editing_active = false;
+}
+
+static void reset_line()
+{
+ // A non-tty session never drew a prompt, so skip the redraw.
+ if (editing_active && tty_editing && write(line_state.ofd, "\n", 1) == -1) {}
+ line_state.in_completion = 0;
+ line_state.completion_idx = 0;
+ line_state.buf[0] = '\0';
+ line_state.pos = 0;
+ line_state.oldpos = 0;
+ line_state.len = 0;
+ line_state.oldrows = 0;
+ line_state.oldrpos = 1;
+ line_state.history_index = 0;
+ line_state.fold_count = 0;
+ if (editing_active && tty_editing)
+ {
+ linenoiseHistoryAdd("");
+ linenoiseShow(&line_state);
+ }
}
rdln::suspend_readline::suspend_readline()
@@ -46,7 +150,7 @@ std::vector<std::string>& rdln::readline_buffer::completion_commands()
}
rdln::readline_buffer::readline_buffer()
-: std::stringbuf(), m_cout_buf(NULL), m_prompt_length(0)
+: std::stringbuf(), m_cout_buf(NULL)
{
current = this;
}
@@ -56,9 +160,19 @@ void rdln::readline_buffer::start()
boost::lock_guard<boost::mutex> lock(sync_mutex);
if(m_cout_buf != NULL)
return;
+ static bool stdin_unbuffered = false;
+ if (!stdin_unbuffered && !isatty(STDIN_FILENO))
+ {
+ setvbuf(stdin, NULL, _IONBF, 0);
+ stdin_unbuffered = true;
+ }
+ // Mirrors linenoiseEditStart()'s own no-tty check.
+ tty_editing = (isatty(STDIN_FILENO) && isatty(STDOUT_FILENO)) || getenv("LINENOISE_ASSUME_TTY");
m_cout_buf = std::cout.rdbuf();
std::cout.rdbuf(this);
- install_line_handler();
+ linenoiseSetCompletionCallback(&completion_callback);
+ linenoiseHistorySetMaxLen(500);
+ begin_edit();
}
void rdln::readline_buffer::stop()
@@ -68,38 +182,90 @@ void rdln::readline_buffer::stop()
return;
std::cout.rdbuf(m_cout_buf);
m_cout_buf = NULL;
- remove_line_handler();
+ if (editing_active && tty_editing)
+ linenoiseHide(&line_state);
+ end_edit();
}
-rdln::linestatus rdln::readline_buffer::get_line(std::string& line) const
+rdln::linestatus rdln::readline_buffer::get_line(std::string& line)
{
- boost::lock_guard<boost::mutex> lock(sync_mutex);
- line_stat = rdln::partial;
+ boost::unique_lock<boost::mutex> lock(sync_mutex);
if (!m_cout_buf)
{
line = "";
return rdln::full;
}
- rl_callback_read_char();
- if (line_stat == rdln::full)
+
+ begin_edit();
+ if (!editing_active)
{
- line = the_line;
- free(the_line);
- the_line = NULL;
+ // Raw mode could not be set up: don't spin on the input left unread.
+ lock.unlock();
+ std::this_thread::sleep_for(std::chrono::milliseconds(100));
+ return rdln::partial;
}
- return line_stat;
+
+ // Avoid blocking in read() while holding sync_mutex: another thread
+ // may have already consumed the byte that made select() wake us.
+ struct pollfd pfd = {STDIN_FILENO, POLLIN, 0};
+ if (poll(&pfd, 1, 0) <= 0)
+ return rdln::partial;
+
+ update_columns();
+ errno = 0;
+ char* result = linenoiseEditFeed(&line_state);
+
+ if (result == linenoiseEditMore)
+ return rdln::partial;
+
+ if (result == NULL && errno == EINTR)
+ {
+ return rdln::partial;
+ }
+
+ const bool cancelled = (result == NULL && errno == EAGAIN);
+
+ if (result == NULL)
+ {
+ if (!cancelled)
+ {
+ end_edit();
+ return rdln::empty;
+ }
+ reset_line();
+ try { std::thread([]{ raise(SIGINT); }).detach(); }
+ catch (const std::system_error&) { raise(SIGINT); }
+ return rdln::partial;
+ }
+
+ line = strip_unsafe_bytes(result);
+ std::string test_line = line;
+ boost::trim_right(test_line);
+ if (!test_line.empty())
+ linenoiseHistoryAdd(test_line.c_str());
+ linenoiseFree(result);
+ reset_line();
+ return rdln::full;
}
void rdln::readline_buffer::set_prompt(const std::string& prompt)
{
boost::lock_guard<boost::mutex> lock(sync_mutex);
if(m_cout_buf == NULL)
return;
- rl_set_prompt(std::string(m_prompt_length, ' ').c_str());
- rl_redisplay();
- rl_set_prompt(prompt.c_str());
- rl_redisplay();
- m_prompt_length = prompt.size();
+ if (editing_active)
+ {
+ if (tty_editing) linenoiseHide(&line_state);
+ current_prompt = prompt;
+ line_state.prompt = current_prompt.c_str();
+ line_state.plen = current_prompt.size();
+ if (tty_editing) linenoiseShow(&line_state);
+ }
+ else
+ {
+ current_prompt = prompt;
+ begin_edit();
+ }
}
void rdln::readline_buffer::add_completion(const std::string& command)
@@ -123,141 +289,25 @@ int rdln::readline_buffer::sync()
return -1;
}
-#if RL_READLINE_VERSION < 0x0700
- char lbuf[2] = {0,0};
- char *line = NULL;
- int end = 0, point = 0;
-#endif
-
- if (rl_end || (rl_prompt && *rl_prompt))
- {
-#if RL_READLINE_VERSION >= 0x0700
- rl_clear_visible_line();
-#else
- line = rl_line_buffer;
- end = rl_end;
- point = rl_point;
- rl_line_buffer = lbuf;
- rl_end = 0;
- rl_point = 0;
- rl_save_prompt();
- rl_redisplay();
-#endif
- }
+ update_columns();
+ if (editing_active && tty_editing)
+ linenoiseHide(&line_state);
- do
+ while ( this->sgetc() != EOF )
{
m_cout_buf->sputc( this->sgetc() );
+ this->snextc();
}
- while ( this->snextc() != EOF );
-
-#if RL_READLINE_VERSION < 0x0700
- if (end || (rl_prompt && *rl_prompt))
- {
- rl_restore_prompt();
- rl_line_buffer = line;
- rl_end = end;
- rl_point = point;
- }
-#endif
- rl_on_new_line();
- rl_redisplay();
- return 0;
-}
+ m_cout_buf->pubsync();
-static void handle_line(char* line)
-{
- bool exit = false;
- if (line)
- {
- line_stat = rdln::full;
- the_line = line;
- std::string test_line = line;
- boost::trim_right(test_line);
- if(!test_line.empty())
- {
- if (!same_as_last_line(test_line))
- {
- add_history(test_line.c_str());
- history_set_pos(history_length);
- }
- if (test_line == "exit" || test_line == "q")
- exit = true;
- }
- } else
- /* EOF */
- {
- line_stat = rdln::empty;
- exit = true;
- }
- rl_done = 1;
- if (exit)
- rl_set_prompt("");
- return;
-}
+ if (editing_active && tty_editing)
+ linenoiseShow(&line_state);
-// same_as_last_line returns true, if the last line in the history is
-// equal to test_line.
-static bool same_as_last_line(const std::string& test_line)
-{
- // Note that state->offset == state->length, when a new line was entered.
- auto state = std::unique_ptr<HISTORY_STATE, decltype(free)*>{history_get_history_state(), free};
- return state->length > 0
- && test_line.compare(state->entries[state->length-1]->line) == 0;
-}
-
-static char* completion_matches(const char* text, int state)
-{
- static size_t list_index;
- static size_t len;
-
- if(state == 0)
- {
- list_index = 0;
- len = strlen(text);
- }
-
- const std::vector<std::string>& completions = rdln::readline_buffer::get_completions();
- for(; list_index<completions.size(); )
- {
- const std::string& cmd = completions[list_index++];
- if(cmd.compare(0, len, text) == 0)
- {
- return strdup(cmd.c_str());
- }
- }
-
- return NULL;
-}
-
-static char** attempted_completion(const char* text, int start, int end)
-{
- rl_attempted_completion_over = 1;
- return rl_completion_matches(text, completion_matches);
-}
-
-static void install_line_handler()
-{
-#if RL_READLINE_VERSION >= 0x0801
- rl_variable_bind("enable-bracketed-paste", "off");
-#endif
-
- rl_attempted_completion_function = attempted_completion;
- rl_callback_handler_install("", handle_line);
- stifle_history(500);
-}
-
-static void remove_line_handler()
-{
- rl_replace_line("", 0);
- rl_set_prompt("");
- rl_redisplay();
- rl_callback_handler_remove();
+ return 0;
}
void rdln::clear_screen()
{
- rl_clear_screen(0, 0);
+ linenoiseClearScreen();
}
-
### external/CMakeLists.txt
@@ -37,6 +37,9 @@ option(MX25519_COPYLEFT "Include the MPL-2.0 licensed assembly backends (ARM64,
add_subdirectory(db_drivers)
add_subdirectory(easylogging++)
+if(NOT WIN32)
+ add_subdirectory(linenoise)
+endif()
add_subdirectory(mx25519 EXCLUDE_FROM_ALL)
add_subdirectory(qrcodegen)
add_subdirectory(randomx EXCLUDE_FROM_ALL)
### external/linenoise/CMakeLists.txt
@@ -0,0 +1,8 @@
+project(linenoise C)
+
+add_library(linenoise STATIC linenoise.c)
+set_target_properties(linenoise PROPERTIES POSITION_INDEPENDENT_CODE ON)
+
+target_compile_definitions(linenoise PRIVATE _DEFAULT_SOURCE)
+
+target_include_directories(linenoise PUBLIC ${CMAKE_CURRENT_SOURCE_DIR})
### external/linenoise/linenoise.c
@@ -0,0 +1,2580 @@
+/* linenoise.c -- guerrilla line editing library against the idea that a
+ * line editing lib needs to be 20,000 lines of C code.
+ *
+ * You can find the latest source code at:
+ *
+ * http://github.com/antirez/linenoise
+ *
+ * Does a number of crazy assumptions that happen to be true in 99.9999% of
+ * the 2010 UNIX computers around.
+ *
+ * ------------------------------------------------------------------------
+ *
+ * Copyright (c) 2010-2023, Salvatore Sanfilippo <antirez at gmail dot com>
+ * Copyright (c) 2010-2013, Pieter Noordhuis <pcnoordhuis at gmail dot com>
+ *
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ * * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *
+ * * Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * ------------------------------------------------------------------------
+ *
+ * References:
+ * - http://invisible-island.net/xterm/ctlseqs/ctlseqs.html
+ * - http://www.3waylabs.com/nw/WWW/products/wizcon/vt220.html
+ *
+ * Todo list:
+ * - Filter bogus Ctrl+<char> combinations.
+ * - Win32 support
+ *
+ * Bloat:
+ * - History search like Ctrl+r in readline?
+ *
+ * List of escape sequences used by this program, we do everything just
+ * with three sequences. In order to be so cheap we may have some
+ * flickering effect with some slow terminal, but the lesser sequences
+ * the more compatible.
+ *
+ * EL (Erase Line)
+ * Sequence: ESC [ n K
+ * Effect: if n is 0 or missing, clear from cursor to end of line
+ * Effect: if n is 1, clear from beginning of line to cursor
+ * Effect: if n is 2, clear entire line
+ *
+ * CUF (CUrsor Forward)
+ * Sequence: ESC [ n C
+ * Effect: moves cursor forward n chars
+ *
+ * CUB (CUrsor Backward)
+ * Sequence: ESC [ n D
+ * Effect: moves cursor backward n chars
+ *
+ * The following is used to get the terminal width if getting
+ * the width with the TIOCGWINSZ ioctl fails
+ *
+ * DSR (Device Status Report)
+ * Sequence: ESC [ 6 n
+ * Effect: reports the current cusor position as ESC [ n ; m R
+ * where n is the row and m is the column
+ *
+ * When multi line mode is enabled, we also use an additional escape
+ * sequence. However multi line editing is disabled by default.
+ *
+ * CUU (Cursor Up)
+ * Sequence: ESC [ n A
+ * Effect: moves cursor up of n chars.
+ *
+ * CUD (Cursor Down)
+ * Sequence: ESC [ n B
+ * Effect: moves cursor down of n chars.
+ *
+ * When linenoiseClearScreen() is called, two additional escape sequences
+ * are used in order to clear the screen and position the cursor at home
+ * position.
+ *
+ * CUP (Cursor position)
+ * Sequence: ESC [ H
+ * Effect: moves the cursor to upper left corner
+ *
+ * ED (Erase display)
+ * Sequence: ESC [ 2 J
+ * Effect: clear the whole screen
+ *
+ */
+
+#include <termios.h>
+#include <unistd.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <errno.h>
+#include <string.h>
+#include <stdlib.h>
+#include <ctype.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+#include <sys/ioctl.h>
+#include <sys/select.h>
+#include <unistd.h>
+#include <stdint.h>
+#include <time.h>
+#include "linenoise.h"
+
+#define LINENOISE_DEFAULT_HISTORY_MAX_LEN 100
+#define LINENOISE_MAX_LINE (1024*1024) // That will get dynamically allocated
+#define LINENOISE_INITIAL_BUFLEN 4096
+#define PASTE_FOLD_CONTEXT 8 // Context chars kept around generic folds.
+#define PASTE_MAX_BYTES LINENOISE_MAX_LINE
+static char *unsupported_term[] = {"dumb","cons25","emacs",NULL};
+static linenoiseCompletionCallback *completionCallback = NULL;
+static linenoiseHintsCallback *hintsCallback = NULL;
+static linenoiseFreeHintsCallback *freeHintsCallback = NULL;
+static char *linenoiseReadLine(FILE *fp, int *err);
+static char *linenoiseNoTTY(void);
+static char *linenoiseNoTTYFeed(void);
+static char *linenoiseEditPasteFeed(struct linenoiseState *l);
+static void refreshLineWithCompletion(struct linenoiseState *ls, linenoiseCompletions *lc, int flags);
+static void refreshLineWithFlags(struct linenoiseState *l, int flags);
+static void linenoiseFoldClear(struct linenoiseState *l);
+
+static struct termios orig_termios; /* In order to restore at exit.*/
+static int maskmode = 0; /* Show "***" instead of input. For passwords. */
+static int rawmode = 0; /* For atexit() function to check if restore is needed*/
+static int mlmode = 0; /* Multi line mode. Default is single line. */
+static int atexit_registered = 0; /* Register atexit just 1 time. */
+static int history_max_len = LINENOISE_DEFAULT_HISTORY_MAX_LEN;
+static int history_len = 0;
+static char **history = NULL;
+
+/* =========================== UTF-8 support ================================ */
+
+/* Return the number of bytes that compose the UTF-8 character starting at
+ * 'c'. This function assumes a valid UTF-8 encoding and handles the four
+ * standard byte patterns:
+ * 0xxxxxxx -> 1 byte (ASCII)
+ * 110xxxxx -> 2 bytes
+ * 1110xxxx -> 3 bytes
+ * 11110xxx -> 4 bytes */
+static int utf8ByteLen(char c) {
+ unsigned char uc = (unsigned char)c;
+ if ((uc & 0x80) == 0) return 1; /* 0xxxxxxx: ASCII */
+ if ((uc & 0xE0) == 0xC0) return 2; /* 110xxxxx: 2-byte seq */
+ if ((uc & 0xF0) == 0xE0) return 3; /* 1110xxxx: 3-byte seq */
+ if ((uc & 0xF8) == 0xF0) return 4; /* 11110xxx: 4-byte seq */
+ return 1; /* Fallback for invalid encoding, treat as single byte. */
+}
+
+/* Decode a UTF-8 sequence starting at 's' into a Unicode codepoint. 'avail'
+ * is the number of bytes actually available at 's'; a lead byte declaring a
+ * sequence longer than 'avail' is treated as invalid/truncated rather than
+ * reading past the available bytes. Returns the codepoint value. */
+static int utf8IsCont(unsigned char b) {
+ return (b & 0xC0) == 0x80;
+}
+
+static uint32_t utf8DecodeChar(const char *s, size_t avail, size_t *len) {
+ unsigned char *p = (unsigned char *)s;
+ uint32_t cp;
+
+ if (avail == 0) {
+ *len = 0;
+ return 0;
+ }
+ if ((*p & 0x80) == 0) {
+ *len = 1;
+ return *p;
+ } else if ((*p & 0xE0) == 0xC0 && avail >= 2 &&
+ utf8IsCont(p[1])) {
+ *len = 2;
+ cp = (*p & 0x1F) << 6;
+ cp |= (p[1] & 0x3F);
+ return cp;
+ } else if ((*p & 0xF0) == 0xE0 && avail >= 3 &&
+ utf8IsCont(p[1]) && utf8IsCont(p[2])) {
+ *len = 3;
+ cp = (*p & 0x0F) << 12;
+ cp |= (p[1] & 0x3F) << 6;
+ cp |= (p[2] & 0x3F);
+ return cp;
+ } else if ((*p & 0xF8) == 0xF0 && avail >= 4 &&
+ utf8IsCont(p[1]) && utf8IsCont(p[2]) && utf8IsCont(p[3])) {
+ *len = 4;
+ cp = (*p & 0x07) << 18;
+ cp |= (p[1] & 0x3F) << 12;
+ cp |= (p[2] & 0x3F) << 6;
+ cp |= (p[3] & 0x3F);
+ return cp;
+ }
+ *len = 1;
+ return *p; /* Fallback for invalid or truncated sequences. */
+}
+
+/* Check if codepoint is a variation selector (emoji style modifiers). */
+static int isVariationSelector(uint32_t cp) {
+ return cp == 0xFE0E || cp == 0xFE0F; /* Text/emoji style */
+}
+
+/* Check if codepoint is a skin tone modifier. */
+static int isSkinToneModifier(uint32_t cp) {
+ return cp >= 0x1F3FB && cp <= 0x1F3FF;
+}
+
+/* Check if codepoint is Zero Width Joiner. */
+static int isZWJ(uint32_t cp) {
+ return cp == 0x200D;
+}
+
+/* Check if codepoint is a Regional Indicator (for flag emoji). */
+static int isRegionalIndicator(uint32_t cp) {
+ return cp >= 0x1F1E6 && cp <= 0x1F1FF;
+}
+
+/* Check if codepoint is a combining mark or other zero-width character. */
+static int isCombiningMark(uint32_t cp) {
+ return (cp >= 0x0300 && cp <= 0x036F) || /* Combining Diacriticals */
+ (cp >= 0x1AB0 && cp <= 0x1AFF) || /* Combining Diacriticals Extended */
+ (cp >= 0x1DC0 && cp <= 0x1DFF) || /* Combining Diacriticals Supplement */
+ (cp >= 0x20D0 && cp <= 0x20FF) || /* Combining Diacriticals for Symbols */
+ (cp >= 0xFE20 && cp <= 0xFE2F); /* Combining Half Marks */
+}
+
+/* Check if codepoint extends the previous character (doesn't start a new grapheme). */
+static int isGraphemeExtend(uint32_t cp) {
+ return isVariationSelector(cp) || isSkinToneModifier(cp) ||
+ isZWJ(cp) || isCombiningMark(cp);
+}
+
+/* Decode the UTF-8 codepoint ending at position 'pos' (exclusive) and
+ * return its value. Also sets *cplen to the byte length of the codepoint. */
+static uint32_t utf8DecodePrev(const char *buf, size_t pos, size_t *cplen) {
+ if (pos == 0) {
+ *cplen = 0;
+ return 0;
+ }
+ /* Scan backwards to find the start byte. */
+ size_t i = pos;
+ do {
+ i--;
+ } while (i > 0 && (pos - i) < 4 && ((unsigned char)buf[i] & 0xC0) == 0x80);
+ *cplen = pos - i;
+ size_t dummy;
+ return utf8DecodeChar(buf + i, pos - i, &dummy);
+}
+
+/* Given a buffer and a position, return the byte length of the grapheme
+ * cluster before that position. A grapheme cluster includes:
+ * - The base character
+ * - Any following variation selectors, skin tone modifiers
+ * - ZWJ sequences (emoji joined by Zero Width Joiner)
+ * - Regional indicator pairs (flag emoji) */
+static size_t utf8PrevCharLen(const char *buf, size_t pos) {
+ if (pos == 0) return 0;
+
+ size_t total = 0;
+ size_t curpos = pos;
+
+ /* First, get the last codepoint. */
+ size_t cplen;
+ uint32_t cp = utf8DecodePrev(buf, curpos, &cplen);
+ if (cplen == 0) return 0;
+ total += cplen;
+ curpos -= cplen;
+
+ /* If we're at an extending character, we need to find what it extends.
+ * Keep going back through the grapheme cluster. */
+ while (curpos > 0) {
+ size_t prevlen;
+ uint32_t prevcp = utf8DecodePrev(buf, curpos, &prevlen);
+ if (prevlen == 0) break;
+
+ if (isZWJ(prevcp)) {
+ /* ZWJ joins two emoji. Include the ZWJ and continue to get
+ * the preceding character. */
+ total += prevlen;
+ curpos -= prevlen;
+ /* Now get the character before ZWJ. */
+ prevcp = utf8DecodePrev(buf, curpos, &prevlen);
+ if (prevlen == 0) break;
+ total += prevlen;
+ curpos -= prevlen;
+ cp = prevcp;
+ continue; /* Check if there's more extending before this. */
+ } else if (isGraphemeExtend(cp)) {
+ /* Current cp is an extending character; include previous. */
+ total += prevlen;
+ curpos -= prevlen;
+ cp = prevcp;
+ continue;
+ } else if (isRegionalIndicator(cp) && isRegionalIndicator(prevcp)) {
+ /* Two regional indicators form a flag. But we need to be careful:
+ * flags are always pairs, so only join if we're at an even boundary.
+ * For simplicity, just join one pair. */
+ total += prevlen;
+ curpos -= prevlen;
+ break;
+ } else {
+ /* No more extending; we've found the start of the cluster. */
+ break;
+ }
+ }
+
+ return total;
+}
+
+/* Given a buffer, position and total length, return the byte length of the
+ * grapheme cluster at the current position. */
+static size_t utf8NextCharLen(const char *buf, size_t pos, size_t len) {
+ if (pos >= len) return 0;
+
+ size_t total = 0;
+ size_t curpos = pos;
+
+ /* Get the first codepoint. */
+ size_t cplen;
+ uint32_t cp = utf8DecodeChar(buf + curpos, len - curpos, &cplen);
+ total += cplen;
+ curpos += cplen;
+
+ int isRI = isRegionalIndicator(cp);
+
+ /* Consume any extending characters that follow. */
+ while (curpos < len) {
+ size_t nextlen;
+ uint32_t nextcp = utf8DecodeChar(buf + curpos, len - curpos, &nextlen);
+
+ if (isZWJ(nextcp) && curpos + nextlen < len) {
+ /* ZWJ: include it and the following character. */
+ total += nextlen;
+ curpos += nextlen;
+ /* Get the character after ZWJ. */
+ nextcp = utf8DecodeChar(buf + curpos, len - curpos, &nextlen);
+ total += nextlen;
+ curpos += nextlen;
+ continue; /* Check for more extending after the joined char. */
+ } else if (isGraphemeExtend(nextcp)) {
+ /* Variation selector, skin tone, combining mark, etc. */
+ total += nextlen;
+ curpos += nextlen;
+ continue;
+ } else if (isRI && isRegionalIndicator(nextcp)) {
+ /* Second regional indicator for a flag pair. */
+ total += nextlen;
+ curpos += nextlen;
+ isRI = 0; /* Only pair once. */
+ continue;
+ } else {
+ break;
+ }
+ }
+
+ return total;
+}
+
+/* Return the display width of a Unicode codepoint. This is a heuristic
+ * that works for most common cases:
+ * - Control chars and zero-width: 0 columns
+ * - Grapheme-extending chars (VS, skin tone, ZWJ): 0 columns
+ * - ASCII printable: 1 column
+ * - Wide chars (CJK, emoji, fullwidth): 2 columns
+ * - Everything else: 1 column
+ *
+ * This is not a full wcwidth() implementation, but a minimal heuristic
+ * that handles emoji and CJK characters reasonably well. */
+static int utf8CharWidth(uint32_t cp) {
+ /* Control characters and combining marks: zero width. */
+ if (cp < 32 || (cp >= 0x7F && cp < 0xA0)) return 0;
+ if (isCombiningMark(cp)) return 0;
+
+ /* Grapheme-extending characters: zero width.
+ * These modify the preceding character rather than taking space. */
+ if (isVariationSelector(cp)) return 0;
+ if (isSkinToneModifier(cp)) return 0;
+ if (isZWJ(cp)) return 0;
+
+ /* Wide character ranges - these display as 2 columns:
+ * - CJK Unified Ideographs and Extensions
+ * - Fullwidth forms
+ * - Various emoji ranges */
+ if (cp >= 0x1100 &&
+ (cp <= 0x115F || /* Hangul Jamo */
+ cp == 0x2329 || cp == 0x232A || /* Angle brackets */
+ (cp >= 0x231A && cp <= 0x231B) || /* Watch, Hourglass */
+ (cp >= 0x23E9 && cp <= 0x23F3) || /* Various symbols */
+ (cp >= 0x23F8 && cp <= 0x23FA) || /* Various symbols */
+ (cp >= 0x25AA && cp <= 0x25AB) || /* Small squares */
+ (cp >= 0x25B6 && cp <= 0x25C0) || /* Play/reverse buttons */
+ (cp >= 0x25FB && cp <= 0x25FE) || /* Squares */
+ (cp >= 0x2600 && cp <= 0x26FF) || /* Misc Symbols (sun, cloud, etc) */
+ (cp >= 0x2700 && cp <= 0x27BF) || /* Dingbats (❤, ✂, etc) */
+ (cp >= 0x2934 && cp <= 0x2935) || /* Arrows */
+ (cp >= 0x2B05 && cp <= 0x2B07) || /* Arrows */
+ (cp >= 0x2B1B && cp <= 0x2B1C) || /* Squares */
+ cp == 0x2B50 || cp == 0x2B55 || /* Star, circle */
+ (cp >= 0x2E80 && cp <= 0xA4CF &&
+ cp != 0x303F) || /* CJK ... Yi */
+ (cp >= 0xAC00 && cp <= 0xD7A3) || /* Hangul Syllables */
+ (cp >= 0xF900 && cp <= 0xFAFF) || /* CJK Compatibility Ideographs */
+ (cp >= 0xFE10 && cp <= 0xFE1F) || /* Vertical forms */
+ (cp >= 0xFE30 && cp <= 0xFE6F) || /* CJK Compatibility Forms */
+ (cp >= 0xFF00 && cp <= 0xFF60) || /* Fullwidth Forms */
+ (cp >= 0xFFE0 && cp <= 0xFFE6) || /* Fullwidth Signs */
+ (cp >= 0x1F1E6 && cp <= 0x1F1FF) || /* Regional Indicators (flags) */
+ (cp >= 0x1F300 && cp <= 0x1F64F) || /* Misc Symbols and Emoticons */
+ (cp >= 0x1F680 && cp <= 0x1F6FF) || /* Transport and Map Symbols */
+ (cp >= 0x1F900 && cp <= 0x1F9FF) || /* Supplemental Symbols */
+ (cp >= 0x1FA00 && cp <= 0x1FAFF) || /* Chess, Extended-A */
+ (cp >= 0x20000 && cp <= 0x2FFFF))) /* CJK Extension B and beyond */
+ return 2;
+
+ return 1; /* Default: single width */
+}
+
+/* If s[] points at an ANSI CSI escape sequence (e.g. a color change like
+ * ESC [ 1 ; 32 m), return its length in bytes. Otherwise return 0.
+ *
+ * The caller must have already verified that s[0] == ESC (0x1b). The
+ * sequence layout follows ECMA-48: ESC '[' , parameter bytes (0x30-0x3f),
+ * intermediate bytes (0x20-0x2f), and a final byte (0x40-0x7e). */
+static size_t ansiEscapeLen(const char *s, size_t len) {
+ size_t i;
+ if (len < 2 || s[1] != '[') return 0;
+ i = 2;
+ while (i < len && (unsigned char)s[i] >= 0x30 && (unsigned char)s[i] <= 0x3f) i++;
+ while (i < len && (unsigned char)s[i] >= 0x20 && (unsigned char)s[i] <= 0x2f) i++;
+ if (i >= len || (unsigned char)s[i] < 0x40 || (unsigned char)s[i] > 0x7e) return 0;
+ return i + 1;
+}
+
+/* Calculate the display width of a UTF-8 string of 'len' bytes.
+ * This is used for cursor positioning in the terminal.
+ * Handles grapheme clusters: characters joined by ZWJ contribute 0 width
+ * after the first character in the sequence.
+ * ANSI CSI escape sequences (e.g. color codes in the prompt) are treated
+ * as zero-width. */
+static size_t utf8StrWidth(const char *s, size_t len) {
+ size_t width = 0;
+ size_t i = 0;
+ int after_zwj = 0; /* Track if previous char was ZWJ */
+
+ while (i < len) {
+ size_t clen;
+ uint32_t cp = utf8DecodeChar(s + i, len - i, &clen);
+
+ /* Skip ANSI CSI escape sequences entirely: they produce no
+ * glyph, so they must not contribute to the display width.
+ * Checked before the ZWJ state so a stray ZWJ immediately
+ * followed by ESC cannot swallow the ESC byte. */
+ if (cp == 0x1b) {
+ size_t skip = ansiEscapeLen(s + i, len - i);
+ if (skip > 0) {
+ i += skip;
+ continue;
+ }
+ }
+
+ if (after_zwj) {
+ /* Character after ZWJ: don't add width, it's joined.
+ * But do check for extending chars after it. */
+ after_zwj = 0;
+ } else {
+ width += utf8CharWidth(cp);
+ }
+
+ /* Check if this is a ZWJ - next char will be joined. */
+ if (isZWJ(cp)) {
+ after_zwj = 1;
+ }
+
+ i += clen;
+ }
+ return width;
+}
+
+/* Return the display width of a single UTF-8 character at position 's'. */
+static int utf8SingleCharWidth(const char *s, size_t len) {
+ if (len == 0) return 0;
+ size_t clen;
+ uint32_t cp = utf8DecodeChar(s, len, &clen);
+ return utf8CharWidth(cp);
+}
+
+enum KEY_ACTION{
+ KEY_NULL = 0, /* NULL */
+ CTRL_A = 1, /* Ctrl+a */
+ CTRL_B = 2, /* Ctrl-b */
+ CTRL_C = 3, /* Ctrl-c */
+ CTRL_D = 4, /* Ctrl-d */
+ CTRL_E = 5, /* Ctrl-e */
+ CTRL_F = 6, /* Ctrl-f */
+ CTRL_H = 8, /* Ctrl-h */
+ TAB = 9, /* Tab */
+ CTRL_K = 11, /* Ctrl+k */
+ CTRL_L = 12, /* Ctrl+l */
+ ENTER = 13, /* Enter */
+ CTRL_N = 14, /* Ctrl-n */
+ CTRL_P = 16, /* Ctrl-p */
+ CTRL_T = 20, /* Ctrl-t */
+ CTRL_U = 21, /* Ctrl+u */
+ CTRL_W = 23, /* Ctrl+w */
+ ESC = 27, /* Escape */
+ BACKSPACE = 127 /* Backspace */
+};
+
+static void linenoiseAtExit(void);
+int linenoiseHistoryAdd(const char *line);
+#define REFRESH_CLEAN (1<<0) // Clean the old prompt from the screen
+#define REFRESH_WRITE (1<<1) // Rewrite the prompt on the screen.
+#define REFRESH_ALL (REFRESH_CLEAN|REFRESH_WRITE) // Do both.
+static void refreshLine(struct linenoiseState *l);
+
+/* Debugging macro. */
+#if 0
+FILE *lndebug_fp = NULL;
+#define lndebug(...) \
+ do { \
+ if (lndebug_fp == NULL) { \
+ lndebug_fp = fopen("/tmp/lndebug.txt","a"); \
+ fprintf(lndebug_fp, \
+ "[%d %d %d] p: %d, rows: %d, rpos: %d, max: %d, oldmax: %d\n", \
+ (int)l->len,(int)l->pos,(int)l->oldpos,plen,rows,rpos, \
+ (int)l->oldrows,old_rows); \
+ } \
+ fprintf(lndebug_fp, ", " __VA_ARGS__); \
+ fflush(lndebug_fp); \
+ } while (0)
+#else
+#define lndebug(fmt, ...)
+#endif
+
+/* ======================= Low level terminal handling ====================== */
+
+/* Enable "mask mode". When it is enabled, instead of the input that
+ * the user is typing, the terminal will just display a corresponding
+ * number of asterisks, like "****". This is useful for passwords and other
+ * secrets that should not be displayed. */
+void linenoiseMaskModeEnable(void) {
+ maskmode = 1;
+}
+
+/* Disable mask mode. */
+void linenoiseMaskModeDisable(void) {
+ maskmode = 0;
+}
+
+/* Set if to use or not the multi line mode. */
+void linenoiseSetMultiLine(int ml) {
+ mlmode = ml;
+}
+
+/* Return true if the terminal name is in the list of terminals we know are
+ * not able to understand basic escape sequences. */
+static int isUnsupportedTerm(void) {
+ char *term = getenv("TERM");
+ int j;
+
+ if (term == NULL) return 0;
+ for (j = 0; unsupported_term[j]; j++)
+ if (!strcasecmp(term,unsupported_term[j])) return 1;
+ return 0;
+}
+
+/* Raw mode: 1960 magic shit. */
+static int enableRawMode(int fd) {
+ struct termios raw;
+
+ /* Test mode: when LINENOISE_ASSUME_TTY is set, skip terminal setup.
+ * This allows testing via pipes without a real terminal. */
+ if (getenv("LINENOISE_ASSUME_TTY")) {
+ rawmode = 1;
+ return 0;
+ }
+
+ if (!isatty(STDIN_FILENO)) goto fatal;
+ if (!atexit_registered) {
+ atexit(linenoiseAtExit);
+ atexit_registered = 1;
+ }
+ if (tcgetattr(fd,&orig_termios) == -1) goto fatal;
+
+ raw = orig_termios; /* modify the original mode */
+ /* input modes: no break, no CR to NL, no parity check, no strip char,
+ * no start/stop output control. */
+ raw.c_iflag &= ~(BRKINT | ICRNL | INPCK | ISTRIP | IXON);
+ /* control modes - set 8 bit chars */
+ raw.c_cflag |= (CS8);
+ /* local modes - choing off, canonical off, no extended functions.
+ * ISIG stays enabled so ^C/^\ still deliver SIGINT/SIGQUIT through the
+ * kernel even while no read() is pending (e.g. while a command runs). */
+ raw.c_lflag &= ~(ECHO | ICANON | IEXTEN);
+ /* control chars - set return condition: min number of bytes and timer.
+ * We want read to return every single byte, without timeout. */
+ raw.c_cc[VMIN] = 1; raw.c_cc[VTIME] = 0; /* 1 byte, no timer */
+ raw.c_cc[VSUSP] = _POSIX_VDISABLE; /* keep ^Z from suspending the process */
+
+ /* put terminal in raw mode; TCSADRAIN (not TCSAFLUSH) so input already
+ * queued by the terminal driver survives the mode switch. */
+ if (tcsetattr(fd,TCSADRAIN,&raw) < 0) goto fatal;
+ rawmode = 1;
+ return 0;
+
+fatal:
+ errno = ENOTTY;
+ return -1;
+}
+
+static void disableRawMode(int fd) {
+ /* Test mode: nothing to restore. */
+ if (getenv("LINENOISE_ASSUME_TTY")) {
+ rawmode = 0;
+ return;
+ }
+ /* Don't even check the return value as it's too late. TCSADRAIN, not
+ * TCSAFLUSH: this runs on every PAUSE_READLINE, and TCSAFLUSH discards
+ * whatever the user typed ahead while a background message was printing. */
+ if (rawmode && tcsetattr(fd,TCSADRAIN,&orig_termios) != -1) {
+ rawmode = 0;
+ }
+}
+
+/* Use the ESC [6n escape sequence to query the horizontal cursor position
+ * and return it. On error -1 is returned, on success the position of the
+ * cursor. */
+static int getCursorPosition(int ifd, int ofd) {
+ char buf[32];
+ int cols, rows;
+ unsigned int i = 0;
+
+ /* Report cursor location */
+ if (write(ofd, "\x1b[6n", 4) != 4) return -1;
+
+ /* Read the response: ESC [ rows ; cols R */
+ while (i < sizeof(buf)-1) {
+ if (read(ifd,buf+i,1) != 1) break;
+ if (buf[i] == 'R') break;
+ i++;
+ }
+ buf[i] = '\0';
+
+ /* Parse it. */
+ if (buf[0] != ESC || buf[1] != '[') return -1;
+ if (sscanf(buf+2,"%d;%d",&rows,&cols) != 2) return -1;
+ return cols;
+}
+
+/* Try to get the number of columns in the current terminal, or assume 80
+ * if it fails. */
+static int getColumns(int ifd, int ofd) {
+ struct winsize ws;
+
+ /* Test mode: use LINENOISE_COLS env var for fixed width. */
+ char *cols_env = getenv("LINENOISE_COLS");
+ if (cols_env) return atoi(cols_env);
+
+ if (ioctl(1, TIOCGWINSZ, &ws) == -1 || ws.ws_col == 0) {
+ /* ioctl() failed. Try to query the terminal itself. */
+ int start, cols;
+
+ /* Get the initial position so we can restore it later. */
+ start = getCursorPosition(ifd,ofd);
+ if (start == -1) goto failed;
+
+ /* Go to right margin and get position. */
+ if (write(ofd,"\x1b[999C",6) != 6) goto failed;
+ cols = getCursorPosition(ifd,ofd);
+ if (cols == -1) goto failed;
+
+ /* Restore position. */
+ if (cols > start) {
+ char seq[32];
+ snprintf(seq,32,"\x1b[%dD",cols-start);
+ if (write(ofd,seq,strlen(seq)) == -1) {
+ /* Can't recover... */
+ }
+ }
+ return cols;
+ } else {
+ return ws.ws_col;
+ }
+
+failed:
+ return 80;
+}
+
+/* Clear the screen. Used to handle ctrl+l */
+void linenoiseClearScreen(void) {
+ if (write(STDOUT_FILENO,"\x1b[H\x1b[2J",7) <= 0) {
+ /* nothing to do, just to avoid warning. */
+ }
+}
+
+/* Beep, used for completion when there is nothing to complete or when all
+ * the choices were already shown. */
+static void linenoiseBeep(void) {
+ fprintf(stderr, "\x7");
+ fflush(stderr);
+}
+
+/* ============================== Completion ================================ */
+
+/* Free a list of completion option populated by linenoiseAddCompletion(). */
+static void freeCompletions(linenoiseCompletions *lc) {
+ size_t i;
+ for (i = 0; i < lc->len; i++)
+ free(lc->cvec[i]);
+ if (lc->cvec != NULL)
+ free(lc->cvec);
+}
+
+/* Called by completeLine() and linenoiseShow() to render the current
+ * edited line with the proposed completion. If the current completion table
+ * is already available, it is passed as second argument, otherwise the
+ * function will use the callback to obtain it.
+ *
+ * Flags are the same as refreshLine*(), that is REFRESH_* macros. */
+static void refreshLineWithCompletion(struct linenoiseState *ls, linenoiseCompletions *lc, int flags) {
+ /* Obtain the table of completions if the caller didn't provide one. */
+ linenoiseCompletions ctable = { 0, NULL };
+ if (lc == NULL) {
+ completionCallback(ls->buf,&ctable);
+ lc = &ctable;
+ }
+
+ /* Show the edited line with completion if possible, or just refresh. */
+ if (ls->completion_idx < lc->len) {
+ struct linenoiseState saved = *ls;
+ ls->len = ls->pos = strlen(lc->cvec[ls->completion_idx]);
+ ls->buf = lc->cvec[ls->completion_idx];
+ ls->fold_count = 0;
+ refreshLineWithFlags(ls,flags);
+ ls->len = saved.len;
+ ls->pos = saved.pos;
+ ls->buf = saved.buf;
+ ls->fold_count = saved.fold_count;
+ } else {
+ refreshLineWithFlags(ls,flags);
+ }
+
+ /* Free the completions table if needed. */
+ if (lc == &ctable) freeCompletions(&ctable);
+}
+
+/* This is an helper function for linenoiseEdit*() and is called when the
+ * user types the <tab> key in order to complete the string currently in the
+ * input.
+ *
+ * The state of the editing is encapsulated into the pointed linenoiseState
+ * structure as described in the structure definition.
+ *
+ * If the function returns non-zero, the caller should handle the
+ * returned value as a byte read from the standard input, and process
+ * it as usually: this basically means that the function may return a byte
+ * read from the termianl but not processed. Otherwise, if zero is returned,
+ * the input was consumed by the completeLine() function to navigate the
+ * possible completions, and the caller should read for the next characters
+ * from stdin. */
+static int completeLine(struct linenoiseState *ls, int keypressed) {
+ linenoiseCompletions lc = { 0, NULL };
+ int nwritten;
+ char c = keypressed;
+
+ completionCallback(ls->buf,&lc);
+ if (lc.len == 0) {
+ linenoiseBeep();
+ ls->in_completion = 0;
+ c = 0;
+ } else {
+ switch(c) {
+ case 9: /* tab */
+ if (ls->in_completion == 0) {
+ ls->in_completion = 1;
+ ls->completion_idx = 0;
+ } else {
+ ls->completion_idx = (ls->completion_idx+1) % (lc.len+1);
+ if (ls->completion_idx == lc.len) linenoiseBeep();
+ }
+ c = 0;
+ break;
+ case 27: /* escape */
+ /* Re-show original buffer */
+ if (ls->completion_idx < lc.len) refreshLine(ls);
+ ls->in_completion = 0;
+ break;
+ default:
+ /* Update buffer and return */
+ if (ls->completion_idx < lc.len) {
+ nwritten = snprintf(ls->buf,ls->buflen,"%s",
+ lc.cvec[ls->completion_idx]);
+ ls->len = ls->pos = nwritten;
+ linenoiseFoldClear(ls);
+ }
+ ls->in_completion = 0;
+ break;
+ }
+
+ /* Show completion or original buffer */
+ if (ls->in_completion && ls->completion_idx < lc.len) {
+ refreshLineWithCompletion(ls,&lc,REFRESH_ALL);
+ } else {
+ refreshLine(ls);
+ }
+ }
+
+ freeCompletions(&lc);
+ return c; /* Return last read character */
+}
+
+/* Register a callback function to be called for tab-completion. */
+void linenoiseSetCompletionCallback(linenoiseCompletionCallback *fn) {
+ completionCallback = fn;
+}
+
+/* Register a hits function to be called to show hits to the user at the
+ * right of the prompt. */
+void linenoiseSetHintsCallback(linenoiseHintsCallback *fn) {
+ hintsCallback = fn;
+}
+
+/* Register a function to free the hints returned by the hints callback
+ * registered with linenoiseSetHintsCallback(). */
+void linenoiseSetFreeHintsCallback(linenoiseFreeHintsCallback *fn) {
+ freeHintsCallback = fn;
+}
+
+/* This function is used by the callback function registered by the user
+ * in order to add completion options given the input string when the
+ * user typed <tab>. See the example.c source code for a very easy to
+ * understand example. */
+void linenoiseAddCompletion(linenoiseCompletions *lc, const char *str) {
+ size_t len = strlen(str);
+ char *copy, **cvec;
+
+ copy = malloc(len+1);
+ if (copy == NULL) return;
+ memcpy(copy,str,len+1);
+ cvec = realloc(lc->cvec,sizeof(char*)*(lc->len+1));
+ if (cvec == NULL) {
+ free(copy);
+ return;
+ }
+ lc->cvec = cvec;
+ lc->cvec[lc->len++] = copy;
+}
+
+/* =========================== Line editing ================================= */
+
+/* We define a very simple "append buffer" structure, that is an heap
+ * allocated string where we can append to. This is useful in order to
+ * write all the escape sequences in a buffer and flush them to the standard
+ * output in a single call, to avoid flickering effects. */
+struct abuf {
+ char *b;
+ int len;
+};
+
+static void abInit(struct abuf *ab) {
+ ab->b = NULL;
+ ab->len = 0;
+}
+
+static void abAppend(struct abuf *ab, const char *s, int len) {
+ char *new = realloc(ab->b,ab->len+len);
+
+ if (new == NULL) return;
+ memcpy(new+ab->len,s,len);
+ ab->b = new;
+ ab->len += len;
+}
+
+static void abFree(struct abuf *ab) {
+ free(ab->b);
+}
+
+/* A fold is a display-only replacement for a range in l->buf. The edited
+ * buffer always keeps the real bytes; refresh code asks linenoiseRenderBuffer()
+ * for a temporary printable version plus the cursor position inside it. */
+struct linenoiseFold {
+ size_t start;
+ size_t end;
+ char display[64];
+ size_t displaylen;
+};
+
+struct linenoiseFolds {
+ int count;
+ struct linenoiseFold fold[LINENOISE_MAX_FOLDS];
+};
+
+/* Return the number of logical lines in the range. */
+static size_t foldCountLines(const char *buf, size_t len) {
+ size_t lines = 1, j;
+ for (j = 0; j < len; j++) {
+ if (buf[j] == '\n') lines++;
+ }
+ return lines;
+}
+
+/* Return true if the text should be folded: only multi-line text is, so a
+ * long single-line paste (e.g. a wallet's own base58 output) stays visible. */
+static int shouldFoldText(const char *buf, size_t len) {
+ return memchr(buf, '\n', len) != NULL;
+}
+
+/* Fill f->display with the text shown instead of the folded range. */
+static void foldSetRenderedText(struct linenoiseFold *f, const char *buf) {
+ size_t hidden = f->end - f->start;
+ size_t lines = foldCountLines(buf + f->start, hidden);
+ int n;
+
+ if (lines > 1)
+ n = snprintf(f->display,sizeof(f->display),"[... %zu pasted lines ...]",lines);
+ else
+ n = snprintf(f->display,sizeof(f->display),"[... %zu pasted chars ...]",hidden);
+ if (n < 0) n = 0;
+ f->displaylen = (size_t)n;
+}
+
+/* Populate f with one fold reconstructed from a history entry. History stores
+ * the real text, but not the original paste boundaries, so we reconstruct
+ * an approximation of text we want to hide on the fly: if it is long or
+ * contains newlines. */
+static int linenoiseBuildHistoryFold(struct linenoiseState *l, struct linenoiseFold *f) {
+ f->start = f->end = f->displaylen = 0;
+ if (l->len == 0 || maskmode) return 0;
+ if (!shouldFoldText(l->buf,l->len)) return 0;
+
+ f->start = 0;
+ f->end = l->len;
+ if (l->len > PASTE_FOLD_CONTEXT*2) {
+ size_t pos = 0, chars = 0;
+ int nl = 0;
+
+ /* We leave (if possible) a few chars on
+ * the start before the fold, to give context. */
+ while (pos < l->len && chars < PASTE_FOLD_CONTEXT) {
+ size_t step = utf8NextCharLen(l->buf,pos,l->len);
+ if (step == 0 || pos + step > l->len) break;
+ if (l->buf[pos] == '\n') nl = 1;
+ pos += step;
+ chars++;
+ }
+ f->start = nl ? 0 : pos;
+
+ /* And also on the end side. */
+ pos = l->len;
+ chars = 0;
+ nl = 0;
+ while (pos > 0 && chars < PASTE_FOLD_CONTEXT) {
+ size_t step = utf8PrevCharLen(l->buf,pos);
+ if (step == 0 || step > pos) break;
+ pos -= step;
+ if (l->buf[pos] == '\n') nl = 1;
+ chars++;
+ }
+ f->end = nl ? l->len : pos;
+ if (f->start >= f->end) {
+ f->start = 0;
+ f->end = l->len;
+ }
+ }
+ foldSetRenderedText(f,l->buf);
+ return 1;
+}
+
+/* Populate fs with the folds to render for the current buffer. As a side
+ * effect, the rendered text of each fold is updated. Return 1 if folding
+ * should be used, or 0 if the buffer should be rendered as-is. */
+static int linenoiseGetRenderFolds(struct linenoiseState *l, struct linenoiseFolds *fs) {
+ int j;
+
+ fs->count = 0;
+ if (l->len == 0 || maskmode) return 0;
+
+ for (j = 0; j < l->fold_count; j++) {
+ struct linenoiseFold *f;
+ size_t start = l->fold_start[j];
+ size_t end = l->fold_end[j];
+
+ if (start >= end || end > l->len) continue;
+ f = fs->fold + fs->count++;
+ f->start = start;
+ f->end = end;
+ foldSetRenderedText(f,l->buf);
+ }
+ return fs->count != 0;
+}
+
+static size_t sanitizeForDisplay(const char *s, size_t len, char *out) {
+ size_t i, o = 0;
+ for (i = 0; i < len; ) {
+ unsigned char c = (unsigned char)s[i];
+ if (c < 0x20 || c == 0x7f) {
+ if (out) { out[o] = '^'; out[o+1] = (c == 0x7f) ? '?' : (char)(c ^ 0x40); }
+ o += 2;
+ i += 1;
+ continue;
+ }
+ {
+ size_t clen;
+ uint32_t cp = utf8DecodeChar(s+i, len-i, &clen);
+ if (clen == 0) clen = 1;
+ if (cp < 0x20 || cp == 0x7f || (cp >= 0x80 && cp <= 0x9f)) {
+ char tmp[8];
+ int n = snprintf(tmp,sizeof(tmp),"\\x%02X",(unsigned)cp);
+ if (n < 0) n = 0;
+ if (out) memcpy(out+o,tmp,(size_t)n);
+ o += (size_t)n;
+ } else {
+ if (out) memcpy(out+o,s+i,clen);
+ o += clen;
+ }
+ i += clen;
+ }
+ }
+ return o;
+}
+
+static char *sanitizeForDisplayAlloc(const char *s, size_t len, size_t *outlen) {
+ size_t slen = sanitizeForDisplay(s,len,NULL);
+ char *r = malloc(slen ? slen : 1);
+ if (r == NULL) return NULL;
+ sanitizeForDisplay(s,len,r);
+ *outlen = slen;
+ return r;
+}
+
+/* Return the freshly allocated string content that is actually displayed in
+ * the user prompt. It can be the actual edited line, or a special version
+ * where pasted or multiline history ranges are replaced by their folded
+ * "[...]" style versions. outpos is l->pos translated into this rendered
+ * buffer. */
+static int linenoiseRenderBuffer(struct linenoiseState *l, char **out, size_t *outlen, size_t *outpos) {
+ struct linenoiseFolds fs;
+ size_t len, pos, src, dst;
+ char *r;
+ int j, pos_set = 0;
+
+ if (!linenoiseGetRenderFolds(l,&fs)) {
+ /* Keep the refresh code simple: it always owns a temporary render
+ * buffer, even when the render is identical to the real edit buffer. */
+ len = sanitizeForDisplay(l->buf,l->len,NULL);
+ r = malloc(len+1);
+ if (r == NULL) return -1;
+ sanitizeForDisplay(l->buf,l->len,r);
+ r[len] = '\0';
+ *out = r;
+ *outlen = len;
+ pos = sanitizeForDisplay(l->buf,l->pos,NULL);
+ *outpos = pos > len ? len : pos;
+ return 0;
+ }
+
+ /* Gaps are sanitized and copied, folded ranges are replaced by their
+ * markers as-is (fixed text, not attacker bytes). The bytes inside each
+ * [start,end) range stay in l->buf but are not emitted to the terminal. */
+ len = 0;
+ src = 0;
+ for (j = 0; j < fs.count; j++) {
+ struct linenoiseFold *f = fs.fold+j;
+ len += sanitizeForDisplay(l->buf+src,f->start-src,NULL);
+ len += f->displaylen;
+ src = f->end;
+ }
+ len += sanitizeForDisplay(l->buf+src,l->len-src,NULL);
+ r = malloc(len+1);
+ if (r == NULL) return -1;
+
+ src = dst = 0;
+ pos = 0;
+ for (j = 0; j < fs.count; j++) {
+ struct linenoiseFold *f = fs.fold+j;
+
+ if (!pos_set && l->pos <= f->start) {
+ pos = dst + sanitizeForDisplay(l->buf+src,l->pos-src,NULL);
+ pos_set = 1;
+ }
+ dst += sanitizeForDisplay(l->buf+src,f->start-src,r+dst);
+
+ if (!pos_set && l->pos < f->end) {
+ pos = dst + f->displaylen;
+ pos_set = 1;
+ }
+ memcpy(r+dst,f->display,f->displaylen);
+ dst += f->displaylen;
+ if (!pos_set && l->pos == f->end) {
+ pos = dst;
+ pos_set = 1;
+ }
+ src = f->end;
+ }
+ if (!pos_set) pos = dst + sanitizeForDisplay(l->buf+src,l->pos-src,NULL);
+ dst += sanitizeForDisplay(l->buf+src,l->len-src,r+dst);
+ r[len] = '\0';
+
+ *out = r;
+ *outlen = len;
+ *outpos = pos > len ? len : pos;
+ return 0;
+}
+
+/* Return the number of bytes to move right from pos. If pos is at the start of
+ * a folded range, the whole hidden range is skipped by one cursor movement. */
+static size_t linenoiseEditNextLen(struct linenoiseState *l, size_t pos) {
+ struct linenoiseFolds fs;
+ int j;
+
+ if (linenoiseGetRenderFolds(l,&fs)) {
+ for (j = 0; j < fs.count; j++) {
+ if (pos == fs.fold[j].start)
+ return fs.fold[j].end - fs.fold[j].start;
+ }
+ }
+ return utf8NextCharLen(l->buf,pos,l->len);
+}
+
+/* Return the number of bytes to move left from pos. If pos is at the end of a
+ * folded range, the whole hidden range is skipped by one cursor movement. */
+static size_t linenoiseEditPrevLen(struct linenoiseState *l, size_t pos) {
+ struct linenoiseFolds fs;
+ int j;
+
+ if (linenoiseGetRenderFolds(l,&fs)) {
+ for (j = 0; j < fs.count; j++) {
+ if (pos == fs.fold[j].end)
+ return fs.fold[j].end - fs.fold[j].start;
+ }
+ }
+ return utf8PrevCharLen(l->buf,pos);
+}
+
+/* Add a fold range, keeping the array sorted by start offset. */
+static void linenoiseFoldAdd(struct linenoiseState *l, size_t start, size_t end) {
+ int j;
+
+ if (start >= end || l->fold_count == LINENOISE_MAX_FOLDS) return;
+ j = l->fold_count;
+ while (j > 0 && start < l->fold_start[j-1]) {
+ l->fold_start[j] = l->fold_start[j-1];
+ l->fold_end[j] = l->fold_end[j-1];
+ j--;
+ }
+ l->fold_start[j] = start;
+ l->fold_end[j] = end;
+ l->fold_count++;
+}
+
+/* Clear all remembered fold ranges. */
+static void linenoiseFoldClear(struct linenoiseState *l) {
+ l->fold_count = 0;
+}
+
+/* Remove one remembered fold range. */
+static void linenoiseFoldRemove(struct linenoiseState *l, int j) {
+ memmove(l->fold_start+j,l->fold_start+j+1,
+ sizeof(size_t)*(l->fold_count-j-1));
+ memmove(l->fold_end+j,l->fold_end+j+1,
+ sizeof(size_t)*(l->fold_count-j-1));
+ l->fold_count--;
+}
+
+/* Return true if [pos,pos+len) overlaps any folded range. */
+static int linenoiseRangeOverlapsFold(struct linenoiseState *l, size_t pos, size_t len) {
+ size_t end = pos + len;
+ int j;
+
+ for (j = 0; j < l->fold_count; j++) {
+ if (end > l->fold_start[j] && pos < l->fold_end[j])
+ return 1;
+ }
+ return 0;
+}
+
+/* Adjust fold ranges after an insertion. If insertion somehow lands inside a
+ * fold, remove that fold because it no longer maps to an unchanged range. */
+static void linenoiseAdjustFoldsAfterInsert(struct linenoiseState *l, size_t pos, size_t len) {
+ int j = 0;
+
+ while (j < l->fold_count) {
+ if (pos <= l->fold_start[j]) {
+ l->fold_start[j] += len;
+ l->fold_end[j] += len;
+ j++;
+ } else if (pos < l->fold_end[j]) {
+ linenoiseFoldRemove(l,j);
+ } else {
+ j++;
+ }
+ }
+}
+
+/* Adjust fold ranges after a deletion. If deletion overlaps a fold, remove
+ * that fold because it no longer maps to an unchanged range. */
+static void linenoiseAdjustFoldsAfterDelete(struct linenoiseState *l, size_t pos, size_t len) {
+ size_t end = pos + len;
+ int j = 0;
+
+ while (j < l->fold_count) {
+ if (end <= l->fold_start[j]) {
+ l->fold_start[j] -= len;
+ l->fold_end[j] -= len;
+ j++;
+ } else if (pos >= l->fold_end[j]) {
+ j++;
+ } else {
+ linenoiseFoldRemove(l,j);
+ }
+ }
+}
+
+/* Helper of refreshSingleLine() and refreshMultiLine() to show hints
+ * to the right of the prompt. Now uses display widths for proper UTF-8. */
+void refreshShowHints(struct abuf *ab, struct linenoiseState *l, int pwidth, size_t bufwidth) {
+ if (hintsCallback) {
+ char seq[64];
+ int color = -1, bold = 0;
+ char *hint;
+
+ if (pwidth + bufwidth >= l->cols) return;
+ hint = hintsCallback(l->buf,&color,&bold);
+ if (hint) {
+ size_t hintlen = strlen(hint);
+ size_t hintwidth = utf8StrWidth(hint, hintlen);
+ size_t hintmaxwidth = l->cols - (pwidth + bufwidth);
+ /* Truncate hint to fit, respecting UTF-8 boundaries. */
+ if (hintwidth > hintmaxwidth) {
+ size_t i = 0, w = 0;
+ while (i < hintlen) {
+ size_t clen = utf8NextCharLen(hint, i, hintlen);
+ int cwidth = utf8SingleCharWidth(hint + i, clen);
+ if (w + cwidth > hintmaxwidth) break;
+ w += cwidth;
+ i += clen;
+ }
+ hintlen = i;
+ }
+ if (bold == 1 && color == -1) color = 37;
+ if (color != -1 || bold != 0)
+ snprintf(seq,64,"\033[%d;%d;49m",bold,color);
+ else
+ seq[0] = '\0';
+ abAppend(ab,seq,strlen(seq));
+ abAppend(ab,hint,hintlen);
+ if (color != -1 || bold != 0)
+ abAppend(ab,"\033[0m",4);
+ /* Call the function to free the hint returned. */
+ if (freeHintsCallback) freeHintsCallback(hint);
+ }
+ }
+}
+
+/* Single line low level line refresh.
+ *
+ * Rewrite the currently edited line accordingly to the buffer content,
+ * cursor position, and number of columns of the terminal.
+ *
+ * Flags is REFRESH_* macros. The function can just remove the old
+ * prompt, just write it, or both.
+ *
+ * This function is UTF-8 aware and uses display widths (not byte counts)
+ * for cursor positioning and horizontal scrolling. */
+static void refreshSingleLine(struct linenoiseState *l, int flags) {
+ char seq[64];
+ size_t pwidth = utf8StrWidth(l->prompt, l->plen); /* Prompt display width */
+ int fd = l->ofd;
+ char *render = NULL;
+ char *buf;
+ size_t len; /* Byte length of buffer to display */
+ size_t pos; /* Byte position of cursor in display buffer */
+ size_t poscol; /* Display column of cursor */
+ size_t lencol; /* Display width of buffer */
+ size_t fullwidth; /* Display width before horizontal trimming. */
+ struct abuf ab;
+
+ if (linenoiseRenderBuffer(l,&render,&len,&pos) == -1) return;
+ buf = render;
+
+ /* Calculate the display width up to cursor and total display width. */
+ poscol = utf8StrWidth(buf, pos);
+ lencol = utf8StrWidth(buf, len);
+ fullwidth = lencol;
+
+ /* Scroll the buffer horizontally if cursor is past the right edge.
+ * We need to trim full UTF-8 characters from the left until the
+ * cursor position fits within the terminal width. */
+ while (pwidth + poscol >= l->cols) {
+ size_t clen = utf8NextCharLen(buf, 0, len);
+ if (clen == 0) break;
+ int cwidth = utf8SingleCharWidth(buf, clen);
+ buf += clen;
+ len -= clen;
+ pos -= clen;
+ poscol -= cwidth;
+ lencol -= cwidth;
+ }
+
+ /* Trim from the right if the line still doesn't fit. */
+ while (pwidth + lencol > l->cols) {
+ size_t clen = utf8PrevCharLen(buf, len);
+ if (clen == 0) break;
+ int cwidth = utf8SingleCharWidth(buf + len - clen, clen);
+ len -= clen;
+ lencol -= cwidth;
+ }
+
+ abInit(&ab);
+ /* Cursor to left edge */
+ snprintf(seq,sizeof(seq),"\r");
+ abAppend(&ab,seq,strlen(seq));
+
+ if (flags & REFRESH_WRITE) {
+ /* Write the prompt and the current buffer content */
+ abAppend(&ab,l->prompt,l->plen);
+ if (maskmode == 1) {
+ /* In mask mode, we output one '*' per UTF-8 character, not byte */
+ size_t i = 0;
+ while (i < len) {
+ abAppend(&ab,"*",1);
+ i += utf8NextCharLen(buf, i, len);
+ }
+ } else {
+ abAppend(&ab,buf,len);
+ }
+ /* Show hints if any. */
+ refreshShowHints(&ab,l,pwidth,fullwidth);
+ }
+
+ /* Erase to right */
+ snprintf(seq,sizeof(seq),"\x1b[0K");
+ abAppend(&ab,seq,strlen(seq));
+
+ if (flags & REFRESH_WRITE) {
+ /* Move cursor to original position (using display column, not byte). */
+ if (poscol+pwidth > 0)
+ snprintf(seq,sizeof(seq),"\r\x1b[%dC", (int)(poscol+pwidth));
+ else
+ snprintf(seq,sizeof(seq),"\r");
+ abAppend(&ab,seq,strlen(seq));
+ }
+
+ if (write(fd,ab.b,ab.len) == -1) {} /* Can't recover from write error. */
+ abFree(&ab);
+ free(render);
+}
+
+/* Multi line low level line refresh.
+ *
+ * Rewrite the currently edited line accordingly to the buffer content,
+ * cursor position, and number of columns of the terminal.
+ *
+ * Flags is REFRESH_* macros. The function can just remove the old
+ * prompt, just write it, or both.
+ *
+ * This function is UTF-8 aware and uses display widths for positioning. */
+static void refreshMultiLine(struct linenoiseState *l, int flags) {
+ char seq[64];
+ size_t pwidth = utf8StrWidth(l->prompt, l->plen); /* Prompt display width */
+ char *render = NULL;
+ size_t render_len, render_pos;
+ size_t bufwidth;
+ size_t poswidth;
+ int rows; /* rows used by current rendered buffer. */
+ int rpos = l->oldrpos; /* cursor relative row from previous refresh. */
+ int rpos2; /* rpos after refresh. */
+ int col; /* column position, zero-based. */
+ int old_rows = l->oldrows;
+ int fd = l->ofd, j;
+ struct abuf ab;
+
+ if (linenoiseRenderBuffer(l,&render,&render_len,&render_pos) == -1) return;
+ bufwidth = utf8StrWidth(render, render_len);
+ poswidth = utf8StrWidth(render, render_pos);
+ rows = (pwidth+bufwidth+l->cols-1)/l->cols;
+ l->oldrows = rows;
+
+ /* First step: clear all the lines used before. To do so start by
+ * going to the last row. */
+ abInit(&ab);
+
+ if (flags & REFRESH_CLEAN) {
+ if (old_rows-rpos > 0) {
+ lndebug("go down %d", old_rows-rpos);
+ snprintf(seq,64,"\x1b[%dB", old_rows-rpos);
+ abAppend(&ab,seq,strlen(seq));
+ }
+
+ /* Now for every row clear it, go up. */
+ for (j = 0; j < old_rows-1; j++) {
+ lndebug("clear+up");
+ snprintf(seq,64,"\r\x1b[0K\x1b[1A");
+ abAppend(&ab,seq,strlen(seq));
+ }
+ }
+
+ if (flags & REFRESH_ALL) {
+ /* Clean the top line. */
+ lndebug("clear");
+ snprintf(seq,64,"\r\x1b[0K");
+ abAppend(&ab,seq,strlen(seq));
+ }
+
+ if (flags & REFRESH_WRITE) {
+ /* Write the prompt and the current buffer content */
+ abAppend(&ab,l->prompt,l->plen);
+ if (maskmode == 1) {
+ /* In mask mode, output one '*' per UTF-8 character, not byte */
+ size_t i = 0;
+ while (i < render_len) {
+ abAppend(&ab,"*",1);
+ i += utf8NextCharLen(render, i, render_len);
+ }
+ } else {
+ abAppend(&ab,render,render_len);
+ }
+
+ /* Show hints if any. */
+ refreshShowHints(&ab,l,pwidth,bufwidth);
+
+ /* If we are at the very end of the screen with our prompt, we need to
+ * emit a newline and move the prompt to the first column. */
+ if (l->pos &&
+ render_pos == render_len &&
+ (poswidth+pwidth) % l->cols == 0)
+ {
+ lndebug("<newline>");
+ abAppend(&ab,"\n",1);
+ snprintf(seq,64,"\r");
+ abAppend(&ab,seq,strlen(seq));
+ rows++;
+ if (rows > (int)l->oldrows) l->oldrows = rows;
+ }
+
+ /* Move cursor to right position. */
+ rpos2 = (pwidth+poswidth+l->cols)/l->cols; /* Current cursor relative row */
+ lndebug("rpos2 %d", rpos2);
+
+ /* Go up till we reach the expected position. */
+ if (rows-rpos2 > 0) {
+ lndebug("go-up %d", rows-rpos2);
+ snprintf(seq,64,"\x1b[%dA", rows-rpos2);
+ abAppend(&ab,seq,strlen(seq));
+ }
+
+ /* Set column. */
+ col = (pwidth+poswidth) % l->cols;
+ lndebug("set col %d", 1+col);
+ if (col)
+ snprintf(seq,64,"\r\x1b[%dC", col);
+ else
+ snprintf(seq,64,"\r");
+ abAppend(&ab,seq,strlen(seq));
+ }
+
+ lndebug("\n");
+ l->oldpos = l->pos;
+ if (flags & REFRESH_WRITE) l->oldrpos = rpos2;
+
+ if (write(fd,ab.b,ab.len) == -1) {} /* Can't recover from write error. */
+ abFree(&ab);
+ free(render);
+}
+
+/* Calls the two low level functions refreshSingleLine() or
+ * refreshMultiLine() according to the selected mode. */
+static void refreshLineWithFlags(struct linenoiseState *l, int flags) {
+ if (mlmode)
+ refreshMultiLine(l,flags);
+ else
+ refreshSingleLine(l,flags);
+}
+
+/* Utility function to avoid specifying REFRESH_ALL all the times. */
+static void refreshLine(struct linenoiseState *l) {
+ refreshLineWithFlags(l,REFRESH_ALL);
+}
+
+/* Hide the current line, when using the multiplexing API. */
+void linenoiseHide(struct linenoiseState *l) {
+ if (mlmode)
+ refreshMultiLine(l,REFRESH_CLEAN);
+ else
+ refreshSingleLine(l,REFRESH_CLEAN);
+}
+
+/* Show the current line, when using the multiplexing API. */
+void linenoiseShow(struct linenoiseState *l) {
+ if (l->in_completion) {
+ refreshLineWithCompletion(l,NULL,REFRESH_WRITE);
+ } else {
+ refreshLineWithFlags(l,REFRESH_WRITE);
+ }
+}
+
+/* Grow the editing buffer if this state owns a growable buffer. Only the
+ * blocking linenoise() API sets buflen_max: the multiplexing API still uses
+ * the caller-provided fixed buffer. */
+static int linenoiseEditGrow(struct linenoiseState *l, size_t needed) {
+ size_t newlen;
+ char *newbuf;
+
+ if (needed <= l->buflen) return 0;
+
+ /* buflen_max is zero when the caller provided a fixed buffer, as in the
+ * multiplexing API: in that case there is nothing we can grow. */
+ if (l->buflen_max == 0 || needed > l->buflen_max) return -1;
+
+ /* Grow exponentially, but stop at the configured maximum before the
+ * doubling would overflow or go past it. */
+ newlen = l->buflen ? l->buflen : 16;
+ while (newlen < needed) {
+ if (newlen > l->buflen_max/2) {
+ newlen = l->buflen_max;
+ break;
+ }
+ newlen *= 2;
+ }
+ if (newlen < needed || newlen == SIZE_MAX) return -1;
+
+ /* Allocate one extra byte for the nul terminator. */
+ newbuf = realloc(l->buf,newlen+1);
+ if (newbuf == NULL) return -1;
+ l->buf = newbuf;
+ l->buflen = newlen;
+ return 0;
+}
+
+/* Insert bytes into l->buf without repainting the prompt. The paste path uses
+ * this to first store the real pasted bytes, then mark their range as folded,
+ * and only then refresh so raw pasted newlines are never printed directly. */
+static int linenoiseEditInsertNoRefresh(struct linenoiseState *l, const char *c, size_t clen) {
+ size_t insert_pos = l->pos;
+
+ if (clen > SIZE_MAX-l->len || linenoiseEditGrow(l,l->len+clen) == -1)
+ return -1;
+
+ if (l->len == l->pos) {
+ memcpy(l->buf+l->pos,c,clen);
+ } else {
+ memmove(l->buf+l->pos+clen,l->buf+l->pos,l->len-l->pos);
+ memcpy(l->buf+l->pos,c,clen);
+ }
+ l->pos += clen;
+ l->len += clen;
+ l->buf[l->len] = '\0';
+ linenoiseAdjustFoldsAfterInsert(l,insert_pos,clen);
+ return 0;
+}
+
+/* Insert the character(s) 'c' of length 'clen' at cursor current position.
+ * This handles both single-byte ASCII and multi-byte UTF-8 sequences.
+ *
+ * On error writing to the terminal -1 is returned, otherwise 0. */
+int linenoiseEditInsert(struct linenoiseState *l, const char *c, size_t clen) {
+ if (l->len == l->pos) {
+ int needs_refresh = memchr(c, '\n', clen) != NULL ||
+ memchr(c, '\r', clen) != NULL;
+
+ if (linenoiseEditInsertNoRefresh(l,c,clen) == -1) return 0;
+ if (!needs_refresh && !mlmode && !hintsCallback &&
+ (maskmode || l->fold_count == 0))
+ {
+ size_t sbuflen;
+ char *sbuf = sanitizeForDisplayAlloc(l->buf,l->len,&sbuflen);
+ if (sbuf != NULL) {
+ size_t bufwidth = utf8StrWidth(sbuf,sbuflen);
+ int fits = utf8StrWidth(l->prompt,l->plen)+bufwidth < l->cols;
+ free(sbuf);
+ if (fits) {
+ if (maskmode == 1) {
+ if (write(l->ofd,"*",1) == -1) return -1;
+ } else {
+ size_t sclen;
+ char *sc = sanitizeForDisplayAlloc(c,clen,&sclen);
+ if (sc == NULL) { refreshLine(l); return 0; }
+ int wr = write(l->ofd,sc,sclen);
+ free(sc);
+ if (wr == -1) return -1;
+ }
+ return 0;
+ }
+ }
+ }
+ refreshLine(l);
+ } else {
+ if (linenoiseEditInsertNoRefresh(l,c,clen) == -1) return 0;
+ refreshLine(l);
+ }
+ return 0;
+}
+
+/* Move cursor on the left. Moves by one UTF-8 character, not byte. */
+void linenoiseEditMoveLeft(struct linenoiseState *l) {
+ if (l->pos > 0) {
+ l->pos -= linenoiseEditPrevLen(l, l->pos);
+ refreshLine(l);
+ }
+}
+
+/* Move cursor on the right. Moves by one UTF-8 character, not byte. */
+void linenoiseEditMoveRight(struct linenoiseState *l) {
+ if (l->pos != l->len) {
+ l->pos += linenoiseEditNextLen(l, l->pos);
+ refreshLine(l);
+ }
+}
+
+/* Move cursor to the start of the line. */
+void linenoiseEditMoveHome(struct linenoiseState *l) {
+ if (l->pos != 0) {
+ l->pos = 0;
+ refreshLine(l);
+ }
+}
+
+/* Move cursor to the end of the line. */
+void linenoiseEditMoveEnd(struct linenoiseState *l) {
+ if (l->pos != l->len) {
+ l->pos = l->len;
+ refreshLine(l);
+ }
+}
+
+/* Substitute the currently edited line with the next or previous history
+ * entry as specified by 'dir'. */
+#define LINENOISE_HISTORY_NEXT 0
+#define LINENOISE_HISTORY_PREV 1
+void linenoiseEditHistoryNext(struct linenoiseState *l, int dir) {
+ if (history_len > 1) {
+ const char *src;
+ size_t len;
+ struct linenoiseFold f;
+
+ /* Update the current history entry before to
+ * overwrite it with the next one. */
+ free(history[history_len - 1 - l->history_index]);
+ history[history_len - 1 - l->history_index] = strdup(l->buf);
+ /* Show the new entry */
+ l->history_index += (dir == LINENOISE_HISTORY_PREV) ? 1 : -1;
+ if (l->history_index < 0) {
+ l->history_index = 0;
+ return;
+ } else if (l->history_index >= history_len) {
+ l->history_index = history_len-1;
+ return;
+ }
+
+ /* Copy the selected history entry into the edit buffer. With the
+ * fixed-buffer API, truncate the entry if it does not fit. */
+ src = history[history_len - 1 - l->history_index];
+ len = strlen(src);
+ if (linenoiseEditGrow(l,len) == -1 && len > l->buflen)
+ len = l->buflen;
+ memcpy(l->buf,src,len);
+ l->buf[len] = '\0';
+ l->len = l->pos = len;
+ linenoiseFoldClear(l);
+
+ /* History stores the real text, but not the original paste ranges.
+ * If the recalled entry needs folding, create one display fold now
+ * so text typed after recall remains outside the folded range. */
+ if (linenoiseBuildHistoryFold(l,&f))
+ linenoiseFoldAdd(l,f.start,f.end);
+ refreshLine(l);
+ }
+}
+
+/* Delete the character at the right of the cursor without altering the cursor
+ * position. Basically this is what happens with the "Delete" keyboard key.
+ * Now handles multi-byte UTF-8 characters. */
+void linenoiseEditDelete(struct linenoiseState *l) {
+ if (l->len > 0 && l->pos < l->len) {
+ size_t clen = linenoiseEditNextLen(l, l->pos);
+ linenoiseAdjustFoldsAfterDelete(l,l->pos,clen);
+ memmove(l->buf+l->pos, l->buf+l->pos+clen, l->len-l->pos-clen);
+ l->len -= clen;
+ l->buf[l->len] = '\0';
+ refreshLine(l);
+ }
+}
+
+/* Backspace implementation. Deletes the UTF-8 character before the cursor. */
+void linenoiseEditBackspace(struct linenoiseState *l) {
+ if (l->pos > 0 && l->len > 0) {
+ size_t clen = linenoiseEditPrevLen(l, l->pos);
+ linenoiseAdjustFoldsAfterDelete(l,l->pos-clen,clen);
+ memmove(l->buf+l->pos-clen, l->buf+l->pos, l->len-l->pos);
+ l->pos -= clen;
+ l->len -= clen;
+ l->buf[l->len] = '\0';
+ refreshLine(l);
+ }
+}
+
+/* Delete the previous word, maintaining the cursor at the start of the
+ * current word. Handles UTF-8 by moving character-by-character. */
+void linenoiseEditDeletePrevWord(struct linenoiseState *l) {
+ size_t old_pos = l->pos;
+ size_t diff;
+
+ /* Skip spaces before the word (move backwards by UTF-8 chars). */
+ while (l->pos > 0 && l->buf[l->pos-1] == ' ')
+ l->pos -= linenoiseEditPrevLen(l, l->pos);
+ /* Skip non-space characters (move backwards by UTF-8 chars). */
+ while (l->pos > 0 && l->buf[l->pos-1] != ' ')
+ l->pos -= linenoiseEditPrevLen(l, l->pos);
+ diff = old_pos - l->pos;
+ linenoiseAdjustFoldsAfterDelete(l,l->pos,diff);
+ memmove(l->buf+l->pos, l->buf+old_pos, l->len-old_pos+1);
+ l->len -= diff;
+ refreshLine(l);
+}
+
+/* This function is part of the multiplexed API of Linenoise, that is used
+ * in order to implement the blocking variant of the API but can also be
+ * called by the user directly in an event driven program. It will:
+ *
+ * 1. Initialize the linenoise state passed by the user.
+ * 2. Put the terminal in RAW mode.
+ * 3. Show the prompt.
+ * 4. Return control to the user, that will have to call linenoiseEditFeed()
+ * each time there is some data arriving in the standard input.
+ *
+ * The user can also call linenoiseEditHide() and linenoiseEditShow() if it
+ * is required to show some input arriving asyncronously, without mixing
+ * it with the currently edited line.
+ *
+ * When linenoiseEditFeed() returns non-NULL, the user finished with the
+ * line editing session (pressed enter CTRL-D/C): in this case the caller
+ * needs to call linenoiseEditStop() to put back the terminal in normal
+ * mode. This will not destroy the buffer, as long as the linenoiseState
+ * is still valid in the context of the caller.
+ *
+ * The function returns 0 on success, or -1 if writing to standard output
+ * fails. If stdin_fd or stdout_fd are set to -1, the default is to use
+ * STDIN_FILENO and STDOUT_FILENO.
+ */
+int linenoiseEditStart(struct linenoiseState *l, int stdin_fd, int stdout_fd, char *buf, size_t buflen, const char *prompt) {
+ int resuming = (l->buf != NULL && l->buf == buf);
+ int ifd = stdin_fd != -1 ? stdin_fd : STDIN_FILENO;
+ int ofd = stdout_fd != -1 ? stdout_fd : STDOUT_FILENO;
+ int no_tty = (!isatty(ifd) || !isatty(ofd)) && !getenv("LINENOISE_ASSUME_TTY");
+
+ /* No raw mode on a non-tty; enter it before touching 'l' otherwise. */
+ if (!no_tty) {
+ if (enableRawMode(ifd) == -1) return -1;
+ }
+
+ /* Populate the linenoise state that we pass to functions implementing
+ * specific editing functionalities. */
+ l->in_completion = 0;
+ l->ifd = ifd;
+ l->ofd = ofd;
+ l->buf = buf;
+ l->buflen = buflen;
+ l->buflen--; /* Make sure there is always space for the nulterm */
+ l->buflen_max = 0;
+ l->prompt = prompt;
+ l->plen = strlen(prompt);
+ if (!resuming) {
+ l->oldpos = l->pos = 0;
+ l->len = 0;
+ l->history_index = 0;
+ linenoiseFoldClear(l);
+ }
+
+ if (!resuming) {
+ /* Buffer starts empty. */
+ l->buf[0] = '\0';
+ }
+
+ /* If stdin is not a tty, stop here with the initialization. We
+ * will actually just read a line from standard input in blocking
+ * mode later, in linenoiseEditFeed(). */
+ if (no_tty) return 0;
+
+ l->cols = getColumns(stdin_fd, stdout_fd);
+ l->oldrows = 0;
+ l->oldrpos = 1; /* Cursor starts on row 1. */
+
+ if (!resuming) {
+ /* The latest history entry is always our current buffer, that
+ * initially is just an empty string. */
+ linenoiseHistoryAdd("");
+ }
+
+ linenoiseShow(l);
+ return 0;
+}
+
+/* Make sure the temporary paste buffer can hold len+need bytes. Return -1 on
+ * allocation failure or if the requested size is over PASTE_MAX_BYTES. */
+static int pasteBufferReserve(char **buf, size_t *cap, size_t len, size_t need) {
+ size_t want;
+ char *nb;
+
+ /* Nothing to do if the current paste buffer already has room for the
+ * bytes collected so far plus the new bytes we want to append. */
+ if (*cap >= len + need) return 0;
+
+ /* Start small, then double like the line buffer. The cap avoids turning a
+ * huge paste into an unbounded allocation attempt. */
+ want = *cap ? *cap : 64;
+ while (want < len + need) {
+ size_t doubled = want*2;
+ if (doubled <= want || doubled > PASTE_MAX_BYTES) {
+ want = PASTE_MAX_BYTES;
+ break;
+ }
+ want = doubled;
+ }
+ if (want < len + need) return -1;
+
+ /* realloc(NULL, want) handles the first allocation too. */
+ nb = realloc(*buf, want);
+ if (nb == NULL) return -1;
+ *buf = nb;
+ *cap = want;
+ return 0;
+}
+
+/* Append bytes to the temporary paste buffer, growing both it and l->buf as
+ * needed. Return -1 if the paste is too large or allocation fails. */
+static int pasteBufferAppend(struct linenoiseState *l, char **buf, size_t *cap,
+ size_t *len, const char *s, size_t slen, size_t maxlen) {
+ size_t needed;
+
+ if (*len > maxlen || slen > maxlen-*len) return -1;
+ if (*len > SIZE_MAX-slen) return -1;
+ needed = *len+slen;
+ if (l->len > SIZE_MAX-needed) return -1;
+ if (linenoiseEditGrow(l,l->len+needed) == -1) return -1;
+ if (pasteBufferReserve(buf,cap,*len,slen) == -1) return -1;
+ memcpy(*buf+*len,s,slen);
+ *len = needed;
+ return 0;
+}
+
+static int waitReadable(int fd) {
+ fd_set rfds;
+ struct timeval tv;
+ FD_ZERO(&rfds);
+ FD_SET(fd,&rfds);
+ tv.tv_sec = 0; tv.tv_usec = 50000;
+ return select(fd+1,&rfds,NULL,NULL,&tv);
+}
+
+#define LOOP_TIME_BUDGET_MS 50
+
+static long elapsedMs(const struct timespec *t0) {
+ struct timespec now;
+ clock_gettime(CLOCK_MONOTONIC, &now);
+ return (now.tv_sec - t0->tv_sec) * 1000L +
+ (now.tv_nsec - t0->tv_nsec) / 1000000L;
+}
+
+static int pasteInProgress = 0;
+static char *pasteBuf = NULL;
+static size_t pasteCap = 0, pasteLen = 0, pasteMatch = 0, pasteMaxlen = 0;
+static int pasteOverflowed = 0;
+
+/* Read a bracketed paste until ESC[201~ and insert the real bytes. If folding
+ * is needed, remember the inserted range so only rendering is shortened. */
+static char *linenoiseEditPasteFeed(struct linenoiseState *l) {
+ static const char END[] = "\x1b[201~";
+ const size_t ENDLEN = sizeof(END)-1;
+ struct timespec t0;
+
+ if (!pasteInProgress) {
+ pasteBuf = NULL;
+ pasteCap = pasteLen = pasteMatch = 0;
+ pasteOverflowed = 0;
+ pasteMaxlen = l->buflen_max ? l->buflen_max : l->buflen;
+ pasteMaxlen = pasteMaxlen > l->len ? pasteMaxlen - l->len : 0;
+ if (pasteMaxlen > PASTE_MAX_BYTES) pasteMaxlen = PASTE_MAX_BYTES;
+ /* Once all fold slots are used, consume later pastes without storing them. */
+ if (l->fold_count == LINENOISE_MAX_FOLDS) pasteMaxlen = 0;
+ pasteInProgress = 1;
+ }
+
+ clock_gettime(CLOCK_MONOTONIC, &t0);
+
+ while (1) {
+ if (elapsedMs(&t0) >= LOOP_TIME_BUDGET_MS) return linenoiseEditMore;
+
+ char c;
+ if (waitReadable(l->ifd) <= 0) return linenoiseEditMore;
+ if (read(l->ifd, &c, 1) != 1) break;
+
+ /* Track a possible ESC[201~ terminator without copying it into the
+ * paste. If it turns out to be ordinary input, flush the partial
+ * match below. */
+ if (c == END[pasteMatch]) {
+ pasteMatch++;
+ if (pasteMatch == ENDLEN) break;
+ continue;
+ }
+
+ if (pasteMatch > 0) {
+ if (!pasteOverflowed &&
+ pasteBufferAppend(l,&pasteBuf,&pasteCap,&pasteLen,END,pasteMatch,pasteMaxlen) == -1)
+ pasteOverflowed = 1;
+ pasteMatch = 0;
+ if (c == END[0]) {
+ pasteMatch = 1;
+ continue;
+ }
+ }
+
+ if (!pasteOverflowed &&
+ pasteBufferAppend(l,&pasteBuf,&pasteCap,&pasteLen,&c,1,pasteMaxlen) == -1)
+ pasteOverflowed = 1;
+ }
+
+ pasteInProgress = 0;
+ {
+ char *buf = pasteBuf;
+ size_t len = pasteLen;
+ int overflowed = pasteOverflowed;
+ pasteBuf = NULL;
+ pasteCap = pasteLen = pasteMatch = 0;
+ pasteOverflowed = 0;
+
+ if (overflowed) {
+ free(buf);
+ linenoiseBeep();
+ return linenoiseEditMore;
+ }
+ if (buf == NULL) return linenoiseEditMore;
+
+ /* Normalize pasted CR and CRLF to LF, so the edit buffer uses one
+ * internal newline representation. */
+ size_t r = 0, w = 0;
+ while (r < len) {
+ if (buf[r] == '\0') {
+ r += 1;
+ } else if (buf[r] == '\r') {
+ buf[w++] = '\n';
+ r += (r+1 < len && buf[r+1] == '\n') ? 2 : 1;
+ } else {
+ buf[w++] = buf[r++];
+ }
+ }
+ len = w;
+
+ if (!maskmode && shouldFoldText(buf,len)) {
+ size_t start = l->pos;
+ if (linenoiseEditInsertNoRefresh(l,buf,len) == -1) {
+ free(buf);
+ linenoiseBeep();
+ return linenoiseEditMore;
+ }
+ linenoiseFoldAdd(l,start,start+len);
+ refreshLine(l);
+ } else {
+ linenoiseEditInsert(l,buf,len);
+ }
+ free(buf);
+ }
+ return linenoiseEditMore;
+}
+
+char *linenoiseEditMore = "If you see this, you are misusing the API: when linenoiseEditFeed() is called, if it returns linenoiseEditMore the user is yet editing the line. See the README file for more information.";
+
+/* This function is part of the multiplexed API of linenoise, see the top
+ * comment on linenoiseEditStart() for more information. Call this function
+ * each time there is some data to read from the standard input file
+ * descriptor. In the case of blocking operations, this function can just be
+ * called in a loop, and block.
+ *
+ * The function returns linenoiseEditMore to signal that line editing is still
+ * in progress, that is, the user didn't yet pressed enter / CTRL-D. Otherwise
+ * the function returns the pointer to the heap-allocated buffer with the
+ * edited line, that the user should free with linenoiseFree().
+ *
+ * On special conditions, NULL is returned and errno is populated:
+ *
+ * EAGAIN if the user pressed Ctrl-C
+ * ENOENT if the user pressed Ctrl-D
+ *
+ * Some other errno: I/O error.
+ */
+char *linenoiseEditFeed(struct linenoiseState *l) {
+ if (pasteInProgress) return linenoiseEditPasteFeed(l);
+
+ /* Not a TTY, pass control to line reading without character
+ * count limits. */
+ if ((!isatty(l->ifd) || !isatty(l->ofd)) && !getenv("LINENOISE_ASSUME_TTY")) return linenoiseNoTTYFeed();
+
+ char c;
+ int nread;
+ char seq[3];
+
+ nread = read(l->ifd,&c,1);
+ if (nread < 0) {
+ return (errno == EAGAIN || errno == EWOULDBLOCK) ? linenoiseEditMore : NULL;
+ } else if (nread == 0) {
+ return NULL;
+ }
+
+ /* Only autocomplete when the callback is set. completeLine()
+ * returns the character to be handled next, or zero when the
+ * key was consumed to navigate completions. */
+ if ((l->in_completion || c == 9 /* TAB */) && completionCallback != NULL) {
+ int retval = completeLine(l,c);
+ /* Read next character when 0 */
+ if (retval == 0) return linenoiseEditMore;
+ c = retval;
+ }
+
+ switch(c) {
+ case KEY_NULL:
+ break;
+ case ENTER: /* enter */
+ case 10: /* ctrl-j / line feed: also accepted as enter */
+ history_len--;
+ free(history[history_len]);
+ if (mlmode) linenoiseEditMoveEnd(l);
+ if (hintsCallback) {
+ /* Force a refresh without hints to leave the previous
+ * line as the user typed it after a newline. */
+ linenoiseHintsCallback *hc = hintsCallback;
+ hintsCallback = NULL;
+ refreshLine(l);
+ hintsCallback = hc;
+ }
+ return strdup(l->buf);
+ case CTRL_C: /* ctrl-c */
+ errno = EAGAIN;
+ return NULL;
+ case BACKSPACE: /* backspace */
+ case 8: /* ctrl-h */
+ linenoiseEditBackspace(l);
+ break;
+ case CTRL_D: /* ctrl-d, remove char at right of cursor, or if the
+ line is empty, act as end-of-file. */
+ if (l->len > 0) {
+ linenoiseEditDelete(l);
+ } else {
+ history_len--;
+ free(history[history_len]);
+ errno = ENOENT;
+ return NULL;
+ }
+ break;
+ case CTRL_T: /* ctrl-t, swaps current character with previous. */
+ /* Handle UTF-8: swap the two UTF-8 characters around cursor. */
+ if (l->pos > 0 && l->pos < l->len) {
+ char tmp[32];
+ size_t prevlen = linenoiseEditPrevLen(l, l->pos);
+ size_t currlen = linenoiseEditNextLen(l, l->pos);
+ size_t prevstart = l->pos - prevlen;
+ if (prevlen > sizeof(tmp) || currlen > sizeof(tmp)) break;
+ if (linenoiseRangeOverlapsFold(l,prevstart,prevlen+currlen)) {
+ linenoiseBeep();
+ break;
+ }
+ /* Copy current char to tmp, move previous char right, paste tmp. */
+ memcpy(tmp, l->buf + l->pos, currlen);
+ memmove(l->buf + prevstart + currlen, l->buf + prevstart, prevlen);
+ memcpy(l->buf + prevstart, tmp, currlen);
+ if (l->pos + currlen <= l->len) l->pos += currlen;
+ refreshLine(l);
+ }
+ break;
+ case CTRL_B: /* ctrl-b */
+ linenoiseEditMoveLeft(l);
+ break;
+ case CTRL_F: /* ctrl-f */
+ linenoiseEditMoveRight(l);
+ break;
+ case CTRL_P: /* ctrl-p */
+ linenoiseEditHistoryNext(l, LINENOISE_HISTORY_PREV);
+ break;
+ case CTRL_N: /* ctrl-n */
+ linenoiseEditHistoryNext(l, LINENOISE_HISTORY_NEXT);
+ break;
+ case ESC: /* escape sequence */
+ /* A real escape sequence arrives as one burst from the terminal, but
+ * a lone Escape keypress sends just this byte. Give it a short
+ * window to distinguish the two instead of blocking indefinitely on
+ * the first follow-up byte (this holds sync_mutex the whole time). */
+ if (waitReadable(l->ifd) <= 0) break;
+ if (read(l->ifd,seq,1) == -1) break;
+ if (waitReadable(l->ifd) <= 0) break;
+ if (read(l->ifd,seq+1,1) == -1) break;
+
+ /* ESC [ sequences. */
+ if (seq[0] == '[') {
+ if (seq[1] >= '0' && seq[1] <= '9') {
+ char param[8];
+ size_t plen = 0;
+ char final = seq[1];
+ int budget = 32;
+
+ while ((unsigned char)final >= 0x20 && (unsigned char)final <= 0x3f) {
+ if (plen < sizeof(param)) param[plen++] = final;
+ if (--budget <= 0) { final = 0; break; }
+ if (waitReadable(l->ifd) <= 0) { final = 0; break; }
+ if (read(l->ifd,&final,1) != 1) { final = 0; break; }
+ }
+ if (final == '~') {
+ if (plen == 1 && param[0] == '3') {
+ linenoiseEditDelete(l);
+ }
+ }
+ } else {
+ switch(seq[1]) {
+ case 'A': /* Up */
+ linenoiseEditHistoryNext(l, LINENOISE_HISTORY_PREV);
+ break;
+ case 'B': /* Down */
+ linenoiseEditHistoryNext(l, LINENOISE_HISTORY_NEXT);
+ break;
+ case 'C': /* Right */
+ linenoiseEditMoveRight(l);
+ break;
+ case 'D': /* Left */
+ linenoiseEditMoveLeft(l);
+ break;
+ case 'H': /* Home */
+ linenoiseEditMoveHome(l);
+ break;
+ case 'F': /* End*/
+ linenoiseEditMoveEnd(l);
+ break;
+ }
+ }
+ }
+
+ /* ESC O sequences. */
+ else if (seq[0] == 'O') {
+ switch(seq[1]) {
+ case 'H': /* Home */
+ linenoiseEditMoveHome(l);
+ break;
+ case 'F': /* End*/
+ linenoiseEditMoveEnd(l);
+ break;
+ }
+ }
+ break;
+ default:
+ /* Handle UTF-8 multi-byte sequences. When we receive the first byte
+ * of a multi-byte UTF-8 character, read the remaining bytes to
+ * complete the sequence before inserting. */
+ {
+ char utf8[4];
+ int utf8len = utf8ByteLen(c);
+ int nread = 1;
+ utf8[0] = c;
+ if (utf8len > 1) {
+ /* Read remaining bytes of the UTF-8 sequence, stopping on
+ * the first non-continuation byte (this also rejects NUL). */
+ for (nread = 1; nread < utf8len; nread++) {
+ char cont;
+ if (waitReadable(l->ifd) <= 0) break;
+ if (read(l->ifd, &cont, 1) != 1) break;
+ if (!utf8IsCont((unsigned char)cont)) break;
+ utf8[nread] = cont;
+ }
+ }
+ if (linenoiseEditInsert(l, utf8, nread)) return NULL;
+ }
+ break;
+ case CTRL_U: /* Ctrl+u, delete the whole line. */
+ l->buf[0] = '\0';
+ l->pos = l->len = 0;
+ linenoiseFoldClear(l);
+ refreshLine(l);
+ break;
+ case CTRL_K: /* Ctrl+k, delete from current to end of line. */
+ linenoiseAdjustFoldsAfterDelete(l,l->pos,l->len-l->pos);
+ l->buf[l->pos] = '\0';
+ l->len = l->pos;
+ refreshLine(l);
+ break;
+ case CTRL_A: /* Ctrl+a, go to the start of the line */
+ linenoiseEditMoveHome(l);
+ break;
+ case CTRL_E: /* ctrl+e, go to the end of the line */
+ linenoiseEditMoveEnd(l);
+ break;
+ case CTRL_L: /* ctrl+l, clear screen */
+ linenoiseClearScreen();
+ refreshLine(l);
+ break;
+ case CTRL_W: /* ctrl+w, delete previous word */
+ linenoiseEditDeletePrevWord(l);
+ break;
+ }
+ return linenoiseEditMore;
+}
+
+/* This is part of the multiplexed linenoise API. See linenoiseEditStart()
+ * for more information. This function is called when linenoiseEditFeed()
+ * returns something different than NULL. At this point the user input
+ * is in the buffer, and we can restore the terminal in normal mode. */
+void linenoiseEditStop(struct linenoiseState *l) {
+ if (pasteInProgress) {
+ /* Drain the rest of the paste up to its terminator so it isn't
+ * replayed as keystrokes (e.g. submitted via an embedded newline)
+ * on the next edit session. */
+ static const char END[] = "\x1b[201~";
+ const size_t ENDLEN = sizeof(END)-1;
+ struct timespec t0;
+ clock_gettime(CLOCK_MONOTONIC, &t0);
+ while (elapsedMs(&t0) < LOOP_TIME_BUDGET_MS) {
+ char c;
+ if (waitReadable(l->ifd) <= 0) break;
+ if (read(l->ifd, &c, 1) != 1) break;
+ if (c == END[pasteMatch]) {
+ if (++pasteMatch == ENDLEN) break;
+ } else {
+ pasteMatch = (c == END[0]) ? 1 : 0;
+ }
+ }
+
+ free(pasteBuf);
+ pasteBuf = NULL;
+ pasteCap = pasteLen = pasteMatch = 0;
+ pasteOverflowed = 0;
+ pasteInProgress = 0;
+ }
+
+ if ((!isatty(l->ifd) || !isatty(l->ofd)) && !getenv("LINENOISE_ASSUME_TTY")) return;
+ disableRawMode(l->ifd);
+}
+
+/* This just implements a blocking loop for the multiplexed API.
+ * In many applications that are not event-drivern, we can just call
+ * the blocking linenoise API, wait for the user to complete the editing
+ * and return the buffer. This wrapper owns l.buf, so it can let the edit
+ * state grow it dynamically for large pasted input. */
+static char *linenoiseBlockingEdit(int stdin_fd, int stdout_fd, const char *prompt)
+{
+ struct linenoiseState l;
+ char *buf = malloc(LINENOISE_INITIAL_BUFLEN);
+ char *res;
+
+ if (buf == NULL) {
+ errno = ENOMEM;
+ return NULL;
+ }
+
+ if (linenoiseEditStart(&l,stdin_fd,stdout_fd,buf,
+ LINENOISE_INITIAL_BUFLEN,prompt) == -1)
+ {
+ free(buf);
+ return NULL;
+ }
+ l.buflen_max = LINENOISE_MAX_LINE;
+ while((res = linenoiseEditFeed(&l)) == linenoiseEditMore);
+ linenoiseEditStop(&l);
+ free(l.buf);
+ return res;
+}
+
+/* This special mode is used by linenoise in order to print scan codes
+ * on screen for debugging / development purposes. It is implemented
+ * by the linenoise_example program using the --keycodes option. */
+void linenoisePrintKeyCodes(void) {
+ char quit[4];
+
+ printf("Linenoise key codes debugging mode.\n"
+ "Press keys to see scan codes. Type 'quit' at any time to exit.\n");
+ if (enableRawMode(STDIN_FILENO) == -1) return;
+ memset(quit,' ',4);
+ while(1) {
+ char c;
+ int nread;
+
+ nread = read(STDIN_FILENO,&c,1);
+ if (nread <= 0) continue;
+ memmove(quit,quit+1,sizeof(quit)-1); /* shift string to left. */
+ quit[sizeof(quit)-1] = c; /* Insert current char on the right. */
+ if (memcmp(quit,"quit",sizeof(quit)) == 0) break;
+
+ printf("'%c' %02x (%d) (type quit to exit)\n",
+ isprint(c) ? c : '?', (int)c, (int)c);
+ printf("\r"); /* Go left edge manually, we are in raw mode. */
+ fflush(stdout);
+ }
+ disableRawMode(STDIN_FILENO);
+}
+
+/* Read a newline-terminated record from fp with no fixed-size stack buffer.
+ * Used for non-tty input, unsupported terminals, and history loading. */
+static char *linenoiseReadLine(FILE *fp, int *err) {
+ char *line = NULL;
+ size_t len = 0, cap = 0;
+
+ if (err) *err = 0;
+
+ while(1) {
+ if (len+1 >= cap) {
+ size_t newcap = cap ? cap*2 : 16;
+ char *oldval = line;
+ line = realloc(line,newcap);
+ if (line == NULL) {
+ if (oldval) free(oldval);
+ if (err) *err = 1;
+ return NULL;
+ }
+ cap = newcap;
+ }
+ int c = fgetc(fp);
+ if (c == EOF || c == '\n') {
+ if (c == EOF && len == 0) {
+ free(line);
+ return NULL;
+ } else {
+ line[len] = '\0';
+ return line;
+ }
+ } else {
+ line[len] = c;
+ len++;
+ }
+ }
+}
+
+static char *linenoiseNoTTY(void) {
+ return linenoiseReadLine(stdin,NULL);
+}
+
+static char *linenoiseNoTTYFeed(void) {
+ static char *line = NULL;
+ static size_t len = 0, cap = 0;
+ int fd = fileno(stdin);
+ struct timespec t0;
+
+ clock_gettime(CLOCK_MONOTONIC, &t0);
+
+ while (1) {
+ if (elapsedMs(&t0) >= LOOP_TIME_BUDGET_MS) return linenoiseEditMore;
+
+ if (len+1 >= cap) {
+ size_t newcap = cap ? cap*2 : 16;
+ char *oldval = line;
+ line = realloc(line,newcap);
+ if (line == NULL) {
+ if (oldval) free(oldval);
+ return NULL;
+ }
+ cap = newcap;
+ }
+
+ int sr = waitReadable(fd);
+ if (sr == 0) return linenoiseEditMore;
+ if (sr < 0) {
+ free(line);
+ line = NULL; len = cap = 0;
+ return NULL;
+ }
+
+ char c;
+ ssize_t n = read(fd, &c, 1);
+
+ if (n < 0) {
+ free(line);
+ line = NULL; len = cap = 0;
+ return NULL;
+ }
+
+ if (n == 0 || c == '\n') {
+ if (n == 0 && len == 0) {
+ free(line);
+ line = NULL; len = cap = 0;
+ return NULL;
+ }
+ line[len] = '\0';
+ char *result = line;
+ line = NULL; len = cap = 0;
+ return result;
+ }
+
+ line[len] = c;
+ len++;
+ }
+}
+
+/* The high level function that is the main API of the linenoise library.
+ * This function checks if the terminal has basic capabilities, just checking
+ * for a blacklist of stupid terminals, and later either calls the line
+ * editing function or uses a simple line reader so that you will be able
+ * to type something even in the most desperate of the conditions. */
+char *linenoise(const char *prompt) {
+ if (!isatty(STDIN_FILENO) && !getenv("LINENOISE_ASSUME_TTY")) {
+ /* Not a tty: read from file / pipe. In this mode we don't want any
+ * limit to the line size, so we call a function to handle that. */
+ return linenoiseNoTTY();
+ }
+
+ if (isUnsupportedTerm()) {
+ char *retval;
+ size_t len;
+
+ printf("%s",prompt);
+ fflush(stdout);
+ retval = linenoiseNoTTY();
+ if (retval == NULL) return NULL;
+ len = strlen(retval);
+ while(len && retval[len-1] == '\r') {
+ len--;
+ retval[len] = '\0';
+ }
+ return retval;
+ } else {
+ return linenoiseBlockingEdit(STDIN_FILENO,STDOUT_FILENO,prompt);
+ }
+}
+
+/* This is just a wrapper the user may want to call in order to make sure
+ * the linenoise returned buffer is freed with the same allocator it was
+ * created with. Useful when the main program is using an alternative
+ * allocator. */
+void linenoiseFree(void *ptr) {
+ if (ptr == linenoiseEditMore) return; // Protect from API misuse.
+ free(ptr);
+}
+
+/* ================================ History ================================= */
+
+/* Free the history, but does not reset it. Only used when we have to
+ * exit() to avoid memory leaks are reported by valgrind & co. */
+static void freeHistory(void) {
+ if (history) {
+ int j;
+
+ for (j = 0; j < history_len; j++)
+ free(history[j]);
+ free(history);
+ }
+}
+
+/* At exit we'll try to fix the terminal to the initial conditions. */
+static void linenoiseAtExit(void) {
+ disableRawMode(STDIN_FILENO);
+ freeHistory();
+}
+
+/* This is the API call to add a new entry in the linenoise history.
+ * It uses a fixed array of char pointers that are shifted (memmoved)
+ * when the history max length is reached in order to remove the older
+ * entry and make room for the new one, so it is not exactly suitable for huge
+ * histories, but will work well for a few hundred of entries.
+ *
+ * Using a circular buffer is smarter, but a bit more complex to handle. */
+int linenoiseHistoryAdd(const char *line) {
+ char *linecopy;
+
+ if (history_max_len == 0) return 0;
+
+ /* Initialization on first call. */
+ if (history == NULL) {
+ history = malloc(sizeof(char*)*history_max_len);
+ if (history == NULL) return 0;
+ memset(history,0,(sizeof(char*)*history_max_len));
+ }
+
+ /* Don't add duplicated lines. */
+ if (history_len && !strcmp(history[history_len-1], line)) return 0;
+
+ /* Add an heap allocated copy of the line in the history.
+ * If we reached the max length, remove the older line. */
+ linecopy = strdup(line);
+ if (!linecopy) return 0;
+ if (history_len == history_max_len) {
+ free(history[0]);
+ memmove(history,history+1,sizeof(char*)*(history_max_len-1));
+ history_len--;
+ }
+ history[history_len] = linecopy;
+ history_len++;
+ return 1;
+}
+
+/* Set the maximum length for the history. This function can be called even
+ * if there is already some history, the function will make sure to retain
+ * just the latest 'len' elements if the new history length value is smaller
+ * than the amount of items already inside the history. */
+int linenoiseHistorySetMaxLen(int len) {
+ char **new;
+
+ if (len < 1) return 0;
+ if (history) {
+ int tocopy = history_len;
+
+ new = malloc(sizeof(char*)*len);
+ if (new == NULL) return 0;
+
+ /* If we can't copy everything, free the elements we'll not use. */
+ if (len < tocopy) {
+ int j;
+
+ for (j = 0; j < tocopy-len; j++) free(history[j]);
+ tocopy = len;
+ }
+ memset(new,0,sizeof(char*)*len);
+ memcpy(new,history+(history_len-tocopy), sizeof(char*)*tocopy);
+ free(history);
+ history = new;
+ }
+ history_max_len = len;
+ if (history_len > history_max_len)
+ history_len = history_max_len;
+ return 1;
+}
+
+/* Save the history in the specified file. On success 0 is returned
+ * otherwise -1 is returned. */
+int linenoiseHistorySave(const char *filename) {
+ mode_t old_umask = umask(S_IXUSR|S_IRWXG|S_IRWXO);
+ FILE *fp;
+ int j;
+
+ fp = fopen(filename,"w");
+ umask(old_umask);
+ if (fp == NULL) return -1;
+ fchmod(fileno(fp),S_IRUSR|S_IWUSR);
+ for (j = 0; j < history_len; j++) {
+ char *p = history[j];
+ /* Keep the history file newline-separated: embedded newlines in an
+ * entry are stored as CR and converted back by linenoiseHistoryLoad(). */
+ while (*p) {
+ fputc(*p == '\n' ? '\r' : *p, fp);
+ p++;
+ }
+ fputc('\n', fp);
+ }
+ fclose(fp);
+ return 0;
+}
+
+/* Load the history from the specified file. If the file does not exist
+ * zero is returned and no operation is performed.
+ *
+ * If the file exists and the operation succeeded 0 is returned, otherwise
+ * on error -1 is returned. */
+int linenoiseHistoryLoad(const char *filename) {
+ FILE *fp = fopen(filename,"r");
+ char *buf;
+ int err = 0;
+
+ if (fp == NULL) return -1;
+
+ while ((buf = linenoiseReadLine(fp,&err)) != NULL) {
+ size_t j;
+
+ /* Rebuild embedded newlines that were saved as CR. */
+ for (j = 0; buf[j]; j++) {
+ if (buf[j] == '\r') buf[j] = '\n';
+ }
+ linenoiseHistoryAdd(buf);
+ free(buf);
+ }
+ if (err || ferror(fp)) {
+ fclose(fp);
+ return -1;
+ }
+ fclose(fp);
+ return 0;
+}
### external/linenoise/linenoise.h
@@ -0,0 +1,120 @@
+/* linenoise.h -- VERSION 1.0
+ *
+ * Guerrilla line editing library against the idea that a line editing lib
+ * needs to be 20,000 lines of C code.
+ *
+ * See linenoise.c for more information.
+ *
+ * ------------------------------------------------------------------------
+ *
+ * Copyright (c) 2010-2023, Salvatore Sanfilippo <antirez at gmail dot com>
+ * Copyright (c) 2010-2013, Pieter Noordhuis <pcnoordhuis at gmail dot com>
+ *
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ * * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *
+ * * Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef __LINENOISE_H
+#define __LINENOISE_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <stddef.h> /* For size_t. */
+
+extern char *linenoiseEditMore;
+
+#define LINENOISE_MAX_FOLDS 16
+
+/* The linenoiseState structure represents the state during line editing.
+ * We pass this state to functions implementing specific editing
+ * functionalities. */
+struct linenoiseState {
+ int in_completion; /* The user pressed TAB and we are now in completion
+ * mode, so input is handled by completeLine(). */
+ size_t completion_idx; /* Index of next completion to propose. */
+ int ifd; /* Terminal stdin file descriptor. */
+ int ofd; /* Terminal stdout file descriptor. */
+ char *buf; /* Edited line buffer. */
+ size_t buflen; /* Edited line buffer size. */
+ size_t buflen_max; /* Max buffer size, or 0 if fixed. */
+ const char *prompt; /* Prompt to display. */
+ size_t plen; /* Prompt length. */
+ size_t pos; /* Current cursor position. */
+ size_t oldpos; /* Previous refresh cursor position. */
+ size_t len; /* Current edited line length. */
+ size_t cols; /* Number of columns in terminal. */
+ size_t oldrows; /* Rows used by last refrehsed line (multiline mode) */
+ int oldrpos; /* Cursor row from last refresh (for multiline clearing). */
+ int history_index; /* The history index we are currently editing. */
+ int fold_count; /* Number of folded ranges. */
+ size_t fold_start[LINENOISE_MAX_FOLDS]; /* Folded range start offsets. */
+ size_t fold_end[LINENOISE_MAX_FOLDS]; /* Folded range end offsets. */
+};
+
+typedef struct linenoiseCompletions {
+ size_t len;
+ char **cvec;
+} linenoiseCompletions;
+
+/* Non blocking API. */
+int linenoiseEditStart(struct linenoiseState *l, int stdin_fd, int stdout_fd, char *buf, size_t buflen, const char *prompt);
+char *linenoiseEditFeed(struct linenoiseState *l);
+void linenoiseEditStop(struct linenoiseState *l);
+void linenoiseHide(struct linenoiseState *l);
+void linenoiseShow(struct linenoiseState *l);
+
+/* Blocking API. */
+char *linenoise(const char *prompt);
+void linenoiseFree(void *ptr);
+
+/* Completion API. */
+typedef void(linenoiseCompletionCallback)(const char *, linenoiseCompletions *);
+typedef char*(linenoiseHintsCallback)(const char *, int *color, int *bold);
+typedef void(linenoiseFreeHintsCallback)(void *);
+void linenoiseSetCompletionCallback(linenoiseCompletionCallback *);
+void linenoiseSetHintsCallback(linenoiseHintsCallback *);
+void linenoiseSetFreeHintsCallback(linenoiseFreeHintsCallback *);
+void linenoiseAddCompletion(linenoiseCompletions *, const char *);
+
+/* History API. */
+int linenoiseHistoryAdd(const char *line);
+int linenoiseHistorySetMaxLen(int len);
+int linenoiseHistorySave(const char *filename);
+int linenoiseHistoryLoad(const char *filename);
+
+/* Other utilities. */
+void linenoiseClearScreen(void);
+void linenoiseSetMultiLine(int ml);
+void linenoisePrintKeyCodes(void);
+void linenoiseMaskModeEnable(void);
+void linenoiseMaskModeDisable(void);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* __LINENOISE_H */
### src/common/util.cpp
@@ -62,7 +62,6 @@ using namespace epee;
#include "stack_trace.h"
#include "memwipe.h"
#include "net/http_client.h" // epee::net_utils::...
-#include "readline_buffer.h"
#ifdef WIN32
#include <windows.h>
### src/daemon/CMakeLists.txt
@@ -65,7 +65,6 @@ target_link_libraries(daemon
${Boost_SYSTEM_LIBRARY}
${CMAKE_THREAD_LIBS_INIT}
PkgConfig::libzmq
- ${GNU_READLINE_LIBRARY}
${EXTRA_LIBRARIES}
$<TARGET_NAME_IF_EXISTS:blocks>)
set_property(TARGET daemon
### src/gen_multisig/CMakeLists.txt
@@ -43,7 +43,6 @@ target_link_libraries(gen_multisig
${Boost_FILESYSTEM_LIBRARY}
${Boost_THREAD_LIBRARY}
${CMAKE_THREAD_LIBS_INIT}
- ${GNU_READLINE_LIBRARY}
${EXTRA_LIBRARIES})
add_dependencies(gen_multisig
version)
### src/simplewallet/CMakeLists.txt
@@ -57,7 +57,6 @@ target_link_libraries(simplewallet
${ICU_LIBRARIES}
${Boost_THREAD_LIBRARY}
${CMAKE_THREAD_LIBS_INIT}
- ${GNU_READLINE_LIBRARY}
${EXTRA_LIBRARIES})
set_property(TARGET simplewallet
PROPERTYWhy this scored 20/100
Community notes
Notes can correct, qualify, or add evidence to the AI analysis. Every note shown here has been validated by a human moderator.
The AI analysis stands alone for now. Submit a note if you can add evidence or important context.