pax_global_header00006660000000000000000000000064147716031470014524gustar00rootroot0000000000000052 comment=91b7f0311609976fe5fde2e13d35d26c29af7804 inspircd-4.7.0/000077500000000000000000000000001477160314700133475ustar00rootroot00000000000000inspircd-4.7.0/.github/000077500000000000000000000000001477160314700147075ustar00rootroot00000000000000inspircd-4.7.0/.github/ISSUE_TEMPLATE/000077500000000000000000000000001477160314700170725ustar00rootroot00000000000000inspircd-4.7.0/.github/ISSUE_TEMPLATE/BUG.yml000066400000000000000000000023271477160314700202360ustar00rootroot00000000000000--- name: Bug report description: Report a non-security bug in InspIRCd. body: - type: markdown attributes: value: | Thanks for taking the time to fill out this bug report! If you're looking for help with setting up your server please post on [our support forum](https://github.com/orgs/inspircd/discussions/categories/support) instead. If you're reporting a crash or other security issue [please read our security policy](https://github.com/inspircd/inspircd/security/policy#reporting-a-vulnerability) for how to report security issues privately. - type: textarea attributes: label: Description validations: required: true - type: textarea attributes: label: Steps to reproduce the issue validations: required: true - type: textarea attributes: label: Describe the results you received validations: required: true - type: textarea attributes: label: Describe the results you expected validations: required: true - type: input attributes: label: InspIRCd version description: |- Either the output of `inspircd --version` or `./src/version.sh`. validations: required: true inspircd-4.7.0/.github/ISSUE_TEMPLATE/FEATURE.yml000066400000000000000000000006511477160314700207120ustar00rootroot00000000000000--- name: Feature request description: Request that a new feature is added to InspIRCd. body: - type: markdown attributes: value: | Thanks for taking the time to fill out this feature request! - type: textarea attributes: label: Description validations: required: true - type: textarea attributes: label: Why this would be useful? validations: required: true inspircd-4.7.0/.github/ISSUE_TEMPLATE/config.yml000066400000000000000000000002721477160314700210630ustar00rootroot00000000000000blank_issues_enabled: false contact_links: - name: Support forum url: https://github.com/orgs/inspircd/discussions/categories/support about: Please ask support questions here. inspircd-4.7.0/.github/PULL_REQUEST_TEMPLATE.md000066400000000000000000000021351477160314700205110ustar00rootroot00000000000000 ## Summary ## Rationale ## Testing Environment I have tested this pull request on: **Operating system name and version:** **Compiler name and version:** ## Checks I have ensured that: - [ ] The code I am submitting is my own work and/or I have permission from the author to share it. - [ ] Generative AI (Copilot, ChatGPT, etc) was not used to create any part of this pull request. - [ ] I have documented any features added by this pull request. - [ ] This pull request does not introduce any incompatible API changes (stable branches only, delete if not applicable). - [ ] If ABI changes have been made I have incremented MODULE_ABI in `moduledefs.h` (stable branches only, delete if not applicable). inspircd-4.7.0/.github/SECURITY.md000066400000000000000000000014771477160314700165110ustar00rootroot00000000000000# Security Policy ## Supported Versions Currently the v3 (old stable) and v4 (stable) branches are actively receiving security fixes. Support for v3 will end at the end of 2025. The v5 branch is still early in development and only receives security fixes when they are synced from the v3 and v4 branches. Version | Supported ------- | --------- 5.x.y | :warning: 4.x.y | :white_check_mark: 3.x.y | :white_check_mark: 2.0.x | :x: 1.2.y | :x: 1.1.y | :x: 1.0.y | :x: ## Reporting a Vulnerability Please do not report security vulnerabilities on GitHub. Instead, get the attention of a developer in our development IRC channel at ircs://irc.teranova.net/inspircd.dev and PM them the details. We will triage your issue as soon as possible and try to release a fixed version within a week of receiving your report. inspircd-4.7.0/.github/dependabot.yml000066400000000000000000000001611477160314700175350ustar00rootroot00000000000000version: 2 updates: - package-ecosystem: github-actions directory: / schedule: interval: monthly inspircd-4.7.0/.github/workflows/000077500000000000000000000000001477160314700167445ustar00rootroot00000000000000inspircd-4.7.0/.github/workflows/ci-alpine.yml000066400000000000000000000036511477160314700213350ustar00rootroot00000000000000name: Alpine CI on: pull_request: push: schedule: - cron: '0 0 * * 0' jobs: build: if: "!contains(github.event.head_commit.message, '[skip alpine ci]')" container: alpine:3.20 runs-on: ubuntu-latest env: CXX: ${{ matrix.compiler }} INSPIRCD_DEBUG: 3 INSPIRCD_VERBOSE: 1 steps: - uses: actions/checkout@v4 - name: Install dependencies run: | apk update apk add \ argon2-dev \ clang \ g++ \ git \ gnutls-dev \ libmaxminddb-dev \ libpq-dev \ libpsl-dev \ make \ mariadb-dev \ openldap-dev \ openssl-dev \ pcre2-dev \ perl \ pkgconf \ re2-dev \ sqlite-dev \ yyjson-dev - name: Run configure run: | ./configure --enable-extras "argon2 geo_maxmind ldap log_json log_syslog mysql pgsql regex_pcre2 regex_posix regex_re2 sqlite3 ssl_gnutls ssl_openssl sslrehashsignal" ./configure --development --disable-auto-extras --disable-ownership --socketengine ${{ matrix.socketengine }} - name: Build core run: | INSPIRCD_TARGET=inspircd make --jobs $(($(getconf _NPROCESSORS_ONLN) + 1)) - name: Build core modules run: | INSPIRCD_TARGET=coremods make --jobs $(($(getconf _NPROCESSORS_ONLN) + 1)) - name: Build modules run: | INSPIRCD_TARGET=modules make --jobs $(($(getconf _NPROCESSORS_ONLN) + 1)) - name: Install run: | make install - name: Run run: | touch ./run/conf/inspircd.conf ./run/inspircd start --runasroot strategy: fail-fast: false matrix: compiler: - clang++ - g++ socketengine: - epoll - poll - select inspircd-4.7.0/.github/workflows/ci-irctest.yml000066400000000000000000000060131477160314700215350ustar00rootroot00000000000000# This workflow has four tasks: # # 1. the first builds inspircd (with some optimizations for irctest), and uploads it # to a temporary storage # 2. the other three download the binary we just built, and run it through inspircd, # with either Anope, Atheme, or runs service-independent tests name: irctest on: pull_request: push: schedule: - cron: 0 0 * * 0 jobs: build: if: "!contains(github.event.head_commit.message, '[skip irctest ci]')" runs-on: ubuntu-24.04-arm steps: - name: Checkout repository uses: actions/checkout@v4 - name: Run configure run: ./configure --development --disable-auto-extras --prefix=$HOME/inspircd # Speed-up build (6 min -> 5 min) - name: Precompile inspircd.h run: c++ -Ivendor include/inspircd.h - name: Build and install env: CXXFLAGS: -DINSPIRCD_UNLIMITED_MAINLOOP run: make install --jobs $(($(getconf _NPROCESSORS_ONLN) + 1)) - name: Make artifact tarball run: |- cd ~ tar -czf artifacts-inspircd.tar.gz inspircd - name: Upload build artifacts uses: actions/upload-artifact@v4 with: name: installed-inspircd-for-irctest path: ~/artifacts-inspircd.tar.gz retention-days: 1 test: if: "!contains(github.event.head_commit.message, '[skip irctest ci]')" runs-on: ubuntu-24.04-arm env: IRCTEST_DEBUG_LOGS: "1" needs: - build steps: - name: Download build artifacts uses: actions/download-artifact@v4 with: name: installed-inspircd-for-irctest path: "~" - name: Unpack artifacts run: |- cd ~ find -name 'artifacts-inspircd.tar.gz' -exec tar -xzf '{}' \; - name: Checkout irctest uses: actions/checkout@v4 with: path: irctest ref: 2680502dfe496a597bf8fb3cfc08cd3b6a698b17 repository: progval/irctest - name: Install irctest dependencies run: sudo apt-get install --assume-yes faketime python3-pytest - name: Run irctest (no services) if: matrix.services == 'no services' run: PATH=$HOME/inspircd/bin:$PATH make -C irctest inspircd - name: Checkout Anope if: matrix.services == 'anope' uses: actions/checkout@v4 with: path: anope ref: 2.1.10 repository: anope/anope - name: Build and install Anope if: matrix.services == 'anope' run: | cd $GITHUB_WORKSPACE/anope sudo apt-get install ninja-build --no-install-recommends mkdir build && cd build cmake -DCMAKE_INSTALL_PREFIX=$HOME/anope -DPROGRAM_NAME=anope -GNinja .. ninja install - name: Run irctest (Anope services) if: matrix.services == 'anope' run: PATH=$HOME/anope/bin:$HOME/inspircd/bin:$PATH make -C irctest inspircd-anope strategy: fail-fast: false matrix: services: - no services - anope inspircd-4.7.0/.github/workflows/ci-linux.yml000066400000000000000000000037541477160314700212300ustar00rootroot00000000000000name: Ubuntu CI on: pull_request: push: schedule: - cron: '0 0 * * 0' jobs: build: if: "!contains(github.event.head_commit.message, '[skip ubuntu ci]')" runs-on: ubuntu-22.04 env: CXX: ${{ matrix.compiler }} INSPIRCD_DEBUG: 3 INSPIRCD_VERBOSE: 1 steps: - uses: actions/checkout@v4 - name: Install dependencies run: | sudo apt-get update --assume-yes sudo apt-get install --assume-yes --no-install-recommends \ clang \ g++ \ git \ libargon2-dev \ libgnutls28-dev \ libldap2-dev \ libmaxminddb-dev \ libmysqlclient-dev \ libpcre2-dev \ libpq-dev \ libpsl-dev \ libre2-dev \ libsqlite3-dev \ libssl-dev \ make \ pkg-config \ rapidjson-dev - name: Run configure run: | ./configure --enable-extras "argon2 geo_maxmind ldap log_json log_syslog mysql pgsql regex_pcre2 regex_posix regex_re2 sqlite3 ssl_gnutls ssl_openssl sslrehashsignal" ./configure --development --disable-auto-extras --socketengine ${{ matrix.socketengine }} - name: Build core run: | INSPIRCD_TARGET=inspircd make --jobs $(($(getconf _NPROCESSORS_ONLN) + 1)) - name: Build core modules run: | INSPIRCD_TARGET=coremods make --jobs $(($(getconf _NPROCESSORS_ONLN) + 1)) - name: Build modules run: | INSPIRCD_TARGET=modules make --jobs $(($(getconf _NPROCESSORS_ONLN) + 1)) - name: Install run: | make install - name: Run run: | touch ${{ github.workspace }}/run/conf/inspircd.conf ${{ github.workspace }}/run/inspircd start strategy: fail-fast: false matrix: compiler: - clang++ - g++ socketengine: - epoll - poll - select inspircd-4.7.0/.github/workflows/ci-macos.yml000066400000000000000000000045241477160314700211670ustar00rootroot00000000000000name: macOS CI on: pull_request: push: schedule: - cron: '0 0 * * 0' jobs: build: if: "!contains(github.event.head_commit.message, '[skip macos ci]')" runs-on: macos-14 env: HOMEBREW_NO_AUTO_UPDATE: 1 HOMEBREW_NO_INSTALL_CLEANUP: 1 HOMEBREW_NO_INSTALLED_DEPENDENTS_CHECK: 1 INSPIRCD_DEBUG: 3 INSPIRCD_VERBOSE: 1 steps: - uses: actions/checkout@v4 - name: Prepare the build environment run: | echo "CPPFLAGS=-I$(brew --prefix)/include" >> $GITHUB_ENV echo "LDFLAGS=-L$(brew --prefix)/lib" >> $GITHUB_ENV - name: Install dependencies run: | brew update || true for PACKAGE in pkg-config argon2 gnutls libmaxminddb libpq libpsl mysql-client openssl openldap pcre2 re2 sqlite yyjson do brew install $PACKAGE || brew upgrade $PACKAGE BREW_PREFIX=$(brew --prefix $PACKAGE) if [ -d "$BREW_PREFIX/bin" ] then export PATH="$PATH:$BREW_PREFIX/bin" fi if [ -d "$BREW_PREFIX/lib/pkgconfig" ] then export PKG_CONFIG_PATH="$PKG_CONFIG_PATH:$BREW_PREFIX/lib/pkgconfig" fi done echo "PATH=$PATH" >> $GITHUB_ENV echo "PKG_CONFIG_PATH=$PKG_CONFIG_PATH" >> $GITHUB_ENV - name: Run configure run: | ./configure --enable-extras "argon2 geo_maxmind ldap log_json log_syslog mysql pgsql regex_pcre2 regex_posix regex_re2 sqlite3 ssl_gnutls ssl_openssl sslrehashsignal" ./configure --development --disable-auto-extras --socketengine ${{ matrix.socketengine }} - name: Build core run: | INSPIRCD_TARGET=inspircd make --jobs $(($(sysctl -n hw.activecpu) + 1)) - name: Build core modules run: | INSPIRCD_TARGET=coremods make --jobs $(($(sysctl -n hw.activecpu) + 1)) - name: Build modules run: | INSPIRCD_TARGET=modules make --jobs $(($(sysctl -n hw.activecpu) + 1)) - name: Install run: | make install - name: Run run: | touch ${{ github.workspace }}/run/conf/inspircd.conf ${{ github.workspace }}/run/inspircd start strategy: fail-fast: false matrix: socketengine: - kqueue - poll - select inspircd-4.7.0/.github/workflows/ci-windows.yml000066400000000000000000000031461477160314700215560ustar00rootroot00000000000000name: Windows CI on: pull_request: push: release: types: - published schedule: - cron: '0 0 * * 0' jobs: build: if: "!contains(github.event.head_commit.message, '[skip windows ci]')" runs-on: windows-2019 steps: - uses: actions/checkout@v4 - name: Setup MSBuild uses: microsoft/setup-msbuild@v2.0.0 with: msbuild-architecture: x64 - name: Setup Conan uses: turtlebrowser/get-conan@v1.2 with: version: 1.66.0 - name: Install libraries working-directory: ${{ github.workspace }}/win/build run: | (Get-Content ../conanfile.txt).replace('##', '') | Set-Content ../conanfile.txt conan install .. --build=missing - name: Run CMake working-directory: ${{ github.workspace }}/win/build env: LDFLAGS: /DEBUG:FASTLINK /INCREMENTAL run: | cmake -A x64 -D CMAKE_BUILD_TYPE=${{ github.event_name == 'release' && 'Release' || 'Debug' }} -G "Visual Studio 16 2019" -Wdev .. - name: Build InspIRCd working-directory: ${{ github.workspace }}/win/build run: | msbuild PACKAGE.vcxproj /M:3 /P:Configuration=${{ github.event_name == 'release' && 'Release' || 'Debug' }} /P:Platform=x64 /VERBOSITY:MINIMAL - name: Upload installer if: "${{ github.event_name == 'release' }}" working-directory: ${{ github.workspace }}/win/build env: GH_TOKEN: ${{ secrets.GITHUB_TOKEN }} run: | gh release upload ${{ github.event.release.tag_name }} $(Get-ChildItem InspIRCd-*.exe) inspircd-4.7.0/.github/workflows/misspell-fixer.yml000066400000000000000000000025211477160314700224320ustar00rootroot00000000000000name: Misspell fixer on: schedule: - cron: '0 0 15 * *' jobs: build: if: github.repository == 'inspircd/inspircd' runs-on: ubuntu-latest env: REF_BRANCH: ${{ github.ref }} steps: - uses: actions/checkout@v4 - name : Set a couple env variables run: | echo "DATE=$(date +'%Y-%m-%d')" >> $GITHUB_ENV echo "REF_BRANCH=${REF_BRANCH//refs\/heads\//}" >> $GITHUB_ENV # The below creates a file used by grep '-f' # These are compared to './folder/file:line_num:word' - name: Whitelist some directories, files, and words. run: | echo "\ ^./.github/workflows ^./.mailmap ^./vendor ^./make/directive.pm:.*:atleast ALLTIME$ alltime$ Alltime$ setts$" > \ ${{ runner.workspace }}/inspircd/.misspell-fixer.ignore - uses: sobolevn/misspell-fixer-action@master with: options: '-rvnfuRVD .' - uses: peter-evans/create-pull-request@v7 with: token: ${{ secrets.GITHUB_TOKEN }} branch: ${{ env.REF_BRANCH }}+fix-spellings-${{ env.DATE }} author: 'InspIRCd Robot ' committer: 'InspIRCd Robot ' commit-message: 'Fixes by misspell-fixer' title: 'Typos fix by misspell-fixer' reviewers: 'genius3000' inspircd-4.7.0/.gitignore000066400000000000000000000010541477160314700153370ustar00rootroot00000000000000*~ *.pem *.swp .* !.git* /.configure /GNUmakefile /build /core /core.* /vgcore /vgcore.* /docs/doxygen /run /include/config.h /src/modules/m_argon2.cpp /src/modules/m_geo_maxmind.cpp /src/modules/m_ldap.cpp /src/modules/m_log_json.cpp /src/modules/m_log_syslog.cpp /src/modules/m_mysql.cpp /src/modules/m_pgsql.cpp /src/modules/m_regex_pcre2.cpp /src/modules/m_regex_posix.cpp /src/modules/m_regex_re2.cpp /src/modules/m_sqlite3.cpp /src/modules/m_ssl_gnutls.cpp /src/modules/m_ssl_openssl.cpp /src/modules/m_sslrehashsignal.cpp /win/Win32 /win/*.dir inspircd-4.7.0/.mailmap000066400000000000000000000121071477160314700147710ustar00rootroot00000000000000Adam Adam Adam Adam Ariadne Conill nenolod Ariadne Conill William Pitcock Attila Molnar Attila Molnar Attila Molnar attilamolnar Attila Molnar attilamolnar blitmap Pogs McPoggerson blitmap Sir Poggles blitmap Sir Pogsalot ChrisTX ChrisTX Craig Edwards (no author) <(no author)@e03df62e-2008-0410-955e-edbf42e46eb7> Craig Edwards brain Craig Edwards root Craig McLure frostycoolslug Daniel De Graaf danieldg Daniel Vassdal Daniel Vassdal Daniel Vassdal Daniel Vassdal Daniel Vassdal Daniel Vassdal Daniel Vassdal Daniel Vassdal Daniel Vassdal ShutterQuick Dennis Friis peavey DjSlash Rutger Geoff Bricker bricker Herman GermanAizek iwalkalone iwalkalone jackmcbarn Jackmcbarn James Lu James Lu John Brooks special Justin Crawford Justasic linuxdaemon linuxdaemon linuxdaemon linuxdaemon Matt Schatz genius3000 Matt Smith dz md_5 md-5 Oliver Lupton om Pippijn van Steenhoven pippijn Robby Robby Robby Robby- Robby Robby- Robin Burchell Robin Burchell Robin Burchell w00t Sadie Powell Peter Powell satmd satmd satmd satmd Thomas Stagner aquanight typobox43 typobox43 Uli Schlachter psychon Val Lorentz Valentin Lorentz Val Lorentz Val Lorentz # The identities of the following people could not be verified. If you have an # email address for them please contact Sadie. burlex burlex eggy eggy fez fez jamie jamie katsklaw katsklaw PhilSliderS Philouuu PhilSliderS PhilSliderS randomdan randomdan inspircd-4.7.0/README.md000066400000000000000000000050511477160314700146270ustar00rootroot00000000000000## About InspIRCd is a modular C++ Internet Relay Chat (IRC) server for UNIX-like and Windows systems. ## Supported Platforms InspIRCd is supported on the following platforms: - Most recent BSD variants using the Clang 5+ or GCC 7+ compilers and the GNU toolchains (Make, etc). - Most recent Linux distributions using the Clang 5+ or GCC 7+ compilers and the GNU toolchain. - The three most recent major releases of macOS using the AppleClang 10, Clang 5+, or GCC 7+ compilers and the GNU toolchain. - Windows 10 April 2018 Update or newer using the MSVC 19.15+ (Visual Studio 15.8 2017) compiler and CMake 3.20 or newer. Other platforms and toolchains may also work but are not officially supported by the InspIRCd team. Generally speaking if you are using a reasonably modern UNIX-like system you should be able to build InspIRCd on it. If you can not and you wish to submit a patch we are happy to accept it as long as it is not extremely large. If you encounter any bugs then [please file an issue](https://github.com/inspircd/inspircd/issues/new/choose). ## Installation Most InspIRCd users running a UNIX-like system build from source. A guide about how to do this is available on [the InspIRCd docs site](https://docs.inspircd.org/4/installation/source). Building from source on Windows is generally not recommended but [a guide is available](https://docs.inspircd.org/4/installation/windows-source/) if you wish to do this. If you are running on Debian 12/13, RHEL 8/9, Ubuntu 22.04/24.04, or Windows 10+ binary packages are available from [the downloads page](https://github.com/inspircd/inspircd/releases/latest). A [Docker](https://www.docker.com) image is also available. See [the inspircd-docker repository](https://github.com/inspircd/inspircd-docker) for more information. Some distributions ship an InspIRCd package in their package managers. We generally do not recommend the use of such packages as in the past distributions have made broken modifications to InspIRCd and not kept their packages up to date with essential security updates. ## License InspIRCd is licensed under [version 2 of the GNU General Public License](https://docs.inspircd.org/license). ## External Links * [Website](https://www.inspircd.org) * [Documentation](https://docs.inspircd.org) * [GitHub](https://github.com/inspircd) * [Support](https://docs.inspircd.org/support) * Support IRC channel — \#inspircd on irc.teranova.net (TLS only) * Development IRC channel — \#inspircd.dev on irc.teranova.net (TLS only) * InspIRCd test network — testnet.inspircd.org (TLS only) inspircd-4.7.0/configure000077500000000000000000000611301477160314700152570ustar00rootroot00000000000000#!/usr/bin/env perl # # InspIRCd -- Internet Relay Chat Daemon # # Copyright (C) 2019 Matt Schatz # Copyright (C) 2013-2022, 2024 Sadie Powell # Copyright (C) 2012, 2019 Robby # Copyright (C) 2012 ChrisTX # Copyright (C) 2010 Daniel De Graaf # Copyright (C) 2008 Thomas Stagner # Copyright (C) 2008 Robin Burchell # Copyright (C) 2007 Dennis Friis # Copyright (C) 2006, 2008 Craig Edwards # # This file is part of InspIRCd. InspIRCd is free software: you can # redistribute it and/or modify it under the terms of the GNU General Public # License as published by the Free Software Foundation, version 2. # # This program is distributed in the hope that it will be useful, but WITHOUT # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS # FOR A PARTICULAR PURPOSE. See the GNU General Public License for more # details. # # You should have received a copy of the GNU General Public License # along with this program. If not, see . # use v5.26.0; use strict; use warnings FATAL => qw(all); use Config qw(%Config); use Cwd qw(getcwd); use File::Basename qw(basename); use File::Copy (); use File::Spec::Functions qw(abs2rel catfile catdir rel2abs); use FindBin qw($RealDir); use Getopt::Long qw(GetOptions); use POSIX qw(getgid getuid); use lib $RealDir; use make::common; use make::configure; use make::console; use make::directive; my ($opt_binary_dir, $opt_config_dir, $opt_data_dir, $opt_development, $opt_disable_auto_extras, $opt_disable_interactive, $opt_disable_ownership, $opt_distribution_label, $opt_example_dir, $opt_gid, $opt_log_dir, $opt_manual_dir, $opt_module_dir, $opt_portable, $opt_prefix, $opt_runtime_dir, $opt_script_dir, $opt_socketengine, $opt_system, $opt_uid); sub list_extras (); sub enable_extras (@); sub disable_extras (@); my @opt_enableextras; my @opt_disableextras; exit 1 unless GetOptions( 'clean' => \&cmd_clean, 'help' => \&cmd_help, 'update' => \&cmd_update, 'binary-dir=s' => \$opt_binary_dir, 'config-dir=s' => \$opt_config_dir, 'data-dir=s' => \$opt_data_dir, 'development' => \$opt_development, 'disable-auto-extras' => \$opt_disable_auto_extras, 'disable-interactive' => \$opt_disable_interactive, 'disable-ownership' => \$opt_disable_ownership, 'distribution-label=s' => \$opt_distribution_label, 'example-dir=s' => \$opt_example_dir, 'gid=s' => \$opt_gid, 'log-dir=s' => \$opt_log_dir, 'manual-dir=s' => \$opt_manual_dir, 'module-dir=s' => \$opt_module_dir, 'portable' => \$opt_portable, 'prefix=s' => \$opt_prefix, 'runtime-dir=s' => \$opt_runtime_dir, 'script-dir=s' => \$opt_script_dir, 'socketengine=s' => \$opt_socketengine, 'system' => \$opt_system, 'uid=s' => \$opt_uid, 'disable-extras=s@' => \@opt_disableextras, 'enable-extras=s@' => \@opt_enableextras, 'list-extras' => sub { list_extras; exit 0; }, ); if (scalar(@opt_enableextras) + scalar(@opt_disableextras) > 0) { @opt_enableextras = grep { /\S/ } split /[, ]+/, join(',', @opt_enableextras); @opt_disableextras = grep { /\S/ } split /[, ]+/, join(',', @opt_disableextras); enable_extras(@opt_enableextras); disable_extras(@opt_disableextras); list_extras; print "Remember: YOU are responsible for making sure any libraries needed have been installed!\n"; exit 0; } our $interactive = !( !-t STDIN || !-t STDOUT || defined $opt_binary_dir || defined $opt_config_dir || defined $opt_data_dir || defined $opt_development || defined $opt_disable_auto_extras || defined $opt_disable_interactive || defined $opt_disable_ownership || defined $opt_distribution_label || defined $opt_example_dir || defined $opt_gid || defined $opt_log_dir || defined $opt_manual_dir || defined $opt_module_dir || defined $opt_portable || defined $opt_prefix || defined $opt_runtime_dir || defined $opt_script_dir || defined $opt_socketengine || defined $opt_system || defined $opt_uid ); my %version = get_version $opt_distribution_label; chomp(my $platform = `uname -mrs 2>/dev/null` || "$Config{osname} $Config{osvers} $Config{archname}"); say console_format "Configuring <|GREEN InspIRCd $version{FULL}|> on <|GREEN $platform|>."; my %config; if ($interactive) { %config = read_config_file(CONFIGURE_CACHE_FILE); run_test abs2rel(CONFIGURE_CACHE_FILE, $RealDir), %config; if (!defined $config{VERSION}) { $config{VERSION} = CONFIGURE_CACHE_VERSION; } elsif ($config{VERSION} != CONFIGURE_CACHE_VERSION) { print_warning "ignoring contents of ${\CONFIGURE_CACHE_FILE} as it was generated by an incompatible version of $0!"; %config = ('VERSION', CONFIGURE_CACHE_VERSION); } } unless (run_test $RealDir, -w $RealDir, 'writable') { print_error <<"EOE"; the source directory is not writable. This most likely means that you downloaded InspIRCd as root but tried to build as an unprivileged user. To fix this issue redownload the source as the user you want to build as or fix the permissions of <|GREEN $RealDir|>. EOE }; $config{CXX} = find_compiler($config{CXX} // $ENV{CXX}); unless ($config{CXX}) { say 'A suitable C++ compiler could not be detected on your system!'; unless ($interactive) { say 'Set the CXX environment variable to the path to a C++ compiler binary if this is incorrect.'; exit 1; } until ($config{CXX}) { my $compiler_path = prompt_string 1, 'Please enter the path to a C++ compiler binary:', 'c++'; $config{CXX} = find_compiler $compiler_path; } } my %compiler = get_compiler_info($config{CXX}); $config{HAS_ARC4RANDOM_BUF} = run_test 'arc4random_buf()', test_file($config{CXX}, 'arc4random_buf.cpp'); $config{HAS_CLOCK_GETTIME} = run_test 'clock_gettime()', test_file($config{CXX}, 'clock_gettime.cpp', $^O eq 'darwin' ? undef : '-lrt'); $config{HAS_GETENTROPY} = run_test 'getentropy()', test_file($config{CXX}, 'getentropy.cpp'); my @socketengines; push @socketengines, 'epoll' if run_test 'epoll', test_header $config{CXX}, 'sys/epoll.h'; push @socketengines, 'kqueue' if run_test 'kqueue', test_file $config{CXX}, 'kqueue.cpp'; push @socketengines, 'poll' if run_test 'poll', test_header $config{CXX}, 'poll.h'; push @socketengines, 'select'; if (defined $opt_socketengine) { unless (grep { $_ eq $opt_socketengine } @socketengines) { my $reason = -f "src/socketengines/$opt_socketengine.cpp" ? 'is not available on this platform' : 'does not exist'; print_error "The socket engine you requested ($opt_socketengine) $reason!", 'Available socket engines are:', map { " * $_" } @socketengines; } } $config{SOCKETENGINE} = $opt_socketengine // $socketengines[0]; if (defined $opt_portable) { print_error '--portable and --system can not be used together!' if defined $opt_system; $config{DESTDIR} = catfile $RealDir, 'run', ''; $config{BASE_DIR} = $opt_prefix // ''; $config{BINARY_DIR} = $opt_binary_dir // 'bin'; $config{CONFIG_DIR} = $opt_config_dir // 'conf'; $config{DATA_DIR} = $opt_data_dir // 'data'; $config{EXAMPLE_DIR} = $opt_example_dir // catdir $config{CONFIG_DIR}, 'examples'; $config{LOG_DIR} = $opt_log_dir // 'logs'; $config{MANUAL_DIR} = $opt_manual_dir // 'manuals'; $config{MODULE_DIR} = $opt_module_dir // 'modules'; $config{RUNTIME_DIR} = $opt_runtime_dir // $config{DATA_DIR}; $config{SCRIPT_DIR} = $opt_script_dir // $config{BASE_DIR}; } elsif (defined $opt_system) { $config{BASE_DIR} = $opt_prefix // '/'; $config{BINARY_DIR} = $opt_binary_dir // catdir $config{BASE_DIR}, 'usr/bin'; $config{CONFIG_DIR} = $opt_config_dir // catdir $config{BASE_DIR}, 'etc/inspircd'; $config{DATA_DIR} = $opt_data_dir // catdir $config{BASE_DIR}, 'var/lib/inspircd'; $config{EXAMPLE_DIR} = $opt_example_dir // catdir $config{BASE_DIR}, 'usr/share/doc/inspircd/examples'; $config{LOG_DIR} = $opt_log_dir // catdir $config{BASE_DIR}, 'var/log/inspircd'; $config{MANUAL_DIR} = $opt_manual_dir // catdir $config{BASE_DIR}, 'usr/share/man/man1'; $config{MODULE_DIR} = $opt_module_dir // catdir $config{BASE_DIR}, 'usr/lib/inspircd'; $config{RUNTIME_DIR} = $opt_runtime_dir // catdir $config{BASE_DIR}, $^O eq 'linux' ? '/run/inspircd' : '/var/run/inspircd'; $config{SCRIPT_DIR} = $opt_script_dir // catdir $config{BASE_DIR}, 'usr/share/inspircd'; } else { $config{BASE_DIR} = rel2abs $opt_prefix // $config{BASE_DIR} // catdir $RealDir, 'run'; $config{BINARY_DIR} = $opt_binary_dir // $config{BINARY_DIR} // catdir $config{BASE_DIR}, 'bin'; $config{CONFIG_DIR} = $opt_config_dir // $config{CONFIG_DIR} // catdir $config{BASE_DIR}, 'conf'; $config{DATA_DIR} = $opt_data_dir // $config{DATA_DIR} // catdir $config{BASE_DIR}, 'data'; $config{EXAMPLE_DIR} = $opt_example_dir // $config{EXAMPLE_DIR} // catdir $config{CONFIG_DIR}, 'examples'; $config{LOG_DIR} = $opt_log_dir // $config{LOG_DIR} // catdir $config{BASE_DIR}, 'logs'; $config{MANUAL_DIR} = $opt_manual_dir // $config{MANUAL_DIR} // catdir $config{BASE_DIR}, 'manuals'; $config{MODULE_DIR} = $opt_module_dir // $config{MODULE_DIR} // catdir $config{BASE_DIR}, 'modules'; $config{RUNTIME_DIR} = $opt_runtime_dir // $config{RUNTIME_DIR} // $config{DATA_DIR}; $config{SCRIPT_DIR} = $opt_script_dir // $config{SCRIPT_DIR} // $config{BASE_DIR}; } # Parse --gid=123 or --gid=foo and extract the group id. my @group; if (defined $opt_gid) { @group = $opt_gid =~ /^\d+$/ ? getgrgid($opt_gid) : getgrnam($opt_gid); print_error "there is no '$opt_gid' group on this system!" unless @group; } elsif (defined $opt_disable_ownership) { @group = qw(insert-group-here . -1); } else { @group = $opt_system ? getgrnam('irc') : getgrgid($config{GID} // getgid()); print_error "you need to specify a group to run as using '--gid [id|name]'!" unless @group; unless ($group[2]) { print_warning <<"EOW"; You are building as the privileged $group[0] group and have not specified an unprivileged group to run InspIRCd as. This is almost never what you should do. You should probably either create a new unprivileged user/group to build and run as or pass the '--gid [id|name]' flag to specify an unprivileged group to run as. EOW if (!prompt_bool $interactive, "Are you sure you want to build as the $group[0] group?", 0) { # PACKAGERS: You do not need to delete this check. Use `--disable-ownership` instead. say STDERR "If you are sure you want to build as the $group[0] group pass the --gid $group[2] flag." unless $interactive; exit 1; } } } $config{GROUP} = $group[0]; $config{GID} = $group[2]; # Parse --uid=123 or --uid=foo and extract the user id. my @user; if (defined $opt_uid) { @user = $opt_uid =~ /^\d+$/ ? getpwuid($opt_uid) : getpwnam($opt_uid); print_error "there is no '$opt_uid' user on this system!" unless @user; } elsif (defined $opt_disable_ownership) { @user = qw(insert-user-here . -1); } else { @user = $opt_system ? getpwnam('irc') : getpwuid($config{UID} // getuid()); print_error "you need to specify a user to run as using '--uid [id|name]'!" unless @user; unless ($user[2]) { print_warning <<"EOW"; You are building as the privileged $user[0] user and have not specified an unprivileged user to run InspIRCd as. This is almost never what you should do. You should probably either create a new unprivileged user/group to build and run as or pass the '--uid [id|name]' flag to specify an unprivileged user to run as. EOW if (!prompt_bool $interactive, "Are you sure you want to build as the $user[0] user?", 0) { # PACKAGERS: You do not need to delete this check. Use `--disable-ownership` instead. say STDERR "If you are sure you want to build as the $user[0] user pass the --uid $user[2] flag." unless $interactive; exit 1; } } } $config{USER} = $user[0]; $config{UID} = $user[2]; # Warn the user about clock drifting when running on OpenVZ. if (-e '/proc/user_beancounters' || -e '/proc/vz/vzaquota') { print_warning <<'EOW'; You are building InspIRCd inside of an OpenVZ container. If you plan to use InspIRCd in this container then you should make sure that NTP is configured on the Hardware Node. Failure to do so may result in clock drifting! EOW } # Warn the user about OpenBSD shipping incredibly broken compilers/linkers. if ($^O eq 'openbsd') { print_warning <<'EOW'; You are building InspIRCd on OpenBSD. The C++ compilers and linkers that OpenBSD ship are incredibly broken. You may have strange linker errors and crashes. Please consider using a different OS like FreeBSD/NetBSD instead. EOW } # Warn about how quirky musl's libdl implementation is. chomp(my $machine = `$config{CXX} -dumpmachine 2>/dev/null`); if ($machine =~ /-musl$/) { print_warning <<'EOW'; You are building InspIRCd with musl. This libc does not have a useful dlclose() implementation which causes problems with unloading and reloading modules. Please complain to the musl maintainers if this is an issue for you. EOW } # Check that the user actually wants this version. if (defined $version{REAL_LABEL}) { print_warning <<'EOW'; You are building a development version. This contains code which has not been tested as heavily and may contain various faults which could seriously affect the running of your server. It is recommended that you use a stable version instead. You can obtain the latest stable version from https://www.inspircd.org or by running `<|GREEN git checkout $(git describe --abbrev=0 --tags insp4)|>` if you are installing from Git. EOW if (!prompt_bool $interactive, 'I understand this warning and want to continue anyway.', $opt_development // 0) { say STDERR 'If you understand this warning and still want to continue pass the --development flag.' unless $interactive; exit 1; } } # Configure directory settings. my $question = <<"EOQ"; Currently, InspIRCd is configured with the following paths: <|BOLD Binary:|> $config{BINARY_DIR} <|BOLD Config:|> $config{CONFIG_DIR} <|BOLD Data:|> $config{DATA_DIR} <|BOLD Log:|> $config{LOG_DIR} <|BOLD Manual:|> $config{MANUAL_DIR} <|BOLD Module:|> $config{MODULE_DIR} <|BOLD Script:|> $config{SCRIPT_DIR} Do you want to change these settings? EOQ if (prompt_bool $interactive, $question, 0) { my $original_base_dir = $config{BASE_DIR}; $config{BASE_DIR} = prompt_dir $interactive, 'In what directory do you wish to install the InspIRCd base?', $config{BASE_DIR}; for my $key (qw(BINARY_DIR CONFIG_DIR DATA_DIR LOG_DIR MANUAL_DIR MODULE_DIR SCRIPT_DIR)) { $config{$key} =~ s/^\Q$original_base_dir\E/$config{BASE_DIR}/; } $config{BINARY_DIR} = prompt_dir $interactive, 'In what directory should the InspIRCd binary be placed?', $config{BINARY_DIR}; $config{CONFIG_DIR} = prompt_dir $interactive, 'In what directory are configuration files to be stored?', $config{CONFIG_DIR}; $config{DATA_DIR} = prompt_dir $interactive, 'In what directory are variable data files to be stored?', $config{DATA_DIR}; $config{LOG_DIR} = prompt_dir $interactive, 'In what directory are log files to be stored?', $config{LOG_DIR}; $config{MANUAL_DIR} = prompt_dir $interactive, 'In what directory are manual pages to be placed?', $config{MANUAL_DIR}; $config{MODULE_DIR} = prompt_dir $interactive, 'In what directory are modules to be placed?', $config{MODULE_DIR}; $config{SCRIPT_DIR} = prompt_dir $interactive, 'In what directory are scripts to be placed?', $config{SCRIPT_DIR}; $config{EXAMPLE_DIR} = $config{CONFIG_DIR} . '/examples'; $config{RUNTIME_DIR} = $config{DATA_DIR}; } # Configure module settings. $question = <<'EOQ'; Currently, InspIRCd is configured to automatically enable all available extra modules. Would you like to enable extra modules manually? EOQ if (prompt_bool $interactive, $question, 0) { for my $extra (<$RealDir/src/modules/extra/m_*.cpp>) { my $module_name = module_shrink $extra; if (prompt_bool $interactive, "Would you like to enable the <|BOLD $module_name|> module?", 0) { enable_extras $module_name; } } } elsif (!defined $opt_disable_auto_extras) { my %modules = ( 'argon2' => 'pkg-config --exists libargon2', 'geo_maxmind' => 'pkg-config --exists libmaxminddb', 'mysql' => 'mysql_config --version', 'pgsql' => 'pg_config --version', 'ldap' => "pkg-config --exists lber && pkg-config --exists ldap", 'log_json' => 'pkg-config --exists yyjson', 'log_syslog' => undef, 'regex_pcre2' => 'pkg-config --exists libpcre2-8', 'regex_posix' => undef, 'regex_re2' => 'pkg-config --exists re2', 'sqlite3' => 'pkg-config --exists sqlite3', 'ssl_gnutls' => 'pkg-config --exists "gnutls >= 3.3.5"', 'ssl_openssl' => 'pkg-config --exists "openssl >= 1.1.1"', 'sslrehashsignal' => undef, ); while (my ($module, $command) = each %modules) { unless (defined $command && system "$command 1>/dev/null 2>/dev/null") { enable_extras $module; } } } if (!<$RealDir/src/modules/m_ssl_*.cpp> && !defined $opt_disable_auto_extras) { print_error <<"EOM"; you MUST build with at least one TLS module. TLS greatly enhances the security and privacy of your IRC server and is required for linking servers. Please read the following documentation pages on how to enable TLS support: Configuration: https://docs.inspircd.org/tutorials/enable-tls GnuTLS module: https://docs.inspircd.org/$version{MAJOR}/modules/ssl_gnutls OpenSSL module: https://docs.inspircd.org/$version{MAJOR}/modules/ssl_openssl EOM } # Cache the distribution label so that its not lost when --update is run. $config{DISTRIBUTION} = $opt_distribution_label if $opt_distribution_label; $config{DISABLE_OWNERSHIP} = $opt_disable_ownership // 0; write_configure_cache %config; parse_templates \%config, \%compiler, \%version; print console_format <<"EOM"; Configuration is complete! You have chosen to build with the following settings: <|GREEN Compiler:|> <|GREEN Binary:|> $config{CXX} <|GREEN Name:|> $compiler{NAME} <|GREEN Version:|> $compiler{VERSION} <|GREEN Extra Modules:|> EOM for my $file (<$RealDir/src/modules/m_*>) { say " * ${\module_shrink $file}" if -l $file; } my @makeargs; push @makeargs, "-C${\abs2rel $RealDir}" unless getcwd eq $RealDir; push @makeargs, "-j${\(get_cpu_count() + 1)}"; print console_format <<"EOM"; <|GREEN Paths:|> <|GREEN Binary:|> $config{BINARY_DIR} <|GREEN Config:|> $config{CONFIG_DIR} <|GREEN Data:|> $config{DATA_DIR} <|GREEN Example:|> $config{EXAMPLE_DIR} <|GREEN Log:|> $config{LOG_DIR} <|GREEN Manual:|> $config{MANUAL_DIR} <|GREEN Module:|> $config{MODULE_DIR} <|GREEN Runtime:|> $config{RUNTIME_DIR} <|GREEN Script:|> $config{SCRIPT_DIR} <|GREEN Execution Group:|> $config{GROUP} ($config{GID}) <|GREEN Execution User:|> $config{USER} ($config{UID}) <|GREEN Socket Engine:|> $config{SOCKETENGINE} To build with these settings run '<|GREEN make ${\join ' ', @makeargs} install|>' now. EOM # Routine to list out the extra/ modules that have been enabled. # Note: when getting any filenames out and comparing, it's important to lc it if the # file system is not case-sensitive (== Epoc, MacOS, OS/2 (incl DOS/DJGPP), VMS, Win32 # (incl NetWare, Symbian)). Cygwin may or may not be case-sensitive, depending on # configuration, however, File::Spec does not currently tell us (it assumes Unix behavior). sub list_extras () { use File::Spec; # @_ not used my $srcdir = File::Spec->catdir("src", "modules"); my $abs_srcdir = File::Spec->rel2abs($srcdir); local $_; my $dd; opendir $dd, File::Spec->catdir($abs_srcdir, "extra") or die (File::Spec->catdir($abs_srcdir, "extra") . ": $!\n"); my @extras = map { File::Spec->case_tolerant() ? lc($_) : $_ } (readdir($dd)); closedir $dd; undef $dd; opendir $dd, $abs_srcdir or die "$abs_srcdir: $!\n"; my @sources = map { File::Spec->case_tolerant() ? lc($_) : $_ } (readdir($dd)); closedir $dd; undef $dd; my $maxlen = (sort { $b <=> $a } (map { length module_shrink $_ } (@extras)))[0]; my %extras = (); EXTRA: for my $extra (@extras) { next if (File::Spec->curdir() eq $extra || File::Spec->updir() eq $extra); my $abs_extra = File::Spec->catfile($abs_srcdir, "extra", $extra); my $abs_source = File::Spec->catfile($abs_srcdir, $extra); next unless ($extra =~ m/\.(cpp|h)$/ || (-d $abs_extra)); # C++ Source/Header, or directory if (-l $abs_source) { # Symlink, is it in the right place? my $targ = readlink($abs_source); my $abs_targ = File::Spec->rel2abs($targ, $abs_srcdir); if ($abs_targ eq $abs_extra) { $extras{$extra} = "\e[32;1menabled\e[0m"; } else { $extras{$extra} = sprintf("\e[31;1mwrong symlink target (%s)\e[0m", $abs_targ); } } elsif (-e $abs_source) { my ($devext, $inoext) = stat($abs_extra); my ($devsrc, $inosrc, undef, $lnksrc) = stat($abs_source); if ($lnksrc > 1) { if ($devsrc == $devext && $inosrc == $inoext) { $extras{$extra} = "\e[32;1menabled\e[0m"; } else { $extras{$extra} = sprintf("\e[31;1mwrong hardlink target (%d:%d)\e[0m", $devsrc, $inosrc); } } else { open my $extfd, "<", $abs_extra; open my $srcfd, "<", $abs_source; local $/ = undef; if (scalar(<$extfd>) eq scalar(<$srcfd>)) { $extras{$extra} = "\e[32;1menabled\e[0m"; } else { $extras{$extra} = sprintf("\e[31;1mout of synch (re-copy)\e[0m"); } } } else { $extras{$extra} = "\e[33;1mdisabled\e[0m"; } } # Now let's add dependency info for my $extra (keys(%extras)) { next unless $extras{$extra} =~ m/enabled/; # only process enabled extras. my $abs_extra = File::Spec->catfile($abs_srcdir, "extra", $extra); my @deps = split /\s+/, get_directive($abs_extra, 'ModDep', ''); for my $dep (@deps) { if (exists($extras{$dep})) { my $ref = \$extras{$dep}; # Take reference. if ($$ref !~ m/needed by/) { # First dependency found. if ($$ref =~ m/enabled/) { $$ref .= " (needed by \e[32;1m$extra\e[0m"; } else { $$ref =~ s/\e\[.*?m//g; # Strip out previous coloring. Will be set in bold+red+blink later. $$ref .= " (needed by \e[0;32;1;5m$extra\e[0;31;1;5m"; } } else { if ($$ref =~ m/enabled/) { $$ref .= ", \e[32;1m$extra\e[0m"; } else { $$ref .= ", \e[0;32;1;5m$extra\e[0;31;1;5m"; } } } } } for my $extra (sort {$a cmp $b} keys(%extras)) { my $text = $extras{$extra}; if ($text =~ m/needed by/ && $text !~ m/enabled/) { printf "\e[31;1;5m%-*s = %s%s\e[0m\n", $maxlen, module_shrink($extra), $text, ($text =~ m/needed by/ ? ")" : ""); } else { printf "%-*s = %s%s\n", $maxlen, module_shrink($extra), $text, ($text =~ m/needed by/ ? "\e[0m)" : ""); } } return keys(%extras) if wantarray; # Can be used by manage_extras. } sub enable_extras(@) { my $moduledir = catdir $RealDir, 'src', 'modules'; my $extradir = catdir $moduledir, 'extra'; for my $extra (@_) { my $shortname = module_shrink $extra; my $extrafile = module_expand $extra; my $extrapath = catfile $extradir, $extrafile; if (!-f $extrapath) { print_error "<|GREEN $extra|> is not an extra module!"; } my $modulepath = catfile $moduledir, $extrafile; if (-l $modulepath) { if (readlink($modulepath) ne $extrapath) { unlink $modulepath; # Remove the dead symlink. } else { next; # Module is already enabled. } } if (-e $modulepath) { print_error "unable to symlink <|GREEN ${\abs2rel $modulepath}|> to <|GREEN ${\abs2rel $extrapath}|>: the target exists and is not a symlink."; } else { say console_format "Enabling the <|GREEN $shortname|> module ..."; symlink $extrapath, $modulepath or print_error "unable to symlink <|GREEN ${\abs2rel $modulepath}|> to <|GREEN ${\abs2rel $extrapath}|>: $!"; } } } sub disable_extras(@) { my $moduledir = catdir $RealDir, 'src', 'modules'; my $extradir = catdir $moduledir, 'extra'; for my $extra (@_) { my $shortname = module_shrink $extra; my $extrafile = module_expand $extra; my $modulepath = catfile $moduledir, $extrafile; my $extrapath = catfile $extradir, $extrafile; if (!-e $modulepath && !-e $extrapath) { print_error "the <|GREEN $shortname|> module does not exist!"; } elsif (!-e $modulepath && -e $extrapath) { print_error "the <|GREEN $shortname|> module is not currently enabled!"; } elsif ((-e $modulepath && !-e $extrapath) || !-l $modulepath) { print_error "the <|GREEN $shortname|> module is not an extra module!"; } else { say console_format "Disabling the <|GREEN $shortname|> module ..."; unlink $modulepath or print_error "unable to unlink <|GREEN $extrapath|>: $!"; } } } inspircd-4.7.0/docs/000077500000000000000000000000001477160314700142775ustar00rootroot00000000000000inspircd-4.7.0/docs/AUTHORS.txt000066400000000000000000000077471477160314700162040ustar00rootroot00000000000000Since the first commit in January 2003 111 people have submitted patches, commits, and other useful contributions to InspIRCd. These people, ordered by the number of contributions they have made, are: * Craig Edwards * Sadie Powell * Attila Molnar * Robin Burchell * Daniel De Graaf * Dennis Friis * Oliver Lupton * John Brooks * Adam * Craig McLure * Matt Schatz * Thomas Stagner * Robby * Daniel Vassdal * Matt Smith * Geoff Bricker * linuxdaemon * Pippijn van Steenhoven * Ariadne Conill * burlex * jackmcbarn * Uli Schlachter * B00mX0r * ChrisTX * fez * Shawn Smith * DjSlash * blitmap * jamie * Justin Crawford * Wade Cline * iwalkalone * katsklaw * Val Lorentz * Dylan Frank * satmd * Steven Van Acker * Dan Parsons * Googolplexed * Herman * Mantas MikulФ—nas * Renegade334 * Sheogorath * typobox43 * Anatole Denis * Andrio Celos * Ben Harris * Chin Lee * Christopher 'm4z' Holm * eggy * Glen Miner * Guillaume Delacour * James Lu * JD Horelick * Jens Voss * Johanna A * Kyle Fuller * Marcus Rueckert * md_5 * Michael * Michael Hazell * Molly Miller * PhilSliderS * 0x277F <0x277F@gmail.com> * A_D * Adrien Bustany * Akinwale Ariwodola * Alyx * Boleslaw Tokarski * Chew * Chris Novakovic * Christian HУЖltje * Christoph Egger * Christos Triantafyllidis * David Lamont * David Schultz * delthas * Dominic Hamon * edef * ElementalAlchemist * Elizabeth Myers * emerson * Filippo Cortigiani * Florian Praden * Garrett Holmstrom * Hendrik JУЄger * James Wheare * Joel Sing * Jordyn/The Linux Geek * Josh Soref * Julien Vehent * JustArchi * Larry Williamson * Matthew Martin * newuser1 * nia * Nicole Kleinhoff * Pierre Carrier * Puck Meerburg * R-V6 * randomdan * Richard Bradfield * systocrat * ThatOneRoadie * The Aviator * Thiago Crepaldi * Thomas Fargeix * Tim Heckman * Vitor Luis * WindowsUser inspircd-4.7.0/docs/Doxyfile000066400000000000000000000207721477160314700160150ustar00rootroot00000000000000DOXYFILE_ENCODING = UTF-8 PROJECT_NAME = InspIRCd PROJECT_NUMBER = v4 PROJECT_BRIEF = PROJECT_LOGO = PROJECT_ICON = win/inspircd.ico OUTPUT_DIRECTORY = docs/doxygen CREATE_SUBDIRS = NO CREATE_SUBDIRS_LEVEL = 8 ALLOW_UNICODE_NAMES = NO OUTPUT_LANGUAGE = English BRIEF_MEMBER_DESC = YES REPEAT_BRIEF = YES ABBREVIATE_BRIEF = ALWAYS_DETAILED_SEC = NO INLINE_INHERITED_MEMB = NO FULL_PATH_NAMES = YES STRIP_FROM_PATH = STRIP_FROM_INC_PATH = SHORT_NAMES = NO JAVADOC_AUTOBRIEF = NO JAVADOC_BANNER = NO QT_AUTOBRIEF = NO MULTILINE_CPP_IS_BRIEF = NO PYTHON_DOCSTRING = YES INHERIT_DOCS = YES SEPARATE_MEMBER_PAGES = NO TAB_SIZE = 8 ALIASES = OPTIMIZE_OUTPUT_FOR_C = NO OPTIMIZE_OUTPUT_JAVA = NO OPTIMIZE_FOR_FORTRAN = NO OPTIMIZE_OUTPUT_VHDL = NO OPTIMIZE_OUTPUT_SLICE = NO EXTENSION_MAPPING = MARKDOWN_SUPPORT = YES TOC_INCLUDE_HEADINGS = 5 MARKDOWN_ID_STYLE = GITHUB AUTOLINK_SUPPORT = YES BUILTIN_STL_SUPPORT = YES CPP_CLI_SUPPORT = NO SIP_SUPPORT = NO IDL_PROPERTY_SUPPORT = YES DISTRIBUTE_GROUP_DOC = NO GROUP_NESTED_COMPOUNDS = NO SUBGROUPING = YES INLINE_GROUPED_CLASSES = NO INLINE_SIMPLE_STRUCTS = NO TYPEDEF_HIDES_STRUCT = NO LOOKUP_CACHE_SIZE = 0 NUM_PROC_THREADS = 0 TIMESTAMP = NO EXTRACT_ALL = YES EXTRACT_PRIVATE = YES EXTRACT_PRIV_VIRTUAL = YES EXTRACT_PACKAGE = NO EXTRACT_STATIC = YES EXTRACT_LOCAL_CLASSES = NO EXTRACT_LOCAL_METHODS = NO EXTRACT_ANON_NSPACES = NO RESOLVE_UNNAMED_PARAMS = YES HIDE_UNDOC_MEMBERS = NO HIDE_UNDOC_CLASSES = NO HIDE_FRIEND_COMPOUNDS = NO HIDE_IN_BODY_DOCS = NO INTERNAL_DOCS = NO CASE_SENSE_NAMES = NO HIDE_SCOPE_NAMES = NO HIDE_COMPOUND_REFERENCE= NO SHOW_HEADERFILE = YES SHOW_INCLUDE_FILES = YES SHOW_GROUPED_MEMB_INC = NO FORCE_LOCAL_INCLUDES = NO INLINE_INFO = YES SORT_MEMBER_DOCS = YES SORT_BRIEF_DOCS = NO SORT_MEMBERS_CTORS_1ST = NO SORT_GROUP_NAMES = NO SORT_BY_SCOPE_NAME = NO STRICT_PROTO_MATCHING = NO GENERATE_TODOLIST = YES GENERATE_TESTLIST = YES GENERATE_BUGLIST = YES GENERATE_DEPRECATEDLIST= YES ENABLED_SECTIONS = MAX_INITIALIZER_LINES = 30 SHOW_USED_FILES = YES SHOW_FILES = YES SHOW_NAMESPACES = YES FILE_VERSION_FILTER = LAYOUT_FILE = CITE_BIB_FILES = QUIET = NO WARNINGS = NO WARN_IF_UNDOCUMENTED = NO WARN_IF_DOC_ERROR = YES WARN_IF_INCOMPLETE_DOC = YES WARN_NO_PARAMDOC = NO WARN_IF_UNDOC_ENUM_VAL = NO WARN_AS_ERROR = NO WARN_FORMAT = "$file:$line: $text" WARN_LINE_FORMAT = "at line $line of file $file" WARN_LOGFILE = INPUT = README.md \ include \ win INPUT_ENCODING = UTF-8 INPUT_FILE_ENCODING = FILE_PATTERNS = RECURSIVE = YES EXCLUDE = EXCLUDE_SYMLINKS = YES EXCLUDE_PATTERNS = EXCLUDE_SYMBOLS = EXAMPLE_PATH = EXAMPLE_PATTERNS = EXAMPLE_RECURSIVE = NO IMAGE_PATH = INPUT_FILTER = FILTER_PATTERNS = FILTER_SOURCE_FILES = NO FILTER_SOURCE_PATTERNS = USE_MDFILE_AS_MAINPAGE = README.md FORTRAN_COMMENT_AFTER = 72 SOURCE_BROWSER = NO INLINE_SOURCES = NO STRIP_CODE_COMMENTS = YES REFERENCED_BY_RELATION = NO REFERENCES_RELATION = NO REFERENCES_LINK_SOURCE = YES SOURCE_TOOLTIPS = YES USE_HTAGS = NO VERBATIM_HEADERS = YES ALPHABETICAL_INDEX = YES IGNORE_PREFIX = GENERATE_HTML = YES HTML_OUTPUT = html HTML_FILE_EXTENSION = .html HTML_HEADER = HTML_FOOTER = HTML_STYLESHEET = HTML_EXTRA_STYLESHEET = HTML_EXTRA_FILES = HTML_COLORSTYLE = AUTO_LIGHT HTML_COLORSTYLE_HUE = 220 HTML_COLORSTYLE_SAT = 100 HTML_COLORSTYLE_GAMMA = 80 HTML_DYNAMIC_MENUS = YES HTML_DYNAMIC_SECTIONS = NO HTML_CODE_FOLDING = YES HTML_COPY_CLIPBOARD = YES HTML_PROJECT_COOKIE = HTML_INDEX_NUM_ENTRIES = 100 GENERATE_DOCSET = NO DOCSET_FEEDNAME = "Doxygen generated documentation" DOCSET_FEEDURL = DOCSET_BUNDLE_ID = org.doxygen.Project DOCSET_PUBLISHER_ID = org.doxygen.Publisher DOCSET_PUBLISHER_NAME = Publisher GENERATE_HTMLHELP = NO CHM_FILE = HHC_LOCATION = GENERATE_CHI = NO CHM_INDEX_ENCODING = BINARY_TOC = NO TOC_EXPAND = NO SITEMAP_URL = GENERATE_QHP = NO QCH_FILE = QHP_NAMESPACE = org.doxygen.Project QHP_VIRTUAL_FOLDER = doc QHP_CUST_FILTER_NAME = QHP_CUST_FILTER_ATTRS = QHP_SECT_FILTER_ATTRS = QHG_LOCATION = GENERATE_ECLIPSEHELP = NO ECLIPSE_DOC_ID = org.doxygen.Project DISABLE_INDEX = NO GENERATE_TREEVIEW = NO FULL_SIDEBAR = NO ENUM_VALUES_PER_LINE = 4 TREEVIEW_WIDTH = 250 EXT_LINKS_IN_WINDOW = NO OBFUSCATE_EMAILS = YES HTML_FORMULA_FORMAT = png FORMULA_FONTSIZE = 10 FORMULA_MACROFILE = USE_MATHJAX = NO MATHJAX_VERSION = MathJax_2 MATHJAX_FORMAT = HTML-CSS MATHJAX_RELPATH = http://cdn.mathjax.org/mathjax/latest MATHJAX_EXTENSIONS = MATHJAX_CODEFILE = SEARCHENGINE = YES SERVER_BASED_SEARCH = NO EXTERNAL_SEARCH = NO SEARCHENGINE_URL = SEARCHDATA_FILE = searchdata.xml EXTERNAL_SEARCH_ID = EXTRA_SEARCH_MAPPINGS = GENERATE_LATEX = NO LATEX_OUTPUT = latex LATEX_CMD_NAME = latex MAKEINDEX_CMD_NAME = makeindex LATEX_MAKEINDEX_CMD = makeindex COMPACT_LATEX = NO PAPER_TYPE = a4 EXTRA_PACKAGES = LATEX_HEADER = LATEX_FOOTER = LATEX_EXTRA_STYLESHEET = LATEX_EXTRA_FILES = PDF_HYPERLINKS = YES USE_PDFLATEX = YES LATEX_BATCHMODE = NO LATEX_HIDE_INDICES = NO LATEX_BIB_STYLE = plain LATEX_EMOJI_DIRECTORY = GENERATE_RTF = NO RTF_OUTPUT = rtf COMPACT_RTF = NO RTF_HYPERLINKS = NO RTF_STYLESHEET_FILE = RTF_EXTENSIONS_FILE = RTF_EXTRA_FILES = GENERATE_MAN = NO MAN_OUTPUT = man MAN_EXTENSION = .3 MAN_SUBDIR = MAN_LINKS = NO GENERATE_XML = NO XML_OUTPUT = xml XML_PROGRAMLISTING = YES XML_NS_MEMB_FILE_SCOPE = NO GENERATE_DOCBOOK = NO DOCBOOK_OUTPUT = docbook GENERATE_AUTOGEN_DEF = NO GENERATE_SQLITE3 = NO SQLITE3_OUTPUT = sqlite3 SQLITE3_RECREATE_DB = YES GENERATE_PERLMOD = NO PERLMOD_LATEX = NO PERLMOD_PRETTY = YES PERLMOD_MAKEVAR_PREFIX = ENABLE_PREPROCESSING = YES MACRO_EXPANSION = YES EXPAND_ONLY_PREDEF = NO SEARCH_INCLUDES = YES INCLUDE_PATH = INCLUDE_FILE_PATTERNS = PREDEFINED = CoreExport=/**/ \ ATTR_NOT_NULL(...)=/**/ \ INSPIRCD_INTRUSIVE_LIST_NAME=intrusive_list EXPAND_AS_DEFINED = SKIP_FUNCTION_MACROS = YES TAGFILES = GENERATE_TAGFILE = ALLEXTERNALS = NO EXTERNAL_GROUPS = YES EXTERNAL_PAGES = YES HIDE_UNDOC_RELATIONS = YES HAVE_DOT = NO DOT_NUM_THREADS = 0 DOT_COMMON_ATTR = "fontname=Helvetica,fontsize=10" DOT_EDGE_ATTR = "labelfontname=Helvetica,labelfontsize=10" DOT_NODE_ATTR = "shape=box,height=0.2,width=0.4" DOT_FONTPATH = CLASS_GRAPH = YES COLLABORATION_GRAPH = YES GROUP_GRAPHS = YES UML_LOOK = NO UML_LIMIT_NUM_FIELDS = 10 DOT_UML_DETAILS = NO DOT_WRAP_THRESHOLD = 17 TEMPLATE_RELATIONS = NO INCLUDE_GRAPH = YES INCLUDED_BY_GRAPH = YES CALL_GRAPH = NO CALLER_GRAPH = NO GRAPHICAL_HIERARCHY = YES DIRECTORY_GRAPH = YES DIR_GRAPH_MAX_DEPTH = 1 DOT_IMAGE_FORMAT = png INTERACTIVE_SVG = NO DOT_PATH = DOTFILE_DIRS = DIA_PATH = DIAFILE_DIRS = PLANTUML_JAR_PATH = PLANTUML_CFG_FILE = PLANTUML_INCLUDE_PATH = DOT_GRAPH_MAX_NODES = 50 MAX_DOT_GRAPH_DEPTH = 0 DOT_MULTI_TARGETS = NO GENERATE_LEGEND = YES DOT_CLEANUP = YES MSCGEN_TOOL = MSCFILE_DIRS = inspircd-4.7.0/docs/LICENSE.txt000066400000000000000000000431001477160314700161200ustar00rootroot00000000000000 GNU GENERAL PUBLIC LICENSE Version 2, June 1991 Copyright (C) 1989, 1991 Free Software Foundation, Inc., Everyone is permitted to copy and distribute verbatim copies of this license document, but changing it is not allowed. Preamble The licenses for most software are designed to take away your freedom to share and change it. By contrast, the GNU General Public License is intended to guarantee your freedom to share and change free software--to make sure the software is free for all its users. This General Public License applies to most of the Free Software Foundation's software and to any other program whose authors commit to using it. (Some other Free Software Foundation software is covered by the GNU Lesser General Public License instead.) You can apply it to your programs, too. When we speak of free software, we are referring to freedom, not price. Our General Public Licenses are designed to make sure that you have the freedom to distribute copies of free software (and charge for this service if you wish), that you receive source code or can get it if you want it, that you can change the software or use pieces of it in new free programs; and that you know you can do these things. To protect your rights, we need to make restrictions that forbid anyone to deny you these rights or to ask you to surrender the rights. These restrictions translate to certain responsibilities for you if you distribute copies of the software, or if you modify it. For example, if you distribute copies of such a program, whether gratis or for a fee, you must give the recipients all the rights that you have. You must make sure that they, too, receive or can get the source code. And you must show them these terms so they know their rights. We protect your rights with two steps: (1) copyright the software, and (2) offer you this license which gives you legal permission to copy, distribute and/or modify the software. Also, for each author's protection and ours, we want to make certain that everyone understands that there is no warranty for this free software. If the software is modified by someone else and passed on, we want its recipients to know that what they have is not the original, so that any problems introduced by others will not reflect on the original authors' reputations. Finally, any free program is threatened constantly by software patents. We wish to avoid the danger that redistributors of a free program will individually obtain patent licenses, in effect making the program proprietary. To prevent this, we have made it clear that any patent must be licensed for everyone's free use or not licensed at all. The precise terms and conditions for copying, distribution and modification follow. GNU GENERAL PUBLIC LICENSE TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION 0. This License applies to any program or other work which contains a notice placed by the copyright holder saying it may be distributed under the terms of this General Public License. The "Program", below, refers to any such program or work, and a "work based on the Program" means either the Program or any derivative work under copyright law: that is to say, a work containing the Program or a portion of it, either verbatim or with modifications and/or translated into another language. (Hereinafter, translation is included without limitation in the term "modification".) Each licensee is addressed as "you". Activities other than copying, distribution and modification are not covered by this License; they are outside its scope. The act of running the Program is not restricted, and the output from the Program is covered only if its contents constitute a work based on the Program (independent of having been made by running the Program). Whether that is true depends on what the Program does. 1. You may copy and distribute verbatim copies of the Program's source code as you receive it, in any medium, provided that you conspicuously and appropriately publish on each copy an appropriate copyright notice and disclaimer of warranty; keep intact all the notices that refer to this License and to the absence of any warranty; and give any other recipients of the Program a copy of this License along with the Program. You may charge a fee for the physical act of transferring a copy, and you may at your option offer warranty protection in exchange for a fee. 2. You may modify your copy or copies of the Program or any portion of it, thus forming a work based on the Program, and copy and distribute such modifications or work under the terms of Section 1 above, provided that you also meet all of these conditions: a) You must cause the modified files to carry prominent notices stating that you changed the files and the date of any change. b) You must cause any work that you distribute or publish, that in whole or in part contains or is derived from the Program or any part thereof, to be licensed as a whole at no charge to all third parties under the terms of this License. c) If the modified program normally reads commands interactively when run, you must cause it, when started running for such interactive use in the most ordinary way, to print or display an announcement including an appropriate copyright notice and a notice that there is no warranty (or else, saying that you provide a warranty) and that users may redistribute the program under these conditions, and telling the user how to view a copy of this License. (Exception: if the Program itself is interactive but does not normally print such an announcement, your work based on the Program is not required to print an announcement.) These requirements apply to the modified work as a whole. If identifiable sections of that work are not derived from the Program, and can be reasonably considered independent and separate works in themselves, then this License, and its terms, do not apply to those sections when you distribute them as separate works. But when you distribute the same sections as part of a whole which is a work based on the Program, the distribution of the whole must be on the terms of this License, whose permissions for other licensees extend to the entire whole, and thus to each and every part regardless of who wrote it. Thus, it is not the intent of this section to claim rights or contest your rights to work written entirely by you; rather, the intent is to exercise the right to control the distribution of derivative or collective works based on the Program. In addition, mere aggregation of another work not based on the Program with the Program (or with a work based on the Program) on a volume of a storage or distribution medium does not bring the other work under the scope of this License. 3. You may copy and distribute the Program (or a work based on it, under Section 2) in object code or executable form under the terms of Sections 1 and 2 above provided that you also do one of the following: a) Accompany it with the complete corresponding machine-readable source code, which must be distributed under the terms of Sections 1 and 2 above on a medium customarily used for software interchange; or, b) Accompany it with a written offer, valid for at least three years, to give any third party, for a charge no more than your cost of physically performing source distribution, a complete machine-readable copy of the corresponding source code, to be distributed under the terms of Sections 1 and 2 above on a medium customarily used for software interchange; or, c) Accompany it with the information you received as to the offer to distribute corresponding source code. (This alternative is allowed only for noncommercial distribution and only if you received the program in object code or executable form with such an offer, in accord with Subsection b above.) The source code for a work means the preferred form of the work for making modifications to it. For an executable work, complete source code means all the source code for all modules it contains, plus any associated interface definition files, plus the scripts used to control compilation and installation of the executable. However, as a special exception, the source code distributed need not include anything that is normally distributed (in either source or binary form) with the major components (compiler, kernel, and so on) of the operating system on which the executable runs, unless that component itself accompanies the executable. If distribution of executable or object code is made by offering access to copy from a designated place, then offering equivalent access to copy the source code from the same place counts as distribution of the source code, even though third parties are not compelled to copy the source along with the object code. 4. You may not copy, modify, sublicense, or distribute the Program except as expressly provided under this License. Any attempt otherwise to copy, modify, sublicense or distribute the Program is void, and will automatically terminate your rights under this License. However, parties who have received copies, or rights, from you under this License will not have their licenses terminated so long as such parties remain in full compliance. 5. You are not required to accept this License, since you have not signed it. However, nothing else grants you permission to modify or distribute the Program or its derivative works. These actions are prohibited by law if you do not accept this License. Therefore, by modifying or distributing the Program (or any work based on the Program), you indicate your acceptance of this License to do so, and all its terms and conditions for copying, distributing or modifying the Program or works based on it. 6. Each time you redistribute the Program (or any work based on the Program), the recipient automatically receives a license from the original licensor to copy, distribute or modify the Program subject to these terms and conditions. You may not impose any further restrictions on the recipients' exercise of the rights granted herein. You are not responsible for enforcing compliance by third parties to this License. 7. If, as a consequence of a court judgment or allegation of patent infringement or for any other reason (not limited to patent issues), conditions are imposed on you (whether by court order, agreement or otherwise) that contradict the conditions of this License, they do not excuse you from the conditions of this License. If you cannot distribute so as to satisfy simultaneously your obligations under this License and any other pertinent obligations, then as a consequence you may not distribute the Program at all. For example, if a patent license would not permit royalty-free redistribution of the Program by all those who receive copies directly or indirectly through you, then the only way you could satisfy both it and this License would be to refrain entirely from distribution of the Program. If any portion of this section is held invalid or unenforceable under any particular circumstance, the balance of the section is intended to apply and the section as a whole is intended to apply in other circumstances. It is not the purpose of this section to induce you to infringe any patents or other property right claims or to contest validity of any such claims; this section has the sole purpose of protecting the integrity of the free software distribution system, which is implemented by public license practices. Many people have made generous contributions to the wide range of software distributed through that system in reliance on consistent application of that system; it is up to the author/donor to decide if he or she is willing to distribute software through any other system and a licensee cannot impose that choice. This section is intended to make thoroughly clear what is believed to be a consequence of the rest of this License. 8. If the distribution and/or use of the Program is restricted in certain countries either by patents or by copyrighted interfaces, the original copyright holder who places the Program under this License may add an explicit geographical distribution limitation excluding those countries, so that distribution is permitted only in or among countries not thus excluded. In such case, this License incorporates the limitation as if written in the body of this License. 9. The Free Software Foundation may publish revised and/or new versions of the General Public License from time to time. Such new versions will be similar in spirit to the present version, but may differ in detail to address new problems or concerns. Each version is given a distinguishing version number. If the Program specifies a version number of this License which applies to it and "any later version", you have the option of following the terms and conditions either of that version or of any later version published by the Free Software Foundation. If the Program does not specify a version number of this License, you may choose any version ever published by the Free Software Foundation. 10. If you wish to incorporate parts of the Program into other free programs whose distribution conditions are different, write to the author to ask for permission. For software which is copyrighted by the Free Software Foundation, write to the Free Software Foundation; we sometimes make exceptions for this. Our decision will be guided by the two goals of preserving the free status of all derivatives of our free software and of promoting the sharing and reuse of software generally. NO WARRANTY 11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION. 12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES. END OF TERMS AND CONDITIONS How to Apply These Terms to Your New Programs If you develop a new program, and you want it to be of the greatest possible use to the public, the best way to achieve this is to make it free software which everyone can redistribute and change under these terms. To do so, attach the following notices to the program. It is safest to attach them to the start of each source file to most effectively convey the exclusion of warranty; and each file should have at least the "copyright" line and a pointer to where the full notice is found. Copyright (C) This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program; if not, see . Also add information on how to contact you by electronic and paper mail. If the program is interactive, make it output a short notice like this when it starts in an interactive mode: Gnomovision version 69, Copyright (C) year name of author Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'. This is free software, and you are welcome to redistribute it under certain conditions; type `show c' for details. The hypothetical commands `show w' and `show c' should show the appropriate parts of the General Public License. Of course, the commands you use may be called something other than `show w' and `show c'; they could even be mouse-clicks or menu items--whatever suits your program. You should also get your employer (if you work as a programmer) or your school, if any, to sign a "copyright disclaimer" for the program, if necessary. Here is a sample; alter the names: Yoyodyne, Inc., hereby disclaims all copyright interest in the program `Gnomovision' (which makes passes at compilers) written by James Hacker. , 1 April 1989 Moe Ghoul, President of Vice This General Public License does not permit incorporating your program into proprietary programs. If your program is a subroutine library, you may consider it more useful to permit linking proprietary applications with the library. If this is what you want to do, use the GNU Lesser General Public License instead of this License. inspircd-4.7.0/docs/conf/000077500000000000000000000000001477160314700152245ustar00rootroot00000000000000inspircd-4.7.0/docs/conf/codepages/000077500000000000000000000000001477160314700171565ustar00rootroot00000000000000inspircd-4.7.0/docs/conf/codepages/ascii.example.conf000066400000000000000000000027641477160314700225600ustar00rootroot00000000000000# This file contains ASCII codepage rules for use with the codepage module. # - # 01234567899 # ABCDEFGHIJKLMNOPQRSTUVWXYZ # [\]^_` # abcdefghijklmnopqrstuvwxyz # {|} # a => A # b => B # c => C # d => D # e => E # f => F # g => G # h => H # i => I # j => J # k => K # l => L # m => M # n => N # o => O # p => P # q => Q # r => R # s => S # t => T # u => U # v => V # w => W # x => X # y => Y # z => Z inspircd-4.7.0/docs/conf/codepages/iso-8859-1.example.conf000066400000000000000000000035171477160314700230300ustar00rootroot00000000000000# This file contains ISO 8859-1 codepage rules for use with the codepage module. # У€УУ‚УƒУ„У…У†У‡УˆУ‰УŠУ‹УŒУУŽУУУ‘У’У“У”У•У– # У˜У™УšУ›УœУУžУŸУ УЁУЂУЃУЄУЅУІУЇУЈУЉУЊУЋУЌУ­УЎУЏУАУБУВУГУДУЕУЖ # УИУЙУКУЛУМУНУОУП # УŸ => S # У  => У€ # УЁ => У # УЂ => У‚ # УЃ => Уƒ # УЄ => У„ # УЅ => У… # УІ => У† # УЇ => У‡ # УЈ => Уˆ # УЉ => У‰ # УЊ => УŠ # УЋ => У‹ # УЌ => УŒ # У­ => У # УЎ => УŽ # УЏ => У # УА => У # УБ => У‘ # УВ => У’ # УГ => У“ # УД => У” # УЕ => У• # УЖ => У– # УИ => Ә # УЙ => У™ # УК => Уš # УЛ => У› # УМ => Уœ # УН => У # УО => Уž # Include the ASCII rules to avoid duplication. inspircd-4.7.0/docs/conf/codepages/iso-8859-2.example.conf000066400000000000000000000052511477160314700230260ustar00rootroot00000000000000# This file contains ISO 8859-2 codepage rules for use with the codepage module. # Ф„ # Х # ФНХš # Х ХžХЄХЙ # ХНХЛ # Ф… # Х‚ # ФОХ› # ХЁХŸХЅХК # ХОХМХ”УУ‚Ф‚У„ФЙФ†У‡ФŒУ‰Ф˜У‹ФšУУŽФŽФХƒХ‡У“У”ХУ– # Х˜ХЎУšХАУœУХЂУŸХ•УЁУЂФƒУЄФКФ‡УЇФУЉФ™УЋФ›У­УЎФФ‘Х„ХˆУГУДХ‘УЖ # Х™ХЏУКХБУМУНХЃ # Ф… => Ф„ # Х‚ => Х # ФО => ФН # Х› => Хš # ХЁ => Х  # ХŸ => Хž # ХЅ => ХЄ # ХК => ХЙ # ХО => ХН # ХМ => ХЛ # Х• => Х” # УЁ => У # УЂ => У‚ # Фƒ => Ф‚ # УЄ => У„ # ФК => ФЙ # Ф‡ => Ф† # УЇ => У‡ # Ф => ФŒ # УЉ => У‰ # Ф™ => Ԙ # УЋ => У‹ # Ф› => Фš # У­ => У # УЎ => УŽ # Ф => ФŽ # Ф‘ => Ф # Х„ => Хƒ # Хˆ => Х‡ # УГ => У“ # УД => У” # Х‘ => Х # УЖ => У– # Х™ => ՘ # ХЏ => ХЎ # УК => Уš # ХБ => ХА # УМ => Уœ # УН => У # ХЃ => ХЂ # Include the ASCII rules to avoid duplication. inspircd-4.7.0/docs/conf/codepages/rfc1459.example.conf000066400000000000000000000032351477160314700225570ustar00rootroot00000000000000# This file contains RFC 1459 codepage rules for use with the codepage module. # - # 01234567899 # ABCDEFGHIJKLMNOPQRSTUVWXYZ # [\]^_` # abcdefghijklmnopqrstuvwxyz # {|} # a => A # b => B # c => C # d => D # e => E # f => F # g => G # h => H # i => I # j => J # k => K # l => L # m => M # n => N # o => O # p => P # q => Q # r => R # s => S # t => T # u => U # v => V # w => W # x => X # y => Y # z => Z # { => [ # | => \ # } => ] # ~ => ^ inspircd-4.7.0/docs/conf/codepages/strict-rfc1459.example.conf000066400000000000000000000032021477160314700240570ustar00rootroot00000000000000# This file contains strict RFC 1459 codepage rules for use with the codepage module. # - # 01234567899 # ABCDEFGHIJKLMNOPQRSTUVWXYZ # [\]^_` # abcdefghijklmnopqrstuvwxyz # {|} # a => A # b => B # c => C # d => D # e => E # f => F # g => G # h => H # i => I # j => J # k => K # l => L # m => M # n => N # o => O # p => P # q => Q # r => R # s => S # t => T # u => U # v => V # w => W # x => X # y => Y # z => Z # { => [ # | => \ # } => ] inspircd-4.7.0/docs/conf/filter.example.conf000066400000000000000000000065411477160314700210200ustar00rootroot00000000000000# Configuration file for the filter module # The tags for this module are formatted as follows: # # # # Valid actions for 'action' are: # # warn This allows the line and sends out a notice to all opers # with +s. # # block This blocks the line, sends out a notice to all opers with # +s and informs the user that their message was blocked. # # silent This blocks the line only, and informs the user that their # message was blocked, but does not notify opers. # # none This action causes nothing to be done except logging. This # is the default action if none is specified. # # kill This disconnects the user, with the 'reason' parameter as # the kill reason. # # gline G-line the user for 'duration' length of time. Durations may # be specified using the notation 1y2w3d4h5m6s in a similar way to # other G-lines, omitting the duration or setting it to 0 makes # any G-lines set by this filter be permanent. # # zline Z-line the user for 'duration' length of time. Durations may # be specified using the notation 1y2w3d4h5m6s in a similar way to # other Z-lines, omitting the duration or setting it to 0 makes # any Z-lines set by this filter be permanent. # # shun Shun the user for 'duration' length of time. Durations may # be specified using the notation 1y2w3d4h5m6s in a similar way to # other X-lines, omitting the duration or setting it to 0 makes # any shuns set by this filter be permanent. # Requires the shun module to be loaded. # # You can add filters from IRC using the /FILTER command. If you do this, they # will be set globally to your entire network. # # Valid characters for 'flags' are one or more of: # # p: Block private and channel messages # n: Block private and channel notices # P: Block part messages # q: Block quit messages # o: Don't match against opers # r: Don't match against registered users # c: Strip color codes from text before trying to match # *: Represents all of the above flags except r # -: Does nothing, a no-op for when you do not want to specify any flags # Example filters: # # # # # An example regexp filter: # # # You may specify specific channels that are exempt from being filtered: # # # You can also exempt messages from being filtered if they are sent to # specific nicks. # Example that exempts all messages sent *to* NickServ: # # Note that messages *from* services are never subject to filtering; # tags are only for exempting messages sent *to* the # configured targets. inspircd-4.7.0/docs/conf/help.example.conf000066400000000000000000001446011477160314700204630ustar00rootroot00000000000000# Sample configuration file for the help module. # You can either copy this into your conf folder and set up the module to use it, # or you can customize the responses for your network and/or add more. # # The way the new help system works is simple. You use one or more helptopic tags. # # key is what the user is looking for (i.e. /HELP moo), title is the title, and # value is what they get back # (note that it can span multiple lines!). # -- w00t 16/dec/2006 # inspircd-4.7.0/docs/conf/inspircd.example.conf000066400000000000000000001506431477160314700213510ustar00rootroot00000000000000######################################################################## # # # ___ ___ ____ ____ _ # # |_ _|_ __ ___ _ __|_ _| _ \ / ___|__| | # # | || '_ \/ __| '_ \| || |_) | | / _` | # # | || | | \__ \ |_) | || _ <| |__| (_| | # # |___|_| |_|___/ .__/___|_| \_\\____\__,_| # # |_| # # ____ __ _ _ _ # # / ___|___ _ __ / _(_) __ _ _ _ _ __ __ _| |_(_) ___ _ __ # # | | / _ \| '_ \| |_| |/ _` | | | | '__/ _` | __| |/ _ \| '_ \ # # | |__| (_) | | | | _| | (_| | |_| | | | (_| | |_| | (_) | | | | # # \____\___/|_| |_|_| |_|\__, |\__,_|_| \__,_|\__|_|\___/|_| |_| # # |___/ # # # ##################################||#################################### #||# ##################################||#################################### # # # This is an example of the config file for InspIRCd. # # Change the options to suit your network. # # # # # # ____ _ _____ _ _ ____ _ _ _ # # | _ \ ___ __ _ __| | |_ _| |__ (_)___ | __ )(_) |_| | # # | |_) / _ \/ _` |/ _` | | | | '_ \| / __| | _ \| | __| | # # | _ < __/ (_| | (_| | | | | | | | \__ \ | |_) | | |_|_| # # |_| \_\___|\__,_|\__,_| |_| |_| |_|_|___/ |____/|_|\__(_) # # # # Lines prefixed with READ THIS BIT, as shown above, are IMPORTANT # # lines, and you REALLY SHOULD READ THEM. Yes, THIS MEANS YOU. Even # # if you've configured InspIRCd before, these probably indicate # # something new or different to this version and you SHOULD READ IT. # # # ######################################################################## #-#-#-#-#-#-#-#-#-# INCLUDE CONFIGURATION #-#-#-#-#-#-#-#-#-#-#-#-#-# # # # This optional tag allows you to include another config file # # allowing you to keep your configuration tidy. The configuration # # file you include will be treated as part of the configuration file # # which includes it, in simple terms the inclusion is transparent. # # # # All paths to config files are relative to the config directory. # # # # You may also include an executable file, in which case if you do so # # the output of the executable on the standard output will be added # # to your config at the point of the include tag. # # # # Syntax is as follows: # # # # # # # # # # Executable include example: # # # # #-#-#-#-#-#-#-#-#-#-#-# VARIABLE DEFINITIONS -#-#-#-#-#-#-#-#-#-#-#-# # # # You can define variables that will be substituted later in the # # configuration file. This can be useful to allow settings to be # # easily changed, or to parameterize a remote includes. # # # # Variables may be redefined and may reference other variables. # # Value expansion happens at the time the tag is read. # # # # See https://docs.inspircd.org/4/configuration/#define for a list of # # predefined config variables. # #-#-#-#-#-#-#-#-#-#-#-#- SERVER DESCRIPTION -#-#-#-#-#-#-#-#-#-#-#-#- # # # Here is where you enter the information about your server. # # # #-#-#-#-#-#-#-#-#-#-#-#- ADMIN INFORMATION -#-#-#-#-#-#-#-#-#-#-#-# # # # Configures the name and email of the server admin. # # # #-#-#-#-#-#-#-#-#-#-#-#- PORT CONFIGURATION -#-#-#-#-#-#-#-#-#-#-#- # # # Configure the port and address bindings here. # # # # TLS listener that binds on a TCP/IP endpoint: tag that you have defined. See the # docs page for the TLS module you are using for more details: # # GnuTLS: https://docs.inspircd.org/4/modules/ssl_gnutls#sslprofile # OpenSSL: https://docs.inspircd.org/4/modules/ssl_openssl#sslprofile # # You will need to load the ssl_openssl module for OpenSSL and ssl_gnutls # for GnuTLS. sslprofile="Clients" # defer: When this is non-zero, connections will not be handed over to # the daemon from the operating system before data is ready. # In Linux, the value indicates the time period we'll wait for a # connection to come up with data. Don't set it too low! # In BSD the value is ignored; only zero and non-zero is possible. # Windows ignores this parameter completely. # Note: This does not take effect on rehash. # To change it on a running bind, you'll have to comment it out, # rehash, comment it in and rehash again. defer="0" # free: When this is enabled the listener will be created regardless of # whether the interface that provides the bind address is available. This # is useful for if you are starting InspIRCd on boot when the server may # not have brought the network interfaces up yet. free="no"> # Plaintext listener that binds on a TCP/IP endpoint: # Listener that binds on a UNIX endpoint (not supported on Windows): # # Listener accepting WebSocket connections. # Requires the websocket module and SHA-1 hashing support (provided by the sha1 # module). # # You must define a custom tag which defines the TLS configuration # for this listener. See the docs page for the TLS module you are using for # more details. # # When linking servers, the OpenSSL and GnuTLS implementations are completely # link-compatible and can be used alongside each other on each end of the link # without any significant issues. #-#-#-#-#-#-#-#-#-#- CONNECTIONS CONFIGURATION -#-#-#-#-#-#-#-#-#-#-# # # # This is where you can configure which connections are allowed # # and denied access onto your server. The password is optional. # # You may have as many of these as you require. To allow/deny all # # connections, use a '*' or 0.0.0.0/0. # # # # -- It is important to note that connect tags are read from the -- # # TOP DOWN. This means that you should have more specific deny # # and allow tags at the top, progressively more general, followed # # by a (should you wish to have one). # # # # Connect blocks are searched twice for each user - once when the TCP # # connection is accepted, and once when the user completes their # # connection. Most of the information (hostname, ident response, # # password, TLS when using STARTTLS, etc) is only available during # # the second search. If you are trying to make a closed server you # # will probably need a connect block just for user connection. This # # can be done by using # # To enable IRCCloud on your network uncomment this: # # A connect class with set denies connections from the specified host/IP range. # A connect class with set allows c from the specified host/IP range. #hash="bcrypt" # password: Password to use for this block/user(s) password="secret" # maxchans: Maximum number of channels a user in this class # can be in at one time. maxchans="20" # timeout: How long the server will wait before disconnecting # a user if they do not do anything on connect. # (Note, this is a client-side thing, if the client does not # send /NICK, /USER or /PASS) timeout="20" # localmax: Maximum local connections per IP (or CIDR mask, see below). localmax="3" # globalmax: Maximum global (network-wide) connections per IP (or CIDR mask, see below). globalmax="3" # maxconnwarn: Enable warnings when localmax or globalmax are reached (defaults to yes) maxconnwarn="no" # resolvehostnames: If disabled, no DNS lookups will be performed on connecting users # in this class. This can save a lot of resources on very busy servers. resolvehostnames="yes" # useconnectban: Defines if users in this class should be exempt from connectban limits. # This setting only has effect when the connectban module is loaded. #useconnectban="yes" # useconnflood: Defines if users in this class should be exempt from connflood limits. # This setting only has effect when the connflood module is loaded. #useconnflood="yes" # usednsbl: Defines whether or not users in this class are subject to DNSBL. Default is yes. # This setting only has effect when the dnsbl module is loaded. #usednsbl="yes" # useident: Whether to try to look up the real username of users in this class using # the RFC 1413 identification protocol. # This setting only has effect when the ident module is loaded. useident="no" # usests: Whether a STS policy should be advertised to users in this class. # This setting only has effect when the ircv3_sts module is loaded. #usests="no" # webirc: Restricts usage of this class to the specified WebIRC gateway. # This setting only has effect when the gateway module is loaded. #webirc="name" # limit: How many users are allowed in this class limit="5000" # modes: The modes to set on users in this class when they connect to # the server. See https://docs.inspircd.org/4/user-modes/ for a list of # user modes. The example below sets user modes c (deaf_commonchans) # and x (cloak) which require the commonchans and cloak modules. # This setting only has effect when the conn_umodes module is loaded. modes="+cx" # requireident: Require that users of this block have a valid ident response. # Requires the ident module to be loaded. #requireident="yes" # requiressl: Require that users of this block use a TLS connection. # This can also be set to "trusted", as to only accept client certificates # issued by a certificate authority that you can configure in the # settings of the TLS module that you're using. # Requires the sslinfo module to be loaded. #requiressl="yes" # requireaccount: Require that users of this block have authenticated to a # user account. # NOTE: You must complete the signon prior to full connection. Currently, # this is only possible by using SASL authentication; passforward # and PRIVMSG NickServ happen after your final connect block has been found. # You can also set this to "nick" to require that users are logged into their # current nickname. # Requires the account module to be loaded. #requireaccount="yes" # Alternate MOTD file for this connect class. The contents of this file are # specified using <files secretmotd="filename"> or <execfiles ...> # # NOTE: the following escape sequences for IRC formatting characters can be # used in your MOTD: # Bold: \b # Color: \c<fg>[,<bg>] # Color (alt): \c{<fg>[,<bg>]} # Hex Color: \h<fg>[,<bg>] # Italic: \i # Monospace: \m (not widely supported) # Reset: \x # Reverse: \r # Strikethrough: \s (not widely supported) # Underline: \u # # When using the alternate color syntax the following colors can be used: # black, blue, brown, cyan, default, green, grey, light blue, # light cyan, light green, light grey, magenta orange, pink, # red, white, yellow. # # See https://defs.ircdocs.horse/info/formatting.html for more information # on client support for formatting characters. motd="secretmotd" # port: What port range this user is allowed to connect on. (optional) # The ports MUST be set to listen in the bind blocks above. port="6697,9999"> <connect # name: Name to use for this connect block. Mainly used for # connect class inheriting. name="main" # allow: The IP address or hostname of clients that can use this # class. You can specify either an exact match, a glob match, or # a CIDR range here. allow="*" # maxchans: Maximum number of channels a user in this class # can be in at one time. maxchans="20" # timeout: How long the server will wait before disconnecting # a user if they do not do anything on connect. # (Note, this is a client-side thing, if the client does not # send /NICK, /USER or /PASS) timeout="20" # pingfreq: How often the server tries to ping connecting clients. pingfreq="2m" # hardsendq: maximum amount of data allowed in a client's send queue # before they are dropped. Keep this value higher than the length of # your network's /LIST or /WHO output, or you will have lots of # disconnects from sendq overruns! # Setting this to "1M" is equivalent to "1048576", "8K" is 8192, etc. hardsendq="1M" # softsendq: amount of data in a client's send queue before the server # begins delaying their commands in order to allow the sendq to drain softsendq="10240" # recvq: amount of data allowed in a client's queue before they are dropped. # Entering "10K" is equivalent to "10240", see above. recvq="10K" # threshold: This specifies the amount of command penalty a user is allowed to have # before being quit or fakelagged due to flood. Normal commands have a penalty of 1, # ones such as /OPER have penalties up to 10. # # If you are not using fakelag, this should be at least 20 to avoid excess flood kills # from processing some commands. threshold="10" # commandrate: This specifies the maximum rate that commands can be processed. # If commands are sent more rapidly, the user's penalty will increase and they will # either be fakelagged or killed when they reach the threshold # # Units are millicommands per second, so 1000 means one line per second. commandrate="1000" # fakelag: Use fakelag instead of killing users for excessive flood # # Fake lag stops command processing for a user when a flood is detected rather than # immediately killing them; their commands are held in the recvq and processed later # as the user's command penalty drops. Note that if this is enabled, flooders will # quit with "RecvQ exceeded" rather than "Excess Flood". fakelag="yes" # localmax: Maximum local connections per IP. localmax="3" # globalmax: Maximum global (network-wide) connections per IP. globalmax="3" # resolvehostnames: If disabled, no DNS lookups will be performed on connecting users # in this class. This can save a lot of resources on very busy servers. resolvehostnames="yes" # useident: Whether to try to look up the real username of users in this class using # the RFC 1413 identification protocol. # This setting only has effect when the ident module is loaded. useident="no" # usests: Whether a STS policy should be advertised to users in this class. # This setting only has effect when the ircv3_sts module is loaded. #usests="no" # limit: How many users are allowed in this class limit="5000" # modes: The modes to set on users in this class when they connect to # the server. See https://docs.inspircd.org/4/user-modes/ for a list of # user modes. The example below sets user modes c (deaf_commonchans) # and x (cloak) which require the commonchans and cloak modules. # This setting only has effect when the conn_umodes module is loaded. modes="+cx"> #-#-#-#-#-#-#-#-#-#-#-#- CIDR CONFIGURATION -#-#-#-#-#-#-#-#-#-#-#- # # # CIDR configuration allows detection of clones and applying of # # throttle limits across a CIDR range. (A CIDR range is a group of # # IPs, for example, the CIDR range 192.168.1.0-192.168.1.255 may be # # represented as 192.168.1.0/24). This means that abuse across an ISP # # is detected and curtailed much easier. Here is a good chart that # # shows how many IPs the different CIDRs correspond to: # # https://en.wikipedia.org/wiki/IPv4_subnetting_reference # # https://en.wikipedia.org/wiki/IPv6_subnetting_reference # # # <cidr # ipv4clone: specifies how many bits of an IP address should be # looked at for clones. The default only looks for clones on a # single IP address of a user. You do not want to set this # extremely low. (Values are 0-32). ipv4clone="32" # ipv6clone: specifies how many bits of an IP address should be # looked at for clones. The default only looks for clones on a # single IP address of a user. You do not want to set this # extremely low. (Values are 0-128). ipv6clone="128"> # This file has all the information about oper classes, types and o:lines. # You *MUST* edit it. #<include file="&dir.example;/opers.example.conf"> #-#-#-#-#-#-#-#-#-#- MISCELLANEOUS CONFIGURATION -#-#-#-#-#-#-#-#-#-# # # # Files block - contains files whose contents are used by the ircd # # motd - displayed on connect and when a user executes /MOTD # Modules can also define their own files <files motd="&dir.example;/motd.example.txt"> # Example of an executable file include. Note this will be read on rehash, # not when the command is run. #<execfiles motd="wget -O - https://www.example.com/motd.txt"> #-#-#-#-#-#-#-#-#-#-#-#-#-#-# DNS SERVER -#-#-#-#-#-#-#-#-#-#-#-#-#-#-# # If these values are not defined, InspIRCd uses the default DNS resolver # of your system. <dns # server: DNS server to use to attempt to resolve IP's to hostnames. # in most cases, you won't need to change this, as inspircd will # automatically detect the nameserver depending on /etc/resolv.conf # (or, on Windows, your set nameservers in the registry.) # Note that this must be an IP address and not a hostname, because # there is no resolver to resolve the name until this is defined! # # server="127.0.0.1" # timeout: time to wait to try to resolve DNS/hostname. timeout="5"> # An example of using an IPv6 nameserver #<dns server="::1" timeout="5"> #-#-#-#-#-#-#-#-#-#-#-#-#-#-# PID FILE -#-#-#-#-#-#-#-#-#-#-#-#-#-#-# # # # Define the path to the PID file here. The PID file can be used to # # rehash the ircd from the shell or to terminate the ircd from the # # shell using shell scripts, perl scripts, etc... and to monitor the # # ircd's state via cron jobs. If this is a relative path, it will be # # relative to the runtime directory, and if it is not defined, the # # default of 'inspircd.pid' is used. # # # #<pid file="inspircd.pid"> #-#-#-#-#-#-#-#-#-#-#-#-#- LIST MODE LIMITS #-#-#-#-#-#-#-#-#-#-#-#-#-# # # # The <maxlist> tag is used customise the maximum number of each list # # mode that can be set on a channel. # # The tags are read from top to bottom and the list mode limit from # # the first tag found which matches the channel name and mode type is # # applied to that channel. # # It is advisable to put an entry with the channel as '*' at the # # bottom of the list. If none are specified or no maxlist tag is # # matched, the banlist size defaults to 100 entries. # # # # Allows #largechan to have up to 200 ban entries. #<maxlist mode="ban" chan="#largechan" limit="200"> # Allows #largechan to have up to 200 ban exception entries. #<maxlist mode="e" chan="#largechan" limit="200"> # Allows all channels and list modes not previously matched to have # up to 100 entries. <maxlist chan="*" limit="100"> #-#-#-#-#-#-#-#-#-#-#-#-#- SERVER OPTIONS -#-#-#-#-#-#-#-#-#-#-#-#-# # # # Settings to define which features are usable on your server. # # # <options # prefixquit: What (if anything) users' quit messages # should be prefixed with. prefixquit="Quit: " # suffixquit: What (if anything) users' quit messages # should be suffixed with. suffixquit="" # prefixpart: What (if anything) users' part messages # should be prefixed with. prefixpart="&quot;" # suffixpart: What (if anything) users' part message # should be suffixed with. suffixpart="&quot;" # fixedquit: Set all users' quit messages to this value. #fixedquit="" # fixedpart: Set all users' part messages in all channels # to this value. #fixedpart="" # syntaxhints: If enabled, if a user fails to send the correct parameters # for a command, the ircd will give back some help text of what # the correct parameters are. syntaxhints="no" # cyclehostsfromuser: If enabled, the source of the mode change for # cyclehosts will be the user who cycled. This can look nicer, but # triggers anti-takeover mechanisms of some obsolete bots. cyclehostsfromuser="no" # announcets: If set to yes, when the timestamp on a channel changes, all users # in the channel will be sent a NOTICE about it. announcets="yes" # allowmismatch: Setting this option to yes will allow servers to link even # if they don't have the same "optionally common" modules loaded. Setting this to # yes may introduce some desyncs and unwanted behaviour. allowmismatch="no" # defaultbind: Sets the default for <bind> tags without an address. Choices are # ipv4 or ipv6; if not specified, IPv6 will be used if your system has support, # falling back to IPv4 otherwise. defaultbind="auto" # maskinlist: If enabled then channels will show the nick!user@host of a list # mode setter in the mode list instead of just the nick of the list mode setter. maskinlist="yes" # maskintopic: If enabled then channels will show the nick!user@host of the topic # setter in the topic instead of just the nick of the topic setter. maskintopic="yes" # pingwarning: If a server does not respond to a ping within this period, # it will send a notice to opers with snomask +l informing that the server # is about to ping timeout. pingwarning="15" # serverpingfreq: How often pings are sent between servers. serverpingfreq="1m" # splitwhois: Whether to split private/secret channels from normal channels # in WHOIS responses. Possible values for this are: # 'no' - list all channels together in the WHOIS response regardless of type. # 'split' - split private/secret channels to a separate WHOIS response numeric. # 'splitmsg' - the same as split but also send a message explaining the split. splitwhois="no" # defaultmodes: The modes to set on a channel when it is created. See # https://docs.inspircd.org/4/channel-modes/ for a list of channel # modes. If a prefix mode is included in this option it will be set on # the user that created the channel. The example below sets channel # modes n (noextmsg) and t (topiclock) and grants channel prefix mode # o (op) to the channel creator. defaultmodes="not" # xlinemessage: This is the text that is sent to a user when they are # banned from the server. xlinemessage="You're banned! Email irc@&networkDomain; with the ERROR line below for help." # xlinequit: The quit message to show to opers and affected users when # a user is [KGZ]-lined. The variables you can use in this are: # # %created% - The date/time at which the X-line was created. # %duration% - The duration of the X-line. # %duration.long% - The long duration of the X-line. # %expiry% - The date/time at which the X-line expires. # %fulltype% - The type of X-line which was matched, suffixed with # "-lined" if its name is one or two characters. # %reason% - The reason the X-line was added. # %remaining% - The duration remaining on the X-line. # %remaining.long% - The long duration remaining on the X-line. # %setter% - The name of the X-line setter. # %type% - The type of X-line which was matched. xlinequit="%fulltype%: %reason%" # modesinlist: Whether to show the current channel modes in the /LIST # output. Can be set to any one of: # - yes Show the current channel modes to all users. # - opers Show the current channel modes to server operators with the # channels/auspex privilege. This is the default. # - no Do not show the current channel modes in /LIST. modesinlist="opers" # extbanformat: The method to use for normalising extbans. Can be set # to one of: # - any Do not perform any extban normalisation. # - name Normalise extbans to use their name. # - letter Normalise extbans to use their letter. This is useful for # if you need to keep compatibility with v3. # Defaults to "any" if not set. extbanformat="name" # exemptchanops: Allows users with with a status mode to be exempt # from various channel restrictions. Possible restrictions are: # - anticaps Channel mode +B - blocks messages with too many capital # letters (requires the anticaps module). # - auditorium-see Permission required to see the full user list of # a +u channel (requires the auditorium module). # - auditorium-vis Permission required to be visible in a +u channel # (requires the auditorium module). # - blockcolor Channel mode +c - blocks messages with formatting codes # (requires the blockcolor module). # - delaymsg Channel mode +d - blocks sending messages until specified # seconds have passed since user join # - filter Channel mode +g - blocks messages containing the given # glob mask (requires the chanfilter module). # - flood Channel mode +f - kicks (and bans) on text flood of a # specified rate (requires the messageflood module). # - nickflood Channel mode +F - blocks nick changes after a specified # rate (requires the nickflood module). # - noctcp Channel mode +C - blocks any CTCPs to the channel # (requires the noctcp module). # - nonick Channel mode +N - prevents users on the channel from # changing nicks (requires the nonicks module). # - nonotice Channel mode +T - blocks /NOTICEs to the channel # (requires the nonotice module). # - opmoderated Channel mode +U - hides the messages of unprivileged users # from other unprivileged users (requires the opmoderated module). # - regmoderated Channel mode +M - blocks unregistered users from # speaking (requires the account module). # - repeat Channel mode +E - allows blocking of similar messages # (requires the repeat module). # - stripcolor Channel mode +S - strips formatting codes from # messages (requires the stripcolor module). # - topiclock Channel mode +t - limits changing the topic to (half)ops # You can also configure this on a per-channel basis with a channel mode and # even negate the configured exemptions below. # See exemptchanops in modules.example.conf for more details. exemptchanops="filter:o nickflood:o nonick:v regmoderated:o" # invitebypassmodes: This allows /INVITE to bypass other channel modes. # (Such as +k, +j, +l, etc.) invitebypassmodes="yes" # nosnoticestack: This prevents snotices from 'stacking' and giving you # the message saying '(last message repeated X times)'. Defaults to no. nosnoticestack="no"> #-#-#-#-#-#-#-#-#-#-#-# PERFORMANCE CONFIGURATION #-#-#-#-#-#-#-#-#-#-# # # <performance # netbuffersize: Size of the buffer used to receive data from clients. # The ircd may only read this amount of text in 1 go at any time. netbuffersize="10240" # somaxconn: The maximum number of connections that may be waiting # in the accept queue. This is *NOT* the total maximum number of # connections per server. Some systems may only allow this to be up # to 5, while others (such as Linux and *BSD) default to 128. # Setting this above the limit imposed by your OS can have undesired # effects. somaxconn="128" # softlimit: This optional feature allows a defined softlimit for # connections. If defined, it sets a soft max connections value. softlimit="12800" # clonesonconnect: If this is set to no, we won't check for clones # on initial connection, but only after the DNS check is done. # This can be useful where your main class is more restrictive # than some other class a user can be assigned after DNS lookup is complete. # Turning this option off will make the server spend more time on users we may # potentially not want. Normally this should be negligible, though. # Default value is yes clonesonconnect="yes" # timeskipwarn: The time period that a server clock can jump by before # operators will be warned that the server is having performance issues. timeskipwarn="2s" # quietbursts: When syncing or splitting from a network, a server # can generate a lot of connect and quit messages to opers with # +C and +Q snomasks. Setting this to yes squelches those messages, # which makes it easier for opers, but degrades the functionality of # bots like BOPM during netsplits. quietbursts="yes"> #-#-#-#-#-#-#-#-#-#-#-# SECURITY CONFIGURATION #-#-#-#-#-#-#-#-#-#-#-# # # <security # announceinvites: This option controls which members of the channel # receive an announcement when someone is INVITEd. Available values: # 'none' - don't send invite announcements # 'all' - send invite announcements to all members # 'ops' - send invite announcements to ops and higher ranked users # 'dynamic' - send invite announcements to halfops (if available) and # higher ranked users. This is the recommended setting. announceinvites="dynamic" # hideservices: If this value is set to yes, services servers will # be hidden from non-opers in /LINKS and /MAP. hideservices="no" # flatlinks: If this value is set to yes, /MAP and /LINKS will # be flattened when shown to non-opers. flatlinks="no" # hideserver: When defined, the given text will be used in place # of the server name in public messages. As with <server:name> this # does not need to resolve but does need to be a valid hostname. # # NOTE: enabling this will cause users' idle times to only be shown # when a remote whois (/WHOIS <nick> <nick>) is used. #hideserver="irc.&networkDomain;" # publicxlinequit: The quit message to show to unprivileged users when # a user is [KGZ]-lined. The variables you can use in this are: # # %created% - The date/time at which the X-line was created. # %duration% - The duration of the X-line. # %duration.long% - The long duration of the X-line. # %expiry% - The date/time at which the X-line expires. # %fulltype% - The type of X-line which was matched, suffixed with # "-lined" if its name is one or two characters. # %reason% - The reason the X-line was added. # %remaining% - The duration remaining on the X-line. # %remaining.long% - The long duration remaining on the X-line. # %setter% - The name of the X-line setter. # %type% - The type of X-line which was matched. #publicxlinequit="%fulltype%" # hidekills: If defined, replaces who executed a /KILL with a custom string. hidekills="" # hideservicekills: Hide kills from clients of services servers from server notices. hideservicekills="yes" # hidesplits: If enabled, non-opers will not be able to see which # servers split in a netsplit, they will only be able to see that one # occurred (If their client has netsplit detection). hidesplits="no" # maxtargets: Maximum number of targets per command. # (Commands like /NOTICE, /PRIVMSG, /KICK, etc) maxtargets="20" # customversion: A custom message to be displayed in the comments field # of the VERSION command response. This does not hide the InspIRCd version. customversion="" # runasuser: If this is set, InspIRCd will attempt to switch # to run as this user, which allows binding of ports under 1024. # You should NOT set this unless you are starting as root. # NOT SUPPORTED/NEEDED UNDER WINDOWS. #runasuser="" # runasgroup: If this is set, InspIRCd will attempt to switch # to run as this group, which allows binding of ports under 1024. # You should NOT set this unless you are starting as root. # NOT SUPPORTED/NEEDED UNDER WINDOWS. #runasgroup="" # restrictbannedusers: If this is set to yes, InspIRCd will not allow users # banned on a channel to change nickname or message channels they are # banned on. This can also be set to silent to restrict the user but not # notify them. restrictbannedusers="yes" # genericoper: Setting this value to yes makes all opers on this server # appear as 'is a server operator' in their WHOIS, regardless of their # oper type, however oper types are still used internally. This only # affects the display in WHOIS. genericoper="no" # userstats: /STATS commands that users can run (opers can run all). userstats="Pu"> #-#-#-#-#-#-#-#-#-#-#-#-# LIMITS CONFIGURATION #-#-#-#-#-#-#-#-#-#-#-# # # # This configuration tag defines the maximum sizes of various types # # on IRC, such as the maximum length of a channel name, and the # # maximum length of a channel. These values should match network-wide # # otherwise issues will occur. # # # # The highest safe value you can set any of these options to is 500, # # but it is recommended that you keep them somewhat # # near their defaults (or lower). # <limits # maxaway: Maximum length of an away message. maxaway="200" # maxchan: Maximum length of a channel name. maxchan="60" # maxhost: Maximum length of a hostname. maxhost="64" # maxuser: Maximum length of a username. maxuser="10" # maxkey: Maximum length of a channel key. maxkey="30" # maxkick: Maximum length of a kick message. maxkick="300" # maxmodes: Maximum number of mode changes per line. maxmodes="20" # maxnick: Maximum length of a nickname. maxnick="30" # maxquit: Maximum length of a quit message. maxquit="300" # maxreal: Maximum length of a real name. maxreal="130" # maxtopic: Maximum length of a channel topic. maxtopic="330"> #-#-#-#-#-#-#-#-#-#-#-#-# PATHS CONFIGURATION #-#-#-#-#-#-#-#-#-#-#-#-# # # # This configuration tag defines the location that InspIRCd stores # # various types of files such as configuration files, log files and # # modules. You will probably not need to change these from the values # # set when InspIRCd was built unless you are using a binary package # # where you do not have the ability to set build time configuration. # #<path configdir="conf" datadir="data" logdir="logs" moduledir="modules"> #-#-#-#-#-#-#-#-#-#-#-# LOGGING CONFIGURATION #-#-#-#-#-#-#-#-#-#-#-#-# # # # The <log> tag allows you to define a list of targets to write log # # messages to. # # # # method - The method to use when logging. This can be set to "file" # # to log to a file, "stderr" to log to the standard error # # stream, or "stdout" to log to the standard output stream. # # You can also set it to a log method provided by a module. # # # # level - The level of messages to write to this logger. Can be set # # to "error", "warning", "normal", or "debug". # # # # type - A space-delimited list of log types to write to this logger. # # See https://docs.inspircd.org/4/configuration/#log for a # # full list of log types. You can also use * to include every # # log type and then -TYPE to exclude specific unwanted types. # # # # target - If the method is set to "file" then the name of the file # # to write log messages to. # <log method="file" level="normal" type="* -USERINPUT -USEROUTPUT" target="inspircd.log"> #<log method="stderr" # level="normal" # type="* -USERINPUT -USEROUTPUT"> #<log method="stdout" # level="normal" # type="* -USERINPUT -USEROUTPUT"> #-#-#-#-#-#-#-#-#-#-#-#-#- WHOWAS OPTIONS -#-#-#-#-#-#-#-#-#-#-#-#-# # # # This tag lets you define the behaviour of the /WHOWAS command of # # your server. # # # <whowas # groupsize: Maximum entries per nick shown when performing # a /WHOWAS <nick>. Defaults to 10. groupsize="10" # maxgroups: Maximum number of nickgroups that can be added to # the list so that /WHOWAS does not use a lot of resources on # large networks. Defaults to 10000. maxgroups="10000" # maxkeep: Maximum time a nick is kept in the whowas list # before being pruned. Time may be specified in seconds, # or in the following format: 1y2w3d4h5m6s. Minimum is # 1 hour. Defaults to 7 days. maxkeep="7d" # nickupdate: Whether to update the WHOWAS database on nick # change as well as quit. This can significantly increase the # memory usage of your IRC server so it is not recommended # for large networks. Defaults to yes. nickupdate="yes"> #-#-#-#-#-#-#-#-#-#-#-#-#-#- BAN OPTIONS -#-#-#-#-#-#-#-#-#-#-#-#-#-# # # # The ban tags define nick masks, host masks and ip ranges which are # # banned from your server. All details in these tags are local to # # Your server. # # # <badip # ipmask: IP range to ban. Wildcards and CIDR can be used. ipmask="192.0.2.69" # reason: Reason to display when user is disconnected. reason="No porn here thanks."> <badnick # nick: Nick to disallow. Wildcards are supported. nick="Tr0ll123" # reason: Reason to display on /NICK. reason="Don't use this nick."> <badhost # host: username@hostname to ban. # Wildcards and CIDR (if you specify an IP) can be used. host="*@banneduser.example.net" # reason: Reason to display when user is disconnected reason="Evading Bans"> <badhost host="root@*" reason="Don't IRC as root!"> <badhost host="*@198.51.100.0/24" reason="This subnet is bad."> # exception: Hosts that are exempt from [KGZ]-lines. <exception # host: username@hostname to exempt. # Wildcards and CIDR (if you specify an IP) can be used. host="*@serverop.example.com" # reason: Reason for exception. Only shown in /STATS e. reason="Oper's hostname"> #-#-#-#-#-#-#-#-#-#-#- INSANE BAN OPTIONS -#-#-#-#-#-#-#-#-#-#-#-#-#-# # # # This optional tag allows you to specify how wide a G-line, E-line, # # K-line, Z-line or Q-line can be before it is forbidden from being # # set. By setting hostmasks="yes", you can allow all G-, K-, E-lines, # # no matter how many users the ban would cover. This is not # # recommended! By setting ipmasks="yes", you can allow all Z-lines, # # no matter how many users these cover too. Needless to say we # # don't recommend you do this, or, set nickmasks="yes", which will # # allow any Q-line. # # # <insane # hostmasks: Allow bans with insane hostmasks. (over-reaching bans) hostmasks="no" # ipmasks: Allow bans with insane ipmasks. (over-reaching bans) ipmasks="no" # nickmasks: Allow bans with insane nickmasks. (over-reaching bans) nickmasks="no" # trigger: What percentage of users on the network to trigger # specifying an insane ban as. The default is 95.5%, which means # if you have a 1000 user network, a ban will not be allowed if it # will be banning 955 or more users. trigger="95.5"> #-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-# MODULES #-#-#-#-#-#-#-#-#-#-#-#-#-#-# # ____ _ _____ _ _ ____ _ _ _ # # | _ \ ___ __ _ __| | |_ _| |__ (_)___ | __ )(_) |_| | # # | |_) / _ \/ _` |/ _` | | | | '_ \| / __| | _ \| | __| | # # | _ < __/ (_| | (_| | | | | | | | \__ \ | |_) | | |_|_| # # |_| \_\___|\__,_|\__,_| |_| |_| |_|_|___/ |____/|_|\__(_) # # # # Well done, you've reached the end of the basic configuration, your # # ircd should now start if you want to try it out! (./inspircd start) # # # # We now suggest you read and edit modules.conf, as modules are what # # provide almost all the features of InspIRCd. :) # # # # The default does nothing -- we include it for simplicity for you. # #<include file="&dir.example;/modules.example.conf"> #-#-#-#-#-#-#-#-#-#-#-# SERVICES CONFIGURATION #-#-#-#-#-#-#-#-#-#-#-# # # # If you use services you will probably want to include one of the # # following files which set up aliases, nick reservations and filter # # exemptions for services pseudoclients: # # # Anope users should uncomment this: #<include file="&dir.example;/services/anope.example.conf"> # # Atheme users should uncomment this: #<include file="&dir.example;/services/atheme.example.conf"> # # Users of other services should uncomment this: #<include file="&dir.example;/services/generic.example.conf"> ######################################################################### # # # - InspIRCd Development Team - # # https://www.inspircd.org # # # ######################################################################### ���������������������������������������������������������������������������������������������inspircd-4.7.0/docs/conf/links.example.conf���������������������������������������������������������0000664�0000000�0000000�00000014520�14771603147�0020647�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������#-#-#-#-#-#-#-#-#-#-#-#- PORT CONFIGURATION -#-#-#-#-#-#-#-#-#-#-#- # # # Configure the port and address bindings for linking here. # # # # Refer to the port configuration section in inspircd.example.conf # # for more information about the available options. # # # # TLS listener that binds on a TCP/IP endpoint: <bind address="1.2.3.4" port="7005" type="servers" sslprofile="Servers"> # Plaintext listener that binds on a TCP/IP endpoint: <bind address="" port="7000,7001" type="servers"> #-#-#-#-#-#-#-#-#-#-#- SERVER LINK CONFIGURATION -#-#-#-#-#-#-#-#-#-# # # # Defines which servers can link to this one, and which servers this # # server may create outbound links to. # # # # ____ _ _____ _ _ ____ _ _ _ # # | _ \ ___ __ _ __| | |_ _| |__ (_)___ | __ )(_) |_| | # # | |_) / _ \/ _` |/ _` | | | | '_ \| / __| | _ \| | __| | # # | _ < __/ (_| | (_| | | | | | | | \__ \ | |_) | | |_|_| # # |_| \_\___|\__,_|\__,_| |_| |_| |_|_|___/ |____/|_|\__(_) # # # # If you want to link servers to InspIRCd you must load the # # spanningtree module! If you do not load this module, server ports # # will NOT work! # # # <link # name: The name of the remote server. This must match # the <server:name> value of the remote server. name="hub.example.org" # ipaddr: The IP address of the remote server. # Can also be a hostname, but hostname must resolve. ipaddr="penguin.example.org" # port: The port to connect to the server on. # It must be bound as a server port on the other server. port="7000" # allowmask: Range of IP addresses to allow for this link. # Can be a CIDR (see example). allowmask="203.0.113.0/24 127.0.0.0/8 2001:db8::/32" # timeout: If defined, this option defines how long the server # will wait to consider the connect attempt failed and try the # failover (see above). timeout="5m" # sslprofile: If defined, this states the TLS profile that will be used # when making an outbound connection to the server. See the docs page for # the TLS module you are using for more details: # # GnuTLS: https://docs.inspircd.org/4/modules/ssl_gnutls#sslprofile # OpenSSL: https://docs.inspircd.org/4/modules/ssl_openssl#sslprofile # # You will need to load the ssl_openssl module for OpenSSL and ssl_gnutls # for GnuTLS. The server port that you connect to must be capable of # accepting this type of connection. sslprofile="Servers" # fingerprint: If defined, this option will force servers to be # authenticated using TLS certificate fingerprints. See # https://docs.inspircd.org/4/modules/spanningtree for more information. # This will require a TLS link for both inbound and outbound connections. #fingerprint="" # bind: Local IP address to bind to. bind="1.2.3.4" # statshidden: Defines if IP is shown to opers when # /STATS c is invoked. statshidden="no" # hidden: If this is set to yes, this server and its "child" # servers will not be shown when users do a /MAP or /LINKS. hidden="no" # passwords: The passwords we send and receive. # The remote server will have these passwords reversed. # Passwords that contain a space character or begin with # a colon (:) are invalid and may not be used. sendpass="outgoing!password" recvpass="incoming!password"> # A duplicate of the first link block without comments, # if you like copying & pasting. <link name="hub.example.org" ipaddr="penguin.example.org" port="7000" allowmask="203.0.113.0/24 127.0.0.0/8 2001:db8::/32" timeout="5m" sslprofile="Servers" bind="1.2.3.4" statshidden="no" hidden="no" sendpass="outgoing!password" recvpass="incoming!password"> # Link block for services. Options are the same as for the first # link block (depending on what your services package supports). <link name="services.example.com" ipaddr="localhost" port="7000" allowmask="127.0.0.0/8" sendpass="penguins" recvpass="polarbears"> # Simple autoconnect block. This enables automatic connections to a server. # Recommended setup is to have leaves connect to the hub, and have no # automatic connections started by the hub. <autoconnect period="10m" server="hub.example.org"> # Failover autoconnect block. If you have multiple hubs, or want your network # to automatically link even if the hub is down, you can specify multiple # space separated servers to autoconnect; they will be tried in a round # robin fashion until one succeeds. Period defines the time for restarting # a single loop. <autoconnect period="2m" server="hub.us.example.org hub.eu.example.org leaf.eu.example.org"> #-#-#-#-#-#-#-#-#-#-#-# SERVICES CONFIGURATION #-#-#-#-#-#-#-#-#-#-#-#-# # This tag defines a services server. A services server has special # # permissions, and should be used with caution. This should be used for # # the server that has ChanServ, NickServ, etc on it not a user server. # # # # The 'silent' value, if set to yes, indicates that this server should # # not generate quit and connect notices, which can cut down on noise # # to opers on the network. # # # <services server="services.example.com" silent="yes"> # Once you have edited this file you can remove this line. This is just to # ensure that you don't hastily include the file without reading it. <die reason="Using links.example.conf without editing it is a security risk"> ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/docs/conf/modules.example.conf�������������������������������������������������������0000664�0000000�0000000�00000412671�14771603147�0021210�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������#-#-#-#-#-#-#-#-#-#-#-#-#- MODULE OPTIONS -#-#-#-#-#-#-#-#-#-#-#-#-# # # # These tags define which modules will be loaded on startup by your # # server. Add modules without any paths. When you make your ircd # # using the 'make' command, all compiled modules will be moved into # # the folder you specified when you ran ./configure. The module tag # # automatically looks for modules in this location. # # If you attempt to load a module outside of this location, either # # in the config, or via /LOADMODULE, you will receive an error. # # # # By default, ALL modules are commented out. You must uncomment them # # or add lines to your config to load modules. Please refer to # # https://docs.inspircd.org/4/modules for a list of modules and # # each modules link for any additional conf tags they require. # # # # ____ _ _____ _ _ ____ _ _ _ # # | _ \ ___ __ _ __| | |_ _| |__ (_)___ | __ )(_) |_| | # # | |_) / _ \/ _` |/ _` | | | | '_ \| / __| | _ \| | __| | # # | _ < __/ (_| | (_| | | | | | | | \__ \ | |_) | | |_|_| # # |_| \_\___|\__,_|\__,_| |_| |_| |_|_|___/ |____/|_|\__(_) # # # # To link servers to InspIRCd, you MUST load the spanningtree module. # # If you don't do this, server links will NOT work at all. # # This is by design, to allow for the implementation of other linking # # protocols in modules in the future. This module is at the bottom of # # this file. # # # #-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-# # Abbreviation module: Provides the ability to abbreviate commands a-la # BBC BASIC keywords. #<module name="abbreviation"> #-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-# # Account support module: Adds support for user accounts as well as # several several modes relating to accounts. #<module name="account"> #-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-# # Alias module: Allows you to define server-side command aliases. #<module name="alias"> # # Set the 'prefix' for in-channel aliases (fantasy commands) to the # specified character. If not set, the default is "!". # If 'allowbots' is disabled, +B clients will not be able to use # fantasy commands. If not set, the default is no. #<fantasy prefix="!" allowbots="no"> # #-#-#-#-#-#-#-#-#-#-#- ALIAS DEFINITIONS -#-#-#-#-#-#-#-#-#-#-#-#-#-# # # # If you have the alias module loaded, you may also define aliases as # # shown below. They are commonly used to provide shortcut commands to # # services, however they are not limited to just this use. # # An alias tag requires the following values to be defined in it: # # # # text - The text to detect as the actual command line. # # Can't contain spaces, but case insensitive. # # You may have multiple aliases with the same # # command name (text="" value), however the first # # found will be executed if its format value is # # matched, or it has no format value. Aliases are # # read from the top of the file to the bottom. # # # # usercommand - If set to yes, the alias can be run simply as # # /ALIASNAME. Defaults to yes. # # # # channelcommand - If set to yes, the alias can be used as an # # in-channel alias or 'fantasy command', prefixed # # by the fantasy prefix character, !aliasname by # # default. Defaults to no. # # # # format - If this is defined, the parameters of the alias # # must match this glob pattern. For example if you # # want the first parameter to start with a # for # # the alias to be executed, set format="#*" in the # # alias definition. Note that the :'s which are # # part of IRC formatted lines will be preserved # # for matching of this text. This value is # # optional. # # # # replace - The text to replace 'text' with. Usually this # # will be "PRIVMSG ServiceName :$2-" or similar. # # You may use the variables $1 through $9 in the # # replace string, which refer to the first through # # ninth word in the original string typed by the # # user. You may also use $1- through $9- which # # refer to the first word onwards, through to the # # ninth word onwards, e.g. if the user types the # # command "foo bar baz qux quz" then $3- will hold # # "baz qux quz" and $2 will contain "bar". You may # # also use the special variables: $nick, $user, # # $address, $host and $vhost, and you may separate # # multiple commands with a newline (which can be # # written in the file literally or encoded as &nl; # # # # requires - If you provide a value for 'requires' this means # # the given nickname MUST be online for the alias # # to successfully trigger. If they are not, then # # the user receives a 'no such nick' 401 numeric. # # # # stripcolor - If set to yes, the text from the user will be # # stripped of color and format codes before # # matching against 'text'. # # # # service - Setting this to yes will ensure that the user # # given in 'requires' is also on a servicesserver, # # as well as actually being on the network. If the # # user is online, but not on a services server, # # then an oper alert is sent out as this is # # possibly a sign of a user trying to impersonate # # a service. # # # # operonly - If yes, this will make the alias oper only. # # If a non-oper attempts to use the alias, it will # # appear to not exist. # # # # # An example of using the format value to create an alias with two # different behaviours depending on the format of the parameters. # #<alias text="ID" format="#*" replace="PRIVMSG ChanServ :IDENTIFY $2 $3" # requires="ChanServ" service="yes"> # #<alias text="ID" replace="PRIVMSG NickServ :IDENTIFY $2" # requires="NickServ" service="yes"> # # You may also add aliases to trigger based on something said in a # channel, aka 'fantasy' commands, configured in the same manner as any # other alias, with usercommand="no" and channelcommand="yes" The # command must be preceded by the fantasy prefix when used. # #<alias text="CS" usercommand="no" channelcommand="yes" # replace="PRIVMSG ChanServ :$1 $chan $2-" requires="ChanServ" service="yes"> # # This would be used as "!cs <command> <options>", with the channel # being automatically inserted after the command in the message to # ChanServ, assuming the fantasy prefix is "!". #-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-# # Allowinvite module: Gives channel mode +A to allow all users to use # /INVITE, and extban A to deny invite from specific masks. #<module name="allowinvite"> #-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-# # Alltime module: Shows time on all connected servers at once. # This module is oper-only and provides /ALLTIME. # To use, ALLTIME must be in one of your oper class blocks. #<module name="alltime"> #-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-# # Anticaps module: Adds channel mode +B which allows you to punish # users that send overly capitalised messages to channels. #<module name="anticaps"> # # You may also configure the characters which anticaps considers to be # lower case and upper case. Any characters not listed here are assumed # to be punctuation and will be ignored when counting: # <anticaps lowercase="abcdefghijklmnopqrstuvwxyz" # uppercase="ABCDEFGHIJKLMNOPQRSTUVWXYZ"> #-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-# # Argon2 module: Allows other modules to generate Argon2 hashes, # usually for cryptographic uses and security. # This module makes the algorithms argon2i, argon2d and argon2id # available for use. # Note that this module is extra, and must be enabled explicitly # to build. It depends on libargon2. #<module name="argon2"> # # memory: Memory hardness, in KiB. E.g. 131072 KiB = 128 MiB. # iterations: Time hardness in iterations. (def. 3) # threads: Maximum amount of threads each invocation can spawn. (def. 1) # length: Output length in bytes. (def. 32) # saltlength: Salt length in bytes. (def. 16) # version: Algorithm version, 10 or 13. (def. 13) # The parameters can be customized as follows: #<argon2 iterations="3" memory="131074" length="32" saltlength="16"> # Defines the parameters that are common for all the variants (i/d/id). # Can be overridden on individual basis, e.g. #<argon2i iterations="4"> #<argon2d memory="131074" #<argon2id iterations="5" memory="262144" length="64" saltlength="32"> #-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-# # Auditorium module: Adds channel mode +u which makes everyone else # except you in the channel invisible, used for large meetings etc. #<module name="auditorium"> # # Auditorium settings: # #<auditorium opvisible="no" opcansee="no" opercansee="yes"> # # opvisible (auditorium-vis in exemptchanops): # Show channel ops to all users # opcansee (auditorium-see in exemptchanops): # Allow ops to see all joins/parts/kicks in the channel # opercansee: # Allow opers (channels/auspex) to see see all joins/parts/kicks in the channel # # Exemptchanops can be used to adjust the level at which users become visible or # the level at which they can see the full member list of the channel. #-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-# # Autoop module: Adds basic channel access controls via the +w listmode. # For example +w o:*!Attila@127.0.0.1 will op anyone matching that mask # on join. This can be combined with extbans, for example +w o:R:Brain # will op anyone identified to the account "Brain". # Another useful combination is with TLS client certificate # fingerprints: +w h:z:72db600734bb9546c1bdd02377bc21d2a9690d48 will # give halfop to the user(s) having the given certificate. #<module name="autoop"> #-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-# # Ban except module: Adds support for channel ban exceptions (+e). #<module name="banexception"> #-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-# # Ban redirection module: Allows bans which redirect to a specified # channel. e.g. +b nick!user@host#channelbanneduserissentto #<module name="banredirect"> #-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-# # bcrypt module: Allows other modules to generate bcrypt hashes, # usually for cryptographic uses and security. #<module name="bcrypt"> # # rounds: Defines how many rounds the bcrypt function will run when # generating new hashes. #<bcrypt rounds="10"> #-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-# # Block amsg module: Attempt to block all usage of /amsg and /ame. #<module name="blockamsg"> # #-#-#-#-#-#-#-#-#-#-#- BLOCKAMSG CONFIGURATION -#-#-#-#-#-#-#-#-#-#-# # # # If you have the blockamsg module loaded, you can configure it with # # the <blockamsg> tag: # # # # delay - How much time between two messages to force them # # to be recognised as unrelated. # # action - Any of 'notice', 'noticeopers', 'silent', 'kill' # # or 'killopers'. Define how to take action when # # a user uses /amsg or /ame. # # #<blockamsg delay="3" action="killopers"> #-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-# # Block color module: Blocking color-coded messages with chan mode +c. #<module name="blockcolor"> #-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-# # Botmode module: Adds the user mode +B. If set on a user, it will # show that the user is a bot in /WHOIS. #<module name="botmode"> #-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-# # CallerID module: Adds user mode +g which activates hybrid-style # callerid: block all private messages unless you /ACCEPT first. #<module name="callerid"> # #-#-#-#-#-#-#-#-#-#-#- CALLERID CONFIGURATION -#-#-#-#-#-#-#-#-#-#-#-# # maxaccepts - Maximum number of entries a user can add to their # # /ACCEPT list. Default is 30 entries. # # tracknick - Preserve /ACCEPT entries when a user changes nick? # # If no (the default), the user is removed from # # everyone's accept list if their nickname changes. # # cooldown - Amount of time that must pass since the last # # notification sent to a user before they can be # # sent another. Default is 1 minute. # #<callerid maxaccepts="30" # tracknick="no" # cooldown="1m"> #-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-# # CAP module: Provides the CAP negotiation mechanism required by many # other modules. It is strongly recommended that you load this. #<module name="cap"> #-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-# # CBAN module: Lets you disallow channels from being used at runtime. # This module is oper-only and provides /CBAN. # To use, CBAN must be in one of your oper class blocks. #<module name="cban"> #-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-# # Channel create module: Adds snomask +j, which will notify opers of # any new channels that are created. # This module is oper-only. #<module name="chancreate"> #-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-# # Channel filter module: Allows channel-op defined message filtering # using simple string matches (channel mode +g). #<module name="chanfilter"> # # If hidemask is set to yes, the user will not be shown the mask when # their message is blocked. # # If maxlen is set then it defines the maximum length of a filter entry. # # If notifyuser is set to no, the user will not be notified when # their message is blocked. #<chanfilter hidemask="yes" maxlen="50" notifyuser="yes"> #-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-# # Channel history module: Displays the last 'X' lines of chat to a user # joining a channel with +H 'X:T' set; 'T' is the maximum time to keep # lines in the history buffer. Designed so that the new user knows what # the current topic of conversation is when joining the channel. #<module name="chanhistory"> # #-#-#-#-#-#-#-#-#-#-#- CHANHISTORY CONFIGURATION -#-#-#-#-#-#-#-#-#-#-# # # # maxduration - The maximum period to keep chat history for. Defaults # # to 4 weeks. # # # # maxlines - The maximum number of lines of chat history to send to a # # joining users. Defaults to 50. # # # # prefixmsg - Whether to send an explanatory message to clients that # # don't support the chathistory batch type. Defaults to # # yes. # # # # savefrombots - Whether to save messages from users with user mode # # +B (bot) in the channel history. Defaults to yes. # # # # sendtobots - Whether to send channel history to users with user # # mode +B (bot) enabled. Defaults to yes. # # #<chanhistory maxlines="50" # maxduration="4w" # prefixmsg="yes" # savefrombots="yes" # sendtobots="yes"> #-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-# # Channel logging module: Used to send snotice output to channels, to # allow staff to centrally monitor and discuss network activity. # # The "channel" field is where you want the messages to go, "snomasks" # is what snomasks you want to be sent to that channel. Multiple tags # are allowed. #<module name="chanlog"> #<chanlog snomasks="AOcC" channel="#opers"> #-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-# # Channel names module: Allows disabling channels which have certain # characters in the channel name such as bold, colorcodes, etc. which # can be quite annoying and allow users to on occasion have a channel # that looks like the name of another channel on the network. #<module name="channames"> #<channames # denyrange: characters or range of characters to deny in channel # names. #denyrange="2,3" # allowrange: characters or range of characters to specifically allow # in channel names. #allowrange=""> #-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-# # Channelban: Implements extended ban j:, which stops anyone already # in a channel matching a ban like +b j:#channel from joining. # It is also possible to ban based on their status in that channel, # like so: +b j:@#channel, this example prevents the ops from joining. # Note that by default wildcard characters * and ? are allowed in # channel names. To disallow them, load the channames module and # add characters 42 and 63 to denyrange (see above). #<module name="channelban"> #-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-# # Check module: Adds the /CHECK command. # Check is useful for looking up information on channels, users, # IP addresses and hosts. # This module is oper-only. # To use, CHECK must be in one of your oper class blocks. #<module name="check"> #-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-# # CHGHOST module: Adds the /CHGHOST command. # This module is oper-only. # To use, CHGHOST must be in one of your oper class blocks. # NOTE: Services will not be able to set vhosts on users if this module # isn't loaded. If you're planning on running services, you probably # want to load this. #<module name="chghost"> # #-#-#-#-#-#-#-#-# /CHGHOST - /SETHOST CONFIGURATION #-#-#-#-#-#-#-#-# # Optional - If you want to use special chars for hostnames you can # # specify your own custom list of chars with the <hostname> tag: # # # # charmap - A list of chars accepted as valid by the /CHGHOST # # and /SETHOST commands. Also note that the list is # # case-sensitive. # #<hostname charmap="abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ.-_/0123456789"> #-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-# # CHGIDENT module: Adds the /CHGIDENT command. # This module is oper-only. # To use, CHGIDENT must be in one of your oper class blocks. #<module name="chgident"> #-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-# # CHGNAME module: Adds the /CHGNAME command. # This module is oper-only. # To use, CHGNAME must be in one of your oper class blocks. #<module name="chgname"> # #-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-# # Connection class ban module: Adds support for extban 'n' which # matches against the class name of the user's connection. # This module assumes that connection classes are named in a uniform # way on all servers of the network. Wildcards are accepted. #<module name="classban"> #-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-# # Clear chan module: Allows opers to masskick, masskill or # mass G/Z-line all users on a channel using /CLEARCHAN. #<module name="clearchan"> #-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-# # Cloak module: Adds user mode x (cloak) which allows user hostnames to # be hidden. This module does not provide any cloak methods by itself. # You should also load another module like cloak_account or cloak_sha256. # # In order to have users automatically cloaked on connect you should # load the conn_umodes module and add "x" to <connect:modes>. #<module name="cloak"> #-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-# # MD5 cloak module: Adds the "half" and "full" cloak methods. These # methods are deprecated and will be removed in the next major version # of InspIRCd. They should only be used on a network which is upgrading # from v3 and wishes to keep ban compatibility. New networks should use # the "hmac-sha256" method (see below) instead. # # IMPORTANT: If you are using this module you should also load the md5 # module. Failure to do so will result in users not being cloaked. #<module name="cloak_md5"> # #-#-#-#-#-#-#-#-#-#-#- MD5 CLOAK CONFIGURATION -#-#-#-#-#-#-#-#-#-#-#-# # To use the cloak_md5 module you must define a <cloak> tag. This tag # # tag can have the following fields. # # # # key - The secret key to use when hashing hostnames. This # # MUST be at least 30 characters long. # # # # class - If non-empty then a comma-delimited list of connect # # class names that a user has to be in to get the cloak # # from this tag. # # # # prefix - A freeform value to prefix cloaks with. This must not # # contain spaces. # # # # suffix - A freeform value to suffix cloaks with. This must not # # contain spaces. # # # # domainparts - The maximum number of hostname labels that should be # # visible on the end of a host. Defaults to 3. # # # # ignorecase - Whether to ignore the capitalisation of a hostname # # when generating the cloak. This prevents users from # # evading bans by changing the case of their DNS PTR # # record. Defaults to off. # # # # IMPORTANT: Changing these details will break all of your existing # # bans. If you do not want this to happen you can define multiple # # cloak tags. The first will be used for hostnames and the rest will # # be used for checking if a user is banned in a channel. # #-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-# # #<cloak method="half" # key="changeme" # class="" # prefix="MyNet-" # suffix=".IP" # domainparts="3" # ignorecase="yes"> # #<cloak method="full" # key="changeme" # class="" # prefix="MyNet-" # suffix=".IP"> #-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-# # HMAC-SHA256 cloak module: Adds the "hmac-sha256" (hostname or IP) and # "hmac-sha256-addr" (IP only) cloak methods. This is the recommended # cloak module for new networks. # # IMPORTANT: If you are using this module you should also load the sha2 # module. Failure to do so will result in users not being cloaked. #<module name="cloak_sha256"> # #-#-#-#-#-#-#-#-#- HMAC-SHA256 CLOAK CONFIGURATION -#-#-#-#-#-#-#-#-#-# # To use the cloak_sha256 module you must define a <cloak> tag. This # # tag can have the following fields. # # # # key - The secret key to use when hashing hostnames. This # # MUST be at least 30 characters long. # # # # class - If non-empty then a comma-delimited list of connect # # class names that a user has to be in to get the cloak # # from this tag. # # # # prefix - A freeform value to prefix cloaks with. This must not # # contain spaces. # # # # suffix - A freeform value to suffix IPv4/IPv6 cloaks with. This # # must not contain spaces. # # # # case - The case of the cloak table. Can be set to "upper" or # # "lower". Defaults to "lower". # # # # hostparts - The maximum number of hostname labels that should be # # visible on the end of a host. Defaults to 3. # # # # pathparts - The maximum number of UNIX socket path segments that # # should be visible on the end of a host. Defaults to 1. # # # # psl - If non-empty then the path to a Mozilla Public Suffix # # List database to use for finding the visible part of a # # hostname or "system" to use the system database if one # # exists. This overrides the hostparts (above) field. # # Only available if libpsl was installed at build time. # # # # IMPORTANT: Changing these details will break all of your existing # # bans. If you do not want this to happen you can define multiple # # cloak tags. The first will be used for hostnames and the rest will # # be used for checking if a user is banned in a channel. # #-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-# # #<cloak method="hmac-sha256" # key="changeme" # class="" # prefix="MyNet" # suffix="ip" # case="lower" # hostparts="3" # pathparts="1" # psl="system"> # #<cloak method="hmac-sha256-addr" # key="changeme" # class="" # prefix="MyNet" # suffix="ip" # case="lower" # pathparts="1"> #-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-# # Static cloak module: Adds the "static" (fixed value) cloak method. #<module name="cloak_static"> # #-#-#-#-#-#-#-#-#-#- STATIC CLOAK CONFIGURATION -#-#-#-#-#-#-#-#-#-#-# # To use the cloak_static module you must define a <cloak> tag. This # # tag can have the following fields. # # # # class - If non-empty then a comma-delimited list of connect class # # names that a user has to be in to get the cloak from this tag. # # # # cloak - The cloak to give to users. # # # # IMPORTANT: Changing these details will break all of your existing # # bans. If you do not want this to happen you can define multiple # # cloak tags. The first will be used for hostnames and the rest will # # be used for checking if a user is banned in a channel. # #-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-# # #<cloak method="static" # class="" # cloak="some.fixed.value"> #-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-# # User data cloak module: Adds the "account" (services account name), # "account-id" (services account id), "nickname" (current nickname), # "fingerprint" (client certificate fingerprint), and "username" (RFC # 1413 identification string) cloak methods. #<module name="cloak_user"> # #-#-#-#-#-#-#-#-#-#-#- USER CLOAK CONFIGURATION -#-#-#-#-#-#-#-#-#-#-# # To use the cloak_user module you must define a <cloak> tag. This # # tag can have the following fields. # # # # case - The case to transform the cloak value to. Can be set # # to "upper" to use upper case, "lower" to use lower # # case, or "preserve" to not change the case. Defaults # # to "preserve". # # # # class - If non-empty then a comma-delimited list of connect # # class names that a user has to be in to get the # # cloak from this tag. # # # # invalidchar - The action to take when an invalid host character is # # encountered in the cloak. Can be set to "reject" to # # not apply the cloak, "strip" to remove the invalid # # host character, or "truncate" to truncate the cloak # # at the invalid host character. Defaults to "strip". # # # # length - If using the "fingerprint" method them the number of # # characters of the fingerprint hash to use. Defaults # # to the value of <limits:maxhost> minus the length of # # the prefix and suffix fields. # # # # prefix - A freeform value to prefix cloaks with. This must # # not contain spaces. # # # # suffix - A freeform value to suffix IPv4/IPv6 cloaks with. # # This must not contain spaces. # # # # IMPORTANT: Changing these details will break all of your existing # # bans. If you do not want this to happen you can define multiple # # cloak tags. The first will be used for hostnames and the rest will # # be used for checking if a user is banned in a channel. # #-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-# # #<cloak method="account" # case="preserve" # class="" # invalidchar="strip" # prefix="" # suffix=".users.example.com"> # #<cloak method="account-id" # case="preserve" # class="" # invalidchar="strip" # prefix="" # suffix=".users.example.com"> # #<cloak method="fingerprint" # case="preserve" # class="" # invalidchar="strip" # length="16" # prefix="" # suffix=".fp"> # #<cloak method="nickname" # case="preserve" # class="" # invalidchar="strip" # prefix="Users/" # suffix=""> # #<cloak method="username" # case="preserve" # class="" # invalidchar="strip" # prefix="Users/" # suffix=""> #-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-# # Codepage module: Allows using a custom 8-bit codepage for nicknames # and case mapping. #<module name="codepage"> # # You should include one of the following files to set your codepage: #<include file="&dir.example;/codepages/ascii.example.conf"> #<include file="&dir.example;/codepages/iso-8859-1.example.conf"> #<include file="&dir.example;/codepages/iso-8859-2.example.conf"> #<include file="&dir.example;/codepages/rfc1459.example.conf"> #<include file="&dir.example;/codepages/strict-rfc1459.example.conf"> # # You can also define a custom codepage. For details on how to do this # please refer to the docs site: # https://docs.inspircd.org/4/modules/codepage #-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-# # Common channels module: Adds user mode +c, which, when set, requires # that users must share a common channel with you to PRIVMSG, NOTICE, # TAGMSG, or INVITE you. #<module name="commonchans"> #-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-# # Connectban: Provides IP connection throttling. Any IP range that # connects too many times (configurable) in an hour is Z-lined for a # (configurable) duration, and their count resets to 0. #<module name="connectban"> # # threshold - The number of connections which are allowed before a user # is connectbanned. Defaults to 10. # # banmessage - The message to give users when Z-lining them for connecting # too much. # # banduration - The time period to ban users who connect to much for. Defaults # to 10 minutes. # # ipv4cidr - The IPv4 CIDR mask (1-32) to treat connecting users as coming # from the same host. Defaults to 32. # # ipv6cidr - The IPv6 CIDR mask (1-128) to treat connecting users as coming # from the same host. Defaults to 128. # # bootwait - The time period to wait after starting up before enforcing # connection bans. Defaults to 2 minutes. # # splitwait - The time period to wait after a netsplit before enforcing # connection bans. Defaults to 2 minutes. # #<connectban threshold="10" # banmessage="Your IP range has been attempting to connect too many times in too short a duration. Wait a while, and you will be able to connect." # banduration="6h" # ipv4cidr="32" # ipv6cidr="128" # bootwait="2m" # splitwait="2m"> #-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-# # Connection throttle module. #<module name="connflood"> # #-#-#-#-#-#-#-#-#-#-#- CONNTHROTTLE CONFIGURATION -#-#-#-#-#-#-#-#-#-# # period, maxconns - Amount of connections per <period>. # # timeout - Time to wait after the throttle was activated # before deactivating it. Be aware that the time # is seconds + timeout. # # quitmsg - The message that users get if they attempt to # connect while the throttle is active. # # bootwait - Amount of time in seconds to wait before enforcing # the throttling when the server just booted. # #<connflood period="30" maxconns="3" timeout="30" # quitmsg="Throttled" bootwait="2m"> #-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-# # Auto join on connect module: Allows you to force users to join one # or more channels automatically upon connecting to the server, or # join them in case they aren't on any channels after being online # for X seconds. #<module name="conn_join"> # #-#-#-#-#-#-#-#-#-#-#-#- CONNJOIN CONFIGURATION -#-#-#-#-#-#-#-#-#-#-# # # If you have the conn_join module loaded, you can configure it below # or set autojoin="#chat,#help" in <connect> blocks. # # Join users immediately after connection to #one #two and #three. #<autojoin channel="#one,#two,#three"> # Join users to #chat after 15 seconds if they aren't on any channels. #<autojoin channel="#chat" delay="15"> #-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-# # Set modes on connect module: When this module is loaded <connect> # blocks may have an optional modes="" value, which contains modes to # add or remove from users when they connect to the server. #<module name="conn_umodes"> #-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-# # Wait for PONG on connect module: Send a PING to all connecting users # and don't let them connect until they reply with a PONG. # This is useful to stop certain kinds of bots and proxies. #<module name="conn_waitpong"> # #-#-#-#-#-#-#-#-#-#-#- WAITPONG CONFIGURATION -#-#-#-#-#-#-#-#-#-#-# # # # If you have the conn_waitpong module loaded, configure it with the # # <waitpong> tag: # # # # sendsnotice - Whether to send a helpful notice to users on # # connect telling them how to connect, should # # their client not reply PONG automatically. # # # # killonbadreply - Whether to kill the user if they send the wrong # # PONG reply. # # # #<waitpong sendsnotice="no" killonbadreply="yes"> #-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-# # Custom prefixes: Allows for channel prefixes to be configured. #<module name="customprefix"> # # name The name of the mode, must be unique from other modes. # letter The letter used for this mode. Required. # prefix The prefix used for nicks with this mode. Not required. # rank A numeric rank for this prefix, defining what permissions it gives. # The rank of voice, halfop and op is 10000, 20000, and 30000, # respectively. # ranktoset The numeric rank required to set this mode. Defaults to rank. # ranktounset The numeric rank required to unset this mode. Defaults to ranktoset. # depriv Can you remove the mode from yourself? Defaults to yes. #<customprefix name="founder" letter="q" prefix="~" rank="50000" ranktoset="50000"> #<customprefix name="admin" letter="a" prefix="&amp;" rank="40000" ranktoset="50000"> #<customprefix name="halfop" letter="h" prefix="%" rank="20000" ranktoset="30000"> # # You can also override the configuration of prefix modes added by both the core # and other modules by adding a customprefix tag with change="yes" specified. # <customprefix name="op" change="yes" rank="30000" ranktoset="30000"> # <customprefix name="voice" change="yes" rank="10000" ranktoset="20000" depriv="no"> # # Do /RELOADMODULE customprefix after changing the settings of this module. #-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-# # Custom title module: Adds the /TITLE command which allows for trusted # users to gain a custom whois line and an optional vhost can be # specified. #<module name="customtitle"> # #-#-#-#-#-#-#-#-#-#- CUSTOM TITLE CONFIGURATION -#-#-#-#-#-#-#-#-#-# # name - The username used to identify. # password - The password used to identify. # hash - The hash for the specific user's password (optional). # password_hash and a hashing module must be loaded # for this to work. # host - Allowed hostmask (optional). # title - Title shown in whois. # vhost - Displayed host (optional). # #<title name="foo" password="bar" title="Official Chat Helper"> #<title name="bar" password="foo" host="test@test.org" title="Official Chat Helper" vhost="helper.test.org"> #<title name="foo" password="$2a$10$UYZ4OcO8NNTCCGyCdY9SK.2GHiqGgxZfHFPOPmWuxEVWVQTtoDC7C" hash="bcrypt" title="Official Chat Helper"> #-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-# # Channel cycle module: Adds the /CYCLE command which is a server-side # /HOP that bypasses restrictive modes. #<module name="cycle"> #-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-# # DCCALLOW module: Adds the /DCCALLOW command. #<module name="dccallow"> # #-#-#-#-#-#-#-#-#-#-#- DCCALLOW CONFIGURATION -#-#-#-#-#-#-#-#-#-#-# # blockchat - Whether to block DCC CHAT as well as DCC SEND. # length - Default duration of entries in DCCALLOW list. # action - Default action to take if no action is # specified, can be 'block' or 'allow'. # maxentries - Max number of nicks to allow on a DCCALLOW list. # # File configuration: # pattern - The glob pattern to match against. # action - Action to take if a user attempts to send a file # that matches this pattern, can be 'block' or # 'allow'. # #<dccallow blockchat="yes" length="5m" action="block" maxentries="20"> #<banfile pattern="*.exe" action="block"> #<banfile pattern="*.txt" action="allow"> #-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-# # Deaf module: Adds support for user modes +d and +D: # d - deaf to channel messages and notices. # D - deaf to user messages and notices. #<module name="deaf"> # #-#-#-#-#-#-#-#-#-#-#-#- DEAF CONFIGURATION -#-#-#-#-#-#-#-#-#-#-#-# # bypasschars - Characters that bypass deaf to a regular user. # servicebypasschars - Characters that bypass deaf to a services users. # Both of these take a list of characters that must match # the starting character of a message. # If 'servicebypasschars' is empty, then 'bypasschars' will # match for both regular and services users. # privdeafservice - Whether services users bypass user mode +D (privdeaf). # #<deaf bypasschars="" servicebypasschars="!" privdeafservice="yes"> #-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-# # Delay join module: Adds the channel mode +D which delays all JOIN # messages from users until they speak. If they quit or part before # speaking, their quit or part message will not be shown to the channel # which helps cut down noise on large channels in a more friendly way # than the auditorium mode. Only channel ops may set the +D mode. #<module name="delayjoin"> #-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-# # Delay message module: Adds the channel mode +d which disallows a user # from talking in the channel unless they've been joined for X seconds. # Settable using /MODE #chan +d 30 #<module name="delaymsg"> #-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-# # Deny channels module: Deny channels from being used by users. #<module name="denychans"> # #-#-#-#-#-#-#-#-#-#-#- DENYCHAN DEFINITIONS -#-#-#-#-#-#-#-#-#-#-#-# # # # If you have the denychans module loaded, you need to specify the # # channels to deny: # # # # name - The channel name to deny (glob masks are ok). # # allowopers - If operators are allowed to override the deny. # # reason - Reason given for the deny. # # redirect - Redirect the user to a different channel. # # # #<badchan name="#gods*" allowopers="yes" reason="Tortoises!"> # #<badchan name="#chan1" redirect="#chan2" reason="Chan1 is closed"> # # # # Redirects will not work if the target channel is set +L. # # # # Additionally, you may specify channels which are allowed, even if # # a badchan tag specifies it would be denied: # #<goodchan name="#funtimes"> # # Glob masks are accepted here also. # #-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-# # Disable module: Provides support for disabling commands and modes. # #<module name="disable"> # #-#-#-#-#-#-#-#-#-#-#-#- DISABLE CONFIGURATION -#-#-#-#-#-#-#-#-#-#-#-# # # # If you have the disable module loaded then you need to specify the # # commands and modes that you want disabled. Users who have not fully # # connected yet are exempt from this module so you can e.g. disable # # the NICK command but still allow users to connect to the server. # # # # commands - A space-delimited list of commands that can not be used # # by users. You can exempt server operators from this with # # the servers/use-disabled-commands privilege. # # # # chanmodes - One or more channel modes that can not be added/removed # # by users. You can exempt server operators from this # # with the servers/use-disabled-modes privilege. # # # # usermodes - One or more user modes that can not be added/removed by # # users. You can exempt server operators from this with # # the servers/use-disabled-modes privilege. # # # # fakenonexistent - Whether to pretend that a disabled command/mode # # does not exist when executed/changed by a user. # # Defaults to no. # # # # notifyopers - Whether to send a notice to snomask `a` when a user # # is prevented from using a disabled command/mode. # # Defaults to no. # # # #<disabled commands="KICK TOPIC" # # chanmodes="kp" # # usermodes="iw" # # fakenonexistent="yes" # # notifyopers="no"> # #-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-# # DNS blacklist module: Provides support for looking up IPs on one or # # more blacklists. # #<module name="dnsbl"> # # # For configuration options please see the docs page for dnsbl at # # https://docs.inspircd.org/4/modules/dnsbl. You can also use one or # # more of the following example configs for popular DNSBLs: # # # # DroneBL (https://dronebl.org) # #<include file="&dir.example;/providers/dronebl.example.conf"> # # # EFnet RBL (https://rbl.efnetrbl.org) # #<include file="&dir.example;/providers/efnet-rbl.example.conf"> # # # dan.me.uk Tor exit node DNSBL (https://www.dan.me.uk/dnsbl) # #<include file="&dir.example;/providers/torexit.example.conf"> #-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-# # Exempt channel operators module: Provides support for allowing # # users of a specified channel status to be exempt from some channel # # restriction modes. Supported restrictions are: # # anticaps, auditorium-see, auditorium-vis, blockcolor, delaymsg, # # filter, flood, nickflood, noctcp, nonick, nonotice, opmoderated, # # regmoderated, repeat, stripcolor, topiclock # # See <options:exemptchanops> in inspircd.example.conf for a more # # detailed list of the restriction modes that can be exempted. # # These are settable using: /MODE #chan +X <restriction>:<status> # # Furthermore, the exemptions configured in <options:exemptchanops> # # can also be negated by using: /MODE #chan +X <restriction>:* # #<module name="exemptchanops"> #-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-# # Filter module: Provides message filtering, similar to SPAMFILTER. # #<module name="filter"> # # # This module depends upon a regex provider such as regex_stdlib or # # regex_glob to function. You must specify which of these you want # # the filter module to use via the tag below. # # # # Valid engines are: # # # # glob - Glob patterns, provided via regex_glob. # # pcre - PCRE regexps, provided via regex_pcre2, needs libpcre2. # # posix - POSIX regexps, provided via regex_posix, not available # # on Windows, no dependencies on other operating systems. # # stdregex - stdlib regexps, provided via regex_stdlib, see comment # # at the <module> tag for info on availability. # # # # If enableflags is set, you can specify flags that modify matching # # of the regular expression. # # # # If notifyuser is set to no, the user will not be notified when # # their message is blocked. # # # # If warnonselfmsg is set to yes when a user sends a message to # # themself that matches a filter the filter will be ignored and a # # warning will be sent to opers instead. This stops spambots which # # send their spam message to themselves first to check if it is being # # filtered by the server. # #<filteropts engine="stdregex" # enableflags="yes" # notifyuser="yes" # warnonselfmsg="no"> # # # Your choice of regex engine must match on all servers network-wide. # # # # To learn more about the configuration of this module, read # # examples/filter.example.conf, which covers the various types of # # filters and shows how to add exemptions. # # # #-#-#-#-#-#-#-#-#-#-#- FILTER CONFIGURATION -#-#-#-#-#-#-#-#-#-#-#-# # # # Optional - If you specify to use the filter module, then # # specify below the path to the filter.conf file, or define some # # <keyword> tags. # # # #<include file="&dir.example;/filter.example.conf"> #-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-# # Gateway module: Enables forwarding the real IP address of a user from # a gateway to the IRC server. #<module name="gateway"> # #-#-#-#-#-#-#-#-#-#-#-# GATEWAY CONFIGURATION #-#-#-#-#-#-#-#-#-#-#-#-# # # If you use the gateway module then you must specify the gateways which # are authorised to forward IP/host information to your server. There # are currently two ways to do this: # # The webirc method is the recommended way to allow gateways to forward # IP/host information. When using this method the gateway sends a WEBIRC # message to the server on connection. For more details please read the # IRCv3 WebIRC specification at: https://ircv3.net/specs/extensions/webirc.html # # When using this method you must specify one or more wildcard masks # or CIDR ranges to allow gateway connections from and at least one of # either a TLS client certificate fingerprint for the gateway or # a password to be sent in the WEBIRC command. # # <gateway type="webirc" # fingerprint="bd90547b59c1942b85f382bc059318f4c6ca54c5" # mask="192.0.2.0/24 198.51.100.*"> # <gateway type="webirc" # password="$2a$10$WEUpX9GweJiEF1WxBDSkeODBstIBMlVPweQTG9cKM8/Vd58BeM5cW" # hash="bcrypt" # mask="*.webirc.gateway.example.com"> # # Alternatively if your gateway does not support sending the WEBIRC # message then you can configure InspIRCd to look for the client IP # address in the username sent by the user. This is not recommended # as it only works with IPv4 connections. # # When using this method you must specify one or more wildcard masks # or CIDR ranges to allow gateway connections from. You can also # optionally configure the static value that replaces the IP in the # username to avoid leaking the real IP address of gateway clients # (defaults to "gateway" if not set). # # <gateway type="username" # mask="198.51.100.0/24 203.0.113.*" # newusername="wibble"> # <gateway type="username" # mask="*.username.gateway.example.com" # newusername="wobble"> # # IMPORTANT NOTE: # --------------- # # When you connect gateway clients, there are two connect classes which # apply to these clients. When the client initially connects, the connect # class which matches the gateway site's host is checked. Therefore you # must raise the maximum local/global clients for this IP as high as you # want to allow gateway clients. After the client has connected and is # determined to be a gateway client, the class which matches the client's # real IP is then checked. You may set this class to a lower value, so that # the real IP of the client can still be restricted to, for example, 3 # sessions maximum. #-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-# # MaxMindDB geolocation module: Provides geolocation information for # # other modules that need it using the libMaxMindDB library. # # # # This module depends on a third-party library (libmaxminddb) and may # # need to be manually enabled at build time. If you are building from # # source you can do this by installing this dependency and running: # # # # ./configure --enable-extras geo_maxmind # # make install # # # # Users of binary packages should consult the documentation for their # # package to find out whether this module is available. # #<module name="geo_maxmind"> # # # If you use the geo_maxmind module you MUST provide a database file # # to look up geolocation information in. You can either purchase this # # from MaxMind at https://www.maxmind.com/en/geoip2-country-database # # or use the free CC-BY-SA licensed GeoLite2 Country database which # # can be downloaded at https://dev.maxmind.com/geoip/geoip2/geolite2/ # #<maxmind file="GeoLite2-Country.mmdb"> #-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-# # Geolocation ban module: Adds support for extban 'G' which matches # # against the ISO 3166-1 alpha-2 codes for the countries that users # # are connecting from. Users connecting from unknown origins such as # # internal networks can be matched against using the XX alpha-2 code. # # A full list of ISO 3166-1 alpha-2 codes can be found at # # https://en.wikipedia.org/wiki/ISO_3166-1_alpha-2 # #<module name="geoban"> #-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-# # Geolocation connect class module: Adds support for limiting connect # # classes to users from specific countries. With this module you can # # specify a space-delimited list of two character the ISO 3166-1 # # alpha-2 codes in the "country" field of a connect class. e.g. to # # deny connections from users in Russia or Turkey: # # # # <connect deny="*" country="TR RU"> # # # # Users connecting from unknown origins such as internal networks can # # be matched against using the XX alpha-2 code. A full list of ISO # # 3166-1 alpha-2 codes can be found at # # https://en.wikipedia.org/wiki/ISO_3166-1_alpha-2 # #<module name="geoclass"> #-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-# # Global load module: Allows loading and unloading of modules network- # wide (USE WITH EXTREME CAUTION!) # This module is oper-only and provides /GLOADMODULE, /GUNLOADMODULE # and /GRELOADMODULE. # To use, GLOADMODULE, GUNLOADMODULE and GRELOADMODULE # must be in one of your oper class blocks. #<module name="globalload"> #-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-# # Globops module: Provides the /GLOBOPS command and snomask +g. # This module is oper-only. # To use, GLOBOPS must be in one of your oper class blocks. #<module name="globops"> #-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-# # HAProxy module: Adds support for the HAProxy PROXY v2 protocol. To # use this module specify hook="haproxy" in the <bind> tag that HAProxy # has been configured to connect to. #<module name="haproxy"> #-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-# # Help module: Provides the /HELP command #<module name="help"> # #-#-#-#-#-#-#-#-#-#-#-#- HELP CONFIGURATION -#-#-#-#-#-#-#-#-#-#-#-# # # # If you specify to use the help module, then specify below the path # # to the help.conf file. # # # #<include file="&dir.example;/help.example.conf"> #-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-# # Help mode module: Provides oper-only user mode `h` (helpop) which # marks a server operator as available for help. #<module name="helpmode"> # # If you also use the hideoper module you can allow hidden opers with # the help mode set to to be included in `/STATS P` and mark helpers # as such to differentiate them from opers. # <helpmode ignorehideoper="no" # markhelpers="yes"> # # You can also define one or more channels which helpers will be given # a channel prefix mode in. If not otherwise specified the prefix mode # defaults to channel mode o (op). # # <helpchan name="#help-*" prefix="o"> #-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-# # Hide chans module: Allows users to hide their channels list from non- # opers by setting user mode +I on themselves. #<module name="hidechans"> # # affectsopers: Whether server operators with the users/auspex privilege # are exempt from the hideoper (+I) mode. Defaults to no. # # hideservices: Whether to hide the channels of services pseudoclients # with the hideoper (+I) mode from all users. Defaults # to yes. # # <hidechans affectsopers="no" # hideservices="yes"> #-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-# # Hide list module: Allows for hiding the list of listmodes from users # who do not have sufficient channel rank. #<module name="hidelist"> # # Each <hidelist> tag configures one listmode to hide. # mode: Name of the listmode to hide. # rank: Minimum rank required to view the list. If set to 0, all # members of the channel may view the list, but non-members may not. # The rank of the built-in op and voice mode is 30000 and 10000, # respectively; the rank of other prefix modes is configurable. # Defaults to 20000. # # Hiding the ban list is not recommended because it may break some # clients. # # Hide filter (+g) list: #<hidelist mode="filter" rank="30000"> # Only show invite exceptions (+I) to channel members: #<hidelist mode="invex" rank="0"> #-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-# # Hide mode module: Allows for hiding mode changes from users who do not # have sufficient channel privileges. #<module name="hidemode"> # # Hide bans (+b) from people who are not voiced: #<hidemode mode="ban" rank="10000"> #-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-# # Hide oper module: Allows opers to hide their oper status from non- # opers by setting user mode +H on themselves. # This module is oper-only. #<module name="hideoper"> #-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-# # hostcycle module: Sends a fake part and join for users when their # username or hostname changes to update client information caches. # This module is compatible with the ircv3_chghost module. Clients # supporting the chghost extension will get the chghost message instead # of seeing a host cycle. #<module name="hostcycle"> #-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-# # httpd module: Provides HTTP server support for InspIRCd. #<module name="httpd"> # #-#-#-#-#-#-#-#-#-#-#-#- HTTPD CONFIGURATION -#-#-#-#-#-#-#-#-#-#-# # # If you choose to use the httpd module, then you will need to add # a <bind> tag with type "httpd", and load at least one of the other # httpd_* modules to provide pages to display. # <bind address="127.0.0.1" port="8067" type="httpd"> # <bind address="127.0.0.1" port="8097" type="httpd" sslprofile="Clients"> # # You can adjust the timeout for HTTP connections below. All HTTP # connections will be closed after (roughly) this time period. #<httpd timeout="20"> #-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-# # HTTP ACL module: Provides access control lists for httpd dependent # modules. Use this module to restrict pages by IP address and by # password. #<module name="httpd_acl"> # #-#-#-#-#-#-#-#-#-#-#-#- HTTPD ACL CONFIGURATION -#-#-#-#-#-#-#-#-#-#-# # # Restrict access to the httpd_stats module to all but the local # network and when the correct password is specified: # <httpdacl path="/stats*" types="password,whitelist" # username="secrets" password="mypasshere" whitelist="127.0.0.*,10.*"> # # Deny all connections to all but the main index page: # <httpdacl path="/*" types="blacklist" blacklist="*"> #-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-# # HTTP config module: Allows the server configuration to be viewed over # HTTP via the /config path. Requires the httpd module to be loaded for # it to function. # # IMPORTANT: This module exposes extremely sensitive information about # your server and users so you *MUST* protect it using a local-only # <bind> tag and/or the httpd_acl module. See above for details. #<module name="httpd_config"> #-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-# # HTTP stats module: Provides server statistics over HTTP via the /stats # path. Requires the httpd module to be loaded for it to function. # # IMPORTANT: This module exposes extremely sensitive information about # your server and users so you *MUST* protect it using a local-only # <bind> tag and/or the httpd_acl module. See above for details. #<module name="httpd_stats"> #-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-# # Ident: Provides RFC 1413 ident lookup support. # When this module is loaded <connect:allow> tags may have an optional # useident="yes|no" boolean value, determining whether or not to lookup # usernames on users matching that connect tag. #<module name="ident"> # #-#-#-#-#-#-#-#-#-#-#-#- IDENT CONFIGURATION -#-#-#-#-#-#-#-#-#-#-# # # # Optional - If you are using the ident module, then you can specify # # the timeout for ident lookups here. If not defined, it will default # # to 5 seconds. This is a non-blocking timeout which holds the user # # in a 'connecting' state until the lookup is complete. # # prefixunqueried: If yes, the usernames of users in a connect class # # with ident lookups disabled (i.e. <connect useident="no">) will be # # prefixed with a "~". If no, the username of those users will not be # # prefixed. Default is no. # # #<ident timeout="5" prefixunqueried="no"> #-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-# # Invite exception module: Adds support for channel invite exceptions # (+I). #<module name="inviteexception"> # bypasskey: If this is enabled, exceptions will bypass +k as well as +i #<inviteexception bypasskey="yes"> #-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-# # IRCv3 module: Provides the IRCv3 account-notify, away-notify, # extended-join, and standard-replies extensions. These are optional # enhancements to the client-to-server protocol. An extension is only # active for a client when the client specifically requests it, so this # module needs the cap module to work. # # Further information on these extensions can be found at the IRCv3 # working group website: # https://ircv3.net/irc/ # #<module name="ircv3"> # The following block can be used to control which extensions are # enabled. Note that extended-join can be incompatible with delayjoin # and host cycling. #<ircv3 accountnotify="yes" # awaynotify="yes" # extendedjoin="yes" # standardreplies="yes"> #-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-# # IRCv3 account-tag module. Adds the 'account' tag which contains the # user account name of the message sender. #<module name="ircv3_accounttag"> #-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-# # IRCv3 batch module: Provides the batch IRCv3 extension which allows # the server to inform a client that a group of messages are related to # each other. #<module name="ircv3_batch"> #-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-# # IRCv3 cap-notify module: Provides the cap-notify IRCv3 extension. # Required for IRCv3 conformance. #<module name="ircv3_capnotify"> #-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-# # IRCv3 chghost module: Provides the chghost IRCv3 extension which # allows capable clients to learn when the username or hostname of a # user changes # This module is compatible with the hostcycle module. If both are # loaded, clients supporting the chghost extension will get the chghost # message and won't receive a host cycle. #<module name="ircv3_chghost"> #-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-# # IRCv3 client-to-client tags module: Provides the message-tags IRCv3 # extension which allows clients to add extra data to their messages. # This is used to support new IRCv3 features such as replies and ids. #<module name="ircv3_ctctags"> # # If you want to only allow client tags that are intended for processing # by the server you can disable the following setting. Doing this is not # recommended though as it may break clients. #<ctctags allowclientonlytags="yes"> #-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-# # IRCv3 echo-message module: Provides the echo-message IRCv3 # extension which allows capable clients to get an acknowledgement when # their messages are delivered and learn what modifications, if any, # were applied to them. #<module name="ircv3_echomessage"> #-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-# # IRCv3 invite-notify module: Provides the invite-notify IRCv3 # extension which notifies supporting clients when a user invites # another user into a channel. This respects <security:announceinvites>. #<module name="ircv3_invitenotify"> #-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-# # IRCv3 labeled-response module: Provides the labeled-response IRCv3 # extension which allows server responses to be associated with the # client message which caused them to be sent. #<module name="ircv3_labeledresponse"> #-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-# # IRCv3 message id module: Provides the msgid IRCv3 extension which # adds a unique identifier to each message when the message-tags cap # has been requested. This enables support for modern features such as # reactions and replies. #<module name="ircv3_msgid"> #-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-# # IRCv3 server-time module. Adds the 'time' tag which adds a timestamp # to all messages received from the server. #<module name="ircv3_servertime"> #-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-# # IRCv3 Strict Transport Security module: Provides the sts IRCv3 # extension which allows clients connecting insecurely to upgrade their # connections to TLS. #<module name="ircv3_sts"> # # If using the ircv3_sts module you MUST define a STS policy to send # to clients using the <sts> tag. This tag takes the following # attributes: # # host - A glob match for the SNI hostname to apply this policy to. # duration - The amount of time that the policy lasts for. Defaults to # five minutes by default. You should raise this to a month # or two once you know that your config is valid. # port - The port on which TLS connections to the server are being # accepted. You MUST have a CA-verified certificate on this # port. Self signed certificates are not acceptable. # preload - Whether client developers can include your certificate in # preload lists. # # <sts host="*.example.com" duration="5m" port="6697" preload="yes"> #-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-# # Join flood module: Adds support for join flood protection +j X:Y. # Closes the channel for N seconds if X users join in Y seconds. #<module name="joinflood"> # # duration: The number of seconds to close a channel for when it is # being flooded with joins. # # bootwait: The number of seconds to disengage joinflood for after # a server boots. This allows users to reconnect without # being throttled by joinflood. # # splitwait: The number of seconds to disengage joinflood for after # a server splits. This allows users to reconnect without # being throttled by joinflood. # # notifyrank: The lowest prefix rank that should receive notification # that the channel is closed to new users. This can be set # to 0 for all users, 10000 for voiced users (+v) and above, # 30000 for channel operators (+o), or the value specified # in <customprefix:rank> for any custom prefix rank. # #<joinflood duration="1m" # bootwait="30s" # splitwait="30s" # notifyrank="0"> #-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-# # Anti auto rejoin: Adds support for prevention of auto-rejoin (+J). #<module name="kicknorejoin"> #-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-# # Knock module: Adds the /KNOCK command and channel mode +K. #<module name="knock"> # # This setting specifies what to do when someone successfully /KNOCKs. # If set to "notice", then a NOTICE will be sent to the channel. # This is the default and the compatible setting, as it requires no # special support from the clients. # If set to "numeric" then a 710 numeric will be sent to the channel. # This allows easier scripting but not all clients support it. # If set to "both" then (surprise!) both will be sent. #<knock notify="notice"> #-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-# # LDAP module: Allows other SQL modules to access a LDAP database # through a unified API. # # This module depends on a third-party library (OpenLDAP) and may need # to be manually enabled at build time. If you are building from source # you can do this by installing this dependency and running: # # ./configure --enable-extras ldap # make install # # Users of binary packages should consult the documentation for their # package to find out whether this module is available. #<module name="ldap"> # #<database module="ldap" id="ldapdb" server="ldap://localhost" binddn="cn=Manager,dc=inspircd,dc=org" bindauth="mysecretpass" searchscope="subtree"> # The server parameter indicates the LDAP server to connect to. The # # ldap:// style scheme before the hostname proper is MANDATORY. # # # # The binddn and bindauth indicate the DN to bind to for searching, # # and the password for the distinguished name. Some LDAP servers will # # allow anonymous searching in which case these two values do not # # need defining, otherwise they should be set similar to the examples # # above. # # # # The searchscope value indicates the subtree to search under. On our # # test system this is 'subtree'. Your mileage may vary. # #-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-# # LDAP authentication module: Adds the ability to authenticate users # # via LDAP. # #<module name="ldapauth"> # # # Configuration: # # # # <ldapauth dbid="ldapdb" # # baserdn="ou=People,dc=brainbox,dc=cc" # # attribute="uid" # # killreason="Access denied" # # verbose="yes" # # host="$uid.$ou.inspircd.org" # # field="nickname"> # # # # <ldapexemption mask="*!*@10.42.0.0/16"> # # <ldapexemption mask="Guest*!*@*"> # # # # <ldaprequire attribute="attr" value="val"> # # # # The baserdn indicates the base DN to search in for users. Usually # # this is 'ou=People,dc=yourdomain,dc=yourtld'. # # # # The attribute value indicates the attribute which is used to locate # # a user account by name. On POSIX systems this is usually 'uid'. # # # # The field setting chooses where to select the LDAP username from. # # Valid options are "nickname", "username", and "password". # # # # Killreason indicates the QUIT reason to give to users if they fail # # to authenticate. # # # # Setting the verbose value causes an oper notice to be sent out for # # every failed authentication to the server, with an error string. # # # # ldapwhitelist indicates that clients connecting from an IP in the # # provided CIDR do not need to authenticate against LDAP. It can be # # repeated to whitelist multiple CIDRs. # # # # ldaprequire allows further filtering on the LDAP user, by requiring # # certain LDAP attributes to have a given value. It can be repeated, # # in which case the list will act as an OR list, that is, the # # authentication will succeed if any of the requirements in the list # # is satisfied. # # # # host allows you to change the displayed host of users connecting # # from ldap. The string supplied takes formatters which are replaced # # from the DN. For instance, if your DN looks like: # # uid=w00t,ou=people,dc=inspircd,dc=org, then the formatters uid, ou # # and dc will be available to you. If a key is given multiple times # # in the DN, the last appearance will take precedence. # #-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-# # LDAP oper configuration module: Adds the ability to authenticate # # opers via LDAP. # #<module name="ldapoper"> # # # Configuration: # # # # <ldapoper dbid="ldapdb" # baserdn="ou=People,dc=brainbox,dc=cc" # attribute="uid"> # # # Available configuration items are identical to the same items in # # ldapauth above (except for the verbose setting, that is only # # supported in ldapauth). # # Please always specify a password in your <oper> tags even if the # # opers are to be authenticated via LDAP, so in case this module is # # not loaded the oper accounts are still protected by a password. # #-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-# # JSON logging module: Allows writing messages to a JSON file. # # # # This module depends on a third-party library (yyjson or RapidJSON) # # and may need to be manually enabled at build time. If you are # # building from source you can do this by installing this dependency # # and running: # # # # ./configure --enable-extras log_json # # make install # # # # Users of binary packages should consult the documentation for their # # package to find out whether this module is available. # #<module name="log_json"> # #<log method="json" # target="inspircd.json" # level="normal" # type="* -USERINPUT -USEROUTPUT"> # #<log method="json-stderr" # level="normal" # type="* -USERINPUT -USEROUTPUT"> # #<log method="json-stdout" # level="normal" # type="* -USERINPUT -USEROUTPUT"> #-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-# # SQL logging module: Allows writing messages to an SQL database.. # #<module name="log_sql"> # # This module adds the following fields to the <log> tag: # # dbid - The id for the <database> tag that defines your database # connection details. # query - A custom query to use when inserting logs into the database. # #<log method="sql" # level="normal" # type="* -USERINPUT -USEROUTPUT" # dbid="sql-log" # query="INSERT INTO ircd_log (time, type, message) VALUES (FROM_UNIXTIME($time), '$type', '$message');"> #-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-# # Syslog logging module: Allows writing messages to the system log. # # # # This module depends on a POSIX component (syslog) and may need to # # be manually enabled at build time. If you are building from source # # you can do this by running: # # # # ./configure --enable-extras log_syslog # # make install # # # # Users of binary packages should consult the documentation for their # # package to find out whether this module is available. # #<module name="log_syslog"> # #<log method="syslog" # level="normal" # type="* -USERINPUT -USEROUTPUT"> #-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-# # Map hiding module: replaces /MAP and /LINKS output to users with a # # message to see a website, set by maphide="https://test.org/map" in # # the <security> tag, instead. # #<module name="maphide"> #-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-# # MD5 module: Allows other modules to generate MD5 hashes, usually for # cryptographic uses and security. This module is deprecated and will # be removed in the next major version of InspIRCd. # # IMPORTANT: # Other modules such as cloak_md5 and password_hash may rely on # this module being loaded to function. # #<module name="md5"> #-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-# # Message flood module: Adds message/notice flood protection via # channel mode +f. #<module name="messageflood"> # # The weight to give each message type. TAGMSGs are considered to be # 1/5 of a NOTICE or PRIVMSG to avoid users being accidentally flooded # out of a channel by automatic client features such as typing # notifications. #<messageflood message="Message flood detected (trigger is %messages% messages in %duration%)" # extended="yes" # notice="1.0" # privmsg="1.0" # tagmsg="0.2"> #-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-# # Monitor module: Adds support for MONITOR which is used by clients to # maintain notify lists. #<module name="monitor"> # # Set the maximum number of entries on a user's monitor list below. #<monitor maxentries="30"> #-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-# # Multiple prefix module: Provides support for the IRCv3 multi-prefix # capability which allows clients to see all the prefix modes set on a # user. #<module name="multiprefix"> #-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-# # Muteban: Implements extended ban 'm', which stops anyone matching # a mask like +b m:nick!user@host from speaking on channel. #<module name="muteban"> # # If notifyuser is set to no, the user will not be notified when # their message is blocked. #<muteban notifyuser="yes"> #-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-# # MySQL module: Allows other SQL modules to access MySQL databases # through a unified API. # # This module depends on a third-party library (libmysqlclient) and may # need to be manually enabled at build time. If you are building from # source you can do this by installing this dependency and running: # # ./configure --enable-extras mysql # make install # # Users of binary packages should consult the documentation for their # package to find out whether this module is available. #<module name="mysql"> # #-#-#-#-#-#-#-#-#-#-#-#- SQL CONFIGURATION -#-#-#-#-#-#-#-#-#-#-#-#-# # # # mysql is more complex than described here, see the docs for more # # info: https://docs.inspircd.org/4/modules/mysql # # #<database module="mysql" name="mydb" user="myuser" pass="mypass" host="localhost" id="my_database2" ssl="no"> #-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-# # Named modes module: Allows for the display and set/unset of channel # modes via long-form mode names via +Z and the /PROP command. # For example, to set a ban, do /MODE #channel +Z ban=foo!bar@baz or # /PROP #channel ban=foo!bar@baz #<module name="namedmodes"> #-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-# # Nickchange flood protection module: Provides channel mode +F X:Y # which allows up to X nick changes in Y seconds. #<module name="nickflood"> # # The time period to prevent nick changes for: #<nickflood duration="1m"> #-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-# # Nicklock module: Let opers change a user's nick and then stop that # user from changing their nick again until unlocked. # This module is oper-only. # To use, NICKLOCK and NICKUNLOCK must be in one of your oper class blocks. #<module name="nicklock"> #-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-# # No CTCP module: Adds the channel mode +C and user mode +T to block # CTCPs and extban 'C' to block CTCPs sent by specific users. #<module name="noctcp"> #-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-# # No kicks module: Adds the +Q channel mode and the Q: extban to deny # certain users from kicking. #<module name="nokicks"> #-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-# # No nicks module: Adds the +N channel mode, as well as the 'N' extban. # +N stops all users from changing their nick, the N extban stops # anyone from matching a +b N:nick!user@host mask from changing their # nick. #<module name="nonicks"> #-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-# # No notice module: Adds the channel mode +T and the extban 'T' to # block specific users from noticing the channel. #<module name="nonotice"> #-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-# # Network business join module: # Allows an oper to join a channel using /OJOIN, giving them +Y on the # channel which makes them immune to kicks. #<module name="ojoin"> # # Specify the prefix that +Y will grant here. # Leave 'prefix' empty if you do not wish +Y to grant a prefix. # If 'notice' is set to on, upon /OJOIN, the server will notice the # channel saying that the oper is joining on network business. # If 'op' is set to on, it will give them +o along with +Y. #<ojoin prefix="!" notice="yes" op="yes"> #-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-# # Oper channels mode: Adds the +O channel mode which restricts channel # access to server operators and extbans O:<type> and o:<account> that # match against an oper type and oper account respectively. #<module name="operchans"> #-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-# # Oper join module: Auto-joins opers to a channel upon oper-up. # This module is oper-only. For the user equivalent, see the conn_join # module. #<module name="operjoin"> # #-#-#-#-#-#-#-#-#-#-# OPERJOIN CONFIGURATION -#-#-#-#-#-#-#-#-#-#-# # # # If you are using the operjoin module, specify options here: # # # # channel - The channel name to join, can also be a comma # # separated list e.g. "#channel1,#channel2". # # # # override - If on, lets the oper join walking thru any modes # # that might be set, even bans. # # # #<operjoin channel="#channel" override="no"> # # Alternatively you can use the autojoin="channellist" in a <type> # # tag to set specific autojoins for a type of oper, for example: # # #<type name="Helper" autojoin="#help" classes="..."> #-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-# # Oper levels module: Gives each oper a level and prevents actions # being taken by lower level opers against higher level opers. # Specify the level as the 'level' parameter of the <type> tag. # This module is oper-only. #<module name="operlevels"> #-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-# # Oper log module: Logs all oper commands to the server log (with log # type "m_operlog" at default loglevel), and optionally to the 'o' # snomask. # This module is oper-only. #<module name="operlog"> # # If the following option is on then all oper commands will be sent to # the snomask 'o'. The default is no. #<operlog tosnomask="no"> #-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-# # Oper modes module: Allows you to specify modes to add/remove on oper. # Specify the modes as the 'modes' parameter of the <type> tag # and/or as the 'modes' parameter of the <oper> tag. # This module is oper-only. For the user equivalent, see the # conn_umodes module. #<module name="opermodes"> #-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-# # Oper MOTD module: Provides support for a separate message of the day # on oper-up. # This module is oper-only. #<module name="opermotd"> #-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-# # Oper prefixing module: Adds a channel prefix mode +y which is given # to all server operators automatically on all channels they are in. # This prefix mode is more powerful than channel op and other regular # prefix modes. # # Load this module if you want all your server operators to have # channel operator powers. #<module name="operprefix"> # # You may additionally customise the prefix character. #<operprefix prefix="!"> #-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-# # Op moderated module: Adds channel mode +U and extban u: which allow # making messages from matching unprivileged users only visible to # channel operators. #<module name="opmoderated"> #-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-# # Override module: Adds support for oper override. # This module is oper-only. #<module name="override"> # #-#-#-#-#-#-#-#-#-#-# OVERRIDE CONFIGURATION -#-#-#-#-#-#-#-#-#-#-# # # # Much of override's configuration relates to your oper blocks. # # For more information on how to allow opers to override, see: # # https://docs.inspircd.org/4/modules/override # # # # noisy - If enabled, all oper overrides will be announced # # via channel notice. # # # # requirekey - If enabled, overriding on join requires a channel # # key of "override" to be specified. # # # # timeout: The time period after which to automatically remove # # the override user mode. If not set then it will not # # be removed automatically. # # # #<override noisy="yes" # requirekey="no" # timeout="30m"> #-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-# # Password forwarding module: Allows forwarding passwords to services to # automatically log users into their account. The password can either be # specified as the server password or as a second parameter to the /NICK # command. #<module name="passforward"> <passforward # nick: The nick of the service to forward passwords to. nick="NickServ" # forwardmsg: Message to send to users when forwarding their # password. You can use the following variables in this message: # # %nick% The nickname of the authenticating user. # %nickrequired% The nickname of the service to forward to (see above). # %pass% The password to forward to services. # %user% The username of the authenticating user. forwardmsg="NOTICE %nick% :*** Forwarding password to %nickrequired%" # cmd: The message to send to forward passwords to services. cmd="SQUERY %nickrequired% :IDENTIFY %nick% %pass%"> #-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-# # Password hash module: Allows hashed passwords to be used. # To be useful, a hashing module like bcrypt also needs to be loaded. #<module name="password_hash"> # #-#-#-#-#-#-#-#-#-# PASSWORD HASH CONFIGURATION #-#-#-#-#-#-#-#-#-#-#-# # # To use this module, you must define a hash type for each oper's # password you want to hash. For example: # # <oper name="Brain" # host="brain@dialup15.isp.test.com" # hash="bcrypt" # password="$2a$10$Mss9AtHHslZTLBrXqM0FB.JBwD.UTSu8A48SfrY9exrpxbsRiRTbO" # type="NetAdmin"> # # If you are using a hash algorithm which does not perform salting you can use # HMAC to salt your passwords in order to prevent them from being looked up in # a rainbow table. # # hash="hmac-sha256" password="lkS1Nbtp$CyLd/WPQXizsbxFUTqFRoMvaC+zhOULEeZaQkUJj+Gg" # # Generate hashes using the /MKPASSWD command on the server. # Don't run it on a server you don't trust with your password. # # You can also make the MKPASSWD command oper only by uncommenting this: #<mkpasswd operonly="yes"> #-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-# # PBKDF2 module: Allows other modules to generate PBKDF2 hashes, # usually for cryptographic uses and security. # This module relies on other hash providers (e.g. SHA2). #<module name="pbkdf2"> # # iterations: Iterations the hashing function runs when generating new # hashes. # length: Length in bytes of the derived key. #<pbkdf2 iterations="12288" length="32"> # You can override these values with specific values # for specific providers if you want to. Example given for SHA2. #<pbkdf2prov hash="sha256" iterations="24576"> #-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-# # Permanent channels module: Channels with the permanent channel mode # will remain open even after everyone else has left the channel, and # therefore keep things like modes, ban lists and topic. Permanent # channels -may- need support from your Services package to function # properly with them. This adds channel mode +P. # This module is oper-only. #<module name="permchannels"> # # If you like, this module can write a config file of permanent channels # whenever +P is set, unset, or the topic/modes on a +P channel is changed. # If you want to do this, set the filename below, and uncomment the include. # # If 'listmodes' is yes then all list modes (+b, +I, +e, +g...) will be # saved. Defaults to no. # # 'saveperiod' determines how often to check if the database needs to be # saved to disk. Defaults to every five seconds. # # 'backoff' is the value to multiply the saveperiod by every time a save # fails. When the save succeeds the period will be reset. # # 'maxbackoff' is the maximum write period that should be allowed even # if incremental backoff is enabled. # # 'operonly' determines whether a server operator or services server is # needed to enable the permchannels mode. You should generally keep this # set to yes unless you know what you are doing. #<permchanneldb filename="permchannels.conf" # listmodes="yes" # saveperiod="5s" # backoff="2" # maxbackoff="5m" # operonly="yes"> #<include file="permchannels.conf" missingokay="yes"> # # You may also create channels on startup by using the <permchannels> block. #<permchannels channel="#opers" modes="isP" topic="Opers only."> #-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-# # PostgreSQL module: Allows other SQL modules to access PgSQL databases # through a unified API. # # This module depends on a third-party library (libpq) and may need to # be manually enabled at build time. If you are building from source # you can do this by installing this dependency and running: # # ./configure --enable-extras pgsql # make install # # Users of binary packages should consult the documentation for their # package to find out whether this module is available. #<module name="pgsql"> # #-#-#-#-#-#-#-#-#-#-#-#- SQL CONFIGURATION -#-#-#-#-#-#-#-#-#-#-#-#-# # # # pgsql is more complex than described here, see the docs for # # more: https://docs.inspircd.org/4/modules/pgsql # # #<database module="pgsql" name="mydb" user="myuser" pass="mypass" host="localhost" id="my_database" tls="yes"> #-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-# # Random quote module: Provides a random quote on connect. # NOTE: Some of these may mimic fatal errors and confuse users and # opers alike - BEWARE! #<module name="randquote"> # #-#-#-#-#-#-#-#-#-#- RANDOMQUOTES CONFIGURATION -#-#-#-#-#-#-#-#-#-#-# # # # Optional - If you specify to use the randquote module, then specify # # below the path to the quotes file. # # # #<randquote file="quotes.txt"> #-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-# # Real name ban: Implements two extended bans: # # 'a', which matches a n!u@h+realname mask like +b a:*!*@host+*real* # # 'r', which matches a realname mask like +b r:*realname?here* # #<module name="realnameban"> #-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-# # Redirect module: Adds channel mode +L which redirects users to # # another channel when the channel has reached its user limit and # # user mode +L which stops redirection. # #<module name="redirect"> #-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-# # Regular expression provider for glob or wildcard (?/*) matching. # You must have at least 1 provider loaded to use the filter or R-line # modules. This module has no additional requirements, as it uses the # matching already present in InspIRCd core. #<module name="regex_glob"> #-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-# # Regular expression provider for PCRE2 (Perl-Compatible Regular # Expressions). You need libpcre2 installed to compile and load this # module. You must have at least 1 provider loaded to use the filter or # R-line modules. #<module name="regex_pcre2"> #-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-# # Regular expression provider for POSIX regular expressions. # You shouldn't need any additional libraries on a POSIX-compatible # system (i.e.: any Linux, BSD, but not Windows). You must have at # least 1 provider loaded to use the filter or R-line modules. # On POSIX-compliant systems, regex syntax can be found by using the # command: 'man 7 regex'. #<module name="regex_posix"> #-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-# # Regular Expression Provider for RE2 Regular Expressions. # You need libre2 installed and in your include/library paths in order # to compile and load this module. #<module name="regex_re2"> #-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-# # Regular expression provider for C++11 std::regex regular expressions. #<module name="regex_stdlib"> # # Specify the regular expression engine to use here. Valid settings are # bre, ere, awk, grep, egrep, ecmascript (default if not specified). #<stdregex type="ecmascript"> #-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-# # Remove module: Adds the /REMOVE command which is a peaceful # alternative to /KICK. #<module name="remove"> # # supportnokicks: If yes, /REMOVE is not allowed on channels where the # nokicks (+Q) mode is set. Defaults to no. # protectedrank: Members having this rank or above may not be /REMOVE'd # by anyone. Set to 0 to disable this feature. Defaults to 50000. #<remove supportnokicks="yes" protectedrank="50000"> #-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-# # Repeat module: Allows to block, kick or ban upon similar messages # being uttered several times. Provides channel mode +E. # # Syntax: [~|*]<lines>:<duration>[:<difference>][:<backlog>] # ~ is to block, * is to ban, default is kick. # lines - In mode 1, the amount of lines that has to match consecutively. # In mode 2, the size of the backlog to keep for matching. # seconds - How old the message has to be before it's invalidated. # difference - Edit distance, in percent, between two strings to trigger on. # backlog - When set, the function goes into mode 2. In this mode the # function will trigger if this many of the last <lines> matches. # # As this module can be rather CPU-intensive, it comes with some options. # maxbacklog - Maximum size that can be specified for backlog. 0 disables # multiline matching. # maxdistance - Max percentage of difference between two lines we'll allow # to match. Set to 0 to disable edit-distance matching. # maxlines - Max lines of backlog to match against. # maxtime - Maximum period of time a user can set. 0 to allow any. # size - Maximum number of characters to check for, can be used to # truncate messages before they are checked, resulting in # less CPU usage. Increasing this beyond 512 doesn't have # any effect, as the maximum length of a message on IRC # cannot exceed that. # kickmessage - Kick message when * is specified #<repeat maxbacklog="20" # maxdistance="50" # maxlines="20" # maxtime="0s" # size="512" # extended="yes" # message="Repeat flood detected (trigger is %lines% messages in %duration%)"> #<module name="repeat"> #-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-# # Restricted channels module: Allows only opers with the # channels/restricted-create priv and/or registered users to # create channels. # # You probably *DO NOT* want to load this module on a public network. # #<module name="restrictchans"> # # allowregistered: should registered users be allowed to bypass the restrictions? #<restrictchans allowregistered="no"> # # Allow any channel matching #user-* to be created, bypassing restrictchans checks #<allowchannel name="#user-*"> #-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-# # Restrict message module: Allows users to only message opers. # # You probably *DO NOT* want to load this module on a public network. # #<module name="restrictmsg"> #-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-# # R-line module: Ban users through regular expression patterns. #<module name="rline"> # #-#-#-#-#-#-#-#-#-#-#-#- RLINE CONFIGURATION -#-#-#-#-#-#-#-#-#-#-#-#-# # # If you wish to re-check a user when they change nickname (can be # useful under some situations, but *can* also use CPU with more users # on a server) then set 'matchonnickchange' to yes. # If you additionally want Z-lines to be added on matches, then # set 'zlineonmatch' to yes. # Also, this is where you set what Regular Expression engine is to be # used. If you ever change it while running, all of your R-lines will # be wiped. This is the regex engine used by all R-lines set, and # regex_<engine> must be loaded, or rline will be non-functional # until you load it or change the engine to one that is loaded. # #<rline matchonnickchange="yes" zlineonmatch="no" engine="stdregex"> # # Generally, you will NOT want to use 'glob' here, as this turns an # R-line into just another G-line. The exceptions are that R-lines will # always use the full "nick!user@host realname" string, rather than only # user@host, but beware that only the ? and * wildcards are available, # and are the only way to specify where the space can occur if you do # use glob. For this reason, is recommended to use a real regex engine # so that at least \s or [[:space:]] is available. #-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-# # RMODE module: Adds the /RMODE command. # Allows channel operators to remove list modes en masse, optionally # matching a glob-based pattern. # Syntax: /RMODE <channel> <mode> [<pattern>] # E.g. '/RMODE #channel b m:*' will remove all mute extbans on the channel. #<module name="rmode"> #-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-# # SAJOIN module: Adds the /SAJOIN command which forcibly joins a user # to the given channel. # This module is oper-only. # To use, SAJOIN must be in one of your oper class blocks. # Opers need the users/sajoin-others priv to be able to /SAJOIN users # other than themselves. #<module name="sajoin"> #-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-# # SAKICK module: Adds the /SAKICK command which kicks a user from the # given channel. # This module is oper-only. # To use, SAKICK must be in one of your oper class blocks. #<module name="sakick"> #-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-# # SAMODE module: Adds the /SAMODE command which allows server operators # to change modes on a channel without requiring them to have any # channel privileges. Also allows changing user modes for any user. # This module is oper-only. # To use, SAMODE must be in one of your oper class blocks. #<module name="samode"> #-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-# # SANICK module: Adds the /SANICK command which allows opers to change # users' nicks. # This module is oper-only. # To use, SANICK must be in one of your oper class blocks. #<module name="sanick"> #-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-# # SAPART module: Adds the /SAPART command which forcibly parts a user # from a channel. # This module is oper-only. # To use, SAPART must be in one of your oper class blocks. #<module name="sapart"> #-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-# # SAQUIT module: Adds the /SAQUIT command which forcibly quits a user. # This module is oper-only. # To use, SAQUIT must be in one of your oper class blocks. #<module name="saquit"> #-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-# # SASL authentication module: Provides support for IRC Authentication # Layer via AUTHENTICATE. Note: You also need to have cap loaded # for SASL to work. #<module name="sasl"> # You must define <sasl:target> to the name of your services server so # that InspIRCd knows where to send SASL authentication messages and # when it should enable the SASL capability. # You can also define <sasl:requiressl> to require users to use TLS # in order to be able to use SASL. #<sasl target="services.mynetwork.com" # requiressl="yes"> #-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-# # SATOPIC module: Adds the /SATOPIC command which allows changing the # topic on a channel without requiring any channel privileges. # This module is oper-only. # To use, SATOPIC must be in one of your oper class blocks. #<module name="satopic"> #-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-# # Secure list module: Prevent users from using the /LIST command until # a predefined period has passed. This helps protect your network from # spambots. #<module name="securelist"> # #-#-#-#-#-#-#-#-#-# SECURELIST CONFIGURATION -#-#-#-#-#-#-#-#-#-#-#-#-# # # # Securelist can be harmful to some IRC search engines. To prevent # # securelist blocking these sites from listing, define exception tags # # as shown below: # #<securehost exception="*@*.netsplit.de"> # # # exemptregistered - Whether the waiting period applies to users who # # are logged in to a user account. # # Defaults to no. # # # # fakechans - The number of fake channels to show in /LIST. This can # # be used to break spambots. # # # # fakechanprefix - The prefix for the fake channels. A random suffix # # will be appended to this when generating channels. # # # # fakechantopic - The topic for the fake channels. A random format # # modifier will be inserted into this for randomness. # # # # hidesmallchans - The minimum user count for a channel to show up in # # /LIST after the wait period (see below). If a user # # is exempt from the wait period this will not apply # # to them. # # # # showmsg - Whether to tell users that they need to wait for a while # # before they can use the /LIST command. # # Defaults to no. # # # # waittime - The time period that a user must be connected for before # # they can use the /LIST command. If exemptregistered is # # enabled you can set this to 0 to disable unauthenticated # # users from viewing the channel list. # # Defaults to 1 minute. # # # #<securelist exemptregistered="yes" # fakechans="5" # fakechanprefix="#spam" # fakechantopic="Fake channel for confusing spambots" # hidesmallchans="0" # showmsg="yes" # waittime="1m"> #-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-# # See nicks module: Adds snomask +n and +N which show local and remote # nick changes. # This module is oper-only. #<module name="seenicks"> #-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-# # Serverban: Implements extended ban 's', which stops anyone connected # to a server matching a mask like +b s:server.mask.here from joining. # Wildcards are accepted. #<module name="serverban"> #-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-# # Services integration module: Adds various features which enable # integrating with a third-party services pseudoserver like Anope or # Atheme. #<module name="services"> # #-#-#-#-#-#-#-#-#-#-#-#- SERVICES CONFIGURATION -#-#-#-#-#-#-#-#-#-#-# # # # accountoverrideshold - Whether to allow users that are logged in # # to an account that has a services-held nick # # in their group to override the SVSHOLD. # # Defaults to no. # # # # disablemodes - Whether channel mode `r` (registered) and # # user mode `r` (u_registered) are disabled. # # These modes are deprecated in InspIRCd v4 # # but may still be needed by older services # # software. Anope 2.1 is known to work with # # this enabled. Defaults to no. # # # #-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-# # # <servicesintegration accountoverrideshold="yes" # disablemodes="no"> #-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-# # Sethost module: Adds the /SETHOST command. # This module is oper-only. # To use, SETHOST must be in one of your oper class blocks. # See the chghost module for how to customise valid chars for hostnames. #<module name="sethost"> #-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-# # Setident module: Adds the /SETIDENT command. # This module is oper-only. # To use, SETIDENT must be in one of your oper class blocks. #<module name="setident"> #-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-# # Set idle module: Adds a command for opers to change their idle time. # This module is oper-only. # To use, SETIDLE must be in one of your oper class blocks. #<module name="setidle"> #-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-# # SETNAME module: Adds the /SETNAME command. #<module name="setname"> # #-#-#-#-#-#-#-#-#-#-#-#- SETNAME CONFIGURATION -#-#-#-#-#-#-#-#-#-#-#-# # # # operonly - Whether the SETNAME command should only be usable by # # server operators. Defaults to no. # # # # notifyopers - Whether to send a snotice to snomask `a` when a user # # changes their real name. Defaults to to yes if # # oper-only and no if usable by everyone. # # # #<setname notifyopers="yes" # operonly="no"> #-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-# # SHA1 module: Allows other modules to generate SHA1 hashes. # Required by the WebSocket module. #<module name="sha1"> #-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-# # SHA2 module: Allows other modules to generate SHA2 hashes, # usually for cryptographic uses and security. # # IMPORTANT: # Other modules such as password_hash may rely on this module being # loaded to function. Certain modules such as spanningtree will # function without this module but when it is loaded their features will # be enhanced (for example the addition of HMAC authentication). # #<module name="sha2"> #-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-# # Showfile: Provides support for showing a text file to users when # # they enter a command. # # This module adds one command for each <showfile> tag that shows the # # given file to the user as a series of messages or numerics. # #<module name="showfile"> # # #-#-#-#-#-#-#-#-#-#-# SHOWFILE CONFIGURATION -#-#-#-#-#-#-#-#-#-#-#-#-# # # # name - The name of the command which displays this file. This is # # the only mandatory setting, all others are optional. # # file - The text file to be shown to the user. # # By default same as the command name. # # method - How should the file be shown? # # * numeric: Send contents using a numeric # # (similar to /MOTD; the default). # # * notice: Send contents as a series of notices. # # * msg: Send contents as a series of private messages. # # # # When using the method "numeric", the following extra settings are # # available: # # # # introtext - Introductory line, "Showing <name>" by default. # # intronumeric - Numeric used for the introductory line. # # numeric - Numeric used for sending the text itself. # # endtext - Ending line, "End of <name>" by default. # # endnumeric - Numeric used for the ending line. # # # #<showfile name="RULES" # file="rules.txt" # introtext="Server rules:" # endtext="End of server rules."> #-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-# # Show whois module: Adds the +W user mode which allows opers to see # when they are /WHOIS'd. # This module is oper-only by default. #<module name="showwhois"> # # If you wish, you may also let users set this mode. #<showwhois opersonly="yes"> #-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-# # Shun module: Provides the /SHUN command, which stops a user from # executing all except configured commands. # This module is oper-only. # To use, SHUN must be in one of your oper class blocks. #<module name="shun"> # # Configuration: # # allowconnect: Whether to only apply shuns to users who are fully # connected to the server. # # allowtags: Whether to allow client tags to be attached to enabled # commands. # # cleanedcommands: The commands that, if enabled, should be cleaned # of any message content if a shunned user tries to # execute them. # # enabledcommands: The commands that a shunned user is allowed to # execute. # # notifyuser: Whether to notify shunned users that a command they tried # to execute has been blocked. # #<shun enabledcommands="ADMIN OPER PING PONG QUIT PART JOIN" # cleanedcommands="AWAY PART QUIT" # allowconnect="no" # allowtags="no" # notifyuser="yes"> #-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-# # Silence module: Adds support for the /SILENCE command, which allows # users to have a server-side ignore list for their client. #<module name="silence"> # # Set the maximum number of entries allowed on a user's silence list. #<silence maxentries="32" # # Whether messages from services servers will bypass silence masks. #exemptservice="yes"> #-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-# # ____ _ _____ _ _ ____ _ _ _ # # | _ \ ___ __ _ __| | |_ _| |__ (_)___ | __ )(_) |_| | # # | |_) / _ \/ _` |/ _` | | | | '_ \| / __| | _ \| | __| | # # | _ < __/ (_| | (_| | | | | | | | \__ \ | |_) | | |_|_| # # |_| \_\___|\__,_|\__,_| |_| |_| |_|_|___/ |____/|_|\__(_) # # # # To link servers to InspIRCd, you MUST load the spanningtree module. # # If you don't do this, server links will NOT work at all. # # This is by design, to allow for the implementation of other linking # # protocols in modules in the future. # #-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-# # Spanning tree module: Allows linking of servers using the spanning # tree protocol (see the READ THIS BIT section above). # You will almost always want to load this. # #<module name="spanningtree"> # # This file has all the information about server links and services servers. # You *MUST* edit it if you intend to link servers. #<include file="&dir.example;/links.example.conf"> #-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-# # SQL authentication module: Allows IRCd connections to be tied into # a database table (for example a forum). # #<module name="sqlauth"> # #-#-#-#-#-#-#-#-#-#-#- SQLAUTH CONFIGURATION -#-#-#-#-#-#-#-#-#-#-#-# # # # sqlauth is too complex to describe here, see the docs: # # https://docs.inspircd.org/4/modules/sqlauth # #-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-# # SQLite3 module: Allows other SQL modules to access SQLite3 # # databases through a unified API. # # # # This module depends on a third-party library (SQLite) and may need # # to be manually enabled at build time. If you are building from # # source you can do this by installing this dependency and running: # # # # ./configure --enable-extras sqlite3 # # make install # # # # Users of binary packages should consult the documentation for their # # package to find out whether this module is available. # #<module name="sqlite3"> # #-#-#-#-#-#-#-#-#-#-#-#- SQL CONFIGURATION -#-#-#-#-#-#-#-#-#-#-#-#-# # # # sqlite is more complex than described here, see the docs for more # # info: https://docs.inspircd.org/4/modules/sqlite3 # # #<database module="sqlite" hostname="/full/path/to/database.db" id="anytext"> #-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-# # SQL oper module: Allows you to store oper credentials in an SQL # table. You can add additional table columns like you would config # tags in opers.conf. Opers in opers.conf will override opers from # this module. # #<module name="sqloper"> # #-#-#-#-#-#-#-#-#-#-#- SQLOPER CONFIGURATION -#-#-#-#-#-#-#-#-#-#-#-# # # # dbid - Database ID to use (see SQL modules). # # # # See also: https://docs.inspircd.org/4/modules/sqloper # # # #<sqloper dbid="1"> #-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-# # GnuTLS TLS module: Adds support for TLS connections using GnuTLS, # if enabled. You must answer 'yes' in ./configure when asked or # manually symlink the source for this module from the directory # src/modules/extra, if you want to enable this, or it will not load. #<module name="ssl_gnutls"> # #-#-#-#-#-#-#-#-#-#-#- GNUTLS CONFIGURATION -#-#-#-#-#-#-#-#-#-#-#-# # # # ssl_gnutls is too complex to describe here, see the docs: # # https://docs.inspircd.org/4/modules/ssl_gnutls # #-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-# # OpenSSL TLS module: Adds support for TLS connections using OpenSSL, # if enabled. You must answer 'yes' in ./configure when asked or symlink # the source for this module from the directory src/modules/extra, if # you want to enable this, or it will not load. #<module name="ssl_openssl"> # #-#-#-#-#-#-#-#-#-#-#- OPENSSL CONFIGURATION -#-#-#-#-#-#-#-#-#-#-#-# # # # ssl_openssl is too complex to describe here, see the docs: # # https://docs.inspircd.org/4/modules/ssl_openssl # #-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-# # TLS info module: Allows users to retrieve information about other # users' peer TLS certificates and keys via the SSLINFO command. # This can be used by client scripts to validate users. For this to # work either ssl_gnutls or ssl_openssl must be loaded. # This module also adds the "<user> is using a secure connection" # and "<user> has TLS client certificate fingerprint <fingerprint>" # WHOIS lines, the ability for opers to use TLS cert fingerprints to # verify their identity and the ability to force opers to use TLS # connections in order to oper up. It is highly recommended to load # this module if you use TLS on your network. # For how to use the oper features, please see the first # example <oper> tag in opers.example.conf. # #<module name="sslinfo"> # #-#-#-#-#-#-#-#-#-#-#-#- SSLINFO CONFIGURATION -#-#-#-#-#-#-#-#-#-#-#-# # # # hash - The IANA Hash Function Name of the hash algorithm # # used for the TLS client fingerprint of WebIRC # # gateway users (requires the gateway module). This # # should be the same algorithm you specified in the # # <sslprofile:hash> field of the TLS profile used for # # user connections. You can prefix the algorithm name # # with spki- to use a Subject Public Key Info (SPKI) # # fingerprint instead of a certificate fingerprint. # # # # localsecure - Whether to treat locally-connected plaintext users # # as if they are connected with TLS. Defaults to yes. # # # # operonly - Whether TLS client certificate info is only visible # # by server operators. Defaults to no. # # # # warnexpiring - If specified then the maximum period of validity # # that can be left on a user's TLS client certificate # # before users are warned about the imminent expiry. # # # # welcomemsg - Whether to send a welcome message to users that are # # connecting using TLS containing their server name, # # ciphersuite and client fingerprint. Defaults to no. # # # #-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-# # #<sslinfo hash="sha-256" # localsecure="yes" # operonly="no" # warnexpiring="1w" # welcomemsg="no"> #-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-# # TLS mode module: Adds support for TLS-only channels via the '+z' # channel mode, TLS-only private messages via the '+z' user mode and # the 'z:' extban which matches TLS client certificate fingerprints. # # Does not do anything useful without a working TLS module and the # sslinfo module (see below). #<module name="sslmodes"> #-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-# # TLS rehash signal module: Allows the TLS modules to be rehashed by # sending SIGUSR1 to a running InspIRCd process. # # This module depends on a POSIX component (SIGUSR1) and may need to be # manually enabled at build time. If you are building from source you # can do this by running: # # ./configure --enable-extras sslrehashsignal # make install # # Users of binary packages should consult the documentation for their # package to find out whether this module is available. #<module name="sslrehashsignal"> #-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-# # StartTLS module: Adds support for the IRCv3 tls capability which # # allows clients to upgrade their connection to use TLS. As well as # # this module you should also load one of ssl_gnutls or ssl_openssl # # modules. You may also want to consider using the ircv3_sts module. # #<module name="starttls"> #-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-# # Strip color module: Adds channel mode +S that strips IRC formatting # characters from all messages sent to the channel. #<module name="stripcolor"> #-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-# # SWHOIS module: Allows you to add arbitrary lines to user WHOIS. # This module is oper-only. # To use, SWHOIS must be in one of your oper class blocks. #<module name="swhois"> #-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-# # Timed bans module: Adds timed channel bans with the /TBAN command. #<module name="timedbans"> # By default, it sends a notice to channel operators when timed ban is # set and when it is removed by server. #<timedbans sendnotice="yes"> #-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-# # Test line module: Adds the /TLINE command, used to test how many # users a /GLINE or /ZLINE etc. would match. # This module is oper-only. # To use, TLINE must be in one of your oper class blocks. #<module name="tline"> #-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-# # UHNAMES support module: Adds support for the IRCv3 userhost-in-names # capability which displays the username and hostname of users in the # NAMES response. #<module name="uhnames"> #-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-# # Uninvite module: Adds the /UNINVITE command which lets users remove # pending invites from channels without waiting for the user to join. #<module name="uninvite"> #-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-# # Vhost module: Adds the VHOST command which allows for adding virtual # hosts which are accessible using a username and password in the config. #<module name="vhost"> # #-#-#-#-#-#-#-#-#-#-#- VHOST CONFIGURATION -#-#-#-#-#-#-#-#-#-#-#-#-# # # # user - Username for the vhost. # # # # pass - Password for the vhost. # # # # hash - The hash for the specific user (optional) # # password_hash and a hashing module must be loaded for # # this to work. # # # # host - Vhost to set. # # #<vhost user="some_username" pass="some_password" host="some.host.test.cc"> #<vhost user="foo" password="$2a$10$iTuYLT6BRhRlOgzfsW9oPe62etW.oXwSpyKw5rJit64SGZanLXghO" hash="bcrypt" host="some.other.host.example.com"> #-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-# # Watch module: Adds the WATCH command, which is used by clients to # maintain notify lists. #<module name="watch"> # # Set the maximum number of entries on a user's watch list below. #<watch maxwatch="32"> #-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-# # WebSocket module: Adds WebSocket support. # Specify hook="websocket" in a <bind> tag to make that port accept # WebSocket connections. Compatible with TLS. # Requires SHA-1 hash support available in the sha1 module. #<module name="websocket"> # # defaultmode: The default frame mode if a client does not send a # WebSocket subprotocol. Potential values are "text" to # encode messages as UTF-8 text frames, "binary" to send # messages as raw binary frames, or "reject" to close # connections which do not request a subprotocol. Defaults # to "text". # # proxyranges: A space-delimited list of glob or CIDR matches to trust # the X-Real-IP or X-Forwarded-For headers from. If enabled # the server will use the IP address specified by those HTTP # headers. You should NOT enable this unless you are using # a HTTP proxy like nginx as it will allow IP spoofing. # # allowmissingorigin: Whether to allow connections from clients that # don't send an origin header. These are probably # not web clients so it probably safe to allow this. # Defaults to yes. # # nativeping: Whether to check client connectivity using WebSocket ping # messages instead of IRC ping messages. Defaults to yes. # #<websocket defaultmode="text" # proxyranges="192.0.2.0/24 198.51.100.*" # allowmissingorigin="yes" # nativeping="yes"> # # If you use the websocket module you MUST specify one or more origins # which are allowed to connect to the server. You should set this as # strict as possible to prevent malicious webpages from connecting to # your server. # <wsorigin allow="https://*.example.com"> #-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-# # X-line database: Stores all *-lines (G/Z/K/R/any added by other modules) # in a file which is re-loaded on restart. This is useful # for two reasons: it keeps bans so users may not evade them, and on # bigger networks, server connections will take less time as there will # be a lot less bans to apply - as most of them will already be there. #<module name="xline_db"> # Specify the filename for the xline database and how often to check whether # the database needs to be saved here. #<xlinedb filename="xline.db" # saveperiod="5s" # backoff="2" # maxbackoff="5m"> �����������������������������������������������������������������������inspircd-4.7.0/docs/conf/motd.example.txt�����������������������������������������������������������0000664�0000000�0000000�00000003266�14771603147�0020371�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������ _____ _____ _____ _____ _ |_ _| |_ _| | __ \ / ____| | | | | _ __ ___ _ __ | | | |__) || | __| | | | | '_ \ / __| | '_ \ | | | _ / | | / _` | _| |_ | | | | \__ \ | |_) | _| |_ | | \ \ | |____ | (_| | |_____| |_| |_| |___/ | .__/ |_____| |_| \_\ \_____| \__,_| _____________________| |__________________________________ |_____________________|_|__________________________________| \iThe IRC server for the 31st century\x /\ /\ { `---' } \bWELCOME TO AN \c13I\c04N\c07S\c08P\c03I\c10R\c12C\c06D\c99 NETWORK\x { O O } ~~> V <~~ If you see this, I'm probably new. \ \|/ / If I'm not new, my owner is lazy. ;-) `-----'____ / \ \_ { }\ )_\_ _ | \_/ |/ / \_\_/ ) \__/ /(_/ \__/ (__/ +---- To change this see \bmotd.example.txt\x ----+ | | | * \bWeb:\x https://www.inspircd.org | | * \bIRC:\x ircs://irc.teranova.net/inspircd | | * \bDocs:\x https://docs.inspircd.org | | * \bIssues:\x https://git.io/JIuYi | | * \bDiscussions:\x https://git.io/JIuYv | | | | We hope you like this software. Please do | | make sure to customise your configuration, | | though, so you love it. Enjoy. | | | | -- The InspIRCd Team | +---------------------------------------------+ ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/docs/conf/opermotd.example.txt�������������������������������������������������������0000664�0000000�0000000�00000003266�14771603147�0021257�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������ _____ _____ _____ _____ _ |_ _| |_ _| | __ \ / ____| | | | | _ __ ___ _ __ | | | |__) || | __| | | | | '_ \ / __| | '_ \ | | | _ / | | / _` | _| |_ | | | | \__ \ | |_) | _| |_ | | \ \ | |____ | (_| | |_____| |_| |_| |___/ | .__/ |_____| |_| \_\ \_____| \__,_| _____________________| |__________________________________ |_____________________|_|__________________________________| \iThe IRC server for the 31st century\x /\ /\ { `---' } \bWELCOME TO AN \c13I\c04N\c07S\c08P\c03I\c10R\c12C\c06D\c99 NETWORK\x { O O } ~~> V <~~ If you see this, I'm probably new. \ \|/ / If I'm not new, my owner is lazy. ;-) `-----'____ / \ \_ { }\ )_\_ _ | \_/ |/ / \_\_/ ) \__/ /(_/ \__/ (__/ +-- To change this see \bopermotd.example.txt\x --+ | | | * \bWeb:\x https://www.inspircd.org | | * \bIRC:\x ircs://irc.teranova.net/inspircd | | * \bDocs:\x https://docs.inspircd.org | | * \bIssues:\x https://git.io/JIuYi | | * \bDiscussions:\x https://git.io/JIuYv | | | | We hope you like this software. Please do | | make sure to customise your configuration, | | though, so you love it. Enjoy. | | | | -- The InspIRCd Team | +---------------------------------------------+ ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/docs/conf/opers.example.conf���������������������������������������������������������0000664�0000000�0000000�00000031060�14771603147�0020655�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������#-#-#-#-#-#-#-#-#-#-#-#-# CLASS CONFIGURATION #-#-#-#-#-#-#-#-#-#-#-# # # # Classes are a group of commands which are grouped together and # # given a unique name. They're used to define which commands # # are available to certain types of Operators. # # # # # # Note: It is possible to make a class which covers all available # # commands. To do this, specify commands="*". This is not really # # recommended, as it negates the whole purpose of the class system, # # however it is provided for fast configuration (e.g. in test nets). # # # <class name="Shutdown" # commands: Oper-only commands that opers of this class can run. commands="DIE RESTART REHASH LOADMODULE UNLOADMODULE RELOADMODULE GLOADMODULE GUNLOADMODULE GRELOADMODULE" # privs: Special privileges that users with this class may utilise. # VIEWING: # - channels/auspex: allows opers with this priv to see more details about channels than normal users. # - users/auspex: allows opers with this priv to view more details about users than normal users, e.g. real host and IP. # - users/channel-spy: allows opers with this priv to view the private/secret channels that a user is on. # - servers/auspex: allows opers with this priv to see more details about server information than normal users. # ACTIONS: # - users/mass-message: allows opers with this priv to PRIVMSG and NOTICE to a server mask (e.g. NOTICE $*). # - users/samode-usermodes: allows opers with this priv to change the user modes of any other user using /SAMODE. # PERMISSIONS: # - channels/ignore-chanfilter: allows opers with this priv to be immune to channel filters. # - channels/ignore-delaymsg: allows opers with this priv to be immune to delaymsg restriction on a +d channel. # - channels/ignore-noctcp: allows opers with this priv to send a CTCP to a +C channel. # - channels/ignore-nonicks: allows opers with this priv to change their nick when on a +N channel. # - channels/ignore-opmoderated: allows opers with this priv to ignore +U. # - channels/ignore-repeat: allows opers with this priv to be immune to repeat punishment on a +E channel. # - channels/restricted-create: allows opers with this priv to create channels if the restrictchans module is loaded. # - users/flood/increased-buffers: allows opers with this priv to send and receive data without worrying about being disconnected for exceeding limits (*NOTE). # - users/flood/no-fakelag: prevents opers from being penalized with fake lag for flooding (*NOTE). # - users/flood/no-throttle: allows opers with this priv to send commands without being throttled (*NOTE). # - users/ignore-callerid: allows opers with this priv to message people using callerid without being on their callerid list. # - users/ignore-commonchans: allows opers with this priv to send a message to a +c user without sharing common channels. # - users/ignore-noctcp: allows opers with this priv to send a CTCP to a +T user. # - users/ignore-privdeaf: allows opers with this priv to message users with +D set. # - users/sajoin-others: allows opers with this priv to /SAJOIN users other than themselves. # - users/secret-whois: allows opers with this priv to /WHOIS +W users without them being notified. # servers/ignore-blockamsg: allows opers with this priv to use /AMSG and /AME. # - servers/ignore-shun: allows opers with this priv to ignore shuns. # - servers/ignore-securelist: allows opers with this priv to ignore securelist. # - servers/use-disabled-commands: allows opers with this priv to use disabled commands. # - servers/use-disabled-modes: allows opers with this priv to use disabled modes. # # *NOTE: These privs are potentially dangerous, as they grant users with them the ability to hammer your server's CPU/RAM as much as they want, essentially. privs="users/auspex channels/auspex servers/auspex users/mass-message users/flood/no-throttle users/flood/increased-buffers" # usermodes: Oper-only user modes that opers with this class can use. usermodes="*" # chanmodes: Oper-only channel modes that opers with this class can use. chanmodes="*" # snomasks: The snomasks that opers with this class can use. snomasks="*"> <class name="SACommands" commands="SAJOIN SAPART SANICK SAQUIT SATOPIC SAKICK SAMODE OJOIN"> <class name="ServerLink" commands="CONNECT SQUIT RCONNECT RSQUIT MKPASSWD ALLTIME SWHOIS" usermodes="*" chanmodes="*" privs="servers/auspex" snomasks="Cc"> <class name="BanControl" commands="KILL GLINE KLINE ZLINE QLINE ELINE TLINE RLINE CHECK NICKLOCK NICKUNLOCK SHUN CBAN" usermodes="*" chanmodes="*" snomasks="Xx"> <class name="OperChat" commands="WALLOPS GLOBOPS" usermodes="*" chanmodes="*" privs="users/mass-message" snomasks="Gg"> <class name="HostCloak" commands="SETHOST SETIDENT SETIDLE CHGNAME CHGHOST CHGIDENT" usermodes="*" chanmodes="*" privs="users/auspex"> #-#-#-#-#-#-#-#-#-#-#-#- OPERATOR COMPOSITION -#-#-#-#-#-#-#-#-#-#-# # # # This is where you specify which types of operators you have on # # your server, as well as the commands they are allowed to use. # # This works alongside with the classes specified above. # # # <type # name: Name of the type. Used in actual server operator accounts below. name="NetAdmin" # classes: Classes (blocks above) that this type belongs to. classes="SACommands OperChat BanControl HostCloak Shutdown ServerLink" # vhost: Host that opers of this type get when they log in (oper up). This is optional. vhost="netadmin.omega.example.org" # maxchans: Maximum number of channels opers of this type can be in at once. maxchans="60" # motd: The server operator MOTD that this should be shown to this # operator type. This can be viewed with /OPERMOTD or automatically # on login if automotd (see below) is enabled. # Requires the opermotd module to be loaded. motd="&dir.example;/opermotd.example.txt" # automotd: Whether to send the server operator MOTD (see above) # to operators of this type when they log in. # Requires the opermotd module to be loaded. automotd="yes" # modes: User modes besides +o that are set on an oper of this type # when they oper up. Used for snomasks and other things. # Requires the opermodes module to be loaded. modes="+s +cCqQ"> <type name="GlobalOp" classes="SACommands OperChat BanControl HostCloak ServerLink" vhost="serverop.omega.example.org"> <type name="Helper" classes="HostCloak" vhost="helper.omega.example.org"> #-#-#-#-#-#-#-#-#-#-#- OPERATOR CONFIGURATION -#-#-#-#-#-#-#-#-#-#-# # # # Opers are defined here. This is a very important section. # # Remember to only make operators out of trustworthy people. # # # # Operator account with a plaintext password. <oper # name: Oper login that is used to oper up (/OPER <username> <password>). # Remember: This is case sensitive. name="Attila" # password: Case-sensitive, unhashed (plaintext). password="s3cret" # nopassword: Whether to allow logging into an account without a password. # # IMPORTANT: As this option overrides the password field it should **NOT** be used # unless you are certain that nobody other than the intended user will match the # restrictions of this <oper> block. Failure to do this may result in your server # being compromised. #nopassword="no" # host: What hostnames and IPs are allowed to use this operator account. # Multiple options can be separated by spaces and CIDRs are allowed. # You can use just * or *@* for this section, but it is not recommended # for security reasons. host="attila@inspircd.org *@2001:db8::/32" # account: A space delimited list of account names or account ids that are allowed # to log into this account. # Requires the account module. account="Attila 1234567890" # fingerprint: When using the sslinfo module, you may specify a space separated # list of TLS client certificate fingerprints here. These can be obtained by using # the /SSLINFO command while the module is loaded, and is also noticed on connect. # This enhances security by verifying that the person opering up has # a matching TLS client certificate, which is very difficult to # forge (impossible unless preimage attacks on the hash exist). # If the sslinfo module isn't loaded, this option will be ignored. #fingerprint="67cb9dc013248a829bb2171ed11becd4" # autologin: Whether to automatically log this server operator in on connect if all # of their details match the ones in this <oper> block. Can be set to "strict" to # automatically log in if the user's nickname matches the oper account name and the # account/host/sslonly/etc fields match, "relaxed" to automatically log in if the # account/host/sslonly/etc fields match, and "never" to not allow automatically # logging in to this oper account. Defaults to "never". # # IMPORTANT: As this option overrides the password field it should **NOT** be used # unless you are certain that nobody other than the intended user will match the # restrictions of this <oper> block. Failure to do this may result in your server # being compromised. #autologin="strict" # sslonly: If enabled, this oper can only oper up if they're using a TLS connection. # Setting this option adds a decent bit of security. Highly recommended # if the oper is on wifi, or specifically, unsecured wifi. Note that it # is redundant to specify this option if you specify a fingerprint. # This setting only takes effect if the sslinfo module is loaded. #sslonly="yes" # vhost: Overrides the vhost in the type block. Class and modes may also # be overridden. vhost="attila.example.org" # type: Which type of operator this person is; see the block # above for the list of types. NOTE: This is case-sensitive as well. type="NetAdmin"> # Operator with a plaintext password and no comments, for easy copy & paste. <oper name="Brain" password="youshouldhashthis" host="brain@dialup15.isp.test.com *@localhost *@example.com *@2001:db8::/32" #fingerprint="67cb9dc013248a829bb2171ed11becd4" type="NetAdmin"> # Operator with a hashed password. It is highly recommended to use hashed passwords. <oper # name: Oper login that is used to oper up (/OPER <username> <password>). # Remember: This is case sensitive. name="Adam" # hash: The hash function this password is hashed with. Requires the # module for the selected function (bcrypt, md5, sha1, or sha256) and # the password hashing module (password_hash) to be loaded. # # You may also use any of the above other than bcrypt prefixed with # either "hmac-" or "pbkdf2-hmac-" (requires the pbkdf2 module). # Create hashed passwords with: /MKPASSWD <hashtype> <plaintext>. hash="bcrypt" # password: A hash of the password (see above option) hashed # with /MKPASSWD <hashtype> <plaintext>. See the password_hash module # in modules.conf for more information about password hashing. password="qQmv3LcF$Qh63wzmtUqWp9OXnLwe7yv1GcBwHpq59k2a0UrY8xe0" # host: What hostnames and IPs are allowed to use this operator account. # Multiple options can be separated by spaces and CIDRs are allowed. # You can use just * or *@* for this section, but it is not recommended # for security reasons. host="*@127.0.0.1 *@192.0.2.40 *@198.51.100.4" # type: Which type of operator this person is; see the block # above for the list of types. NOTE: This is case-sensitive as well. type="Helper"> # Once you have edited this file you can remove this line. This is just to # ensure that you don't hastily include the file without reading it. <die reason="Using opers.example.conf without editing it is a security risk"> ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/docs/conf/providers/�����������������������������������������������������������������0000775�0000000�0000000�00000000000�14771603147�0017241�5����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/docs/conf/providers/dronebl.example.conf���������������������������������������������0000664�0000000�0000000�00000004511�14771603147�0023170�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������# This file contains configuration for using the dnsbl module with # the DroneBL DNSBL. See https://dronebl.org/ for more information on # DroneBL. <dnsbl name="DroneBL" domain="dnsbl.dronebl.org" type="record" records="3,5,6,7,8,9,10,11,13,14,15,16,17,19" action="zline" duration="7d" reason="You are listed in DroneBL: %reason%. Please visit https://dronebl.org/lookup?ip=%ip%&amp;network=%network.url% for more information."> <dnsblreply name="DroneBL" reply="1" description="Testing"> <dnsblreply name="DroneBL" reply="2" description="Sample data used for heuristical analysis"> <dnsblreply name="DroneBL" reply="3" description="IRC spam drone (litmus/sdbot/fyle)"> <dnsblreply name="DroneBL" reply="5" description="Bottler"> <dnsblreply name="DroneBL" reply="6" description="Unknown worm or spambot"> <dnsblreply name="DroneBL" reply="7" description="DDoS drone"> <dnsblreply name="DroneBL" reply="8" description="Open SOCKS proxy"> <dnsblreply name="DroneBL" reply="9" description="Open HTTP proxy"> <dnsblreply name="DroneBL" reply="10" description="Proxychain"> <dnsblreply name="DroneBL" reply="11" description="Webpage proxy"> <dnsblreply name="DroneBL" reply="12" description="Open DNS resolver"> <dnsblreply name="DroneBL" reply="13" description="Automated dictionary attack"> <dnsblreply name="DroneBL" reply="14" description="Open WINGATE proxy"> <dnsblreply name="DroneBL" reply="15" description="Compromised router / gateway"> <dnsblreply name="DroneBL" reply="16" description="Autorooting worm"> <dnsblreply name="DroneBL" reply="17" description="Automatically determined botnet IP"> <dnsblreply name="DroneBL" reply="18" description="Possibly compromised DNS/MX type hostname detected on IRC"> <dnsblreply name="DroneBL" reply="19" description="Abused VPN service"> <dnsblreply name="DroneBL" reply="255" description="Uncategorized threat"> ���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/docs/conf/providers/efnet-rbl.example.conf�������������������������������������������0000664�0000000�0000000�00000001623�14771603147�0023422�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������# This file contains configuration for using the dnsbl module with # the EFnet RBL. See https://rbl.efnetrbl.org/ for more information # on the EFnet RBL. <dnsbl name="EFnet RBL" domain="rbl.efnetrbl.org" type="record" records="1,2,3,4,5" action="zline" duration="7d" reason="You are listed in the EFnet RBL: %reason%. Please visit https://rbl.efnetrbl.org/?i=%ip% for more information."> <dnsblreply name="EFnet RBL" reply="1" description="Open proxy"> <dnsblreply name="EFnet RBL" reply="2" description="Spamtrap score of 666"> <dnsblreply name="EFnet RBL" reply="3" description="Spamtrap score of 50+"> <dnsblreply name="EFnet RBL" reply="4" description="Tor exit node"> <dnsblreply name="EFnet RBL" reply="5" description="Drones or flooding"> �������������������������������������������������������������������������������������������������������������inspircd-4.7.0/docs/conf/providers/irccloud.example.conf��������������������������������������������0000664�0000000�0000000�00000002237�14771603147�0023352�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������# This file contains connect classes which are used by IRCCloud users. # See https://www.irccloud.com for more information on IRCCloud and # https://www.irccloud.com/networks for more information on supporting # IRCCloud on your network. <connect name="IRCCloud" parent="main" globalmax="100" localmax="100" useconnectban="no" useconnflood="no" usednsbl="no"> <connect name="IRCCloud (IPv4)" parent="IRCCloud" allow="5.254.36.56/29 5.254.36.104/29" uniqueusername="yes"> # This is not typically needed as each user has their own IPv6 but if you have # <cidr:ipv6clone> set to a value lower than 128 you will need to enable it. #<connect name="IRCCloud (IPv6)" # parent="IRCCloud" # allow="2a03:5180:f::/62 2a03:5180:f:4::/63 2a03:5180:f:6::/64"> # IRCCloud IPv4 users use a shared IPv4 address which means that some clients # may have trouble banning them. To work around this you can use the cloak_user # module to copy the user identifier from the username to the hostname. #<cloak method="username" # class="IRCCloud (IPv4),IRCCloud (IPv6)" # suffix=".irccloud.com"> �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/docs/conf/providers/torexit.example.conf���������������������������������������������0000664�0000000�0000000�00000001147�14771603147�0023243�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������# This file contains configuration for using the dnsbl module with # the dan.me.uk Tor exit node DNSBL. See https://www.dan.me.uk/dnsbl # for more information on the dan.me.uk Tor exit node DNSBL. <dnsbl name="torexit.dan.me.uk" domain="torexit.dan.me.uk" type="record" records="100" timeout="10s" action="zline" duration="7d" reason="Tor exit nodes are not allowed on this network. See https://metrics.torproject.org/rs.html#search/%ip% for more information."> <dnsblreply name="torexit.dan.me.uk" reply="100" description="Tor exit node"> �������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/docs/conf/quotes.example.txt���������������������������������������������������������0000664�0000000�0000000�00000027530�14771603147�0020746�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������Men are from Mars. Women are from Venus. Computers are from hell Computer /nm./: a device designed to speed and automate errors Hardware /nm./: the part of the computer that you can kick. Maniac /n./ An early computer built by nuts. RAM /abr./: Rarely Adequate Memory. Programmer /n./ A red-eyed, mumbling mammal capable of conversing with inanimate objects Multitasking /adj./ 3 PCs and a chair with wheels Plonk /excl./: The sound a newbie makes as he falls to the bottom of a kill file hURL /n./: a link to a web site that makes you want to puke SUPERCOMPUTER: what it sounded like before you bought it. If it's really a supercomputer, how come the bullets don't bounce off when I shoot it? . The Covert Comic. A computer is like an Old Testament god, with a lot of rules and no mercy. . Joseph Campbell I dropped my computer on my foot! That Megahurtz!! A computer's attention span is as long as it's power cord 586: The average IQ needed to understand a PC Memory is like an orgasm. It's a lot better if you don't have to fake it If it jams, force it. If it breaks, it needed replacing anyway. A bus station is where a bus stops. A train station is where a train stops. On my desk I have a workstation.. Want to come see my HARD DRIVE ? I promise it isn't 3.5 inches and it ain't floppy. . Geek pick-up line. If you torture the data enough, it will confess. . Ronald Coase If you give someone a program, you will frustrate them for a day; if you teach them how to program, you will frustrate them for a lifetime ASCII stupid question, get a stupid ANSI! Use the source, Luke... Programming is an art form that fights back MacOS, Windows, BeOS: they're all just Xerox copies Whenever you think you have a clever programming trick... forget it! Managing senior programmers is like herding cats. . Dave Platt Your program is sick ! Shoot it and put it out of its memory /* You are not expected to understand this */ To define recursion, we must first define recursion ERROR: Computer possessed; Load EXOR.SYS ? [Y/N] Linux is only free if your time is worthless Linux: find out what you've been missing while you've been rebooting Windows NT unzip; strip; touch; finger; mount; fsck; more; yes; unmount; sleep Profanity is the one language all programmers know best It's 5.50 a.m.... Do you know where your stack pointer is? #define QUESTION ((bb) || !(bb)) . Shakespeare The more I C, the less I see. Confucius say: He who play in root, eventually kill tree. Unix is the answer, but only if you phrase the question very carefully C++: Hard to learn and built to stay that way Java is, in many ways, C++-- . Michael Feldman. They don't make bugs like Bunny anymore . Olav Mjelde If debugging is the process of removing software bugs, then programming must be the process of putting them in When the only tool you own is a hammer, every problem you encounter resembles a nail System Error: press F13 to continue... To err is human, but for a real disaster you need a computer Computers make very fast, very accurate mistakes Life would be so much easier if we only had the source code Who is this 'General Failure' and why is he reading my disk? hAS aNYONE sEEN MY cAPSLOCK kEY? InspIRCd, now with excessive amounts of Cheeze I'm in the computer business, I make Out-Of-Order signs Kevorkian Virus: helps your computer shut down whenever it wants to. [OUT OF QUOTES, PLEASE ORDER MORE] Insert Something Funkeh.. err.. There! --> Cannot delete tmp150---3.tmp: There is not enough free disk space. Delete one or more files to free disk space, and then try again File not found. Should I fake it ? (Y/N) The definition of an upgrade: Take old bugs out, put new ones in If it's not on fire, it's a software problem It's a little-known fact that the Y1K problem caused the Dark Ages Artificial Intelligence usually beats natural stupidity Making fun of AOL users is like making fun of the kid in the wheel chair Daddy, why doesn't this magnet pick up this floppy disk? Daddy, what does FORMATTING DRIVE C mean? See daddy ? All the keys are in alphabetical order now. Enter any 11-digit prime number to continue... ASCII and ye shall receive. The web is a dominatrix. Every where I turn, I see little buttons ordering me to Submit. <FrostyCoolSlug> NO, You cannot dial 999, I'm downloading my mail ;/ 640K ought to be enough for anybody. . Bill Gates, 1981 Windows not found, [P]arty, [C]elebrate, [D]rink? English, the Microsoft of languages... It's been said that Bill Gates named his company after his dick... Ever notice how fast Windows runs ? -- Neither did I If at first you don't succeed, work for Microsoft We are Microsoft. Resistance Is Futile. You Will Be Assimilated "Microsoft Works." . Oxymoron Windows isn't a virus, viruses do something PANIC! buffer = :NickServ WRITE_DB(3). <-- JUST KIDDING! It just keeps going and going and going and going and goi <BANG> All that I know is that nukes are coming from 127.0.0.1 I know all about the irc and the mirc cops. M re ink n ed d, ple s r fil Please refrain from feeding the server operators. Thank you. I know all about mirc stuff, hmm.. I think this channel is experiencing packet loss.. MacDonalds claims Macintosh stole their next idea of the iMac I can't hold her any longer, captain, she's gonna bl.. sorry, got caught up in the moment I recommend purchasing a Cyrix CPU for testing nuclear meltdowns Is it an international rule to have the worst picture possible on your driver license? Have you hugged your services coder, today? Ever wonder why they make the colon flash on alarm clocks? Whats this?.. blue screen with a VXD error?!.. I'VE BEEN NUKED! do-do-bop-doo-doo-do-do-doo.. For those of you who know that song, you have problems.. be wery wery quiet... hunting wabbit... I've been IRC Nuked"Great warrior? War does not make one great." - Yoda "I find your lack of faith.....disturbing." - Darth Vader "I have a bad feeling about this.."--All of the Star Wars characters. Can I upgrade my Hard Drive to a WARP drive? Canadian DOS prompt: EH?\> Canadian DOS: "Yer sure, eh?" [y/n] CONGRESS.SYS Corrupted: Re-boot Washington D.C (Y/n)? I don't have a solution but I admire the problem. Famous Last Words: Trust me. I know what I'm doing. Hey Captain, I just created a black ho-їp!%$ћ NO CARRIER Access denied--nah nah na nah nah! Bad command. Bad, bad command! Sit! Stay! Staaay.. Error: Keyboard not attached. Press F1 to continue. *grumble* "You're just supposed to sit here?" "Hey, what's this button d..<BOOM>" -W. Crusher "He has become One with Himself!" "He's passed out!" "That too."-B5 For a funny quote, call back later. Famous last words: 'You saw a WHAT around the corner?!' I like work ... I can sit and watch it for hours. Copywight 1994 Elmer Fudd. All wights wesewved. Cannot find REALITY.SYS. Universe halted. BUFFERS=20 FILES=15 2nd down, 4th quarter, 5 yards to go! My software never has bugs. It just develops random features. Why doesn't DOS ever say 'EXCELLENT command or filename!? Shell to DOS... Come in DOS, do you copy? Shell to DOS... Computing Definition - Network-Admin: Primary person who just got set up for the blame of the system crash. An expert is a person who has made all the mistakes which can be made in a very narrow field. Famous last words: This is the safe way to do it....... Famous Last Words: Trust me. I know what I'm doing. Clinton, "I didn't say that - er, well - yes, but I didn't mean..." CLINTON LEGACY??...even Pharaoh had only ten plagues... IBM I Bought McIntosh IBM I Bring Manuals IBM I've Been Moved IBM Idolized By Management IBM Impenetrable Brain Matter IBM Imperialism By Marketing IBM Incorrigible Boisterous Mammoth IBM Inertia Breeds Mediocrity IBM Ingenuity Becomes Mysterious IBM Ingrained Batch Mentality IBM Innovation By Management IBM Insipid Belligerent Mossbacks IBM Insipidly Bankrolling Millions IBM Inspect Before Multiusing IBM Install Bigger Memory IBM Institution By Machiavelli IBM Insultingly Boring Merchandisers IBM Intellectuals Being Moronized IBM Intelligence Belittling Meaning IBM Intimidated, Buffaloed Management IBM Into Building Money IBM Intolerant of Beards & Moustaches IBM Invest Before Multi-tasking IBM Investigate Baffling Malodor IBM Irresponsible Behave Multinational IBM It Beats Mattel IBM It's a Big Mess IBM It's Better Manually IBM Itty Bitty Machine IBM Institute for Black Magic 100,000 lemmings can't be wrong. Murphy's Eighth Law: If everything seems to be going well, you have obviously overlooked something. Rules of the game: Do not believe in miracles - rely on them. Rules of the game: Any given program, once running, is obsolete. Computing Definition - Error: What someone else has made when they disagree with your computer output. Backup not found: (A)bort (R)etry (P)anic WinErr 653: Multitasking attempted - system confused. Cannot join #real_life (invite only) "Unfortunately, no one can be told what the Matrix is. You have to see it for yourself." - Matrix "Reality is a thing of the past" - Matrix "The future will not be user friendly" - Matrix "The general idea in chat is to make yourself understandable... ..." - Peer "heh i am talkin to someone...she's not dead...yet anyways" - Stinky "He who must die, must die in the dark, even though he sells candles" "If at first you don't succeed, skydiving is not for you." "Friendship is like peeing on yourself: everyone can see it, but only you get the warm feeling that it brings." "France sucks, but Paris swallows" "A computer once beat me at chess, but it was no match for me at kick boxing. "Ever wonder why the SAME PEOPLE make up ALL the conspiracy theories? "Don't think of it as being outnumbered. Think of it as having a wide target selection." "Sysadmins can't be sued for malpractice, but surgeons don't have to deal with patients who install new versions of their own innards." "FACE!" "Dirka Dirka Mohammed JIHAD!" We can learn much from wise words, little from wisecracks, and less from wise guys. "Blessed are the young, for they shall inherit the national debt." - Herbert Hoover If you have five dollars and Chuck Norris has five dollars, Chuck Norris has more money than you. Apple pays Chuck Norris 99 cents every time he listens to a song. If Chuck Norris and InspIRCd met in a dark alley, Chuck Norris would get his first black eye. Ever. Chuck Norris can sneeze with his eyes open. Chuck Norris can kill two stones with one bird. There is no theory of evolution. Just a list of animals Chuck Norris allows to live. The Great Wall of China was originally created to keep Chuck Norris out. It failed miserably. Chuck Norris can win a game of Connect Four in only three moves. Chuck Norris is not hung like a horse... horses are hung like Chuck Norris. Chuck Norris is currently suing NBC, claiming Law and Order are trademarked names for his left and right legs. Chuck Norris CAN believe it's not butter. Chuck Norris is so fast, he can run around the world and punch himself in the back of the head. When the Boogeyman goes to sleep every night, he checks his closet for Chuck Norris. Outer space exists because it's afraid to be on the same planet with Chuck Norris. Chuck Norris counted to infinity - twice. Chuck Norris only fears one thing in this world, and that is InspIRCd. InspIRCd's core is ran by donated Chuck Norris DNA. Chuck Norris exists because InspIRCd allows him to. Chuck Norris CAN punch you in the face over the internet. When Chuck Norris uses InspIRCd, he doesn't use the /kill command, he uses the /ROUND-HOUSE-TO-THE-FACE command. A developer only classifies oneself as such if they consider themselves as such. "While hunting in Africa, I shot an elephant in my pajamas. How an elephant got into my pajamas I'll never know." -- Groucho Marx ������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/docs/conf/services/������������������������������������������������������������������0000775�0000000�0000000�00000000000�14771603147�0017047�5����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/docs/conf/services/anope.example.conf������������������������������������������������0000664�0000000�0000000�00000000413�14771603147�0022450�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������# This file contains aliases and nickname reservations which are used # by Anope. See https://www.anope.org for more information on Anope. # This file inherits from the generic config to avoid repetition. <include file="&dir.example;/services/generic.example.conf"> �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/docs/conf/services/atheme.example.conf�����������������������������������������������0000664�0000000�0000000�00000006031�14771603147�0022613�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������# This file contains aliases and nickname reservations which are used # by Atheme. See https://atheme.github.io/atheme.html for more # information on Atheme. # This file inherits from the generic config to avoid repetition. <include file="&dir.example;/services/generic.example.conf"> # Long hand aliases for services pseudoclients. <alias text="ALIS" replace="PRIVMSG $requirement :$2-" requires="ALIS" service="yes"> <alias text="CHANFIX" replace="PRIVMSG $requirement :$2-" requires="ChanFix" service="yes"> <alias text="GAMESERV" replace="PRIVMSG $requirement :$2-" requires="GameServ" service="yes"> <alias text="GROUPSERV" replace="PRIVMSG $requirement :$2-" requires="GroupServ" service="yes"> <alias text="HELPSERV" replace="PRIVMSG $requirement :$2-" requires="HelpServ" service="yes"> <alias text="INFOSERV" replace="PRIVMSG $requirement :$2-" requires="InfoServ" service="yes"> <alias text="PROXYSCAN" replace="PRIVMSG $requirement :$2-" requires="Proxyscan" service="yes" operonly="yes"> <alias text="RPGSERV" replace="PRIVMSG $requirement :$2-" requires="RPGServ" service="yes"> # Short hand aliases for services pseudoclients. <alias text="CF" replace="PRIVMSG $requirement :$2-" requires="ChanFix" service="yes"> <alias text="GS" replace="PRIVMSG $requirement :$2-" requires="GroupServ" service="yes"> <alias text="IS" replace="PRIVMSG $requirement :$2-" requires="InfoServ" service="yes"> <alias text="LS" replace="PRIVMSG $requirement :$2-" requires="ALIS" service="yes"> <alias text="PS" replace="PRIVMSG $requirement :$2-" requires="Proxyscan" service="yes" operonly="yes"> <alias text="RS" replace="PRIVMSG $requirement :$2-" requires="RPGServ" service="yes"> # These short hand aliases conflict with other pseudoclients. You can enable # them but you will need to comment out the uncommented ones above first, #<alias text="GS" replace="PRIVMSG $requirement :$2-" requires="GameServ" service="yes"> #<alias text="HS" replace="PRIVMSG $requirement :$2-" requires="HelpServ" service="yes"> # Prevent clients from using the nicknames of services pseudoclients. <badnick nick="ALIS" reason="Reserved for a network service"> <badnick nick="ChanFix" reason="Reserved for a network service"> <badnick nick="GameServ" reason="Reserved for a network service"> <badnick nick="GroupServ" reason="Reserved for a network service"> <badnick nick="HelpServ" reason="Reserved for a network service"> <badnick nick="InfoServ" reason="Reserved for a network service"> <badnick nick="Proxyscan" reason="Reserved for a network service"> <badnick nick="RPGServ" reason="Reserved for a network service"> <badnick nick="SaslServ" reason="Reserved for a network service"> # Exempt services pseudoclients from filters. <exemptfromfilter target="ALIS"> <exemptfromfilter target="ChanFix"> <exemptfromfilter target="GameServ"> <exemptfromfilter target="GroupServ"> <exemptfromfilter target="HelpServ"> <exemptfromfilter target="InfoServ"> <exemptfromfilter target="Proxyscan"> <exemptfromfilter target="RPGServ"> <exemptfromfilter target="SaslServ"> �������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/docs/conf/services/generic.example.conf����������������������������������������������0000664�0000000�0000000�00000006256�14771603147�0022775�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������# This file contains aliases and nickname reservations which are used # by all common services implementations. <module name="alias"> # Long hand aliases for services pseudoclients. <alias text="BOTSERV" replace="PRIVMSG $requirement :$2-" requires="BotServ" service="yes"> <alias text="CHANSERV" replace="PRIVMSG $requirement :$2-" requires="ChanServ" service="yes"> <alias text="GLOBAL" replace="PRIVMSG $requirement :$2-" requires="Global" service="yes" operonly="yes"> <alias text="HOSTSERV" replace="PRIVMSG $requirement :$2-" requires="HostServ" service="yes"> <alias text="MEMOSERV" replace="PRIVMSG $requirement :$2-" requires="MemoServ" service="yes"> <alias text="NICKSERV" replace="PRIVMSG $requirement :$2-" requires="NickServ" service="yes"> <alias text="OPERSERV" replace="PRIVMSG $requirement :$2-" requires="OperServ" service="yes" operonly="yes"> <alias text="STATSERV" replace="PRIVMSG $requirement :$2-" requires="StatServ" service="yes"> # Short hand aliases for services pseudoclients. <alias text="BS" replace="PRIVMSG $requirement :$2-" requires="BotServ" service="yes"> <alias text="CS" replace="PRIVMSG $requirement :$2-" requires="ChanServ" service="yes"> <alias text="GL" replace="PRIVMSG $requirement :$2-" requires="Global" service="yes" operonly="yes"> <alias text="HS" replace="PRIVMSG $requirement :$2-" requires="HostServ" service="yes"> <alias text="MS" replace="PRIVMSG $requirement :$2-" requires="MemoServ" service="yes"> <alias text="NS" replace="PRIVMSG $requirement :$2-" requires="NickServ" service="yes"> <alias text="OS" replace="PRIVMSG $requirement :$2-" requires="OperServ" service="yes" operonly="yes"> <alias text="SS" replace="PRIVMSG $requirement :$2-" requires="StatServ" service="yes"> # /ID [account] <password> # Identifies to a services account. <alias text="ID" format="*" replace="PRIVMSG $requirement :IDENTIFY $2-" requires="NickServ" service="yes"> <alias text="IDENTIFY" format="*" replace="PRIVMSG $requirement :IDENTIFY $2-" requires="NickServ" service="yes"> <alias text="LOGIN" format="*" replace="PRIVMSG $requirement :IDENTIFY $2-" requires="NickServ" service="yes"> # /LOGOUT # Logs out of a services account. <alias text="LOGOUT" format="*" replace="PRIVMSG $requirement :LOGOUT" requires="NickServ" service="yes"> # Prevent clients from using the nicknames of services pseudoclients. <badnick nick="BotServ" reason="Reserved for a network service"> <badnick nick="ChanServ" reason="Reserved for a network service"> <badnick nick="Global" reason="Reserved for a network service"> <badnick nick="HostServ" reason="Reserved for a network service"> <badnick nick="MemoServ" reason="Reserved for a network service"> <badnick nick="NickServ" reason="Reserved for a network service"> <badnick nick="OperServ" reason="Reserved for a network service"> <badnick nick="StatServ" reason="Reserved for a network service"> # Exempt services pseudoclients from filters. <exemptfromfilter target="BotServ"> <exemptfromfilter target="ChanServ"> <exemptfromfilter target="Global"> <exemptfromfilter target="HostServ"> <exemptfromfilter target="MemoServ"> <exemptfromfilter target="NickServ"> <exemptfromfilter target="OperServ"> <exemptfromfilter target="StatServ"> ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/docs/sql/����������������������������������������������������������������������������0000775�0000000�0000000�00000000000�14771603147�0015076�5����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/docs/sql/log_sql/��������������������������������������������������������������������0000775�0000000�0000000�00000000000�14771603147�0016536�5����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/docs/sql/log_sql/mysql.sql�����������������������������������������������������������0000664�0000000�0000000�00000000200�14771603147�0020414�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������CREATE TABLE IF NOT EXISTS `ircd_log` ( `time` datetime NOT NULL, `type` varchar(50) NOT NULL, `message` text NOT NULL ); ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/docs/sql/log_sql/pgsql.sql�����������������������������������������������������������0000664�0000000�0000000�00000000200�14771603147�0020375�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������CREATE TABLE IF NOT EXISTS "ircd_log" ( "time" datetime NOT NULL, "type" varchar(50) NOT NULL, "message" text NOT NULL ); ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/docs/sql/log_sql/schema.dbml���������������������������������������������������������0000664�0000000�0000000�00000000146�14771603147�0020637�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������Table ircd_log { time datetime [not null] type varchar(50) [not null] message text [not null] } ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/docs/sql/log_sql/sqlite3.sql���������������������������������������������������������0000664�0000000�0000000�00000000200�14771603147�0020633�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������CREATE TABLE IF NOT EXISTS "ircd_log" ( "time" datetime NOT NULL, "type" varchar(50) NOT NULL, "message" text NOT NULL ); ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/docs/sql/sqloper/��������������������������������������������������������������������0000775�0000000�0000000�00000000000�14771603147�0016563�5����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/docs/sql/sqloper/mysql.sql�����������������������������������������������������������0000664�0000000�0000000�00000001132�14771603147�0020446�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������CREATE TABLE IF NOT EXISTS `ircd_opers` ( `active` bool NOT NULL DEFAULT true, `name` text NOT NULL, `password` text NOT NULL, `host` text NOT NULL, `type` text NOT NULL, `autologin` ENUM ('strict', 'relaxed', 'never'), `class` text, `hash` text, `maxchans` bigint, `nopassword` bool, `vhost` text, `commands` text, `privs` text, `chanmodes` text, `usermodes` text, `snomasks` text, `account` text, `autojoin` text, `automotd` bool, `fingerprint` text, `level` bigint, `modes` text, `motd` bool, `override` text, `sslonly` bool, `swhois` text ); ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/docs/sql/sqloper/pgsql.sql�����������������������������������������������������������0000664�0000000�0000000�00000001211�14771603147�0020425�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������CREATE TYPE "autologin" AS ENUM ( 'strict', 'relaxed', 'never' ); CREATE TABLE IF NOT EXISTS "ircd_opers" ( "active" bool NOT NULL DEFAULT true, "name" text NOT NULL, "password" text NOT NULL, "host" text NOT NULL, "type" text NOT NULL, "autologin" autologin, "class" text, "hash" text, "maxchans" bigint, "nopassword" bool, "vhost" text, "commands" text, "privs" text, "chanmodes" text, "usermodes" text, "snomasks" text, "account" text, "autojoin" text, "automotd" bool, "fingerprint" text, "level" bigint, "modes" text, "motd" bool, "override" text, "sslonly" bool, "swhois" text ); ���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/docs/sql/sqloper/schema.dbml���������������������������������������������������������0000664�0000000�0000000�00000001643�14771603147�0020667�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������Enum autologin { strict relaxed never } Table ircd_opers { // internal to sqloper active bool [default: true, not null] // core oper config (required) name text [not null] password text [not null] host text [not null] type text [not null] // core oper config (optional) autologin autologin [null] class text [null] hash text [null] maxchans bigint [null] nopassword bool [null] vhost text [null] // core type config commands text [null] privs text [null] chanmodes text [null] usermodes text [null] snomasks text [null] // module config account text [null] // account autojoin text [null] // operjoin automotd bool [null] // opermotd fingerprint text [null] // sslinfo level bigint [null] // operlevels modes text [null] // opermodes motd bool [null] // opermotd override text [null] // override sslonly bool [null] // sslinfo swhois text [null] // swhois } ���������������������������������������������������������������������������������������������inspircd-4.7.0/docs/sql/sqloper/sqlite3.sql���������������������������������������������������������0000664�0000000�0000000�00000001154�14771603147�0020671�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������CREATE TABLE IF NOT EXISTS "ircd_opers" ( "active" bool NOT NULL DEFAULT true, "name" text NOT NULL, "password" text NOT NULL, "host" text NOT NULL, "type" text NOT NULL, "autologin" CHECK ("autologin" IN ('strict', 'relaxed', 'never')), "class" text, "hash" text, "maxchans" bigint, "nopassword" bool, "vhost" text, "commands" text, "privs" text, "chanmodes" text, "usermodes" text, "snomasks" text, "account" text, "autojoin" text, "automotd" bool, "fingerprint" text, "level" bigint, "modes" text, "motd" bool, "override" text, "sslonly" bool, "swhois" text ); ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/include/�����������������������������������������������������������������������������0000775�0000000�0000000�00000000000�14771603147�0014772�5����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/include/bancache.h�������������������������������������������������������������������0000664�0000000�0000000�00000006116�14771603147�0016673�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2019 Matt Schatz <genius3000@g3k.solutions> * Copyright (C) 2013, 2021-2022 Sadie Powell <sadie@witchery.services> * Copyright (C) 2012-2014 Attila Molnar <attilamolnar@hush.com> * Copyright (C) 2012, 2019 Robby <robby@chatbelgie.be> * Copyright (C) 2009 Daniel De Graaf <danieldg@inspircd.org> * Copyright (C) 2007-2008 Robin Burchell <robin+git@viroteck.net> * Copyright (C) 2007-2008 Craig Edwards <brain@inspircd.org> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #pragma once /** Stores a cached ban entry. * Each ban has one of these hashed in a hash_map to make for faster removal * of already-banned users in the case that they try to reconnect. As no wildcard * matching is done on these IPs, the speed of the system is improved. These cache * entries expire every few hours, which is a reasonable expiry for any reasonable * sized network. */ class CoreExport BanCacheHit final { public: /** Type of cached ban */ std::string Type; /** Reason, shown as quit message */ std::string Reason; /** Time that the ban expires at */ time_t Expiry; BanCacheHit(const std::string& type, const std::string& reason, time_t seconds); bool IsPositive() const { return (!Reason.empty()); } }; /** A manager for ban cache, which allocates and deallocates and checks cached bans. */ class CoreExport BanCacheManager final { /** A container of ban cache items. */ typedef std::unordered_map<std::string, BanCacheHit*> BanCacheHash; BanCacheHash BanHash; bool RemoveIfExpired(BanCacheHash::iterator& it); public: /** Creates and adds a Ban Cache item. * @param ip The IP the item is for. * @param type The type of ban cache item. std::string. .empty() means it's a negative match (user is allowed freely). * @param reason The reason for the ban. Left .empty() if it's a negative match. * @param seconds Number of seconds before nuking the bancache entry, the default is a day. This might seem long, but entries will be removed as G-lines/etc expire. */ BanCacheHit* AddHit(const std::string& ip, const std::string& type, const std::string& reason, time_t seconds = 0); BanCacheHit* GetHit(const std::string& ip); /** Removes all entries of a given type, either positive or negative. Returns the number of hits removed. * @param type The type of bancache entries to remove (e.g. 'G') * @param positive Remove either positive (true) or negative (false) hits. */ void RemoveEntries(const std::string& type, bool positive); ~BanCacheManager(); }; ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/include/base.h�����������������������������������������������������������������������0000664�0000000�0000000�00000012763�14771603147�0016066�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2020 Matt Schatz <genius3000@g3k.solutions> * Copyright (C) 2013, 2020-2022, 2024 Sadie Powell <sadie@witchery.services> * Copyright (C) 2013, 2015 Attila Molnar <attilamolnar@hush.com> * Copyright (C) 2012 Robby <robby@chatbelgie.be> * Copyright (C) 2012 ChrisTX <xpipe@hotmail.de> * Copyright (C) 2011-2012 Adam <Adam@anope.org> * Copyright (C) 2009-2010 Daniel De Graaf <danieldg@inspircd.org> * Copyright (C) 2007 Oliver Lupton <om@inspircd.org> * Copyright (C) 2007 Dennis Friis <peavey@inspircd.org> * Copyright (C) 2006 Craig Edwards <brain@inspircd.org> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #pragma once #include "compat.h" #include <string> #include "utility/uncopiable.h" #include "cull.h" /** The base class for inspircd classes that support reference counting. * Any objects that do not have a well-defined lifetime should inherit from * this, and should be assigned to a reference<type> object to establish their * lifetime. * * Reference objects should not hold circular references back to themselves, * even indirectly; this will cause a memory leak because the count will never * drop to zero. * * Using a normal pointer for the object is recommended if you can assure that * at least one reference<> will remain as long as that pointer is used; this * will avoid the slight overhead of changing the reference count. */ class CoreExport refcountbase : private insp::uncopiable { mutable unsigned int refcount = 0; public: refcountbase(); virtual ~refcountbase(); inline unsigned int GetReferenceCount() const { return refcount; } static inline void* operator new(size_t, void* m) { return m; } static void* operator new(size_t); static void operator delete(void*); inline void refcount_inc() const { refcount++; } inline bool refcount_dec() const { refcount--; return !refcount; } }; /** Base class for use count tracking. Uses reference<>, but does not * cause object deletion when the last user is removed. * * Safe for use as a second parent class; will not add a second vtable. */ class CoreExport usecountbase : private insp::uncopiable { mutable unsigned int usecount = 0; public: usecountbase() = default; ~usecountbase(); inline unsigned int GetUseCount() const { return usecount; } inline void refcount_inc() const { usecount++; } inline bool refcount_dec() const { usecount--; return false; } }; template <typename T> class reference final { T* value = nullptr; public: reference() = default; reference(T* v) : value(v) { if (value) value->refcount_inc(); } reference(const reference<T>& v) : value(v.value) { if (value) value->refcount_inc(); } reference<T>& operator=(const reference<T>& other) { if (other.value) other.value->refcount_inc(); this->reference::~reference(); value = other.value; return *this; } ~reference() { if (value && value->refcount_dec()) delete value; } inline reference<T>& operator=(T* other) { if (value != other) { if (value && value->refcount_dec()) delete value; value = other; if (value) value->refcount_inc(); } return *this; } inline T* ptr() const { return value; } inline operator bool() const { return (value != nullptr); } inline operator T*() const { return value; } inline T* operator->() const { return value; } inline T& operator*() const { return *value; } inline bool operator<(const reference<T>& other) const { return value < other.value; } inline bool operator>(const reference<T>& other) const { return value > other.value; } static inline void* operator new(size_t, void* m) { return m; } private: #ifndef _WIN32 static void* operator new(size_t); static void operator delete(void*); #endif }; typedef const reference<Module> ModuleRef; enum ServiceType { /** is a Command */ SERVICE_COMMAND, /** is a ModeHandler */ SERVICE_MODE, /** is a metadata descriptor */ SERVICE_METADATA, /** is a data processing provider (MD5, SQL) */ SERVICE_DATA, /** is an I/O hook provider */ SERVICE_IOHOOK, /** Service managed by a module */ SERVICE_CUSTOM }; /** A structure defining something that a module can provide */ class CoreExport ServiceProvider : public Cullable { public: /** Module that is providing this service */ ModuleRef creator; /** Name of the service being provided */ const std::string name; /** Type of service (must match object type) */ const ServiceType service; ServiceProvider(Module* Creator, const std::string& Name, ServiceType Type); /** Retrieves a string that represents the type of this service. */ const char* GetTypeString() const; /** Register this service in the appropriate registrar */ virtual void RegisterService(); /** If called, this ServiceProvider won't be registered automatically */ void DisableAutoRegister(); }; class CoreExport DataProvider : public ServiceProvider { public: DataProvider(Module* Creator, const std::string& Name) : ServiceProvider(Creator, Name, SERVICE_DATA) {} }; �������������inspircd-4.7.0/include/channelmanager.h�������������������������������������������������������������0000664�0000000�0000000�00000004270�14771603147�0020111�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2020-2022 Sadie Powell <sadie@witchery.services> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #pragma once /** A mapping of channel names to their Channel object. */ typedef std::unordered_map<std::string, Channel*, irc::insensitive, irc::StrHashComp> ChannelMap; /** Manages state relating to channels. */ class CoreExport ChannelManager final { private: /** A map of channel names to the channel object. */ ChannelMap channels; public: /** Determines whether an channel name is valid. */ std::function<bool(const std::string_view&)> IsChannel = DefaultIsChannel; /** Determines whether a channel name is valid according to the RFC 1459 rules. * This is the default function for InspIRCd::IsChannel. * @param channel The channel name to validate. * @return True if the channel name is valid according to RFC 1459 rules; otherwise, false. */ static bool DefaultIsChannel(const std::string_view& channel); /** Finds a channel by name. * @param channel The name of the channel to look up. * @return If the channel was found then a pointer to a Channel object; otherwise, nullptr. */ Channel* Find(const std::string& channel) const; /** Retrieves a map containing all channels keyed by the channel name. */ ChannelMap& GetChans() { return channels; } const ChannelMap& GetChans() const { return channels; } /** Determines whether the specified character is a valid channel prefix. * @param prefix The channel name prefix to validate. * @return True if the character is a channel prefix; otherwise, false. */ bool IsPrefix(unsigned char prefix) const; }; ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/include/channels.h�������������������������������������������������������������������0000664�0000000�0000000�00000030634�14771603147�0016744�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2024 Glen Miner <shaggie76@gmail.com> * Copyright (C) 2013-2014, 2016, 2018 Attila Molnar <attilamolnar@hush.com> * Copyright (C) 2012-2013, 2018-2023 Sadie Powell <sadie@witchery.services> * Copyright (C) 2012 Robby <robby@chatbelgie.be> * Copyright (C) 2009 Daniel De Graaf <danieldg@inspircd.org> * Copyright (C) 2007-2008 Robin Burchell <robin+git@viroteck.net> * Copyright (C) 2007, 2009 Dennis Friis <peavey@inspircd.org> * Copyright (C) 2003-2006, 2008 Craig Edwards <brain@inspircd.org> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #pragma once #include "membership.h" #include "mode.h" #include "parammode.h" /** Holds an entry for a ban list, exemption list, or invite list. * This class contains a single element in a channel list, such as a banlist. */ /** Holds all relevant information for a channel. * This class represents a channel, and contains its name, modes, topic, topic set time, * etc, and an instance of the BanList type. */ class CoreExport Channel final : public Extensible { public: /** A map of Memberships on a channel keyed by User pointers */ typedef std::unordered_map<User*, insp::aligned_storage<Membership>> MemberMap; private: /** Set default modes for the channel on creation */ void SetDefaultModes(); /** Modes for the channel. * It is a bitset where each item in it represents if a mode is set. * To see if a mode is set, inspect modes[mh->modeid] */ ModeParser::ModeStatus modes; /** Remove the given membership from the channel's internal map of * memberships and destroy the Membership object. * This function does not remove the channel from User::chanlist. * Since the parameter is an iterator to the target, the complexity * of this function is constant. * @param membiter The MemberMap iterator to remove, must be valid */ void DelUser(const MemberMap::iterator& membiter); public: /** Creates a channel record and initialises it with default values * @param name The name of the channel * @param ts The creation time of the channel * @throw CoreException if this channel name is in use */ Channel(const std::string& name, time_t ts); /** Checks whether the channel should be destroyed, and if yes, begins * the teardown procedure. * * If there are users on the channel or a module vetoes the deletion * (OnPreChannelDelete hook) then nothing else happens. * Otherwise, first the OnChannelDelete event is fired, then the channel is * removed from the channel list. All pending invites are destroyed and * finally the channel is added to the cull list. */ void CheckDestroy(); /** The channel's name. */ std::string name; /** Time that the object was instantiated (used for TS calculation etc) */ time_t age; /** User list. */ MemberMap userlist; /** Channel topic. * If this is an empty string, no channel topic is set. */ std::string topic; /** Time topic was set. * If no topic was ever set, this will be equal to Channel::created */ time_t topicset = 0; /** The last user to set the topic. * If this member is an empty string, no topic was ever set. */ std::string setby; /* 128 */ /** Sets or unsets a custom mode in the channels info * @param mode The mode character to set or unset * @param value True if you want to set the mode or false if you want to remove it */ void SetMode(const ModeHandler* mode, bool value); void SetMode(const ModeHandler& mh, bool value) { SetMode(&mh, value); } /** Returns true if a mode is set on a channel * @param mode The mode character you wish to query * @return True if the custom mode is set, false if otherwise */ inline bool IsModeSet(const ModeHandler* mode) const { return mode->GetId() != ModeParser::MODEID_MAX && modes[mode->GetId()]; } inline bool IsModeSet(const ModeHandler& mode) const { return IsModeSet(&mode); } inline bool IsModeSet(const ChanModeReference& mode) const { return mode ? IsModeSet(*mode) : false; } /** Returns the parameter for a custom mode on a channel. * @param mode The mode character you wish to query * * For example if "+L #foo" is set, and you pass this method * 'L', it will return '\#foo'. If the mode is not set on the * channel, or the mode has no parameters associated with it, * it will return an empty string. * * @return The parameter for this mode is returned, or an empty string */ std::string GetModeParameter(ModeHandler* mode); std::string GetModeParameter(ChanModeReference& mode); std::string GetModeParameter(ParamModeBase* pm); /** Sets the channel topic. * @param user The user setting the topic. * @param topic The topic to set it to. * @param topicts Timestamp of the new topic. * @param setter Setter string, may be used when the original setter is no longer online. * If omitted or NULL, the setter string is obtained from the user. */ void SetTopic(User* user, const std::string& topic, time_t topicts, const std::string* setter = nullptr); /** Add a user pointer to the internal reference list * @param user The user to add * * The data inserted into the reference list is a table as it is * an arbitrary pointer compared to other users by its memory address, * as this is a very fast 32 or 64 bit integer comparison. */ Membership* AddUser(User* user); /** Delete a user pointer to the internal reference list * @param user The user to delete */ void DelUser(User* user); /** Obtain the internal reference list * The internal reference list contains a list of User*. * These are used for rapid comparison to determine * channel membership for PRIVMSG, NOTICE, QUIT, PART etc. * The resulting pointer to the vector should be considered * readonly and only modified via AddUser and DelUser. * * @return This function returns pointer to a map of User pointers (CUList*). */ const MemberMap& GetUsers() const { return userlist; } /** Returns true if the user given is on the given channel. * @param user The user to look for * @return True if the user is on this channel */ inline bool HasUser(User* user) const { return userlist.find(user) != userlist.end(); } Membership* GetUser(User* user) const; /** Make \p source kick \p victimiter from this channel with the given reason. * @param source The user who initiated the kick. * @param victimiter An iterator to the user to kick from the channel. * @param reason The kick reason. */ void KickUser(User* source, const MemberMap::iterator& victimiter, const std::string& reason); /** Make \p source kick \p victim from this channel with the given reason. * @param source The user who initiated the kick. * @param victim The user to kick from the channel. * @param reason The kick reason. * @return True if the user was a member of the channel and was kicked; otherwise, false. */ inline bool KickUser(User* source, User* victim, const std::string& reason) { auto it = userlist.find(victim); if (it != userlist.end()) { KickUser(source, it, reason); return true; } return false; } /** Part \p membiter from this channel with the given reason. * @param membiter An iterator to the user to part from the channel. * @param reason The part reason. */ void PartUser(const MemberMap::iterator& membiter, const std::string& reason); /** Part \p user from this channel with the given reason. * @param user The user to part from the channel. * @param reason The part reason. * @return True if the user was a member of the channel and was parted; otherwise, false. */ inline bool PartUser(User* user, const std::string& reason) { auto it = userlist.find(user); if (it != userlist.end()) { PartUser(it, reason); return true; } return false; } /** Join a local user to a channel, with or without permission checks. May be a channel that doesn't exist yet. * @param user The user to join to the channel. * @param channame The channel name to join to. Does not have to exist. * @param key The key of the channel, if given * @param override If true, override all join restrictions such as +bkil * @return A pointer to the Membership of the joined user. A new Channel may have * been created if the channel did not exist before the user was joined to it. * If the user could not be joined to a channel, the return value is NULL. */ static Membership* JoinUser(LocalUser* user, std::string channame, bool override = false, const std::string& key = ""); /** Join a user to an existing channel, without doing any permission checks * @param user The user to join to the channel * @param privs Privileges (prefix mode letters) to give to this user, may be NULL * @param bursting True if this join is the result of a netburst (passed to modules in the OnUserJoin hook) * @param created_by_local True if this channel was just created by a local user (passed to modules in the OnUserJoin hook) * @return A newly created Membership object, or NULL if the user was already inside the channel or if the user is a server user */ Membership* ForceJoin(User* user, const std::string* privs = nullptr, bool bursting = false, bool created_by_local = false); /** Write to all users on a channel except some users * @param protoev Event to send, may contain any number of messages. * @param status The status of the users to write to, e.g. '@' or '%'. Use a value of 0 to write to everyone * @param except_list List of users not to send to */ void Write(ClientProtocol::Event& protoev, char status = 0, const CUList& except_list = {}) const; /** Write to all users on a channel except some users. * @param protoevprov Protocol event provider for the message. * @param msg Message to send. * @param status The status of the users to write to, e.g. '@' or '%'. Use a value of 0 to write to everyone * @param except_list List of users not to send to */ void Write(ClientProtocol::EventProvider& protoevprov, ClientProtocol::Message& msg, char status = 0, const CUList& except_list = {}) const; /** Return the channel's modes with parameters. * @param showsecret If this is set to true, the value of secret parameters * are shown, otherwise they are replaced with '&lt;name&gt;'. * @return The channel mode string */ const char* ChanModes(bool showsecret); /** Get the value of a users prefix on this channel. * @param user The user to look up * @return The module or core-defined value of the users prefix. * The values for op, halfop and voice status are constants in * mode.h, and are OP_VALUE, HALFOP_VALUE, and VOICE_VALUE respectively. * If the value you are given does not match one of these three, it is * a module-defined mode, and it should be compared in proportion to * these three constants. For example a value greater than OP_VALUE * is a prefix of greater 'worth' than ops, and a value less than * VOICE_VALUE is of lesser 'worth' than a voice. */ ModeHandler::Rank GetPrefixValue(User* user) const; /** Check if a user is banned on this channel * @param user A user to check against the banlist * @returns True if the user given is banned */ bool IsBanned(User* user); /** Check a single ban for match */ bool CheckBan(User* user, const std::string& banmask); /** Write a NOTICE to all local users on the channel * @param text Text to send * @param status The minimum status rank to send this message to. */ void WriteNotice(const std::string& text, char status = 0) const; void WriteRemoteNotice(const std::string& text, char status = 0) const; }; inline std::string Channel::GetModeParameter(ChanModeReference& mode) { if (!mode) return ""; return GetModeParameter(*mode); } inline std::string Channel::GetModeParameter(ModeHandler* mh) { std::string out; ParamModeBase* pm = mh->IsParameterMode(); if (pm && this->IsModeSet(pm)) pm->GetParameter(this, out); return out; } inline std::string Channel::GetModeParameter(ParamModeBase* pm) { std::string out; if (this->IsModeSet(pm)) pm->GetParameter(this, out); return out; } ����������������������������������������������������������������������������������������������������inspircd-4.7.0/include/clientprotocol.h�������������������������������������������������������������0000664�0000000�0000000�00000061141�14771603147�0020206�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2018-2023 Sadie Powell <sadie@witchery.services> * Copyright (C) 2018 Attila Molnar <attilamolnar@hush.com> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #pragma once #include "event.h" namespace ClientProtocol { class EventHook; class MessageSource; struct RFCEvents; struct ParseOutput; class TagSelection; } /** Contains a message parsed from wire format. * Used by Serializer::Parse(). */ struct CoreExport ClientProtocol::ParseOutput final { /** Command name, must not be empty. */ std::string cmd; /** Parameter list, may be empty. */ ClientProtocol::ParamList params; /** Message tags, may be empty. */ ClientProtocol::TagMap tags; }; /** A selection of zero or more tags in a TagMap. */ class CoreExport ClientProtocol::TagSelection final { std::bitset<64> selection; public: /** Check if a tag is selected. * @param tags TagMap the tag is in. The TagMap must contain the same tags as it had when the tag * was selected with Select(), otherwise the result is not meaningful. * @param it Iterator to the tag to check. * @return True if the tag is selected, false otherwise. */ bool IsSelected(const TagMap& tags, TagMap::const_iterator it) const { const size_t index = std::distance(tags.begin(), it); return ((index < selection.size()) && (selection[index])); } /** Select a tag. * @param tags TagMap the tag is in. This parameter must be the same every time the method is called. * The TagMap must not be altered otherwise the results of IsSelected() is not meaningful. * @param it Iterator to the tag to mark as selected. */ void Select(const TagMap& tags, TagMap::const_iterator it) { const size_t index = std::distance(tags.begin(), it); if (index < selection.size()) selection[index] = true; } /** Check if a TagSelection is equivalent to this object. * @param other Other TagSelection object to compare this with. * @return True if the objects are equivalent, false if they aren't. */ bool operator==(const TagSelection& other) const { return (this->selection == other.selection); } }; class CoreExport ClientProtocol::MessageSource { protected: User* sourceuser; const std::string* sourcestr; bool sourceowned:1; public: /** Constructor, sets the source to be the full host of a user or sets it to be nothing. * The actual source string when serializing will be obtained from User::GetFullHost() if the user is non-NULL. * @param Sourceuser User to set as source of the message. If NULL, the message won't have a source when serialized. * Optional, defaults to NULL. */ MessageSource(User* Sourceuser = nullptr) : sourceowned(false) { SetSourceUser(Sourceuser); } ~MessageSource() { if (sourceowned && sourcestr) delete sourcestr; } /** Constructor, sets the source to the supplied string and optionally sets the source user. * @param Sourcestr String to use as message source for serialization purposes. Must remain valid * as long as this object is alive. * @param Sourceuser User to set as source. Optional, defaults to NULL. It will not be used for serialization but * if provided it may be used internally, for example to create message tags. * Useful when the source string is synthesized but it is still related to a User. */ MessageSource(const std::string& Sourcestr, User* Sourceuser = nullptr) : sourceowned(false) { SetSource(Sourcestr, Sourceuser); } /** Get the source of this message as a string. * @return Pointer to the message source string or NULL if there is no source. */ const std::string* GetSource() const { // Return string if there's one explicitly set if (sourcestr) return sourcestr; if (sourceuser) return &sourceuser->GetMask(); return nullptr; } /** Get the source User. * This shouldn't be used for serialization, use GetSource() for that. * @return User pointer if the message has a source user, NULL otherwise. */ User* GetSourceUser() const { return sourceuser; } /** Set the source of this message to a User. * See the one parameter constructor for a more detailed description. * @param Sourceuser User to set as source. */ void SetSourceUser(User* Sourceuser) { sourceuser = Sourceuser; sourcestr = nullptr; } /** Set the source string and optionally source user. * See the two parameter constructor for a more detailed description. * @param Sourcestr String source, to be used for serialization purposes. Must remain valid as long * as this object is alive. * @param Sourceuser Source user to set, optional. */ void SetSource(const std::string& Sourcestr, User* Sourceuser = nullptr) { sourcestr = &Sourcestr; sourceuser = Sourceuser; } /** Copy the source from a MessageSource object. * @param other MessageSource object to copy from. */ void SetSource(const MessageSource& other) { sourcestr = other.sourcestr; sourceuser = other.sourceuser; } }; /** Outgoing client protocol message. * Represents a high level client protocol message which is turned into raw or wire format * by a Serializer. Messages can be serialized into different format by different serializers. * * Messages are created on demand and are disposed of after they have been sent. * * All messages have a command name, a list of parameters and a map of tags, the last two can be empty. * They also always have a source, see class MessageSource. */ class CoreExport ClientProtocol::Message : public ClientProtocol::MessageSource { public: /** Contains information required to identify a specific version of a serialized message. */ struct SerializedInfo final { const Serializer* serializer; TagSelection tagwl; /** Constructor. * @param Ser Serializer used to serialize the message. * @param Tagwl Tag whitelist used to serialize the message. */ SerializedInfo(const Serializer* Ser, const TagSelection& Tagwl) : serializer(Ser) , tagwl(Tagwl) { } /** Check if a SerializedInfo object is equivalent to this object. * @param other Other SerializedInfo object. * @return True if other is equivalent to this object, false otherwise. */ bool operator==(const SerializedInfo& other) const { return ((serializer == other.serializer) && (tagwl == other.tagwl)); } }; class Param final { const std::string* ptr; insp::aligned_storage<std::string> str; bool owned; void InitFrom(const Param& other) { owned = other.owned; if (owned) new(str) std::string(*other.str); else ptr = other.ptr; } public: operator const std::string&() const { return (owned ? *str : *ptr); } Param() : ptr(nullptr) , owned(false) { } Param(const std::string& s) : ptr(&s) , owned(false) { } Param(int, const char* s) : ptr(nullptr) , owned(true) { new(str) std::string(s); } Param(int, const std::string& s) : ptr(nullptr) , owned(true) { new(str) std::string(s); } Param(const Param& other) { InitFrom(other); } ~Param() { using std::string; if (owned) str->~string(); } Param& operator=(const Param& other) { if (&other == this) return *this; using std::string; if (owned) str->~string(); InitFrom(other); return *this; } bool IsOwned() const { return owned; } }; typedef std::vector<Param> ParamList; /** Escapes a value to the tag format. * @param value The value to escape. */ static std::string EscapeTag(const std::string& value); /** Unescapes a value from the tag format. * @param value The value to unescape. */ static std::string UnescapeTag(const std::string& value); private: typedef std::vector<std::pair<SerializedInfo, SerializedMessage>> SerializedList; ParamList params; TagMap tags; std::string command; bool msginit_done = false; mutable SerializedList serlist; bool sideeffect = false; protected: /** Set command string. * @param cmd Command string to set. */ void SetCommand(const char* cmd) { command.clear(); if (cmd) command = cmd; } public: /** Constructor. * @param cmd Command name, e.g. "JOIN", "NICK". May be NULL. If NULL, the command must be set * with SetCommand() before the message is serialized. * @param Sourceuser See the one parameter constructor of MessageSource for description. */ Message(const char* cmd, User* Sourceuser = nullptr) : ClientProtocol::MessageSource(Sourceuser) , command(cmd ? cmd : std::string()) { params.reserve(8); serlist.reserve(8); } /** Constructor. * @param cmd Command name, e.g. "JOIN", "NICK". May be NULL. If NULL, the command must be set * with SetCommand() before the message is serialized. * @param Sourcestr See the two parameter constructor of MessageSource for description. * Must remain valid as long as this object is alive. * @param Sourceuser See the two parameter constructor of MessageSource for description. */ Message(const char* cmd, const std::string& Sourcestr, User* Sourceuser = nullptr) : ClientProtocol::MessageSource(Sourcestr, Sourceuser) , command(cmd ? cmd : std::string()) { params.reserve(8); serlist.reserve(8); } /** Get the parameters of this message. * @return List of parameters. */ const ParamList& GetParams() const { return params; } /** Get a map of tags attached to this message. * The map contains the tag providers that attached the tag to the message. * @return Map of tags. */ const TagMap& GetTags() const { return tags; } /** Get the command string. * @return Command string, e.g. "NICK", "001". */ const char* GetCommand() const { return command.c_str(); } /** Add a parameter to the parameter list. * @param str String to add, will be copied. */ void PushParam(const char* str) { params.emplace_back(0, str); } /** Add a parameter to the parameter list. * @param str String to add, will be copied. */ void PushParam(const std::string& str) { params.emplace_back(0, str); } /** Converts the given arguments to a string and adds them to the parameter list. * @param args One or more parameters to add to the parameter list. */ template <typename... Args> void PushParam(Args&&... args) { (PushParam(ConvToStr(args)), ...); } /** Add a parameter to the parameter list. * @param str String to add. * The string will NOT be copied, it must remain alive until ClearParams() is called or until the object is destroyed. */ void PushParamRef(const std::string& str) { params.push_back(str); } /** Add a placeholder parameter to the parameter list. * Placeholder parameters must be filled in later with actual parameters using ReplaceParam() or ReplaceParamRef(). */ void PushParamPlaceholder() { params.emplace_back(); } /** Replace a parameter or a placeholder that is already in the parameter list. * @param index Index of the parameter to replace. Must be less than GetParams().size(). * @param str String to replace the parameter or placeholder with, will be copied. */ void ReplaceParam(size_t index, const char* str) { params[index] = Param(0, str); } /** Replace a parameter or a placeholder that is already in the parameter list. * @param index Index of the parameter to replace. Must be less than GetParams().size(). * @param str String to replace the parameter or placeholder with, will be copied. */ void ReplaceParam(size_t index, const std::string& str) { params[index] = Param(0, str); } /** Replace a parameter or a placeholder that is already in the parameter list. * @param index Index of the parameter to replace. Must be less than GetParams().size(). * @param str String to replace the parameter or placeholder with. * The string will NOT be copied, it must remain alive until ClearParams() is called or until the object is destroyed. */ void ReplaceParamRef(size_t index, const std::string& str) { params[index] = Param(str); } /** Add a tag. * @param tagname Raw name of the tag to use in the protocol. * @param tagprov Provider of the tag. * @param val Tag value. If empty no value will be sent with the tag. * @param tagdata Tag provider specific data, will be passed to MessageTagProvider::ShouldSendTag(). Optional, defaults to NULL. */ void AddTag(const std::string& tagname, MessageTagProvider* tagprov, const std::string& val, void* tagdata = nullptr) { tags.emplace(tagname, MessageTagData(tagprov, val, tagdata)); } /** Add all tags in a TagMap to the tags in this message. Existing tags will not be overwritten. * @param newtags New tags to add. */ void AddTags(const ClientProtocol::TagMap& newtags) { tags.insert(newtags.begin(), newtags.end()); } /** Get the message in a serialized form. * @param serializeinfo Information about which exact serialized form of the message is the caller asking for * (which serializer to use and which tags to include). * @return Serialized message according to serializeinfo. The returned reference remains valid until the * next call to this method. */ const SerializedMessage& GetSerialized(const SerializedInfo& serializeinfo) const; /** Clear the parameter list and tags. */ void ClearParams() { msginit_done = false; params.clear(); tags.clear(); InvalidateCache(); } /** Remove all serialized messages. * If a parameter is changed after the message has been sent at least once, this method must be called before * serializing the message again to ensure the cache won't contain stale data. */ void InvalidateCache() { serlist.clear(); } void CopyAll() { size_t idx = 0; for (const auto& param : params) { if (!param.IsOwned()) ReplaceParam(idx, param); idx++; } if (GetSource()) { sourcestr = new std::string(*GetSource()); sourceowned = true; } } void SetSideEffect(bool Sideeffect) { sideeffect = Sideeffect; } bool IsSideEffect() const { return sideeffect; } friend class Serializer; }; /** Client protocol event class. * All messages sent to a user must be part of an event. A single event may result in more than one protocol message * being sent, for example a join event may result in a JOIN and a MODE protocol message sent to members of the channel * if the joining user has some prefix modes set. * * Event hooks attached to a specific event can alter the messages sent for that event. */ class CoreExport ClientProtocol::Event { EventProvider* event; Message* initialmsg = nullptr; const MessageList* initialmsglist = nullptr; bool eventinit_done = false; public: /** Constructor. * @param protoeventprov Protocol event provider the event is an instance of. */ Event(EventProvider& protoeventprov) : event(&protoeventprov) { } /** Constructor. * @param protoeventprov Protocol event provider the event is an instance of. * @param msg Message to include in this event by default. */ Event(EventProvider& protoeventprov, ClientProtocol::Message& msg) : event(&protoeventprov) , initialmsg(&msg) { } /** Set a single message as the initial message in the event. * Modules may alter this later. */ void SetMessage(Message* msg) { initialmsg = msg; initialmsglist = nullptr; } /** Set a list of messages as the initial messages in the event. * Modules may alter this later. */ void SetMessageList(const MessageList& msglist) { initialmsg = nullptr; initialmsglist = &msglist; } /** Get a list of messages to send to a user. * The exact messages sent to a user are determined by the initial message(s) set and hooks. * @param user User to get the messages for. * @param messagelist List to fill in with messages to send to the user for the event */ void GetMessagesForUser(LocalUser* user, MessageList& messagelist); }; class CoreExport ClientProtocol::MessageTagEvent : public Events::ModuleEventProvider { public: MessageTagEvent(Module* mod) : ModuleEventProvider(mod, "event/messagetag") { } }; /** Base class for message tag providers. * All message tags belong to a message tag provider. Message tag providers can populate messages * with tags before the message is sent and they have the job of determining whether a user should * get a message tag or be allowed to send one. */ class CoreExport ClientProtocol::MessageTagProvider : public Events::ModuleEventListener { public: /** Constructor. * @param mod Module owning the provider. * @param eventprio The priority to give this event listener. */ MessageTagProvider(Module* mod, unsigned int eventprio = DefaultPriority) : Events::ModuleEventListener(mod, "event/messagetag", eventprio) { } /** Called when a message is ready to be sent to give the tag provider a chance to add tags to the message. * To add tags call Message::AddTag(). If the provided tag or tags have been added already elsewhere or if the * provider doesn't want its tag(s) to be on the message, the implementation doesn't have to do anything special. * The default implementation does nothing. * @param msg Message to be populated with tags. */ virtual void OnPopulateTags(ClientProtocol::Message& msg) { } /** Called for each tag that the server receives from a client in a message. * @param user User that sent the tag. * @param tagname Name of the tag. * @param tagvalue Value of the tag, empty string if the tag has no value. May be modified. * @return MOD_RES_ALLOW to accept the tag with the value in 'value', MOD_RES_DENY to reject the tag and act as if it wasn't sent, * MOD_RES_PASSTHRU to make no decision. If no hooks accept a tag, the tag is rejected. * The default implementation returns MOD_RES_PASSTHRU. */ virtual ModResult OnProcessTag(User* user, const std::string& tagname, std::string& tagvalue) { return MOD_RES_PASSTHRU; } /** Called whenever a user is about to receive a message that has a tag attached which is provided by this provider * to determine whether or not the user should get the tag. * @param user User in question. * @param tagdata Tag in question. * @return True if the tag should be sent to the user, false otherwise. */ virtual bool ShouldSendTag(LocalUser* user, const MessageTagData& tagdata) = 0; }; /** Base class for client protocol event hooks. * A protocol event hook is attached to a single event type. It has the ability to alter or block messages * sent to users which belong to the event the hook is attached to. */ class CoreExport ClientProtocol::EventHook : public Events::ModuleEventListener { public: static std::string GetEventName(const std::string& name) { return "event/protoevent_" + name; } /** Constructor. * @param mod Owner of the hook. * @param name Name of the event to hook. * @param priority Priority of the hook. Determines the order in which hooks for the same event get called. * Optional. */ EventHook(Module* mod, const std::string& name, unsigned int priority = Events::ModuleEventListener::DefaultPriority) : Events::ModuleEventListener(mod, GetEventName(name), priority) { } /** Called exactly once before an event is sent to any user. * The default implementation doesn't do anything. * @param ev Event being sent to one or more users. */ virtual void OnEventInit(const ClientProtocol::Event& ev) { } /** Called for each user that may receive the event. * The hook may alter the messages sent to the user and decide whether further hooks should be executed. * @param user User the message list is being prepared to be sent to. * @param ev Event associated with the messages. * @param messagelist List of messages to send to the user. The hook can alter this in any way it sees fit, for example it can replace messages, * add new messages, etc. The list must not be empty when the method returns. * @return MOD_RES_PASSTHRU to run hooks after the called hook or if no hooks are after the called hook, send the messages in messagelist to the user. * MOD_RES_DENY to not send any messages to the user and to not run other hooks, * MOD_RES_ALLOW to send the messages in messagelist to the user and to not run other hooks. */ virtual ModResult OnPreEventSend(LocalUser* user, const ClientProtocol::Event& ev, ClientProtocol::MessageList& messagelist) = 0; }; /** Event provider for client protocol events. * Protocol event hooks can be attached to the instances of these providers. The core has event * providers for most common IRC events defined in RFC1459. */ class CoreExport ClientProtocol::EventProvider final : public Events::ModuleEventProvider { public: /** Constructor. * @param Mod Module that owns the event provider. * @param eventname Name of the event this provider is for, e.g. "JOIN", "PART", "NUMERIC". * Should match command name if applicable. */ EventProvider(Module* Mod, const std::string& eventname) : Events::ModuleEventProvider(Mod, ClientProtocol::EventHook::GetEventName(eventname)) { } }; /** Commonly used client protocol events. * Available via InspIRCd::GetRFCEvents(). */ struct CoreExport ClientProtocol::RFCEvents final { EventProvider numeric; EventProvider join; EventProvider part; EventProvider kick; EventProvider quit; EventProvider nick; EventProvider mode; EventProvider topic; EventProvider privmsg; EventProvider invite; EventProvider ping; EventProvider pong; EventProvider error; RFCEvents() : numeric(nullptr, "NUMERIC") , join(nullptr, "JOIN") , part(nullptr, "PART") , kick(nullptr, "KICK") , quit(nullptr, "QUIT") , nick(nullptr, "NICK") , mode(nullptr, "MODE") , topic(nullptr, "TOPIC") , privmsg(nullptr, "PRIVMSG") , invite(nullptr, "INVITE") , ping(nullptr, "PING") , pong(nullptr, "PONG") , error(nullptr, "ERROR") { } }; /** Base class for client protocol serializers. * A serializer has to implement serialization and parsing of protocol messages to/from wire format. */ class CoreExport ClientProtocol::Serializer : public DataProvider { private: ClientProtocol::MessageTagEvent evprov; /** Make a white list containing which tags a user should get. * @param user User in question. * @param tagmap Tag map that contains all possible tags. * @return Whitelist of tags to send to the user. */ static TagSelection MakeTagWhitelist(LocalUser* user, const TagMap& tagmap); public: /** Constructor. * @param mod Module owning the serializer. * @param Name Name of the serializer, e.g. "rfc". */ Serializer(Module* mod, const std::string& Name); /** Handle a tag in a message being parsed. Call this method for each parsed tag. * @param user User sending the tag. * @param tagname Name of the tag. * @param tagvalue Tag value, may be empty. * @param tags TagMap to place the tag into, if it gets accepted. * @return True if no error occurred, false if the tag name is invalid or if this tag already exists. */ bool HandleTag(LocalUser* user, const std::string& tagname, std::string& tagvalue, TagMap& tags) const; /** Serialize a message for a user. * @param user User to serialize the message for. * @param msg Message to serialize. * @return Raw serialized message, only containing the appropriate tags for the user. * The reference is guaranteed to be valid as long as the Message object is alive and until the same * Message is serialized for another user. */ const SerializedMessage& SerializeForUser(LocalUser* user, Message& msg); /** Serialize a high level protocol message into wire format. * @param msg High level message to serialize. Contains all necessary information about the message, including all possible tags. * @param tagwl Message tags to include in the serialized message. Tags attached to the message but not included in the whitelist must not * appear in the output. This is because each user may get a different set of tags for the same message. * @return Protocol message in wire format. Must contain message delimiter as well, if any (e.g. CRLF for RFC1459). */ virtual std::string Serialize(const Message& msg, const TagSelection& tagwl) const = 0; /** Parse a protocol message from wire format. * @param user Source of the message. * @param line Raw protocol message. * @param parseoutput Output of the parser. * @return True if the message was parsed successfully into parseoutput and should be processed, false to drop the message. */ virtual bool Parse(LocalUser* user, const std::string& line, ParseOutput& parseoutput) = 0; }; inline ClientProtocol::MessageTagData::MessageTagData(MessageTagProvider* prov, const std::string& val, void* data) : tagprov(prov) , value(val) , provdata(data) { } �������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/include/clientprotocolevent.h��������������������������������������������������������0000664�0000000�0000000�00000005237�14771603147�0021254�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2018, 2021-2022 Sadie Powell <sadie@witchery.services> * Copyright (C) 2018 Attila Molnar <attilamolnar@hush.com> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #pragma once #include "clientprotocolmsg.h" namespace ClientProtocol { namespace Events { struct Join; class Mode; } } struct CoreExport ClientProtocol::Events::Join : public ClientProtocol::Messages::Join, public ClientProtocol::Event { Join() : ClientProtocol::Event(ServerInstance->GetRFCEvents().join, *this) { } Join(Membership* Memb) : ClientProtocol::Messages::Join(Memb) , ClientProtocol::Event(ServerInstance->GetRFCEvents().join, *this) { } Join(Membership* Memb, const std::string& Sourcestr) : ClientProtocol::Messages::Join(Memb, Sourcestr) , ClientProtocol::Event(ServerInstance->GetRFCEvents().join, *this) { } }; class CoreExport ClientProtocol::Events::Mode : public ClientProtocol::Event { std::list<ClientProtocol::Messages::Mode> modelist; std::vector<Message*> modemsgplist; const Modes::ChangeList& modechanges; public: static void BuildMessages(User* source, Channel* Chantarget, User* Usertarget, const Modes::ChangeList& changelist, std::list<ClientProtocol::Messages::Mode>& modelist, std::vector<Message*>& modemsgplist) { // Build as many MODEs as necessary for (Modes::ChangeList::List::const_iterator i = changelist.getlist().begin(); i != changelist.getlist().end(); i = modelist.back().GetEndIterator()) { modelist.push_back(ClientProtocol::Messages::Mode(source, Chantarget, Usertarget, changelist, i)); modemsgplist.push_back(&modelist.back()); } } Mode(User* source, Channel* Chantarget, User* Usertarget, const Modes::ChangeList& changelist) : ClientProtocol::Event(ServerInstance->GetRFCEvents().mode) , modechanges(changelist) { BuildMessages(source, Chantarget, Usertarget, changelist, modelist, modemsgplist); SetMessageList(modemsgplist); } const Modes::ChangeList& GetChangeList() const { return modechanges; } const std::list<ClientProtocol::Messages::Mode>& GetMessages() const { return modelist; } }; �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/include/clientprotocolmsg.h����������������������������������������������������������0000664�0000000�0000000�00000053016�14771603147�0020717�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2018, 2020-2023 Sadie Powell <sadie@witchery.services> * Copyright (C) 2018 Attila Molnar <attilamolnar@hush.com> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #pragma once namespace ClientProtocol { namespace Messages { class Numeric; class Join; struct Part; struct Kick; struct Quit; struct Nick; class Mode; struct Topic; class Privmsg; struct Invite; struct Ping; struct Pong; struct Error; } } /** Numeric message. * Doesn't have a fixed command name, it's always a 3 digit number padded with zeroes if necessary. * The first parameter is the target of the numeric which is almost always the nick of the user * the numeric will be sent to. */ class CoreExport ClientProtocol::Messages::Numeric : public ClientProtocol::Message { char numericstr[4]; void InitCommand(unsigned int number) { snprintf(numericstr, sizeof(numericstr), "%03u", number); SetCommand(numericstr); } void InitFromNumeric(const ::Numeric::Numeric& numeric) { AddTags(numeric.GetParams().GetTags()); InitCommand(numeric.GetNumeric()); for (const auto& param : numeric.GetParams()) PushParamRef(param); } public: /** Constructor, target is a User. * @param num Numeric object to send. Must remain valid as long as this object is alive and must not be modified. * @param user User to send the numeric to. May be partially connected, must remain valid as long as this object is alive. */ Numeric(const ::Numeric::Numeric& num, User* user) : ClientProtocol::Message(nullptr, (num.GetServer() ? num.GetServer() : ServerInstance->FakeClient->server)->GetPublicName()) { if (user->connected & User::CONN_NICK) PushParamRef(user->nick); else PushParam("*"); InitFromNumeric(num); } /** Constructor, target is a string. * @param num Numeric object to send. Must remain valid as long as this object is alive and must not be modified. * @param target Target string, must stay valid as long as this object is alive. */ Numeric(const ::Numeric::Numeric& num, const std::string& target) : ClientProtocol::Message(nullptr, (num.GetServer() ? num.GetServer() : ServerInstance->FakeClient->server)->GetPublicName()) { PushParamRef(target); InitFromNumeric(num); } /** Constructor. Only the numeric number has to be specified. * @param num Numeric number. */ Numeric(unsigned int num) : ClientProtocol::Message(nullptr, ServerInstance->Config->GetServerName()) { InitCommand(num); PushParam("*"); } }; /** JOIN message. * Sent when a user joins a channel. */ class CoreExport ClientProtocol::Messages::Join : public ClientProtocol::Message { Membership* memb; public: /** Constructor. Does not populate parameters, call SetParams() before sending the message. */ Join() : ClientProtocol::Message("JOIN") , memb(nullptr) { } /** Constructor. * @param Memb Membership of the joining user. */ Join(Membership* Memb) : ClientProtocol::Message("JOIN", Memb->user) { SetParams(Memb); } /** Constructor. * @param Memb Membership of the joining user. * @param sourcestrref Message source string, must remain valid as long as this object is alive. */ Join(Membership* Memb, const std::string& sourcestrref) : ClientProtocol::Message("JOIN", sourcestrref, Memb->user) { SetParams(Memb); } /** Populate parameters from a Membership * @param Memb Membership of the joining user. */ void SetParams(Membership* Memb) { memb = Memb; PushParamRef(memb->chan->name); } /** Get the Membership of the joining user. * @return Membership of the joining user. */ Membership* GetMember() const { return memb; } }; /** PART message. * Sent when a user parts a channel. */ struct CoreExport ClientProtocol::Messages::Part : public ClientProtocol::Message { /** Constructor. * @param memb Member parting. * @param reason Part reason, may be empty. If non-empty, must remain valid as long as this object is alive. */ Part(Membership* memb, const std::string& reason) : ClientProtocol::Message("PART", memb->user) { PushParamRef(memb->chan->name); if (!reason.empty()) PushParamRef(reason); } }; /** KICK message. * Sent when a user is kicked from a channel. */ struct CoreExport ClientProtocol::Messages::Kick : public ClientProtocol::Message { /** Constructor. * @param source User that does the kick. * @param memb Membership of the user being kicked. * @param reason Kick reason. Must remain valid as long as this object is alive. */ Kick(User* source, Membership* memb, const std::string& reason) : ClientProtocol::Message("KICK", source) { PushParamRef(memb->chan->name); PushParamRef(memb->user->nick); PushParamRef(reason); } }; /** QUIT message. * Sent when a user quits. */ struct CoreExport ClientProtocol::Messages::Quit : public ClientProtocol::Message { /** Constructor. * @param source User quitting. * @param reason Quit reason, may be empty. Must remain valid as long as this object is alive. */ Quit(User* source, const std::string& reason) : ClientProtocol::Message("QUIT", source) { if (!reason.empty()) PushParamRef(reason); } }; /** NICK message. * Sent when a user changes their nickname. */ struct CoreExport ClientProtocol::Messages::Nick : public ClientProtocol::Message { /** Constructor. * @param source User changing nicks. * @param newnick New nickname. Must remain valid as long as this object is alive. */ Nick(User* source, const std::string& newnick) : ClientProtocol::Message("NICK", source) { PushParamRef(newnick); } }; /** MODE message. * Sent when modes are changed on a user or channel. */ class CoreExport ClientProtocol::Messages::Mode : public ClientProtocol::Message { Channel* chantarget; User* usertarget; Modes::ChangeList::List::const_iterator beginit; Modes::ChangeList::List::const_iterator lastit; /** Convert a range of a mode change list to mode letters and '+', '-' symbols. * @param list Mode change list. * @param maxlinelen Maximum output length. * @param beginit Iterator to the first element in 'list' to process. * @param lastit Iterator which is set to the first element not processed due to length limitations by the method. */ static std::string ToModeLetters(const Modes::ChangeList::List& list, std::string::size_type maxlinelen, Modes::ChangeList::List::const_iterator beginit, Modes::ChangeList::List::const_iterator& lastit) { std::string ret; std::string::size_type paramlength = 0; char output_pm = '\0'; // current output state, '+' or '-' Modes::ChangeList::List::const_iterator i; for (i = beginit; i != list.end(); ++i) { const Modes::Change& item = *i; const char needed_pm = (item.adding ? '+' : '-'); if (needed_pm != output_pm) { output_pm = needed_pm; ret.push_back(output_pm); } if (!item.param.empty()) paramlength += item.param.length() + 1; if (ret.length() + 1 + paramlength > maxlinelen) { // Mode sequence is getting too long if ((ret.back() == '+') || (ret.back() == '-')) ret.pop_back(); break; } ret.push_back(item.mh->GetModeChar()); } lastit = i; return ret; } /** Push mode parameters for modes that have one, starting at beginit to lastit (not including lastit). */ void PushModeParams() { for (Modes::ChangeList::List::const_iterator i = beginit; i != lastit; ++i) { const Modes::Change& item = *i; if (!item.param.empty()) PushParamRef(item.param); } } public: /** Convert an entire mode change list into mode letters and '+' and '-' characters. * @param changelist Mode change list to convert into mode letters. * @return Mode letters. */ static std::string ToModeLetters(const Modes::ChangeList& changelist) { std::string dummystr; Modes::ChangeList::List::const_iterator dummy; return ToModeLetters(changelist.getlist(), dummystr.max_size(), changelist.getlist().begin(), dummy); } /** Constructor, populate parameters starting from a given position in a mode change list. * @param source User doing the mode change. * @param Chantarget Channel target of the mode change. May be NULL if Usertarget is non-NULL. * @param Usertarget User target of the mode change. May be NULL if Chantarget is non-NULL. * @param changelist Mode change list. Must remain valid and unchanged as long as this object is alive or until the next SetParams() call. * @param beginiter Starting position of mode changes in 'changelist'. */ Mode(User* source, Channel* Chantarget, User* Usertarget, const Modes::ChangeList& changelist, Modes::ChangeList::List::const_iterator beginiter) : ClientProtocol::Message("MODE", source) , chantarget(Chantarget) , usertarget(Usertarget) , beginit(beginiter) { PushParamRef(GetStrTarget()); PushParam(ToModeLetters(changelist.getlist(), 450, beginit, lastit)); PushModeParams(); } /** Constructor, populate parameters starting from the beginning of a mode change list. * @param source User doing the mode change. * @param Chantarget Channel target of the mode change. May be NULL if Usertarget is non-NULL. * @param Usertarget User target of the mode change. May be NULL if Chantarget is non-NULL. * @param changelist Mode change list. Must remain valid and unchanged as long as this object is alive or until the next SetParams() call. */ Mode(User* source, Channel* Chantarget, User* Usertarget, const Modes::ChangeList& changelist) : ClientProtocol::Message("MODE", source) , chantarget(Chantarget) , usertarget(Usertarget) , beginit(changelist.getlist().begin()) { PushParamRef(GetStrTarget()); PushParam(ToModeLetters(changelist.getlist(), 450, beginit, lastit)); PushModeParams(); } /** Constructor. Does not populate parameters, call SetParams() before sending the message. * The message source is set to the local server. */ Mode() : ClientProtocol::Message("MODE", ServerInstance->FakeClient) , chantarget(nullptr) , usertarget(nullptr) { } /** Set parameters * @param Chantarget Channel target of the mode change. May be NULL if Usertarget is non-NULL. * @param Usertarget User target of the mode change. May be NULL if Chantarget is non-NULL. * @param changelist Mode change list. Must remain valid and unchanged as long as this object is alive or until the next SetParams() call. */ void SetParams(Channel* Chantarget, User* Usertarget, const Modes::ChangeList& changelist) { ClearParams(); chantarget = Chantarget; usertarget = Usertarget; beginit = changelist.getlist().begin(); PushParamRef(GetStrTarget()); PushParam(ToModeLetters(changelist.getlist(), 450, beginit, lastit)); PushModeParams(); } /** Get first mode change included in this MODE message. * @return Iterator to the first mode change that is included in this MODE message. */ Modes::ChangeList::List::const_iterator GetBeginIterator() const { return beginit; } /** Get first mode change not included in this MODE message. * @return Iterator to the first mode change that is not included in this MODE message. */ Modes::ChangeList::List::const_iterator GetEndIterator() const { return lastit; } /** Get mode change target as a string. * This is the name of the channel if the mode change targets a channel or the nickname of the user * if the target is a user. * @return Name of target as a string. */ const std::string& GetStrTarget() const { return (chantarget ? chantarget->name : usertarget->nick); } /** Get user target. * @return User target or NULL if the mode change targets a channel. */ User* GetUserTarget() const { return usertarget; } /** Get channel target. * @return Channel target or NULL if the mode change targets a user. */ Channel* GetChanTarget() const { return chantarget; } }; /** TOPIC message. */ struct CoreExport ClientProtocol::Messages::Topic : public ClientProtocol::Message { /** Constructor. * @param source User changing the topic. * @param chan Channel the topic is being changed on. * @param newtopic New topic. May be empty, must remain valid as long as this object is alive. */ Topic(User* source, const Channel* chan, const std::string& newtopic) : ClientProtocol::Message("TOPIC", source) { PushParamRef(chan->name); PushParamRef(newtopic); } }; /** PRIVMSG and NOTICE message. */ class CoreExport ClientProtocol::Messages::Privmsg : public ClientProtocol::Message { void PushTargetChan(char status, const Channel* targetchan) { if (status) { std::string rawtarget(1, status); rawtarget.append(targetchan->name); PushParam(rawtarget); } else { PushParamRef(targetchan->name); } } void PushTargetUser(const User* targetuser) { if (targetuser->connected & User::CONN_NICK) PushParamRef(targetuser->nick); else PushParam("*"); } public: /** Used to differentiate constructors that copy the text from constructors that do not. */ enum NoCopy { nocopy }; /** Get command name from MessageType. * @param mt Message type to get command name for. * @return Command name for the message type. */ static const char* CommandStrFromMsgType(MessageType mt) { return ((mt == MessageType::PRIVMSG) ? "PRIVMSG" : "NOTICE"); } /** Constructor, user source, string target, copies text. * @param source Source user. * @param target Privmsg target string. * @param text Privmsg text, will be copied. * @param mt Message type. */ Privmsg(User* source, const std::string& target, const std::string& text, MessageType mt = MessageType::PRIVMSG) : ClientProtocol::Message(CommandStrFromMsgType(mt), source) { PushParam(target); PushParam(text); } /** Constructor, user source, user target, copies text. * @param source Source user. * @param targetchan Target channel. * @param text Privmsg text, will be copied. * @param mt Message type. * @param status Prefix character for status messages. If non-zero the message is a status message. Optional, defaults to 0. */ Privmsg(User* source, const Channel* targetchan, const std::string& text, MessageType mt = MessageType::PRIVMSG, char status = 0) : ClientProtocol::Message(CommandStrFromMsgType(mt), source) { PushTargetChan(status, targetchan); PushParam(text); } /** Constructor, user source, user target, copies text. * @param source Source user. * @param targetuser Target user. * @param text Privmsg text, will be copied. * @param mt Message type. */ Privmsg(User* source, const User* targetuser, const std::string& text, MessageType mt = MessageType::PRIVMSG) : ClientProtocol::Message(CommandStrFromMsgType(mt), source) { PushTargetUser(targetuser); PushParam(text); } /** Constructor, string source, string target, copies text. * @param source Source user. * @param target Target string. * @param text Privmsg text, will be copied. * @param mt Message type. * @param status Prefix character for status messages. If non-zero the message is a status message. Optional, defaults to 0. */ Privmsg(const std::string& source, const std::string& target, const std::string& text, MessageType mt = MessageType::PRIVMSG, char status = 0) : ClientProtocol::Message(CommandStrFromMsgType(mt), source) { if (status) { std::string rawtarget(1, status); rawtarget.append(target); PushParam(rawtarget); } else { PushParam(target); } PushParam(text); } /** Constructor, string source, channel target, copies text. * @param source Source string. * @param targetchan Target channel. * @param text Privmsg text, will be copied. * @param status Prefix character for status messages. If non-zero the message is a status message. Optional, defaults to 0. * @param mt Message type. */ Privmsg(const std::string& source, const Channel* targetchan, const std::string& text, MessageType mt = MessageType::PRIVMSG, char status = 0) : ClientProtocol::Message(CommandStrFromMsgType(mt), source) { PushTargetChan(status, targetchan); PushParam(text); } /** Constructor, string source, user target, copies text. * @param source Source string. * @param targetuser Target user. * @param text Privmsg text, will be copied. * @param mt Message type. */ Privmsg(const std::string& source, const User* targetuser, const std::string& text, MessageType mt = MessageType::PRIVMSG) : ClientProtocol::Message(CommandStrFromMsgType(mt), source) { PushTargetUser(targetuser); PushParam(text); } /** Constructor, user source, string target, copies text. * @param source Source user. * @param target Target string. * @param text Privmsg text, will not be copied. * @param mt Message type. */ Privmsg(NoCopy, User* source, const std::string& target, const std::string& text, MessageType mt = MessageType::PRIVMSG) : ClientProtocol::Message(CommandStrFromMsgType(mt), source) { PushParam(target); PushParamRef(text); } /** Constructor, user source, channel target, does not copy text. * @param source Source user. * @param targetchan Target channel. * @param text Privmsg text, will not be copied. * @param status Prefix character for status messages. If non-zero the message is a status message. Optional, defaults to 0. * @param mt Message type. */ Privmsg(NoCopy, User* source, const Channel* targetchan, const std::string& text, MessageType mt = MessageType::PRIVMSG, char status = 0) : ClientProtocol::Message(CommandStrFromMsgType(mt), source) { PushTargetChan(status, targetchan); PushParamRef(text); } /** Constructor, user source, user target, does not copy text. * @param source Source user. * @param targetuser Target user. * @param text Privmsg text, will not be copied. * @param mt Message type. */ Privmsg(NoCopy, User* source, const User* targetuser, const std::string& text, MessageType mt = MessageType::PRIVMSG) : ClientProtocol::Message(CommandStrFromMsgType(mt), source) { PushTargetUser(targetuser); PushParamRef(text); } /** Constructor, string source, string target, does not copy text. * @param source Source string. * @param target Target string. * @param text Privmsg text, will not be copied. * @param mt Message type. */ Privmsg(NoCopy, const std::string& source, const std::string& target, const std::string& text, MessageType mt = MessageType::PRIVMSG) : ClientProtocol::Message(CommandStrFromMsgType(mt), source) { PushParam(target); PushParamRef(text); } /** Constructor, string source, channel target, does not copy text. * @param source Source string. * @param targetchan Target channel. * @param text Privmsg text, will not be copied. * @param status Prefix character for status messages. If non-zero the message is a status message. Optional, defaults to 0. * @param mt Message type. */ Privmsg(NoCopy, const std::string& source, const Channel* targetchan, const std::string& text, MessageType mt = MessageType::PRIVMSG, char status = 0) : ClientProtocol::Message(CommandStrFromMsgType(mt), source) { PushTargetChan(status, targetchan); PushParamRef(text); } /** Constructor, string source, user target, does not copy text. * @param source Source string. * @param targetuser Target user. * @param text Privmsg text, will not be copied. * @param mt Message type. */ Privmsg(NoCopy, const std::string& source, const User* targetuser, const std::string& text, MessageType mt = MessageType::PRIVMSG) : ClientProtocol::Message(CommandStrFromMsgType(mt), source) { PushTargetUser(targetuser); PushParamRef(text); } }; /** INVITE message. * Sent when a user is invited to join a channel. */ struct CoreExport ClientProtocol::Messages::Invite : public ClientProtocol::Message { /** Constructor. * @param source User inviting the target user. * @param target User being invited by source. * @param chan Channel the target user is being invited to. */ Invite(User* source, User* target, Channel* chan) : ClientProtocol::Message("INVITE", source) { PushParamRef(target->nick); PushParamRef(chan->name); } }; /** PING message. * Used to check if a connection is still alive. */ struct CoreExport ClientProtocol::Messages::Ping : public ClientProtocol::Message { /** Constructor. * The ping cookie is the name of the local server. */ Ping() : ClientProtocol::Message("PING") { PushParamRef(ServerInstance->Config->GetServerName()); } /** Constructor. * @param cookie Ping cookie. Must remain valid as long as this object is alive. */ Ping(const std::string& cookie) : ClientProtocol::Message("PING") { PushParamRef(cookie); } }; /** PONG message. * Sent as a reply to PING. */ struct CoreExport ClientProtocol::Messages::Pong : public ClientProtocol::Message { /** Constructor. * @param cookie Ping cookie. Must remain valid as long as this object is alive. * @param server Pinged server. Must remain valid as long as this object is alive. */ Pong(const std::string& cookie, const std::string& server = "") : ClientProtocol::Message("PONG", ServerInstance->Config->GetServerName()) { PushParamRef(server); PushParamRef(cookie); } }; /** ERROR message. * Sent to clients upon disconnection. */ struct CoreExport ClientProtocol::Messages::Error : public ClientProtocol::Message { /** Constructor. * @param text Error text. */ Error(const std::string& text) : ClientProtocol::Message("ERROR") { PushParam(text); } }; ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/include/command_parse.h��������������������������������������������������������������0000664�0000000�0000000�00000017405�14771603147�0017762�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2013-2014, 2016, 2018 Attila Molnar <attilamolnar@hush.com> * Copyright (C) 2012-2013, 2018, 2020-2022 Sadie Powell <sadie@witchery.services> * Copyright (C) 2012 Robby <robby@chatbelgie.be> * Copyright (C) 2009 Daniel De Graaf <danieldg@inspircd.org> * Copyright (C) 2007 Robin Burchell <robin+git@viroteck.net> * Copyright (C) 2007 Dennis Friis <peavey@inspircd.org> * Copyright (C) 2006-2008 Craig Edwards <brain@inspircd.org> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #pragma once /** This class handles command management and parsing. * It allows you to add and remove commands from the map, * call command handlers by name, and chop up comma separated * parameters into multiple calls. */ class CoreExport CommandParser final { public: typedef std::unordered_map<std::string, Command*, irc::insensitive, irc::StrHashComp> CommandMap; private: /** Command list, a hash_map of command names to Command* */ CommandMap cmdlist; public: /** Get a command name -> Command* map containing all client to server commands * @return A map of command handlers keyed by command names */ const CommandMap& GetCommands() const { return cmdlist; } /** Calls the handler for a given command. * @param commandname The command to find. This should be in uppercase. * @param parameters Parameter list * @param user The user to call the handler on behalf of * @param cmd If non-NULL and the command was executed it is set to the command handler, * otherwise it isn't written to. * @return This method will return CmdResult::SUCCESS if the command handler was found and called, * and the command completeld successfully. It will return CmdResult::FAILURE if the command handler was found * and called, but the command did not complete successfully, and it will return CmdResult::INVALID if the * command simply did not exist at all or the wrong number of parameters were given, or the user * was not privileged enough to execute the command. */ CmdResult CallHandler(const std::string& commandname, const CommandBase::Params& parameters, User* user, Command** cmd = nullptr); /** Get the handler function for a command. * @param commandname The command required. Always use uppercase for this parameter. * @return a pointer to the command handler, or NULL */ Command* GetHandler(const std::string& commandname); /** LoopCall is used to call a command handler repeatedly based on the contents of a comma separated list. * There are two ways to call this method, either with one potential list or with two potential lists. * We need to handle two potential lists for JOIN, because a JOIN may contain two lists of items at once: * the channel names and their keys as follows: * * JOIN \#chan1,\#chan2,\#chan3 key1,,key3 * * Therefore, we need to deal with both lists concurrently. If there are two lists then the method reads * them both together until the first runs out of tokens. * With one list it is much simpler, and is used in NAMES, WHOIS, PRIVMSG etc. * * If there is only one list and there are duplicates in it, then the command handler is only called for * unique items. Entries are compared using "irc comparison". * If the usemax parameter is true (the default) the function only parses until it reaches * ServerInstance->Config->MaxTargets number of targets, to stop abuse via spam. * * The OnPostCommand hook is executed for each item after it has been processed by the handler, with the * original line parameter being empty (to indicate that the command in that form was created by this function). * This only applies if the user executing the command is local. * * If there are two lists and the second list runs out of tokens before the first list then parameters[extra] * will be an EMPTY string when Handle() is called for the remaining tokens in the first list, even if it is * in the middle of parameters[]! Moreover, empty tokens in the second list are allowed, and those will also * result in the appropriate entry being empty in parameters[]. * This is different than what command handlers usually expect; the command parser only allows an empty param * as the last item in the vector. * * @param user The user who sent the command * @param handler The command handler to call for each parameter in the list * @param parameters Parameter list as a vector of strings * @param splithere The first parameter index to split as a comma separated list * @param extra The second parameter index to split as a comma separated list, or -1 (the default) if there is only one list * @param usemax True to limit the command to MaxTargets targets (default), or false to process all tokens * @return This function returns true when it identified a list in the given parameter and finished calling the * command handler for each entry on the list. When this occurs, the caller should return without doing anything, * otherwise it should continue into its main section of code. */ static bool LoopCall(User* user, Command* handler, const CommandBase::Params& parameters, unsigned int splithere, int extra = -1, bool usemax = true); /** Take a raw input buffer from a recvq, and process it on behalf of a user. * @param buffer The buffer line to process * @param user The user to whom this line belongs */ void ProcessBuffer(LocalUser* user, const std::string& buffer); /** Process a command from a user. * @param user The user to parse the command for. * @param command The name of the command. * @param parameters The parameters to the command. */ void ProcessCommand(LocalUser* user, std::string& command, CommandBase::Params& parameters); /** Add a new command to the commands hash * @param f The new Command to add to the list * @return True if the command was added */ bool AddCommand(Command* f); /** Removes a command. */ void RemoveCommand(Command* x); /** Translate a single item based on the TranslationType given. * @param to The translation type to use for the process * @param item The input string * @param dest The output string. The translation result will be appended to this string * @param custom_translator Used to translate the parameter if the translation type is TR_CUSTOM, if NULL, TR_CUSTOM will act like TR_TEXT * @param paramnumber The index of the parameter we are translating. */ static void TranslateSingleParam(TranslateType to, const std::string& item, std::string& dest, CommandBase* custom_translator = nullptr, unsigned int paramnumber = 0); /** Translate nicknames in a list of strings into UIDs, based on the TranslateTypes given. * @param to The translation types to use for the process. If this list is too short, TR_TEXT is assumed for the rest. * @param source The strings to translate * @param prefix_final True if the final source argument should have a colon prepended (if it could contain a space) * @param custom_translator Used to translate the parameter if the translation type is TR_CUSTOM, if NULL, TR_CUSTOM will act like TR_TEXT * @return dest The output string */ static std::string TranslateUIDs(const std::vector<TranslateType>& to, const CommandBase::Params& source, bool prefix_final = false, CommandBase* custom_translator = nullptr); }; �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/include/compat.h���������������������������������������������������������������������0000664�0000000�0000000�00000004044�14771603147�0016430�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2013, 2022-2023 Sadie Powell <sadie@witchery.services> * Copyright (C) 2013 Attila Molnar <attilamolnar@hush.com> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #pragma once /** * @def ATTR_NOT_NULL(...) * Enables the compile-time checking of arguments that must never be be null. If * a function is marked with this attribute then the compiler will warnif a null * pointer is passed to any of the specified arguments. */ #if defined __GNUC__ # define ATTR_NOT_NULL(...) __attribute__((nonnull(__VA_ARGS__))) #else # define ATTR_NOT_NULL(...) #endif /** @def INSP_FORMAT(FORMAT, ...) * Formats a string with format string checking. */ #if defined __cpp_if_constexpr && defined __cpp_return_type_deduction # include <fmt/compile.h> # define INSP_FORMAT(FORMAT, ...) fmt::format(FMT_COMPILE(FORMAT), __VA_ARGS__) #else # include <fmt/core.h> # define INSP_FORMAT(FORMAT, ...) fmt::format(FMT_STRING(FORMAT), __VA_ARGS__) #endif /** * Windows is very different to UNIX so we have to wrap certain features in * order to build on Windows correctly. */ #ifdef _WIN32 # include "win32wrapper.h" # ifdef INSPIRCD_CORE # define CoreExport __declspec(dllexport) # define DllExport __declspec(dllimport) # else # define CoreExport __declspec(dllimport) # define DllExport __declspec(dllexport) # endif #else # define DllExport __attribute__ ((visibility ("default"))) # define CoreExport __attribute__ ((visibility ("default"))) #endif ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/include/configparser.h���������������������������������������������������������������0000664�0000000�0000000�00000003123�14771603147�0017624�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2014 Attila Molnar <attilamolnar@hush.com> * Copyright (C) 2013, 2016, 2020-2023 Sadie Powell <sadie@witchery.services> * Copyright (C) 2012 Robby <robby@chatbelgie.be> * Copyright (C) 2009-2010 Daniel De Graaf <danieldg@inspircd.org> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #pragma once typedef std::unique_ptr<FILE, int(*)(FILE*)> FilePtr; struct ParseStack final { std::vector<std::string> reading; insp::flat_map<std::string, std::string, irc::insensitive_swo> vars; ServerConfig::TagMap& output; ServerConfig::FileSource& FilesOutput; std::stringstream& errstr; ParseStack(ServerConfig* conf); bool ParseFile(const std::string& name, int flags, const std::string& mandatory_tag = std::string(), bool isexec = false); void DoInclude(const std::shared_ptr<ConfigTag>& includeTag, int flags); void DoReadFile(const std::string& key, const std::string& file, int flags, bool exec); static FilePtr DoOpenFile(const std::string& name, bool isexec); }; ���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/include/configreader.h���������������������������������������������������������������0000664�0000000�0000000�00000050310�14771603147�0017572�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2018 Chris Novakovic * Copyright (C) 2013-2014 Attila Molnar <attilamolnar@hush.com> * Copyright (C) 2012-2014, 2016-2024 Sadie Powell <sadie@witchery.services> * Copyright (C) 2012 Robby <robby@chatbelgie.be> * Copyright (C) 2009-2010 Daniel De Graaf <danieldg@inspircd.org> * Copyright (C) 2008 Thomas Stagner <aquanight@gmail.com> * Copyright (C) 2007-2008 Robin Burchell <robin+git@viroteck.net> * Copyright (C) 2007-2008 Craig Edwards <brain@inspircd.org> * Copyright (C) 2007 Dennis Friis <peavey@inspircd.org> * Copyright (C) 2006 Oliver Lupton <om@inspircd.org> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #pragma once #include "inspircd.h" /** Represents the position within a file. */ class CoreExport FilePosition final { public: /** The name of the file that the position points to. */ std::string name; /** The line of the file that this position points to. */ unsigned long line; /** The column of the file that this position points to. */ unsigned long column; /** Initialises a new file position with the specified name, line, and column. * @param Name The name of the file that the position points to. * @param Line The line of the file that this position points to. * @param Column The column of the file that this position points to. */ FilePosition(const std::string& Name, unsigned long Line, unsigned long Column); /** Returns a string that represents this file position. */ std::string str() const; }; /** Structure representing a single \<tag> in config */ class CoreExport ConfigTag final { public: /** A mapping of configuration keys to their assigned values. */ typedef insp::flat_map<std::string, std::string, irc::insensitive_swo> Items; private: Items items; /** Retrieves the value of a signed integer from the server config. * @param key The config key to retrieve. * @param def The default value to return if not set, empty, or out of range. * @param min The minimum valid value. * @param max The maximum valid value. */ long double getFloat(const std::string& key, long double def, long double min, long double max) const; /** Retrieves the value of a signed integer from the server config. * @param key The config key to retrieve. * @param def The default value to return if not set, empty, or out of range. * @param min The minimum valid value. * @param max The maximum valid value. */ intmax_t getSInt(const std::string& key, intmax_t def, intmax_t min, intmax_t max) const; /** Retrieves the value of an unsigned integer from the server config. * @param key The config key to retrieve. * @param def The default value to return if not set, empty, or out of range. * @param min The minimum valid value. * @param max The maximum valid value. */ uintmax_t getUInt(const std::string& key, uintmax_t def, uintmax_t min, uintmax_t max) const; public: /** The name of the configuration tag (e.g. "foo" for \<foo bar="baz">). */ const std::string name; /** The position within the source file that this tag was read from. */ const FilePosition source; /** Creates a new ConfigTag instance with the specified tag name, file, and line. * @param Name The name of this config tag (e.g. "foo" for \<foo bar="baz">). * @param Source The source of this config tag. */ ConfigTag(const std::string& Name, const FilePosition& Source); /** @copydoc getFloat */ template<typename T> std::enable_if_t<std::is_floating_point_v<T>, T> getNum(const std::string& key, T def, T min = std::numeric_limits<T>::min(), T max = std::numeric_limits<T>::max()) const { return static_cast<T>(getFloat(key, def, min, max)); } /** @copydoc getSInt */ template<typename T> std::enable_if_t<std::is_signed_v<T> && !std::is_floating_point_v<T>, T> getNum(const std::string& key, T def, T min = std::numeric_limits<T>::min(), T max = std::numeric_limits<T>::max()) const { return static_cast<T>(getSInt(key, def, min, max)); } /** @copydoc getUInt */ template<typename T> std::enable_if_t<std::is_unsigned_v<T> && !std::is_floating_point_v<T>, T> getNum(const std::string& key, T def, T min = std::numeric_limits<T>::min(), T max = std::numeric_limits<T>::max()) const { return static_cast<T>(getUInt(key, def, min, max)); } /** Get the value of an option, using def if it does not exist */ std::string getString(const std::string& key, const std::string& def, const std::function<bool(const std::string&)>& validator) const; /** Get the value of an option, using def if it does not exist */ std::string getString(const std::string& key, const std::string& def = "", size_t minlen = 0, size_t maxlen = UINT32_MAX) const; /** Get the value of an option, using def if it does not exist */ bool getBool(const std::string& key, bool def = false) const; /** Get the value of an option, using def if it does not exist */ unsigned char getCharacter(const std::string& key, unsigned char def = '\0', bool emptynul = false) const; /** Get the value in seconds of a duration that is in the user-friendly "1h2m3s" format, * using a default value if it does not exist or is out of bounds. * @param key The config key name * @param def Default value (optional) * @param min Minimum acceptable value (optional) * @param max Maximum acceptable value (optional) * @return The duration in seconds */ unsigned long getDuration(const std::string& key, unsigned long def, unsigned long min = 0, unsigned long max = ULONG_MAX) const; template<typename TReturn> TReturn getEnum(const std::string& key, TReturn def, std::initializer_list<std::pair<const char*, TReturn>> enumvals) { const std::string val = getString(key); if (val.empty()) return def; for (const auto& [enumkey, enumval] : enumvals) if (strcasecmp(val.c_str(), enumkey) == 0) return enumval; // Unfortunately we have to iterate this twice. std::string enumdef = "(unknown)"; std::string enumkeys; for (const auto& [enumkey, enumval] : enumvals) { enumkeys.append(enumkey).append(", "); if (enumval == def) enumdef = enumkey; } if (!enumkeys.empty()) enumkeys.erase(enumkeys.length() - 2); LogMalformed(key, val, enumdef, "not one of " + enumkeys); return def; } /** Get the value of an option * @param key The option to get * @param value The location to store the value (unmodified if does not exist) * @param allow_newline Allow newlines in the option (normally replaced with spaces) * @return true if the option exists */ bool readString(const std::string& key, std::string& value, bool allow_newline = false) const; /** Retrieves the underlying map of config entries. */ inline const Items& GetItems() const { return items; } inline Items& GetItems() { return items; } /** @internal Logs that the value of a config field is malformed. */ void LogMalformed(const std::string& key, const std::string& val, const std::string& def, const std::string& reason) const; }; struct CommandLineConf final { /** If this value is true, the owner of the * server specified -nofork on the command * line, causing the daemon to stay in the * foreground. */ bool nofork; /** If this value if true then all log * messages will be output, regardless of * the level given in the config file. * This is set with the -debug commandline * option. */ bool forcedebug; /** If enabled then protocol traffic is being logged. */ bool forceprotodebug; /** If this is true then log output will be * written to the logfile. This is the default. * If you put -nolog on the commandline then * the logfile will not be written. * This is meant to be used in conjunction with * -debug for debugging without filling up the * hard disk. */ bool writelog; /** If this is true, a PID file will be written * to the file given in the "file" variable of * the \<pid> tag in the config file. This is * the default. * Passing --nopid as a command line argument * sets this to false; in this case, a PID file * will not be written, even the default PID * file that is usually written when the \<pid> * tag is not defined in the config file. */ bool writepid; /* Whether the --runasroot option was specified at boot. */ bool runasroot; /** Saved argc from startup. */ int argc; /** Saved argv from startup. */ char** argv; }; /** This class holds the bulk of the runtime configuration for the ircd. * It allows for reading new config values, accessing configuration files, * and storage of the configuration data needed to run the ircd, such as * the servername, connect classes, /ADMIN data, MOTDs and filenames etc. */ class CoreExport ServerConfig final { private: friend class ConfigReaderThread; // valid friend struct ParseStack; // config_data, errstr, filesources /** Holds the contents of a cached file. */ typedef insp::flat_map<std::string, std::pair<std::string, time_t>> FileCache; /** Holds the contents of a cached file. */ typedef insp::flat_map<std::string, std::pair<std::string, bool>, irc::insensitive_swo> FileSource; /** Holds the server config. */ typedef std::multimap<std::string, std::shared_ptr<ConfigTag>, irc::insensitive_swo> TagMap; /** The server config. */ TagMap config_data; /** Whether any errors occurred whilst reading the server config. */ std::stringstream errstr; /** Files which have been read from disk. */ FileCache filecontents; /** The location of files from \<[exec]files>. */ FileSource filesources; /** Whether the server config is valid. */ bool valid; /** Loads added modules and unloads any removed ones. * @param user If non-nullptr then the user who initiated this config load. */ void ApplyModules(User* user) const; /** Ensures that connect classes are well formed. * @param current The current server config that is about to be replaced. */ void CrossCheckConnectBlocks(ServerConfig* current); /** Ensures that oper accounts, oper types, and oper classes are well formed. */ void CrossCheckOperBlocks(); /** Reads the core server config. */ void Fill(); public: /** How to treat a user in a channel who is banned. */ enum BannedUserTreatment : uint8_t { /** Don't treat a banned user any different to normal. */ BUT_NORMAL, /** Restrict the actions of a banned user. */ BUT_RESTRICT_SILENT, /** Restrict the actions of a banned user and notify them of their treatment. */ BUT_RESTRICT_NOTIFY }; /** Encapsulates the result of calling ReadFile. */ class CoreExport ReadResult final : private insp::uncopiable { public: /* If the read succeeded then the contents of the file. */ const std::string& contents; /* If the read failed then the reason why. */ const std::string error; ReadResult(const std::string& c, const std::string& e); /** Allows nicer evaluation of a read result */ inline operator bool() const { return error.empty(); } }; /** Holds the limits for how long various fields can be. Read from the \<limits> tag. */ class CoreExport ServerLimits final { public: /** Maximum line length */ size_t MaxLine; /** Maximum nickname length */ size_t MaxNick; /** Maximum channel length */ size_t MaxChannel; /** Maximum number of modes per line */ size_t MaxModes; /** Maximum length of a username */ size_t MaxUser; /** Maximum length of a quit message */ size_t MaxQuit; /** Maximum topic length */ size_t MaxTopic; /** Maximum kick message length */ size_t MaxKick; /** Maximum real name length */ size_t MaxReal; /** Maximum away message length */ size_t MaxAway; /** Maximum hostname length */ size_t MaxHost; /** Read all limits from a config tag. Limits which aren't specified in the tag are set to a default value. * @param tag Configuration tag to read the limits from */ ServerLimits(const std::shared_ptr<ConfigTag>& tag); /** Maximum length of a n!u\@h mask */ size_t GetMaxMask() const { return MaxNick + 1 + MaxUser + 1 + MaxHost; } }; /** Holds the location of various directories. Read from the \<path> tag */ class CoreExport ServerPaths final { private: /** Expands a path fragment to a full path. * @param base The base path to expand from * @param fragment The path fragment to expand on top of base. */ static std::string ExpandPath(const std::string& base, const std::string& fragment); public: /** Config path */ std::string Config; /** Data path */ std::string Data; /** Log path */ std::string Log; /** Module path */ std::string Module; /** Runtime path */ std::string Runtime; ServerPaths(const std::shared_ptr<ConfigTag>& tag); inline std::string PrependConfig(const std::string& fn) const { return ExpandPath(Config, fn); } inline std::string PrependData(const std::string& fn) const { return ExpandPath(Data, fn); } inline std::string PrependLog(const std::string& fn) const { return ExpandPath(Log, fn); } inline std::string PrependModule(const std::string& fn) const { return ExpandPath(Module, fn); } inline std::string PrependRuntime(const std::string& fn) const { return ExpandPath(Runtime, fn); } }; /** Holds the connect classes from the server config. */ typedef std::vector<std::shared_ptr<ConnectClass>> ClassVector; /** Holds the oper accounts from the server config. */ typedef insp::flat_map<std::string, std::shared_ptr<OperAccount>> OperAccountMap; /** Holds the oper types from the server config. */ typedef insp::flat_map<std::string, std::shared_ptr<OperType>> OperTypeMap; /** Holds iterators to a subsection of the server config map. */ typedef insp::iterator_range<TagMap::const_iterator> TagList; /** The connect classes from the server config. */ ClassVector Classes; /** The configuration read from the command line. */ CommandLineConf CommandLine; /** An empty configuration tag. */ std::shared_ptr<ConfigTag> EmptyTag; /** The limits for how long various fields can be. */ ServerLimits Limits; /** The location of various directories. */ ServerPaths Paths; /** Oper accounts keyed by their name. */ OperAccountMap OperAccounts; /** Oper types keyed by their name. */ OperTypeMap OperTypes; /** The name of the casemapping method used by this server. */ std::string CaseMapping = "ascii"; /** The value to show in the comment field of the RPL_VERSION. */ std::string CustomVersion; /** The modes to set on a new channel. May contain channel prefix modes to set on the channel creator. */ std::string DefaultModes; /** If non-empty then the value to replace the server name with in public messages. */ std::string HideServer; /* The name of the IRC network (e.g. ExampleNet). */ std::string Network; /** The description of the IRC server (e.g. ExampleNet European Server). */ std::string ServerDesc; /** The unique identifier for this server. Must be in the format [0-9][A-Z0-9][A-Z0-9]. */ std::string ServerId; /** The hostname of the IRC server (e.g. irc.example.com). */ std::string ServerName; /** The message to send to users when they are banned by an X-line. */ std::string XLineMessage; /** The quit message to use when killing an X-lined user. */ std::string XLineQuit; /** If non-empty then the public quit message to use when killing an X-lined user. */ std::string XLineQuitPublic; /** The CIDR range to use when determining if IPv4 clients are from the same origin. */ unsigned char IPv4Range; /** The CIDR range to use when determining if IPv4 clients are from the same origin. */ unsigned char IPv6Range; /** How to treat a user in a channel who is banned. */ BannedUserTreatment RestrictBannedUsers; /** The maximum number of connections that can be waiting in the server accept queue. */ int MaxConn; /** The number of seconds that the server clock can skip by before server operators are warned. */ time_t TimeSkipWarn; /** The maximum number of targets for a multi-target command (e.g. KICK). */ size_t MaxTargets; /** The maximum amount of data to read from a socket in one go. */ size_t NetBufferSize; /** The maximum number of local connections that can be made to the IRC server. */ size_t SoftLimit; /** Whether to store the full nick!duser\@dhost as a list mode setter instead of just their nick. */ bool MaskInList; /** Whether to store the full nick!duser\@dhost as a topic setter instead of just their nick. */ bool MaskInTopic; /** Whether to disable stacking snotices when multiple identical messages are sent. */ bool NoSnoticeStack; /** Whether raw I/O traffic is being logged. */ bool RawLog = false; /** Whether to show syntax hints when a user does not provide enough parameters for a command. */ bool SyntaxHints; /** Whether to bind to IPv6 by default. */ bool WildcardIPv6; ServerConfig(); /** Apply configuration changes from the old configuration. */ void Apply(ServerConfig* old, const std::string& useruid); /** Get a list of configuration tags by name. * @param tag The name of the tags to get. * @param def The value to return if the tag doesn't exist. * @returns Either a list of tags from the config or an empty TagList. */ TagList ConfTags(const std::string& tag, std::optional<TagList> def = std::nullopt) const; /** Get a configuration tag by name. If one or more tags are present then the first is returned. * @param tag The name of the tag to get. * @param def The value to return if the tag doesn't exist. * @returns Either a tag from the config or EmptyTag. */ const std::shared_ptr<ConfigTag>& ConfValue(const std::string& tag, const std::shared_ptr<ConfigTag>& def = nullptr) const; /** Escapes a value for storage in a configuration key. * @param str The string to escape. */ static std::string Escape(const std::string& str); /** Retrieves the entire server config. */ const auto& GetConfig() const { return config_data; } /** Retrieves the list of modules that were specified in the config. */ std::vector<std::string> GetModules() const; /** Retrieves the server description which should be shown to users. */ const auto& GetServerDesc() const { return HideServer.empty() ? ServerDesc : Network; } /** Retrieves the server name which should be shown to users. */ const auto& GetServerName() const { return HideServer.empty() ? ServerName : HideServer; } /** Attempt to read the configuration from disk. */ void Read(); /** Reads a file from disk. * @param file The file to read from. May also be an \<[exec]files> key. * @param mincache If non-zero then invalidate cached copies from before the specified time. * @return The result of the read operation. */ ReadResult ReadFile(const std::string& file, time_t mincache = 0); }; /** The background thread for config reading, so that reading from executable includes * does not block. */ class CoreExport ConfigReaderThread final : public Thread { private: /** The new server configuration. */ ServerConfig* Config = new ServerConfig(); /** Whether the config has been read yet. */ std::atomic_bool done = { false }; protected: /** @copydoc Thread::OnStart */ void OnStart() override; /** @copydoc Thread::OnStop */ void OnStop() override; public: const std::string UUID; ConfigReaderThread(const std::string& uuid) : UUID(uuid) { } ~ConfigReaderThread() override { delete Config; } /** Whether the configuration has been read yet. */ bool IsDone() { return done.load(); } }; /** Represents the status of a config load. */ class CoreExport ConfigStatus final { public: /** Whether this is the initial config load. */ bool const initial; /** The user who initiated the config load or NULL if not initiated by a user. */ User* const srcuser; /** Initializes a new instance of the ConfigStatus class. * @param user The user who initiated the config load or NULL if not initiated by a user. * @param isinitial Whether this is the initial config load. */ ConfigStatus(User* user = nullptr, bool isinitial = false) : initial(isinitial) , srcuser(user) { } }; ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/include/convto.h���������������������������������������������������������������������0000664�0000000�0000000�00000007630�14771603147�0016461�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2019, 2021, 2023-2024 Sadie Powell <sadie@witchery.services> * Copyright (C) 2016 Attila Molnar <attilamolnar@hush.com> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #pragma once /** No-op function that returns the string that was passed to it. * @param in The string to return. */ inline const std::string& ConvToStr(const std::string& in) { return in; } /** Converts a string_view to a string. * @param in The value to convert. */ inline std::string ConvToStr(const std::string_view& in) { return std::string(in); } /** Converts a char array to a string. * @param in The value to convert. */ inline std::string ConvToStr(const char* in) { return std::string(in); } /** Converts a char to a string. * @param in The value to convert. */ inline std::string ConvToStr(char in) { return std::string(1, static_cast<std::string::value_type>(in)); } /** Converts an unsigned char to a string. * @param in The value to convert. */ inline std::string ConvToStr(unsigned char in) { return std::string(1, static_cast<std::string::value_type>(in)); } /** Converts a bool to a string. * @param in The value to convert. */ inline std::string ConvToStr(const bool in) { return (in ? "1" : "0"); } /** Converts a type that to_string is implemented for to a string. * @param in The value to convert. */ template<typename Stringable> inline std::enable_if_t<std::is_arithmetic_v<Stringable>, std::string> ConvToStr(const Stringable& in) { return std::to_string(in); } /** Converts a type that fmtlib can format to a string. * @param in The value to convert. */ template<typename Formattable> inline std::enable_if_t<!std::is_arithmetic_v<Formattable> && fmt::is_formattable<Formattable>::value, std::string> ConvToStr(const Formattable& in) { return INSP_FORMAT("{}", in); } /** Converts any type to a string. * @param in The value to convert. */ template <class T> inline std::enable_if_t<!std::is_arithmetic_v<T> && !fmt::is_formattable<T>::value, std::string> ConvToStr(const T& in) { std::stringstream tmp; if (!(tmp << in)) return std::string(); return tmp.str(); } /** Converts a string to a numeric type. * @param in The string to convert to a numeric type. * @param def The value to return if the string could not be converted (defaults to 0) */ template<typename Numeric> inline Numeric ConvToNum(const std::string& in, Numeric def = 0) { Numeric ret; std::istringstream tmp(in); if (!(tmp >> ret)) return def; return ret; } /** Specialisation of ConvToNum so istringstream doesn't try to extract a text character. * @param in The string to convert to a numeric type. * @param def The value to return if the string could not be converted (defaults to 0) */ template<> inline char ConvToNum<char>(const std::string& in, char def) { int16_t num = ConvToNum<int16_t>(in, def); return num >= INT8_MIN && num <= INT8_MAX ? static_cast<char>(num) : def; } /** Specialisation of ConvToNum so istringstream doesn't try to extract a text character. * @param in The string to convert to a numeric type. * @param def The value to return if the string could not be converted (defaults to 0) */ template<> inline unsigned char ConvToNum<unsigned char>(const std::string& in, unsigned char def) { uint16_t num = ConvToNum<uint16_t>(in, def); return num <= UINT8_MAX ? static_cast<unsigned char>(num) : def; } ��������������������������������������������������������������������������������������������������������inspircd-4.7.0/include/ctables.h��������������������������������������������������������������������0000664�0000000�0000000�00000025303�14771603147�0016563�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2012-2015, 2018 Attila Molnar <attilamolnar@hush.com> * Copyright (C) 2012-2013, 2017-2022 Sadie Powell <sadie@witchery.services> * Copyright (C) 2012 Robby <robby@chatbelgie.be> * Copyright (C) 2009 Daniel De Graaf <danieldg@inspircd.org> * Copyright (C) 2008 Thomas Stagner <aquanight@gmail.com> * Copyright (C) 2007-2008 Robin Burchell <robin+git@viroteck.net> * Copyright (C) 2007 Dennis Friis <peavey@inspircd.org> * Copyright (C) 2003, 2006-2009 Craig Edwards <brain@inspircd.org> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #pragma once /** Used to indicate the type of a command. */ enum class CmdAccess : uint8_t { /* The command has no special attributes. */ NORMAL = 0, /** Only server operators can use the command. */ OPERATOR = 1, /** Only servers can use the command. */ SERVER = 2, }; /** Used to indicate the result of trying to execute a command. */ enum class CmdResult : uint8_t { /** The command exists and its execution succeeded. */ SUCCESS = 0, /** The command exists but its execution failed. */ FAILURE = 1, /* The command does not exist. */ INVALID = 2, }; /** Translation types for translation of parameters to UIDs. * This allows the core commands to not have to be aware of how UIDs * work (making it still possible to write other linking modules which * do not use UID (but why would you want to?) */ enum TranslateType { TR_TEXT, /* Raw text, leave as-is */ TR_NICK, /* Nickname, translate to UUID for server->server */ TR_CUSTOM /* Custom translation handled by EncodeParameter/DecodeParameter */ }; /** The type of routes that a message can take. */ enum class RouteType : uint8_t { /** The message is only routed to the local server. */ LOCAL, /** The message is routed to all servers. */ BROADCAST, /** The message is routed to all servers using ENCAP. */ OPTIONAL_BROADCAST, /** The message is routed to a specific remote server. */ UNICAST, /** The message is routed to a specific remote server using ENCAP. */ OPTIONAL_UNICAST, /** The message is routed to a specific user, channel, or server mask. */ MESSAGE, }; /** Describes the routing of an IRC message. */ class RouteDescriptor final { public: /** The target of the message in question. */ const std::string target; /** The type of route that the message should take. */ const RouteType type; /** For unicast messages a specific server that the message should be routed to. */ const Server* server; /** Creates a new route descriptor with the specified route type and target string. */ RouteDescriptor(RouteType rt, const std::string& t) : target(t) , type(rt) , server(nullptr) { } RouteDescriptor(RouteType rt, const Server* s = nullptr) : type(rt) , server(s) { } }; /** The message is only routed to the local server. */ #define ROUTE_LOCALONLY (RouteDescriptor(RouteType::LOCAL)) /** The message is routed to all servers. */ #define ROUTE_BROADCAST (RouteDescriptor(RouteType::BROADCAST)) /** The message is routed to all servers using ENCAP. */ #define ROUTE_OPT_BCAST (RouteDescriptor(RouteType::OPTIONAL_BROADCAST)) /** The message is routed to a specific remote server. */ #define ROUTE_UNICAST(dest) (RouteDescriptor(RouteType::UNICAST, dest)) /** The message is routed to a specific remote server using ENCAP. */ #define ROUTE_OPT_UCAST(dest) (RouteDescriptor(RouteType::OPTIONAL_UNICAST, dest)) /** The message is routed to a specific user, channel, or server mask. */ #define ROUTE_MESSAGE(dest) (RouteDescriptor(RouteType::MESSAGE, dest)) /** A structure that defines a command. Every command available * in InspIRCd must be defined as derived from Command. */ class CoreExport CommandBase : public ServiceProvider { public: /** Encapsulates parameters to a command. */ class Params : public std::vector<std::string> { private: /* IRCv3 message tags. */ ClientProtocol::TagMap tags; public: /** Initializes a new instance from parameter and tag references. * @param paramsref Message parameters. * @param tagsref IRCv3 message tags. */ Params(const std::vector<std::string>& paramsref, const ClientProtocol::TagMap& tagsref) : std::vector<std::string>(paramsref) , tags(tagsref) { } /** Initializes a new instance from parameter iterators. * @param first The first element in the parameter array. * @param last The last element in the parameter array. */ template<typename Iterator> Params(Iterator first, Iterator last) : std::vector<std::string>(first, last) { } /** Initializes a new empty instance. */ Params() = default; /** Retrieves the IRCv3 message tags. */ const ClientProtocol::TagMap& GetTags() const { return tags; } ClientProtocol::TagMap& GetTags() { return tags; } }; /** Minimum number of parameters command takes */ const unsigned int min_params; /** Maximum number of parameters command takes. * This is used by the command parser to join extra parameters into one last param. * If not set, no munging is done to this command. */ const unsigned int max_params; /** True if the command allows an empty last parameter. * When false and the last parameter is empty, it's popped BEFORE * checking there are enough params, etc. (i.e. the handler won't * be called if there aren't enough params after popping the empty * param). */ bool allow_empty_last_param = false; /** Translation type list for possible parameters, used to tokenize * parameters into UIDs and SIDs etc. */ std::vector<TranslateType> translation; /** Create a new command. * @param me The module which created this command. * @param cmd Command name. This must be UPPER CASE. * @param minpara Minimum parameters required for the command. * @param maxpara Maximum number of parameters this command may have - extra parameters * will be tossed into one last space-separated param. */ CommandBase(Module* me, const std::string& cmd, unsigned int minpara = 0, unsigned int maxpara = 0); virtual RouteDescriptor GetRouting(User* user, const CommandBase::Params& parameters); /** Encode a parameter for server->server transmission. * Used for parameters for which the translation type is TR_CUSTOM. * @param parameter The parameter to encode. Can be modified in place. * @param index The parameter index (0 == first parameter). */ virtual void EncodeParameter(std::string& parameter, unsigned int index); }; class CoreExport Command : public CommandBase { protected: /** Initializes a new instance of the Command class. * @param me The module which created this instance. * @param cmd The name of the command. * @param minpara The minimum number of parameters that the command accepts. * @param maxpara The maximum number of parameters that the command accepts. */ Command(Module* me, const std::string& cmd, unsigned int minpara = 0, unsigned int maxpara = 0); public: /** Unregisters this command from the command parser. */ ~Command() override; /** Who can access this command? */ CmdAccess access_needed = CmdAccess::NORMAL; /** Whether the command will not be forwarded by the linking module even if it comes via ENCAP. */ bool force_manual_route = false; /** The number of milliseconds worth of penalty that executing this command gives. */ unsigned int penalty = 1000; /** The number of times this command has been executed. */ unsigned long use_count = 0; /** If non-empty then the syntax of the parameter for this command. */ std::vector<std::string> syntax; /** Whether the command can be issued before registering. */ bool works_before_reg = false; /** Handle the command from a user. * @param user The user who issued the command. * @param parameters The parameters for the command. * @return Returns CmdResult::FAILURE on failure, CmdResult::SUCCESS on success, or CmdResult::INVALID * if the command was malformed. */ virtual CmdResult Handle(User* user, const Params& parameters) = 0; /** Registers this command with the command parser. */ void RegisterService() override; /** Tells the user they did not specify enough parameters. * @param user The user who issued the command. * @param parameters The parameters for the command. */ virtual void TellNotEnoughParameters(LocalUser* user, const Params& parameters); /** Tells the user they need to be fully connected to execute this command. * @param user The user who issued the command. * @param parameters The parameters for the command. */ virtual void TellNotFullyConnected(LocalUser* user, const Params& parameters); }; class CoreExport SplitCommand : public Command { protected: /** Initializes a new instance of the SplitCommand class. * @param me The module which created this instance. * @param cmd The name of the command. * @param minpara The minimum number of parameters that the command accepts. * @param maxpara The maximum number of parameters that the command accepts. */ SplitCommand(Module* me, const std::string& cmd, unsigned int minpara = 0, unsigned int maxpara = 0); public: /** @copydoc Command::Handle */ CmdResult Handle(User* user, const Params& parameters) override; /** Handle the command from a local user. * @param user The user who issued the command. * @param parameters The parameters for the command. * @return Returns CmdResult::FAILURE on failure, CmdResult::SUCCESS on success, or CmdResult::INVALID * if the command was malformed. */ virtual CmdResult HandleLocal(LocalUser* user, const Params& parameters); /** Handle the command from a remote user. * @param user The user who issued the command. * @param parameters The parameters for the command. * @return Returns CmdResult::FAILURE on failure, CmdResult::SUCCESS on success, or CmdResult::INVALID * if the command was malformed. */ virtual CmdResult HandleRemote(RemoteUser* user, const Params& parameters); /** Handle the command from a server user. * @param user The user who issued the command. * @param parameters The parameters for the command. * @return Returns CmdResult::FAILURE on failure, CmdResult::SUCCESS on success, or CmdResult::INVALID * if the command was malformed. */ virtual CmdResult HandleServer(FakeUser* user, const Params& parameters); }; �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/include/cull.h�����������������������������������������������������������������������0000664�0000000�0000000�00000005305�14771603147�0016105�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2013, 2017, 2021-2022, 2024 Sadie Powell <sadie@witchery.services> * Copyright (C) 2012 Robby <robby@chatbelgie.be> * Copyright (C) 2011 jackmcbarn <jackmcbarn@inspircd.org> * Copyright (C) 2009 Daniel De Graaf <danieldg@inspircd.org> * Copyright (C) 2007 Dennis Friis <peavey@inspircd.org> * Copyright (C) 2005 Craig Edwards <brain@inspircd.org> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #pragma once /* Allows deleting instances of an inheriting type at the end of the current main loop iteration. */ class CoreExport Cullable : private insp::uncopiable { protected: /** Default constructor for the Cullable class. */ Cullable(); public: /** Deleter that queues an object for deletion at the end of the current main loop iteration. */ struct Deleter final { void operator()(Cullable* item) const; }; /** Dummy class to help ensure all superclasses get culled. */ class Result final { public: /** Default constructor for the Cullable::Result class. */ Result() = default; }; /** Destroys this instance of the Cullable class. */ virtual ~Cullable(); /** Called just before the instance is deleted to allow culling members. */ virtual Result Cull(); }; /** * The CullList class is used to delete objects at the end of the main loop to * avoid problems with references to deleted pointers if an object were deleted * during execution. */ class CoreExport CullList final { std::vector<Cullable*> list; std::vector<LocalUser*> SQlist; public: /** Adds an item to the cull list */ void AddItem(Cullable* item) { list.push_back(item); } void AddSQItem(LocalUser* item) { SQlist.push_back(item); } /** Applies the cull list (deletes the contents) */ void Apply(); }; /** Represents an action which is executable by an action list */ class CoreExport ActionBase : public Cullable { public: /** Executes this action. */ virtual void Call() = 0; }; class CoreExport ActionList { std::vector<ActionBase*> list; public: /** Adds an item to the list */ void AddAction(ActionBase* item) { list.push_back(item); } /** Runs the items */ void Run(); }; ���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/include/dynamic.h��������������������������������������������������������������������0000664�0000000�0000000�00000006222�14771603147�0016571�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2013, 2019-2022 Sadie Powell <sadie@witchery.services> * Copyright (C) 2012 Robby <robby@chatbelgie.be> * Copyright (C) 2012 ChrisTX <xpipe@hotmail.de> * Copyright (C) 2009-2010 Daniel De Graaf <danieldg@inspircd.org> * Copyright (C) 2007 Oliver Lupton <om@inspircd.org> * Copyright (C) 2007 Dennis Friis <peavey@inspircd.org> * Copyright (C) 2006 Craig Edwards <brain@inspircd.org> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #pragma once /** The extension that dynamic libraries end with. */ #if defined __APPLE__ # define DLL_EXTENSION ".dylib" #elif defined _WIN32 # define DLL_EXTENSION ".dll" #else # define DLL_EXTENSION ".so" #endif /** The DLLManager class is able to load a module file by filename, * and locate its init_module symbol. */ class CoreExport DLLManager final : public Cullable { private: /** The last error string. */ std::string err; /** The module library handle. */ #ifdef _WIN32 HMODULE lib = static_cast<HMODULE>(INVALID_HANDLE_VALUE); #else void* lib = nullptr; #endif /** The filename of the module library. */ const std::string libname; /** Sets the last error string. */ void RetrieveLastError(); public: /** Attempts to load the specified module. * @param name The name of the library to load. */ DLLManager(const std::string& name); /** Unloads the module if one was loaded. */ ~DLLManager() override; /** Attempts to create a new module instance from this shared library. * @return Either a new instance of the Module class or NULL on error. */ Module* CallInit(); /** Retrieves the value of the specified symbol. * @param name The name of the symbol to retrieve. * @return Either the value of the specified symbol or or NULL if it does not exist. */ void* GetSymbol(const char* name) const; /** Retrieves the value of the specified symbol and casts it to the requested type. * @param name The name of the symbol to retrieve. * @return Either the value of the specified symbol or or NULL if it does not exist. */ template <typename TReturn> TReturn* GetSymbol(const char* name) const { return static_cast<TReturn*>(GetSymbol(name)); } /** Retrieves the module version from the dynamic library. */ const char* GetVersion() const { return GetSymbol<const char>(MODULE_STR_VERSION); } /** Retrieves the last error which occurred or an empty string if no errors have occurred. */ const std::string& LastError() const { return err; } /** Retrieves the filename of the underlying shared library. */ const std::string& LibraryName() const { return libname; } }; ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/include/dynref.h���������������������������������������������������������������������0000664�0000000�0000000�00000006745�14771603147�0016446�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2019-2023 Sadie Powell <sadie@witchery.services> * Copyright (C) 2013, 2015 Attila Molnar <attilamolnar@hush.com> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #pragma once #include "base.h" class CoreExport dynamic_reference_base : public insp::intrusive_list_node<dynamic_reference_base> { public: class CaptureHook { public: /** Called when the target of the dynamic_reference has been acquired */ virtual void OnCapture() = 0; }; private: std::string name; CaptureHook* hook = nullptr; void resolve(); static void* operator new(std::size_t) = delete; static void* operator new[](std::size_t) = delete; protected: ServiceProvider* value = nullptr; public: ModuleRef creator; dynamic_reference_base(Module* Creator, const std::string& Name); dynamic_reference_base(const dynamic_reference_base&) = default; ~dynamic_reference_base(); dynamic_reference_base& operator=(const dynamic_reference_base& rhs) { SetProvider(rhs.GetProvider()); return *this; } inline const std::string& GetProvider() const { return name; } void ClearProvider(); void SetProvider(const std::string& newname); /** Set handler to call when the target object becomes available * @param h Handler to call */ void SetCaptureHook(CaptureHook* h) { hook = h; } void check(); operator bool() const { return (value != nullptr); } static void reset_all(); }; inline void dynamic_reference_base::check() { if (!value) throw ModuleException(creator, "Dynamic reference to '" + name + "' failed to resolve. Are you missing a module?"); } template<typename T> class dynamic_reference : public dynamic_reference_base { public: dynamic_reference(Module* Creator, const std::string& Name) : dynamic_reference_base(Creator, Name) {} inline T* operator->() { check(); return static_cast<T*>(value); } T* operator*() { return operator->(); } const T* operator->() const { return static_cast<T*>(value); } const T* operator*() const { return operator->(); } }; template<typename T> class dynamic_reference_nocheck : public dynamic_reference_base { public: dynamic_reference_nocheck(Module* Creator, const std::string& Name) : dynamic_reference_base(Creator, Name) {} T* operator->() { return static_cast<T*>(value); } T* operator*() { return operator->(); } const T* operator->() const { return static_cast<T*>(value); } const T* operator*() const { return operator->(); } }; class ModeHandler; class ChanModeReference final : public dynamic_reference_nocheck<ModeHandler> { public: ChanModeReference(Module* mod, const std::string& modename) : dynamic_reference_nocheck<ModeHandler>(mod, "mode/" + modename) {} }; class UserModeReference final : public dynamic_reference_nocheck<ModeHandler> { public: UserModeReference(Module* mod, const std::string& modename) : dynamic_reference_nocheck<ModeHandler>(mod, "umode/" + modename) {} }; ���������������������������inspircd-4.7.0/include/event.h����������������������������������������������������������������������0000664�0000000�0000000�00000016166�14771603147�0016276�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2018-2023 Sadie Powell <sadie@witchery.services> * Copyright (C) 2015, 2018 Attila Molnar <attilamolnar@hush.com> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #pragma once #include "base.h" namespace Events { class ModuleEventListener; class ModuleEventProvider; } /** Provider of one or more cross-module events. * Modules who wish to provide events for other modules create instances of this class and use * one of the macros below to fire the event, passing the instance of the event provider class * to the macro. * Event providers are identified using a unique identifier string. */ class Events::ModuleEventProvider : public ServiceProvider , private dynamic_reference_base::CaptureHook { public: struct Comp final { bool operator()(ModuleEventListener* lhs, ModuleEventListener* rhs) const; }; struct ElementComp final { bool operator()(ModuleEventListener* lhs, ModuleEventListener* rhs) const; }; typedef insp::flat_multiset<ModuleEventListener*, Comp, ElementComp> SubscriberList; /** Constructor * @param mod Module providing the event(s) * @param eventid Identifier of the event or event group provided, must be unique */ ModuleEventProvider(Module* mod, const std::string& eventid) : ServiceProvider(mod, eventid, SERVICE_DATA) , prov(mod, eventid) { prov.SetCaptureHook(this); } /** Retrieves the module which created this listener. */ const Module* GetModule() const { return prov.creator; } /** Get list of objects subscribed to this event * @return List of subscribed objects */ const SubscriberList& GetSubscribers() const { return prov->subscribers; } /** Subscribes a listener to this event. * @param subscriber The listener to subscribe. */ void Subscribe(ModuleEventListener* subscriber) { subscribers.insert(subscriber); OnSubscribe(subscriber); } /** Unsubscribes a listener from this event. * @param subscriber The listener to unsubscribe. */ void Unsubscribe(ModuleEventListener* subscriber) { subscribers.erase(subscriber); OnUnsubscribe(subscriber); } /** Run the given hook provided by a module. */ template<typename Class, typename... FunArgs, typename... FwdArgs> inline void Call(void (Class::*function)(FunArgs...), FwdArgs&&... args) const; /** * Run the given hook provided by a module until some module returns MOD_RES_ALLOW or * MOD_RES_DENY. If no module does that the result is set to MOD_RES_PASSTHRU. */ template<typename Class, typename... FunArgs, typename... FwdArgs> inline ModResult FirstResult(ModResult (Class::*function)(FunArgs...), FwdArgs&&... args) const; private: void OnCapture() override { // If someone else holds the list from now on, clear mine. See below for more info. if (*prov != this) subscribers.clear(); } /** Called when a listener subscribes to this event. * @param subscriber The listener which subscribed. */ virtual void OnSubscribe(ModuleEventListener* subscriber) { } /** Called when a listener unsubscribes from this event. * @param subscriber The listener which unsubscribed. */ virtual void OnUnsubscribe(ModuleEventListener* subscriber) { } /** Reference to the active provider for this event. In case multiple event providers * exist for the same event, only one of them contains the list of subscribers. * To handle the case when we are not the ones with the list, we get it from the provider * where the dynref points to. */ dynamic_reference_nocheck<ModuleEventProvider> prov; /** List of objects subscribed to the event(s) provided by us, or empty if multiple providers * exist with the same name and we are not the ones holding the list. */ SubscriberList subscribers; }; /** Base class for abstract classes describing cross-module events. * Subscribers should NOT inherit directly from this class. */ class Events::ModuleEventListener : private dynamic_reference_base::CaptureHook { private: /** Reference to the provider, can be NULL if none of the provider modules are loaded */ dynamic_reference_nocheck<ModuleEventProvider> prov; const unsigned int eventpriority; /** Called by the dynref when the event provider becomes available */ void OnCapture() override { prov->Subscribe(this); } protected: /** Constructor * @param mod Module subscribing * @param eventid Identifier of the event to subscribe to * @param eventprio The priority to give this event listener */ ModuleEventListener(Module* mod, const std::string& eventid, unsigned int eventprio) : prov(mod, eventid) , eventpriority(eventprio) { prov.SetCaptureHook(this); // If the dynamic_reference resolved at construction our capture handler wasn't called if (prov) ModuleEventListener::OnCapture(); } public: static constexpr unsigned int DefaultPriority = 100; ~ModuleEventListener() { if (prov) prov->Unsubscribe(this); } /** Retrieves the module which created this listener. */ const Module* GetModule() const { return prov.creator; } /** Retrieves the priority of this event. */ unsigned int GetPriority() const { return eventpriority; } }; inline bool Events::ModuleEventProvider::Comp::operator()(Events::ModuleEventListener* lhs, Events::ModuleEventListener* rhs) const { return (lhs->GetPriority() < rhs->GetPriority()); } inline bool Events::ModuleEventProvider::ElementComp::operator()(Events::ModuleEventListener* lhs, Events::ModuleEventListener* rhs) const { if (lhs->GetPriority() < rhs->GetPriority()) return true; if (lhs->GetPriority() > rhs->GetPriority()) return false; return std::less<>()(lhs, rhs); } template<typename Class, typename... FunArgs, typename... FwdArgs> inline void Events::ModuleEventProvider::Call(void (Class::*function)(FunArgs...), FwdArgs&&... args) const { if (GetModule() && GetModule()->dying) return; for (auto* subscriber : GetSubscribers()) { const Module* mod = subscriber->GetModule(); if (!mod || mod->dying) continue; Class* klass = static_cast<Class*>(subscriber); (klass->*function)(std::forward<FwdArgs>(args)...); } } template<typename Class, typename... FunArgs, typename... FwdArgs> inline ModResult Events::ModuleEventProvider::FirstResult(ModResult (Class::*function)(FunArgs...), FwdArgs&&... args) const { if (GetModule() && GetModule()->dying) return MOD_RES_PASSTHRU; ModResult result; for (auto* subscriber : GetSubscribers()) { const Module* mod = subscriber->GetModule(); if (!mod || mod->dying) continue; Class* klass = static_cast<Class*>(subscriber); result = (klass->*function)(std::forward<FwdArgs>(args)...); if (result != MOD_RES_PASSTHRU) break; } return result; } ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/include/exception.h������������������������������������������������������������������0000664�0000000�0000000�00000005202�14771603147�0017140�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2022, 2025 Sadie Powell <sadie@witchery.services> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #pragma once /** The base class for InspIRCd exception types. */ class CoreException : public std::exception { private: /** The reason this exception was thrown. */ const std::string reason; public: /** Creates a new instance of the CoreException class with the specified reason. * @param message A message that contains the reason this exception was thrown. */ CoreException(const std::string& message) : reason(message) { } /** Retrieves a character array that contains the reason this exception was thrown. */ const char* what() const noexcept override { return reason.c_str(); } /** Retrieves a string that contains the reason this exception was thrown. */ const std::string& GetReason() const noexcept { return reason; } }; class Module; /** An generic exception which was thrown by a module. */ class CoreExport ModuleException : public CoreException { private: /* The module which threw this exception. */ const Module* module; public: /** Creates a new instance of the ModuleException class with the specified module instance and reason. * @param mod The module which threw this exception. * @param format A format string for a message that contains the reason this exception was thrown. * @param args The arguments to format the message. */ template <typename... Args> ModuleException(const Module* mod, const char* format, Args&&... args) : ModuleException(mod, fmt::vformat(format, fmt::make_format_args(args...))) { } /** Creates a new instance of the ModuleException class with the specified module instance and reason. * @param mod The module which threw this exception. * @param message A message that contains the reason this exception was thrown. */ ModuleException(const Module* mod, const std::string& message) : CoreException(message) , module(mod) { } /** Retrieves the module which threw this exception. */ const Module* GetModule() const noexcept { return module; } }; ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/include/extensible.h�����������������������������������������������������������������0000664�0000000�0000000�00000006725�14771603147�0017317�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2013, 2019, 2021-2022 Sadie Powell <sadie@witchery.services> * Copyright (C) 2012, 2014-2015 Attila Molnar <attilamolnar@hush.com> * Copyright (C) 2012 Robby <robby@chatbelgie.be> * Copyright (C) 2009 Daniel De Graaf <danieldg@inspircd.org> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #pragma once class ExtensionItem; /** Types of extensible that an extension can extend. */ enum class ExtensionType : uint8_t { /** The extension extends the User class. */ USER = 0, /** The extension extends the Channel class. */ CHANNEL = 1, /** The extension extends the Membership class. */ MEMBERSHIP = 2, }; /** Base class for types which can be extended with additional data. */ class CoreExport Extensible : public Cullable { public: /** The container which extension values are stored in. */ typedef insp::flat_map<ExtensionItem*, void*> ExtensibleStore; /** Allows extensions to access the extension store. */ friend class ExtensionItem; /** The type of extensible that this is. */ const ExtensionType extype:2; ~Extensible() override; /** @copydoc Cullable::Cull */ Cullable::Result Cull() override; /** Frees all extensions attached to this extensible. */ void FreeAllExtItems(); /** Retrieves the values for extensions which are set on this extensible. */ const ExtensibleStore& GetExtList() const { return extensions; } /** Unhooks the specifies extensions from this extensible. * @param items The items to unhook. */ void UnhookExtensions(const std::vector<ExtensionItem*>& items); protected: Extensible(ExtensionType exttype); private: /** The values for extensions which are set on this extensible. */ ExtensibleStore extensions; /** Whether this extensible has been culled yet. */ bool culled:1; }; /** Manager for the extension system */ class CoreExport ExtensionManager final { public: /** The container which registered extensions are stored in. */ typedef std::map<std::string, ExtensionItem*, irc::insensitive_swo> ExtMap; /** Begins unregistering extensions belonging to the specified module. * @param module The module to unregister extensions for. * @param list The list to add unregistered extensions to. */ void BeginUnregister(Module* module, std::vector<ExtensionItem*>& list); /** Retrieves registered extensions keyed by their names. */ const ExtMap& GetExts() const { return types; } /** Retrieves an extension by name. * @param name The name of the extension to retrieve. * @return Either the value of this extension or nullptr if it does not exist. */ ExtensionItem* GetItem(const std::string& name); /** Registers an extension with the manager. * @return Either true if the extension was registered or false if an extension with the same * name already exists. */ bool Register(ExtensionItem* item); private: /** Registered extensions keyed by their names. */ ExtMap types; }; �������������������������������������������inspircd-4.7.0/include/extension.h������������������������������������������������������������������0000664�0000000�0000000�00000040275�14771603147�0017167�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2022-2024 Sadie Powell <sadie@witchery.services> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #pragma once #include "stringutils.h" #include "utility/string.h" /** Base class for types that extend an extensible. */ class CoreExport ExtensionItem : public ServiceProvider { public: /** The type of extensible that this extension extends. */ const ExtensionType extype:2; /** Deletes a \p value which is set on \p container. * @param container The container that this extension is set on. * @param item The item to delete. */ virtual void Delete(Extensible* container, void* item) = 0; /** Deserialises a value for this extension of the specified container from the internal format. * @param container A container this extension should be set on. * @param value A value in the internal format. */ virtual void FromInternal(Extensible* container, const std::string& value) noexcept; /** Deserialises a value for this extension of the specified container from the network format. * @param container A container this extension should be set on. * @param value A value in the network format. */ virtual void FromNetwork(Extensible* container, const std::string& value) noexcept; /** Called when a value for this extension is synchronised across the network. * @param container The container that this extension is set on. * @param item The value that is set on the container. * @param server The server which is being synchronised to or nullptr for a broadcast. */ virtual void OnSync(const Extensible* container, void* item, Server* server); /** @copydoc ServiceProvider::RegisterService */ void RegisterService() override; /** Serialises a value for this extension of the specified container to the human-readable * format. * @param container The container that this extension is set on. * @param item The value to convert to the human-readable format. * @return The value specified in \p item in the human-readable format. */ virtual std::string ToHuman(const Extensible* container, void* item) const noexcept; /** Serialises a value for this extension of the specified container to the internal format. * @param container The container that this extension is set on. * @param item The value to convert to the internal format. * @return The value specified in \p item in the internal format. */ virtual std::string ToInternal(const Extensible* container, void* item) const noexcept; /** Serialises a value for this extension of the specified container to the network format. * @param container The container that this extension is set on. * @param item The value to convert to the network format. * @return The value specified in \p item in the network format. */ virtual std::string ToNetwork(const Extensible* container, void* item) const noexcept; protected: /** Initializes an instance of the ExtensionItem class. * @param owner The module which created the extension. * @param key The name of the extension (e.g. foo-bar). * @param exttype The type of extensible that the extension applies to. */ ExtensionItem(Module* owner, const std::string& key, ExtensionType exttype); /** Retrieves the value for this extension of the specified container from the internal map. * @param container The container that this extension is set on. * @return Either the value of this extension or nullptr if it does not exist. */ void* GetRaw(const Extensible* container) const; /** Sets a value for this extension of the specified container in the internal map and * returns the old value if one was set * @param container The container that this extension should be set on. * @param value The new value to set for this extension. Will NOT be copied. * @return Either the old value or nullptr if one is not set. */ void* SetRaw(Extensible* container, void* value); /** Syncs the value of this extension of the specified container across the network. Does * nothing if an inheritor does not implement ExtensionItem::ToNetwork. * @param container The container that this extension is set on. * @param item The value of this extension. */ void Sync(const Extensible* container, void* item); /** Removes this extension from the specified container and returns it. * @param container The container that this extension should be removed from. * @return Either the old value of this extension or nullptr if it was not set. */ void* UnsetRaw(Extensible* container); }; /** An extension which has a simple (usually POD) value. */ template <typename Value, typename Del = std::default_delete<Value>> class SimpleExtItem : public ExtensionItem { protected: /** Whether to sync this extension across the network. */ bool synced; public: /** Initializes an instance of the SimpleExtItem<T,Del> class. * @param owner The module which created the extension. * @param key The name of the extension (e.g. foo-bar). * @param exttype The type of extensible that the extension applies to. * @param sync Whether this extension should be broadcast to other servers. */ SimpleExtItem(Module* owner, const std::string& key, ExtensionType exttype, bool sync = false) : ExtensionItem(owner, key, exttype) , synced(sync) { } /** @copydoc ExtensionItem::FromNetwork */ void FromNetwork(Extensible* container, const std::string& value) noexcept override { if (synced) FromInternal(container, value); } /** @copydoc ExtensionItem::ToNetwork */ std::string ToNetwork(const Extensible* container, void* item) const noexcept override { return synced ? ToInternal(container, item) : std::string(); } /** @copydoc ExtensionItem::Delete */ void Delete(Extensible* container, void* item) override { Del del; del(static_cast<Value*>(item)); } /** Retrieves the value for this extension of the specified container. * @param container The container that this extension is set on. * @return Either a pointer to the value of this extension or nullptr if it is not set. */ inline Value* Get(const Extensible* container) const { return static_cast<Value*>(GetRaw(container)); } /** Retrieves the value for this extension of the specified container. * @param container The container that this extension is set on. * @return A reference to the value of this extension. */ inline Value& GetRef(Extensible* container) { auto* value = Get(container); if (!value) { value = new Value(); Set(container, value, false); } return *value; } /** Sets a value for this extension of the specified container. * @param container The container that this extension should be set on. * @param value The new value to set for this extension. Will NOT be copied. * @param sync If syncable then whether to sync this set to the network. */ inline void Set(Extensible* container, Value* value, bool sync = true) { if (container->extype != this->extype) return; auto old = static_cast<Value*>(SetRaw(container, value)); Delete(container, old); if (sync && synced) Sync(container, value); } /** Sets a value for this extension of the specified container. * @param container The container that this extension should be set on. * @param value The new value to set for this extension. Will be copied. * @param sync If syncable then whether to sync this set to the network. */ inline void Set(Extensible* container, const Value& value, bool sync = true) { if (container->extype == this->extype) Set(container, new Value(value), sync); } /** Sets a forwarded value for this extension of the specified container. * @param container The container that this extension should be set on. * @param args The arguments to forward to the constructor of \p T. */ template <typename... Args> inline void SetFwd(Extensible* container, Args&&... args) { // Forwarded arguments are for complex types which are assumed to not // be synced across the network. You can manually call Sync() if this // is not the case. if (container->extype == this->extype) Set(container, new Value(std::forward<Args>(args)...), false); } /** Removes this extension from the specified container. * @param container The container that this extension should be removed from. * @param sync If syncable then whether to sync this unset to the network. */ inline void Unset(Extensible* container, bool sync = true) { if (container->extype != this->extype) return; Delete(container, UnsetRaw(container)); if (synced && sync) Sync(container, nullptr); } }; /** An extension which has a boolean value. */ class CoreExport BoolExtItem : public ExtensionItem { protected: /** Whether to sync this extension across the network. */ bool synced; public: /** Initializes an instance of the BoolExtItem class. * @param owner The module which created the extension. * @param key The name of the extension (e.g. foo-bar). * @param exttype The type of extensible that the extension applies to. * @param sync Whether this extension should be broadcast to other servers. */ BoolExtItem(Module* owner, const std::string& key, ExtensionType exttype, bool sync = false); /** @copydoc ExtensionItem::Delete */ void Delete(Extensible* container, void* item) override; /** Retrieves the value for this extension of the specified container. * @param container The container that this extension is set on. * @return Either the value of this extension or false if it is not set. */ bool Get(const Extensible* container) const; /** @copydoc ExtensionItem::FromInternal */ void FromInternal(Extensible* container, const std::string& value) noexcept override; /** @copydoc ExtensionItem::FromNetwork */ void FromNetwork(Extensible* container, const std::string& value) noexcept override; /** Sets a value for this extension of the specified container. * @param container The container that this extension should be set on. * @param sync If syncable then whether to sync this set to the network. */ void Set(Extensible* container, bool sync = true); /** @copydoc ExtensionItem::ToHuman */ std::string ToHuman(const Extensible* container, void* item) const noexcept override; /** @copydoc ExtensionItem::ToInternal */ std::string ToInternal(const Extensible* container, void* item) const noexcept override; /** @copydoc ExtensionItem::ToNetwork */ std::string ToNetwork(const Extensible* container, void* item) const noexcept override; /** Removes this extension from the specified container. * @param container The container that this extension should be removed from. * @param sync If syncable then whether to sync this unset to the network. */ void Unset(Extensible* container, bool sync = true); }; /** An extension which has a list value. */ template <typename Container, typename Del = std::default_delete<Container>> class ListExtItem : public SimpleExtItem<Container, Del> { public: /** The underlying list type. */ typedef Container List; /** Initializes an instance of the ListExtItem class. * @param owner The module which created the extension. * @param key The name of the extension (e.g. foo-bar). * @param exttype The type of extensible that the extension applies to. * @param sync Whether this extension should be broadcast to other servers. */ ListExtItem(Module* owner, const std::string& key, ExtensionType exttype, bool sync = false) : SimpleExtItem<List>(owner, key, exttype, sync) { } /** @copydoc ExtensionItem::FromInternal */ void FromInternal(Extensible* container, const std::string& value) noexcept override { if (container->extype != this->extype) return; if (value.empty()) { SimpleExtItem<Container>::Unset(container, false); return; } auto list = new List(); irc::spacesepstream stream(value); for (std::string element; stream.GetToken(element); ) { // Argh! Why doesn't vector<string> have an insert(value_type) method? if constexpr (std::is_same_v<Container, std::vector<typename Container::value_type>>) list->push_back(Percent::Decode(element)); else list->insert(Percent::Decode(element)); } if (list->empty()) { // The remote sent an empty list. delete list; SimpleExtItem<Container>::Unset(container, false); } else { // The remote sent a non-zero list. SimpleExtItem<Container>::Set(container, list, false); } } /** @copydoc ExtensionItem::ToInternal */ std::string ToHuman(const Extensible* container, void* item) const noexcept override { auto list = static_cast<List*>(item); if (list->empty()) return {}; return insp::join(*list, ' '); } /** @copydoc ExtensionItem::ToInternal */ std::string ToInternal(const Extensible* container, void* item) const noexcept override { auto list = static_cast<List*>(item); if (list->empty()) return {}; std::string value; for (const auto& element : *list) value.append(Percent::Encode(element)).push_back(' '); value.pop_back(); return value; } }; /** An extension which has an integer value. */ class CoreExport IntExtItem : public ExtensionItem { protected: /** Whether to sync this extension across the network. */ bool synced; public: /** Initializes an instance of the IntExtItem class. * @param owner The module which created the extension. * @param key The name of the extension (e.g. foo-bar). * @param exttype The type of extensible that the extension applies to. * @param sync Whether this extension should be broadcast to other servers. */ IntExtItem(Module* owner, const std::string& key, ExtensionType exttype, bool sync = false); /** @copydoc ExtensionItem::Delete */ void Delete(Extensible* container, void* item) override; /** Retrieves the value for this extension of the specified container. * @param container The container that this extension is set on. * @return Either the value of this extension or 0 if it is not set. */ intptr_t Get(const Extensible* container) const; /** @copydoc ExtensionItem::FromInternal */ void FromInternal(Extensible* container, const std::string& value) noexcept override; /** @copydoc ExtensionItem::FromNetwork */ void FromNetwork(Extensible* container, const std::string& value) noexcept override; /** Sets a value for this extension of the specified container. * @param container The container that this extension should be set on. * @param value The new value to set for this extension. * @param sync If syncable then whether to sync this set to the network. */ void Set(Extensible* container, intptr_t value, bool sync = true); /** @copydoc ExtensionItem::ToInternal */ std::string ToInternal(const Extensible* container, void* item) const noexcept override; /** @copydoc ExtensionItem::ToNetwork */ std::string ToNetwork(const Extensible* container, void* item) const noexcept override; /** Removes this extension from the specified container. * @param container The container that this extension should be removed from. * @param sync If syncable then whether to sync this unset to the network. */ void Unset(Extensible* container, bool sync = true); }; /** An extension which has a string value. */ class CoreExport StringExtItem : public SimpleExtItem<std::string> { public: /** Initializes an instance of the StringExtItem class. * @param owner The module which created the extension. * @param key The name of the extension (e.g. foo-bar). * @param exttype The type of extensible that the extension applies to. * @param sync Whether this extension should be broadcast to other servers. */ StringExtItem(Module* owner, const std::string& key, ExtensionType exttype, bool sync = false); /** @copydoc ExtensionItem::FromInternal */ void FromInternal(Extensible* container, const std::string& value) noexcept override; /** @copydoc ExtensionItem::ToInternal */ std::string ToInternal(const Extensible* container, void* item) const noexcept override; }; �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/include/flat_map.h�������������������������������������������������������������������0000664�0000000�0000000�00000025265�14771603147�0016740�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2019-2021, 2024 Sadie Powell <sadie@witchery.services> * Copyright (C) 2014 Attila Molnar <attilamolnar@hush.com> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #pragma once namespace insp { namespace detail { template <typename T, typename Comp> class map_pair_compare final : public Comp { typedef T value_type; typedef typename value_type::first_type key_type; public: bool operator()(const value_type& x, const value_type& y) const { return Comp::operator()(x.first, y.first); } bool operator()(const value_type& x, const key_type& y) const { return Comp::operator()(x.first, y); } bool operator()(const key_type& x, const value_type& y) const { return Comp::operator()(x, y.first); } }; template <typename Val, typename Comp> class map_value_compare { public: bool operator()(const Val& x, const Val& y) const { Comp c; return c(x.first, y.first); } }; template <typename T, typename Comp, typename Key = T, typename ElementComp = Comp> class flat_map_base { protected: typedef std::vector<T> storage_type; storage_type vect; public: typedef typename storage_type::iterator iterator; typedef typename storage_type::const_iterator const_iterator; typedef typename storage_type::reverse_iterator reverse_iterator; typedef typename storage_type::const_reverse_iterator const_reverse_iterator; typedef typename storage_type::size_type size_type; typedef typename storage_type::difference_type difference_type; typedef Key key_type; typedef T value_type; typedef Comp key_compare; typedef ElementComp value_compare; flat_map_base() = default; flat_map_base(const flat_map_base& other) : vect(other.vect) { } flat_map_base& operator=(const flat_map_base& other) = default; size_type size() const { return vect.size(); } bool empty() const { return vect.empty(); } size_type capacity() const { return vect.capacity(); } size_type max_size() const { return vect.max_size(); } void clear() { vect.clear(); } void reserve(size_type n) { vect.reserve(n); } void shrink_to_fit() { vect.shrink_to_fit(); } iterator begin() { return vect.begin(); } iterator end() { return vect.end(); } reverse_iterator rbegin() { return vect.rbegin(); } reverse_iterator rend() { return vect.rend(); } const_iterator begin() const { return vect.begin(); } const_iterator end() const { return vect.end(); } const_reverse_iterator rbegin() const { return vect.rbegin(); } const_reverse_iterator rend() const { return vect.rend(); } key_compare key_comp() const { return Comp(); } iterator erase(iterator it) { return vect.erase(it); } iterator erase(iterator first, iterator last) { return vect.erase(first, last); } size_type erase(const key_type& x) { size_type n = vect.size(); std::pair<iterator, iterator> itpair = equal_range(x); vect.erase(itpair.first, itpair.second); return n - vect.size(); } iterator find(const key_type& x) { value_compare c; iterator it = std::lower_bound(vect.begin(), vect.end(), x, c); if ((it != vect.end()) && (!c(x, *it))) return it; return vect.end(); } const_iterator find(const key_type& x) const { // Same as above but this time we return a const_iterator value_compare c; const_iterator it = std::lower_bound(vect.begin(), vect.end(), x, c); if ((it != vect.end()) && (!c(x, *it))) return it; return vect.end(); } std::pair<iterator, iterator> equal_range(const key_type& x) { return std::equal_range(vect.begin(), vect.end(), x, value_compare()); } std::pair<const_iterator, const_iterator> equal_range(const key_type& x) const { return std::equal_range(vect.begin(), vect.end(), x, value_compare()); } iterator lower_bound(const key_type& x) { return std::lower_bound(vect.begin(), vect.end(), x, value_compare()); } const_iterator lower_bound(const key_type& x) const { return std::lower_bound(vect.begin(), vect.end(), x, value_compare()); } iterator upper_bound(const key_type& x) { return std::upper_bound(vect.begin(), vect.end(), x, value_compare()); } const_iterator upper_bound(const key_type& x) const { return std::upper_bound(vect.begin(), vect.end(), x, value_compare()); } size_type count(const key_type& x) const { std::pair<const_iterator, const_iterator> itpair = equal_range(x); return std::distance(itpair.first, itpair.second); } protected: std::pair<iterator, bool> insert_single(const value_type& x) { bool inserted = false; value_compare c; iterator it = std::lower_bound(vect.begin(), vect.end(), x, c); if ((it == vect.end()) || (c(x, *it))) { inserted = true; it = vect.insert(it, x); } return std::make_pair(it, inserted); } iterator insert_multi(const value_type& x) { iterator it = std::lower_bound(vect.begin(), vect.end(), x, value_compare()); return vect.insert(it, x); } }; } // namespace detail template <typename T, typename Comp = std::less<T>, typename ElementComp = Comp> class flat_set : public detail::flat_map_base<T, Comp, T, ElementComp> { typedef detail::flat_map_base<T, Comp, T, ElementComp> base_type; public: typedef typename base_type::iterator iterator; typedef typename base_type::value_type value_type; flat_set() = default; template <typename InputIterator> flat_set(InputIterator first, InputIterator last) { this->insert(first, last); } flat_set(std::initializer_list<value_type> init) { for (const auto& elem : init) insert(elem); } flat_set(const flat_set& other) : base_type(other) { } flat_set& operator=(const flat_set& other) = default; template <typename... Args> std::pair<iterator, bool> emplace(Args&&... args) { return insert(value_type(std::forward<Args>(args)...)); } std::pair<iterator, bool> insert(const value_type& x) { return this->insert_single(x); } template <typename InputIterator> void insert(InputIterator first, InputIterator last) { for (; first != last; ++first) this->insert_single(*first); } void swap(flat_set& other) { base_type::vect.swap(other.vect); } }; template <typename T, typename Comp = std::less<T>, typename ElementComp = Comp> class flat_multiset : public detail::flat_map_base<T, Comp, T, ElementComp> { typedef detail::flat_map_base<T, Comp, T, ElementComp> base_type; public: typedef typename base_type::iterator iterator; typedef typename base_type::value_type value_type; flat_multiset() = default; template <typename InputIterator> flat_multiset(InputIterator first, InputIterator last) { this->insert(first, last); } flat_multiset(std::initializer_list<value_type> init) { for (const auto& elem : init) insert(elem); } flat_multiset(const flat_multiset& other) : base_type(other) { } flat_multiset& operator=(const flat_multiset& other) = default; template <typename... Args> iterator emplace(Args&&... args) { return insert(value_type(std::forward<Args>(args)...)); } iterator insert(const value_type& x) { return this->insert_multi(x); } template <typename InputIterator> void insert(InputIterator first, InputIterator last) { for (; first != last; ++first) insert_multi(*first); } void swap(flat_multiset& other) { base_type::vect.swap(other.vect); } }; template <typename T, typename U, typename Comp = std::less<T>, typename ElementComp = Comp > class flat_map : public detail::flat_map_base<std::pair<T, U>, Comp, T, detail::map_pair_compare<std::pair<T, U>, ElementComp>> { typedef detail::flat_map_base<std::pair<T, U>, Comp, T, detail::map_pair_compare<std::pair<T, U>, ElementComp>> base_type; public: typedef typename base_type::iterator iterator; typedef typename base_type::key_type key_type; typedef typename base_type::value_type value_type; typedef U mapped_type; typedef typename base_type::value_compare value_compare; flat_map() = default; template <typename InputIterator> flat_map(InputIterator first, InputIterator last) { insert(first, last); } flat_map(std::initializer_list<value_type> init) { for (const auto& elem : init) insert(elem); } flat_map(const flat_map& other) : base_type(other) { } flat_map& operator=(const flat_map& other) = default; template <typename... Args> std::pair<iterator, bool> emplace(Args&&... args) { return insert(value_type(std::forward<Args>(args)...)); } std::pair<iterator, bool> insert(const value_type& x) { return this->insert_single(x); } template <typename InputIterator> void insert(InputIterator first, InputIterator last) { for (; first != last; ++first) this->insert_single(*first); } void swap(flat_map& other) { base_type::vect.swap(other.vect); } mapped_type& operator[](const key_type& x) { return insert(value_type(x, mapped_type())).first->second; } value_compare value_comp() const { return value_compare(); } }; template <typename T, typename U, typename Comp = std::less<T>, typename ElementComp = Comp > class flat_multimap : public detail::flat_map_base<std::pair<T, U>, Comp, T, detail::map_pair_compare<std::pair<T, U>, ElementComp>> { typedef detail::flat_map_base<std::pair<T, U>, Comp, T, detail::map_pair_compare<std::pair<T, U>, ElementComp>> base_type; public: typedef typename base_type::iterator iterator; typedef typename base_type::value_type value_type; typedef U mapped_type; typedef typename base_type::value_compare value_compare; flat_multimap() = default; template <typename InputIterator> flat_multimap(InputIterator first, InputIterator last) { this->insert(first, last); } flat_multimap(std::initializer_list<value_type> init) { for (const auto& elem : init) insert(elem); } flat_multimap(const flat_multimap& other) : base_type(other) { } flat_multimap& operator=(const flat_multimap& other) = default; template <typename... Args> iterator emplace(Args&&... args) { return insert(value_type(std::forward<Args>(args)...)); } iterator insert(const value_type& x) { return this->insert_multi(x); } template <typename InputIterator> void insert(InputIterator first, InputIterator last) { for (; first != last; ++first) this->insert_multi(*first); } void swap(flat_multimap& other) { base_type::vect.swap(other.vect); } value_compare value_comp() const { return value_compare(); } }; } // namespace insp �������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/include/hashcomp.h�������������������������������������������������������������������0000664�0000000�0000000�00000021242�14771603147�0016746�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2013, 2018-2022 Sadie Powell <sadie@witchery.services> * Copyright (C) 2013 Adam <Adam@anope.org> * Copyright (C) 2012-2013, 2016 Attila Molnar <attilamolnar@hush.com> * Copyright (C) 2012 Robby <robby@chatbelgie.be> * Copyright (C) 2009 Daniel De Graaf <danieldg@inspircd.org> * Copyright (C) 2008-2009 Robin Burchell <robin+git@viroteck.net> * Copyright (C) 2007 Dennis Friis <peavey@inspircd.org> * Copyright (C) 2005-2008 Craig Edwards <brain@inspircd.org> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #pragma once #include "inspircd.h" #include "convto.h" /******************************************************* * This file contains classes and templates that deal * with the comparison and hashing of 'irc strings'. * An 'irc string' is a string which compares in a * case insensitive manner, and as per RFC 1459 will * treat [ identical to {, ] identical to }, and \ * as identical to |. * * There are functors that accept std::string and * compare/hash them as type irc::string by using * mapping arrays internally. *******************************************************/ /** Separate from the other casemap tables so that code *can* still exclusively rely on RFC casemapping * if it must. * * This is provided as a pointer so that modules can change it to their custom mapping tables, * e.g. for national character support. */ CoreExport extern const unsigned char* national_case_insensitive_map; /** Case insensitive map, ASCII rules. * That is; * [ != {, but A == a. */ CoreExport extern const unsigned char ascii_case_insensitive_map[256]; /** The irc namespace contains a number of helper classes. */ namespace irc { /** Check if two IRC object (e.g. nick or channel) names are equal. * This function uses national_case_insensitive_map to determine equality, which, by default does comparison * according to RFC 1459, treating certain otherwise non-identical characters as identical. * @param s1 First string to compare * @param s2 Second string to compare * @return True if the two names are equal, false otherwise */ CoreExport bool equals(const std::string_view& s1, const std::string_view& s2); /** Check whether \p needle exists within \p haystack. * @param haystack The string to search within. * @param needle The string to search for. * @return Either the index at which \p needle was found or std::string::npos. */ CoreExport size_t find(const std::string_view& haystack, const std::string_view& needle); /** This class returns true if two strings match. * Case sensitivity is ignored, and the RFC 'character set' * is adhered to */ struct StrHashComp final { /** The operator () does the actual comparison in hash_map */ bool operator()(const std::string& s1, const std::string& s2) const { return equals(s1, s2); } }; struct insensitive final { size_t CoreExport operator()(const std::string& s) const; }; struct insensitive_swo { bool CoreExport operator()(const std::string& a, const std::string& b) const; }; /** irc::sepstream allows for splitting token separated lists. * Each successive call to sepstream::GetToken() returns * the next token, until none remain, at which point the method returns * false. */ class CoreExport sepstream { protected: /** Original string. */ std::string tokens; /** Separator value */ char sep; /** Current string position */ size_t pos = 0; /** If set then GetToken() can return an empty string */ bool allow_empty; public: /** Create a sepstream and fill it with the provided data */ sepstream(const std::string& source, char separator, bool allowempty = false); /** Fetch the next token from the stream * @param token The next token from the stream is placed here * @return True if tokens still remain, false if there are none left */ bool GetToken(std::string& token); /** Fetch the next numeric token from the stream * @param token The next token from the stream is placed here * @return True if tokens still remain, false if there are none left */ template<typename Numeric> bool GetNumericToken(Numeric& token) { std::string str; if (!GetToken(str)) return false; token = ConvToNum<Numeric>(str); return true; } /** Fetch the entire remaining stream, without tokenizing * @return The remaining part of the stream */ std::string GetRemaining(); /** Returns true if the end of the stream has been reached * @return True if the end of the stream has been reached, otherwise false */ bool StreamEnd(); }; /** A derived form of sepstream, which separates on commas */ class CoreExport commasepstream : public sepstream { public: /** Initialize with comma separator */ commasepstream(const std::string& source, bool allowempty = false) : sepstream(source, ',', allowempty) { } }; /** A derived form of sepstream, which separates on spaces */ class CoreExport spacesepstream : public sepstream { public: /** Initialize with space separator */ spacesepstream(const std::string& source, bool allowempty = false) : sepstream(source, ' ', allowempty) { } }; /** irc::tokenstream reads a string formatted as per RFC1459 and RFC2812. * It will split the string into 'tokens' each containing one parameter * from the string. * For instance, if it is instantiated with the string: * "PRIVMSG #test :foo bar baz qux" * then each successive call to tokenstream::GetToken() will return * "PRIVMSG", "#test", "foo bar baz qux", "". * Note that if the whole string starts with a colon this is not taken * to mean the string is all one parameter, and the first item in the * list will be ":item". This is to allow for parsing 'source' fields * from data. */ class CoreExport tokenstream { private: /** The message we are parsing tokens from. */ std::string message; /** The current position within the message. */ size_t position = 0; public: /** Create a tokenstream and fill it with the provided data. */ tokenstream(const std::string& msg, size_t start = 0, size_t end = std::string::npos); /** Retrieves the underlying message. */ std::string& GetMessage() { return message; } /** Retrieve the next \<middle> token in the token stream. * @param token The next token available, or an empty string if none remain. * @return True if tokens are left to be read, false if the last token was just retrieved. */ bool GetMiddle(std::string& token); /** Retrieve the next \<trailing> token in the token stream. * @param token The next token available, or an empty string if none remain. * @return True if tokens are left to be read, false if the last token was just retrieved. */ bool GetTrailing(std::string& token); }; /** The portparser class separates out a port range into integers. * A port range may be specified in the input string in the form * "6660,6661,6662-6669,7020". The end of the stream is indicated by * a return value of 0 from portparser::GetToken(). If you attempt * to specify an illegal range (e.g. one where start >= end, or * start or end < 0) then GetToken() will return the first element * of the pair of numbers. */ class CoreExport portparser { private: /** Used to split on commas */ commasepstream sep; /** Current position in a range of ports */ long in_range = 0; /** Starting port in a range of ports */ long range_begin = 0; /** Ending port in a range of ports */ long range_end = 0; /** Allow overlapped port ranges */ bool overlapped; /** Used to determine overlapping of ports * without O(n) algorithm being used */ std::set<long> overlap_set; /** Returns true if val overlaps an existing range */ bool Overlaps(long val); public: /** Create a portparser and fill it with the provided data * @param source The source text to parse from * @param allow_overlapped Allow overlapped ranges */ portparser(const std::string& source, bool allow_overlapped = true); /** Fetch the next token from the stream * @return The next port number is returned, or 0 if none remain */ long GetToken(); }; } ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/include/inspircd.h�������������������������������������������������������������������0000664�0000000�0000000�00000040265�14771603147�0016765�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2012-2016, 2018 Attila Molnar <attilamolnar@hush.com> * Copyright (C) 2012-2013, 2017-2025 Sadie Powell <sadie@witchery.services> * Copyright (C) 2012 Robby <robby@chatbelgie.be> * Copyright (C) 2012 ChrisTX <xpipe@hotmail.de> * Copyright (C) 2009-2010 Daniel De Graaf <danieldg@inspircd.org> * Copyright (C) 2007-2009 Dennis Friis <peavey@inspircd.org> * Copyright (C) 2007-2008 Robin Burchell <robin+git@viroteck.net> * Copyright (C) 2007 Oliver Lupton <om@inspircd.org> * Copyright (C) 2005-2008 Craig Edwards <brain@inspircd.org> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #pragma once #include <cfloat> #include <climits> #include <csignal> #include <cstdarg> #include <cstdint> #include <cstring> #include <algorithm> #include <array> #include <atomic> #include <bitset> #include <deque> #include <functional> #include <memory> #include <map> #include <optional> #include <set> #include <sstream> #include <string> #include <string_view> #include <unordered_map> #include <vector> #ifndef _WIN32 # include <sys/time.h> #endif #include "utility/aligned_storage.h" #include "utility/iterator_range.h" #include "intrusive_list.h" #include "flat_map.h" #include "compat.h" #include "typedefs.h" #include "convto.h" #include "stdalgo.h" #include "exception.h" CoreExport extern InspIRCd* ServerInstance; #include "config.h" #include "dynref.h" #include "cull.h" #include "extensible.h" #include "ctables.h" #include "numeric.h" #include "uid.h" #include "server.h" #include "token_list.h" #include "users.h" #include "channels.h" #include "timer.h" #include "hashcomp.h" #include "channelmanager.h" #include "usermanager.h" #include "socket.h" #include "command_parse.h" #include "mode.h" #include "socketengine.h" #include "snomasks.h" #include "message.h" #include "modules.h" #include "moduledefs.h" #include "clientprotocol.h" #include "thread.h" #include "configreader.h" #include "protocol.h" #include "bancache.h" #include "logging.h" /** This class contains various STATS counters * It is used by the InspIRCd class, which internally * has an instance of it. */ class ServerStats final { public: /** Number of accepted connections. */ size_t Accept = 0; /** Number of rejected connections. */ size_t Refused = 0; /** Number of unknown commands seen. */ size_t Unknown = 0; /** Number of nickname collisions handled. */ size_t Collisions = 0; /** Number of fully connected users seen. */ size_t Connects = 0; /** Total bytes of data transmitted. */ size_t Sent = 0; /** Total bytes of data received. */ size_t Recv = 0; #ifdef _WIN32 /** CPU performance frequency on boot. */ LARGE_INTEGER BootCPU; /** CPU performance frequency at the last sample. */ LARGE_INTEGER LastCPU; /** Time the last sample was read. */ FILETIME LastSampled; #else /** CPU usage at the last sample. */ timeval LastCPU; /** Time the last sample was read. */ timespec LastSampled; #endif }; /** The main class of the irc server. * This class contains instances of all the other classes in this software. * Amongst other things, it contains a ModeParser, a DNS object, a CommandParser * object, and a list of active Module objects, and facilities for Module * objects to interact with the core system it implements. */ class CoreExport InspIRCd final { private: /** The last signal that was received from the operating system. */ static sig_atomic_t lastsignal; /** A 64k buffer used to read socket data into. */ char readbuffer[65535]; /** The client protocol events provided by the core. */ ClientProtocol::RFCEvents rfcevents; /** The current time, updated once per main loop iteration. */ struct timespec ts; /** Prepares the server for restart or shutdown. */ void Cleanup(); /** Handles an stored signal in the main loop. * @param signal The signal received from the operating system. */ void HandleSignal(sig_atomic_t signal); /** Attempt to write the process id to a file. */ void WritePID(); public: /** Actions that must happen outside of the current call stack. */ ActionList AtomicActions; /** Caches server bans to speeds up checking of restrictions on connect. */ BanCacheManager BanCache; /** Manager for state relating to channels. */ ChannelManager Channels; /** Default implementation of the protocol interface which does nothing. */ ProtocolInterface DefaultProtocolInterface; /* Manager for the extension system. */ ExtensionManager Extensions; /** Objects that should be culled outside of the current call stack. */ CullList GlobalCulls; /** Manager for the logging system. */ Log::Manager Logs; /* Manager for the mode handlers. */ ModeParser Modes; /** Manager for the module loading system. */ ModuleManager Modules; /** Manager for the command handlers. */ CommandParser Parser; /** Manages sending snomasks to server operators. */ SnomaskManager SNO; /** Holds miscellaneous stats counters. */ ServerStats Stats; /** Manages scheduling and triggering of timer events. */ TimerManager Timers; /* Generator for unique user identifiers. */ UIDGenerator UIDGen; /** Manager for state relating to users. */ UserManager Users; /** The server configuration. */ ServerConfig* Config = nullptr; /* If non-nullptr then the thread that is reading the server configuration on rehash. */ ConfigReaderThread* ConfigThread = nullptr; /** A fake user that represents the local server. */ FakeUser* FakeClient = nullptr; /** The protocol interface used for interacting with remote servers by the linking module. */ ProtocolInterface* PI = &DefaultProtocolInterface; /** Manager for X-lines. */ XLineManager* XLines = nullptr; /** The current server configuration file from --config or configure. */ std::string ConfigFileName; /** Fills a buffer with random bytes. */ std::function<void(char*, size_t)> GenRandom = &DefaultGenRandom; /** Determines whether a nickname is valid. */ std::function<bool(const std::string_view&)> IsNick = &DefaultIsNick; /** Determines whether a username is valid. */ std::function<bool(const std::string_view&)> IsUser = &DefaultIsUser; /** List of the open listeners. */ std::vector<ListenSocket*> ports; /** The time at which the server was started. */ time_t startup_time; /** Initialises a new server instance and stores it in ServerInstance * @param argc The argument count from main(). * @param argv The argument list from main(). */ InspIRCd(int argc, char** argv); /** Binds to a specific port from a config tag. * @param tag the tag that contains bind information. * @param sa The endpoint to listen on. * @param oldports Previously listening ports that may be on the same endpoint. * @param protocol The protocol to bind with or 0 to determine from the endpoint. * @return True if the port was bound successfully; otherwise, false. */ bool BindPort(const std::shared_ptr<ConfigTag>& tag, const irc::sockets::sockaddrs& sa, std::vector<ListenSocket*>& oldports, sa_family_t protocol); /** Binds all ports specified in the configuration file. * @param failedports The location to store details about the ports that failed to bind. * @return The number of ports bound without error. */ size_t BindPorts(FailedPortList& failedports); /** Compares a password to a hashed password. * @param password The hashed password. * @param passwordhash If non-empty then the algorithm the password is hashed with. * @param value The value to check to see if the password is valid. * @return True if the password is correct, otherwise, false. */ static bool CheckPassword(const std::string& password, const std::string& passwordhash, const std::string& value); /** Generates a random integer. * @param max The maximum value for the integer. * @return A random integer between 0 and \p max. */ unsigned long GenRandomInt(unsigned long max) const; /** Generates a human readable random string. * @param length The length in bytes. * @return A random string of \p length bytes. */ std::string GenRandomStr(size_t length) const; /** Generates a random string. * @param length The length in bytes. * @param printable Whether to only return printable characters. * @return A random string of \p length bytes. */ [[deprecated("Use GenRandomStr(length) or GenRandom(buf, len) instead")]] std::string GenRandomStr(size_t length, bool printable) const; /** Retrieves a 64k buffer used to read socket data into. */ inline auto* GetReadBuffer() { return readbuffer; } /** Retrieves the client protocol events provided by the core. */ inline auto& GetRFCEvents() { return rfcevents; } /** Fills the output buffer with the specified number of random characters. * This is the default function for InspIRCd::GenRandom. * @param output The output buffer to store random characters in. * @param max The maximum number of random characters to put in the buffer. */ static void DefaultGenRandom(char* output, size_t max); /** Determines whether a nickname is valid according to the RFC 1459 rules. * This is the default function for InspIRCd::IsNick. * @param nick The nickname to validate. * @return True if the nickname is valid according to RFC 1459 rules; otherwise, false. */ static bool DefaultIsNick(const std::string_view& nick); /** Determines whether a username is valid according to the RFC 1459 rules. * This is the default function for InspIRCd::IsUser. * @param user The username to validate. * @return True if the username is valid according to RFC 1459 rules; otherwise, false. */ static bool DefaultIsUser(const std::string_view& user); /** Causes the server to exit after unloading modules and closing all open file descriptors. * @param status The exit code to give to the operating system. */ [[noreturn]] void Exit(int status); /** Determines whether a fully qualified hostname is valid according to RFC 5891 rules. * @param host The hostname to validate. * @return True if the hostname is valid; otherwise, false. */ inline static auto IsFQDN(const std::string_view& host) { return IsHost(host, false); } /** Determines whether a hostname is valid according to RFC 5891 rules. * @param host The hostname to validate. * @param allowsimple Whether to allow simple hostnames (e.g. localhost). * @return True if the hostname is valid; otherwise, false. */ static bool IsHost(const std::string_view& host, bool allowsimple); /** Determines whether the specified string is a server identifier. * @param sid The string to check. * @return True if the specified string is a server identifier; otherwise, false. */ static bool IsSID(const std::string_view& sid); /** Determines whether the specified string is a valid nick!user\@host mask. * @param mask The string to check. * @return True if the specified string is a valid nick!user\@host mask; otherwise, false. */ static bool IsValidMask(const std::string& mask); /** Matches two strings using glob pattern matching, optionally with a case map to use instead * of the server case map. * @param str The literal string to match against * @param pattern The glob pattern to match against. * @param map The character map to use when matching. * @return True if the string matches the mask; otherwise, false. */ static bool Match(const std::string& str, const std::string& pattern, const unsigned char* map = nullptr); /** Matches two strings using glob pattern matching, optionally with a case map to use instead * of the server case map. * @param str The literal string to match against * @param pattern The glob pattern to match against. * @param map The character map to use when matching. * @return True if the string matches the pattern; otherwise, false. */ static bool Match(const char* str, const char* pattern, const unsigned char* map = nullptr); /** Matches two strings using glob pattern and CIDR range matching, optionally with a case map * to use instead of the server case map. * @param str The literal string to match against * @param pattern The glob pattern to match against. * @param map The character map to use when matching. * @return True if the string matches the pattern; otherwise, false. */ static bool MatchCIDR(const std::string& str, const std::string& pattern, const unsigned char* map = nullptr); /** Matches two strings using glob pattern and CIDR range matching, optionally with a case map * to use instead of the server case map. * @param str The literal string to match against * @param pattern The glob pattern to match against. * @param map The character map to use when matching. * @return True if the string matches the pattern; otherwise, false. */ static bool MatchCIDR(const char* str, const char* pattern, const unsigned char* map = nullptr); /** Matches a hostname and address against a space delimited list of hostmasks. * @param masks The space delimited masks to match against. * @param hostname The hostname to try and match. * @param address The IP address or UNIX socket path to try and match. * @return True if a mask matches the hostname or address; otherwise, false. */ static bool MatchMask(const std::string& masks, const std::string& hostname, const std::string& address); /** Reloads the server configuration. * @param uuid If non-empty then the uuid of the user who started the rehash. */ void Rehash(const std::string& uuid = ""); /** Starts the execution of the server main loop. */ [[noreturn]] void Run(); /** Replaces color escapes in the specified lines with IRC colors. * @param lines A vector of lines to replace color escapes in. */ [[deprecated("Use ProcessColors(std::string) instead")]] static void ProcessColors(std::vector<std::string>& lines); /** Replaces color escapes in the specified string with IRC colors. * @param lines The string replace color escapes in. */ static void ProcessColors(std::string& str); /** Stores an incoming signal when received from the operating system. * @param signal The signal received from the operating system. */ static void SetSignal(int signal); /* Removes IRC colors from the specified string. * @param str The string to strip colors from. */ static void StripColor(std::string& str); /** Retrieves the time, updated once per main loop iteration, as the number of seconds since * the UNIX epoch. This is faster than calling time functions manually. */ inline auto Time() const { return ts.tv_sec; } /** Retrieves the time, updated once per main loop iteration, as the number of fractional * seconds since the UNIX epoch. This is faster than calling time functions manually. */ inline auto Time_ns() const { return ts.tv_nsec; } /** Compares two strings in a timing-safe way. If the lengths of the strings differ the * function returns false immediately (leaking information about the length). Otherwise, it * compares each character and only returns after all characters have been compared. * @param str1 The first string to compare. * @param str2 The second string to compare. * @return True if the strings are equivalent; otherwise, false. */ static bool TimingSafeCompare(const std::string& str1, const std::string& str2); /** Updates the current cached time. Don't call this unless you have reason to do so. */ void UpdateTime(); }; inline void Cullable::Deleter::operator()(Cullable* item) const { if (item) ServerInstance->GlobalCulls.AddItem(item); } inline void Channel::Write(ClientProtocol::EventProvider& protoevprov, ClientProtocol::Message& msg, char status, const CUList& except_list) const { ClientProtocol::Event event(protoevprov, msg); Write(event, status, except_list); } inline void LocalUser::Send(ClientProtocol::EventProvider& protoevprov, ClientProtocol::Message& msg) { ClientProtocol::Event event(protoevprov, msg); Send(event); } �������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/include/intrusive_list.h�������������������������������������������������������������0000664�0000000�0000000�00000004045�14771603147�0020231�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2020, 2022 Sadie Powell <sadie@witchery.services> * Copyright (C) 2014 Attila Molnar <attilamolnar@hush.com> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #pragma once #include <iterator> namespace insp { struct intrusive_list_def_tag { }; template <typename T, typename Tag = intrusive_list_def_tag> class intrusive_list; template <typename T, typename Tag = intrusive_list_def_tag> class intrusive_list_tail; template <typename T, typename Tag = intrusive_list_def_tag> class intrusive_list_node { T* ptr_next = nullptr; T* ptr_prev = nullptr; void unlink() { if (ptr_next) ptr_next->intrusive_list_node<T, Tag>::ptr_prev = this->ptr_prev; if (ptr_prev) ptr_prev->intrusive_list_node<T, Tag>::ptr_next = this->ptr_next; ptr_next = ptr_prev = nullptr; } public: friend class intrusive_list<T, Tag>; friend class intrusive_list_tail<T, Tag>; }; } // namespace insp // Intrusive list where the list only has a pointer to the head element #define INSPIRCD_INTRUSIVE_LIST_NAME intrusive_list #include "intrusive_list_impl.h" #undef INSPIRCD_INTRUSIVE_LIST_NAME // Intrusive list where the list maintains a pointer to both the head and the tail elements. // Additional methods: back(), push_back(), pop_back() #define INSPIRCD_INTRUSIVE_LIST_NAME intrusive_list_tail #define INSPIRCD_INTRUSIVE_LIST_HAS_TAIL #include "intrusive_list_impl.h" #undef INSPIRCD_INTRUSIVE_LIST_NAME #undef INSPIRCD_INTRUSIVE_LIST_HAS_TAIL �������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/include/intrusive_list_impl.h��������������������������������������������������������0000664�0000000�0000000�00000006165�14771603147�0021257�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2020, 2022 Sadie Powell <sadie@witchery.services> * Copyright (C) 2014 Attila Molnar <attilamolnar@hush.com> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ namespace insp { template <typename T, typename Tag> class INSPIRCD_INTRUSIVE_LIST_NAME final { public: class iterator final { T* curr; public: using difference_type = std::ptrdiff_t; using iterator_category = std::bidirectional_iterator_tag; using pointer = T**; using reference = T*&; using value_type = T*; iterator(T* i = nullptr) : curr(i) { } iterator& operator++() { curr = curr->intrusive_list_node<T, Tag>::ptr_next; return *this; } iterator operator++(int) { iterator ret(*this); operator++(); return ret; } iterator& operator--() { curr = curr->intrusive_list_node<T, Tag>::ptr_prev; return *this; } iterator operator--(int) { iterator ret(*this); operator--(); return ret; } bool operator==(const iterator& other) const { return (curr == other.curr); } bool operator!=(const iterator& other) const { return (curr != other.curr); } T* operator*() const { return curr; } }; typedef iterator const_iterator; bool empty() const { return (size() == 0); } size_t size() const { return listsize; } iterator begin() const { return iterator(listhead); } iterator end() const { return iterator(); } void pop_front() { erase(listhead); } T* front() const { return listhead; } void push_front(T* x) { if (listsize++) { x->intrusive_list_node<T, Tag>::ptr_next = listhead; listhead->intrusive_list_node<T, Tag>::ptr_prev = x; } #ifdef INSPIRCD_INTRUSIVE_LIST_HAS_TAIL else listtail = x; #endif listhead = x; } #ifdef INSPIRCD_INTRUSIVE_LIST_HAS_TAIL T* back() const { return listtail; } void push_back(T* x) { if (listsize++) { x->intrusive_list_node<T, Tag>::ptr_prev = listtail; listtail->intrusive_list_node<T, Tag>::ptr_next = x; } else listhead = x; listtail = x; } void pop_back() { erase(listtail); } #endif void erase(const iterator& it) { erase(*it); } void erase(T* x) { if (listhead == x) listhead = x->intrusive_list_node<T, Tag>::ptr_next; #ifdef INSPIRCD_INTRUSIVE_LIST_HAS_TAIL if (listtail == x) listtail = x->intrusive_list_node<T, Tag>::ptr_prev; #endif x->intrusive_list_node<T, Tag>::unlink(); listsize--; } private: T* listhead = nullptr; #ifdef INSPIRCD_INTRUSIVE_LIST_HAS_TAIL T* listtail = nullptr; #endif size_t listsize = 0; }; } // namespace insp �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/include/iohook.h���������������������������������������������������������������������0000664�0000000�0000000�00000014055�14771603147�0016440�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2021 Dominic Hamon * Copyright (C) 2020-2023 Sadie Powell <sadie@witchery.services> * Copyright (C) 2019 Robby <robby@chatbelgie.be> * Copyright (C) 2013, 2016 Attila Molnar <attilamolnar@hush.com> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #pragma once class StreamSocket; class IOHookProvider : public std::enable_shared_from_this<IOHookProvider> , public ServiceProvider { const bool middlehook; public: enum Type { IOH_UNKNOWN, IOH_SSL }; const Type type; /** Constructor * @param mod Module that owns the IOHookProvider * @param Name Name of the provider * @param hooktype One of IOHookProvider::Type * @param middle True if the IOHook instances created by this hook are subclasses of IOHookMiddle, false otherwise */ IOHookProvider(Module* mod, const std::string& Name, Type hooktype = IOH_UNKNOWN, bool middle = false) : ServiceProvider(mod, Name, SERVICE_IOHOOK) , middlehook(middle) , type(hooktype) { } /** Check if the IOHook provided can appear in the non-last position of a hook chain. * That is the case if and only if the IOHook instances created are subclasses of IOHookMiddle. * @return True if the IOHooks provided are subclasses of IOHookMiddle */ bool IsMiddle() const { return middlehook; } /** Called when the provider should hook an incoming connection and act as being on the server-side of the connection. * This occurs when a bind block has a hook configured and the listener accepts a connection. * @param sock Socket to hook * @param client Client IP address and port * @param server Server IP address and port */ virtual void OnAccept(StreamSocket* sock, const irc::sockets::sockaddrs& client, const irc::sockets::sockaddrs& server) = 0; /** Called when the provider should hook an outgoing connection and act as being on the client side of the connection. * @param sock Socket to hook */ virtual void OnConnect(StreamSocket* sock) = 0; }; class IOHook : public Cullable { public: /** The IOHookProvider for this hook, contains information about the hook, * such as the module providing it and the hook type. */ std::shared_ptr<IOHookProvider> prov; /** Constructor * @param provider IOHookProvider that creates this object */ IOHook(const std::shared_ptr<IOHookProvider>& provider) : prov(provider) { } /** Determines whether this I/O hook is ready to send and receive data. */ virtual bool IsHookReady() const { return true; } /** * Called when the hooked socket has data to write, or when the socket engine returns it as writable * @param sock Hooked socket * @param sendq Send queue to send data from * @return 1 if the sendq has been completely emptied, 0 if there is * still data to send, and -1 if there was an error */ virtual ssize_t OnStreamSocketWrite(StreamSocket* sock, StreamSocket::SendQueue& sendq) = 0; /** Called immediately before the hooked socket is closed. When this event is called, shutdown() * has not yet been called on the socket. * @param sock Hooked socket */ virtual void OnStreamSocketClose(StreamSocket* sock) = 0; /** * Called when the hooked socket has data to read * @param sock Hooked socket * @param recvq The receive queue that new data should be appended to * @return 1 if new data has been read, 0 if no new data is ready (but the * socket is still connected), -1 if there was an error or close */ virtual ssize_t OnStreamSocketRead(StreamSocket* sock, std::string& recvq) = 0; /** Sends a ping to the remote client to check whether it is still connected. * @return True if the client was pinged; otherwise, false. */ virtual bool Ping() { return false; } }; class IOHookMiddle : public IOHook { /** Data already processed by the IOHook waiting to go down the chain */ StreamSocket::SendQueue sendq; /** Data waiting to go up the chain */ std::string precvq; /** Next IOHook in the chain */ IOHook* nexthook = nullptr; protected: /** Get all queued up data which has not yet been passed up the hook chain * @return RecvQ containing the data */ std::string& GetRecvQ() { return precvq; } /** Get all queued up data which is ready to go down the hook chain * @return SendQueue containing all data waiting to go down the hook chain */ StreamSocket::SendQueue& GetSendQ() { return sendq; } public: /** Constructor * @param provider IOHookProvider that creates this object */ IOHookMiddle(const std::shared_ptr<IOHookProvider>& provider) : IOHook(provider) { } /** @copydoc IOHook::OnStreamSocketClose */ void OnStreamSocketClose(StreamSocket* sock) override { } /** Get all queued up data which is ready to go down the hook chain * @return SendQueue containing all data waiting to go down the hook chain */ const StreamSocket::SendQueue& GetSendQ() const { return sendq; } /** Get the next IOHook in the chain * @return Next hook in the chain or NULL if this is the last hook */ IOHook* GetNextHook() const { return nexthook; } /** Set the next hook in the chain * @param hook Hook to set as the next hook in the chain */ void SetNextHook(IOHook* hook) { nexthook = hook; } /** Check if a hook is capable of being the non-last hook in a hook chain and if so, cast it to an IOHookMiddle object. * @param hook IOHook to check * @return IOHookMiddle referring to the same hook or NULL */ static IOHookMiddle* ToMiddleHook(IOHook* hook) { if (hook->prov->IsMiddle()) return static_cast<IOHookMiddle*>(hook); return nullptr; } friend class StreamSocket; }; �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/include/listmode.h�������������������������������������������������������������������0000664�0000000�0000000�00000015673�14771603147�0016777�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2018 B00mX0r <b00mx0r@aureus.pw> * Copyright (C) 2013-2014 Attila Molnar <attilamolnar@hush.com> * Copyright (C) 2013, 2017-2019, 2021-2023 Sadie Powell <sadie@witchery.services> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #pragma once #include "extension.h" /** The base class for list modes, should be inherited. */ class CoreExport ListModeBase : public ModeHandler { public: /** An item in a listmode's list */ struct ListItem final { std::string setter; std::string mask; time_t time; ListItem(const std::string& Mask, const std::string& Setter, time_t Time) : setter(Setter) , mask(Mask) , time(Time) { } }; /** Items stored in the channel's list */ typedef std::vector<ListItem> ModeList; private: class ChanData final { public: ModeList list; std::optional<size_t> maxitems; }; /** The number of items a listmode's list may contain */ struct ListLimit final { std::string mask; size_t limit; ListLimit(const std::string& Mask, size_t Limit) : mask(Mask) , limit(Limit) { } bool operator==(const ListLimit& other) const { return (this->mask == other.mask && this->limit == other.limit); } }; /** Max items per channel by name */ typedef std::vector<ListLimit> limitlist; /** The default maximum list size. */ static constexpr unsigned int DEFAULT_LIST_SIZE = 100; /** Finds the limit of modes that can be placed on the given channel name according to the config * @param channame The channel name to find the limit for * @return The maximum number of modes of this type that we allow to be set on the given channel name */ size_t FindLimit(const std::string& channame); /** Returns the limit on the given channel for this mode. * If the limit is cached then the cached value is returned, * otherwise the limit is determined using FindLimit() and cached * for later queries before it is returned * @param channame The channel name to find the limit for * @param cd The ChanData associated with channel channame * @return The maximum number of modes of this type that we allow to be set on the given channel */ size_t GetLimitInternal(const std::string& channame, ChanData* cd); protected: /** Numeric to use when outputting the list */ unsigned int listnumeric; /** Numeric to indicate end of list */ unsigned int endoflistnumeric; /** Limits on a per-channel basis read from the \<listmode> * config tag. */ limitlist chanlimits; /** Storage key */ SimpleExtItem<ChanData> extItem; public: /** Constructor. * @param Creator The creator of this class * @param Name Mode name * @param modechar Mode character * @param lnum List numeric * @param eolnum End of list numeric */ ListModeBase(Module* Creator, const std::string& Name, char modechar, unsigned int lnum, unsigned int eolnum); /** Determines whether some channels have longer lists than others. */ bool HasVariableLength() const { return chanlimits.size() > 1; } /** Compares an entry from this list with the specified value. * @param entry The list entry to compare against. * @param value The value to compare to. * @return If the entries are equivalent then true; otherwise, false. */ virtual bool CompareEntry(const std::string& entry, const std::string& value) const { return entry == value; } /** Get limit of this mode on a channel * @param channel The channel to inspect * @return Maximum number of modes of this type that can be placed on the given channel */ size_t GetLimit(Channel* channel); /** Gets the lower list limit for this listmode. */ size_t GetLowerLimit(); /** Retrieves the list of all modes set on the given channel * @param channel Channel to get the list from * @return A list with all modes of this type set on the given channel, can be NULL */ ModeList* GetList(Channel* channel); /** @copydoc ModeHandler::DisplayList */ void DisplayList(User* user, Channel* channel) override; /** @copydoc ModeHandler::DisplayEmptyList */ void DisplayEmptyList(User* user, Channel* channel) override; /** @copydoc ModeHandler::RemoveMode(Channel*,Modes::ChangeList&) */ void RemoveMode(Channel* channel, Modes::ChangeList& changelist) override; /** Perform a rehash of this mode's configuration data */ void DoRehash(); /** @copydoc ModeHandler::OnModeChange */ bool OnModeChange(User* source, User* dest, Channel* channel, Modes::Change& change) override; /** Validate a potential entry for this list mode. This is only for local validation, you * should be prepared to handle malformed entries from remote servers as there is no good * way to prevent them from being set without causing a desync. * @param user The local user which sent the list mode change. * @param channel The channel the mode is being changed on. * @param parameter The parameter that the user specified. * @return True if the parameter is valid; otherwise, false. */ virtual bool ValidateParam(LocalUser* user, Channel* channel, std::string& parameter); /** @copydoc ModeHandler::OnParameterMissing */ void OnParameterMissing(User* user, User* dest, Channel* channel) override; /** Tell the user the list is too long. * Overridden by implementing module. * @param source Source user adding the parameter * @param channel Channel the parameter is being added to * @param parameter The actual parameter being added * @param limit The list limit for the channel. */ virtual void TellListTooLong(LocalUser* source, Channel* channel, const std::string& parameter, size_t limit); /** Tell the user an item is already on the list. * Overridden by implementing module. * @param source Source user adding the parameter * @param channel Channel the parameter is being added to * @param parameter The actual parameter being added */ virtual void TellAlreadyOnList(LocalUser* source, Channel* channel, const std::string& parameter); /** Tell the user that the parameter is not in the list. * Overridden by implementing module. * @param source Source user removing the parameter * @param channel Channel the parameter is being removed from * @param parameter The actual parameter being removed */ virtual void TellNotSet(LocalUser* source, Channel* channel, const std::string& parameter); }; inline ListModeBase::ModeList* ListModeBase::GetList(Channel* channel) { ChanData* cd = extItem.Get(channel); if (!cd) return nullptr; return &cd->list; } ���������������������������������������������������������������������inspircd-4.7.0/include/logging.h��������������������������������������������������������������������0000664�0000000�0000000�00000026060�14771603147�0016575�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2022-2025 Sadie Powell <sadie@witchery.services> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #pragma once namespace Log { class Method; class FileMethod; class Engine; class FileEngine; class StreamEngine; class Manager; /** A shared pointer to a log method. */ typedef std::shared_ptr<Method> MethodPtr; /** Levels at which messages can be logged. */ enum class Level : uint8_t { /** A critical message which must be investigated. */ CRITICAL = 0, /** An important message which should be investigated. */ WARNING = 1, /** A general message which is useful to have on record. */ NORMAL = 2, /** A debug message that we might want to store when testing. */ DEBUG = 3, /** A sensitive message that we should not store lightly. */ RAWIO = 4, /** The lowest log level supported. */ LOWEST = CRITICAL, /** The highest log level supported. */ HIGHEST = RAWIO, }; /** Converts a log level to a string. * @param level The log level to convert. */ CoreExport const char* LevelToString(Level level); /** Notify a user that raw I/O logging is enabled. * @param user The user to notify. * @param type The type of message to send. */ CoreExport void NotifyRawIO(LocalUser* user, MessageType type); } /** Base class for logging methods. */ class CoreExport Log::Method { protected: Method() = default; public: virtual ~Method() = default; /** Determines whether this logging method accepts cached messages. */ virtual bool AcceptsCachedMessages() const { return true; } /** Writes a message to the logger. * @param time The time at which the message was logged. * @param level The level at which the log message was written. * @param type The component which wrote the log message. * @param message The message which was written to the log. */ virtual void OnLog(time_t time, Level level, const std::string& type, const std::string& message) = 0; }; /** A logger that writes to a file stream. */ class CoreExport Log::FileMethod final : public Method , public Timer { private: /** Whether to autoclose the file on exit. */ bool autoclose; /** The file to which the log is written. */ FILE* file; /** How often the file stream should be flushed. */ const unsigned long flush; /** The number of lines which have been written since the file stream was created. */ unsigned long lines = 0; /** The name the underlying file. */ const std::string name; public: FileMethod(const std::string& n, FILE* fh, unsigned long fl, bool ac); ~FileMethod() override; /** @copydoc Log::Method::AcceptsCachedMessages */ bool AcceptsCachedMessages() const override { return false; } /** @copydoc Timer::Tick */ bool Tick() override; /** @copydoc Log::Method::OnLog */ void OnLog(time_t time, Level level, const std::string& type, const std::string& message) override; }; /** Base class for logging engines. */ class CoreExport Log::Engine : public DataProvider { protected: Engine(Module* Creator, const std::string& Name); public: virtual ~Engine() override; /** Creates a new logger from the specified config. * @param tag The config tag to configure the logger with. */ virtual MethodPtr Create(const std::shared_ptr<ConfigTag>& tag) = 0; }; /** A logger which writes to a file. */ class CoreExport Log::FileEngine final : public Engine { public: FileEngine(Module* Creator); /** @copydoc Log::Engine::Create */ MethodPtr Create(const std::shared_ptr<ConfigTag>& tag) override; }; /** A logger which writes to a stream. */ class CoreExport Log::StreamEngine final : public Engine { private: FILE* file; public: StreamEngine(Module* Creator, const std::string& Name, FILE* fh); /** @copydoc Log::Engine::Create */ MethodPtr Create(const std::shared_ptr<ConfigTag>& tag) override; }; /** Manager for the logging system. */ class CoreExport Log::Manager final { private: /** A log message which has been cached until modules load. */ struct CachedMessage final { /** The time the message was logged at. */ time_t time; /** The level the message was logged at. */ Level level; /** The type of the message that was logged. */ std::string type; /** The message that was logged. */ std::string message; CachedMessage(time_t ts, Level l, const std::string& t, const std::string& m); }; /** Encapsulates information about a logger. */ struct Info final { /** Whether the logger was read from the server config. */ bool config; /** Whether this logger is dead and is awaiting removal. */ bool dead = false; /** The minimum log level that this logger accepts. */ Level level; /** The types of log message that this logger accepts. */ TokenList types; /** The handler for this logger type. */ MethodPtr method; /** The engine which created this logger. */ const Engine* engine; Info(Level l, TokenList t, MethodPtr m, bool c, const Engine* e) ATTR_NOT_NULL(6); /** Determines whether a message of the specified level and type should be written to this logger. * @param l The level to check * @param t The type to check. */ bool Suitable(Level l, const std::string& t) const; }; /** The log messages we have cached for modules. */ std::vector<CachedMessage> cache; /** Whether we have just started up and need to cache messages until modules are loaded. */ bool caching = true; /** The logger engine that writes to a file. */ Log::FileEngine filelog; /** A logger that writes to stderr. */ Log::StreamEngine stderrlog; /** A logger that writes to stdout. */ Log::StreamEngine stdoutlog; /** The currently registered loggers. */ std::vector<Info> loggers; /** Whether we are currently logging to a file. */ bool logging = false; /** The highest level that loggers will accept. */ Log::Level maxlevel = Level::HIGHEST; /** Check for the highest log level and warn about raw logging */ void CheckLevel(); /** Writes a message to the server log. * @param level The level to log at. * @param type The type of message that is being logged. * @param message The message to log. */ void Write(Level level, const std::string& type, const std::string& message); template <typename... Args> void Write(Level level, const std::string& type, const char* format, Args&&... args) { if (maxlevel < level && !caching) return; // No loggers care about this message. try { Write(level, type, fmt::vformat(format, fmt::make_format_args(args...))); } catch (const fmt::format_error& err) { // This should only ever happen when we encounter a bug. Write(Log::Level::CRITICAL, "LOG", "BUG: failed to format a log message: {} -- {}", format, err.what()); } } public: Manager(); /** Closes all loggers which were opened from the config. */ void CloseLogs(); /** Enables writing rawio logs to the standard output stream. */ void EnableDebugMode(); /** Opens loggers that are specified in the config. */ void OpenLogs(bool requiremethods); /** Registers the core logging services with the event system. */ void RegisterServices(); /** Unloads all loggers that are provided by the specified engine. * @param engine The engine to unload the loggers of. */ void UnloadEngine(const Engine* engine) ATTR_NOT_NULL(2); /** Writes an critical message to the server log. * @param type The type of message that is being logged. * @param message The message to log. */ inline void Critical(const std::string& type, const std::string& message) { Write(Level::CRITICAL, type, message); } /** Writes an critical message to the server log. * @param type The type of message that is being logged. * @param format A format string to format and then log. * @param args One or more arguments to format the string with. */ template <typename... Args> void Critical(const std::string& type, const char* format, Args&&... args) { Write(Level::CRITICAL, type, format, std::forward<Args>(args)...); } /** Writes a warning message to the server log. * @param type The type of message that is being logged. * @param message The message to log. */ inline void Warning(const std::string& type, const std::string& message) { Write(Level::WARNING, type, message); } /** Writes a warning message to the server log. * @param type The type of message that is being logged. * @param format A format string to format and then log. * @param args One or more arguments to format the string with. */ template <typename... Args> void Warning(const std::string& type, const char* format, Args&&... args) { Write(Level::WARNING, type, format, std::forward<Args>(args)...); } /** Writes a normal message to the server log. * @param type The type of message that is being logged. * @param message The message to log. */ inline void Normal(const std::string& type, const std::string& message) { Write(Level::NORMAL, type, message); } /** Writes a normal message to the server log. * @param type The type of message that is being logged. * @param format A format string to format and then log. * @param args One or more arguments to format the string with. */ template <typename... Args> void Normal(const std::string& type, const char* format, Args&&... args) { Write(Level::NORMAL, type, format, std::forward<Args>(args)...); } /** Writes a debug message to the server log. * @param type The type of message that is being logged. * @param message The message to log. */ inline void Debug(const std::string& type, const std::string& message) { Write(Level::DEBUG, type, message); } /** Writes a debug message to the server log. * @param type The type of message that is being logged. * @param format A format string to format and then log. * @param args One or more arguments to format the string with. */ template <typename... Args> void Debug(const std::string& type, const char* format, Args&&... args) { Write(Level::DEBUG, type, format, std::forward<Args>(args)...); } /** Writes a raw I/O message to the server log. * @param type The type of message that is being logged. * @param message The message to log. */ inline void RawIO(const std::string& type, const std::string& message) { Write(Level::RAWIO, type, message); } /** Writes a raw I/O message to the server log. * @param type The type of message that is being logged. * @param format A format string to format and then log. * @param args One or more arguments to format the string with. */ template <typename... Args> void RawIO(const std::string& type, const char* format, Args&&... args) { Write(Level::RAWIO, type, format, std::forward<Args>(args)...); } }; ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/include/membership.h�����������������������������������������������������������������0000664�0000000�0000000�00000012264�14771603147�0017303�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2013-2014, 2016 Attila Molnar <attilamolnar@hush.com> * Copyright (C) 2013, 2017-2018, 2021-2022, 2024 Sadie Powell <sadie@witchery.services> * Copyright (C) 2012 Robby <robby@chatbelgie.be> * Copyright (C) 2009 Daniel De Graaf <danieldg@inspircd.org> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #pragma once #include "convto.h" /** * Represents a member of a channel. * A Membership object is created when a user joins a channel, and destroyed when a user leaves * (via kick, part or quit) a channel. * All prefix modes a member has is tracked by this object. Moreover, Memberships are Extensibles * meaning modules can add arbitrary data to them using extensions (see m_delaymsg for an example). */ class CoreExport Membership final : public Extensible , public insp::intrusive_list_node<Membership> { public: /** Type of the Membership id */ typedef uint64_t Id; /** User on the channel */ User* const user; /** Channel the user is on */ Channel* const chan; /** List of prefix mode letters this member has, * sorted by prefix rank, highest first */ std::set<PrefixMode*, PrefixMode::Sorter> modes; /** Id of this Membership, set by the protocol module, other components should never read or * write this field. */ Id id; /** Converts a string to a Membership::Id * @param str The string to convert * @return Raw value of type Membership::Id */ static Id IdFromString(const std::string& str) { return ConvToNum<Id>(str); } /** Constructor, sets the user and chan fields to the parameters, does NOT update any bookkeeping * information in the User or the Channel. * Call Channel::JoinUser() or ForceJoin() to make a user join a channel instead of constructing * Membership objects directly. */ Membership(User* u, Channel* c) : Extensible(ExtensionType::MEMBERSHIP) , user(u) , chan(c) { } /** Check if this member has a given prefix mode set * @param pm Prefix mode to check * @return True if the member has the prefix mode set, false otherwise */ bool HasMode(const PrefixMode* pm) const { return std::find(modes.begin(), modes.end(), pm) != modes.end(); } /** Returns the highest prefix mode for this membership or nullptr if no prefix mode is set. */ PrefixMode* GetMode() const { return modes.empty() ? nullptr : *modes.begin(); } /** Returns the rank of this member. * The rank of a member is defined as the rank given by the 'strongest' prefix mode a * member has. See the PrefixMode class description for more info. * @return The rank of the member */ ModeHandler::Rank GetRank() const { return modes.empty() ? 0 : (*modes.begin())->GetPrefixRank(); } /** Add a prefix character to a user. * Only the core should call this method, usually from * within the mode parser or when the first user joins * the channel (to grant the default privs to them) * @param mh The mode handler of the prefix mode to associate * @param adding True if adding the prefix, false when removing * @return True if a change was made */ bool SetPrefix(PrefixMode* mh, bool adding); /** Get the highest prefix this user has on the channel * @return A character containing the highest prefix. * If the user has no prefix, 0 is returned. If the user has multiple prefixes, * the highest is returned. If you do not recognise the prefix character you * can get, you can deal with it in a 'proportional' manner compared to known * prefixes, using GetPrefixValue(). */ char GetPrefixChar() const; /** Get the mode character of the highest prefix mode this user has on the channel or 0 if no prefix modes are set. */ char GetModeChar() const { return modes.empty() ? 0 : (*modes.begin())->GetModeChar(); } /** Return all prefix chars this member has. * @return A list of all prefix characters. The prefixes will always * be in rank order, greatest first, as certain IRC clients require * this when multiple prefixes are used names lists. */ std::string GetAllPrefixChars() const; /** Returns all prefix modes this member has ordered descending by rank. */ std::string GetAllPrefixModes() const; /** Sends a server notice to this user in the context of this channel. * @param text The contents of the message to send. */ void WriteNotice(const std::string& text) const; /** Sends a server notice to this user in the context of this channel. * @param text A format string to format and then send. * @param p One or more arguments to format the string with. */ template <typename... Param> void WriteNotice(const char* text, Param&&... p) { WriteNotice(fmt::vformat(text, fmt::make_format_args(p...))); } }; ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/include/message.h��������������������������������������������������������������������0000664�0000000�0000000�00000011603�14771603147�0016570�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2018 Attila Molnar <attilamolnar@hush.com> * Copyright (C) 2017-2018, 2020-2021, 2023 Sadie Powell <sadie@witchery.services> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #pragma once /** Whether message was a PRIVMSG or a NOTICE. */ enum class MessageType : uint8_t { /** The message is a PRIVMSG. */ PRIVMSG, /** The message is a NOTICE. */ NOTICE, }; class CoreExport MessageDetails { public: /** Whether to echo the message at all. */ bool echo = true; /* Whether to send the original message back to clients with echo-message support. */ bool echo_original = false; /** Whether to update the source user's idle time. */ bool update_idle = true; /** The users who are exempted from receiving this message. */ CUList exemptions; /* The original message as sent by the user. */ const std::string original_text; /** IRCv3 message tags sent to the server by the user. */ const ClientProtocol::TagMap tags_in; /** IRCv3 message tags sent out to users who get this message. */ ClientProtocol::TagMap tags_out; /** The message which will be sent to clients. */ std::string text; /** The type of message. */ MessageType type; /** Determines whether the specified message is a CTCP. If the specified message * is a CTCP then the CTCP name and CTCP body are extracted and stored in the * name and body references. * @param name The location to store the parsed CTCP name. * @param body The location to store the parsed CTCP body. */ virtual bool IsCTCP(std::string_view& name, std::string_view& body) const = 0; /** Determines whether the specified message is a CTCP. If the specified message * is a CTCP then the CTCP name is extracted and stored in the name reference. * @param name The location to store the parsed CTCP name. */ virtual bool IsCTCP(std::string_view& name) const = 0; /** Determines whether the specified message is a CTCP. */ virtual bool IsCTCP() const = 0; protected: MessageDetails(MessageType mt, const std::string& msg, const ClientProtocol::TagMap& tags) : original_text(msg) , tags_in(tags) , text(msg) , type(mt) { } }; /** Represents the target of a message (NOTICE, PRIVMSG, etc). */ class CoreExport MessageTarget final { public: /** An enumeration of possible message target types. */ enum TargetType { /** The target of the message is a user. */ TYPE_USER, /** The target of the message is a channel. */ TYPE_CHANNEL, /** The target of the message is a server. */ TYPE_SERVER }; private: /** The target of the message. */ void* dest; public: /** If type is TYPE_CHANNEL then the original status rank of users who can receive the message. */ const char original_status = 0; /** If type is TYPE_CHANNEL then the status rank of users who can receive the message. */ char status = 0; /** The type of the target of the message. If this is TYPE_CHANNEL then dest * is a Channel*, TYPE_USER then dest is a User*, and TYPE_SERVER then dest is * a std::string* containing a server glob. */ const MessageTarget::TargetType type; /** Initialises a new channel message target. * @param channel The channel which is the target of the message. * @param statuschar The lowest status rank that the message is being sent to. */ MessageTarget(Channel* channel, char statuschar) : dest(channel) , original_status(statuschar) , status(statuschar) , type(TYPE_CHANNEL) { } /** Initialises a new user message target. * @param user The user which is the target of the message. */ MessageTarget(User* user) : dest(user) , type(TYPE_USER) { } /** Initialises a new server message target. * @param server The server glob which is the target of the message. */ MessageTarget(std::string* server) : dest(server) , type(TYPE_SERVER) { } /** Retrieves the target of this message. */ template<typename T> T* Get() const { return static_cast<T*>(dest); } /** Retrieves the name of the target of this message. */ const std::string& GetName() const { switch (type) { case TYPE_CHANNEL: return Get<Channel>()->name; case TYPE_USER: return Get<User>()->nick; case TYPE_SERVER: return *Get<std::string>(); } // We should never reach this point during a normal execution but // handle it just in case. static const std::string target = "*"; return target; } }; �����������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/include/mode.h�����������������������������������������������������������������������0000664�0000000�0000000�00000076332�14771603147�0016102�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2013-2016 Attila Molnar <attilamolnar@hush.com> * Copyright (C) 2012-2013, 2017-2024 Sadie Powell <sadie@witchery.services> * Copyright (C) 2012 Robby <robby@chatbelgie.be> * Copyright (C) 2009 Daniel De Graaf <danieldg@inspircd.org> * Copyright (C) 2008 Thomas Stagner <aquanight@gmail.com> * Copyright (C) 2007 Robin Burchell <robin+git@viroteck.net> * Copyright (C) 2007 Dennis Friis <peavey@inspircd.org> * Copyright (C) 2006-2008 Craig Edwards <brain@inspircd.org> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #pragma once #include "ctables.h" #include "modechange.h" /** * Holds the values for different type of modes * that can exist, USER or CHANNEL type. */ enum ModeType { /** User mode */ MODETYPE_USER = 0, /** Channel mode */ MODETYPE_CHANNEL = 1 }; /** * These fixed values can be used to proportionally compare module-defined prefixes to known values. * For example, if your module queries a Channel, and is told that user 'joebloggs' has the prefix * '$', and you dont know what $ means, then you can compare it to these three values to determine * its worth against them. For example if '$' had a value of 15000, you would know it is of higher * status than voice, but lower status than halfop. * No two modes should have equal prefix values. */ enum PrefixModeValue { /* +v */ VOICE_VALUE = 10000, /* +h */ HALFOP_VALUE = 20000, /* +o */ OP_VALUE = 30000 }; enum ParamSpec { /** No parameters */ PARAM_NONE, /** Parameter required on mode setting only */ PARAM_SETONLY, /** Parameter always required */ PARAM_ALWAYS }; class PrefixMode; class ListModeBase; class ParamModeBase; /** Each mode is implemented by ONE ModeHandler class. * You must derive ModeHandler and add the child class to * the list of modes handled by the ircd, using * ModeParser::AddMode. When the mode you implement is * set by a user, the virtual function OnModeChange is * called. If you specify a value greater than 0 for * parameters_on or parameters_off, then when the mode is * set or unset respectively, std::string& parameter will * contain the parameter given by the user, else it will * contain an empty string. You may alter this parameter * string, and if you alter it to an empty string, and your * mode is expected to have a parameter, then this is * equivalent to returning false. */ class CoreExport ModeHandler : public ServiceProvider { public: /** The underlying type of a mode rank. */ typedef unsigned long Rank; /** The underlying type of a mode id. */ typedef size_t Id; enum Class { MC_PREFIX, MC_LIST, MC_PARAM, MC_OTHER }; private: /** The opaque id of this mode assigned by the mode parser */ Id modeid; protected: /** What kind of parameters does the mode take? */ ParamSpec parameters_taken; /** * The mode letter you're implementing. */ char mode; /** * True if the mode requires oper status * to set. */ bool oper = false; /** * Mode is a 'list' mode. The behaviour * of your mode is now set entirely within * the class as of the 1.1 api, rather than * inside the mode parser as in the 1.0 api, * so the only use of this value (along with * IsListMode()) is for the core to determine * whether your module can produce 'lists' or not * (e.g. banlists, etc) */ bool list = false; /** * The mode type, either MODETYPE_USER or * MODETYPE_CHANNEL. */ ModeType m_type; /** The object type of this mode handler */ const Class type_id; /** The prefix rank required to set this mode on channels. */ Rank ranktoset = HALFOP_VALUE; /** The prefix rank required to unset this mode on channels. */ Rank ranktounset = HALFOP_VALUE; /** If non-empty then the syntax of the parameter for this mode. */ std::string syntax; public: /** * The constructor for ModeHandler initializes the mode handler. * The constructor of any class you derive from ModeHandler should * probably call this constructor with the parameters set correctly. * @param me The module which created this mode * @param name A one-word name for the mode * @param modeletter The mode letter you wish to handle * @param params Parameters taken by the mode * @param type Type of the mode (MODETYPE_USER or MODETYPE_CHANNEL) * @param mclass The object type of this mode handler, one of ModeHandler::Class */ ModeHandler(Module* me, const std::string& name, char modeletter, ParamSpec params, ModeType type, Class mclass = MC_OTHER); Cullable::Result Cull() override; /** Register this object in the ModeParser */ void RegisterService() override; /** * Returns true if the mode is a list mode */ bool IsListMode() const { return list; } /** * Check whether this mode is a prefix mode * @return non-NULL if this mode is a prefix mode, NULL otherwise */ PrefixMode* IsPrefixMode(); /** * Check whether this mode is a prefix mode * @return non-NULL if this mode is a prefix mode, NULL otherwise */ const PrefixMode* IsPrefixMode() const; /** * Check whether this mode handler inherits from ListModeBase * @return non-NULL if this mode handler inherits from ListModeBase, NULL otherwise */ ListModeBase* IsListModeBase(); /** * Check whether this mode handler inherits from ListModeBase * @return non-NULL if this mode handler inherits from ListModeBase, NULL otherwise */ const ListModeBase* IsListModeBase() const; /** * Check whether this mode handler inherits from ParamModeBase * @return non-NULL if this mode handler inherits from ParamModeBase, NULL otherwise */ ParamModeBase* IsParameterMode(); /** * Check whether this mode handler inherits from ParamModeBase * @return non-NULL if this mode handler inherits from ParamModeBase, NULL otherwise */ const ParamModeBase* IsParameterMode() const; /** * Returns the mode's type */ inline ModeType GetModeType() const { return m_type; } /** * Returns true if the mode can only be set/unset by an oper */ inline bool NeedsOper() const { return oper; } /** * Check if the mode needs a parameter for adding or removing * @param adding True to check if the mode needs a parameter when setting, false to check if the mode needs a parameter when unsetting * @return True if the mode needs a parameter for the specified action, false if it doesn't */ bool NeedsParam(bool adding) const; /** * Returns the mode character this handler handles. * @return The mode character */ char GetModeChar() const { return mode; } /** Return the id of this mode which is used in User::modes and * Channel::modes as the index to determine whether a mode is set. */ Id GetId() const { return modeid; } /** For user modes, return the current parameter, if any */ virtual std::string GetUserParameter(const User* user) const; /** * Called when a channel mode change access check for your mode occurs. * @param source Contains the user setting the mode. * @param channel The destination channel the modes are being set on. * @param change Information regarding the mode change. */ virtual ModResult AccessCheck(User* source, Channel* channel, Modes::Change& change); /** * Called when a mode change for your mode occurs. * @param source Contains the user setting the mode. * @param dest For usermodes, contains the destination user the mode is being set on. For channelmodes, this is an undefined value. * @param channel For channel modes, contains the destination channel the modes are being set on. For usermodes, this is an undefined value. * @param change Information regarding the mode change. * @return true to allow the mode, or false to prevent the mode, also see the description of 'parameter'. */ virtual bool OnModeChange(User* source, User* dest, Channel* channel, Modes::Change& change); /** * If your mode is a listmode, then this method will be called for displaying an item list, e.g. on MODE \#channel +modechar * without any parameter or other modes in the command. * @param user The user issuing the command * @param channel The channel they're requesting an item list of (e.g. a banlist, or an exception list etc) */ virtual void DisplayList(User* user, Channel* channel); /** In the event that the mode should be given a parameter, and no parameter was provided, this method is called. * This allows you to give special information to the user, or handle this any way you like. * @param user The user issuing the mode change * @param dest For user mode changes, the target of the mode. For channel mode changes, NULL. * @param channel For channel mode changes, the target of the mode. For user mode changes, NULL. */ virtual void OnParameterMissing(User* user, User* dest, Channel* channel); /** Called when a user attempts to set a mode and the parameter is invalid. * @param user The user issuing the mode change * @param targetchannel Either the channel target or NULL if changing a user mode. * @param targetuser Either the user target or NULL if changing a channel mode. * @param parameter The invalid parameter. */ virtual void OnParameterInvalid(User* user, Channel* targetchannel, User* targetuser, const std::string& parameter); /** * If your mode is a listmode, this method will be called to display an empty list (just the end of list numeric) * @param user The user issuing the command * @param channel The channel they're requesting an item list of (e.g. a banlist, or an exception list etc) */ virtual void DisplayEmptyList(User* user, Channel* channel); /** * If your mode needs special action during a server sync to determine which side wins when comparing timestamps, * override this function and use it to return true or false. The default implementation just returns true if * theirs < ours. This will only be called for non-listmodes with parameters, when adding the mode and where * theirs == ours (therefore the default implementation will always return false). * @param their_param Their parameter if the mode has a parameter * @param our_param Our parameter if the mode has a parameter * @param channel The channel we are checking against * @return True if the other side wins the merge, false if we win the merge for this mode. */ virtual bool ResolveModeConflict(const std::string& their_param, const std::string& our_param, Channel* channel); /** * When a MODETYPE_USER mode handler is being removed, the core will call this method for every user on the server. * The usermode will be removed using the appropriate server mode using InspIRCd::SendMode(). * @param user The user which the server wants to remove your mode from */ void RemoveMode(User* user); /** * When a MODETYPE_CHANNEL mode handler is being removed, the server will call this method for every channel on the server. * The mode handler has to populate the given modestacker with mode changes that remove the mode from the channel. * The default implementation of this method can remove all kinds of channel modes except listmodes. * In the case of listmodes, the entire list of items must be added to the modestacker (which is handled by ListModeBase, * so if you inherit from it or your mode can be removed by the default implementation then you do not have to implement * this function). * @param channel The channel which the server wants to remove your mode from * @param changelist Mode change list to populate with the removal of this mode */ virtual void RemoveMode(Channel* channel, Modes::ChangeList& changelist); /** Retrieves the level required to modify this mode. * @param adding Whether the mode is being added or removed. */ inline auto GetLevelRequired(bool adding) const { return adding ? ranktoset : ranktounset; } /** Retrieves the syntax of the parameter for this mode. */ const auto& GetSyntax() const { return syntax; } friend class ModeParser; }; /** * Prefix modes are channel modes that grant a specific rank to members having prefix mode set. * They require a parameter when setting and unsetting; the parameter is always a member of the channel. * A prefix mode may be set on any number of members on a channel, but for a given member a given prefix * mode is either set or not set, in other words members cannot have the same prefix mode set more than once. * * A rank of a member is defined as the rank given by the 'strongest' prefix mode that member has. * Other parts of the IRCd use this rank to determine whether a channel action is allowable for a user or not. * The rank of a prefix mode is constant, i.e. the same rank value is given to all users having that prefix mode set. * * Note that it is possible that the same action requires a different rank on a different channel; * for example changing the topic on a channel having +t set requires a rank that is >= than the rank of a halfop, * but there is no such restriction when +t isn't set. */ class CoreExport PrefixMode : public ModeHandler { protected: /** The prefix character granted by this mode. '@' for op, '+' for voice, etc. * If 0, this mode does not have a visible prefix character. */ char prefix; /** The prefix rank of this mode, used to compare prefix * modes */ Rank prefixrank; /** Whether a client with this prefix can remove it from themself. */ bool selfremove = true; public: /** Sorts a container of PrefixMode* objects descending by their rank. */ struct Sorter final { bool operator()(const PrefixMode* lhs, const PrefixMode* rhs) const { return lhs->GetPrefixRank() > rhs->GetPrefixRank(); } }; /** * Constructor * @param Creator The module creating this mode * @param Name The user-friendly one word name of the prefix mode, e.g.: "op", "voice" * @param ModeLetter The mode letter of this mode * @param PrefixRank Rank given by this prefix mode, see explanation above * @param PrefixChar Prefix character, or 0 if the mode has no prefix character */ PrefixMode(Module* Creator, const std::string& Name, char ModeLetter, Rank PrefixRank = 0, char PrefixChar = 0); /** @copydoc ModeHandler::AccessCheck */ ModResult AccessCheck(User* source, Channel* channel, Modes::Change& change) override; /** @copydoc ModeHandler::OnModeChange */ bool OnModeChange(User* source, User* dest, Channel* channel, Modes::Change& change) override; /** * Updates the configuration of this prefix. * @param rank The prefix rank of this mode. * @param setrank The prefix rank required to set this mode on channels. * @param unsetrank The prefix rank required to set this unmode on channels. * @param selfrm Whether a client with this prefix can remove it from themself. */ void Update(Rank rank, Rank setrank, Rank unsetrank, bool selfrm); /** @copydoc ModeHandler::RemoveMode(Channel*,Modes::ChangeList&) */ void RemoveMode(Channel* channel, Modes::ChangeList& changelist) override; /** * Determines whether a user with this prefix mode can remove it. */ bool CanSelfRemove() const { return selfremove; } /** * Mode prefix or 0. If this is defined, you should * also implement GetPrefixRank() to return an integer * value for this mode prefix. */ char GetPrefix() const { return prefix; } /** * Get the 'value' of this modes prefix. * determines which to display when there are multiple. * The mode with the highest value is ranked first. See the * PrefixModeValue enum and Channel::GetPrefixValue() for * more information. */ Rank GetPrefixRank() const { return prefixrank; } }; /** A prebuilt mode handler which handles a simple user mode, e.g. no parameters, usable by any user, with no extra * behaviour to the mode beyond the basic setting and unsetting of the mode, not allowing the mode to be set if it * is already set and not allowing it to be unset if it is already unset. * An example of a simple user mode is user mode +w. */ class CoreExport SimpleUserMode : public ModeHandler { public: SimpleUserMode(Module* Creator, const std::string& Name, char modeletter, bool operonly = false) : ModeHandler(Creator, Name, modeletter, PARAM_NONE, MODETYPE_USER) { oper = operonly; } /** @copydoc ModeHandler::OnModeChange */ bool OnModeChange(User* source, User* dest, Channel* channel, Modes::Change& change) override; }; /** A prebuilt mode handler which handles a simple channel mode, e.g. no parameters, usable by any user, with no extra * behaviour to the mode beyond the basic setting and unsetting of the mode, not allowing the mode to be set if it * is already set and not allowing it to be unset if it is already unset. * An example of a simple channel mode is channel mode +s. */ class CoreExport SimpleChannelMode : public ModeHandler { public: SimpleChannelMode(Module* Creator, const std::string& Name, char modeletter, bool operonly = false) : ModeHandler(Creator, Name, modeletter, PARAM_NONE, MODETYPE_CHANNEL) { oper = operonly; } /** @copydoc ModeHandler::OnModeChange */ bool OnModeChange(User* source, User* dest, Channel* channel, Modes::Change& change) override; }; /** * The ModeWatcher class can be used to alter the behaviour of a mode implemented * by the core or by another module. To use ModeWatcher, derive a class from it, * and attach it to the mode using Server::AddModeWatcher and Server::DelModeWatcher. * A ModeWatcher will be called both before and after the mode change. */ class CoreExport ModeWatcher : public Cullable { private: /** * The mode name this class is watching */ const std::string mode; /** * The mode type being watched (user or channel) */ ModeType m_type; public: ModuleRef creator; /** * The constructor initializes the mode and the mode type */ ModeWatcher(Module* creator, const std::string& modename, ModeType type); /** * The default destructor does nothing. */ ~ModeWatcher() override; /** * Get the mode name being watched * @return The mode name being watched */ const std::string& GetModeName() const { return mode; } /** * Get the mode type being watched * @return The mode type being watched (user or channel) */ ModeType GetModeType() const { return m_type; } /** * Before the mode character is processed by its handler, this method will be called. * @param source The sender of the mode * @param dest The target user for the mode, if you are watching a user mode * @param channel The target channel for the mode, if you are watching a channel mode * @param change Information regarding the mode change. * If you alter the parameter you are given, the mode handler will see your altered version * when it handles the mode. * @return True to allow the mode change to go ahead, false to abort it. If you abort the * change, the mode handler (and ModeWatcher::AfterMode()) will never see the mode change. */ virtual bool BeforeMode(User* source, User* dest, Channel* channel, Modes::Change& change); /** * After the mode character has been processed by the ModeHandler, this method will be called. * @param source The sender of the mode * @param dest The target user for the mode, if you are watching a user mode * @param channel The target channel for the mode, if you are watching a channel mode * @param change Information regarding the mode change. */ virtual void AfterMode(User* source, User* dest, Channel* channel, const Modes::Change& change); }; /** The mode parser handles routing of modes and handling of mode strings. * It marshalls, controls and maintains both ModeWatcher and ModeHandler classes, * parses client to server MODE strings for user and channel modes, and performs * processing for the 004 mode list numeric, amongst other things. */ class CoreExport ModeParser final { public: /** The maximum number of modes which can be created. */ static constexpr ModeHandler::Id MODEID_MAX = 64; /** The maximum length of a mode parameter. */ static constexpr size_t MODE_PARAM_MAX = 250; /** Type of the container that maps mode names to ModeHandlers */ typedef std::unordered_map<std::string, ModeHandler*, irc::insensitive, irc::StrHashComp> ModeHandlerMap; /** Type of the container that contains whether a mode is set. */ typedef std::bitset<MODEID_MAX> ModeStatus; private: /** Type of the container that maps mode names to ModeWatchers */ typedef insp::flat_multimap<std::string, ModeWatcher*> ModeWatcherMap; /** Last item in the ModeType enum */ static constexpr unsigned int MODETYPE_LAST = 2; /** Mode handlers for each mode indexed by the mode index */ ModeHandler* modehandlers[MODETYPE_LAST][MODEID_MAX]; /** An array of mode handlers indexed by the mode id */ ModeHandler* modehandlersbyid[MODETYPE_LAST][MODEID_MAX]; /** A map of mode handlers keyed by their name */ ModeHandlerMap modehandlersbyname[MODETYPE_LAST]; /** Lists of mode handlers by type */ struct { /** List of mode handlers that inherit from ListModeBase */ std::vector<ListModeBase*> list; /** List of mode handlers that inherit from PrefixMode */ std::vector<PrefixMode*> prefix; } mhlist; /** Mode watcher classes */ ModeWatcherMap modewatchermap; /** Last processed mode change */ Modes::ChangeList LastChangeList; /** Attempts to apply a mode change to a user or channel * @param user The user who triggered the mode change. * @param usertarget If non-NULL then the user to change the modes of. * @param chantarget If non-NULL then the channel to change the modes of. * @param mcitem The actual mode change to attempt. * @param skipacl Whether to skip access checks for the mode change. */ bool TryMode(User* user, User* usertarget, Channel* chantarget, Modes::Change& mcitem, bool skipacl); /** Allocates an unused id for the given mode type, throws a ModuleException if out of ids. * @param mh The mode to allocate the id for * @return The id */ ModeHandler::Id AllocateModeId(ModeHandler* mh); public: typedef std::vector<ListModeBase*> ListModeList; typedef std::vector<PrefixMode*> PrefixModeList; typedef unsigned int ModeProcessFlag; enum ModeProcessFlags { /** If only this flag is specified, the mode change will be global * and parameter modes will have their parameters explicitly set * (not merged). This is the default. */ MODE_NONE = 0, /** If this flag is set then the parameters of non-listmodes will be * merged according to their conflict resolution rules. * Does not affect user modes, channel modes without a parameter and * listmodes. */ MODE_MERGE = 1, /** If this flag is set then the linking module will ignore the mode change * and not send it to other servers. The mode change will be processed * locally and sent to local user(s) as usual. */ MODE_LOCALONLY = 2, /** If this flag is set then the mode change will be subject to access checks. * For more information see the documentation of the PrefixMode class, * ModeHandler::ranktoset and ModeHandler::AccessCheck(). * Modules may explicitly allow a mode change regardless of this flag by returning * MOD_RES_ALLOW from the OnPreMode hook. Only affects channel mode changes. */ MODE_CHECKACCESS = 4 }; ModeParser(); /** Determines whether the specified character is a valid mode. */ static bool IsModeChar(char chr); /** Retrieves the index of the specified mode char within a mode bitset. */ static size_t GetModeIndex(char chr); /** Tidy a banmask. This makes a banmask 'acceptable' if fields are left out. * E.g. * * nick -> nick!*@* * * nick!user -> nick!user@* * * host.name -> *!*\@host.name * * user\@host.name -> *!user\@host.name * * This method can be used on both IPV4 and IPV6 user masks. */ static void CleanMask(std::string& mask); /** Gets the last mode change to be processed. */ const Modes::ChangeList& GetLastChangeList() const { return LastChangeList; } /** Add a mode to the mode parser. * Throws a ModuleException if the mode cannot be added. */ void AddMode(ModeHandler* mh); /** Delete a mode from the mode parser. * When a mode is deleted, the mode handler will be called * for every user (if it is a user mode) or for every channel * (if it is a channel mode) to unset the mode on all objects. * This prevents modes staying in the system which no longer exist. * @param mh The mode handler to remove * @return True if the mode was successfully removed. */ bool DelMode(ModeHandler* mh); /** Add a mode watcher. * A mode watcher is triggered before and after a mode handler is * triggered. See the documentation of class ModeWatcher for more * information. * @param mw The ModeWatcher you want to add */ void AddModeWatcher(ModeWatcher* mw); /** Delete a mode watcher. * A mode watcher is triggered before and after a mode handler is * triggered. See the documentation of class ModeWatcher for more * information. * @param mw The ModeWatcher you want to delete * @return True if the ModeWatcher was deleted correctly */ bool DelModeWatcher(ModeWatcher* mw); /** Process a list of mode changes entirely. If the mode changes do not fit into one MODE line * then multiple MODE lines are generated. * @param user The source of the mode change, can be a server user. * @param targetchannel Channel to apply the mode change on. NULL if changing modes on a channel. * @param targetuser User to apply the mode change on. NULL if changing modes on a user. * @param changelist Modes to change in form of a Modes::ChangeList. * @param flags Optional flags controlling how the mode change is processed, * defaults to MODE_NONE. */ void Process(User* user, Channel* targetchannel, User* targetuser, Modes::ChangeList& changelist, ModeProcessFlag flags = MODE_NONE); /** Process a single MODE line's worth of mode changes, taking max modes and line length limits * into consideration. Return value indicates how many modes were processed. * @param user The source of the mode change, can be a server user. * @param targetchannel Channel to apply the mode change on. NULL if changing modes on a channel. * @param targetuser User to apply the mode change on. NULL if changing modes on a user. * @param changelist Modes to change in form of a Modes::ChangeList. May not process * the entire list due to MODE line length and max modes limitations. * @param flags Optional flags controlling how the mode change is processed, * defaults to MODE_NONE. * @param beginindex Index of the first element in changelist to process. Mode changes before * the element with this index are ignored. * @return Number of mode changes processed from changelist. */ size_t ProcessSingle(User* user, Channel* targetchannel, User* targetuser, Modes::ChangeList& changelist, ModeProcessFlag flags = MODE_NONE, size_t beginindex = 0); /** Turn a list of parameters compatible with the format of the MODE command into * Modes::ChangeList form. All modes are processed, regardless of max modes. Unknown modes * are skipped. * @param user The source of the mode change, can be a server user. Error numerics are sent to * this user. * @param type MODETYPE_USER if this is a user mode change or MODETYPE_CHANNEL if this * is a channel mode change. * @param parameters List of strings describing the mode change to convert to a ChangeList. * Must be using the same format as the parameters of a MODE command. * @param changelist ChangeList object to populate. * @param beginindex Index of the first element that is part of the MODE list in the parameters * container. Defaults to 1. * @param endindex Index of the first element that is not part of the MODE list. By default, * the entire container is considered part of the MODE list. */ void ModeParamsToChangeList(User* user, ModeType type, const std::vector<std::string>& parameters, Modes::ChangeList& changelist, size_t beginindex = 1, size_t endindex = SIZE_MAX); /** Find the mode handler for a given mode name and type. * @param modename The mode name to search for. * @param mt Type of mode to search for, user or channel. * @return A pointer to a ModeHandler class, or NULL of there isn't a handler for the given mode name. */ ModeHandler* FindMode(const std::string& modename, ModeType mt); /** Find the mode handler for a given mode and type. * @param modeletter mode letter to search for * @param mt type of mode to search for, user or channel * @returns a pointer to a ModeHandler class, or NULL of there isn't a handler for the given mode */ ModeHandler* FindMode(unsigned char modeletter, ModeType mt); /** Find the mode handler for the given prefix mode * @param modeletter The mode letter to search for * @return A pointer to the PrefixMode or NULL if the mode wasn't found or it isn't a prefix mode */ PrefixMode* FindPrefixMode(unsigned char modeletter); /** Find the mode handler for the prefix mode nearest the given rank. * @param rank The rank to search for prefix modes near. * @return A pointer to the PrefixMode or NULL if a prefix mode wasn't found. */ PrefixMode* FindNearestPrefixMode(ModeHandler::Rank rank) const; /** Find a mode handler by its prefix. * If there is no mode handler with the given prefix, NULL will be returned. * @param pfxletter The prefix to find, e.g. '@' * @return The mode handler which handles this prefix, or NULL if there is none. */ PrefixMode* FindPrefix(unsigned char pfxletter) const; /** Get a list of all mode handlers that inherit from ListModeBase * @return A list containing ListModeBase modes */ const ListModeList& GetListModes() const { return mhlist.list; } /** Get a list of all prefix modes * @return A list containing all prefix modes */ const PrefixModeList& GetPrefixModes() const { return mhlist.prefix; } /** Get a mode name -> ModeHandler* map containing all modes of the given type * @param mt Type of modes to return, MODETYPE_USER or MODETYPE_CHANNEL * @return A map of mode handlers of the given type */ const ModeHandlerMap& GetModes(ModeType mt) const { return modehandlersbyname[mt]; } /** Show the list of a list mode to a user. Modules can deny the listing. * @param user User to show the list to. * @param chan Channel to show the list of. * @param mh List mode to show the list of. */ void ShowListModeList(User* user, Channel* chan, ModeHandler* mh); }; inline PrefixMode* ModeHandler::IsPrefixMode() { return (this->type_id == MC_PREFIX ? static_cast<PrefixMode*>(this) : nullptr); } inline const PrefixMode* ModeHandler::IsPrefixMode() const { return (this->type_id == MC_PREFIX ? static_cast<const PrefixMode*>(this) : nullptr); } inline ListModeBase* ModeHandler::IsListModeBase() { return (this->type_id == MC_LIST ? reinterpret_cast<ListModeBase*>(this) : nullptr); } inline const ListModeBase* ModeHandler::IsListModeBase() const { return (this->type_id == MC_LIST ? reinterpret_cast<const ListModeBase*>(this) : nullptr); } inline ParamModeBase* ModeHandler::IsParameterMode() { return (this->type_id == MC_PARAM ? reinterpret_cast<ParamModeBase*>(this) : nullptr); } inline const ParamModeBase* ModeHandler::IsParameterMode() const { return (this->type_id == MC_PARAM ? reinterpret_cast<const ParamModeBase*>(this) : nullptr); } ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/include/modechange.h�����������������������������������������������������������������0000664�0000000�0000000�00000007502�14771603147�0017241�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2017-2018, 2021 Sadie Powell <sadie@witchery.services> * Copyright (C) 2014, 2018 Attila Molnar <attilamolnar@hush.com> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #pragma once namespace Modes { struct Change; class ChangeList; } /** A single mode to be changed */ struct Modes::Change final { bool adding; ModeHandler* mh; std::string param; std::optional<std::string> set_by; std::optional<time_t> set_at; /** * @param handler Mode handler * @param add True if this mode is being set, false if removed * @param parameter Mode parameter */ Change(ModeHandler* handler, bool add, const std::string& parameter = "") : adding(add) , mh(handler) , param(parameter) { } /** * @param handler Mode handler * @param add True if this mode is being set, false if removed * @param parameter Mode parameter * @param setby Who the mode change was originally performed by. * @param setat When the mode change was originally made. */ Change(ModeHandler* handler, bool add, const std::string& parameter, const std::string& setby, time_t setat) : adding(add) , mh(handler) , param(parameter) , set_by(setby) , set_at(setat) { } }; /** A list of mode changes that can be applied on a Channel or User */ class Modes::ChangeList final { public: typedef std::vector<Change> List; /** Add a new mode to be changed to this ChangeList * @param change Mode change to add */ void push(const Modes::Change& change) { items.push_back(change); } /** Insert multiple mode changes to the ChangeList * @param first Iterator to the first change to insert * @param last Iterator to the first change to not insert */ void push(List::const_iterator first, List::const_iterator last) { items.insert(items.end(), first, last); } /** Add a new mode to be changed to this ChangeList. Parameters are forwarded to the Modes::Change constructor. */ template <typename... Args> void push(Args&&... args) { items.emplace_back(std::forward<Args>(args)...); } /** Add a new mode to this ChangeList which will be set on the target * @param mh Mode handler * @param param Mode parameter */ void push_add(ModeHandler* mh, const std::string& param = std::string()) { push(mh, true, param); } /** Add a new mode to this ChangeList which will be unset from the target * @param mh Mode handler * @param param Mode parameter */ void push_remove(ModeHandler* mh, const std::string& param = std::string()) { push(mh, false, param); } /** Remove all mode changes from this stack */ void clear() { items.clear(); } /** Checks whether the ChangeList is empty, equivalent to (size() != 0). * @return True if the ChangeList is empty, false otherwise. */ bool empty() const { return items.empty(); } /** Get number of mode changes in this ChangeList * @return Number of mode changes in this ChangeList */ List::size_type size() const { return items.size(); } /** Get the list of mode changes in this ChangeList * @return List of modes added to this ChangeList */ const List& getlist() const { return items; } /** Get the list of mode changes in this ChangeList * @return List of modes added to this ChangeList */ List& getlist() { return items; } private: List items; }; ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/include/moduledefs.h�����������������������������������������������������������������0000664�0000000�0000000�00000003603�14771603147�0017274�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2020, 2025 Sadie Powell <sadie@witchery.services> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #pragma once class Module; /** The version of the InspIRCd ABI which is presently in use. */ #define MODULE_ABI 4007UL /** Stringifies the value of a symbol. */ #define MODULE_STRINGIFY_SYM1(DEF) MODULE_STRINGIFY_SYM2(DEF) #define MODULE_STRINGIFY_SYM2(DEF) #DEF /** The name of the symbol which contains the ABI that a module was compiled against. */ #define MODULE_SYM_ABI inspircd_module_abi #define MODULE_STR_ABI MODULE_STRINGIFY_SYM1(MODULE_SYM_ABI) /** The name of the symbol which creates a new Module instance. */ #define MODULE_SYM_INIT inspircd_module_init #define MODULE_STR_INIT MODULE_STRINGIFY_SYM1(MODULE_SYM_INIT) /** The name of the symbol which contains the version that a module was compiled against. */ #define MODULE_SYM_VERSION inspircd_module_version #define MODULE_STR_VERSION MODULE_STRINGIFY_SYM1(MODULE_SYM_VERSION) /** Defines the interface that a shared library must expose in order to be a module. */ #define MODULE_INIT(klass) \ extern "C" DllExport const unsigned long MODULE_SYM_ABI = MODULE_ABI; \ extern "C" DllExport const char MODULE_SYM_VERSION[] = INSPIRCD_VERSION; \ extern "C" DllExport Module* MODULE_SYM_INIT() { return new klass; } �����������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/include/modules.h��������������������������������������������������������������������0000664�0000000�0000000�00000154275�14771603147�0016631�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2019 iwalkalone <iwalkalone69@gmail.com> * Copyright (C) 2012-2016, 2018 Attila Molnar <attilamolnar@hush.com> * Copyright (C) 2012-2013, 2017-2025 Sadie Powell <sadie@witchery.services> * Copyright (C) 2012 Robby <robby@chatbelgie.be> * Copyright (C) 2009-2010 Daniel De Graaf <danieldg@inspircd.org> * Copyright (C) 2008 Thomas Stagner <aquanight@gmail.com> * Copyright (C) 2007-2009 Robin Burchell <robin+git@viroteck.net> * Copyright (C) 2007 Oliver Lupton <om@inspircd.org> * Copyright (C) 2006-2007 Dennis Friis <peavey@inspircd.org> * Copyright (C) 2006 John Brooks <john@jbrooks.io> * Copyright (C) 2003-2008 Craig Edwards <brain@inspircd.org> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #pragma once class DLLManager; /** Used to specify the behaviour of a module. */ enum ModuleFlags { /** The module has no special attributes. */ VF_NONE = 0, /** The module is a coremod and can be assumed to be loaded on all servers. */ VF_CORE = 1, /* The module is included with InspIRCd. */ VF_VENDOR = 2, /** The module MUST be loaded on all servers on a network to link. */ VF_COMMON = 4, /** The module SHOULD be loaded on all servers on a network for consistency. */ VF_OPTCOMMON = 8 }; /** The event was explicitly allowed. */ #define MOD_RES_ALLOW (ModResult(1)) /** The event was not explicitly allowed or denied. */ #define MOD_RES_PASSTHRU (ModResult(0)) /** The event was explicitly denied. */ #define MOD_RES_DENY (ModResult(-1)) /** Represents the result of a module event. */ class ModResult final { private: /** The underlying result value. */ char result = 0; public: /** Creates a new instance of the ModResult class which defaults to MOD_RES_PASSTHRU. */ ModResult() = default; /** Creates a new instance of the ModResult class with the specified value. */ explicit ModResult(char res) : result(res) { } /** Determines whether this ModResult has.the same value as \p res */ inline bool operator==(const ModResult& res) const { return result == res.result; } /** Determines whether this ModResult has.a different value to \p res */ inline bool operator!=(const ModResult& res) const { return result != res.result; } /** Determines whether a non-MOD_RES_PASSTHRU result has been set. */ inline bool operator!() const { return !result; } /** Checks whether the result is an MOD_RES_ALLOW or MOD_RES_PASSTHRU when the default is to allow. */ inline bool check(bool def) const { return (result == 1 || (result == 0 && def)); } /* Merges two results preferring MOD_RES_ALLOW to MOD_RES_DENY. */ inline ModResult operator+(const ModResult& res) const { // If the results are identical or the other result is MOD_RES_PASSTHRU // then return this result. if (result == res.result || res.result == 0) return *this; // If this result is MOD_RES_PASSTHRU then return the other result. if (result == 0) return res; // Otherwise, they are different, and neither is MOD_RES_PASSTHRU. return MOD_RES_ALLOW; } }; /** Priority types which can be used by Module::Prioritize() */ enum Priority { PRIORITY_FIRST, PRIORITY_LAST, PRIORITY_BEFORE, PRIORITY_AFTER }; /** Implementation-specific flags which may be set in Module::Implements() */ enum Implementation { I_OnAcceptConnection, I_OnAddLine, I_OnBackgroundTimer, I_OnBuildNeighborList, I_OnChangeConnectClass, I_OnChangeHost, I_OnChangeRealHost, I_OnChangeRealName, I_OnChangeRealUser, I_OnChangeRemoteAddress, I_OnChangeUser, I_OnChannelDelete, I_OnChannelPreDelete, I_OnCheckBan, I_OnCheckChannelBan, I_OnCheckInvite, I_OnCheckKey, I_OnCheckLimit, I_OnCheckPassword, I_OnCheckReady, I_OnCommandBlocked, I_OnDecodeMetadata, I_OnDelLine, I_OnExpireLine, I_OnGarbageCollect, I_OnKill, I_OnLoadModule, I_OnMode, I_OnModuleRehash, I_OnNumeric, I_OnOperLogin, I_OnOperLogout, I_OnPostChangeConnectClass, I_OnPostChangeRealHost, I_OnPostChangeRealUser, I_OnPostCommand, I_OnPostConnect, I_OnPostJoin, I_OnPostOperLogin, I_OnPostOperLogout, I_OnPostTopicChange, I_OnPreChangeConnectClass, I_OnPreCommand, I_OnPreMode, I_OnPreOperLogin, I_OnPreRehash, I_OnPreTopicChange, I_OnRawMode, I_OnSendSnotice, I_OnServiceAdd, I_OnServiceDel, I_OnShutdown, I_OnUnloadModule, I_OnUserConnect, I_OnUserDisconnect, I_OnUserInit, I_OnUserInvite, I_OnUserJoin, I_OnUserKick, I_OnUserMessage, I_OnUserMessageBlocked, I_OnUserPart, I_OnUserPostInit, I_OnUserPostMessage, I_OnUserPostNick, I_OnUserPreInvite, I_OnUserPreJoin, I_OnUserPreKick, I_OnUserPreMessage, I_OnUserPreNick, I_OnUserPreQuit, I_OnUserQuit, I_OnUserRegister, I_OnUserWrite, I_END }; /** Base class for all InspIRCd modules * This class is the base class for InspIRCd modules. All modules must inherit from this class, * its methods will be called when irc server events occur. class inherited from module must be * instantiated by the ModuleFactory class (see relevant section) for the module to be initialised. */ class CoreExport Module : public Cullable , public usecountbase { protected: /** Initializes a new instance of the Module class. * @param mprops The properties of this module. * @param mdesc A description of this module. */ Module(int mprops, const std::string& mdesc); /** Initializes a new instance of the Module class. * @param mprops The properties of this module. * @param mversion The version of this module (for contrib modules). * @param mdesc A description of this module. */ Module(int mprops, const std::string& mversion, const std::string& mdesc); /** Detach an event from this module * @param i Event type to detach */ void DetachEvent(Implementation i); public: /** Data which is synchronised between servers on link. */ typedef std::map<std::string, std::string, irc::insensitive_swo> LinkData; /** Data which is synchronised between servers on link. */ typedef std::map<std::string, std::pair<std::optional<std::string>, std::optional<std::string>>, irc::insensitive_swo> LinkDataDiff; /** A list of modules. */ typedef std::vector<Module*> List; /** Reference to the dynamic library. */ DLLManager* ModuleDLL = nullptr; /** File that this module was loaded from. */ std::string ModuleFile; /** If true, this module will be unloaded soon, further unload attempts will fail * Value is used by the ModuleManager internally, you should not modify it */ bool dying = false; /** A description of this module. */ const std::string description; /** The properties of this module. */ const int properties; /** The version of this module. */ const std::string version; /** Module setup * \exception ModuleException Throwing this class, or any class derived from ModuleException, causes loading of the module to abort. */ virtual void init() { } /** Clean up prior to destruction * If you override, you must call this AFTER your module's cleanup */ Cullable::Result Cull() override; /** Compares our link data to that of another server. * @param otherdata Link data from another server. * @param diffs The difference between the two sets of link data. */ virtual void CompareLinkData(const LinkData& otherdata, LinkDataDiff& diffs); /** Retrieves link compatibility data for this module. * @param data The location to store link compatibility data. * @param compatdata The location to store link compatibility data for older protocols. */ virtual void GetLinkData(LinkData& data, std::string& compatdata); /** Retrieves a string that represents the properties of this module. */ std::string GetPropertyString() const; /** Retrieves the version of the module. */ std::string GetVersion() const; /** This method is called when you should reload module specific configuration: * on boot, on a /REHASH and on module load. * @param status The current status, can be inspected for more information. */ virtual void ReadConfig(ConfigStatus& status); /** Called when the hooks provided by a module need to be prioritised. */ virtual void Prioritize(); /** Called when a user connects. * The details of the connecting user are available to you in the parameter User* user * @param user The user who is connecting */ virtual void OnUserConnect(LocalUser* user) ATTR_NOT_NULL(2); /** Called when before a user quits. * The details of the exiting user are available to you in the parameter User* user * This event is only called when the user is fully connected when they quit. To catch * raw disconnections, use the OnUserDisconnect method. * @param user The user who is quitting * @param message The user's quit message (as seen by non-opers) * @param oper_message The user's quit message (as seen by opers) */ virtual ModResult OnUserPreQuit(LocalUser* user, std::string& message, std::string& oper_message) ATTR_NOT_NULL(2); /** Called when a user quits. * The details of the exiting user are available to you in the parameter User* user * This event is only called when the user is fully connected when they quit. To catch * raw disconnections, use the OnUserDisconnect method. * @param user The user who is quitting * @param message The user's quit message (as seen by non-opers) * @param oper_message The user's quit message (as seen by opers) */ virtual void OnUserQuit(User* user, const std::string& message, const std::string& oper_message) ATTR_NOT_NULL(2); /** Called whenever a user's socket is closed. * The details of the exiting user are available to you in the parameter User* user * This event is called for all users, registered or not, as a cleanup method for modules * which might assign resources to user, such as dns lookups, objects and sockets. * @param user The user who is disconnecting */ virtual void OnUserDisconnect(LocalUser* user) ATTR_NOT_NULL(2); /** Called whenever a channel is about to be deleted * @param chan The channel being deleted * @return An integer specifying whether or not the channel may be deleted. 0 for yes, 1 for no. */ virtual ModResult OnChannelPreDelete(Channel* chan) ATTR_NOT_NULL(2); /** Called whenever a channel is deleted, either by QUIT, KICK or PART. * @param chan The channel being deleted */ virtual void OnChannelDelete(Channel* chan) ATTR_NOT_NULL(2); /** Called when a user joins a channel. * The details of the joining user are available to you in the parameter User* user, * and the details of the channel they have joined is available in the variable Channel* channel * @param memb The channel membership being created * @param sync This is set to true if the JOIN is the result of a network sync and the remote user is being introduced * to a channel due to the network sync. * @param created This is true if the join created the channel * @param except_list A list of users not to send to. */ virtual void OnUserJoin(Membership* memb, bool sync, bool created, CUList& except_list) ATTR_NOT_NULL(2); /** Called after a user joins a channel * Identical to OnUserJoin, but called immediately afterwards, when any linking module has * seen the join. * @param memb The channel membership created */ virtual void OnPostJoin(Membership* memb) ATTR_NOT_NULL(2); /** Called when a user parts a channel. * The details of the leaving user are available to you in the parameter User* user, * and the details of the channel they have left is available in the variable Channel* channel * @param memb The channel membership being destroyed * @param partmessage The part message, or an empty string (may be modified) * @param except_list A list of users to not send to. */ virtual void OnUserPart(Membership* memb, std::string& partmessage, CUList& except_list) ATTR_NOT_NULL(2); /** Called on rehash. * This method is called prior to a /REHASH or when a SIGHUP is received from the operating * system. This is called in all cases -- including when this server will not execute the * rehash because it is directed at a remote server. * * @param user The user performing the rehash, if any. If this is server initiated, the value of * this variable will be NULL. * @param parameter The (optional) parameter given to REHASH from the user. Empty when server * initiated. */ virtual void OnPreRehash(User* user, const std::string& parameter); /** Called on rehash. * This method is called when a user initiates a module-specific rehash. This can be used to do * expensive operations (such as reloading TLS certificates) that are not executed on a normal * rehash for efficiency. A rehash of this type does not reload the core configuration. * * @param user The user performing the rehash. * @param parameter The parameter given to REHASH */ virtual void OnModuleRehash(User* user, const std::string& parameter); /** Called whenever a snotice is about to be sent to a snomask. * snomask and type may both be modified; the message may not. * @param snomask The snomask the message is going to (e.g. 'A') * @param type The textual description the snomask will go to (e.g. 'OPER') * @param message The text message to be sent via snotice * @return 1 to block the snotice from being sent entirely, 0 else. */ virtual ModResult OnSendSnotice(char& snomask, std::string& type, const std::string& message); /** Called whenever a user is about to join a channel, before any processing is done. * Returning a value of 1 from this function stops the process immediately, causing no * output to be sent to the user by the core. If you do this you must produce your own numerics, * notices etc. This is useful for modules which may want to mimic +b, +k, +l etc. Returning -1 from * this function forces the join to be allowed, bypassing restrictions such as banlists, invite, keys etc. * * IMPORTANT NOTE! * * If the user joins a NEW channel which does not exist yet, OnUserPreJoin will be called BEFORE the channel * record is created. This will cause Channel* chan to be NULL. There is very little you can do in form of * processing on the actual channel record at this point, however the channel NAME will still be passed in * char* cname, so that you could for example implement a channel blacklist or whitelist, etc. * @param user The user joining the channel * @param chan If the channel is a new channel, this will be NULL, otherwise it will be a pointer to the channel being joined * @param cname The channel name being joined. For new channels this is valid where chan is not. * @param privs A string containing the users privileges when joining the channel. For new channels this will contain "o". * You may alter this string to alter the user's modes on the channel. * @param keygiven The key given to join the channel, or an empty string if none was provided * @param override Whether the channel join can be blocked by returning MOD_RES_DENY. * @return 1 To prevent the join, 0 to allow it. */ virtual ModResult OnUserPreJoin(LocalUser* user, Channel* chan, const std::string& cname, std::string& privs, const std::string& keygiven, bool override) ATTR_NOT_NULL(2); /** Called whenever a user is about to be kicked. * Returning a value of 1 from this function stops the process immediately, causing no * output to be sent to the user by the core. If you do this you must produce your own numerics, * notices etc. * @param source The user issuing the kick * @param memb The channel membership of the user who is being kicked. * @param reason The kick reason * @return 1 to prevent the kick, 0 to continue normally, -1 to explicitly allow the kick regardless of normal operation */ virtual ModResult OnUserPreKick(User* source, Membership* memb, const std::string& reason) ATTR_NOT_NULL(2, 3); /** Called whenever a user is kicked. * If this method is called, the kick is already underway and cannot be prevented, so * to prevent a kick, please use Module::OnUserPreKick instead of this method. * @param source The user issuing the kick * @param memb The channel membership of the user who was kicked. * @param reason The kick reason * @param except_list A list of users to not send to. */ virtual void OnUserKick(User* source, Membership* memb, const std::string& reason, CUList& except_list) ATTR_NOT_NULL(2, 3); /** Called whenever a user is about to invite another user into a channel, before any processing is done. * Returning 1 from this function stops the process immediately, causing no * output to be sent to the user by the core. If you do this you must produce your own numerics, * notices etc. This is useful for modules which may want to filter invites to channels. * @param source The user who is issuing the INVITE * @param dest The user being invited * @param channel The channel the user is being invited to * @param timeout The time the invite will expire (0 == never) * @return 1 to deny the invite, 0 to check whether or not the user has permission to invite, -1 to explicitly allow the invite */ virtual ModResult OnUserPreInvite(User* source, User* dest, Channel* channel, time_t timeout) ATTR_NOT_NULL(2, 3, 4); /** Called after a user has been successfully invited to a channel. * You cannot prevent the invite from occurring using this function, to do that, * use OnUserPreInvite instead. * @param source The user who is issuing the INVITE * @param dest The user being invited * @param channel The channel the user is being invited to * @param timeout The time the invite will expire (0 == never) * @param notifyrank Rank required to get an invite announcement (if enabled) * @param notifyexcepts List of users to not send the default NOTICE invite announcement to */ virtual void OnUserInvite(User* source, User* dest, Channel* channel, time_t timeout, ModeHandler::Rank notifyrank, CUList& notifyexcepts) ATTR_NOT_NULL(2, 3, 4); /** Called before a user sends a message to a channel, a user, or a server glob mask. * @param user The user sending the message. * @param target The target of the message. This can either be a channel, a user, or a server * glob mask. * @param details Details about the message such as the message text and type. See the * MessageDetails class for more information. * @return MOD_RES_ALLOW to explicitly allow the message, MOD_RES_DENY to explicitly deny the * message, or MOD_RES_PASSTHRU to let another module handle the event. */ virtual ModResult OnUserPreMessage(User* user, MessageTarget& target, MessageDetails& details) ATTR_NOT_NULL(2); /** Called when sending a message to all "neighbors" of a given user - * that is, all users that share a common channel. This is used in * commands such as NICK, QUIT, etc. * @param source The source of the message * @param include Memberships to scan for users to include * @param exceptions Map of user->bool that overrides the inclusion decision * * Set exceptions[user] = true to include, exceptions[user] = false to exclude */ virtual void OnBuildNeighborList(User* source, User::NeighborList& include, User::NeighborExceptions& exceptions) ATTR_NOT_NULL(2); /** Called before local nickname changes. This can be used to implement Q-lines etc. * If your method returns nonzero, the nickchange is silently forbidden, and it is down to your * module to generate some meaningful output. * @param user The username changing their nick * @param newnick Their new nickname * @return 1 to deny the change, 0 to allow */ virtual ModResult OnUserPreNick(LocalUser* user, const std::string& newnick) ATTR_NOT_NULL(2); /** Called immediately after a user sends a message to a channel, a user, or a server glob mask. * @param user The user sending the message. * @param target The target of the message. This can either be a channel, a user, or a server * glob mask. * @param details Details about the message such as the message text and type. See the * MessageDetails class for more information. */ virtual void OnUserPostMessage(User* user, const MessageTarget& target, const MessageDetails& details) ATTR_NOT_NULL(2); /** Called immediately before a user sends a message to a channel, a user, or a server glob mask. * @param user The user sending the message. * @param target The target of the message. This can either be a channel, a user, or a server * glob mask. * @param details Details about the message such as the message text and type. See the * MessageDetails class for more information. */ virtual void OnUserMessage(User* user, const MessageTarget& target, const MessageDetails& details) ATTR_NOT_NULL(2); /** Called when a message sent by a user to a channel, a user, or a server glob mask is blocked. * @param user The user sending the message. * @param target The target of the message. This can either be a channel, a user, or a server * glob mask. * @param details Details about the message such as the message text and type. See the * MessageDetails class for more information. */ virtual void OnUserMessageBlocked(User* user, const MessageTarget& target, const MessageDetails& details) ATTR_NOT_NULL(2); /** Called after every MODE command sent from a user * Either the usertarget or the chantarget variable contains the target of the modes, * the actual target will have a non-NULL pointer. * All changed modes are available in the changelist object. * @param user The user sending the MODEs * @param usertarget The target user of the modes, NULL if the target is a channel * @param chantarget The target channel of the modes, NULL if the target is a user * @param changelist The changed modes. * @param processflags Flags passed to ModeParser::Process(), see ModeParser::ModeProcessFlags * for the possible flags. */ virtual void OnMode(User* user, User* usertarget, Channel* chantarget, const Modes::ChangeList& changelist, ModeParser::ModeProcessFlag processflags) ATTR_NOT_NULL(2); /** Allows module data, sent via SendMetadata, to be decoded again by a receiving module. * Please see src/modules/m_swhois.cpp for a working example of how to use this method call. * @param target The Channel* or User* that data should be added to * @param extname The extension name which is being sent * @param extdata The extension data, encoded at the other end by an identical module */ virtual void OnDecodeMetadata(Extensible* target, const std::string& extname, const std::string& extdata); /** Called whenever a user's hostname is changed. * This event triggers after the host has been set. * @param user The user whose host is being changed * @param newhost The new hostname being set */ virtual void OnChangeHost(User* user, const std::string& newhost) ATTR_NOT_NULL(2); /** Called whenever a user's real hostname is changed. * This event triggers before the host has been set. * @param user The user whose host is being changed * @param newhost The new hostname being set */ virtual void OnChangeRealHost(User* user, const std::string& newhost) ATTR_NOT_NULL(2); /** Called whenever a user's real hostname is changed. * This event triggers after the host has been set. * @param user The user whos host was changed. */ virtual void OnPostChangeRealHost(User* user) ATTR_NOT_NULL(2); /** Called whenever a user's real name is changed. * This event triggers after the name has been set. * @param user The user who's real name is being changed * @param real The new real name being set on the user */ virtual void OnChangeRealName(User* user, const std::string& real) ATTR_NOT_NULL(2); /** Called before a user's username is changed. * @param user The user who's username is being changed * @param newuser The new username being set. */ virtual void OnChangeUser(User* user, const std::string& newuser) ATTR_NOT_NULL(2); /** Called before a user's real username is changed. * @param user The user who's real username is being changed * @param newuser The new real username being set. */ virtual void OnChangeRealUser(User* user, const std::string& newuser) ATTR_NOT_NULL(2); /** Called after a user's real username is changed. * @param user The user whos real username was changed. */ virtual void OnPostChangeRealUser(User* user) ATTR_NOT_NULL(2); /** Called whenever an xline is added by a local user. * This method is triggered after the line is added. * @param source The sender of the line or NULL for local server * @param line The xline being added */ virtual void OnAddLine(User* source, XLine* line) ATTR_NOT_NULL(3); /** Called whenever an xline is deleted MANUALLY. See OnExpireLine for expiry. * This method is triggered after the line is deleted. * @param source The user removing the line or NULL for local server * @param line the line being deleted */ virtual void OnDelLine(User* source, XLine* line) ATTR_NOT_NULL(3); /** Called whenever an xline expires. * This method is triggered after the line is deleted. * @param line The line being deleted. */ virtual void OnExpireLine(XLine* line) ATTR_NOT_NULL(2); /** Called before the module is unloaded to clean up extension. * This method is called once for every channel, membership, and user. * so that you can clear up any data relating to the specified extensible. * @param type The type of extensible being cleaned up. * @param item A pointer to the extensible which is being cleaned up. */ virtual void OnCleanup(ExtensionType type, Extensible* item) ATTR_NOT_NULL(3); /** Called after any nickchange, local or remote. This can be used to track users after nickchanges * have been applied. Please note that although you can see remote nickchanges through this function, you should * NOT make any changes to the User if the user is a remote user as this may cause a desync. * check user->server before taking any action (including returning nonzero from the method). * Because this method is called after the nickchange is taken place, no return values are possible * to indicate forbidding of the nick change. Use OnUserPreNick for this. * @param user The user changing their nick * @param oldnick The old nickname of the user before the nickchange */ virtual void OnUserPostNick(User* user, const std::string& oldnick) ATTR_NOT_NULL(2); /** Called before a mode change via the MODE command, to allow a single access check for * a full mode change (use OnRawMode to check individual modes) * * Returning MOD_RES_ALLOW will skip prefix level checks, but can be overridden by * OnRawMode for each individual mode * * @param source the user making the mode change * @param dest the user destination of the umode change (NULL if a channel mode) * @param channel the channel destination of the mode change * @param modes Modes being changed, can be edited */ virtual ModResult OnPreMode(User* source, User* dest, Channel* channel, Modes::ChangeList& modes) ATTR_NOT_NULL(2); /** Called when a client is disconnected by KILL. * If a client is killed by a server, e.g. a nickname collision or protocol error, * source is NULL. * Return 1 from this function to prevent the kill, and 0 from this function to allow * it as normal. If you prevent the kill no output will be sent to the client, it is * down to your module to generate this information. * NOTE: It is NOT advisable to stop kills which originate from servers or remote users. * If you do so youre risking race conditions, desyncs and worse! * @param source The user sending the KILL * @param dest The user being killed * @param reason The kill reason * @return 1 to prevent the kill, 0 to allow */ virtual ModResult OnKill(User* source, User* dest, const std::string& reason) ATTR_NOT_NULL(2, 3); /** Called whenever a module is loaded. * mod will contain a pointer to the module, and string will contain its name, * for example m_widgets.so. This function is primary for dependency checking, * your module may decide to enable some extra features if it sees that you have * for example loaded "m_killwidgets.so" with "m_makewidgets.so". It is highly * recommended that modules do *NOT* bail if they cannot satisfy dependencies, * but instead operate under reduced functionality, unless the dependency is * absolutely necessary (e.g. a module that extends the features of another * module). * @param mod A pointer to the new module */ virtual void OnLoadModule(Module* mod) ATTR_NOT_NULL(2); /** Called whenever a module is unloaded. * mod will contain a pointer to the module, and string will contain its name, * for example m_widgets.so. This function is primary for dependency checking, * your module may decide to enable some extra features if it sees that you have * for example loaded "m_killwidgets.so" with "m_makewidgets.so". It is highly * recommended that modules do *NOT* bail if they cannot satisfy dependencies, * but instead operate under reduced functionality, unless the dependency is * absolutely necessary (e.g. a module that extends the features of another * module). * @param mod Pointer to the module being unloaded (still valid) */ virtual void OnUnloadModule(Module* mod) ATTR_NOT_NULL(2); /** Called once every five seconds for background processing. * This timer can be used to control timed features. Its period is not accurate * enough to be used as a clock, but it is guaranteed to be called at least once in * any five second period, directly from the main loop of the server. * @param curtime The current timer derived from time(2) */ virtual void OnBackgroundTimer(time_t curtime); /** Called whenever any command is about to be executed. * This event occurs for all registered commands, whether they are registered in the core, * or another module, and for invalid commands. Invalid commands may only be sent to this * function when the value of validated is false. By returning 1 from this method you may prevent the * command being executed. If you do this, no output is created by the core, and it is * down to your module to produce any output necessary. * Note that unless you return 1, you should not destroy any structures (e.g. by using * InspIRCd::QuitUser) otherwise when the command's handler function executes after your * method returns, it will be passed an invalid pointer to the user object and crash!) * @param command The command being executed * @param parameters An array of array of characters containing the parameters for the command * @param user the user issuing the command * @param validated True if the command has passed all checks, e.g. it is recognised, has enough parameters, the user has permission to execute it, etc. * You should only change the parameter list and command string if validated == false (e.g. before the command lookup occurs). * @return 1 to block the command, 0 to allow */ virtual ModResult OnPreCommand(std::string& command, CommandBase::Params& parameters, LocalUser* user, bool validated) ATTR_NOT_NULL(4); /** Called after any command has been executed. * This event occurs for all registered commands, whether they are registered in the core, * or another module, but it will not occur for invalid commands (e.g. ones which do not * exist within the command table). The result code returned by the command handler is * provided. * @param command The command being executed * @param parameters An array of array of characters containing the parameters for the command * @param user the user issuing the command * @param result The return code given by the command handler, one of CmdResult::SUCCESS or CmdResult::FAILURE * @param loop Whether the command is being called from LoopCall or directly. */ virtual void OnPostCommand(Command* command, const CommandBase::Params& parameters, LocalUser* user, CmdResult result, bool loop) ATTR_NOT_NULL(2, 4); /** Called when a command was blocked before it could be executed. * @param command The command being executed. * @param parameters The parameters for the command. * @param user The user issuing the command. */ virtual void OnCommandBlocked(const std::string& command, const CommandBase::Params& parameters, LocalUser* user) ATTR_NOT_NULL(4); /** Called after a user object is initialised and added to the user list. * When this is called the user has not had their I/O hooks checked or had their initial * connect class assigned and may not yet have a serializer. You probably want to use * the OnUserPostInit or OnUserSetIP hooks instead of this one. * @param user The connecting user. */ virtual void OnUserInit(LocalUser* user) ATTR_NOT_NULL(2); /** Called after a user object has had their I/O hooks checked, their initial connection * class assigned, and had a serializer set. * @param user The connecting user. */ virtual void OnUserPostInit(LocalUser* user) ATTR_NOT_NULL(2); /** Called to check if a user who is connecting can now be allowed to register * If any modules return false for this function, the user is held in the waiting * state until all modules return true. For example a module which implements ident * lookups will continue to return false for a user until their ident lookup is completed. * Note that the connection timeout for a user overrides these checks, if the connection * timeout is reached, the user is disconnected even if modules report that the user is * not ready to connect. * @param user The user to check * @return true to indicate readiness, false if otherwise */ virtual ModResult OnCheckReady(LocalUser* user) ATTR_NOT_NULL(2); /** Called whenever a user is about to register their connection (e.g. before the user * is sent the MOTD etc). Modules can use this method if they are performing a function * which must be done before the actual connection is completed (e.g. ident lookups, * dnsbl lookups, etc). * Note that you should NOT delete the user record here by causing a disconnection! * Use OnUserConnect for that instead. * @param user The user registering * @return 1 to indicate user quit, 0 to continue */ virtual ModResult OnUserRegister(LocalUser* user) ATTR_NOT_NULL(2); /** Called whenever a user joins a channel, to determine if invite checks should go ahead or not. * This method will always be called for each join, whether or not the channel is actually +i, and * determines the outcome of an if statement around the whole section of invite checking code. * return 1 to explicitly allow the join to go ahead or 0 to ignore the event. * @param user The user joining the channel * @param chan The channel being joined * @return 1 to explicitly allow the join, 0 to proceed as normal */ virtual ModResult OnCheckInvite(User* user, Channel* chan) ATTR_NOT_NULL(2, 3); /** Called whenever a mode character is processed. * Return 1 from this function to block the mode character from being processed entirely. * @param user The user who is sending the mode * @param chan The channel the mode is being sent to (or NULL if a usermode) * @param change Information regarding the mode change. * @return MOD_RES_DENY to deny the mode, MOD_RES_DEFAULT to do standard mode checking, and MOD_RES_ALLOW * to skip all permission checking. Please note that for remote mode changes, your return value * will be ignored! */ virtual ModResult OnRawMode(User* user, Channel* chan, const Modes::Change& change) ATTR_NOT_NULL(2); /** Called whenever a user joins a channel, to determine if key checks should go ahead or not. * This method will always be called for each join, whether or not the channel is actually +k, and * determines the outcome of an if statement around the whole section of key checking code. * if the user specified no key, the keygiven string will be a valid but empty value. * return 1 to explicitly allow the join to go ahead or 0 to ignore the event. * @param user The user joining the channel * @param chan The channel being joined * @param keygiven The key given on joining the channel. * @return 1 to explicitly allow the join, 0 to proceed as normal */ virtual ModResult OnCheckKey(User* user, Channel* chan, const std::string& keygiven) ATTR_NOT_NULL(2, 3); /** Called whenever a user joins a channel, to determine if channel limit checks should go ahead or not. * This method will always be called for each join, whether or not the channel is actually +l, and * determines the outcome of an if statement around the whole section of channel limit checking code. * return 1 to explicitly allow the join to go ahead or 0 to ignore the event. * @param user The user joining the channel * @param chan The channel being joined * @return 1 to explicitly allow the join, 0 to proceed as normal */ virtual ModResult OnCheckLimit(User* user, Channel* chan) ATTR_NOT_NULL(2, 3); /** * Checks for a user's ban from the channel * @param user The user to check * @param chan The channel to check in * @return MOD_RES_DENY to mark as banned, MOD_RES_ALLOW to skip the * ban check, or MOD_RES_PASSTHRU to check bans normally */ virtual ModResult OnCheckChannelBan(User* user, Channel* chan) ATTR_NOT_NULL(2, 3); /** * Checks for a user's match of a single ban * @param user The user to check for match * @param chan The channel on which the match is being checked * @param mask The mask being checked * @return MOD_RES_DENY to mark as banned, MOD_RES_ALLOW to skip the * ban check, or MOD_RES_PASSTHRU to check bans normally */ virtual ModResult OnCheckBan(User* user, Channel* chan, const std::string& mask) ATTR_NOT_NULL(2, 3); /** Called when checking if a password is valid. * @param password The hashed password. * @param passwordhash The name of the algorithm used to hash the password. * @param value The value to check to see if the password is valid. * @return MOD_RES_ALLOW if the password is correct, MOD_RES_DENY if the password is incorrect, * or MOD_RES_PASSTHRU to let another module handle the event. */ virtual ModResult OnCheckPassword(const std::string& password, const std::string& passwordhash, const std::string& value); /** Called before a topic is changed. * Return 1 to deny the topic change, 0 to check details on the change, -1 to let it through with no checks * As with other 'pre' events, you should only ever block a local event. * @param user The user changing the topic * @param chan The channels who's topic is being changed * @param topic The actual topic text * @return 1 to block the topic change, 0 to allow */ virtual ModResult OnPreTopicChange(User* user, Channel* chan, const std::string& topic) ATTR_NOT_NULL(2, 3); /** Called whenever a topic has been changed. * To block topic changes you must use OnPreTopicChange instead. * @param user The user changing the topic * @param chan The channels who's topic is being changed * @param topic The actual topic text */ virtual void OnPostTopicChange(User* user, Channel* chan, const std::string& topic) ATTR_NOT_NULL(2, 3); /** Called after a user has fully connected and all modules have executed OnUserConnect * This event is informational only. You should not change any user information in this * event. To do so, use the OnUserConnect method to change the state of local users. * This is called for both local and remote users. * @param user The user who is connecting */ virtual void OnPostConnect(User* user) ATTR_NOT_NULL(2); /** Called when a port accepts a connection * Return MOD_RES_ACCEPT if you have used the file descriptor. * @param fd The file descriptor returned from accept() * @param sock The socket connection for the new user * @param client The client IP address and port * @param server The server IP address and port */ virtual ModResult OnAcceptConnection(int fd, ListenSocket* sock, const irc::sockets::sockaddrs& client, const irc::sockets::sockaddrs& server) ATTR_NOT_NULL(3); /** Called at intervals for modules to garbage-collect any hashes etc. * Certain data types such as hash_map 'leak' buckets, which must be * tidied up and freed by copying into a new item every so often. This * method is called when it is time to do that. */ virtual void OnGarbageCollect(); virtual ModResult OnNumeric(User* user, const Numeric::Numeric& numeric) ATTR_NOT_NULL(2); /** Called whenever a local user's remote address is set or changed. * @param user The user whose remote address is being set or changed. */ virtual void OnChangeRemoteAddress(LocalUser* user) ATTR_NOT_NULL(2); /** Called whenever a ServiceProvider is registered. * @param service ServiceProvider being registered. */ virtual void OnServiceAdd(ServiceProvider& service); /** Called whenever a ServiceProvider is unregistered. * @param service ServiceProvider being unregistered. */ virtual void OnServiceDel(ServiceProvider& service); /** Called whenever a message is about to be written to a user. * @param user The user who is having a message sent to them. * @param msg The message which is being written to the user. * @return MOD_RES_ALLOW to explicitly allow the message to be sent, MOD_RES_DENY to explicitly * deny the message from being sent, or MOD_RES_PASSTHRU to let another module handle the event. */ virtual ModResult OnUserWrite(LocalUser* user, ClientProtocol::Message& msg) ATTR_NOT_NULL(2); /** Called before a server shuts down. * @param reason The reason the server is shutting down. */ virtual void OnShutdown(const std::string& reason); /** Called when a local user is attempting to log in to an server operator account. * @param user The user who is attempting to log in. * @param oper The server operator account they are attempting to log in to. * @param automatic Whether the login attempt is being performed automatically. * @return MOD_RES_ALLOW to explicitly allow the login, MOD_RES_DENY to explicitly deny the * login, or MOD_RES_PASSTHRU to let another module handle the event. */ virtual ModResult OnPreOperLogin(LocalUser* user, const std::shared_ptr<OperAccount>& oper, bool automatic) ATTR_NOT_NULL(2); /** Called when a user is about to be logged in to an server operator account. * @param user The user who is about to be logged in. * @param oper The server operator account they are logging in to. * @param automatic Whether the login was performed automatically. */ virtual void OnOperLogin(User* user, const std::shared_ptr<OperAccount>& oper, bool automatic) ATTR_NOT_NULL(2); /** Called after a user has been logged in to an server operator account. * @param user The user who has been logged in. * @param automatic Whether the login was performed automatically. */ virtual void OnPostOperLogin(User* user, bool automatic) ATTR_NOT_NULL(2); /** Called when a user is about to be logged out of an server operator account. * @param user The user who is about to be logged out. */ virtual void OnOperLogout(User* user) ATTR_NOT_NULL(2); /** Called after a user has been logged out of an server operator account. * @param user The user who has been logged out. * @param oper The server operator account they were logged out of. */ virtual void OnPostOperLogout(User* user, const std::shared_ptr<OperAccount>& oper) ATTR_NOT_NULL(2); /** Called when trying to find a connect class for a user. * @param user The user that needs a new connect class. * @param klass The connect class to check the suitability of. * @param errnum If returning MOD_RES_DENY then the error numeric to send to the user. * @return MOD_RES_ALLOW to select this connect class, MOD_RES_DENY to reject this connect * class, or MOD_RES_PASSTHRU to let another module handle the event. */ virtual ModResult OnPreChangeConnectClass(LocalUser* user, const std::shared_ptr<ConnectClass>& klass, std::optional<Numeric::Numeric>& errnum) ATTR_NOT_NULL(2); /** Called when a user is about to be assigned to a connect class. * @param user The user that is being assigned to a connect class. * @param klass The connect class the user is being assigned to. * @param force Whether the connect class was explicitly picked (e.g. via <oper:class>). */ virtual void OnChangeConnectClass(LocalUser* user, const std::shared_ptr<ConnectClass>& klass, bool force) ATTR_NOT_NULL(2); /** Called when a user has bee assigned to a connect class. * @param user The user that was assigned to a connect class. * @param force Whether the connect class was explicitly picked (e.g. via <oper:class>). */ virtual void OnPostChangeConnectClass(LocalUser* user, bool force) ATTR_NOT_NULL(2); }; /** ModuleManager takes care of all things module-related * in the core. */ class CoreExport ModuleManager final { public: typedef std::multimap<std::string, ServiceProvider*, irc::insensitive_swo> DataProviderMap; typedef std::vector<ServiceProvider*> ServiceList; private: /** Holds a string describing the last module error to occur */ std::string LastModuleError; /** List of loaded modules and shared object/dll handles * keyed by module name */ std::map<std::string, Module*> Modules; enum { PRIO_STATE_FIRST, PRIO_STATE_AGAIN, PRIO_STATE_LAST } prioritizationState; /** Loads all core modules (core_*) */ void LoadCoreModules(std::map<std::string, ServiceList>& servicemap); /** Calls the Prioritize() method in all loaded modules * @return True if all went well, false if a dependency loop was detected */ bool PrioritizeHooks(); /** Unregister all user modes or all channel modes owned by a module * @param mod Module whose modes to unregister * @param modetype MODETYPE_USER to unregister user modes, MODETYPE_CHANNEL to unregister channel modes */ void UnregisterModes(Module* mod, ModeType modetype); public: typedef std::map<std::string, Module*> ModuleMap; /** Event handler hooks. * This needs to be public to be used by FOREACH_MOD and friends. */ Module::List EventHandlers[I_END]; /** List of data services keyed by name */ DataProviderMap DataProviders; /** A list of ServiceProviders waiting to be registered. * Non-NULL when constructing a Module, NULL otherwise. * When non-NULL ServiceProviders add themselves to this list on creation and the core * automatically registers them (that is, call AddService()) after the Module is constructed, * and before Module::init() is called. * If a service is created after the construction of the Module (for example in init()) it * has to be registered manually. */ ServiceList* NewServices; /** Expands the name of a module by prepending "m_" and appending ".so". * No-op if the name is already expanded. * @param modname Module name to expand * @return Module name starting with "m_" and ending with ".so" */ static std::string ExpandModName(const std::string& modname); /** Shrinks the name of a module by removing the "m_" prefix and ".so" suffix. * No-op if the name is already shrunk. * @param modname Module name to expand * @return Module name with the "m_" prefix and ".so" suffix removed. */ static std::string ShrinkModName(const std::string& modname); /** Change the priority of one event in a module. * Each module event has a list of modules which are attached to that event type. * If you wish to be called before or after other specific modules, you may use this * method (usually within void Module::Prioritize()) to set your events priority. * You may use this call in other methods too, however, this is not supported behaviour * for a module. * @param mod The module to change the priority of * @param i The event to change the priority of * @param s The state you wish to use for this event. Use one of * PRIO_FIRST to set the event to be first called, PRIO_LAST to * set it to be the last called, or PRIO_BEFORE and PRIORITY_AFTER * to set it to be before or after one or more other modules. * @param which If PRIO_BEFORE or PRIORITY_AFTER is set in parameter 's', * then this contains a the module that your module must be placed before * or after. */ bool SetPriority(Module* mod, Implementation i, Priority s, Module* which = nullptr); /** Change the priority of all events in a module. * @param mod The module to set the priority of * @param s The priority of all events in the module. * Note that with this method, it is not possible to effectively use * PRIO_BEFORE or PRIORITY_AFTER, you should use the more fine tuned * SetPriority method for this, where you may specify other modules to * be prioritized against. */ void SetPriority(Module* mod, Priority s); /** Attach an event to a module. * You may later detach the event with ModuleManager::Detach(). * If your module is unloaded, all events are automatically detached. * @param i Event type to attach * @param mod Module to attach event to * @return True if the event was attached */ bool Attach(Implementation i, Module* mod); /** Attach an array of events to a module * @param i Event types (array) to attach * @param mod Module to attach events to * @param sz The size of the implementation array */ void Attach(const Implementation* i, Module* mod, size_t sz); /** Attach all events to a module (used on module load) * @param mod Module to attach to all events */ void AttachAll(Module* mod); /** Detach an event from a module. * This is not required when your module unloads, as the core will * automatically detach your module from all events it is attached to. * @param i Event type to detach * @param mod Module to detach event from * @return True if the event was detached */ bool Detach(Implementation i, Module* mod); /** Detach an array of events from a module * This is not required when your module unloads, as the core will * automatically detach your module from all events it is attached to. * @param i Event types (array) to detach * @param mod Module to detach events from * @param sz The size of the implementation array */ void Detach(const Implementation* i, Module* mod, size_t sz); /** Detach all events from a module (used on unload) * @param mod Module to detach from */ void DetachAll(Module* mod); /** Returns text describing the last module error * @return The last error message to occur */ std::string& LastError(); /** Load a given module file * @param filename The file to load * @param defer Defer module init (loading many modules) * @return True if the module was found and loaded */ bool Load(const std::string& filename, bool defer = false); /** Unload a given module file. Note that the module will not be * completely gone until the cull list has finished processing. * * @return true on success; if false, LastError will give a reason */ bool Unload(Module* module); /** Called by the InspIRCd constructor to load all modules from the config file. */ void LoadAll(); void UnloadAll(); void DoSafeUnload(Module*); /** Check if a module can be unloaded and if yes, prepare it for unload * @param mod Module to be unloaded * @return True if the module is unloadable, false otherwise. * If true the module must be unloaded in the current main loop iteration. */ bool CanUnload(Module* mod); /** Find a module by name, and return a Module* to it. * This is preferred over iterating the module lists yourself. * @param name The module name to look up * @return A pointer to the module, or NULL if the module cannot be found */ Module* Find(const std::string& name); /** Register a service provided by a module */ void AddService(ServiceProvider&); /** Unregister a service provided by a module */ void DelService(ServiceProvider&); /** Register all services in a given ServiceList * @param list The list containing the services to register */ void AddServices(const ServiceList& list); inline void AddServices(ServiceProvider** list, int count) { for(int i=0; i < count; i++) AddService(*list[i]); } /** Find a service by name. * If multiple modules provide a given service, the first one loaded will be chosen. */ ServiceProvider* FindService(ServiceType Type, const std::string& name); template<typename T> inline T* FindDataService(const std::string& name) { return static_cast<T*>(FindService(SERVICE_DATA, name)); } /** Get a map of all loaded modules keyed by their name * @return A ModuleMap containing all loaded modules */ const ModuleMap& GetModules() const { return Modules; } /** Make a service referenceable by dynamic_references * @param name Name that will be used by dynamic_references to find the object * @param service Service to make referenceable by dynamic_references */ void AddReferent(const std::string& name, ServiceProvider* service); /** Make a service no longer referenceable by dynamic_references * @param service Service to make no longer referenceable by dynamic_references */ void DelReferent(ServiceProvider* service); }; /** @def FOREACH_MOD(EVENT, ARGS) * Run the given hook. */ #define FOREACH_MOD(EVENT, ARGS) \ do \ { \ const Module::List& _handlers = ServerInstance->Modules.EventHandlers[I_ ## EVENT]; \ for (Module::List::const_reverse_iterator _handler = _handlers.rbegin(); _handler != _handlers.rend(); ) \ { \ Module* _mod = *_handler++; \ try \ { \ if (!_mod->dying) \ _mod->EVENT ARGS; \ } \ catch (const CoreException& _exception_ ## EVENT) \ { \ ServerInstance->Logs.Debug("MODULE", "{} threw an exception in " # EVENT ": {}", _mod->ModuleFile, (_exception_ ## EVENT).GetReason()); \ } \ } \ } while (false) /** @def FIRST_MOD_RESULT(EVENT, RESULT, ARGS) * Run the given hook until some module returns MOD_RES_ALLOW or MOD_RES_DENY. If no module does * that the result is set to MOD_RES_PASSTHRU. */ #define FIRST_MOD_RESULT(EVENT, RESULT, ARGS) \ do \ { \ RESULT = MOD_RES_PASSTHRU; \ const Module::List& _handlers = ServerInstance->Modules.EventHandlers[I_ ## EVENT]; \ for (Module::List::const_reverse_iterator _handler = _handlers.rbegin(); _handler != _handlers.rend(); ) \ { \ Module* _mod = *_handler++; \ try \ { \ if (_mod->dying) \ continue; \ RESULT = _mod->EVENT ARGS; \ if (RESULT != MOD_RES_PASSTHRU) \ break; \ } \ catch (const CoreException& _exception_ ## EVENT) \ { \ ServerInstance->Logs.Debug("MODULE", "{} threw an exception in " # EVENT ": {}", _mod->ModuleFile, (_exception_ ## EVENT).GetReason()); \ } \ } \ } while (false) �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/include/modules/���������������������������������������������������������������������0000775�0000000�0000000�00000000000�14771603147�0016442�5����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/include/modules/account.h������������������������������������������������������������0000664�0000000�0000000�00000005776�14771603147�0020266�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2022-2023 Sadie Powell <sadie@witchery.services> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #pragma once #include "event.h" namespace Account { class API; class APIBase; class EventListener; /** Encapsulates a list of nicknames associated with an account. */ typedef insp::flat_set<std::string, irc::insensitive_swo> NickList; } /** Defines the interface for the account API. */ class Account::APIBase : public DataProvider { public: APIBase(Module* parent) : DataProvider(parent, "accountapi") { } /** Retrieves the account identifier of the specified user. * @param user The user to retrieve the account identifier of. * @return If the user is logged in to an account then the account identifier; otherwise, nullptr. */ virtual std::string* GetAccountId(const User* user) const = 0; /** Retrieves the account name of the specified user. * @param user The user to retrieve the account name of. * @return If the user is logged in to an account then the account name; otherwise, nullptr. */ virtual std::string* GetAccountName(const User* user) const = 0; /** Retrieves the account nicks of the specified user. * @param user The user to retrieve the account nicks of. * @return If the user is logged in to an account then the account nicks; otherwise, nullptr. */ virtual NickList* GetAccountNicks(const User* user) const = 0; /** Determines whether a user is identified to their nickname. * @param user The user to check the identification status of. * @return If the user is identified to their nickname then true; otherwise, false. */ virtual bool IsIdentifiedToNick(const User* user) = 0; }; /** Allows modules to access information regarding user accounts. */ class Account::API final : public dynamic_reference<Account::APIBase> { public: API(Module* parent) : dynamic_reference<Account::APIBase>(parent, "accountapi") { } }; /** Provides handlers for events relating to accounts. */ class Account::EventListener : public Events::ModuleEventListener { public: EventListener(Module* mod, unsigned int eventprio = DefaultPriority) : ModuleEventListener(mod, "event/account", eventprio) { } /** Called whenever a user logs in or out of an account. * @param user The user who logged in or out. * @param account The name of the account if logging in or empty if logging out. */ virtual void OnAccountChange(User* user, const std::string& account) = 0; }; ��inspircd-4.7.0/include/modules/away.h���������������������������������������������������������������0000664�0000000�0000000�00000005062�14771603147�0017557�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2018, 2021, 2023 Sadie Powell <sadie@witchery.services> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #pragma once namespace Away { class EventListener; class EventProvider; } class Away::EventListener : public Events::ModuleEventListener { protected: EventListener(Module* mod, unsigned int eventprio = DefaultPriority) : ModuleEventListener(mod, "event/away", eventprio) { } public: /** Called when a user wishes to mark themselves as away. * @param user The user who is going away. * @param message The away message that the user set. * @return Either MOD_RES_ALLOW to allow the user to mark themself as away, MOD_RES_DENY to * disallow the user to mark themself as away, or MOD_RES_PASSTHRU to let another module * handle the event. */ virtual ModResult OnUserPreAway(LocalUser* user, std::string& message) { return MOD_RES_PASSTHRU; } /** Called when a user wishes to mark themselves as back. * @param user The user who is going away. * @return Either MOD_RES_ALLOW to allow the user to mark themself as back, MOD_RES_DENY to * disallow the user to mark themself as back, or MOD_RES_PASSTHRU to let another module * handle the event. */ virtual ModResult OnUserPreBack(LocalUser* user) { return MOD_RES_PASSTHRU; } /** Called when a user has marked themself as away. * @param user The user who has gone away. * @param prevstate The previous away state of the user. */ virtual void OnUserAway(User* user, const std::optional<AwayState>& prevstate) = 0; /** Called when a user has returned from being away. * @param user The user who has returned from being away. * @param prevstate The previous away state of the user. */ virtual void OnUserBack(User* user, const std::optional<AwayState>& prevstate) = 0; }; class Away::EventProvider final : public Events::ModuleEventProvider { public: EventProvider(Module* mod) : ModuleEventProvider(mod, "event/away") { } }; ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/include/modules/callerid.h�����������������������������������������������������������0000664�0000000�0000000�00000002656�14771603147�0020403�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2018, 2021 Sadie Powell <sadie@witchery.services> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #pragma once namespace CallerID { class APIBase; class API; } class CallerID::APIBase : public DataProvider { public: APIBase(Module* parent) : DataProvider(parent, "m_callerid_api") { } /** Determines whether \p source is on the accept list of \p target. * @param source The user to search for in the accept list. * @param target The user who's accept list to search in. * @return True if \p source is on \p target's accept list; otherwise, false. */ virtual bool IsOnAcceptList(User* source, User* target) = 0; }; class CallerID::API final : public dynamic_reference<CallerID::APIBase> { public: API(Module* parent) : dynamic_reference<CallerID::APIBase>(parent, "m_callerid_api") { } }; ����������������������������������������������������������������������������������inspircd-4.7.0/include/modules/cap.h����������������������������������������������������������������0000664�0000000�0000000�00000025173�14771603147�0017366�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2018-2023 Sadie Powell <sadie@witchery.services> * Copyright (C) 2015-2016, 2018 Attila Molnar <attilamolnar@hush.com> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #pragma once #include "extension.h" namespace Cap { static constexpr unsigned int MAX_CAPS = (sizeof(intptr_t) * 8) - 1; static constexpr intptr_t CAP_302_BIT = (intptr_t)1 << MAX_CAPS; static constexpr unsigned int MAX_VALUE_LENGTH = 100; typedef intptr_t Ext; class ExtItem : public IntExtItem { public: ExtItem(Module* mod); void FromInternal(Extensible* container, const std::string& value) noexcept override; std::string ToHuman(const Extensible* container, void* item) const noexcept override; std::string ToInternal(const Extensible* container, void* item) const noexcept override; }; class Capability; enum Protocol { /** Supports capability negotiation protocol v3.1, or none */ CAP_LEGACY, /** Supports capability negotiation v3.2 */ CAP_302 }; class EventListener : public Events::ModuleEventListener { public: EventListener(Module* mod, unsigned int eventprio = DefaultPriority) : ModuleEventListener(mod, "event/cap", eventprio) { } /** Called whenever a new client capability becomes available or unavailable * @param cap Capability being added or removed * @param add If true, the capability is being added, otherwise its being removed */ virtual void OnCapAddDel(Capability* cap, bool add) = 0; /** Called whenever the value of a cap changes. * @param cap Capability whose value changed */ virtual void OnCapValueChange(Capability* cap) { } }; class Manager : public DataProvider { public: Manager(Module* mod) : DataProvider(mod, "capmanager") { } /** Register a client capability. * Modules should call Capability::SetActive(true) instead of this method. * @param cap Capability to register */ virtual void AddCap(Capability* cap) = 0; /** Unregister a client capability. * Modules should call Capability::SetActive(false) instead of this method. * @param cap Capability to unregister */ virtual void DelCap(Capability* cap) = 0; /** Find a capability by name * @param name Capability to find * @return Capability object pointer if found, NULL otherwise */ virtual Capability* Find(const std::string& name) const = 0; /** Notify manager when a value of a cap changed * @param cap Cap whose value changed */ virtual void NotifyValueChange(Capability* cap) = 0; }; /** Represents a client capability. * * Capabilities offer extensions to the client to server protocol. They must be negotiated with clients before they have any effect on the protocol. * Each cap must have a unique name that is used during capability negotiation. * * After construction the cap is ready to be used by clients without any further setup, like other InspIRCd services. * The get() method accepts a user as parameter and can be used to check whether that user has negotiated usage of the cap. This is only known for local users. * * The cap module must be loaded for the capability to work. The IsRegistered() method can be used to query whether the cap is actually online or not. * The capability can be deactivated and reactivated with the SetActive() method. Deactivated caps behave as if they don't exist. * * It is possible to implement special behavior by inheriting from this class and overriding some of its methods. */ class Capability : public ServiceProvider, private dynamic_reference_base::CaptureHook { typedef size_t Bit; /** Bit allocated to this cap, undefined if the cap is unregistered */ Bit bit; /** Extension containing all caps set by a user. NULL if the cap is unregistered. */ ExtItem* extitem; /** True if the cap is active. Only active caps are registered in the manager. */ bool active = true; /** Reference to the cap manager object */ dynamic_reference<Manager> manager; void OnCapture() override { if (active) SetActive(true); } void Unregister() { bit = 0; extitem = nullptr; } Ext AddToMask(Ext mask) const { return (mask | GetMask()); } Ext DelFromMask(Ext mask) const { return (mask & (~GetMask())); } Bit GetMask() const { return bit; } friend class ManagerImpl; protected: /** Notify the manager that the value of the capability changed. * Must be called if the value of the cap changes for any reason. */ void NotifyValueChange() { if (IsRegistered()) manager->NotifyValueChange(this); } public: /** Constructor, initializes the capability. * Caps are active by default. * @param mod Module providing the cap * @param Name Raw name of the cap as used in the protocol (CAP LS, etc.) */ Capability(Module* mod, const std::string& Name) : ServiceProvider(mod, Name, SERVICE_CUSTOM) , manager(mod, "capmanager") { Unregister(); } ~Capability() override { SetActive(false); } void RegisterService() override { manager.SetCaptureHook(this); SetActive(true); } /** Check whether a user has the capability turned on. * This method is safe to call if the cap is unregistered and will return false. * @param user User to check * @return True if the user is using this capability, false otherwise */ bool IsEnabled(User* user) const { if (!IsRegistered()) return false; Ext caps = extitem->Get(user); return ((caps & GetMask()) != 0); } /** Turn the capability on/off for a user. If the cap is not registered this method has no effect. * @param user User to turn the cap on/off for * @param val True to turn the cap on, false to turn it off */ void Set(User* user, bool val) { if (!IsRegistered()) return; Ext curr = extitem->Get(user); extitem->Set(user, (val ? AddToMask(curr) : DelFromMask(curr))); } /** Activate or deactivate the capability. * If activating, the cap is marked as active and if the manager is available the cap is registered in the manager. * If deactivating, the cap is marked as inactive and if it is registered, it will be unregistered. * Users who had the cap turned on will have it turned off automatically. * @param activate True to activate the cap, false to deactivate it */ void SetActive(bool activate) { active = activate; if (manager) { if (activate) manager->AddCap(this); else manager->DelCap(this); } } /** Get the name of the capability that's used in the protocol * @return Name of the capability as used in the protocol */ const std::string& GetName() const { return name; } /** Check whether the capability is active. The cap must be active and registered to be used by users. * @return True if the cap is active, false if it has been deactivated */ bool IsActive() const { return active; } /** Check whether the capability is registered * The cap must be active and the manager must be available for a cap to be registered. * @return True if the cap is registered in the manager, false otherwise */ bool IsRegistered() const { return (extitem != nullptr); } /** Get the CAP negotiation protocol version of a user. * The cap must be registered for this to return anything other than CAP_LEGACY. * @param user User whose negotiation protocol version to query * @return One of the Capability::Protocol enum indicating the highest supported capability negotiation protocol version */ Protocol GetProtocol(LocalUser* user) const { return ((IsRegistered() && (extitem->Get(user) & CAP_302_BIT)) ? CAP_302 : CAP_LEGACY); } /** Called when a user requests to turn this capability on or off. * @param user User requesting to change the state of the cap * @param add True if requesting to turn the cap on, false if requesting to turn it off * @return True to allow the request, false to reject it */ virtual bool OnRequest(LocalUser* user, bool add) { return true; } /** Called when a user requests a list of all capabilities and this capability is about to be included in the list. * The default behavior always includes the cap in the list. * @param user User querying a list capabilities * @return True to add this cap to the list sent to the user, false to not list it */ virtual bool OnList(LocalUser* user) { return true; } /** Query the value of this capability for a user * @param user User who will get the value of the capability * @return Value to show to the user. If NULL, the capability has no value (default). */ virtual const std::string* GetValue(LocalUser* user) const { return nullptr; } }; /** Reference to a cap. The cap may be provided by another module. */ class Reference { dynamic_reference_nocheck<Capability> ref; public: /** Constructor, initializes the capability reference * @param mod Module creating this object * @param Name Raw name of the cap as used in the protocol (CAP LS, etc.) */ Reference(Module* mod, const std::string& Name) : ref(mod, "cap/" + Name) { } /** Retrieves the underlying cap. */ operator const Cap::Capability*() const { return ref ? *ref : nullptr; } /** Check whether a user has the referenced capability turned on. * @param user User to check * @return True if the user is using the referenced capability, false otherwise */ bool IsEnabled(LocalUser* user) { if (ref) return ref->IsEnabled(user); return false; } /** Turn the capability on/off for a user. If the cap is not registered this method has no effect. * @param user User to turn the cap on/off for * @param val True to turn the cap on, false to turn it off */ void Set(User* user, bool val) { if (ref) ref->Set(user, val); } }; class MessageBase : public ClientProtocol::Message { public: MessageBase(const std::string& subcmd) : ClientProtocol::Message("CAP", ServerInstance->Config->GetServerName()) { PushParamPlaceholder(); PushParam(subcmd); } void SetUser(LocalUser* user) { if (user->connected & User::CONN_NICK) ReplaceParamRef(0, user->nick); else ReplaceParam(0, "*"); } }; } �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/include/modules/cloak.h��������������������������������������������������������������0000664�0000000�0000000�00000014622�14771603147�0017711�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2023 Sadie Powell <sadie@witchery.services> * Copyright (C) 2017 Adam <Adam@anope.org> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #pragma once namespace Cloak { class API; class APIBase; class Engine; class Method; /** Encapsulates a list of cloaks. */ typedef std::vector<std::string> List; /** A shared pointer to a cloak method. */ typedef std::shared_ptr<Method> MethodPtr; /** Takes a hostname and retrieves the part which should be visible. * * This is usually the last \p hostparts segments but if not enough are * present then all but the most specific segments are used. If the domain * name consists of one label only then none are used. * * Here are some examples for how domain names will be shortened assuming * \p domainparts is set to the default of 3. * * "this.is.an.example.com" => "an.example.com" * "an.example.com" => "example.com" * "example.com" => "com" * "localhost" => "" * * "/var/run/inspircd/client.sock" => "run/inspircd/client.sock" * "/run/inspircd/client.sock" => "inspircd/client.sock" * "/inspircd/client.sock" => "client.sock" * "/client.sock" => "" * * @param host The hostname to cloak. * @param hostparts The number of host labels that should be visible. * @param separator The character that separates hostname segments. * @return The visible segment of the hostname. */ inline std::string VisiblePart(const std::string& host, size_t hostparts, char separator); } /** Defines the interface for the cloak API. */ class Cloak::APIBase : public DataProvider { public: APIBase(Module* parent) : DataProvider(parent, "cloakapi") { } /** Retrieves the cloak list for the specified user. * @param user The user to retrieve cloaks for. */ virtual List* GetCloaks(LocalUser* user) = 0; /** Determines whether any cloaks of the specified type exist. * @param engine The engine to check the active status of. */ virtual bool IsActiveCloak(const Cloak::Engine& engine) = 0; /** Reset the cloaks for the specified user. * @param user The user to reset the cloaks for. * @param resetdisplay Whether to reset the currently displayed cloak. */ virtual void ResetCloaks(LocalUser* user, bool resetdisplay) = 0; }; /** Allows modules to access information regarding cloaks. */ class Cloak::API final : public dynamic_reference<Cloak::APIBase> { public: API(Module* parent) : dynamic_reference<Cloak::APIBase>(parent, "cloakapi") { } }; /** Base class for cloak engines. */ class Cloak::Engine : public DataProvider { protected: Engine(Module* Creator, const std::string& Name) : DataProvider(Creator, "cloak/" + Name) { } public: /** Creates a new cloak method from the specified config. * @param tag The config tag to configure the cloak method with. * @param primary Whether the created cloak method is the primary method. */ virtual MethodPtr Create(const std::shared_ptr<ConfigTag>& tag, bool primary) = 0; }; /** Base class for cloak methods. */ class Cloak::Method { private: /** The name of the engine that created this method. */ std::string provname; /** If non-empty the connect classes that a user must be in one of to be cloaked by this method. */ insp::flat_set<std::string> classes; protected: Method(const Engine* engine, const std::shared_ptr<ConfigTag>& tag) ATTR_NOT_NULL(2) : provname(engine->name) { irc::commasepstream klassstream(tag->getString("class")); for (std::string klass; klassstream.GetToken(klass); ) classes.insert(klass); } bool MatchesUser(LocalUser* user) const { if (!classes.empty() && classes.find(user->GetClass()->GetName()) == classes.end()) return false; // All fields matched. return true; } public: virtual ~Method() = default; /** Generates a cloak for the specified user. * @param user The user to generate a cloak for. */ virtual std::string Generate(LocalUser* user) ATTR_NOT_NULL(2) = 0; /** Generates a cloak for the specified hostname, IP address, or UNIX socket path. * @param hostip The hostname, IP address, or UNIX socket path to generate a cloak for. */ virtual std::string Generate(const std::string& hostip) = 0; /** Retrieves link compatibility data for this cloak method. * @param data The location to store link compatibility data. * @param compatdata The location to store link compatibility data for older protocols. */ virtual void GetLinkData(Module::LinkData& data, std::string& compatdata) = 0; /** Retrieves the name of this cloaking method. */ const char* GetName() const { return provname.c_str() + 6; } /** Determines whether when this cloak method is behind non-sensitive cloak methods * if it should be treated as if it was the primary cloak method for the purposes of * generating link data. */ virtual bool IsLinkSensitive() const { return false; } /** Determines whether this method is provided by the specified service provider. * @param prov The service provider to check. */ bool IsProvidedBy(const ServiceProvider& prov) const { return prov.name == provname; } }; inline std::string Cloak::VisiblePart(const std::string& host, size_t hostparts, char separator) { // The position at which we found the last separator. std::string::const_reverse_iterator seppos; // The number of separators we have seen so far. size_t seenseps = 0; for (std::string::const_reverse_iterator it = host.rbegin(); it != host.rend(); ++it) { if (*it != separator) continue; // We have found a separator! seppos = it; seenseps += 1; // Do we have enough segments to stop? if (seenseps >= hostparts) break; } // We only returns a domain part if more than one label is // present. See above for a full explanation. if (!seenseps) return ""; return std::string(seppos.base(), host.end()); } ��������������������������������������������������������������������������������������������������������������inspircd-4.7.0/include/modules/ctctags.h������������������������������������������������������������0000664�0000000�0000000�00000013706�14771603147�0020252�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2018, 2020-2023 Sadie Powell <sadie@witchery.services> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #pragma once #include "modules/cap.h" namespace CTCTags { class CapReference; class EventListener; class TagMessage; class TagMessageDetails; class TagProvider; } class CTCTags::CapReference final : public Cap::Reference { public: CapReference(Module* mod) : Cap::Reference(mod, "message-tags") { } }; class CTCTags::TagMessage final : public ClientProtocol::Message { private: void PushTarget(const char* target, char status) { if (status) { std::string rawtarget(1, status); rawtarget.append(target); PushParam(rawtarget); } else PushParam(target); } public: TagMessage(User* source, const Channel* targetchan, const ClientProtocol::TagMap& Tags, char status = 0) : ClientProtocol::Message("TAGMSG", source) { PushTarget(targetchan->name.c_str(), status); AddTags(Tags); } TagMessage(User* source, const User* targetuser, const ClientProtocol::TagMap& Tags) : ClientProtocol::Message("TAGMSG", source) { if (targetuser->connected & User::CONN_NICK) PushParamRef(targetuser->nick); else PushParam("*"); AddTags(Tags); } TagMessage(User* source, const char* targetstr, const ClientProtocol::TagMap& Tags, char status = 0) : ClientProtocol::Message("TAGMSG", source) { PushTarget(targetstr, status); AddTags(Tags); } TagMessage(const char* source, const char* targetstr, const ClientProtocol::TagMap& Tags, char status = 0) : ClientProtocol::Message("TAGMSG", source) { PushTarget(targetstr, status); AddTags(Tags); } }; class CTCTags::TagMessageDetails final { public: /** Whether to echo the tags at all. */ bool echo = true; /* Whether to send the original tags back to clients with echo-message support. */ bool echo_original = false; /** Whether to update the source user's idle time. */ bool update_idle = true; /** The users who are exempted from receiving this message. */ CUList exemptions; /** IRCv3 message tags sent to the server by the user. */ const ClientProtocol::TagMap tags_in; /** IRCv3 message tags sent out to users who get this message. */ ClientProtocol::TagMap tags_out; TagMessageDetails(const ClientProtocol::TagMap& tags) : tags_in(tags) { } }; class CTCTags::EventListener : public Events::ModuleEventListener { protected: EventListener(Module* mod, unsigned int eventprio = DefaultPriority) : ModuleEventListener(mod, "event/tagmsg", eventprio) { } public: /** Called before a user sends a tag message to a channel, a user, or a server glob mask. * @param user The user sending the message. * @param target The target of the message. This can either be a channel, a user, or a server * glob mask. * @param details Details about the message such as the message tags or whether to echo. See the * TagMessageDetails class for more information. * @return MOD_RES_ALLOW to explicitly allow the message, MOD_RES_DENY to explicitly deny the * message, or MOD_RES_PASSTHRU to let another module handle the event. */ virtual ModResult OnUserPreTagMessage(User* user, MessageTarget& target, TagMessageDetails& details) { return MOD_RES_PASSTHRU; } /** Called immediately after a user sends a tag message to a channel, a user, or a server glob mask. * @param user The user sending the message. * @param target The target of the message. This can either be a channel, a user, or a server * glob mask. * @param details Details about the message such as the message tags or whether to echo. See the * TagMessageDetails class for more information. */ virtual void OnUserPostTagMessage(User* user, const MessageTarget& target, const TagMessageDetails& details) { } /** Called immediately before a user sends a tag message to a channel, a user, or a server glob mask. * @param user The user sending the message. * @param target The target of the message. This can either be a channel, a user, or a server * glob mask. * @param details Details about the message such as the message tags or whether to echo. See the * TagMessageDetails class for more information. */ virtual void OnUserTagMessage(User* user, const MessageTarget& target, const TagMessageDetails& details) { } /** Called when a tag message sent by a user to a channel, a user, or a server glob mask is blocked. * @param user The user sending the message. * @param target The target of the message. This can either be a channel, a user, or a server * glob mask. * @param details Details about the message such as the message tags or whether to echo. See the * TagMessageDetails class for more information. */ virtual void OnUserTagMessageBlocked(User* user, const MessageTarget& target, const TagMessageDetails& details) { } }; class CTCTags::TagProvider : public ClientProtocol::MessageTagProvider { private: CapReference ctctagcap; public: TagProvider(Module* mod) : ClientProtocol::MessageTagProvider(mod) , ctctagcap(mod) { } /** Retrieves the underlying message-tags capability. */ const CapReference& GetCap() const { return ctctagcap; } /** @copydoc ClientProtocol::MessageTagProvider::ShouldSendTag */ bool ShouldSendTag(LocalUser* user, const ClientProtocol::MessageTagData& tagdata) override { return ctctagcap.IsEnabled(user); } }; ����������������������������������������������������������inspircd-4.7.0/include/modules/dns.h����������������������������������������������������������������0000664�0000000�0000000�00000012345�14771603147�0017404�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2021 Dominic Hamon * Copyright (C) 2019-2023 Sadie Powell <sadie@witchery.services> * Copyright (C) 2014-2015 Attila Molnar <attilamolnar@hush.com> * Copyright (C) 2013, 2015-2016 Adam <Adam@anope.org> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #pragma once namespace DNS { /** Valid query types */ enum QueryType { /* Nothing */ QUERY_NONE, /* A simple A lookup */ QUERY_A = 1, /* A CNAME lookup */ QUERY_CNAME = 5, /* Reverse DNS lookup */ QUERY_PTR = 12, /* TXT */ QUERY_TXT = 16, /* IPv6 AAAA lookup */ QUERY_AAAA = 28, /** SRV */ QUERY_SRV = 33, }; /** Flags that can be AND'd into DNSPacket::flags to receive certain values */ enum { QUERYFLAGS_QR = 0x8000, QUERYFLAGS_OPCODE = 0x7800, QUERYFLAGS_AA = 0x400, QUERYFLAGS_TC = 0x200, QUERYFLAGS_RD = 0x100, QUERYFLAGS_RA = 0x80, QUERYFLAGS_Z = 0x70, QUERYFLAGS_RCODE = 0xF }; enum Error { ERROR_NONE, ERROR_DISABLED, ERROR_UNKNOWN, ERROR_UNLOADED, ERROR_TIMEDOUT, ERROR_MALFORMED, ERROR_NOT_AN_ANSWER, ERROR_NONSTANDARD_QUERY, ERROR_FORMAT_ERROR, ERROR_SERVER_FAILURE, ERROR_DOMAIN_NOT_FOUND, ERROR_NOT_IMPLEMENTED, ERROR_REFUSED, ERROR_NO_RECORDS, ERROR_INVALIDTYPE }; typedef uint16_t RequestId; const int PORT = 53; class Exception final : public ModuleException { public: Exception(const Module* mod, const std::string& message) : ModuleException(mod, message) { } }; struct Question { std::string name; QueryType type; Question() : type(QUERY_NONE) { } Question(const std::string& n, QueryType t) : name(n), type(t) { } bool operator==(const Question& other) const { return ((name == other.name) && (type == other.type)); } bool operator!=(const Question& other) const { return (!(*this == other)); } struct hash final { size_t operator()(const Question& question) const { return irc::insensitive()(question.name); } }; }; namespace Record { struct SRV final { uint16_t priority = UINT16_MAX; uint16_t weight = 0; uint16_t port = 0; std::string host; }; } struct ResourceRecord : Question { unsigned int ttl = 0; std::string rdata; std::shared_ptr<void> rdataobj; time_t created; ResourceRecord(const std::string& n, QueryType t) : Question(n, t) , created(ServerInstance->Time()) { } ResourceRecord(const Question& question) : Question(question) , created(ServerInstance->Time()) { } }; struct Query { Question question; std::vector<ResourceRecord> answers; Error error = ERROR_NONE; bool cached = false; Query() = default; Query(const Question& q) : question(q) { } const ResourceRecord* FindAnswerOfType(QueryType qtype) const { for (const auto& rr : answers) { if (rr.type == qtype) return &rr; } return nullptr; } }; class ReplySocket; class Request; /** DNS manager */ class Manager : public DataProvider { public: Manager(Module* mod) : DataProvider(mod, "DNS") { } virtual void Process(Request* req) = 0; virtual void RemoveRequest(Request* req) = 0; virtual std::string GetErrorStr(Error) = 0; virtual std::string GetTypeStr(QueryType) = 0; }; /** Reference to the DNS manager. */ class ManagerRef final : public dynamic_reference<DNS::Manager> { public: ManagerRef(Module* mod) : dynamic_reference<DNS::Manager>(mod, "DNS") { } }; /** A DNS query. */ class Request : public Timer { protected: Manager* const manager; public: Question question; /* Use result cache if available */ bool use_cache; /* Request id */ RequestId id = 0; /* Creator of this request */ Module* const creator; Request(Manager* mgr, Module* mod, const std::string& addr, QueryType qt, bool usecache = true, unsigned long timeout = 0) : Timer(timeout ? timeout : ServerInstance->Config->ConfValue("dns")->getDuration("timeout", 5, 1), false) , manager(mgr) , question(addr, qt) , use_cache(usecache) , creator(mod) { } ~Request() override { manager->RemoveRequest(this); } /** Called when this request succeeds * @param req The query sent back from the nameserver */ virtual void OnLookupComplete(const Query* req) = 0; /** Called when this request fails or times out. * @param req The query sent back from the nameserver, check the error code. */ virtual void OnError(const Query* req) { } /** Used to time out the query, calls OnError and asks the TimerManager * to delete this request */ bool Tick() override { Query rr(this->question); rr.error = ERROR_TIMEDOUT; this->OnError(&rr); delete this; return false; } }; } // namespace DNS �������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/include/modules/exemption.h����������������������������������������������������������0000664�0000000�0000000�00000004442�14771603147�0020627�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2017, 2019, 2021, 2023 Sadie Powell <sadie@witchery.services> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #pragma once namespace CheckExemption { class EventListener; class EventProvider; } class CheckExemption::EventListener : public Events::ModuleEventListener { protected: EventListener(Module* mod, unsigned int eventprio = DefaultPriority) : ModuleEventListener(mod, "event/exemption", eventprio) { } public: /** Called when checking if a user is exempt from something. * @param user The user to check exemption for. * @param chan The channel to check exemption on. * @param restriction The restriction to check for. * @return Either MOD_RES_ALLOW to confirm an exemption, MOD_RES_DENY to deny an exemption, * or MOD_RES_PASSTHRU to let another module handle the event. */ virtual ModResult OnCheckExemption(User* user, Channel* chan, const std::string& restriction) = 0; }; class CheckExemption::EventProvider final : public Events::ModuleEventProvider { public: EventProvider(Module* mod) : ModuleEventProvider(mod, "event/exemption") { } /** Helper function for calling the CheckExemption::EventListener::OnCheckExemption event. * @param user The user to check exemption for. * @param chan The channel to check exemption on. * @param restriction The restriction to check for. * @return Either MOD_RES_ALLOW if the exemption was confirmed, MOD_RES_DENY if the exemption was * denied or MOD_RES_PASSTHRU if no module handled the event. */ inline ModResult Check(User* user, Channel* chan, const std::string& restriction) { return FirstResult(&CheckExemption::EventListener::OnCheckExemption, user, chan, restriction); } }; ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/include/modules/extban.h�������������������������������������������������������������0000664�0000000�0000000�00000027102�14771603147�0020076�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2020-2024 Sadie Powell <sadie@witchery.services> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #pragma once #ifndef INSPIRCD_EXTBAN # define INSPIRCD_EXTBAN #endif namespace ExtBan { class Acting; class ActingBase; class Base; class EventListener; class MatchingBase; class Manager; class ManagerRef; /** All possible results for CompareResult. */ enum class Comparison : uint8_t { /** The value passed to CompareResult is not an extban. */ NOT_AN_EXTBAN, /** The extban is equivalent to the specified value. */ MATCH, /** The extban is not equivalent to the specified value. */ NOT_MATCH, }; /** All possible extban formats. */ enum class Format : uint8_t { /** Do not perform any normalisation of extbans. */ ANY, /** Normalise extbans to use their name (e.g. mute). */ NAME, /** Normalise extbans to use their letter (e.g. m). */ LETTER, }; /** All possible types of extban. */ enum class Type : uint8_t { /** The extban takes action against specific behaviour (e.g. nokicks). */ ACTING, /** The extban matches against a specific pattern (e.g. sslfp). */ MATCHING }; /** The underlying type of an extban letter. */ using Letter = std::string::value_type; /** Parses a ban entry and extracts an extban from it. * @param banentry The ban entry to parse. * @param name The parsed name of the extban. * @param value The parsed value of the extban. * @param inverted Whether the extban is inverted. * @return True if an extban was extracted from the ban entry; otherwise, false. */ inline bool Parse(const std::string& banentry, std::string& name, std::string& value, bool& inverted); } /** Manager for the extban system. */ class ExtBan::Manager : public DataProvider { protected: /** Initializes an instance of the ExtBan::Base class. * @param mod The module which created this instance. */ Manager(Module* mod) : DataProvider(mod, "extbanmanager") { } public: /** A mapping of extban letters to their associated object. */ typedef std::unordered_map<ExtBan::Letter, ExtBan::Base*> LetterMap; /** A mapping of extban names to their associated objects. */ typedef std::unordered_map<std::string, ExtBan::Base*, irc::insensitive, irc::StrHashComp> NameMap; /** Registers an extban with the manager. * @param extban The extban instance to register. */ virtual void AddExtBan(Base* extban) = 0; /** Canonicalises a list mode entry if it is an extban. * @param text The list mode entry to canonicalize. * @return True if the text was a valid extban and was canonicalised. Otherwise, false. */ virtual bool Canonicalize(std::string& text) const = 0; /** Compares an entry from this list with the specified value. * @param lm The list mode which is the entry exists on. * @param entry The list entry to compare against. * @param value The value to compare to. * @return MATCH if the entries match and NOT_MATCH if the entries do not match. */ virtual Comparison CompareEntry(const ListModeBase* lm, const std::string& entry, const std::string& value) const = 0; /** Unregisters an extban from the manager. * @param extban The extban instance to unregister. */ virtual void DelExtBan(Base* extban) = 0; /** Retrieves the method used for normalising extbans. */ virtual Format GetFormat() const = 0; /** Retrieves a mapping of extban letters to their associated object. */ virtual const LetterMap& GetLetterMap() const = 0; /** Retrieves a mapping of extban names to their associated object. */ virtual const NameMap& GetNameMap() const = 0; /** Retrieves the status of an acting extban. * @param extban The extban to get the status of. * @param user The user to match the extban against. * @param channel The channel which the extban is set on. * @return MOD_RES_ALLOW if the user is exempted, MOD_RES_DENY if the user is banned, or * MOD_RES_PASSTHRU if the extban is not set. */ virtual ModResult GetStatus(ActingBase* extban, User* user, Channel* channel) const = 0; /** Finds an extban by name or letter. * @param xbname The name or letter of the extban to find. */ Base* Find(const std::string& xbname) const { return xbname.length() == 1 ? FindLetter(xbname[0]) : FindName(xbname); } /** Finds an extban by letter. * @param xbletter The letter of the extban to find. */ virtual Base* FindLetter(ExtBan::Letter xbletter) const = 0; /** Finds an extban by name. * @param xbname The name of the extban to find. */ virtual Base* FindName(const std::string& xbname) const = 0; }; /** Dynamic reference to the extban manager class. */ class ExtBan::ManagerRef final : public dynamic_reference_nocheck<ExtBan::Manager> { public: ManagerRef(Module* mod) : dynamic_reference_nocheck<ExtBan::Manager>(mod, "extbanmanager") { } }; /** Base class for types of extban. */ class ExtBan::Base : public ServiceProvider , private dynamic_reference_base::CaptureHook { private: /** Whether this ExtBan is currently enabled. */ bool active = false; /** The character used in bans to signify this extban (e.g. z). */ ExtBan::Letter letter; /** A reference to the extban manager. */ dynamic_reference<Manager> manager; /** @copydoc dynamic_reference_base::CaptureHook::OnCapture */ void OnCapture() override { if (active) SetActive(true); } protected: /** Initializes an instance of the ExtBan::Base class. * @param mod The module which created this instance. * @param xbname The name used in bans to signify this extban. * @param xbletter The character used in bans to signify this extban. */ Base(Module* mod, const std::string& xbname, ExtBan::Letter xbletter) : ServiceProvider(mod, xbname, SERVICE_CUSTOM) , letter(ServerInstance->Config->ConfValue("extbans")->getCharacter(xbname, xbletter, true)) , manager(mod, "extbanmanager") { } ~Base() override { SetActive(false); } public: /** Canonicalises a value for this extban. * @param text The value to canonicalize. */ virtual void Canonicalize(std::string& text) { } /** Retrieves the character used in bans to signify this extban. */ ExtBan::Letter GetLetter() const { return letter; } /** Retrieves a pointer to the extban manager. */ Manager* GetManager() { return manager ? *manager : nullptr; } /** Retrieves the name used in bans to signify this extban. */ const std::string& GetName() const { return name; } /** Retrieves the type of this extban. */ virtual Type GetType() const = 0; /** Retrieves whether this extban is enabled. */ bool IsActive() const { return active; } /** Determines whether the specified user matches this extban. * @param user The user to match the text against. * @param channel The channel which the extban is set on. * @param text The string to match the user against. * @return True if the user matches the extban; otherwise, false. */ virtual bool IsMatch(User* user, Channel* channel, const std::string& text) = 0; /** @copydoc ServiceProvider::RegisterService */ void RegisterService() override { manager.SetCaptureHook(this); SetActive(true); } /** Toggles the active status of this extban. * @param Active Whether this extban is active or not. */ void SetActive(bool Active) { active = Active; if (manager) { if (active) manager->AddExtBan(this); else manager->DelExtBan(this); } } }; /** Base class for acting extbans. */ class ExtBan::ActingBase : public Base { protected: /** Initializes an instance of the ExtBan::ActingBase class. * @param mod The module which created this instance. * @param xbname The name used in bans to signify this extban. * @param xbletter The character used in bans to signify this extban. */ ActingBase(Module* mod, const std::string& xbname, ExtBan::Letter xbletter) : Base(mod, xbname, xbletter) { } public: /** @copydoc ExtBan::Base::Canonicalize */ void Canonicalize(std::string& text) override { if (!GetManager() || !GetManager()->Canonicalize(text)) ModeParser::CleanMask(text); } /** @copydoc ExtBan::Base::GetType */ Type GetType() const override { return ExtBan::Type::ACTING; } /** @copydoc ExtBan::Base::IsMatch */ bool IsMatch(User* user, Channel* channel, const std::string& text) override { return channel->CheckBan(user, text); } }; /** A simple acting extban that has no fields. */ class ExtBan::Acting : public ActingBase { public: /** Initializes an instance of the ExtBan::Acting class. * @param mod The module which created this instance. * @param xbname The name used in bans to signify this extban. * @param xbletter The character used in bans to signify this extban. */ Acting(Module* mod, const std::string& xbname, ExtBan::Letter xbletter) : ActingBase(mod, xbname, xbletter) { } /** Determines whether the specified user matches this acting extban on the specified channel. * @param user The user to check. * @param channel The channel to check on. * @return MOD_RES_ALLOW to explicitly allow their action, MOD_RES_DENY to expicitly deny their * action, or MOD_RES_PASSTHRU to let the default behaviour apply. */ ModResult GetStatus(User* user, Channel* channel) { if (!GetManager()) return MOD_RES_PASSTHRU; return GetManager()->GetStatus(this, user, channel); } }; /** Base class for matching extbans. */ class ExtBan::MatchingBase : public Base { protected: /** Initializes an instance of the ExtBan::MatchingBase class. * @param mod The module which created this instance. * @param xbname The name used in bans to signify this extban. * @param xbletter The character used in bans to signify this extban. */ MatchingBase(Module* mod, const std::string& xbname, ExtBan::Letter xbletter) : Base(mod, xbname, xbletter) { } public: /** @copydoc ExtBan::Base::GetType */ Type GetType() const override { return ExtBan::Type::MATCHING; } /** @copydoc ExtBan::Base::IsMatch */ virtual bool IsMatch(User* user, Channel* channel, const std::string& text) override = 0; }; /** Provides events relating to extbans. */ class ExtBan::EventListener : public Events::ModuleEventListener { protected: EventListener(Module* mod, unsigned int eventprio = DefaultPriority) : ModuleEventListener(mod, "event/extban", eventprio) { } public: /** Called when an extban is being checked. * @param user The user which the extban is being checked against. * @param chan The channel which the extban is set on. * @param extban The extban which is being checked against. */ virtual ModResult OnExtBanCheck(User* user, Channel* chan, ExtBan::Base* extban) = 0; }; inline bool ExtBan::Parse(const std::string& banentry, std::string& name, std::string& value, bool& inverted) { // The mask must be in the format [!]<letter>:<value> or [!]<name>:<value>. inverted = false; size_t startpos = 0; if (banentry[0] == '!') { inverted = true; startpos++; } size_t endpos = banentry.find_first_not_of("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", startpos); if (endpos == std::string::npos || banentry[endpos] != ':') return false; name.assign(banentry, startpos, endpos - startpos); value.assign(banentry, endpos + 1); return true; } ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/include/modules/geolocation.h��������������������������������������������������������0000664�0000000�0000000�00000004263�14771603147�0021123�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2019, 2021-2022 Sadie Powell <sadie@witchery.services> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #pragma once namespace Geolocation { class APIBase; class API; class Location; } class Geolocation::APIBase : public DataProvider { public: APIBase(Module* parent) : DataProvider(parent, "geolocationapi") { } /** Looks up the location of the specified user. * @param user The user to look up the location of. * @return Either an instance of the Location class or NULL if no location could be found. */ virtual Location* GetLocation(User* user) = 0; /** Looks up the location of the specified IP address. * @param sa The IP address to look up the location of. * @return Either an instance of the Location class or NULL if no location could be found. */ virtual Location* GetLocation(irc::sockets::sockaddrs& sa) = 0; }; class Geolocation::API final : public dynamic_reference<Geolocation::APIBase> { public: API(Module* parent) : dynamic_reference<Geolocation::APIBase>(parent, "geolocationapi") { } }; class Geolocation::Location final : public usecountbase { private: /** The two character country code for this location. */ std::string code; /** The country name for this location. */ std::string name; public: Location(const std::string& Code, const std::string& Name) : code(Code) , name(Name) { } /** Retrieves the two character country code for this location. */ const std::string& GetCode() const { return code; } /** Retrieves the country name for this location. */ const std::string& GetName() const { return name; } }; ���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/include/modules/hash.h���������������������������������������������������������������0000664�0000000�0000000�00000004401�14771603147�0017535�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2014 Daniel Vassdal <shutter@canternet.org> * Copyright (C) 2013, 2021-2023 Sadie Powell <sadie@witchery.services> * Copyright (C) 2012 Robby <robby@chatbelgie.be> * Copyright (C) 2009-2010 Daniel De Graaf <danieldg@inspircd.org> * Copyright (C) 2007 Dennis Friis <peavey@inspircd.org> * Copyright (C) 2006 Craig Edwards <brain@inspircd.org> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #pragma once #include "stringutils.h" class HashProvider : public DataProvider { public: const unsigned int out_size; const unsigned int block_size; HashProvider(Module* mod, const std::string& Name, unsigned int osiz = 0, unsigned int bsiz = 0) : DataProvider(mod, "hash/" + Name) , out_size(osiz) , block_size(bsiz) { } virtual std::string GenerateRaw(const std::string& data) = 0; virtual std::string ToPrintable(const std::string& raw) { return Hex::Encode(raw); } virtual bool Compare(const std::string& input, const std::string& hash) { return InspIRCd::TimingSafeCompare(Generate(input), hash); } std::string Generate(const std::string& data) { return ToPrintable(GenerateRaw(data)); } /** HMAC algorithm, RFC 2104 */ std::string hmac(const std::string& key, const std::string& msg) { std::string hmac1, hmac2; std::string kbuf = key.length() > block_size ? GenerateRaw(key) : key; kbuf.resize(block_size); for (size_t n = 0; n < block_size; n++) { hmac1.push_back(static_cast<char>(kbuf[n] ^ 0x5C)); hmac2.push_back(static_cast<char>(kbuf[n] ^ 0x36)); } hmac2.append(msg); hmac1.append(GenerateRaw(hmac2)); return GenerateRaw(hmac1); } bool IsKDF() const { return (!block_size); } }; ���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/include/modules/httpd.h��������������������������������������������������������������0000664�0000000�0000000�00000020154�14771603147�0017740�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2019 linuxdaemon <linuxdaemon.irc@gmail.com> * Copyright (C) 2013, 2021-2023, 2025 Sadie Powell <sadie@witchery.services> * Copyright (C) 2013, 2015 Attila Molnar <attilamolnar@hush.com> * Copyright (C) 2012 Robby <robby@chatbelgie.be> * Copyright (C) 2009 Daniel De Graaf <danieldg@inspircd.org> * Copyright (C) 2007 John Brooks <john@jbrooks.io> * Copyright (C) 2007 Dennis Friis <peavey@inspircd.org> * Copyright (C) 2006, 2008 Craig Edwards <brain@inspircd.org> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #pragma once #include "timeutils.h" class HTTPQueryParameters final : public insp::flat_multimap<std::string, std::string> { public: bool get(const std::string& key, std::string& value) const { const_iterator it = find(key); if (it == end()) return false; value = it->second; return true; } std::string getString(const std::string& key, const std::string& def = "") const { std::string value; if (!get(key, value)) return def; return value; } template <typename T> T getNum(const std::string& key, T def = 0) const { std::string value; if (!get(key, value)) return def; return ConvToNum<T>(value); } unsigned long getDuration(const std::string& key, unsigned long def = 0) const { unsigned long value; if (!Duration::TryFrom(getString(key, "0"), value)) return def; return value; } bool getBool(const std::string& key, bool def = false) const { return !!getNum<uint8_t>(key, def); } }; struct HTTPRequestURI final { std::string path; HTTPQueryParameters query_params; std::string fragment; }; /** A modifiable list of HTTP header fields */ class HTTPHeaders final { protected: std::map<std::string, std::string> headers; public: /** Set the value of a header * Sets the value of the named header. If the header is already present, it will be replaced */ void SetHeader(const std::string& name, const std::string& data) { headers[name] = data; } /** Set the value of a header, only if it doesn't exist already * Sets the value of the named header. If the header is already present, it will NOT be updated */ void CreateHeader(const std::string& name, const std::string& data) { if (!IsSet(name)) SetHeader(name, data); } /** Remove the named header */ void RemoveHeader(const std::string& name) { headers.erase(name); } /** Remove all headers */ void Clear() { headers.clear(); } /** Get the value of a header * @return The value of the header, or an empty string */ std::string GetHeader(const std::string& name) { std::map<std::string, std::string>::iterator it = headers.find(name); if (it == headers.end()) return std::string(); return it->second; } /** Check if the given header is specified * @return true if the header is specified */ bool IsSet(const std::string& name) { std::map<std::string, std::string>::iterator it = headers.find(name); return (it != headers.end()); } /** Get all headers, formatted by the HTTP protocol * @return Returns all headers, formatted according to the HTTP protocol. There is no request terminator at the end */ std::string GetFormattedHeaders() { std::stringstream buf; for (const auto& [key, value] : headers) buf << key << ": " << value << "\r\n"; return buf.str(); } }; class HttpServerSocket; /** This class represents a HTTP request. */ class HTTPRequest final { protected: std::string type; std::string ipaddr; std::string postdata; HTTPRequestURI parseduri; public: HTTPHeaders* headers; int errorcode; /** A socket pointer, which you must return in your HTTPDocument class * if you reply to this request. */ HttpServerSocket* sock; /** Initialize HTTPRequest. * This constructor is called by m_httpd.so to initialize the class. * @param request_type The request type, e.g. GET, POST, HEAD * @param parsed_uri The URI which was requested by the client. * @param hdr The headers sent with the request * @param socket The server socket which this request came in via. * @param ip The IP address making the web request. * @param pdata The post data (content after headers) received with the request, up to Content-Length in size */ HTTPRequest(const std::string& request_type, const HTTPRequestURI& parsed_uri, HTTPHeaders* hdr, HttpServerSocket* socket, const std::string& ip, const std::string& pdata) : type(request_type) , ipaddr(ip) , postdata(pdata) , parseduri(parsed_uri) , headers(hdr) , sock(socket) { } /** Get the post data (request content). * All post data will be returned, including carriage returns and linefeeds. * @return The postdata */ std::string& GetPostData() { return postdata; } /** Get the request type. * Any request type can be intercepted, even ones which are invalid in the HTTP/1.1 spec. * @return The request type, e.g. GET, POST, HEAD */ std::string& GetType() { return type; } HTTPRequestURI& GetParsedURI() { return parseduri; } std::string& GetPath() { return GetParsedURI().path; } /** Get IP address of requester. * The requesting system's ip address will be returned. * @return The IP address as a string */ std::string& GetIP() { return ipaddr; } }; /** If you want to reply to HTTP requests, you must return a HTTPDocumentResponse to * the httpd module via the HTTPdAPI. * When you initialize this class you initialize it with all components required to * form a valid HTTP response: the document data and a response code. * You can add additional HTTP headers, if you want. */ class HTTPDocumentResponse final { public: /** Module that generated this reply */ Module* const module; std::stringstream* document; unsigned int responsecode; /** Any extra headers to include with the defaults */ HTTPHeaders headers; HTTPRequest& src; /** Initialize a HTTPDocumentResponse ready for sending to the httpd module. * @param mod A pointer to the module who responded to the request * @param req The request you obtained from the HTTPRequest at an earlier time * @param doc A stringstream containing the document body * @param response A valid HTTP/1.0 or HTTP/1.1 response code. The response text will be determined for you * based upon the response code. */ HTTPDocumentResponse(Module* mod, HTTPRequest& req, std::stringstream* doc, unsigned int response) : module(mod) , document(doc) , responsecode(response) , src(req) { } }; class HTTPdAPIBase : public DataProvider { public: HTTPdAPIBase(Module* parent) : DataProvider(parent, "m_httpd_api") { } /** Answer an incoming HTTP request with the provided document * @param response The response created by your module that will be sent to the client */ virtual void SendResponse(HTTPDocumentResponse& response) = 0; }; /** The API provided by the httpd module that allows other modules to respond to incoming * HTTP requests */ class HTTPdAPI final : public dynamic_reference<HTTPdAPIBase> { public: HTTPdAPI(Module* parent) : dynamic_reference<HTTPdAPIBase>(parent, "m_httpd_api") { } }; class HTTPACLEventListener : public Events::ModuleEventListener { public: HTTPACLEventListener(Module* mod, unsigned int eventprio = DefaultPriority) : ModuleEventListener(mod, "event/http-acl", eventprio) { } virtual ModResult OnHTTPACLCheck(HTTPRequest& req) = 0; }; class HTTPRequestEventListener : public Events::ModuleEventListener { public: HTTPRequestEventListener(Module* mod, unsigned int eventprio = DefaultPriority) : ModuleEventListener(mod, "event/http-request", eventprio) { } virtual ModResult OnHTTPRequest(HTTPRequest& req) = 0; }; ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/include/modules/invite.h�������������������������������������������������������������0000664�0000000�0000000�00000011374�14771603147�0020117�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2019-2022 Sadie Powell <sadie@witchery.services> * Copyright (C) 2015 Attila Molnar <attilamolnar@hush.com> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #pragma once namespace Invite { class APIBase; class API; class Invite; /** Used to indicate who we announce invites to on a channel. */ enum AnnounceState { /** Don't send invite announcements. */ ANNOUNCE_NONE, /** Send invite announcements to all users. */ ANNOUNCE_ALL, /** Send invite announcements to channel operators and higher. */ ANNOUNCE_OPS, /** Send invite announcements to channel half-operators (if available) and higher. */ ANNOUNCE_DYNAMIC }; typedef insp::intrusive_list<Invite, LocalUser> List; } class Invite::APIBase : public DataProvider { public: APIBase(Module* parent); /** Create or extend an Invite. * When a user is invited to join a channel either a new Invite object is created or * or the expiration timestamp is updated if there is already a pending Invite for * the given (user, channel) pair and the new expiration time is further than the current. * @param user Target user * @param chan Target channel * @param timeout Timestamp when the invite should expire, 0 for no expiration */ virtual void Create(LocalUser* user, Channel* chan, time_t timeout) = 0; /** Retrieves the Invite object for the given (user, channel) pair * @param user Target user * @param chan Target channel * @return Invite object for the given (channel, user) pair if it exists, NULL otherwise */ virtual Invite* Find(LocalUser* user, Channel* chan) = 0; /** Returns the announcement behaviour for invites from <security:announceinvites>. */ virtual AnnounceState GetAnnounceState() const = 0; /** Returns the list of channels a user has been invited to but has not yet joined. * @param user User whose invite list to retrieve * @return List of channels the user is invited to or NULL if the list is empty */ virtual const List* GetList(LocalUser* user) = 0; /** Check if a user is invited to a channel * @param user User to check * @param chan Channel to check * @return True if the user is invited to the channel, false otherwise */ bool IsInvited(LocalUser* user, Channel* chan) { return (Find(user, chan) != nullptr); } /** Removes an Invite if it exists * @param user User whose invite to remove * @param chan Channel to remove the invite to * @return True if the user was invited to the channel and the invite was removed, false if the user wasn't invited */ virtual bool Remove(LocalUser* user, Channel* chan) = 0; }; class Invite::API final : public dynamic_reference<APIBase> { public: API(Module* parent) : dynamic_reference<APIBase>(parent, "core_channel_invite") { } }; /** * The Invite class contains all data about a pending invite. * Invite objects are referenced from the user and the channel they belong to. */ class Invite::Invite final : public insp::intrusive_list_node<Invite, LocalUser>, public insp::intrusive_list_node<Invite, Channel> { public: /** User the invite is for */ LocalUser* const user; /** Channel where the user is invited to */ Channel* const chan; /** Check whether the invite will expire or not * @return True if the invite is timed, false if it doesn't expire */ bool IsTimed() const { return (expiretimer != nullptr); } /** Serialize this object * @param human Whether to serialize for human consumption or not. * @param show_chans True to include channel in the output, false to include the nick/uuid * @param out Output will be appended to this string */ void Serialize(bool human, bool show_chans, std::string& out); friend class APIImpl; private: /** Timer handling expiration. If NULL this invite doesn't expire. */ Timer* expiretimer = nullptr; /** Constructor, only available to the module providing the invite API (core_channel). * To create Invites use InviteAPI::Create(). * @param user User being invited * @param chan Channel the user is invited to */ Invite(LocalUser* user, Channel* chan); /** Destructor, only available to the module providing the invite API (core_channel). * To remove Invites use InviteAPI::Remove(). */ ~Invite(); }; ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/include/modules/ircv3.h��������������������������������������������������������������0000664�0000000�0000000�00000006653�14771603147�0017653�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2018-2021 Sadie Powell <sadie@witchery.services> * Copyright (C) 2015, 2018 Attila Molnar <attilamolnar@hush.com> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #pragma once #include "modules/cap.h" namespace IRCv3 { class WriteNeighborsWithCap; template <typename T> class CapTag; } class IRCv3::WriteNeighborsWithCap final : public User::ForEachNeighborHandler { private: const Cap::Capability& cap; ClientProtocol::Event& protoev; uint64_t sentid; void Execute(LocalUser* user) override { if (cap.IsEnabled(user)) user->Send(protoev); } public: WriteNeighborsWithCap(User* user, ClientProtocol::Event& ev, const Cap::Capability& capability, bool include_self = false) : cap(capability) , protoev(ev) { sentid = user->ForEachNeighbor(*this, include_self); } uint64_t GetAlreadySentId() const { return sentid; } }; /** Base class for simple message tags. * Message tags provided by classes derived from this class will be sent to clients that have negotiated * a client capability, also managed by this class. * * Derived classes specify the name of the capability and the message tag and provide a public GetValue() * method with the following signature: const std::string* GetValue(ClientProtocol::Message& msg). * The returned value determines whether to attach the tag to the message. If it is NULL, the tag won't * be attached. If it is non-NULL the tag will be attached with the value in the string. If the string is * empty the tag is attached without a value. * * Providers inheriting from this class don't accept incoming tags by default. * * For more control, inherit from ClientProtocol::MessageTagProvider directly. * * Template parameter T is the derived class. */ template <typename T> class IRCv3::CapTag : public ClientProtocol::MessageTagProvider { protected: Cap::Capability cap; const std::string tagname; bool ShouldSendTag(LocalUser* user, const ClientProtocol::MessageTagData& tagdata) override { return cap.IsEnabled(user); } void OnPopulateTags(ClientProtocol::Message& msg) override { T& tag = static_cast<T&>(*this); const std::string* const val = tag.GetValue(msg); if (val) msg.AddTag(tagname, this, *val); } public: /** Constructor. * @param mod Module that owns the tag. * @param capname Name of the client capability. * A client capability with this name will be created. It will be available to all clients and it won't * have a value. * See Cap::Capability for more info on client capabilities. * @param Tagname Name of the message tag, to use in the protocol. */ CapTag(Module* mod, const std::string& capname, const std::string& Tagname) : ClientProtocol::MessageTagProvider(mod) , cap(mod, capname) , tagname(Tagname) { } /** Retrieves the underlying capability. */ const Cap::Capability& GetCap() const { return cap; } }; �������������������������������������������������������������������������������������inspircd-4.7.0/include/modules/ircv3_batch.h��������������������������������������������������������0000664�0000000�0000000�00000014106�14771603147�0021004�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2018-2022 Sadie Powell <sadie@witchery.services> * Copyright (C) 2018 Attila Molnar <attilamolnar@hush.com> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #pragma once #include "modules/cap.h" namespace IRCv3 { namespace Batch { typedef uint64_t RefTag; class Manager; class ManagerImpl; class Batch; struct BatchInfo; class API; class CapReference; static constexpr unsigned int MAX_BATCHES = (sizeof(intptr_t) * 8) - 1; } } /** Batch Manager. * Implements batch starting and stopping. When it becomes unavailable (due to e.g. module unload) * all running batches are stopped. */ class IRCv3::Batch::Manager : public DataProvider , public ClientProtocol::MessageTagProvider { public: /** Constructor. * @param mod Module that owns the Manager. */ Manager(Module* mod) : DataProvider(mod, "batchapi") , ClientProtocol::MessageTagProvider(mod) { } /** Start a batch. * Check Batch::IsRunning() to learn if the batch has been started. * @param batch Batch to start. */ virtual void Start(Batch& batch) = 0; /** End a batch. * @param batch Batch to end. */ virtual void End(Batch& batch) = 0; }; /** Represents a batch. * Batches are used to group together physically separate client protocol messages that logically belong * together for one reason or another. The type of a batch, if provided, indicates what kind of grouping * it does. * * Batch objects have two states: running and stopped. If a batch is running, messages can be added to it. * If a message has been added to a batch and that message is sent to a client that negotiated the batch * capability then the client will receive a message tag attached to the message indicating the batch that * the message is a part of. If a message M is part of a batch B and M is sent to a client that hasn't yet * received any message from batch B it will get a batch start message for B before M. When a batch B is * stopped, every client that received at least one message which was in batch B will receive an end of * batch message for B. * A message may only be part of a single batch at any given time. */ class IRCv3::Batch::Batch final { Manager* manager = nullptr; const std::string type; RefTag reftag; std::string reftagstr; unsigned int bit; BatchInfo* batchinfo = nullptr; ClientProtocol::Message* batchstartmsg = nullptr; ClientProtocol::Message* batchendmsg = nullptr; void Setup(unsigned int b) { bit = b; reftag = (static_cast<RefTag>(1) << bit); reftagstr = ConvToStr(reftag); } unsigned int GetId() const { return bit; } intptr_t GetBit() const { return reftag; } public: /** Constructor. * The batch is initially stopped. To start it, pass it to Manager::Start(). * @param Type Batch type string, used to indicate what kind of grouping the batch does. May be empty. */ Batch(const std::string& Type) : type(Type) { } /** Destructor. * If the batch is running, it is ended. */ ~Batch() { if (manager) manager->End(*this); } /** Add a message to the batch. * If the batch isn't running then this method does nothing. * @param msg Message to add to the batch. If it is already part of any batch, this method is a no-op. */ void AddToBatch(ClientProtocol::Message& msg) { if (manager) msg.AddTag("batch", manager, reftagstr, this); } /** Get batch reference tag which is an opaque id for the batch and is used in the client protocol. * Only running batches have a reference tag assigned. * @return Reference tag as a string, only valid if the batch is running. */ const std::string& GetRefTagStr() const { return reftagstr; } /** Get batch type. * @return Batch type string. */ const std::string& GetType() const { return type; } /** Check whether the batch is running. * Batches can be started with Manager::Start() and stopped with Manager::End(). * @return True if the batch is running, false otherwise. */ bool IsRunning() const { return (manager != nullptr); } /** Get the batch start client protocol message. * The returned message object can be manipulated to add extra parameters or labels to the message. The first * parameter of the message is the batch reference tag generated by the module providing batch support. * If the batch type string was specified, it will be the second parameter of the message. * May only be called if IsRunning() == true. * @return Mutable batch start client protocol message. */ ClientProtocol::Message& GetBatchStartMessage() { return *batchstartmsg; } /** Get the batch end client protocol message. * The returned message object can be manipulated to add extra parameters or labels to the message. The first * parameter of the message is the batch reference tag generated by the module providing batch support. * If the batch type string was specified, it will be the second parameter of the message. * May only be called if IsRunning() == true. * @return Mutable batch end client protocol message. */ ClientProtocol::Message& GetBatchEndMessage() { return *batchendmsg; } friend class ManagerImpl; }; /** Batch API. Use this to access the Manager. */ class IRCv3::Batch::API final : public dynamic_reference_nocheck<Manager> { public: API(Module* mod) : dynamic_reference_nocheck<Manager>(mod, "batchapi") { } }; /** Reference to the batch cap. * Can be used to check whether a user has the batch client cap enabled. */ class IRCv3::Batch::CapReference final : public Cap::Reference { public: CapReference(Module* mod) : Cap::Reference(mod, "batch") { } }; ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/include/modules/ircv3_replies.h������������������������������������������������������0000664�0000000�0000000�00000011033�14771603147�0021362�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2019-2022, 2024 Sadie Powell <sadie@witchery.services> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #pragma once #include "modules/cap.h" namespace IRCv3 { namespace Replies { class CapReference; class Reply; class Fail; class Note; class Warn; } } /** Reference to the standard-replies cap. */ class IRCv3::Replies::CapReference final : public Cap::Reference { public: CapReference(Module* mod) : Cap::Reference(mod, "standard-replies") { } }; /** Base class for standard replies. */ class IRCv3::Replies::Reply { private: /** The name of the command for this reply. */ const std::string cmd; /** The event provider for this reply. */ ClientProtocol::EventProvider evprov; /** Wraps a message in an event and sends it to a user. * @param user The user to send the message to. * @param msg The message to send to the user. */ void SendInternal(LocalUser* user, ClientProtocol::Message& msg) { ClientProtocol::Event ev(evprov, msg); user->Send(ev); } void SendNoticeInternal(LocalUser* user, const Command* command, const std::string& description) { if (command) user->WriteNotice("*** {}: {}", command->name, description); else user->WriteNotice("*** {}", description); } protected: /** Initializes a new instance of the Reply class. * @param Creator The module which created this instance. * @param Cmd The name of the command to reply with. */ Reply(Module* Creator, const std::string& Cmd) : cmd(Cmd) , evprov(Creator, Cmd) { } public: /** * Sends a standard reply to the specified user. * @param user The user to send the reply to. * @param command The command that the reply relates to. * @param code A machine readable code for this reply. * @param args A variable number of context parameters and a human readable description of this reply. */ template<typename... Args> void Send(LocalUser* user, const Command* command, const std::string& code, Args&&... args) { static_assert(sizeof...(Args) >= 1); ClientProtocol::Message msg(cmd.c_str(), ServerInstance->Config->GetServerName()); if (command) msg.PushParamRef(command->name); else msg.PushParam("*"); msg.PushParam(code); msg.PushParam(std::forward<Args>(args)...); SendInternal(user, msg); } /** * Sends a standard reply to the specified user if they have the specified cap * or a notice if they do not. * @param user The user to send the reply to. * @param cap The capability that determines the type of message to send. * @param command The command that the reply relates to. * @param code A machine readable code for this reply. * @param args A variable number of context parameters and a human readable description of this reply. */ template<typename... Args> void SendIfCap(LocalUser* user, const Cap::Capability* cap, const Command* command, const std::string& code, Args&&... args) { static_assert(sizeof...(Args) >= 1); if (cap && cap->IsEnabled(user)) Send(user, command, code, std::forward<Args>(args)...); else SendNoticeInternal(user, command, std::get<sizeof...(Args) - 1>(std::forward_as_tuple(args...))); } }; /** Sends a FAIL standard reply. */ class IRCv3::Replies::Fail final : public IRCv3::Replies::Reply { public: /** Initializes a new instance of the Fail class. * @param Creator The module which created this instance. */ Fail(Module* Creator) : Reply(Creator, "FAIL") { } }; /** Sends a NOTE standard reply. */ class IRCv3::Replies::Note final : public IRCv3::Replies::Reply { public: /** Initializes a new instance of the Note class. * @param Creator The module which created this instance. */ Note(Module* Creator) : Reply(Creator, "NOTE") { } }; /** Sends a WARN standard reply. */ class IRCv3::Replies::Warn final : public IRCv3::Replies::Reply { public: /** Initializes a new instance of the Warn class. * @param Creator The module which created this instance. */ Warn(Module* Creator) : Reply(Creator, "WARN") { } }; �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/include/modules/ircv3_servertime.h���������������������������������������������������0000664�0000000�0000000�00000006274�14771603147�0022117�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2018-2019, 2021-2023 Sadie Powell <sadie@witchery.services> * Copyright (C) 2018 Attila Molnar <attilamolnar@hush.com> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #pragma once #include "timeutils.h" namespace IRCv3 { namespace ServerTime { class Manager; class API; /** Format a unix timestamp into the format used by server-time. * @param secs UNIX timestamp to format. * @param millisecs Number of milliseconds to format. * @return Time in server-time format, as a string. */ inline std::string FormatTime(time_t secs, long millisecs = 0) { std::string timestr = Time::ToString(secs, "%Y-%m-%dT%H:%M:%S.Z", true); timestr.insert(20, INSP_FORMAT("{:03}", millisecs)); return timestr; } } } /** Implements manipulating the server time on messages. * A timestamp can be attached to outgoing client protocol messages to indicate the time when the message * was generated by us. If a message has server time attached then recipient clients who have negotiated * the appropriate protocol extension will receive it. */ class IRCv3::ServerTime::Manager : public DataProvider { protected: ClientProtocol::MessageTagProvider* tagprov; public: /** Constructor. * @param mod Module that owns the Manager. */ Manager(Module* mod) : DataProvider(mod, "servertimeapi") { } /** Set the server time on a message. * @param msg Message to set the time on. No-op if the message already has server time set. * @param ts Timestamp to set. */ void Set(ClientProtocol::Message& msg, const timespec& ts) { Set(msg, FormatTime(ts.tv_sec, ts.tv_nsec / 1'000'000)); } /** Set the server time on a message. * @param msg Message to set the time on. No-op if the message already has server time set. * @param secs UNIX timestamp to set. * @param millisecs Number of milliseconds to set. */ void Set(ClientProtocol::Message& msg, time_t secs, long millisecs = 0) { Set(msg, FormatTime(secs, millisecs)); } /** Set the server time on a message. * @param msg Message to set the time on. No-op if the message already has server time set. * @param timestr Timestamp to set. Must be in server time format. * The FormatTime() function can be used to convert unix timestamps into the required format. */ void Set(ClientProtocol::Message& msg, const std::string& timestr) { msg.AddTag("time", tagprov, timestr); } }; /** Server time API. Use this to access the Manager. */ class IRCv3::ServerTime::API final : public dynamic_reference_nocheck<Manager> { public: API(Module* mod) : dynamic_reference_nocheck<Manager>(mod, "servertimeapi") { } }; ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/include/modules/isupport.h�����������������������������������������������������������0000664�0000000�0000000�00000003051�14771603147�0020477�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2020-2023 Sadie Powell <sadie@witchery.services> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #pragma once namespace ISupport { class EventListener; class EventProvider; /* A mapping of ISUPPORT tokens to their values. */ typedef std::map<std::string, std::string, irc::insensitive_swo> TokenMap; } enum { // From draft-brocklesby-irc-isupport-03. RPL_ISUPPORT = 5, }; class ISupport::EventListener : public Events::ModuleEventListener { protected: EventListener(Module* mod, unsigned int eventprio = DefaultPriority) : ModuleEventListener(mod, "event/isupport", eventprio) { } public: virtual void OnBuildISupport(TokenMap& tokens) { } virtual void OnBuildClassISupport(const std::shared_ptr<ConnectClass>& klass, TokenMap& tokens) { } }; class ISupport::EventProvider final : public Events::ModuleEventProvider { public: EventProvider(Module* mod) : Events::ModuleEventProvider(mod, "event/isupport") { } }; ���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/include/modules/ldap.h���������������������������������������������������������������0000664�0000000�0000000�00000011325�14771603147�0017535�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2020-2022 Sadie Powell <sadie@witchery.services> * Copyright (C) 2013, 2015 Adam <Adam@anope.org> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #pragma once typedef int LDAPQuery; // XXX: This should be using ModuleException. class LDAPException final : public CoreException { public: LDAPException(const std::string& msg) : CoreException(msg) { } }; struct LDAPModification final { enum LDAPOperation { LDAP_ADD, LDAP_DEL, LDAP_REPLACE }; LDAPOperation op; std::string name; std::vector<std::string> values; }; typedef std::vector<LDAPModification> LDAPMods; struct LDAPAttributes final : public std::map<std::string, std::vector<std::string>> { size_t size(const std::string& attr) const { const std::vector<std::string>& array = this->getArray(attr); return array.size(); } const std::vector<std::string> keys() const { std::vector<std::string> k; for (const auto& [key, _] : *this) k.push_back(key); return k; } const std::string& get(const std::string& attr) const { const std::vector<std::string>& array = this->getArray(attr); if (array.empty()) throw LDAPException("Empty attribute " + attr + " in LDAPResult::get"); return array[0]; } const std::vector<std::string>& getArray(const std::string& attr) const { const_iterator it = this->find(attr); if (it == this->end()) throw LDAPException("Unknown attribute " + attr + " in LDAPResult::getArray"); return it->second; } }; enum QueryType { QUERY_UNKNOWN, QUERY_BIND, QUERY_SEARCH, QUERY_ADD, QUERY_DELETE, QUERY_MODIFY, QUERY_COMPARE }; struct LDAPResult final { std::vector<LDAPAttributes> messages; std::string error; QueryType type = QUERY_UNKNOWN; LDAPQuery id = -1; size_t size() const { return this->messages.size(); } bool empty() const { return this->messages.empty(); } const LDAPAttributes& get(size_t sz) const { if (sz >= this->messages.size()) throw LDAPException("Index out of range"); return this->messages[sz]; } const std::string& getError() const { return this->error; } }; class LDAPInterface { public: ModuleRef creator; LDAPInterface(Module* m) : creator(m) { } virtual ~LDAPInterface() = default; virtual void OnResult(const LDAPResult& r) = 0; virtual void OnError(const LDAPResult& err) = 0; }; class LDAPProvider : public DataProvider { public: LDAPProvider(Module* Creator, const std::string& Name) : DataProvider(Creator, Name) { } /** Attempt to bind to the LDAP server as a manager * @param i The LDAPInterface the result is sent to */ virtual void BindAsManager(LDAPInterface* i) = 0; /** Bind to LDAP * @param i The LDAPInterface the result is sent to * @param who The binddn * @param pass The password */ virtual void Bind(LDAPInterface* i, const std::string& who, const std::string& pass) = 0; /** Search ldap for the specified filter * @param i The LDAPInterface the result is sent to * @param base The base DN to search * @param filter The filter to apply */ virtual void Search(LDAPInterface* i, const std::string& base, const std::string& filter) = 0; /** Add an entry to LDAP * @param i The LDAPInterface the result is sent to * @param dn The dn of the entry to add * @param attributes The attributes */ virtual void Add(LDAPInterface* i, const std::string& dn, LDAPMods& attributes) = 0; /** Delete an entry from LDAP * @param i The LDAPInterface the result is sent to * @param dn The dn of the entry to delete */ virtual void Del(LDAPInterface* i, const std::string& dn) = 0; /** Modify an existing entry in LDAP * @param i The LDAPInterface the result is sent to * @param base The base DN to modify * @param attributes The attributes to modify */ virtual void Modify(LDAPInterface* i, const std::string& base, LDAPMods& attributes) = 0; /** Compare an attribute in LDAP with our value * @param i The LDAPInterface the result is sent to * @param dn DN to use for comparing * @param attr Attr of DN to compare with * @param val value to compare attr of dn */ virtual void Compare(LDAPInterface* i, const std::string& dn, const std::string& attr, const std::string& val) = 0; }; �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/include/modules/monitor.h������������������������������������������������������������0000664�0000000�0000000�00000004440�14771603147�0020304�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2022 delthas * Copyright (C) 2022 Sadie Powell <sadie@witchery.services> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #pragma once namespace Monitor { class APIBase; class API; class ForEachHandler; class WriteWatchersWithCap; } class Monitor::APIBase : public DataProvider { public: APIBase(Module* parent) : DataProvider(parent, "monitor") { } /** Runs the provided handler for all watchers of a user * @param user The user to check watchers for. * @param handler The handler to execute for each watcher of that event. * @param extended_only Whether to only run the handler for watchers using the extended-notify cap. */ virtual void ForEachWatcher(User* user, ForEachHandler& handler, bool extended_only = true) = 0; }; class Monitor::API final : public dynamic_reference<Monitor::APIBase> { public: API(Module* parent) : dynamic_reference<Monitor::APIBase>(parent, "monitor") { } }; class Monitor::ForEachHandler { public: /** Method to execute for each watcher of a user. * Derived classes must implement this. * @param user Current watcher of the user */ virtual void Execute(LocalUser* user) = 0; }; class Monitor::WriteWatchersWithCap : public Monitor::ForEachHandler { private: const Cap::Capability& cap; ClientProtocol::Event& ev; uint64_t sentid; void Execute(LocalUser* user) override { if (user->already_sent != sentid && cap.IsEnabled(user)) user->Send(ev); } public: WriteWatchersWithCap(Monitor::API& monitorapi, User* user, ClientProtocol::Event& event, const Cap::Capability& capability, uint64_t id) : cap(capability) , ev(event) , sentid(id) { if (monitorapi) monitorapi->ForEachWatcher(user, *this); } }; ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/include/modules/names.h��������������������������������������������������������������0000664�0000000�0000000�00000003101�14771603147�0017711�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2019, 2021, 2023 Sadie Powell <sadie@witchery.services> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #pragma once namespace Names { class EventListener; } class Names::EventListener : public Events::ModuleEventListener { public: EventListener(Module* mod, unsigned int eventprio = DefaultPriority) : ModuleEventListener(mod, "event/names", eventprio) { } /* Called for every item in a NAMES list. * @param issuer The user who initiated the NAMES request. * @param memb The channel membership of the user who is being considered for inclusion. * @param prefixes The prefix character(s) to show in front of the user's nickname. * @param nick The nickname of the user to show. * @return Return MOD_RES_PASSTHRU to allow the member to be displayed, MOD_RES_DENY to cause them to be * excluded from this NAMES list */ virtual ModResult OnNamesListItem(LocalUser* issuer, Membership* memb, std::string& prefixes, std::string& nick) = 0; }; ���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/include/modules/regex.h��������������������������������������������������������������0000664�0000000�0000000�00000020771�14771603147�0017734�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2013, 2020-2023, 2025 Sadie Powell <sadie@witchery.services> * Copyright (C) 2012 Robby <robby@chatbelgie.be> * Copyright (C) 2008 Thomas Stagner <aquanight@gmail.com> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #pragma once namespace Regex { class Engine; class EngineReference; class Exception; class MatchCollection; class Pattern; template<typename> class SimpleEngine; /** A list of matches that were captured by index. */ typedef std::vector<std::string> Captures; /** A list of matches that were captured by name. */ typedef insp::flat_map<std::string, std::string> NamedCaptures; /** A shared pointer to a regex pattern. */ typedef std::shared_ptr<Pattern> PatternPtr; /** The options to use when matching a pattern. */ enum PatternOptions : uint8_t { /** No special matching options apply. */ OPT_NONE = 0, /** The pattern is case insensitive. */ OPT_CASE_INSENSITIVE = 1, }; } /** The base class for regular expression engines. */ class Regex::Engine : public DataProvider { protected: /** Initializes a new instance of the Regex::Engine class. * @param Creator The module which created this instance. * @param Name The name of this regular expression engine. */ Engine(Module* Creator, const std::string& Name) : DataProvider(Creator, "regex/" + Name) { } public: /** Compiles a regular expression pattern. * @param pattern The pattern to compile. * @param options One or more options to use when matching the pattern. * @return A shared pointer to an instance of the Regex::Pattern class. */ virtual PatternPtr Create(const std::string& pattern, uint8_t options = Regex::OPT_NONE) const = 0; /** Compiles a regular expression from the human-writable form. * @param pattern The pattern to compile in the format /pattern/flags. * @return A shared pointer to an instance of the Regex::Pattern class. */ PatternPtr CreateHuman(const std::string& pattern) const; /** Retrieves the name of this regex engine. */ const char* GetName() const { return name.c_str() + 6; } }; /**The base class for simple regular expression engines. */ template<typename PatternClass> class Regex::SimpleEngine final : public Regex::Engine { public: /** @copydoc Regex::Engine::Engine */ SimpleEngine(Module* Creator, const std::string& Name) : Regex::Engine(Creator, Name) { } /** @copydoc Regex::Engine::Create */ PatternPtr Create(const std::string& pattern, uint8_t options) const override { return std::make_shared<PatternClass>(creator, pattern, options); } }; /** A dynamic reference to an instance of the Regex::Engine class. */ class Regex::EngineReference final : public dynamic_reference_nocheck<Engine> { public: /** Initializes a new instance of the Regex::EngineReference class. * @param Creator The module which created this instance. * @param Name The name of the regular expression engine to reference. */ EngineReference(Module* Creator, const std::string& Name = "") : dynamic_reference_nocheck<Engine>(Creator, Name.empty() ? "regex" : "regex/" + Name) { } /** Sets the name of the engine this reference is configured with. * @param engine The name of the engine to refer to. */ void SetEngine(const std::string& engine) { SetProvider(engine.empty() ? "regex" : "regex/" + engine); } }; /** The exception which is thrown when a regular expression fails to compile. */ class Regex::Exception final : public ModuleException { public: /** Initializes a new instance of the Regex::Exception class. * @param mod The module which caused this exception to be thrown. * @param regex A regular expression which failed to compile. * @param error The error which occurred whilst compiling the regular expression. */ Exception(const Module* mod, const std::string& regex, const std::string& error) : ModuleException(mod, INSP_FORMAT("Error in regex '{}': {}", regex, error)) { } /** Initializes a new instance of the Regex::Exception class. * @param mod The module which caused this exception to be thrown. * @param regex A regular expression which failed to compile. * @param error The error which occurred whilst compiling the regular expression. * @param offset The offset at which the errror occurred. */ Exception(const Module* mod, const std::string& regex, const std::string& error, size_t offset) : ModuleException(mod, INSP_FORMAT("Error in regex '{}' at offset {}: {}", regex, offset, error)) { } }; class Regex::MatchCollection { private: /** The substrings that were captured. */ const Captures captures; /** The substrings that were captured by name. */ const NamedCaptures namedcaptures; public: /** Initializes a new instance of the Regex::MatchCollection class. * @param c The substrings that were captured. * @param nc The substrings that were captured by name. */ MatchCollection(const Captures& c, const NamedCaptures& nc) : captures(c) , namedcaptures(nc) { } /** Retrieves a specific captured substring by index. * @param idx The index of the captured substring to return. * The requested captured substring or std::nullopt if it does not exist. */ const std::optional<std::string> GetCapture(size_t idx) const { return captures.size() > idx ? std::nullopt : std::make_optional(captures[idx]); } /** Retrieves the substrings that were captured. */ const Captures& GetCaptures() const { return captures; } /** Retrieves a specific captured substring by index. * @param name The name of the captured substring to return. * The requested captured substring or std::nullopt if it does not exist. */ const std::optional<std::string> GetNamedCapture(const std::string& name) const { auto capture = namedcaptures.find(name); return capture == namedcaptures.end() ? std::nullopt : std::make_optional(capture->second); } /** Retrieves the substrings that were captured by name. */ const NamedCaptures& GetNamedCaptures() const { return namedcaptures; } }; /** Represents a compiled regular expression pattern. */ class Regex::Pattern { private: /** The options used when matching this pattern. */ const uint8_t optionflags; /** The pattern as a string. */ const std::string patternstr; protected: /** Initializes a new instance of the Pattern class. * @param pattern The pattern as a string. * @param options The options used when matching this pattern. */ Pattern(const std::string& pattern, uint8_t options) : optionflags(options) , patternstr(pattern) { } public: /** Destroys an instance of the Pattern class. */ virtual ~Pattern() = default; /** Retrieves the options used when matching this pattern. */ uint8_t GetOptions() const { return optionflags; } /** Retrieves the pattern as a string. */ const std::string& GetPattern() const { return patternstr; } /** Attempts to match this pattern against the specified text. * @param text The text to match against. * @return If the text matched the pattern then true; otherwise, false. */ virtual bool IsMatch(const std::string& text) = 0; /** Attempts to extract this pattern's match groups from the specified text. * @param text The text to extract match groups from.. * @return If the text matched the pattern then a match collection; otherwise, std::nullopt. */ virtual std::optional<MatchCollection> Matches(const std::string& text) = 0; }; inline Regex::PatternPtr Regex::Engine::CreateHuman(const std::string& pattern) const { if (pattern.empty() || pattern[0] != '/') return Create(pattern, OPT_NONE); size_t end = pattern.find_last_not_of("Ii"); if (!end || end == std::string::npos || pattern[end] != '/') throw Exception(creator, pattern, "Regex patterns must be terminated with a '/'!"); uint8_t options = Regex::OPT_NONE; for (const auto flag : insp::iterator_range(pattern.begin() + end + 1, pattern.end())) { switch (flag) { case 'I': options &= ~OPT_CASE_INSENSITIVE; break; case 'i': options |= OPT_CASE_INSENSITIVE; break; } } return Create(pattern.substr(1, end - 1), options); } �������inspircd-4.7.0/include/modules/reload.h�������������������������������������������������������������0000664�0000000�0000000�00000005135�14771603147�0020065�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2021-2023 Sadie Powell <sadie@witchery.services> * Copyright (C) 2015 Attila Molnar <attilamolnar@hush.com> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #pragma once namespace ReloadModule { class EventListener; class DataKeeper; /** Container for data saved by modules before another module is reloaded. */ class CustomData { struct Data final { EventListener* handler; void* data; Data(EventListener* Handler, void* moddata) : handler(Handler) , data(moddata) { } }; typedef std::vector<Data> List; List list; public: /** Add data to the saved state of a module. * The provided handler's OnReloadModuleRestore() method will be called when the reload is done with the pointer * provided. * @param handler Handler for restoring the data * @param data Pointer to the data, will be passed back to the provided handler's OnReloadModuleRestore() after the * reload finishes */ void add(EventListener* handler, void* data) { list.emplace_back(handler, data); } friend class DataKeeper; }; class EventListener : public Events::ModuleEventListener { public: EventListener(Module* mod, unsigned int eventprio = DefaultPriority) : ModuleEventListener(mod, "event/reloadmodule", eventprio) { } /** Called whenever a module is about to be reloaded. Use this event to save data related to the module that you want * to be restored after the reload. * @param mod Module to be reloaded * @param cd CustomData instance that can store your data once. */ virtual void OnReloadModuleSave(Module* mod, CustomData& cd) = 0; /** Restore data after a reload. Only called if data was added in OnReloadModuleSave(). * @param mod Reloaded module, if NULL the reload failed and the module no longer exists * @param data Pointer that was passed to CustomData::add() in OnReloadModuleSave() at the time when the module's state * was saved */ virtual void OnReloadModuleRestore(Module* mod, void* data) = 0; }; } �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/include/modules/server.h�������������������������������������������������������������0000664�0000000�0000000�00000011007�14771603147�0020120�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2015 Attila Molnar <attilamolnar@hush.com> * Copyright (C) 2013, 2017-2019, 2022-2024 Sadie Powell <sadie@witchery.services> * Copyright (C) 2012 Robby <robby@chatbelgie.be> * Copyright (C) 2009 Daniel De Graaf <danieldg@inspircd.org> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #pragma once namespace ServerProtocol { class LinkEventListener; class MessageEventListener; class RouteEventListener; class SyncEventListener; } enum { // From ircu. RPL_MAP = 15, RPL_ENDMAP = 17, // InspIRCd-specific. RPL_MAPUSERS = 18, }; class ServerProtocol::LinkEventListener : public Events::ModuleEventListener { public: LinkEventListener(Module* mod, unsigned int eventprio = DefaultPriority) : ModuleEventListener(mod, "event/server-link", eventprio) { } /** Fired when a server has linked to the network. * @param server Server that recently linked. */ virtual void OnServerLink(const Server* server) { } /** Fired when a server has finished bursting. * @param server Server that recently finished bursting. */ virtual void OnServerBurst(const Server* server) { } /** Fired when a server splits * @param server Server that split * @param error Whether the server split because of an error. */ virtual void OnServerSplit(const Server* server, bool error) { } }; class ServerProtocol::MessageEventListener : public Events::ModuleEventListener { public: MessageEventListener(Module* mod, unsigned int eventprio = DefaultPriority) : ModuleEventListener(mod, "event/server-message", eventprio) { } /** Fired when a server message is being sent by a user. * @param source The user who sent the message. * @param name The name of the command which was sent. * @param tags The tags which will be sent with the message. */ virtual void OnBuildUserMessage(const User* source, const char* name, ClientProtocol::TagMap& tags) { } /** Fired when a server message is being sent by a server. * @param source The server who sent the message. * @param name The name of the command which was sent. * @param tags The tags which will be sent with the message. */ virtual void OnBuildServerMessage(const Server* source, const char* name, ClientProtocol::TagMap& tags) { } }; class ServerProtocol::RouteEventListener : public Events::ModuleEventListener { public: RouteEventListener(Module* mod, unsigned int eventprio = DefaultPriority) : ModuleEventListener(mod, "event/server-route", eventprio) { } /** Fired when a channel message is being routed across the network. * @param channel The channel which is having a message sent to it. * @param server The server which might have a message routed to it. * @return Either MOD_RES_ALLOW to always send the message to the server, MOD_RES_DENY to never * send the message to the server, or MOD_RES_PASSTHRU to not handle the event. */ virtual ModResult OnRouteMessage(const Channel* channel, const Server* server) { return MOD_RES_PASSTHRU; } }; class ServerProtocol::SyncEventListener : public Events::ModuleEventListener { public: SyncEventListener(Module* mod, unsigned int eventprio = DefaultPriority) : ModuleEventListener(mod, "event/server-sync", eventprio) { } /** Allows modules to synchronize user metadata during a netburst. This will * be called for every user visible on your side of the burst. * @param user The user being synchronized. * @param server The target of the burst. */ virtual void OnSyncUser(User* user, Server& server) { } /** Allows modules to synchronize channel metadata during a netburst. This will * be called for every channel visible on your side of the burst. * @param chan The channel being synchronized. * @param server The target of the burst. */ virtual void OnSyncChannel(Channel* chan, Server& server) { } /** Allows modules to synchronize network metadata during a netburst. * @param server The target of the burst. */ virtual void OnSyncNetwork(Server& server) { } }; �������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/include/modules/shun.h���������������������������������������������������������������0000664�0000000�0000000�00000004106�14771603147�0017571�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2018, 2021, 2023 Sadie Powell <sadie@witchery.services> * Copyright (C) 2017 B00mX0r <b00mx0r@aureus.pw> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #pragma once #include "xline.h" /** Shun class */ class Shun final : public XLine { public: /** Create a Shun. * @param s_time The set time * @param d The duration of the xline * @param src The sender of the xline * @param re The reason of the xline * @param shunmask Mask to match */ Shun(time_t s_time, unsigned long d, const std::string& src, const std::string& re, const std::string& shunmask) : XLine(s_time, d, src, re, "SHUN") , matchtext(shunmask) { } bool Matches(User* u) const override { LocalUser* lu = IS_LOCAL(u); if (lu && lu->exempt) return false; // Try to match nick!duser@dhost or nick!ruser@rhost if (InspIRCd::Match(u->GetMask(), matchtext) || InspIRCd::Match(u->GetRealMask(), matchtext)) return true; // Try to match nick!ruser@address const std::string addressmask = INSP_FORMAT("{}!{}", u->nick, u->GetUserAddress()); if (InspIRCd::Match(addressmask, matchtext)) return true; // Try to match address if (InspIRCd::MatchCIDR(u->GetAddress(), matchtext, ascii_case_insensitive_map)) return true; return false; } bool Matches(const std::string& str) const override { return (matchtext == str); } const std::string& Displayable() const override { return matchtext; } private: /** Matching mask **/ std::string matchtext; }; ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/include/modules/sql.h����������������������������������������������������������������0000664�0000000�0000000�00000015664�14771603147�0017426�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2015 Daniel Vassdal <shutter@canternet.org> * Copyright (C) 2013, 2017-2019, 2021-2022, 2024 Sadie Powell <sadie@witchery.services> * Copyright (C) 2012 Robby <robby@chatbelgie.be> * Copyright (C) 2010 Daniel De Graaf <danieldg@inspircd.org> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #pragma once namespace SQL { class Error; class Provider; class Query; class Result; /** A list of parameter replacement values. */ typedef std::vector<std::string> ParamList; /** A map of parameter replacement values. */ typedef std::map<std::string, std::string> ParamMap; /** A single SQL field. */ typedef std::optional<std::string> Field; /** A list of SQL fields from a specific row. */ typedef std::vector<Field> Row; /** An enumeration of possible error codes. */ enum ErrorCode { /** No error has occurred. */ SUCCESS, /** The database identifier is invalid. */ BAD_DBID, /** The database connection has failed. */ BAD_CONN, /** Executing the query failed. */ QSEND_FAIL, /** Reading the response failed. */ QREPLY_FAIL }; /** Populates a parameter map with information about a user. * @param user The user to collect information from. * @param userinfo The map to populate. */ void PopulateUserInfo(User* user, ParamMap& userinfo); } /** Represents the result of an SQL query. */ class SQL::Result : public Cullable { public: /** * Return the number of rows in the result. * * Note that if you have performed an INSERT or UPDATE query or other * query which will not return rows, this will return the number of * affected rows. In this case you SHOULD NEVER access any of the result * set rows, as there aren't any! * @returns Number of rows in the result set. */ virtual int Rows() = 0; /** Retrieves the next available row from the database. * @param result A list to store the fields from this row in. * @return True if a row could be retrieved; otherwise, false. */ virtual bool GetRow(Row& result) = 0; /** Retrieves a list of SQL columns in the result. * @param result A reference to the vector to store column names in. */ virtual void GetCols(std::vector<std::string>& result) = 0; /** * Check if there's a column with the specified name in the result * * @param column The column name. * @param index The place to store the column index if it exists. * @returns If the column exists then true; otherwise, false. */ virtual bool HasColumn(const std::string& column, size_t& index) = 0; }; /** SQL::Error holds the error state of a request. * The error string varies from database software to database software * and should be used to display informational error messages to users. */ class SQL::Error final { private: /** The custom error message if one has been specified. */ const std::string message; public: /** The code which represents this error. */ const ErrorCode code; /** Initialize an SQL::Error from an error code. * @param c A code which represents this error. */ Error(ErrorCode c) : code(c) { } /** Initialize an SQL::Error from an error code and a custom error message. * @param c A code which represents this error. * @param m A custom error message. */ Error(ErrorCode c, const std::string& m) : message(m) , code(c) { } /** Retrieves the error message. */ const char* ToString() const { if (!message.empty()) return message.c_str(); switch (code) { case BAD_DBID: return "Invalid database identifier"; case BAD_CONN: return "Invalid connection"; case QSEND_FAIL: return "Sending query failed"; case QREPLY_FAIL: return "Getting query result failed"; default: return "Unknown error"; } } }; /** * Object representing an SQL query. This should be allocated on the heap and * passed to an SQL::Provider, which will free it when the query is complete or * when the querying module is unloaded. * * You should store whatever information is needed to have the callbacks work in * this object (UID of user, channel name, etc). */ class SQL::Query : public Cullable { protected: /** Creates a new SQL query. */ Query(Module* Creator) : creator(Creator) { } public: const ModuleRef creator; /** Called when an SQL error happens. * @param error The error that occurred. */ virtual void OnError(const SQL::Error& error) = 0; /** Called when a SQL result is received. * @param result The result of the SQL query. */ virtual void OnResult(SQL::Result& result) = 0; }; /** * Provider object for SQL servers */ class SQL::Provider : public DataProvider { private: /** The name of the database tag in the config. */ const std::string dbid; public: Provider(Module* Creator, const std::string& Name) : DataProvider(Creator, "SQL/" + Name) , dbid(Name) { } /** Retrieves the name of the database tag in the config. */ const std::string& GetId() const { return dbid; } /** Submit an asynchronous SQL query. * @param callback The result reporting point * @param query The hardcoded query string. If you have parameters to substitute, see below. */ virtual void Submit(Query* callback, const std::string& query) = 0; /** Submit an asynchronous SQL query. * @param callback The result reporting point * @param format The simple parameterized query string ('?' parameters) * @param p Parameters to fill in for the '?' entries */ virtual void Submit(Query* callback, const std::string& format, const SQL::ParamList& p) = 0; /** Submit an asynchronous SQL query. * @param callback The result reporting point * @param format The parameterized query string ('$name' parameters) * @param p Parameters to fill in for the '$name' entries */ virtual void Submit(Query* callback, const std::string& format, const ParamMap& p) = 0; }; inline void SQL::PopulateUserInfo(User* user, ParamMap& userinfo) { userinfo.insert({ { "address", user->GetAddress() }, { "dhost", user->GetDisplayedHost() }, { "duser", user->GetDisplayedUser() }, { "host", user->GetRealHost() }, { "nick", user->nick }, { "real", user->GetRealName() }, { "server", user->server->GetName() }, { "sid", user->server->GetId() }, { "user", user->GetRealUser() }, { "uuid", user->uuid }, }); // Deprecated keys. userinfo.insert({ { "ident", userinfo["user"] }, { "ip" , userinfo["address"] }, }); } ����������������������������������������������������������������������������inspircd-4.7.0/include/modules/ssl.h����������������������������������������������������������������0000664�0000000�0000000�00000023730�14771603147�0017421�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2020 Matt Schatz <genius3000@g3k.solutions> * Copyright (C) 2019 B00mX0r <b00mx0r@aureus.pw> * Copyright (C) 2018 Dylan Frank <b00mx0r@aureus.pw> * Copyright (C) 2013, 2017-2024 Sadie Powell <sadie@witchery.services> * Copyright (C) 2013, 2015-2016 Attila Molnar <attilamolnar@hush.com> * Copyright (C) 2012 Robby <robby@chatbelgie.be> * Copyright (C) 2009-2010 Daniel De Graaf <danieldg@inspircd.org> * Copyright (C) 2007 Dennis Friis <peavey@inspircd.org> * Copyright (C) 2006 Craig Edwards <brain@inspircd.org> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #pragma once #include "iohook.h" /** ssl_cert is a class which abstracts TLS certificate * and key information. * * Because gnutls and openssl represent key information in * wildly different ways, this class allows it to be accessed * in a unified manner. These classes are attached to ssl- * connected local users using SSLCertExt */ class ssl_cert final : public refcountbase { public: std::string dn; std::string issuer; std::string error; std::vector<std::string> fingerprints; bool trusted = false; bool invalid = true; bool unknownsigner = true; bool revoked = false; time_t activation = 0; time_t expiration = 0; /** Get certificate distinguished name * @return Certificate DN */ const std::string& GetDN() const { return dn; } /** Get Certificate issuer * @return Certificate issuer */ const std::string& GetIssuer() const { return issuer; } /** Get error string if an error has occurred * @return The error associated with this users certificate, * or an empty string if there is no error. */ const std::string& GetError() const { return error; } /** Get primary fingerprint. * @return The primary fingerprint as a hex string. */ std::string GetFingerprint() const { return fingerprints.empty() ? "" : fingerprints.front(); } /** Get all fingerprints. * @return All fingerprints as a hex string. */ const std::vector<std::string>& GetFingerprints() const { return fingerprints; } /** Get trust status * @return True if this is a trusted certificate * (the certificate chain validates) */ bool IsTrusted() const { return trusted; } /** Get validity status * @return True if the certificate itself is * correctly formed. */ bool IsInvalid() const { return invalid; } /** Get signer status * @return True if the certificate appears to be * self-signed. */ bool IsUnknownSigner() const { return unknownsigner; } /** Get revocation status. * @return True if the certificate is revoked. * Note that this only works properly for GnuTLS * right now. */ bool IsRevoked() const { return revoked; } /** Get certificate usability * @return True if the certificate is not expired nor revoked */ bool IsUsable() const { return !invalid && !revoked && error.empty(); } /** Get CA trust status * @return True if the certificate is issued by a CA * and valid. */ bool IsCAVerified() const { return IsUsable() && trusted && !unknownsigner; } /** Retrieves the client certificate activation time. * @return The time the client certificate was activated or 0 on error. */ time_t GetActivationTime() const { return activation; } /** Retrieves the client certificate expiration time. * @return The time the client certificate will expire or 0 on error. */ time_t GetExpirationTime() const { return expiration; } }; /** I/O hook provider for TLS modules. */ class SSLIOHookProvider : public IOHookProvider { public: SSLIOHookProvider(Module* mod, const std::string& Name) : IOHookProvider(mod, "ssl/" + Name, IOH_SSL) { } }; class SSLIOHook : public IOHook { protected: /** An enumeration of possible TLS socket states. */ enum Status { /** The TLS socket has just been opened or has been closed. */ STATUS_NONE, /** The TLS socket is currently handshaking. */ STATUS_HANDSHAKING, /** The TLS handshake has completed and data can be sent. */ STATUS_OPEN }; /** Peer TLS certificate, set by the TLS module */ reference<ssl_cert> certificate; /** The status of the TLS connection. */ Status status = STATUS_NONE; /** Reduce elements in a send queue by appending later elements to the first element until there are no more * elements to append or a desired length is reached * @param sendq SendQ to work on * @param targetsize Target size of the front element */ static void FlattenSendQueue(StreamSocket::SendQueue& sendq, size_t targetsize) { if ((sendq.size() <= 1) || (sendq.front().length() >= targetsize)) return; // Avoid multiple repeated TLS encryption invocations // This adds a single copy of the queue, but avoids // much more overhead in terms of system calls invoked // by an IOHook. std::string tmp; tmp.reserve(std::min(targetsize, sendq.bytes())+1); do { tmp.append(sendq.front()); sendq.pop_front(); } while (!sendq.empty() && tmp.length() < targetsize); sendq.push_front(tmp); } public: static SSLIOHook* IsSSL(StreamSocket* sock) { IOHook* const lasthook = sock->GetLastHook(); if (lasthook && (lasthook->prov->type == IOHookProvider::IOH_SSL)) return static_cast<SSLIOHook*>(lasthook); return nullptr; } SSLIOHook(const std::shared_ptr<IOHookProvider>& hookprov) : IOHook(hookprov) { } /** * Get the certificate sent by this peer * @return The TLS certificate sent by the peer, NULL if no cert was sent */ virtual ssl_cert* GetCertificate() const { return certificate; } /** * Get the fingerprint of the peer's certificate * @return The fingerprint of the TLS client certificate sent by the peer, * empty if no cert was sent */ virtual std::string GetFingerprint() const { ssl_cert* cert = GetCertificate(); if (cert && cert->IsUsable()) return cert->GetFingerprint(); return ""; } /** * Get the ciphersuite negotiated with the peer * @param out String where the ciphersuite string will be appended to */ virtual void GetCiphersuite(std::string& out) const = 0; /** Retrieves the name of the TLS connection which is sent via SNI. * @param out String that the server name will be appended to. * returns True if the server name was retrieved; otherwise, false. */ virtual bool GetServerName(std::string& out) const = 0; /** @copydoc IOHook::IsHookReady */ bool IsHookReady() const override { return status == STATUS_OPEN; } }; /** Helper functions for obtaining TLS client certificates and key fingerprints * from StreamSockets */ class SSLClientCert final { public: /** * Get the client certificate from a socket * @param sock The socket to get the certificate from, the socket does not have to use TLS * @return The TLS client certificate information, NULL if the peer is not using TLS */ static ssl_cert* GetCertificate(StreamSocket* sock) { SSLIOHook* ssliohook = SSLIOHook::IsSSL(sock); if (!ssliohook) return nullptr; return ssliohook->GetCertificate(); } /** * Get the fingerprint of a client certificate from a socket * @param sock The socket to get the certificate fingerprint from, the * socket does not have to use TLS * @return The key fingerprint from the TLS certificate sent by the peer, * empty if no cert was sent or the peer is not using TLS */ static std::string GetFingerprint(StreamSocket* sock) { ssl_cert* cert = SSLClientCert::GetCertificate(sock); if (cert) return cert->GetFingerprint(); return ""; } }; class UserCertificateAPIBase : public DataProvider { public: UserCertificateAPIBase(Module* parent) : DataProvider(parent, "m_sslinfo_api") { } /** Get the TLS certificate of a user * @param user The user whose certificate to get, user may be remote * @return The TLS certificate of the user or NULL if the user is not using TLS */ virtual ssl_cert* GetCertificate(User* user) = 0; /** Determines whether the specified user is connected securely. * @return True if the user is connected securely; otherwise, false. */ virtual bool IsSecure(User* user) = 0; /** Set the TLS certificate of a user. * @param user The user whose certificate to set. * @param cert The TLS certificate to set for the user. */ virtual void SetCertificate(User* user, ssl_cert* cert) = 0; /** Get the primary fingerprint from a user's certificate * @param user The user whose primary fingerprint to get. * @return The primary fingerprint from the user's TLS certificate or an empty string * if the user is not using TLS or did not provide a client certificate */ std::string GetFingerprint(User* user) { ssl_cert* cert = GetCertificate(user); if (cert) return cert->GetFingerprint(); return ""; } /** Get all fingerprint from a user's certificate * @param user The user whose fingerprint to get. * @return The fingerprint from the user's TLS certificate or an empty string * if the user is not using TLS or did not provide a client certificate */ std::vector<std::string> GetFingerprints(User* user) { ssl_cert* cert = GetCertificate(user); if (cert) return cert->GetFingerprints(); return {}; } }; /** API implemented by m_sslinfo that allows modules to retrieve the TLS certificate * information of local and remote users. It can also be used to find out whether a * user is using TLS or not. */ class UserCertificateAPI final : public dynamic_reference<UserCertificateAPIBase> { public: UserCertificateAPI(Module* parent) : dynamic_reference<UserCertificateAPIBase>(parent, "m_sslinfo_api") { } }; ����������������������������������������inspircd-4.7.0/include/modules/stats.h��������������������������������������������������������������0000664�0000000�0000000�00000010675�14771603147�0017762�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2018-2019, 2021-2023 Sadie Powell <sadie@witchery.services> * Copyright (C) 2016 Attila Molnar <attilamolnar@hush.com> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #pragma once namespace Stats { class Context; class EventListener; class Row; } enum { // From aircd. RPL_STATS = 210, }; class Stats::EventListener : public Events::ModuleEventListener { public: EventListener(Module* mod, unsigned int eventprio = DefaultPriority) : ModuleEventListener(mod, "event/stats", eventprio) { } /** Called when the STATS command is executed. * @param stats Context of the /STATS request, contains requesting user, list of answer rows etc. * @return MOD_RES_DENY if the stats request has been fulfilled. Otherwise, MOD_RES_PASSTHRU. */ virtual ModResult OnStats(Stats::Context& stats) = 0; }; class Stats::Row final : public Numeric::Numeric { public: Row(unsigned int num) : Numeric(num) { } /** Attaches a stats tag to the response. * @param stats The stats request that is being responded to. * @param name The name of the stats tag. Will be prefixed with `inspircd.org/stats-`. * @param value The value of the stats tag. Will be escaped before attaching. */ inline Row& AddTag(Stats::Context& stats, const std::string& name, const std::string& value); /** Attaches multiple tags to the response. * @param stats The stats request that is being responded to. * @param tags An list of tags to attach. See AddTag for how this will be processed. */ inline Row& AddTags(Stats::Context& stats, std::initializer_list<std::pair<std::string, std::string>>&& tags) { for (const auto& [name, value] : tags) AddTag(stats, name, value); return *this; } }; class Stats::Context final { /** Source user of the STATS request */ User* const source; /** The provider for inspircd.org/stats-* tags. */ ClientProtocol::MessageTagProvider& tagprov; /** List of reply rows */ std::vector<Row> rows; /** Symbol indicating the type of this STATS request (usually a letter) */ const char symbol; public: /** Constructor * @param prov Provider for the inspircd.org/stats-* tags. * @param src Source user of the STATS request, can be a local or remote user * @param sym Symbol (letter) indicating the type of the request */ Context(ClientProtocol::MessageTagProvider& prov, User* src, char sym) : source(src) , tagprov(prov) , symbol(sym) { } /** Retrieves the provider of inspircd.org/stats-* tags. */ auto& GetTagProvider() const { return tagprov; } /** Get the source user of the STATS request * @return Source user of the STATS request */ User* GetSource() const { return source; } /** Get the list of reply rows * @return List of rows generated as reply for the request */ const std::vector<Row>& GetRows() const { return rows; } std::vector<Row>& GetRows() { return rows; } /** Get the symbol (letter) indicating what type of STATS was requested * @return Symbol specified by the requesting user */ char GetSymbol() const { return symbol; } /** Add a row to the reply list * @param row Reply to add */ Row& AddRow(const Row& row) { rows.push_back(row); return rows.back(); } template <typename... Param> Row& AddRow(unsigned int numeric, Param&&... p) { Row n(numeric); n.push(std::forward<Param>(p)...); return AddRow(n); } /** Adds a row to the stats response using a generic numeric. * @param p One or more fields to add to the response. */ template <typename... Param> Row& AddGenericRow(Param&&... p) { Row n(RPL_STATS); n.push(GetSymbol()); n.push(std::forward<Param>(p)...); return AddRow(n); } }; inline Stats::Row& Stats::Row::AddTag(Stats::Context& stats, const std::string& name, const std::string& value) { Numeric::Numeric::AddTag("inspircd.org/stats-" + name, &stats.GetTagProvider(), ClientProtocol::Message::EscapeTag(value)); return *this; } �������������������������������������������������������������������inspircd-4.7.0/include/modules/webirc.h�������������������������������������������������������������0000664�0000000�0000000�00000002222�14771603147�0020064�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2017, 2023 Sadie Powell <sadie@witchery.services> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #pragma once namespace WebIRC { class EventListener; typedef insp::flat_map<std::string, std::string, irc::insensitive_swo> FlagMap; } class WebIRC::EventListener : public Events::ModuleEventListener { protected: EventListener(Module* mod, unsigned int eventprio = DefaultPriority) : ModuleEventListener(mod, "event/webirc", eventprio) { } public: virtual void OnWebIRCAuth(LocalUser* user, const FlagMap* flags) = 0; }; ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/include/modules/who.h����������������������������������������������������������������0000664�0000000�0000000�00000011060�14771603147�0017406�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2019 linuxdaemon <linuxdaemon.irc@gmail.com> * Copyright (C) 2018, 2020-2023 Sadie Powell <sadie@witchery.services> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #pragma once namespace Who { class EventListener; class MatchEventListener; class VisibleEventListener; class Request; } class Who::EventListener : public Events::ModuleEventListener { public: EventListener(Module* mod, unsigned int eventprio = DefaultPriority) : ModuleEventListener(mod, "event/who", eventprio) { } /** Called when a result from WHO is about to be queued. * @param request Details about the WHO request which caused this response. * @param source The user who initiated this WHO request. * @param user The user that this line of the WHO request is about. * @param memb The channel membership of the user or the first visible membership if not targeted at a channel. * @param numeric The numeric which will be sent in response to the request. * @return MOD_RES_ALLOW to explicitly allow the response, MOD_RES_DENY to explicitly deny the * response, or MOD_RES_PASSTHRU to let another module handle the event. */ virtual ModResult OnWhoLine(const Request& request, LocalUser* source, User* user, Membership* memb, Numeric::Numeric& numeric) = 0; }; class Who::MatchEventListener : public Events::ModuleEventListener { public: MatchEventListener(Module* mod, unsigned int eventprio = DefaultPriority) : ModuleEventListener(mod, "event/who-match", eventprio) { } /** Called when a WHO request needs to check if a user matches it. * @param request Details about the WHO request which caused this match attempt. * @param source The user who initiated this WHO request. * @param user The user to attempt to match the WHO request against. * @return MOD_RES_ALLOW to explicitly allow the match, MOD_RES_DENY to explicitly deny the * match, or MOD_RES_PASSTHRU to let another module handle the event. */ virtual ModResult OnWhoMatch(const Request& request, LocalUser* source, User* user) = 0; }; class Who::VisibleEventListener : public Events::ModuleEventListener { public: VisibleEventListener(Module* mod, unsigned int eventprio = DefaultPriority) : ModuleEventListener(mod, "event/who-visible", eventprio) { } /** Called when a WHO request needs to check if a channel is visible. * @param request Details about the WHO request which caused this match attempt. * @param source The user who initiated this WHO request. * @param memb The channel membership of the user to check the visibility of. * @return MOD_RES_ALLOW to explicitly allow the match, MOD_RES_DENY to explicitly deny the * match, or MOD_RES_PASSTHRU to let another module handle the event. */ virtual ModResult OnWhoVisible(const Request& request, LocalUser* source, Membership* memb) = 0; }; class Who::Request { public: /** The flags for matching users to include. */ CharState flags; /** Whether we are matching using a wildcard or a flag. */ bool fuzzy_match = false; /** The text to match against. */ std::string matchtext; /** If the target was a channel then the matched channel */ Channel* matchchan = nullptr; /** The WHO/WHOX responses we will send to the source. */ std::vector<Numeric::Numeric> results; /** Whether the source requested a WHOX response. */ bool whox = false; /** The fields to include in the WHOX response. */ CharState whox_fields; /** A user specified label for the WHOX response. */ std::string whox_querytype; /** Get the index in the response parameters for the different data fields * * The fields 'r' (realname) and 'd' (hops) will always be missing in a non-WHOX * query, because WHOX splits them to 2 fields, where old WHO has them as one. * * @param flag The field name to look for * @param out The index will be stored in this value * @return True if the field is available, false otherwise */ virtual bool GetFieldIndex(char flag, size_t& out) const = 0; protected: Request() = default; }; ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/include/modules/whois.h��������������������������������������������������������������0000664�0000000�0000000�00000007412�14771603147�0017750�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2021 Val Lorentz <progval+git@progval.net> * Copyright (C) 2019, 2021-2023 Sadie Powell <sadie@witchery.services> * Copyright (C) 2015-2016 Attila Molnar <attilamolnar@hush.com> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #pragma once namespace Whois { class EventListener; class LineEventListener; class Context; } enum { // InspIRCd-specific. RPL_WHOISCOUNTRY = 344, RPL_WHOISGATEWAY = 350, RPL_CHANNELSMSG = 651, // From ircu. RPL_WHOISACCOUNT = 330, // From oftc-hybrid. RPL_WHOISCERTFP = 276, // From ircd-hybrid. RPL_WHOISACTUALLY = 338, // From RFC 1459. RPL_WHOISUSER = 311, RPL_WHOISSERVER = 312, RPL_WHOISOPERATOR = 313, RPL_WHOISIDLE = 317, RPL_ENDOFWHOIS = 318, RPL_WHOISCHANNELS = 319, // From UnrealIRCd. RPL_WHOISREGNICK = 307, RPL_WHOISHELPOP = 310, RPL_WHOISSPECIAL = 320, RPL_WHOISBOT = 335, RPL_WHOISMODES = 379, RPL_WHOISSECURE = 671 }; class Whois::EventListener : public Events::ModuleEventListener { public: EventListener(Module* mod, unsigned int eventprio = DefaultPriority) : ModuleEventListener(mod, "event/whois", eventprio) { } /** Called whenever a /WHOIS is performed by a local user. * @param whois Whois context, can be used to send numerics */ virtual void OnWhois(Context& whois) = 0; }; class Whois::LineEventListener : public Events::ModuleEventListener { public: LineEventListener(Module* mod, unsigned int eventprio = DefaultPriority) : ModuleEventListener(mod, "event/whoisline", eventprio) { } /** Called whenever a line of WHOIS output is sent to a user. * You may change the numeric and the text of the output by changing * the values numeric and text, but you cannot change the user the * numeric is sent to. * @param whois Whois context, can be used to send numerics * @param numeric Numeric being sent * @return MOD_RES_DENY to drop the line completely so that the user does not * receive it, or MOD_RES_PASSTHRU to allow the line to be sent. */ virtual ModResult OnWhoisLine(Context& whois, Numeric::Numeric& numeric) = 0; }; class Whois::Context { protected: /** User doing the WHOIS */ LocalUser* const source; /** User being WHOISed */ User* const target; public: Context(LocalUser* sourceuser, User* targetuser) : source(sourceuser) , target(targetuser) { } /** Returns true if the user is /WHOISing himself * @return True if whois source is the same user as the whois target, false if they are different users */ bool IsSelfWhois() const { return (source == target); } /** Returns the LocalUser who has done the /WHOIS * @return LocalUser doing the /WHOIS */ LocalUser* GetSource() const { return source; } /** Returns the target of the /WHOIS * @return User who was /WHOIS'd */ User* GetTarget() const { return target; } /** Send a line of WHOIS data to the source of the WHOIS */ template <typename... Param> void SendLine(unsigned int numeric, Param&&... p) { Numeric::Numeric n(numeric); n.push(target->nick); n.push(std::forward<Param>(p)...); SendLine(n); } /** Send a line of WHOIS data to the source of the WHOIS * @param numeric Numeric to send */ virtual void SendLine(Numeric::Numeric& numeric) = 0; }; ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/include/numeric.h��������������������������������������������������������������������0000664�0000000�0000000�00000011372�14771603147�0016611�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2018-2022, 2024-2025 Sadie Powell <sadie@witchery.services> * Copyright (C) 2016 Attila Molnar <attilamolnar@hush.com> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #pragma once // These numerics are used in multiple source files. enum { // From RFC 1459 RPL_LUSEROP = 252, RPL_AWAY = 301, RPL_LISTSTART = 321, RPL_LIST = 322, RPL_LISTEND = 323, RPL_VERSION = 351, RPL_LINKS = 364, RPL_ENDOFLINKS = 365, RPL_TIME = 391, ERR_NOSUCHNICK = 401, ERR_NOSUCHCHANNEL = 403, ERR_NORECIPIENT = 411, ERR_NOTEXTTOSEND = 412, ERR_UNKNOWNCOMMAND = 421, ERR_NONICKNAMEGIVEN = 431, ERR_ERRONEUSNICKNAME = 432, ERR_NICKNAMEINUSE = 433, ERR_USERNOTINCHANNEL = 441, ERR_NOTONCHANNEL = 442, ERR_NOTREGISTERED = 451, ERR_NEEDMOREPARAMS = 461, ERR_YOUREBANNEDCREEP = 465, ERR_UNKNOWNMODE = 472, ERR_BANNEDFROMCHAN = 474, ERR_BADCHANMASK = 476, ERR_NOPRIVILEGES = 481, ERR_CHANOPRIVSNEEDED = 482, // From RFC 2812. ERR_NOSUCHSERVER = 402, ERR_NOSUCHSERVICE = 408, ERR_UNAVAILRESOURCE = 437, ERR_BANLISTFULL = 478, ERR_RESTRICTED = 484, // From irc2? RPL_SAVENICK = 43, // From ircu. RPL_YOURDISPLAYEDHOST = 396, // From UnrealIRCd. ERR_CANTCHANGENICK = 447, // InspIRCd-specific. ERR_UNKNOWNSNOMASK = 501, RPL_SYNTAX = 650, ERR_LISTMODEALREADYSET = 697, ERR_LISTMODENOTSET = 698, ERR_CANTUNLOADMODULE = 972, RPL_UNLOADEDMODULE = 973, ERR_CANTLOADMODULE = 974, RPL_LOADEDMODULE = 975, }; namespace Numeric { class Numeric; } class Numeric::Numeric { /** Numeric number */ unsigned int numeric; /** Parameters of the numeric */ CommandBase::Params params; /** Source server of the numeric, if NULL (the default) then it is the local server */ Server* sourceserver = nullptr; public: /** Constructor * @param num Numeric number (RPL_*, ERR_*) */ Numeric(unsigned int num) : numeric(num) { } /** Add a tag. * @param tagname Raw name of the tag to use in the protocol. * @param tagprov Provider of the tag. * @param val Tag value. If empty no value will be sent with the tag. * @param tagdata Tag provider specific data, will be passed to MessageTagProvider::ShouldSendTag(). Optional, defaults to NULL. */ Numeric& AddTag(const std::string& tagname, ClientProtocol::MessageTagProvider* tagprov, const std::string& val, void* tagdata = nullptr) { params.GetTags().emplace(tagname, ClientProtocol::MessageTagData(tagprov, val, tagdata)); return *this; } /** Add all tags in a TagMap to the tags in this message. Existing tags will not be overwritten. * @param newtags New tags to add. */ Numeric& AddTags(const ClientProtocol::TagMap& newtags) { params.GetTags().insert(newtags.begin(), newtags.end()); return *this; } /** Converts the given arguments to a string and adds them to the numeric. * @param args One or more arguments to the numeric. */ template <typename... Args> Numeric& push(Args&&... args) { (params.push_back(ConvToStr(args)), ...); return *this; } /** Formats the string with the specified arguments and adds them to the numeric. * @param text A format string to format and then push. * @param args One or more arguments to format the string with. */ template <typename... Args> Numeric& push_fmt(const char* text, Args&&... args) { push(fmt::vformat(text, fmt::make_format_args(args...))); return *this; } /** Set the source server of the numeric. The source server defaults to the local server. * @param server Server to set as source */ void SetServer(Server* server) { sourceserver = server; } /** Get the source server of the numeric * @return Source server or NULL if the source is the local server */ Server* GetServer() const { return sourceserver; } /** Get the number of the numeric as an unsigned integer * @return Numeric number as an unsigned integer */ unsigned int GetNumeric() const { return numeric; } /** Get the parameters of the numeric * @return Parameters of the numeric as a const vector of strings */ const CommandBase::Params& GetParams() const { return params; } /** Get the parameters of the numeric * @return Parameters of the numeric as a vector of strings */ CommandBase::Params& GetParams() { return params; } }; ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/include/numericbuilder.h�������������������������������������������������������������0000664�0000000�0000000�00000011177�14771603147�0020163�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2020-2022 Sadie Powell <sadie@witchery.services> * Copyright (C) 2015-2016 Attila Molnar <attilamolnar@hush.com> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #pragma once namespace Numeric { class WriteNumericSink; class WriteRemoteNumericSink; template <char Sep, bool SendEmpty, typename Sink> class GenericBuilder; template <char Sep = ',', bool SendEmpty = false> class Builder; template <unsigned int NumStaticParams, bool SendEmpty, typename Sink> class GenericParamBuilder; template <unsigned int NumStaticParams, bool SendEmpty = false> class ParamBuilder; } class Numeric::WriteNumericSink final { LocalUser* const user; public: WriteNumericSink(LocalUser* u) : user(u) { } void operator()(Numeric& numeric) const { user->WriteNumeric(numeric); } }; class Numeric::WriteRemoteNumericSink final { User* const user; public: WriteRemoteNumericSink(User* u) : user(u) { } void operator()(Numeric& numeric) const { user->WriteRemoteNumeric(numeric); } }; template <char Sep, bool SendEmpty, typename Sink> class Numeric::GenericBuilder { Sink sink; Numeric numeric; const std::string::size_type max; bool HasRoom(const std::string::size_type additional) const { return (numeric.GetParams().back().size() + additional <= max); } public: GenericBuilder(Sink s, unsigned int num, bool addparam = true, size_t additionalsize = 0) : sink(s) , numeric(num) , max(ServerInstance->Config->Limits.MaxLine - ServerInstance->Config->GetServerName().size() - additionalsize - 10) { if (addparam) numeric.push(std::string()); } Numeric& GetNumeric() { return numeric; } void Add(const std::string& entry) { if (!HasRoom(entry.size())) Flush(); numeric.GetParams().back().append(entry).push_back(Sep); } void Add(const std::string& entry1, const std::string& entry2) { if (!HasRoom(entry1.size() + entry2.size())) Flush(); numeric.GetParams().back().append(entry1).append(entry2).push_back(Sep); } void Flush() { std::string& data = numeric.GetParams().back(); if (IsEmpty()) { if (!SendEmpty) return; } else { data.pop_back(); } sink(numeric); data.clear(); } bool IsEmpty() const { return (numeric.GetParams().back().empty()); } }; template <char Sep, bool SendEmpty> class Numeric::Builder : public GenericBuilder<Sep, SendEmpty, WriteNumericSink> { public: Builder(LocalUser* user, unsigned int num, bool addparam = true, size_t additionalsize = 0) : ::Numeric::GenericBuilder<Sep, SendEmpty, WriteNumericSink>(WriteNumericSink(user), num, addparam, additionalsize + user->nick.size()) { } }; template <unsigned int NumStaticParams, bool SendEmpty, typename Sink> class Numeric::GenericParamBuilder { Sink sink; Numeric numeric; std::string::size_type currlen = 0; std::string::size_type max; bool HasRoom(const std::string::size_type additional) const { return (currlen + additional <= max); } public: GenericParamBuilder(Sink s, unsigned int num, size_t additionalsize) : sink(s) , numeric(num) , max(ServerInstance->Config->Limits.MaxLine - ServerInstance->Config->GetServerName().size() - additionalsize - 10) { } void AddStatic(const std::string& entry) { max -= (entry.length() + 1); numeric.GetParams().push_back(entry); } void Add(const std::string& entry) { if (!HasRoom(entry.size())) Flush(); currlen += entry.size() + 1; numeric.GetParams().push_back(entry); } void Flush() { if ((!SendEmpty) && (IsEmpty())) return; sink(numeric); currlen = 0; numeric.GetParams().erase(numeric.GetParams().begin() + NumStaticParams, numeric.GetParams().end()); } bool IsEmpty() const { return (numeric.GetParams().size() <= NumStaticParams); } }; template <unsigned int NumStaticParams, bool SendEmpty> class Numeric::ParamBuilder : public GenericParamBuilder<NumStaticParams, SendEmpty, WriteNumericSink> { public: ParamBuilder(LocalUser* user, unsigned int num) : ::Numeric::GenericParamBuilder<NumStaticParams, SendEmpty, WriteNumericSink>(WriteNumericSink(user), num, user->nick.size()) { } }; �������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/include/numerichelper.h��������������������������������������������������������������0000664�0000000�0000000�00000011254�14771603147�0020010�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2022-2024 Sadie Powell <sadie@witchery.services> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #pragma once enum { // From RFC 1459. ERR_CANNOTSENDTOCHAN = 404, // InspIRCd-specific. ERR_CANNOTSENDTOUSER = 531, ERR_INVALIDMODEPARAM = 696, }; namespace Numerics { class CannotSendTo; class ChannelPrivilegesNeeded; class InvalidModeParameter; class NoSuchChannel; class NoSuchNick; } /** Helper for the ERR_CANNOTSENDTOCHAN and ERR_CANNOTSENDTOUSER numerics. */ class Numerics::CannotSendTo final : public Numeric::Numeric { public: CannotSendTo(const Channel* chan, const std::string& message) : Numeric(ERR_CANNOTSENDTOCHAN) { push(chan->name); push(message); } CannotSendTo(const Channel* chan, const std::string& what, const ModeHandler* mh) : Numeric(ERR_CANNOTSENDTOCHAN) { push(chan->name); push_fmt("You cannot send {} to this channel whilst the +{} ({}) mode is set.", what, mh->GetModeChar(), mh->name); } #ifdef INSPIRCD_EXTBAN CannotSendTo(const Channel* chan, const std::string& what, const ExtBan::Base& xb) : Numeric(ERR_CANNOTSENDTOCHAN) { push(chan->name); push_fmt("You cannot send {} to this channel whilst {} {}: ({}) extban is set matching you.", what, strchr("AEIOUaeiou", xb.GetLetter()) ? "an" : "a", xb.GetLetter(), xb.GetName()); } #endif CannotSendTo(const User* user, const std::string& message) : Numeric(ERR_CANNOTSENDTOUSER) { push(user->connected & User::CONN_NICK ? user->nick : "*"); push(message); } CannotSendTo(const User* user, const std::string& what, const ModeHandler* mh, bool self = false) : Numeric(ERR_CANNOTSENDTOUSER) { push(user->connected & User::CONN_NICK ? user->nick : "*"); push_fmt("You cannot send {} to this user whilst {} have the +{} ({}) mode set.", what, self ? "you" : "they", mh->GetModeChar(), mh->name); } }; /* Helper for the ERR_CHANOPRIVSNEEDED numeric. */ class Numerics::ChannelPrivilegesNeeded : public Numeric::Numeric { public: ChannelPrivilegesNeeded(const Channel* chan, ModeHandler::Rank rank, const std::string& message) : Numeric(ERR_CHANOPRIVSNEEDED) { push(chan->name); const PrefixMode* pm = ServerInstance->Modes.FindNearestPrefixMode(rank); if (pm) push_fmt("You must be a channel {} or higher to {}.", pm->name, message); else push_fmt("You do not have the required channel privileges to {}.", message); } }; /* Helper for the ERR_INVALIDMODEPARAM numeric. */ class Numerics::InvalidModeParameter final : public Numeric::Numeric { private: void push_message(const ModeHandler* mode, const std::string& message) { if (!message.empty()) { // The caller has specified their own message. push(message); return; } const std::string& syntax = mode->GetSyntax(); if (!syntax.empty()) { // If the mode has a syntax hint we include it in the message. push_fmt("Invalid {} mode parameter. Syntax: {}.", mode->name, syntax); } else { // Otherwise, send it without. push_fmt("Invalid {} mode parameter.", mode->name); } } public: InvalidModeParameter(const Channel* chan, const ModeHandler* mode, const std::string& parameter, const std::string& message = "") : Numeric(ERR_INVALIDMODEPARAM) { push(chan->name); push(mode->GetModeChar()); push(parameter); push_message(mode, message); } InvalidModeParameter(const User* user, const ModeHandler* mode, const std::string& parameter, const std::string& message = "") : Numeric(ERR_INVALIDMODEPARAM) { push(user->connected & User::CONN_NICK ? user->nick : "*"); push(mode->GetModeChar()); push(parameter); push_message(mode, message); } }; /** Helper for the ERR_NOSUCHCHANNEL numeric. */ class Numerics::NoSuchChannel final : public Numeric::Numeric { public: NoSuchChannel(const std::string& chan) : Numeric(ERR_NOSUCHCHANNEL) { push(chan.empty() ? "*" : chan); push("No such channel"); } }; /** Helper for the ERR_NOSUCHNICK numeric. */ class Numerics::NoSuchNick final : public Numeric::Numeric { public: NoSuchNick(const std::string& nick) : Numeric(ERR_NOSUCHNICK) { push(nick.empty() ? "*" : nick); push("No such nick"); } }; ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/include/parammode.h������������������������������������������������������������������0000664�0000000�0000000�00000004764�14771603147�0017123�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2018-2019, 2021-2023 Sadie Powell <sadie@witchery.services> * Copyright (C) 2014 Attila Molnar <attilamolnar@hush.com> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #pragma once class CoreExport ParamModeBase : public ModeHandler { private: virtual void OnUnsetInternal(User* source, Channel* chan) = 0; public: ParamModeBase(Module* Creator, const std::string& Name, char modeletter, ParamSpec ps) : ModeHandler(Creator, Name, modeletter, ps, MODETYPE_CHANNEL, MC_PARAM) { } /** @copydoc ModeHandler::OnModeChange */ bool OnModeChange(User* source, User* dest, Channel* channel, Modes::Change& change) override; // Does nothing by default virtual bool IsParameterSecret() { return false; } virtual void OnUnset(User* source, Channel* chan) { } virtual bool OnSet(User* source, Channel* chan, std::string& param) = 0; virtual void GetParameter(Channel* chan, std::string& out) = 0; }; /** Defines a parameter mode * T = Child class * ExtItemT = Type of the extension item used to store the parameter * * When unsetting the mode, the extension is automatically unset. */ template <typename T, typename ExtItemT> class ParamMode : public ParamModeBase { public: ExtItemT ext; /** * @param Creator Module handling this mode * @param Name The internal name of this mode * @param modeletter The mode letter of this mode * @param ps The parameter type of this mode, one of ParamSpec */ ParamMode(Module* Creator, const std::string& Name, char modeletter, ParamSpec ps = PARAM_SETONLY) : ParamModeBase(Creator, Name, modeletter, ps) , ext(Creator, "param-mode-" + Name, ExtensionType::CHANNEL) { } void OnUnsetInternal(User* source, Channel* chan) override { this->OnUnset(source, chan); ext.Unset(chan); } void GetParameter(Channel* chan, std::string& out) override { auto mh = static_cast<T*>(this); mh->SerializeParam(chan, ext.Get(chan), out); } }; ������������inspircd-4.7.0/include/protocol.h�������������������������������������������������������������������0000664�0000000�0000000�00000011377�14771603147�0017015�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2021 Dominic Hamon * Copyright (C) 2018 Matt Schatz <genius3000@g3k.solutions> * Copyright (C) 2013-2014 Attila Molnar <attilamolnar@hush.com> * Copyright (C) 2013, 2020-2024 Sadie Powell <sadie@witchery.services> * Copyright (C) 2012, 2019 Robby <robby@chatbelgie.be> * Copyright (C) 2008 Robin Burchell <robin+git@viroteck.net> * Copyright (C) 2008 Craig Edwards <brain@inspircd.org> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #pragma once class User; [[deprecated("ProtocolServer has been merged with Server")]] typedef ::Server ProtocolServer; class CoreExport ProtocolInterface { public: [[deprecated("ProtocolInterface::Server has been merged with Server")]] typedef ProtocolServer Server; class ServerInfo final { public: std::string servername; std::string parentname; std::string description; size_t usercount; size_t opercount; unsigned long latencyms; }; typedef std::vector<ServerInfo> ServerList; virtual ~ProtocolInterface() = default; /** Send an ENCAP message to all servers matching a wildcard string. * See the protocol documentation for the purpose of ENCAP. * @param targetmask The target server mask (can contain wildcards) * @param cmd The ENCAP subcommand * @param params List of string parameters which are dependent on the subcommand * @param source The source of the message (prefix), must be a local user or NULL which means use local server * @return Always true if the target mask contains wildcards; otherwise true if the server name was found, * and the message was sent, false if it was not found. * ENCAP (should) be used instead of creating new protocol messages for easier third party application support. */ virtual bool SendEncapsulatedData(const std::string& targetmask, const std::string& cmd, const CommandBase::Params& params, const User* source = nullptr) { return false; } /** Send an ENCAP message to all servers. * See the protocol documentation for the purpose of ENCAP. * @param cmd The ENCAP subcommand * @param params List of string parameters which are dependent on the subcommand * @param source The source of the message (prefix), must be a local user or a user behind 'omit' * or NULL which is equivalent to the local server * @param omit If non-NULL the message won't be sent in the direction of this server, useful for forwarding messages */ virtual void BroadcastEncap(const std::string& cmd, const CommandBase::Params& params, const User* source = nullptr, const User* omit = nullptr) { } /** Send metadata for an extensible to other linked servers. * @param ext The extensible to send metadata for * @param key The 'key' of the data, e.g. "swhois" for swhois desc on a user * @param data The string representation of the data */ virtual void SendMetadata(const Extensible* ext, const std::string& key, const std::string& data) { } /** Send metadata related to the server to other linked servers. * @param key The 'key' of the data * @param data The string representation of the data */ virtual void SendMetadata(const std::string& key, const std::string& data) { } /** Send a notice to users with a given snomask. * @param snomask The snomask required for the message to be sent. * @param text The message to send. */ virtual void SendSNONotice(char snomask, const std::string& text) { } /** Send a message to a channel. * @param target The channel to message. * @param status The status character (e.g. %) required to receive. * @param text The message to send. * @param type The message type (MessageType::PRIVMSG or MessageType::NOTICE) */ virtual void SendMessage(const Channel* target, char status, const std::string& text, MessageType type = MessageType::PRIVMSG) { } /** Send a message to a user. * @param target The user to message. * @param text The message to send. * @param type The message type (MessageType::PRIVMSG or MessageType::NOTICE) */ virtual void SendMessage(const User* target, const std::string& text, MessageType type = MessageType::PRIVMSG) { } /** Fill a list of servers and information about them. * @param sl The list of servers to fill. */ virtual void GetServerList(ServerList& sl) { } }; �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/include/server.h���������������������������������������������������������������������0000664�0000000�0000000�00000006410�14771603147�0016452�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2019, 2021, 2024 Sadie Powell <sadie@witchery.services> * Copyright (C) 2018 Matt Schatz <genius3000@g3k.solutions> * Copyright (C) 2014 Attila Molnar <attilamolnar@hush.com> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #pragma once class CoreExport Server : public Cullable { protected: /** The unique identifier for this server. */ const std::string id; /** The name of this server */ const std::string name; /** The description of this server. * This can be updated by the protocol module (for remote servers) or by a rehash (for the local server). */ std::string description; /** True if this server is a service. */ bool service = false; /** True if this server is a silent service, i.e. silent="yes" in the service block. */ bool silentservice = false; /** Allow ConfigReaderThread to update the description on a rehash */ friend class ConfigReaderThread; public: Server(const std::string& srvid, const std::string& srvname, const std::string& srvdesc) : id(srvid) , name(srvname) , description(srvdesc) { } /** Retrieves the unique identifier for this server (e.g. 36C). */ const std::string& GetId() const { return id; } /** * Returns the name of this server * @return The name of this server, for example "irc.example.com". */ const std::string& GetName() const { return name; } /** Returns the public name of this server respecting <security:hideserver> if set. */ const std::string& GetPublicName() const; /** Returns the description of this server * @return The description of this server */ const std::string& GetDesc() const { return description; } /** * Checks whether this server is a service. * @return True if this server is a service, false otherwise. */ bool IsService() const { return service; } /** * Checks whether this server is a silent service. * Silent services servers introduce, quit and oper up users without a snotice being generated. * @return True if this server is a silent service, false otherwise. */ bool IsSilentService() const { return silentservice; } /** Send metadata related to this server to the target server. * @param key The name of the metadata (e.g. foo-bar). * @param data The network representation of the metadata. */ virtual void SendMetadata(const std::string& key, const std::string& data) const; /** Send metadata related to an extensible to the target server. * @param ext The extensible to send metadata for. * @param key The name of the metadata (e.g. foo-bar). * @param data The network representation of the metadata. */ virtual void SendMetadata(const Extensible* ext, const std::string& key, const std::string& data) const; }; ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/include/snomasks.h�������������������������������������������������������������������0000664�0000000�0000000�00000012663�14771603147�0017011�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2013, 2017, 2020-2021, 2023-2024 Sadie Powell <sadie@witchery.services> * Copyright (C) 2013 Attila Molnar <attilamolnar@hush.com> * Copyright (C) 2012 Robby <robby@chatbelgie.be> * Copyright (C) 2009-2010 Daniel De Graaf <danieldg@inspircd.org> * Copyright (C) 2008 Robin Burchell <robin+git@viroteck.net> * Copyright (C) 2007 Dennis Friis <peavey@inspircd.org> * Copyright (C) 2006 Craig Edwards <brain@inspircd.org> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #pragma once class SnomaskManager; class Snomask final { /** Description of this snomask, e.g.: OPER, ANNOUNCEMENT, XLINE */ std::string Description; /** Information about the last sent message, * used for sending "last message repeated X times" messages */ std::string LastMessage; char LastLetter; unsigned int Count = 0; /** Log and send a message to all opers who have the given snomask set * @param letter The target users of this message * @param desc The description of this snomask, will be prepended to the message * @param msg The message to send */ static void Send(char letter, const std::string& desc, const std::string& msg); public: /** Sends a message to all opers with this snomask. * @param message The message to send * @param letter The snomask character to send the message to. */ void SendMessage(const std::string& message, char letter); /** Sends out the (last message repeated N times) message */ void Flush(); /** Returns the description of this snomask * @param letter The letter of this snomask. If uppercase, the description of the remote * variant of this snomask will be returned (i.e.: "REMOTE" will be prepended to the description). * @return The description of this snomask */ std::string GetDescription(char letter) const; friend class SnomaskManager; }; /** Snomask manager handles routing of SNOMASK (usermode +s) messages to opers. * Modules and the core can enable and disable snomask characters. If they do, * then sending snomasks using these characters becomes possible. */ class CoreExport SnomaskManager final { Snomask masks[26]; public: /** Create a new SnomaskManager */ SnomaskManager(); /** Enable a snomask. * @param letter The snomask letter to enable. Once enabled, * server notices may be routed to users with this letter in * their list, and users may add this letter to their list. * @param description The descriptive text sent along with any * server notices, at the start of the notice, e.g. "GLOBOPS". */ void EnableSnomask(char letter, const std::string& description); /** Write to all users with a given snomask (local server only) * @param letter The snomask letter to write to * @param text The text to send to the users */ void WriteToSnoMask(char letter, const std::string& text); /** Write to all users with a given snomask (local server only) * @param letter The snomask letter to write to * @param text A format string containing text to send * @param args Format arguments */ template <typename... Args> void WriteToSnoMask(char letter, const char* text, Args&&... args) { WriteToSnoMask(letter, fmt::vformat(text, fmt::make_format_args(args...))); } /** Write to all users with a given snomask (sent globally) * @param letter The snomask letter to write to * @param text The text to send to the users */ void WriteGlobalSno(char letter, const std::string& text); /** Write to all users with a given snomask (sent globally) * @param letter The snomask letter to write to * @param text A format string containing text to send * @param args Format arguments */ template <typename... Args> void WriteGlobalSno(char letter, const char* text, Args&&... args) { WriteGlobalSno(letter, fmt::vformat(text, fmt::make_format_args(args...))); } /** Called once per 5 seconds from the mainloop, this flushes any cached * snotices. The way the caching works is as follows: * Calls to WriteToSnoMask write to a cache, if the call is the same as it was * for the previous call, then a count is incremented. If it is different, * the previous message it just sent normally via NOTICE (with count if > 1) * and the new message is cached. This acts as a sender in case the number of notices * is not particularly significant, in order to keep notices going out. */ void FlushSnotices(); /** Check whether a given character is a valid snomask. * @param ch The character to check * @return True if the given char is allowed to be set via +s. */ static bool IsSnomask(char ch); /** Check whether a given character is an enabled (initialized) snomask. * Valid snomask chars are lower- or uppercase letters and have a description. * Snomasks are initialized with EnableSnomask(). * @param ch The character to check * @return True if the given char is allowed to be set via +s. */ bool IsSnomaskUsable(char ch) const; }; �����������������������������������������������������������������������������inspircd-4.7.0/include/socket.h���������������������������������������������������������������������0000664�0000000�0000000�00000017737�14771603147�0016452�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2013, 2015-2016 Attila Molnar <attilamolnar@hush.com> * Copyright (C) 2012-2013, 2017-2024 Sadie Powell <sadie@witchery.services> * Copyright (C) 2012 Robby <robby@chatbelgie.be> * Copyright (C) 2012 ChrisTX <xpipe@hotmail.de> * Copyright (C) 2009-2010 Daniel De Graaf <danieldg@inspircd.org> * Copyright (C) 2008 Pippijn van Steenhoven <pip88nl@gmail.com> * Copyright (C) 2007-2008 Robin Burchell <robin+git@viroteck.net> * Copyright (C) 2007 Dennis Friis <peavey@inspircd.org> * Copyright (C) 2006, 2008 Craig Edwards <brain@inspircd.org> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #pragma once #ifndef _WIN32 # include <netinet/in.h> # include <sys/socket.h> # include <sys/stat.h> # include <sys/un.h> #else # include <afunix.h> typedef USHORT in_port_t; typedef ADDRESS_FAMILY sa_family_t; #endif #include <cerrno> /* Contains irc-specific definitions */ namespace irc { /** This namespace contains various protocol-independent helper classes. * It also contains some types which are often used by the core and modules * in place of inet_* functions and types. */ namespace sockets { /** Represents a socket address. This can be an IP/port pair or a UNIX socket path. */ union CoreExport sockaddrs { struct sockaddr sa; struct sockaddr_in in4; struct sockaddr_in6 in6; struct sockaddr_un un; /** Initializes this sockaddrs optionally as an unspecified socket address. */ explicit sockaddrs(bool initialize = true); /** Returns the address segment of the socket address as a string. */ std::string addr() const; /** Returns the family of the socket address (e.g. AF_INET). */ sa_family_t family() const; /** Store an IP address or UNIX socket path in this socket address. * @param addr An IPv4 address, IPv6 address, or UNIX socket path. * @return True if the IP address or UNIX socket paht was stored in this socket address; otherwise, false. */ inline bool from(const std::string& addr) { return addr.find('/') == std::string::npos ? from_ip(addr) : from_unix(addr); } /** Store an IP address in this socket address. * @param addr An IPv4 or IPv6 address. * @return True if the IP was stored in this socket address; otherwise, false. */ inline bool from_ip(const std::string& addr) { return from_ip_port(addr, 0); } /** Store an IP address and TCP port pair in this socket address. * @param addr An IPv4 or IPv6 address. * @param port A TCP port. * @return True if the IP/port was stored in this socket address; otherwise, false. */ bool from_ip_port(const std::string& addr, in_port_t port); /** Store a UNIX socket path in this socket address. * @param path A path to a UNIX socket. * @return True if the UNIX socket path was stored in this socket address; otherwise, false. */ bool from_unix(const std::string& path); /** Determines whether this socket address is a local endpoint. */ bool is_local() const; /** Determines whether this socket address is an IPv4 or IPv6 address. */ inline bool is_ip() const { return family() == AF_INET || family() == AF_INET6; } /** Returns the TCP port number of the socket address or 0 if not relevant to this family. */ in_port_t port() const; /** Returns the size of the structure for use in networking syscalls. */ socklen_t sa_size() const; /** Returns the whole socket address as a string. */ std::string str() const; /** Determines if this socket address refers to the same endpoint as another socket address. */ bool operator==(const sockaddrs& other) const; inline bool operator!=(const sockaddrs& other) const { return !(*this == other); } }; struct CoreExport cidr_mask { /** Type, AF_INET or AF_INET6 */ sa_family_t type; /** Length of the mask in bits (0-128) */ unsigned char length; /** Raw bits. Unused bits must be zero */ unsigned char bits[16]; cidr_mask() = default; /** Construct a CIDR mask from the string. Will normalize (127.0.0.1/8 => 127.0.0.0/8). */ cidr_mask(const std::string& mask); /** Construct a CIDR mask of a given length from the given address */ cidr_mask(const irc::sockets::sockaddrs& addr, unsigned char len); /** Equality of bits, type, and length */ bool operator==(const cidr_mask& other) const; /** Ordering defined for maps */ bool operator<(const cidr_mask& other) const; /** Match within this CIDR? */ bool match(const irc::sockets::sockaddrs& addr) const; /** Human-readable string */ std::string str() const; }; /** Match CIDR, including an optional username/nickname part. * * This function will compare a human-readable address (plus * optional username and nickname) against a human-readable * CIDR mask, for example joe!bloggs\@1.2.3.4 against * *!bloggs\@1.2.0.0/16. This method supports both IPV4 and * IPV6 addresses. * @param address The human readable address, e.g. fred\@1.2.3.4 * @param cidr_mask The human readable mask, e.g. *\@1.2.0.0/16 * @param match_with_username Does the mask include a nickname segment? * @return True if the mask matches the address */ CoreExport bool MatchCIDR(const std::string& address, const std::string& cidr_mask, bool match_with_username); /** Determines whether the specified file is a UNIX socket. * @param file The path to the file to check. * @return True if the file is a UNIX socket; otherwise, false. */ CoreExport bool isunix(const std::string& file); } } /** Represents information about a failed port binding. */ struct CoreExport FailedPort final { /** The error which happened during binding. */ const std::string error; /** The endpoint on which we were attempting to bind. */ const irc::sockets::sockaddrs sa; /** The config tag that the listener was created from. */ const std::shared_ptr<ConfigTag> tag; FailedPort(const std::string& err, irc::sockets::sockaddrs& addr, const std::shared_ptr<ConfigTag>& cfg) : error(err) , sa(addr) , tag(cfg) { } FailedPort(const std::string& err, const std::shared_ptr<ConfigTag>& cfg) : error(err) , sa(true) , tag(cfg) { } }; /** A list of failed port bindings, used for informational purposes on startup */ typedef std::vector<FailedPort> FailedPortList; #include "socketengine.h" /** This class handles incoming connections on client ports. * It will create a new User for every valid connection * and assign it a file descriptor. */ class CoreExport ListenSocket final : public EventHandler { public: std::shared_ptr<ConfigTag> bind_tag; const irc::sockets::sockaddrs bind_sa; const int bind_protocol; class IOHookProvRef : public dynamic_reference_nocheck<IOHookProvider> { public: IOHookProvRef() : dynamic_reference_nocheck<IOHookProvider>(nullptr, std::string()) { } }; typedef std::array<IOHookProvRef, 2> IOHookProvList; /** IOHook providers for handling connections on this socket, * may be empty. */ IOHookProvList iohookprovs; /** Create a new listening socket */ ListenSocket(const std::shared_ptr<ConfigTag>& tag, const irc::sockets::sockaddrs& bind_to, sa_family_t protocol); /** Close the socket */ ~ListenSocket() override; /** Handles new connections, called by the socket engine */ void OnEventHandlerRead() override; /** Inspects the bind block belonging to this socket to set the name of the IO hook * provider which this socket will use for incoming connections. */ void ResetIOHookProvider(); }; ���������������������������������inspircd-4.7.0/include/socketengine.h���������������������������������������������������������������0000664�0000000�0000000�00000052571�14771603147�0017633�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2021 Dominic Hamon * Copyright (C) 2013-2016 Attila Molnar <attilamolnar@hush.com> * Copyright (C) 2013-2014 Adam <Adam@anope.org> * Copyright (C) 2012-2013, 2017-2023 Sadie Powell <sadie@witchery.services> * Copyright (C) 2012 Robby <robby@chatbelgie.be> * Copyright (C) 2009 Daniel De Graaf <danieldg@inspircd.org> * Copyright (C) 2007, 2017 Robin Burchell <robin+git@viroteck.net> * Copyright (C) 2007 Dennis Friis <peavey@inspircd.org> * Copyright (C) 2005-2008 Craig Edwards <brain@inspircd.org> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #pragma once #include <string> #include "socket.h" #include "base.h" #ifndef _WIN32 #include <sys/uio.h> #endif #ifndef IOV_MAX #define IOV_MAX 1024 #endif /** * Event mask for SocketEngine events */ enum EventMask { /** Do not test this socket for readability */ FD_WANT_NO_READ = 0x1, /** Give a read event at all times when reads will not block. */ FD_WANT_POLL_READ = 0x2, /** Give a read event when there is new data to read. * * An event MUST be sent if there is new data to be read, and the most * recent read/recv() on this FD returned EAGAIN. An event MAY be sent * at any time there is data to be read on the socket. */ FD_WANT_FAST_READ = 0x4, /** Give an optional read event when reads begin to unblock * * This state is useful if you want to leave data in the OS receive * queue but not get continuous event notifications about it, because * it may not require a system call to transition from FD_WANT_FAST_READ */ FD_WANT_EDGE_READ = 0x8, /** Mask for all read events */ FD_WANT_READ_MASK = 0x0F, /** Do not test this socket for writability */ FD_WANT_NO_WRITE = 0x10, /** Give a write event at all times when writes will not block. * * You probably shouldn't use this state; if it's likely that the write * will not block, try it first, then use FD_WANT_FAST_WRITE if it * fails. If it's likely to block (or you are using polling-style reads) * then use FD_WANT_SINGLE_WRITE. */ FD_WANT_POLL_WRITE = 0x20, /** Give a write event when writes don't block any more * * An event MUST be sent if writes will not block, and the most recent * write/send() on this FD returned EAGAIN, or connect() returned * EINPROGRESS. An event MAY be sent at any time that writes will not * block. * * Before calling OnEventHandler*(), a socket engine MAY change the state of * the FD back to FD_WANT_EDGE_WRITE if it is simpler (for example, if a * one-shot notification was registered). If further writes are needed, * it is the responsibility of the event handler to change the state to * one that will generate the required notifications */ FD_WANT_FAST_WRITE = 0x40, /** Give an optional write event on edge-triggered write unblock. * * This state is useful to avoid system calls when moving to/from * FD_WANT_FAST_WRITE when writing data to a mostly-unblocked socket. */ FD_WANT_EDGE_WRITE = 0x80, /** Request a one-shot poll-style write notification. The socket will * return to the FD_WANT_NO_WRITE state before OnEventHandler*() is called. */ FD_WANT_SINGLE_WRITE = 0x100, /** Mask for all write events */ FD_WANT_WRITE_MASK = 0x1F0, /** Add a trial read. During the next DispatchEvents invocation, this * will call OnEventHandlerRead() unless reads are known to be * blocking. */ FD_ADD_TRIAL_READ = 0x1000, /** Assert that reads are known to block. This cancels FD_ADD_TRIAL_READ. * Reset by SE before running OnEventHandlerRead(). */ FD_READ_WILL_BLOCK = 0x2000, /** Add a trial write. During the next DispatchEvents invocation, this * will call OnEventHandlerWrite() unless writes are known to be * blocking. * * This could be used to group several writes together into a single * send() syscall, or to ensure that writes are blocking when attempting * to use FD_WANT_FAST_WRITE. */ FD_ADD_TRIAL_WRITE = 0x4000, /** Assert that writes are known to block. This cancels FD_ADD_TRIAL_WRITE. * Reset by SE before running OnEventHandlerWrite(). */ FD_WRITE_WILL_BLOCK = 0x8000, /** Mask for trial read/trial write */ FD_TRIAL_NOTE_MASK = 0x5000 }; /** This class is a basic I/O handler class. * Any object which wishes to receive basic I/O events * from the socketengine must derive from this class and * implement the OnEventHandler*() methods. The derived class * must then be added to SocketEngine using the method * SocketEngine::AddFd(), after which point the derived * class will receive events to its OnEventHandler*() methods. * The event mask passed to SocketEngine::AddFd() determines * what events the EventHandler gets notified about and with * what semantics. SocketEngine::ChangeEventMask() can be * called to update the event mask later. The only * requirement beyond this for an event handler is that it * must have a file descriptor. What this file descriptor * is actually attached to is completely up to you. */ class CoreExport EventHandler : public Cullable { private: /** Private state maintained by socket engine */ int event_mask = 0; void SetEventMask(int mask) { event_mask = mask; } /** File descriptor. * All events which can be handled must have a file descriptor. This * allows you to add events for sockets, fifo's, pipes, and various * other forms of IPC. Do not change this while the object is * registered with the SocketEngine */ int fd = -1; public: /** Get the current file descriptor * @return The file descriptor of this handler */ inline int GetFd() const { return fd; } /** Checks if this event handler has a fd associated with it. */ inline bool HasFd() const { return fd >= 0; } inline int GetEventMask() const { return event_mask; } /** Set a new file descriptor * @param FD The new file descriptor. Do not call this method without * first deleting the object from the SocketEngine if you have * added it to a SocketEngine instance. */ void SetFd(int FD); /** Called by the socket engine in case of a read event */ virtual void OnEventHandlerRead() = 0; /** Called by the socket engine in case of a write event. * The default implementation does nothing. */ virtual void OnEventHandlerWrite(); /** Called by the socket engine in case of an error event. * The default implementation does nothing. * @param errornum Error code */ virtual void OnEventHandlerError(int errornum); friend class SocketEngine; }; /** Provides basic file-descriptor-based I/O support. * The actual socketengine class presents the * same interface on all operating systems, but * its private members and internal behaviour * should be treated as blackboxed, and vary * from system to system and upon the config * settings chosen by the server admin. */ class CoreExport SocketEngine final { public: /** Socket engine statistics: count of various events, bandwidth usage */ class Statistics { mutable size_t indata = 0; mutable size_t outdata = 0; mutable time_t lastempty = 0; /** Reset the byte counters and lastempty if there wasn't a reset in this second. */ void CheckFlush() const; public: /** Update counters for network data received. * This should be called after every read-type syscall. * @param len_in Number of bytes received, or -1 for error, as typically * returned by a read-style syscall. */ void UpdateReadCounters(ssize_t len_in); /** Update counters for network data sent. * This should be called after every write-type syscall. * @param len_out Number of bytes sent, or -1 for error, as typically * returned by a read-style syscall. */ void UpdateWriteCounters(ssize_t len_out); /** Get data transfer statistics. * @param kbitpersec_in Filled with incoming traffic in this second in kbit/s. * @param kbitpersec_out Filled with outgoing traffic in this second in kbit/s. * @param kbitpersec_total Filled with total traffic in this second in kbit/s. */ void CoreExport GetBandwidth(float& kbitpersec_in, float& kbitpersec_out, float& kbitpersec_total) const; unsigned long TotalEvents = 0; unsigned long ReadEvents = 0; unsigned long WriteEvents = 0; unsigned long ErrorEvents = 0; }; private: /** Reference table, contains all current handlers **/ static std::vector<EventHandler*> ref; /** Current number of descriptors in the engine. */ static size_t CurrentSetSize; /** The maximum number of descriptors in the engine. */ static size_t MaxSetSize; /** List of handlers that want a trial read/write */ static std::set<int> trials; /** Socket engine statistics: count of various events, bandwidth usage */ static Statistics stats; /** Look up the fd limit using rlimit. */ static void LookupMaxFds(); /** Terminates the program when the socket engine fails to initialize. */ [[noreturn]] static void InitError(); static void OnSetEvent(EventHandler* eh, int old_mask, int new_mask) ATTR_NOT_NULL(1); /** Add an event handler to the base socket engine. AddFd(EventHandler*, int) should call this. */ static bool AddFdRef(EventHandler* eh) ATTR_NOT_NULL(1); static void DelFdRef(EventHandler* eh) ATTR_NOT_NULL(1); template <typename T> static void ResizeDouble(std::vector<T>& vect) { if (SocketEngine::CurrentSetSize > vect.size()) vect.resize(SocketEngine::CurrentSetSize * 2); } public: #ifndef _WIN32 typedef iovec IOVector; #else typedef WindowsIOVec IOVector; #endif /** Constructor. * The constructor transparently initializes * the socket engine which the ircd is using. * Please note that if there is a catastrophic * failure (for example, you try and enable * epoll on a 2.4 linux kernel) then this * function may bail back to the shell. */ static void Init(); /** Destructor. * The destructor transparently tidies up * any resources used by the socket engine. */ static void Deinit(); /** Add an EventHandler object to the engine. Use AddFd to add a file * descriptor to the engine and have the socket engine monitor it. You * must provide an object derived from EventHandler which implements * the required OnEventHandler*() methods. * @param eh An event handling object to add * @param event_mask The initial event mask for the object */ static bool AddFd(EventHandler* eh, int event_mask) ATTR_NOT_NULL(1); /** If you call this function and pass it an * event handler, that event handler will * receive the next available write event, * even if the socket is a readable socket only. * Developers should avoid constantly keeping * an eventhandler in the writeable state, * as this will consume large amounts of * CPU time. * @param eh The event handler to change * @param event_mask The changes to make to the wait state */ static void ChangeEventMask(EventHandler* eh, int event_mask) ATTR_NOT_NULL(1); /** Returns the number of file descriptors reported by the system this program may use * when it was started. * @return If non-zero the number of file descriptors that the system reported that we * may use. */ static size_t GetMaxFds() { return MaxSetSize; } /** Returns the number of file descriptors being queried * @return The set size */ static size_t GetUsedFds() { return CurrentSetSize; } /** Delete an event handler from the engine. * This function call deletes an EventHandler * from the engine, returning true if it succeeded * and false if it failed. This does not free the * EventHandler pointer using delete, if this is * required you must do this yourself. * @param eh The event handler object to remove */ static void DelFd(EventHandler* eh) ATTR_NOT_NULL(1); /** Returns true if a file descriptor exists in * the socket engine's list. * @param fd The event handler to look for * @return True if this fd has an event handler */ static bool HasFd(int fd); /** Returns the EventHandler attached to a specific fd. * If the fd isn't in the socketengine, returns NULL. * @param fd The event handler to look for * @return A pointer to the event handler, or NULL */ static EventHandler* GetRef(int fd); /** Waits for events and dispatches them to handlers. Please note that * this doesn't wait long, only a couple of milliseconds. It returns the * number of events which occurred during this call. This method will * dispatch events to their handlers by calling their * EventHandler::OnEventHandler*() methods. * @return The number of events which have occurred. */ static int DispatchEvents(); /** Dispatch trial reads and writes. This causes the actual socket I/O * to happen when writes have been pre-buffered. */ static void DispatchTrialWrites(); /** Abstraction for BSD sockets accept(2). * This function should emulate its namesake system call exactly. * @param eh This version of the call takes an EventHandler instead of a bare file descriptor. * @param addr The client IP address and port * @param addrlen The size of the sockaddr parameter. * @return This method should return exactly the same values as the system call it emulates. */ static int Accept(EventHandler* eh, sockaddr* addr, socklen_t* addrlen) ATTR_NOT_NULL(1, 2, 3); /** Close the underlying fd of an event handler, remove it from the socket engine and set the fd to -1. * @param eh The EventHandler to close. * @return 0 on success, a negative value on error */ static int Close(EventHandler* eh) ATTR_NOT_NULL(1); /** Abstraction for BSD sockets close(2). * This function should emulate its namesake system call exactly. * This function should emulate its namesake system call exactly. * @return This method should return exactly the same values as the system call it emulates. */ static int Close(int fd); /** Abstraction for BSD sockets send(2). * This function should emulate its namesake system call exactly. * @param eh This version of the call takes an EventHandler instead of a bare file descriptor. * @param buf The buffer in which the data that is sent is stored. * @param len The size of the buffer. * @param flags A flag value that controls the sending of the data. * @return This method should return exactly the same values as the system call it emulates. */ static ssize_t Send(EventHandler* eh, const void* buf, size_t len, int flags) ATTR_NOT_NULL(1, 2); /** Abstraction for vector write function writev(). * This function should emulate its namesake system call exactly. * @param eh EventHandler to send data with * @param iov Array of IOVectors containing the buffers to send and their lengths in the platform's * native format. * @param count Number of elements in iov. * @return This method should return exactly the same values as the system call it emulates. */ static ssize_t WriteV(EventHandler* eh, const IOVector* iov, int count) ATTR_NOT_NULL(1, 2); #ifdef _WIN32 /** Abstraction for vector write function writev() that accepts a POSIX format iovec. * This function should emulate its namesake system call exactly. * @param eh EventHandler to send data with * @param iov Array of iovecs containing the buffers to send and their lengths in POSIX format. * @param count Number of elements in iov. * @return This method should return exactly the same values as the system call it emulates. */ static int WriteV(EventHandler* eh, const iovec* iov, int count) ATTR_NOT_NULL(1, 2); #endif /** Abstraction for BSD sockets recv(2). * This function should emulate its namesake system call exactly. * @param eh This version of the call takes an EventHandler instead of a bare file descriptor. * @param buf The buffer in which the data that is read is stored. * @param len The size of the buffer. * @param flags A flag value that controls the reception of the data. * @return This method should return exactly the same values as the system call it emulates. */ static ssize_t Recv(EventHandler* eh, void* buf, size_t len, int flags) ATTR_NOT_NULL(1); /** Abstraction for BSD sockets recvfrom(2). * This function should emulate its namesake system call exactly. * @param eh This version of the call takes an EventHandler instead of a bare file descriptor. * @param buf The buffer in which the data that is read is stored. * @param len The size of the buffer. * @param flags A flag value that controls the reception of the data. * @param from The remote IP address and port. * @param fromlen The size of the from parameter. * @return This method should return exactly the same values as the system call it emulates. */ static ssize_t RecvFrom(EventHandler* eh, void* buf, size_t len, int flags, sockaddr* from, socklen_t* fromlen) ATTR_NOT_NULL(1, 2, 5, 6); /** Abstraction for BSD sockets sendto(2). * This function should emulate its namesake system call exactly. * @param eh This version of the call takes an EventHandler instead of a bare file descriptor. * @param buf The buffer in which the data that is sent is stored. * @param len The size of the buffer. * @param flags A flag value that controls the sending of the data. * @param address The remote IP address and port. * @return This method should return exactly the same values as the system call it emulates. */ static ssize_t SendTo(EventHandler* eh, const void* buf, size_t len, int flags, const irc::sockets::sockaddrs& address) ATTR_NOT_NULL(1, 2); /** Abstraction for BSD sockets connect(2). * This function should emulate its namesake system call exactly. * @param eh This version of the call takes an EventHandler instead of a bare file descriptor. * @param address The server IP address and port. * @return This method should return exactly the same values as the system call it emulates. */ static int Connect(EventHandler* eh, const irc::sockets::sockaddrs& address) ATTR_NOT_NULL(1); /** Make a file descriptor blocking. * @param fd a file descriptor to set to blocking mode * @return 0 on success, -1 on failure, errno is set appropriately. */ static int Blocking(int fd); /** Make a file descriptor nonblocking. * @param fd A file descriptor to set to nonblocking mode * @return 0 on success, -1 on failure, errno is set appropriately. */ static int NonBlocking(int fd); /** Abstraction for BSD sockets shutdown(2). * This function should emulate its namesake system call exactly. * @param eh This version of the call takes an EventHandler instead of a bare file descriptor. * @param how What part of the socket to shut down * @return This method should return exactly the same values as the system call it emulates. */ static int Shutdown(EventHandler* eh, int how) ATTR_NOT_NULL(1); /** Abstraction for BSD sockets bind(2). * This function should emulate its namesake system call exactly. * @return This method should return exactly the same values as the system call it emulates. */ static int Bind(EventHandler* eh, const irc::sockets::sockaddrs& addr) ATTR_NOT_NULL(1); /** Abstraction for BSD sockets listen(2). * This function should emulate its namesake system call exactly. * @return This method should return exactly the same values as the system call it emulates. */ static int Listen(EventHandler* eh, int backlog) ATTR_NOT_NULL(1); /** Sets the value of a socket option. * @param fd The file descriptor to change the options of. * @param level The level at which to change the socket options. * @param name The option to change the value of. * @param value The value to set. * @return The system result of the socket operation. */ template <typename Value> static int SetOption(int fd, int level, int name, Value value) { return setsockopt(fd, level, name, reinterpret_cast<char*>(&value), sizeof(value)); } /** Sets the value of a socket option. * @param eh The socket to change the options of. * @param level The level at which to change the socket options. * @param name The option to change the value of. * @param value The value to set. * @return The system result of the socket operation. */ template <typename Value> static int SetOption(EventHandler* eh, int level, int name, Value value) { return SetOption<Value>(eh->GetFd(), level, name, value); } /** This function is called immediately after fork(). * Some socket engines (notably kqueue) cannot have their * handles inherited by forked processes. This method * allows for the socket engine to re-create its handle * after the daemon forks as the socket engine is created * long BEFORE the daemon forks. */ static void RecoverFromFork(); /** Get data transfer and event statistics */ static const Statistics& GetStats() { return stats; } /** Should we ignore the error in errno? * Checks EAGAIN and WSAEWOULDBLOCK */ static bool IgnoreError(); /** Return the last socket related error. strrerror(errno) on *nix */ static std::string LastError(); /** Returns the error for the given error num, strerror(errnum) on *nix */ static std::string GetError(int errnum); }; inline bool SocketEngine::IgnoreError() { if ((errno == EAGAIN) || (errno == EWOULDBLOCK)) return true; #ifdef _WIN32 if (WSAGetLastError() == WSAEWOULDBLOCK) return true; #endif return false; } ���������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/include/stdalgo.h��������������������������������������������������������������������0000664�0000000�0000000�00000010232�14771603147�0016576�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2020-2022 Sadie Powell <sadie@witchery.services> * Copyright (C) 2014 Attila Molnar <attilamolnar@hush.com> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #pragma once namespace stdalgo { namespace vector { /** * Erase a single element from a vector by overwriting it with a copy of the last element, * which is then removed. This, in contrast to vector::erase(), does not result in all * elements after the erased element being moved. * Returns nothing, but all iterators, references and pointers to the erased element and the * last element are invalidated * @param vect Vector to remove the element from * @param it Iterator to the element to remove */ template <typename T> inline void swaperase(typename std::vector<T>& vect, const typename std::vector<T>::iterator& it) { *it = vect.back(); vect.pop_back(); } /** * Find and if exists, erase a single element from a vector by overwriting it with a * copy of the last element, which is then removed. This, in contrast to vector::erase(), * does not result in all elements after the erased element being moved. * If the given value occurs multiple times, the one with the lowest index is removed. * Individual elements are compared to the given value using operator==(). * @param vect Vector to remove the element from * @param val Value of the element to look for and remove * @return True if the element was found and removed, false if it wasn't found. * If true, all iterators, references and pointers pointing to either the first element that * is equal to val or to the last element are invalidated. */ template <typename T> inline bool swaperase(typename std::vector<T>& vect, const T& val) { const typename std::vector<T>::iterator it = std::find(vect.begin(), vect.end(), val); if (it != vect.end()) { swaperase(vect, it); return true; } return false; } } /** * Deletes all elements in a container using operator delete * @param cont The container containing the elements to delete */ template <template<typename, typename> class Cont, typename T, typename Alloc> inline void delete_all(const Cont<T*, Alloc>& cont) { std::for_each(cont.begin(), cont.end(), std::default_delete<T>()); } /** Deletes a object and zeroes the memory location that pointed to it. * @param pr A reference to the pointer that contains the object to delete. */ template<typename T> void delete_zero(T*& pr) { auto p = pr; pr = nullptr; delete p; } /** * Remove an element from a container * @param cont Container to remove the element from * @param val Value of the element to look for and remove * @return True if the element was found and removed, false otherwise */ template <template<typename, typename> class Cont, typename T, typename Alloc> inline bool erase(Cont<T, Alloc>& cont, const T& val) { const typename Cont<T, Alloc>::iterator it = std::find(cont.begin(), cont.end(), val); if (it != cont.end()) { cont.erase(it); return true; } return false; } /** * Check if an element with the given value is in a container. Equivalent to (std::find(cont.begin(), cont.end(), val) != cont.end()). * @param cont Container to find the element in * @param val Value of the element to look for * @return True if the element was found in the container, false otherwise */ template <template<typename, typename> class Cont, typename T, typename Alloc> inline bool isin(const Cont<T, Alloc>& cont, const T& val) { return (std::find(cont.begin(), cont.end(), val) != cont.end()); } } ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/include/streamsocket.h���������������������������������������������������������������0000664�0000000�0000000�00000031561�14771603147�0017655�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2021 Dominic Hamon * Copyright (C) 2020 Matt Schatz <genius3000@g3k.solutions> * Copyright (C) 2019 linuxdaemon <linuxdaemon.irc@gmail.com> * Copyright (C) 2013, 2015-2016 Attila Molnar <attilamolnar@hush.com> * Copyright (C) 2012-2013, 2017-2024 Sadie Powell <sadie@witchery.services> * Copyright (C) 2012 Robby <robby@chatbelgie.be> * Copyright (C) 2009 Daniel De Graaf <danieldg@inspircd.org> * Copyright (C) 2007-2009 Robin Burchell <robin+git@viroteck.net> * Copyright (C) 2007 Dennis Friis <peavey@inspircd.org> * Copyright (C) 2006 Oliver Lupton <om@inspircd.org> * Copyright (C) 2006 Craig Edwards <brain@inspircd.org> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #pragma once #include "timer.h" class IOHook; /** * States which a socket may be in */ enum BufferedSocketState { /** Socket disconnected */ I_DISCONNECTED, /** Socket connecting */ I_CONNECTING, /** Socket fully connected */ I_CONNECTED, /** Socket has an error */ I_ERROR }; /** * Error types which a socket may exhibit */ enum BufferedSocketError { /** No error */ I_ERR_NONE, /** Socket was closed by peer */ I_ERR_DISCONNECT, /** Socket connect timed out */ I_ERR_TIMEOUT, /** Socket could not be created */ I_ERR_SOCKET, /** Socket could not connect (refused) */ I_ERR_CONNECT, /** Socket could not bind to local port/ip */ I_ERR_BIND, /** Socket could not write data */ I_ERR_WRITE, /** No more file descriptors left to create socket! */ I_ERR_NOMOREFDS, /** Some other error */ I_ERR_OTHER }; /* Required forward declarations */ class BufferedSocket; /** Used to time out socket connections */ class CoreExport SocketTimeout final : public Timer { private: /** BufferedSocket the class is attached to */ BufferedSocket* sock; /** File descriptor of class this is attached to */ int sfd; public: /** Create a socket timeout class * @param fd File descriptor of BufferedSocket * @param thesock BufferedSocket to attach to * @param secs_from_now Seconds from now to time out */ SocketTimeout(int fd, BufferedSocket* thesock, unsigned long secs_from_now) : Timer(secs_from_now, false) , sock(thesock) , sfd(fd) { } /** Handle tick event */ bool Tick() override; }; /** * StreamSocket is a class that wraps a TCP socket and handles send * and receive queues, including passing them to IO hooks */ class CoreExport StreamSocket : public EventHandler { public: /** Socket send queue */ class SendQueue final { public: /** One element of the queue, a continuous buffer */ typedef std::string Element; /** Sequence container of buffers in the queue */ typedef std::deque<Element> Container; /** Container iterator */ typedef Container::const_iterator const_iterator; /** Return whether the queue is empty * @return True if the queue is empty, false otherwise */ bool empty() const { return (nbytes == 0); } /** Get the number of individual buffers in the queue * @return Number of individual buffers in the queue */ Container::size_type size() const { return data.size(); } /** Get the number of queued bytes * @return Size in bytes of the data in the queue */ size_t bytes() const { return nbytes; } /** Get the first buffer of the queue * @return A reference to the first buffer in the queue */ const Element& front() const { return data.front(); } /** Get an iterator to the first buffer in the queue. * The returned iterator cannot be used to make modifications to the queue, * for that purpose the member functions push_*(), pop_front(), erase_front() and clear() can be used. * @return Iterator referring to the first buffer in the queue, or end() if there are no elements. */ const_iterator begin() const { return data.begin(); } /** Get an iterator to the (theoretical) buffer one past the end of the queue. * @return Iterator referring to one element past the end of the container */ const_iterator end() const { return data.end(); } /** Remove the first buffer in the queue */ void pop_front() { nbytes -= data.front().length(); data.pop_front(); } /** Remove bytes from the beginning of the first buffer * @param n Number of bytes to remove */ void erase_front(Element::size_type n) { nbytes -= n; data.front().erase(0, n); } /** Insert a new buffer at the beginning of the queue * @param newdata Data to add */ void push_front(const Element& newdata) { data.push_front(newdata); nbytes += newdata.length(); } /** Insert a new buffer at the end of the queue * @param newdata Data to add */ void push_back(const Element& newdata) { data.push_back(newdata); nbytes += newdata.length(); } /** Clear the queue */ void clear() { data.clear(); nbytes = 0; } void moveall(SendQueue& other) { nbytes += other.bytes(); data.insert(data.end(), other.data.begin(), other.data.end()); other.clear(); } private: /** Private send queue. Note that individual strings may be shared. */ Container data; /** Length, in bytes, of the sendq */ size_t nbytes = 0; }; /** The type of socket this IOHook represents. */ enum Type { SS_UNKNOWN, SS_USER }; private: /** Whether this socket should close once its sendq is empty */ bool closeonempty = false; /** Whether the socket is currently closing or not, used to avoid repeatedly closing a closed socket */ bool closing = false; /** The IOHook that handles raw I/O for this socket, or NULL */ IOHook* iohook = nullptr; /** Send queue of the socket */ SendQueue sendq; /** Error - if nonempty, the socket is dead, and this is the reason. */ std::string error; /** Check if the socket has an error set, if yes, call OnError * @param err Error to pass to OnError() */ void CheckError(BufferedSocketError err); /** Read data from the socket into the recvq, if successful call OnDataReady() */ void DoRead(); /** Send as much data contained in a SendQueue object as possible. * All data which successfully sent will be removed from the SendQueue. * @param sq SendQueue to flush */ void FlushSendQ(SendQueue& sq); /** Read incoming data into a receive queue. * @param rq Receive queue to put incoming data into * @return < 0 on error or close, 0 if no new data is ready (but the socket is still connected), > 0 if data was read from the socket and put into the recvq */ ssize_t ReadToRecvQ(std::string& rq); /** Read data from a hook chain recursively, starting at 'hook'. * If 'hook' is NULL, the recvq is filled with data from SocketEngine::Recv(), otherwise it is filled with data from the * next hook in the chain. * @param hook Next IOHook in the chain, can be NULL * @param rq Receive queue to put incoming data into * @return < 0 on error or close, 0 if no new data is ready (but the socket is still connected), > 0 if data was read from * the socket and put into the recvq */ ssize_t HookChainRead(IOHook* hook, std::string& rq); protected: /** The data which has been received from the socket. */ std::string recvq; public: const Type type; StreamSocket(Type sstype = SS_UNKNOWN) : type(sstype) { } IOHook* GetIOHook() const; void AddIOHook(IOHook* hook); void DelIOHook(); /** Writes the contents of the send queue to the socket. */ void DoWrite(); /** Called by the socket engine when a read event happens. */ void OnEventHandlerRead() override; /** Called by the socket engine when a write event happens. */ void OnEventHandlerWrite() override; /** Called by the socket engine when an error happens. * @param errcode The error code provided by the operating system. */ void OnEventHandlerError(int errcode) override; /** Sets the error message for this socket. Once set, the socket is dead. */ void SetError(const std::string& err) { if (error.empty()) error = err; } /** Retrieves the error message for this socket. */ const std::string& GetError() const { return error; } /** Called when new data is present in the receive queue. */ virtual void OnDataReady() = 0; /** Called when the socket gets an error from socket engine or I/O hook. */ virtual void OnError(BufferedSocketError e) = 0; /** Called when the local socket address address is changed. * @param sa The new local socket address. * @return true if the connection is still open, false if it has been closed */ virtual bool OnChangeLocalSocketAddress(const irc::sockets::sockaddrs& sa) { return true; } /** Called when the remote socket address address is changed. * @param sa The new remote socket address. * @return true if the connection is still open, false if it has been closed */ virtual bool OnChangeRemoteSocketAddress(const irc::sockets::sockaddrs& sa) { return true; } /** Send the given data out the socket, either now or when writes unblock */ void WriteData(const std::string& data); /** Retrieves the current size of the send queue. */ size_t GetSendQSize() const; /** Retrieves the send queue. */ SendQueue& GetSendQ() { return sendq; } /** * Close the socket, remove from socket engine, etc */ virtual void Close(); /** If writeblock is true then only close the socket if all data has been sent. Otherwise, close immediately. */ void Close(bool writeblock); /** This ensures that close is called prior to destructor */ Cullable::Result Cull() override; /** Get the IOHook of a module attached to this socket * @param mod Module whose IOHook to return * @return IOHook belonging to the module or NULL if the module haven't attached an IOHook to this socket */ IOHook* GetModHook(Module* mod) const; /** Get the last IOHook attached to this socket * @return The last IOHook attached to this socket or NULL if no IOHooks are attached */ IOHook* GetLastHook() const; }; /** * BufferedSocket is an extendable socket class which modules * can use for TCP socket support. It is fully integrated * into InspIRCds socket loop and attaches its sockets to * the core's instance of the SocketEngine class, meaning * that all use is fully asynchronous. * * To use BufferedSocket, you must inherit a class from it. */ class CoreExport BufferedSocket : public StreamSocket { public: /** Timeout object or NULL */ SocketTimeout* Timeout = nullptr; /** * The state for this socket, either * listening, connecting, connected * or error. */ BufferedSocketState state; BufferedSocket(); /** * This constructor is used to associate * an existing connecting with an BufferedSocket * class. The given file descriptor must be * valid, and when initialized, the BufferedSocket * will be placed in CONNECTED state. */ BufferedSocket(int newfd); ~BufferedSocket() override; /** Begin connection to the given address * This will create a socket, register with socket engine, and start the asynchronous * connection process. If an error is detected at this point (such as out of file descriptors), * OnError will be called; otherwise, the state will become CONNECTING. * @param dest Remote endpoint to connect to. * @param bind Local endpoint to connect from. * @param maxtime Time to wait for connection * @param protocol The protocol to use when connecting. */ void DoConnect(const irc::sockets::sockaddrs& dest, const irc::sockets::sockaddrs& bind, unsigned long maxtime, sa_family_t protocol = AF_UNSPEC); /** This method is called when an outbound connection on your socket is * completed. */ virtual void OnConnected(); /** When there is data waiting to be read on a socket, the OnDataReady() * method is called. */ void OnDataReady() override = 0; /** * When an outbound connection fails, and the attempt times out, you * will receive this event. The method will trigger once maxtime * seconds are reached (as given in the constructor) just before the * socket's descriptor is closed. A failed DNS lookup may cause this * event if the DNS server is not responding, as well as a failed * connect() call, because DNS lookups are nonblocking as implemented by * this class. */ virtual void OnTimeout(); protected: void OnEventHandlerWrite() override; BufferedSocketError BeginConnect(const irc::sockets::sockaddrs& dest, const irc::sockets::sockaddrs& bind, unsigned long timeout, sa_family_t protocol = AF_UNSPEC); }; inline IOHook* StreamSocket::GetIOHook() const { return iohook; } inline void StreamSocket::DelIOHook() { iohook = nullptr; } �����������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/include/stringutils.h����������������������������������������������������������������0000664�0000000�0000000�00000015525�14771603147�0017542�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2013, 2021-2024 Sadie Powell <sadie@witchery.services> * Copyright (C) 2013 Attila Molnar <attilamolnar@hush.com> * Copyright (C) 2012 Robby <robby@chatbelgie.be> * Copyright (C) 2008 Robin Burchell <robin+git@viroteck.net> * Copyright (C) 2007 Dennis Friis <peavey@inspircd.org> * Copyright (C) 2007 Craig Edwards <brain@inspircd.org> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #pragma once namespace Base64 { /** The default table used when handling Base64-encoded strings. */ inline constexpr const char* TABLE = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"; /** Decodes a Base64-encoded byte array. * @param data The byte array to decode from. * @param length The length of the byte array. * @param table The index table to use for decoding. * @return The decoded form of the specified data. */ CoreExport std::string Decode(const void* data, size_t length, const char* table = nullptr); /** Decodes a Base64-encoded string. * @param data The string to decode from. * @param table The index table to use for decoding. * @return The decoded form of the specified data. */ inline std::string Decode(const std::string& data, const char* table = nullptr) { return Decode(data.c_str(), data.length(), table); } /** Encodes a byte array using Base64. * @param data The byte array to encode from. * @param length The length of the byte array. * @param table The index table to use for encoding. * @param padding If non-zero then the character to pad encoded strings with. * @return The encoded form of the specified data. */ CoreExport std::string Encode(const void* data, size_t length, const char* table = nullptr, char padding = 0); /** Encodes a string using Base64. * @param data The string to encode from. * @param table The index table to use for encoding. * @param padding If non-zero then the character to pad encoded strings with. * @return The encoded form of the specified data. */ inline std::string Encode(const std::string& data, const char* table = nullptr, char padding = 0) { return Encode(data.c_str(), data.length(), table, padding); } } namespace Hex { /** The table used for encoding as a lower-case hexadecimal string. */ inline constexpr const char* TABLE_LOWER = "0123456789abcdef"; /** The table used for encoding as an upper-case hexadecimal string. */ inline constexpr const char* TABLE_UPPER = "0123456789ABCDEF"; /** Decodes a hexadecimal-encoded byte array. * @param data The byte array to decode from. * @param length The length of the byte array. * @param separator If non-zero then the character hexadecimal digits are separated with. * @param table The index table to use for decoding. * @return The decoded form of the specified data. */ CoreExport std::string Decode(const void* data, size_t length, const char* table = nullptr, char separator = 0); /** Decodes a hexadecimal-encoded string. * @param data The string to decode from. * @param table The index table to use for decoding. * @param separator If non-zero then the character hexadecimal digits are separated with. * @return The decoded form of the specified data. */ inline std::string Decode(const std::string& data, const char* table = nullptr, char separator = 0) { return Decode(data.c_str(), data.length(), table, separator); } /** Encodes a byte array using hexadecimal encoding. * @param data The byte array to encode from. * @param length The length of the byte array. * @param table The index table to use for encoding. * @param separator If non-zero then the character to separate hexadecimal digits with. * @return The encoded form of the specified data. */ CoreExport std::string Encode(const void* data, size_t length, const char* table = nullptr, char separator = 0); /** Encodes a string using Base64. * @param data The string to encode from. * @param table The index table to use for encoding. * @param separator If non-zero then the character to separate hexadecimal digits with. * @return The encoded form of the specified data. */ inline std::string Encode(const std::string& data, const char* table = nullptr, char separator = 0) { return Encode(data.c_str(), data.length(), table, separator); } } namespace Percent { /** The table used to determine what characters are safe within a percent-encoded string. */ inline constexpr const char* TABLE = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_.~"; /** Decodes a percent-encoded byte array. * @param data The byte array to decode from. * @param length The length of the byte array. * @return The decoded form of the specified data. */ CoreExport std::string Decode(const void* data, size_t length); /** Decodes a percent-encoded string. * @param data The string to decode from. * @return The decoded form of the specified data. */ inline std::string Decode(const std::string& data) { return Decode(data.c_str(), data.length()); } /** Encodes a byte array using percent encoding. * @param data The byte array to encode from. * @param length The length of the byte array. * @param table The table of characters that do not require escaping. * @param upper Whether to use upper or lower case. * @return The encoded form of the specified data. */ CoreExport std::string Encode(const void* data, size_t length, const char* table = nullptr, bool upper = true); /** Encodes a string using percent encoding. * @param data The string to encode from. * @param table The table of characters that do not require escaping. * @param upper Whether to use upper or lower case. * @return The encoded form of the specified data. */ inline std::string Encode(const std::string& data, const char* table = nullptr, bool upper = true) { return Encode(data.c_str(), data.length(), table, upper); } } namespace Template { /** A mapping of variable names to their values. */ typedef insp::flat_map<std::string, std::string> VariableMap; /** Replaces template variables like %foo% within a string. * @param str The string to template from. * @param vars The variables to replace within the string. * @return The specified string with all variables replaced within it. */ CoreExport std::string Replace(const std::string& str, const VariableMap& vars); } ���������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/include/thread.h���������������������������������������������������������������������0000664�0000000�0000000�00000003760�14771603147�0016420�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2019, 2021 Sadie Powell <sadie@witchery.services> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #pragma once #include <thread> class CoreExport Thread { private: /** Whether this thread is in the process of stopping. */ std::atomic_bool stopping = { false }; /** The underlying C++ thread. */ std::thread* thread = nullptr; /** Internal callback which sets up the thread and calls OnStart. * @param thread A thread which is starting up. */ static void StartInternal(Thread* thread); protected: /** Callback which is executed on this thread after it has started. */ virtual void OnStart() = 0; /** Callback which is executed on the calling thread before this thread is stopped. */ virtual void OnStop() { } /** Initialises an instance of the Thread class. */ Thread() = default; public: /** Destroys an instance of the Thread class. */ virtual ~Thread() = default; /** Determines whether this thread is currently running. */ bool IsRunning() const { return thread; } /** Determines whether this thread is currently stopping. */ bool IsStopping() const { return stopping.load(); } /** Starts the execution of this thread. * @return True if the thread was started, false if it was already running. */ bool Start(); /** Stops the execution of this thread. * @return True if the thread was stopped, false if it was already stopped. */ bool Stop(); }; ����������������inspircd-4.7.0/include/threadsocket.h���������������������������������������������������������������0000664�0000000�0000000�00000003535�14771603147�0017631�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2019, 2021 Sadie Powell <sadie@witchery.services> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #pragma once #include <condition_variable> #include <mutex> class ThreadSignalSocket; class CoreExport SocketThread : public Thread { private: std::mutex mutex; std::condition_variable_any condvar; ThreadSignalSocket* socket; protected: /** Waits for an enqueue operation to complete * You MUST hold the queue lock when you call this. * It will be unlocked while you wait, and will be relocked * before the function returns */ void WaitForQueue() { condvar.wait(mutex); } public: /** Notifies parent by making the SignalFD ready to read * No requirements on locking */ void NotifyParent(); SocketThread(); ~SocketThread() override; /** Lock queue. */ void LockQueue() { mutex.lock(); } /** Unlock queue. */ void UnlockQueue() { mutex.unlock(); } /** Unlock queue and send wakeup to worker */ void UnlockQueueWakeup() { condvar.notify_all(); mutex.unlock(); } void OnStop() override { mutex.lock(); condvar.notify_all(); mutex.unlock(); } /** * Called in the context of the parent thread after a notification * has passed through the socket */ virtual void OnNotify() = 0; }; �������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/include/timer.h����������������������������������������������������������������������0000664�0000000�0000000�00000007754�14771603147�0016300�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2021 Dominic Hamon * Copyright (C) 2013-2014 Attila Molnar <attilamolnar@hush.com> * Copyright (C) 2013, 2021-2023 Sadie Powell <sadie@witchery.services> * Copyright (C) 2012 Robby <robby@chatbelgie.be> * Copyright (C) 2009 Daniel De Graaf <danieldg@inspircd.org> * Copyright (C) 2007-2008 Robin Burchell <robin+git@viroteck.net> * Copyright (C) 2007 Dennis Friis <peavey@inspircd.org> * Copyright (C) 2006-2007 Craig Edwards <brain@inspircd.org> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #pragma once class Module; /** Timer class for one-second resolution timers * Timer provides a facility which allows module * developers to create one-shot timers. The timer * can be made to trigger at any time up to a one-second * resolution. To use Timer, inherit a class from * Timer, then insert your inherited class into the * queue using Server::AddTimer(). The Tick() method of * your object (which you have to override) will be called * at the given time. */ class CoreExport Timer { /** The triggering time */ time_t trigger = 0; /** Number of seconds between triggers */ unsigned long secs; /** True if this is a repeating timer */ bool repeat; public: /** Default constructor, initializes the triggering time * @param secs_from_now The number of seconds from now to trigger the timer * @param repeating Repeat this timer every secs_from_now seconds if set to true */ Timer(unsigned long secs_from_now, bool repeating); /** Default destructor, removes the timer from the timer manager */ virtual ~Timer(); /** Retrieves the time at which this timer will tick next. If the timer is not active then 0 will be returned. */ time_t GetTrigger() const { return trigger; } /** Sets the trigger timeout to a new value * This does not update the bookkeeping in TimerManager, use SetInterval() * to change the interval between ticks while keeping TimerManager updated */ void SetTrigger(time_t nexttrigger) { trigger = nexttrigger; } /** Sets the interval between two ticks. */ void SetInterval(unsigned long interval, bool restart = true); /** Called when the timer ticks. * You should override this method with some useful code to * handle the tick event. * @return True if the Timer object is still valid, false if it was destructed. */ virtual bool Tick() = 0; /** Returns true if this timer is set to repeat */ bool GetRepeat() const { return repeat; } /** Returns the interval (number of seconds between ticks) * of this timer object. */ unsigned long GetInterval() const { return secs; } /** Cancels the repeat state of a repeating timer. * If you call this method, then the next time your * timer ticks, it will be removed immediately after. */ void CancelRepeat() { repeat = false; } }; /** This class manages sets of Timers, and triggers them at their defined times. * This will ensure timers are not missed, as well as removing timers that have * expired and allowing the addition of new ones. */ class CoreExport TimerManager final { typedef std::multimap<time_t, Timer*> TimerMap; /** A list of all pending timers */ TimerMap Timers; public: /** Tick all pending Timers */ void TickTimers(); /** Add an Timer * @param T an Timer derived class to add */ void AddTimer(Timer* T); /** Remove a Timer * @param T an Timer derived class to remove */ void DelTimer(Timer* T); }; ��������������������inspircd-4.7.0/include/timeutils.h������������������������������������������������������������������0000664�0000000�0000000�00000010443�14771603147�0017164�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2023-2025 Sadie Powell <sadie@witchery.services> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #pragma once namespace Duration { /** Converts a string containing a duration to the number of seconds it * represents returning 0 on error. * * The string should should be in the format 1y2w3d4h6m5s which represents * one year, two weeks, three days, four hours, six minutes, and five * seconds. If called with this duration 33,019,565 will be returned. * * @param str A string containing a duration. * @return Either the number of seconds in the duration or 0 on error. */ CoreExport unsigned long From(const std::string& str); /** Determines whether a duration string is valid. * @param str The duration string to check. */ CoreExport bool IsValid(const std::string& str); /** Converts a number of seconds to a human-readable duration string. * * e.g. 33,019,565 will result in 1 year, 2 weeks, 3 days, 4 hours, 6 * minutes, 5 seconds. * * @param duration The number of seconds to convert. * @param brief Whether to round to the nearest time period. */ CoreExport std::string ToLongString(unsigned long duration, bool brief = false); /** Converts a number of seconds to a duration string. * * e.g. 33,019,565 will result in 1y2w3d4h6m5s which represents one year, * two weeks, three days, four hours, six minutes, and five seconds. * * @param duration The number of seconds to convert. */ CoreExport std::string ToString(unsigned long duration); /** Attempts to converts a string containing a duration to the number of * seconds it represents returning whether the conversion succeeded. * * The string should should be in the format 1y2w3d4h6m5s which represents * one year, two weeks, three days, four hours, six minutes, and five * seconds. If called with this duration 33,019,565 will be returned. * * @param str A string containing a duration. * @param duration The location to store the resulting duration. * @param base The base time to use for leap year calculation. * @return True if the conversion succeeded; otherwise, false. */ CoreExport bool TryFrom(const std::string& str, unsigned long& duration); } namespace Time { /** A short time format picked for being readable (e.g. "Sun 23 Mar 2025 10:20:30") */ inline constexpr const char* DEFAULT_SHORT = "%a %d %b %Y %H:%M:%S"; /** A long time format picked for being readable (e.g. "Sunday, 23 March 2025 @ 10:20:30 GMT"). */ inline constexpr const char* DEFAULT_LONG = "%A, %d %B %Y @ %H:%M:%S %Z"; /** The time format specified in ISO 8601 (e.g. "2025-03-23T10:20:30+0000") */ inline constexpr const char* ISO_8601 = "%Y-%m-%dT%H:%M:%S%z"; /** The time format specified in RFC 1123 (e.g. "Sun, 23 Mar 2025 10:20:30 GMT") */ inline constexpr const char* RFC_1123 = "%a, %d %b %Y %H:%M:%S %Z"; /** Converts a UNIX timestamp to a time string. * * @param ts The timestamp to convert to a string. * @param format A snprintf format string to output the timestamp in. * @param utc If the timestamp is a UTC timestamp then true or false if the * timestamp is a local timestamp. */ CoreExport std::string ToString(time_t ts, const char* format = nullptr, bool utc = false); /** Converts a duration from now to a time string. * * @param duration The duration from now to convert to a string. * @param format A snprintf format string to output the timestamp in. * @param utc If the timestamp is a UTC timestamp then true or false if the * timestamp is a local timestamp. */ inline std::string FromNow(unsigned long duration, const char* format = nullptr, bool utc = false) { return ToString(ServerInstance->Time() + duration, format, utc); } } �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/include/token_list.h�����������������������������������������������������������������0000664�0000000�0000000�00000004436�14771603147�0017325�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2023 Sadie Powell <sadie@witchery.services> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #pragma once #include "compat.h" /** Encapsulates a list of tokens in the format "* -FOO -BAR".*/ class CoreExport TokenList final { private: /** Whether this list includes all tokens by default. */ bool permissive = false; /** Either the tokens to exclude if in permissive mode or the tokens to include if in strict mode. */ insp::flat_set<std::string, irc::insensitive_swo> tokens; public: /** Creates a new empty token list. */ TokenList() = default; /** Creates a new token list from a list of tokens. */ TokenList(const std::string& tokenlist); /** Adds a space-delimited list of tokens to the token list. * @param tokenlist The list of space-delimited tokens to add. */ void AddList(const std::string& tokenlist); /** Adds a single token to the token list. * @param token The token to add. */ void Add(const std::string& token); /** Removes all tokens from the token list. */ void Clear(); /** Determines whether the specified token exists in the token list. * @param token The token to search for. */ bool Contains(const std::string& token) const; /** Removes the specified token from the token list. * @param token The token to remove. */ void Remove(const std::string& token); /** Retrieves a string which represents the contents of this token list. */ std::string ToString() const; /** Determines whether the specified token list contains the same tokens as this instance. * @param other The tokenlist to compare against. * @return True if the token lists are equal; otherwise, false. */ bool operator==(const TokenList& other) const; }; ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/include/typedefs.h�������������������������������������������������������������������0000664�0000000�0000000�00000004541�14771603147�0016772�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2013-2014, 2016, 2018 Attila Molnar <attilamolnar@hush.com> * Copyright (C) 2013, 2018, 2020, 2022 Sadie Powell <sadie@witchery.services> * Copyright (C) 2012 Robby <robby@chatbelgie.be> * Copyright (C) 2009 Daniel De Graaf <danieldg@inspircd.org> * Copyright (C) 2007 Dennis Friis <peavey@inspircd.org> * Copyright (C) 2005 Craig Edwards <brain@inspircd.org> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #pragma once class Channel; class ConfigStatus; class ConfigTag; class Extensible; class FakeUser; class InspIRCd; class IOHookProvider; class LocalUser; class ModResult; class Module; class OperAccount; class OperType; class RemoteUser; class Server; class User; class XLine; class XLineFactory; class XLineManager; namespace ClientProtocol { class Event; class EventProvider; class Message; class MessageTagEvent; class MessageTagProvider; class Serializer; typedef std::vector<Message*> MessageList; typedef std::vector<std::string> ParamList; typedef std::string SerializedMessage; struct CoreExport MessageTagData final { MessageTagProvider* tagprov; std::string value; void* provdata; MessageTagData(MessageTagProvider* prov, const std::string& val, void* data = nullptr); }; /** Map of message tag values and providers keyed by their name. * Sorted in descending order to ensure tag names beginning with symbols (such as '+') come later when iterating * the container than tags with a normal name. */ typedef insp::flat_map<std::string, MessageTagData, std::greater<>> TagMap; } #include "hashcomp.h" #include "base.h" /** Generic user list, used for exceptions */ typedef std::set<User*> CUList; /** A bitset of characters which are enabled/set. */ typedef std::bitset<UCHAR_MAX + 1> CharState; ���������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/include/uid.h������������������������������������������������������������������������0000664�0000000�0000000�00000003673�14771603147�0015735�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2013, 2019, 2021-2022 Sadie Powell <sadie@witchery.services> * Copyright (C) 2013 Attila Molnar <attilamolnar@hush.com> * Copyright (C) 2012 Robby <robby@chatbelgie.be> * Copyright (C) 2007 Robin Burchell <robin+git@viroteck.net> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #pragma once class CoreExport UIDGenerator final { private: /** Holds the current UID. Used to generate the next one. */ std::string current_uid; /** Increments the current UID by one. */ void IncrementUID(unsigned int pos); public: /** * This is the maximum length of a UUID (unique user identifier). * It allows up to 12,960 servers and 2,176,782,336 users per server. */ static constexpr unsigned int UUID_LENGTH = 9; /** Initializes this UID generator with the given SID * @param sid SID that conforms to InspIRCd::IsSID() */ void init(const std::string& sid); /** Returns the next available UID for this server. */ std::string GetUID(); /** Generates a pseudorandom SID based on a servername and a description * Guaranteed to return the same if invoked with the same parameters * @param servername The server name to use as seed * @param serverdesc The server description to use as seed * @return A valid SID */ static std::string GenerateSID(const std::string& servername, const std::string& serverdesc); }; ���������������������������������������������������������������������inspircd-4.7.0/include/usermanager.h����������������������������������������������������������������0000664�0000000�0000000�00000025354�14771603147�0017465�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2015 Adam <Adam@anope.org> * Copyright (C) 2012-2016 Attila Molnar <attilamolnar@hush.com> * Copyright (C) 2012-2013, 2017, 2019-2024 Sadie Powell <sadie@witchery.services> * Copyright (C) 2012 Robby <robby@chatbelgie.be> * Copyright (C) 2009 Daniel De Graaf <danieldg@inspircd.org> * Copyright (C) 2008 Robin Burchell <robin+git@viroteck.net> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #pragma once #include <list> /** A mapping of user nicks or uuids to their User object. */ typedef std::unordered_map<std::string, User*, irc::insensitive, irc::StrHashComp> UserMap; class CoreExport UserManager final { public: struct CloneCounts final { unsigned int global = 0; unsigned int local = 0; }; /** Container that maps IP addresses to clone counts */ typedef std::map<irc::sockets::cidr_mask, CloneCounts> CloneMap; /** Sequence container in which each element is a User* */ typedef std::vector<User*> OperList; /** A list containing users who are on a services server. */ typedef std::vector<User*> ServiceList; /** A list holding local users */ typedef insp::intrusive_list<LocalUser> LocalList; private: /** Map of IP addresses for clone counting */ CloneMap clonemap; /** A CloneCounts that contains zero for both local and global */ const CloneCounts zeroclonecounts; /** Local client list, a list containing only local clients */ LocalList local_users; /** Last used already sent id, used when sending messages to neighbors to help determine whether the message has * been sent to a particular user or not. See User::ForEachNeighbor() for more info. */ uint64_t already_sent_id = 0; public: /** Constructor, initializes variables */ UserManager(); /** Destructor, destroys all users in clientlist */ ~UserManager(); /** Nickname string -> User* map. Contains all users, including partially connected ones. */ UserMap clientlist; /** UUID -> User* map. Contains all users, including partially connected ones. */ UserMap uuidlist; /** Oper list, a vector containing all local and remote opered users */ OperList all_opers; /** A list of users on services servers. */ ServiceList all_services; /** Number of local unknown (not fully connected) users. */ size_t unknown_count = 0; /** Perform background user events for all local users such as PING checks, connection timeouts, * penalty management and recvq processing for users who have data in their recvq due to throttling. */ void DoBackgroundUserStuff(); /** Handle a client connection. * Creates a new LocalUser object, inserts it into the appropriate containers, * initializes it as not fully connected, and adds it to the socket engine. * * The new user may immediately be quit after being created, for example if the user limit * is reached or if the user is banned. * @param socket File descriptor of the connection * @param via Listener socket that this user connected to * @param client The IP address and client port of the user * @param server The server IP address and port used by the user */ void AddUser(int socket, ListenSocket* via, const irc::sockets::sockaddrs& client, const irc::sockets::sockaddrs& server) ATTR_NOT_NULL(3); /** Disconnect a user gracefully. * When this method returns the user provided will be quit, but the User object will continue to be valid and will be deleted at the end of the current main loop iteration. * @param user The user to remove * @param quitreason The quit reason to show to normal users * @param operreason The quit reason to show to opers, can be NULL if same as quitreason */ void QuitUser(User* user, const std::string& quitreason, const std::string* operreason = nullptr) ATTR_NOT_NULL(2); /** Add a user to the clone map * @param user The user to add */ void AddClone(User* user) ATTR_NOT_NULL(2); /** Remove all clone counts from the user, you should * use this if you change the user's IP address * after they have fully connected. * @param user The user to remove */ void RemoveCloneCounts(User* user) ATTR_NOT_NULL(2); /** Rebuild clone counts. Required when \<cidr> settings change. */ void RehashCloneCounts(); /** Rebuilds the list of services servers. Required when \<services> settings change. */ void RehashServices(); /** Return the number of local and global clones of this user * @param user The user to get the clone counts for * @return The clone counts of this user. The returned reference is volatile - you * must assume that it becomes invalid as soon as you call any function other than * your own. */ const CloneCounts& GetCloneCounts(User* user) const ATTR_NOT_NULL(2); /** Return a map containing IP addresses and their clone counts * @return The clone count map */ const CloneMap& GetCloneMap() const { return clonemap; } /** Return a count of local unknown (not fully connected) users. * @return The number of local unknown (not fully connected) users. */ size_t UnknownUserCount() const { return this->unknown_count; } /** Return a count of users on a services servers. * @return The number of users on services servers. */ size_t ServiceCount() const { return this->all_services.size(); } /** Return a count of fully connected connections on this server. * @return The number of fully connected users on this server. */ size_t LocalUserCount() const { return this->local_users.size() - this->UnknownUserCount(); } /** Return a count of fully connected connections on the network. * @return The number of fully connected users on the network. */ size_t GlobalUserCount() const { return this->clientlist.size() - this->UnknownUserCount(); } /** Get a hash map containing all users, keyed by their nickname * @return A hash map mapping nicknames to User pointers */ UserMap& GetUsers() { return clientlist; } /** Get a list containing all local users * @return A const list of local users */ const LocalList& GetLocalUsers() const { return local_users; } /** Retrieves the next already sent id, guaranteed to be not equal to any user's already_sent field * @return Next already_sent id */ uint64_t NextAlreadySentId(); /** Find a user by their nickname or UUID. * IMPORTANT: You probably want to use FindNick or FindUUID instead of this. * @param nickuuid The nickname or UUID of the user to find. * @param fullyconnected Whether to only return users who are fully connected to the server. * @return If the user was found then a pointer to a User object; otherwise, nullptr. */ User* Find(const std::string& nickuuid, bool fullyconnected = false); /** Find a local user by their nickname or UUID. * IMPORTANT: You probably want to use FindNick or FindUUID instead of this. * @param nickuuid The nickname or UUID of the user to find. * @param fullyconnected Whether to only return users who are fully connected to the server. * @return If the user was found then a pointer to a User object; otherwise, nullptr. */ template<typename T> std::enable_if_t<std::is_same_v<T, LocalUser>, T*> Find(const std::string& nickuuid, bool fullyconnected = false) { return IS_LOCAL(Find(nickuuid, fullyconnected)); } /** Find a remote user by their nickname or UUID. * IMPORTANT: You probably want to use FindNick or FindUUID instead of this. * @param nickuuid The nickname or UUID of the user to find. * @param fullyconnected Whether to only return users who are fully connected to the server. * @return If the user was found then a pointer to a User object; otherwise, nullptr. */ template<typename T> std::enable_if_t<std::is_same_v<T, RemoteUser>, T*> Find(const std::string& nickuuid, bool fullyconnected = false) { return IS_REMOTE(Find(nickuuid, fullyconnected)); } /** Find a user by their nickname. * @param nick The nickname of the user to find. * @param fullyconnected Whether to only return users who are fully connected to the server. * @return If the user was found then a pointer to a User object; otherwise, nullptr. */ User* FindNick(const std::string& nick, bool fullyconnected = false); /** Find a local user by their nickname. * @param nick The nickname of the user to find. * @param fullyconnected Whether to only return users who are fully connected to the server. * @return If the user was found then a pointer to a User object; otherwise, nullptr. */ template<typename T> std::enable_if_t<std::is_same_v<T, LocalUser>, T*> FindNick(const std::string& nick, bool fullyconnected = false) { return IS_LOCAL(FindNick(nick, fullyconnected)); } /** Find a remote user by their nickname. * @param nick The nickname of the user to find. * @param fullyconnected Whether to only return users who are fully connected to the server. * @return If the user was found then a pointer to a User object; otherwise, nullptr. */ template<typename T> std::enable_if_t<std::is_same_v<T, RemoteUser>, T*> FindNick(const std::string& nick, bool fullyconnected = false) { return IS_REMOTE(FindNick(nick, fullyconnected)); } /** Find a user by their UUID. * @param uuid The UUID of the user to find. * @param fullyconnected Whether to only return users who are fully connected to the server. * @return If the user was found then a pointer to a User object; otherwise, nullptr. */ User* FindUUID(const std::string& uuid, bool fullyconnected = false); /** Find a local user by their UUID. * @param uuid The UUID of the user to find. * @param fullyconnected Whether to only return users who are fully connected to the server. * @return If the user was found then a pointer to a User object; otherwise, nullptr. */ template<typename T> std::enable_if_t<std::is_same_v<T, LocalUser>, T*> FindUUID(const std::string& uuid, bool fullyconnected = false) { return IS_LOCAL(FindUUID(uuid, fullyconnected)); } /** Find a remote user by their UUID. * @param uuid The UUID of the user to find. * @param fullyconnected Whether to only return users who are fully connected to the server. * @return If the user was found then a pointer to a User object; otherwise, nullptr. */ template<typename T> std::enable_if_t<std::is_same_v<T, RemoteUser>, T*> FindUUID(const std::string& uuid, bool fullyconnected = false) { return IS_REMOTE(FindUUID(uuid, fullyconnected)); } }; ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/include/users.h����������������������������������������������������������������������0000664�0000000�0000000�00000105132�14771603147�0016306�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2019 Matt Schatz <genius3000@g3k.solutions> * Copyright (C) 2012-2016, 2018 Attila Molnar <attilamolnar@hush.com> * Copyright (C) 2012-2013, 2016-2024 Sadie Powell <sadie@witchery.services> * Copyright (C) 2012, 2019 Robby <robby@chatbelgie.be> * Copyright (C) 2012 DjSlash <djslash@djslash.org> * Copyright (C) 2011 jackmcbarn <jackmcbarn@inspircd.org> * Copyright (C) 2009-2010 Daniel De Graaf <danieldg@inspircd.org> * Copyright (C) 2008 Thomas Stagner <aquanight@gmail.com> * Copyright (C) 2008 John Brooks <john@jbrooks.io> * Copyright (C) 2007, 2009 Dennis Friis <peavey@inspircd.org> * Copyright (C) 2006-2009 Robin Burchell <robin+git@viroteck.net> * Copyright (C) 2003-2008 Craig Edwards <brain@inspircd.org> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #pragma once #include "socket.h" #include "streamsocket.h" #include "mode.h" #include "membership.h" /** Represents \<connect> class tags from the server config */ class CoreExport ConnectClass final { public: /** An enumeration of possible types of connect class. */ enum Type : uint8_t { /** The class defines who is allowed to connect to the server. */ ALLOW = 0, /** The class defines who is banned from connecting to the server. */ DENY = 1, /** The class is for server operators to be assigned to by name. */ NAMED = 2, }; /** The synthesized (with all inheritance applied) config tag this class was read from. */ std::shared_ptr<ConfigTag> config; /** The hosts that this user can connect from. */ std::vector<std::string> hosts; /** The name of this connect class. */ std::string name; /** If non-empty then the password a user must specify in PASS to be assigned to this class. */ std::string password; /** If non-empty then the hash algorithm that the password field is hashed with. */ std::string passwordhash; /** If non-empty then the server ports which a user has to be connecting on. */ insp::flat_set<in_port_t> ports; /** The type of class this. */ Type type; /** Whether fake lag is used by this class. */ bool fakelag:1; /** Whether to warn server operators about the limit for this class being reached. */ bool maxconnwarn:1; /** Whether the DNS hostnames of users in this class should be resolved. */ bool resolvehostnames:1; /** Whether this class is for a shared host where the username uniquely identifies users. */ bool uniqueusername:1; /** Maximum rate of commands (units: millicommands per second). */ unsigned long commandrate = 1000UL; /** The maximum number of bytes that users in this class can have in their send queue before they are disconnected. */ unsigned long hardsendqmax = 1048576UL; /** The maximum number of users in this class that can connect to the local server from one host. */ unsigned long limit = 5000UL; /** The maximum number of channels that users in this class can join. */ unsigned long maxchans = 20UL; /** The maximum number of users in this class that can connect to the entire network from one host. */ unsigned long maxglobal = 3UL; /** The maximum number of users that can be in this class on the local server. */ unsigned long maxlocal = 3UL; /** The amount of penalty that a user in this class can have before the penalty system activates. */ unsigned long penaltythreshold = 20UL; /** The number of seconds between keepalive checks for idle clients in this class. */ unsigned long pingtime = 120UL; /** The maximum number of bytes that users in this class can have in their receive queue before they are disconnected. */ unsigned long recvqmax = 4096UL; /** The number of seconds that connecting users have to fully connect within in this class. */ unsigned long connection_timeout = 90UL; /** The maximum number of bytes that users in this class can have in their send queue before their commands stop being processed. */ unsigned long softsendqmax = 4096UL; /** The number of users who are currently assigned to this class. */ unsigned long use_count = 0UL; /** Creates a new connect class from a config tag. */ ConnectClass(const std::shared_ptr<ConfigTag>& tag, Type type, const std::vector<std::string>& masks); /** Creates a new connect class with a parent from a config tag. */ ConnectClass(const std::shared_ptr<ConfigTag>& tag, Type type, const std::vector<std::string>& masks, const std::shared_ptr<ConnectClass>& parent); /** Configures this connect class using the config from the specified tag. */ void Configure(const std::string& classname, const std::shared_ptr<ConfigTag>& tag); /** Update the settings in this block to match the given class */ void Update(const std::shared_ptr<ConnectClass>& klass); /** Retrieves the name of this connect class. */ const std::string& GetName() const { return name; } /** Retrieves the hosts for this connect class. */ const std::vector<std::string>& GetHosts() const { return hosts; } }; class CoreExport AwayState final { public: /** The reason this user specified when they went away. */ std::string message; /** The time at which this user went away. */ time_t time; AwayState(const std::string& m, time_t t = 0); }; /** Represents an \<opertype> from the server config. */ class CoreExport OperType : public insp::uncopiable { protected: friend class OperAccount; /** Oper-only channel modes that an oper of this type can use. */ ModeParser::ModeStatus chanmodes; /** Oper-only commands that an oper of this type can use. */ TokenList commands; /** The config tag this oper type was created from. */ std::shared_ptr<ConfigTag> config; /** The name of this oper type. */ std::string name; /** Oper privileges that an oper of this type has. */ TokenList privileges; /** Oper snomasks that an oper of this type can use. */ ModeParser::ModeStatus snomasks; /** Oper-only user modes that an oper of this type can use. */ ModeParser::ModeStatus usermodes; /** Merges the specified config tag into this oper type's config. * @param tag The config tag to merge in. */ void MergeTag(const std::shared_ptr<ConfigTag>& tag); public: /** Creates a new oper type with the specified name and config tag. * @param n The name of the oper type. * @param t The tag to configure the oper type from. */ OperType(const std::string& n, const std::shared_ptr<ConfigTag>& t); /** Configures this oper type with settings from the specified tag. * @param tag The tag to configure from. * @param merge Whether to merge this tag into the synthetic tag. */ void Configure(const std::shared_ptr<ConfigTag>& tag, bool merge); /** Retrieves the config tag this oper type was created from. */ const auto& GetConfig() const { return config; } /** Retrieves the name of this oper type. */ const auto& GetName() const { return name; } /** Retrieves the commands that this oper type has access to. * @param all Whether to return all commands even if they don't currently exist. */ std::string GetCommands(bool all = false) const; /** Retrieves the modes that this oper type has access to. * @param mt The type of mode to retrieve. * @param all Whether to return all commands even if they don't currently exist. */ std::string GetModes(ModeType mt, bool all = false) const; /** Retrieves the privileges that this oper type has access to. */ std::string GetPrivileges() const { return privileges.ToString(); } /** Retrieves the snomasks that this oper type has access to. * @param all Whether to return all snomasks even if they don't currently exist. */ std::string GetSnomasks(bool all = false) const; /** Determines if this oper type can use the specified command. * @param cmd The command to check for. */ bool CanUseCommand(const std::string& cmd) const; /** Determines if this oper type can use the specified command. * @param cmd The command to check for. */ inline bool CanUseCommand(const Command* cmd) const { return CanUseCommand(cmd->name); } /** Determines if this oper type can use the specified mode. * @param mt The type of mode to check for. * @param chr The mode character to check for. */ bool CanUseMode(ModeType mt, unsigned char chr) const; /** Determines if this oper type can use the specified mode. * @param mh The mode to check for. */ inline bool CanUseMode(const ModeHandler* mh) const { return CanUseMode(mh->GetModeType(), mh->GetModeChar()); } /** Determines if this oper type can use the specified snomask. * @param chr The snomask to check for. */ bool CanUseSnomask(unsigned char chr) const; /** Determines if this oper type has the specified privilege. * @param priv The privilege to check for. */ bool HasPrivilege(const std::string& priv) const; }; #ifdef _WIN32 # undef STRICT // Defined by Windows SDK. #endif /** Represents an \<oper> from the server config. */ class CoreExport OperAccount : public OperType { protected: /** Possible states for whether an oper account can be automatically logged into. */ enum class AutoLogin : uint8_t { /** Users can automatically log in to this account if they match all fields and their nick matches the account name. */ STRICT, /** Users can automatically log in to this account if they match all fields. */ RELAXED, /** Users can not automatically log in to this account. */ NEVER, }; /** Whether this oper account can be automatically logged into. */ AutoLogin autologin; /** Whether the account can be logged into without a password. */ bool nopassword; /** The password to used to log into this oper account. */ std::string password; /** The algorithm to used to hash the password of this oper account. */ std::string passwordhash; /** The name of the underlying oper type. */ std::string type; public: /** Creates a new oper account with the specified name, oper type, and config tag. * @param n The name of the oper account. * @param o The oper type that this account inherits settings from. * @param t The tag to configure the oper account from. */ OperAccount(const std::string& n, const std::shared_ptr<OperType>& o, const std::shared_ptr<ConfigTag>& t); /** Check whether this user can attempt to automatically log in to this account. */ bool CanAutoLogin(LocalUser* user) const; /** Check the specified password against the one from this oper account's password. * @param pw The password to check. */ bool CheckPassword(const std::string& pw) const; /** Retrieves the name of the underlying oper type. */ const auto& GetType() const { return type; } }; /** Holds all information about a user * This class stores all information about a user connected to the irc server. Everything about a * connection is stored here primarily, from the user's socket ID (file descriptor) through to the * user's nickname and hostname. */ class CoreExport User : public Extensible { private: /** Cached value for GetAddress. */ std::string cached_address; /** Cached value for GetUserAddress. */ std::string cached_useraddress; /** Cached value for GetUserHost. */ std::string cached_userhost; /** Cached value for GetRealUserHost. */ std::string cached_realuserhost; /** Cached value for GetMask. */ std::string cached_mask; /** Cached value for GetRealMask. */ std::string cached_realmask; /** If set then the hostname which is displayed to users. */ std::string displayhost; /** The real hostname of this user. */ std::string realhost; /** The real name of this user. */ std::string realname; /** If set then the username which is displayed to users. */ std::string displayuser; /** The real username of this user from USER or an ident loookup. */ std::string realuser; /** The user's mode list. * Much love to the STL for giving us an easy to use bitset, saving us RAM. * if (modes[modeid]) is set, then the mode is set. * For example, to work out if mode +i is set, we check the field * User::modes[invisiblemode->modeid] == true. */ ModeParser::ModeStatus modes; public: /** To execute a function for each local neighbor of a user, inherit from this class and * pass an instance of it to User::ForEachNeighbor(). */ class ForEachNeighborHandler { public: /** Method to execute for each local neighbor of a user. * Derived classes must implement this. * @param user Current neighbor */ virtual void Execute(LocalUser* user) = 0; }; /** Represents the state of a connection to the server. */ enum ConnectionState : uint8_t { /** The user has not sent any commands. */ CONN_NONE = 0, /** The user has sent the NICK command. */ CONN_NICK = 1, /** The user has sent the USER command. */ CONN_USER = 2, /** The user has sent both the NICK and USER commands and is waiting to be fully connected. */ CONN_NICKUSER = CONN_NICK | CONN_USER, /** The user has sent both the NICK and USER commands and is fully connected */ CONN_FULL = 7, }; /** An enumeration of all possible types of user. */ enum Type : uint8_t { /** The user is connected to the local server. */ TYPE_LOCAL = 0, /** The user is connected to a remote server. */ TYPE_REMOTE = 1, /** The user is a server pseudo-user. */ TYPE_SERVER = 2, }; /** List of Memberships for this user */ typedef insp::intrusive_list<Membership> ChanList; /** A list of memberships to consider when discovering the neighbors of a user. */ typedef std::vector<Membership*> NeighborList; /** A list of exceptions to the memberships that are considered when discovering the neighbours of a user. */ typedef std::unordered_map<User*, bool> NeighborExceptions; /** The time at which this user's nickname was last changed. */ time_t nickchanged; /** Time the connection was created, set in the constructor. This * may be different from the time the user's Cullable object was * created. */ time_t signon = 0; /** Client address that the user is connected from. * Do not modify this value directly, use ChangeRemoteAddress() to change it. * Port is not valid for remote users. */ irc::sockets::sockaddrs client_sa; /** The users nickname. * Use InspIRCd::IsNick() to validate nicknames. */ std::string nick; /** The user's unique identifier. * This is the unique identifier which the user has across the network. */ const std::string uuid; /** What snomasks are set on this user. * This functions the same as the above modes. */ std::bitset<64> snomasks; /** Channels this user is on */ ChanList chans; /** The server the user is connected to. */ Server* server; /** If non-empty then the away state of this user. */ std::optional<AwayState> away; /** If non-null then the oper account this user is logged in to. */ std::shared_ptr<OperAccount> oper; /** The connection state of the user. */ unsigned int connected:3; /** If this is set to true, then all socket operations for the user * are dropped into the bit-bucket. * This value is set by QuitUser, and is not needed separately from that call. * Please note that setting this value alone will NOT cause the user to quit. */ unsigned int quitting:1; /** Whether the username field uniquely identifies this user on their origin host. */ bool uniqueusername:1; /** What type of user is this? */ const uint8_t usertype:2; /** Retrieves the username which should be included in bans for this user. */ const std::string& GetBanUser(bool real) const; /** Retrieves this user's hostname. * @param uncloak If true then return the real hostname; otherwise, the display hostname. */ inline const std::string& GetHost(bool uncloak) const { return uncloak ? GetRealHost() : GetDisplayedHost(); } /** Retrieves this user's username. * @param uncloak If true then return the real username; otherwise, the display username. */ inline const std::string& GetUser(bool uncloak) const { return uncloak ? GetRealUser() : GetDisplayedUser(); } /** Retrieves this user's displayed hostname. */ inline const std::string& GetDisplayedHost() const { return displayhost.empty() ? realhost : displayhost; } /** Retrieves this user's displayed username. */ inline const std::string& GetDisplayedUser() const { return displayuser.empty() ? realuser : displayuser; } /** Retrieves this user's real hostname. */ inline const std::string& GetRealHost() const { return realhost; } /** Retrieves this user's real username. */ inline const std::string& GetRealUser() const { return realuser; } /** Retrieves this user's real name. */ inline const std::string& GetRealName() const { return realname; } /** Get CIDR mask, using default range, for this user */ irc::sockets::cidr_mask GetCIDRMask() const; /** Retrieves the remote address (IPv4, IPv6, UNIX socket path) as a string. * If this method has not been called before then it will be cached. */ virtual const std::string& GetAddress(); /*** Retrieves the user@address mask for the user as a string. * If this method has not been called before then it will be cached. */ virtual const std::string& GetUserAddress(); /*** Retrieves the user@dhost mask for the user as a string. * If this method has not been called before then it will be cached. */ virtual const std::string& GetUserHost(); /*** Retrieves the user@rhost mask for the user as a string. * If this method has not been called before then it will be cached. */ virtual const std::string& GetRealUserHost(); /*** Retrieves the nick!user@dhost mask for the user as a string. * If this method has not been called before then it will be cached. */ virtual const std::string& GetMask(); /*** Retrieves the nick!user@dhost mask for the user as a string. * If this method has not been called before then it will be cached. */ virtual const std::string& GetRealMask(); /** Changes the remote socket address for this user. * @param sa The new socket address. */ virtual void ChangeRemoteAddress(const irc::sockets::sockaddrs& sa); /** Constructor * @throw CoreException if the UID allocated to the user already exists */ User(const std::string& uid, Server* srv, Type objtype); /** This clears any cached results that are used for GetFullRealHost() etc. * The results of these calls are cached as generating them can be generally expensive. */ void InvalidateCache(); /** Returns whether this user is currently away or not. If true, * further information can be found in away->message and away->time * @return True if the user is away, false otherwise */ inline bool IsAway() const { return away.has_value(); } /** Returns whether this user is an oper or not. If true, * oper information can be obtained from User::oper * @return True if the user is an oper, false otherwise */ bool IsOper() const { return !!oper; } /** Returns true if a notice mask is set * @param sm A notice mask character to check * @return True if the notice mask is set */ bool IsNoticeMaskSet(unsigned char sm) const; /** Get the mode letters of modes set on the user as a string. * @param includeparams True to get the parameters of the modes as well. Defaults to false. * @return Mode letters of modes set on the user and optionally the parameters of those modes, if any. * The returned string always begins with a '+' character. If the user has no modes set, "+" is returned. */ std::string GetModeLetters(bool includeparams = false) const; /** Returns true if a specific mode is set * @param m The user mode * @return True if the mode is set */ bool IsModeSet(unsigned char m) const; bool IsModeSet(const ModeHandler* mh) const; bool IsModeSet(const ModeHandler& mh) const { return IsModeSet(&mh); } bool IsModeSet(const UserModeReference& moderef) const; /** Set a specific usermode to on or off * @param mh The user mode * @param value On or off setting of the mode */ void SetMode(const ModeHandler* mh, bool value); void SetMode(const ModeHandler& mh, bool value) { SetMode(&mh, value); } /** Returns true or false for if a user can execute a privileged oper command. * This is done by looking up their oper type from User::oper, then referencing * this to their oper classes and checking the commands they can execute. * @param command A command (should be all CAPS) * @return True if this user can execute the command */ inline bool HasCommandPermission(const std::string& command) const { return IsOper() && oper->CanUseCommand(command); } /** Returns true if a user has a given permission. * This is used to check whether or not users may perform certain actions which admins may not wish to give to * all operators, yet are not commands. An example might be oper override, mass messaging (/notice $*), etc. * * @param privstr The priv to check, e.g. "users/override/topic". These are loaded free-form from the config file. * @return True if this user has the permission in question. */ inline bool HasPrivPermission(const std::string& privstr) const { return IsOper() && oper->HasPrivilege(privstr); } /** Returns true or false if a user can set a privileged user or channel mode. * This is done by looking up their oper type from User::oper, then referencing * this to their oper classes, and checking the modes they can set. * @param mh Mode to check * @return True if the user can set or unset this mode. */ inline bool HasModePermission(const ModeHandler* mh) const { return IsOper() && oper->CanUseMode(mh); } /** Determines whether this user can set the specified snomask. * @param chr The server notice mask character to look up. * @return True if the user can set the specified snomask; otherwise, false. */ inline bool HasSnomaskPermission(char chr) const { return IsOper() && oper->CanUseSnomask(chr); } /** Logs this user into the specified server operator account. * @param account The account to log this user in to. * @param automatic Whether this is an automatic login attempt. * @param force Whether to ignore any checks from OnPreOperLogin. * @return True if the user is logged into successfully; otherwise, false. */ bool OperLogin(const std::shared_ptr<OperAccount>& account, bool automatic = false, bool force = false); /** Logs this user out of their server operator account. Does nothing to non-operators. */ void OperLogout(); /** Write to all users that can see this user (including this user in the list if include_self is true), appending CR/LF * @param protoev Protocol event to send, may contain any number of messages. * @param include_self Should the message be sent back to the author? */ void WriteCommonRaw(ClientProtocol::Event& protoev, bool include_self = true); /** Sends a server notice to this user. * @param text The message to send. */ void WriteNotice(const std::string& text); /** Sends a server notice to this user. * @param text A format string to format and then send. * @param p One or more arguments to format the string with. */ template <typename... Param> void WriteNotice(const char* text, Param&&... p) { WriteNotice(fmt::vformat(text, fmt::make_format_args(p...))); } /** Sends a server notice from the local server to the user. * @param text The message to send. */ virtual void WriteRemoteNotice(const std::string& text); /** Sends a server notice to this user. * @param text A format string to format and then send. * @param p One or more arguments to format the string with. */ template <typename... Param> void WriteRemoteNotice(const char* text, Param&&... p) { WriteRemoteNotice(fmt::vformat(text, fmt::make_format_args(p...))); } /** Sends a notice to this user. * @param numeric The numeric to send. */ void WriteNumeric(const Numeric::Numeric& numeric); /** Sends a notice to this user. * @param numeric The numeric code to send. * @param p One or more parameters to the numeric. */ template <typename... Param> void WriteNumeric(unsigned int numeric, Param&&... p) { Numeric::Numeric n(numeric); n.push(std::forward<Param>(p)...); WriteNumeric(n); } /** Sends a notice from the local server to this user. * @param numeric The numeric to send. */ virtual void WriteRemoteNumeric(const Numeric::Numeric& numeric); /** Sends a notice from the local server to this user. * @param numeric The numeric code to send. * @param p One or more parameters to the numeric. */ template <typename... Param> void WriteRemoteNumeric(unsigned int numeric, Param&&... p) { Numeric::Numeric n(numeric); n.push(std::forward<Param>(p)...); WriteRemoteNumeric(n); } /** Execute a function once for each local neighbor of this user. By default, the neighbors of a user are the users * who have at least one common channel with the user. Modules are allowed to alter the set of neighbors freely. * This function is used for example to send something conditionally to neighbors, or to send different messages * to different users depending on their oper status. * @param handler Function object to call, inherited from ForEachNeighborHandler. * @param include_self True to include this user in the set of neighbors, false otherwise. * Modules may override this. Has no effect if this user is not local. */ uint64_t ForEachNeighbor(ForEachNeighborHandler& handler, bool include_self = true); /** Return true if the user shares at least one channel with another user * @param other The other user to compare the channel list against * @return True if the given user shares at least one channel with this user */ bool SharesChannelWith(User* other) const; /** Change the displayed hostname of this user. * @param newhost The new displayed hostname of this user. */ void ChangeDisplayedHost(const std::string& newhost); /** Change the real hostname of this user. * @param newhost The new real hostname of this user. * @param resetdisplay Whether to reset the display host to this value. */ void ChangeRealHost(const std::string& newhost, bool resetdisplay); /** Change the displayed username of this user. * @param newuser The new displayed username of this user. */ void ChangeDisplayedUser(const std::string& newuser); /** Change the real username of this user. * @param newuser The new real username of this user. * @param resetdisplay Whether to reset the display username to this value. */ void ChangeRealUser(const std::string& newuser, bool resetdisplay); /** Change the real name of this user. * @param newreal The new real name of this user. */ void ChangeRealName(const std::string& newreal); /** Change a user's nick * @param newnick The new nick. If equal to the users uuid, the nick change always succeeds. * @param newts The time at which this nick change happened. * @return True if the change succeeded */ bool ChangeNick(const std::string& newnick, time_t newts = 0); /** Remove this user from all channels they are on, and delete any that are now empty. * This is used by QUIT, and will not send part messages! */ void PurgeEmptyChannels(); /** @copydoc Cullable::Cull */ Cullable::Result Cull() override; /** Determines whether this user is fully connected to the server .*/ inline bool IsFullyConnected() const { return connected == CONN_FULL; } }; class CoreExport UserIOHandler final : public StreamSocket { private: size_t checked_until = 0; public: LocalUser* const user; UserIOHandler(LocalUser* me) : StreamSocket(StreamSocket::SS_USER) , user(me) { } void OnDataReady() override; bool OnChangeLocalSocketAddress(const irc::sockets::sockaddrs& sa) override; bool OnChangeRemoteSocketAddress(const irc::sockets::sockaddrs& sa) override; void OnError(BufferedSocketError error) override; /** Adds to the user's write buffer. * You may add any amount of text up to this users sendq value, if you exceed the * sendq value, the user will be removed, and further buffer adds will be dropped. * @param data The data to add to the write buffer */ void AddWriteBuf(const std::string& data); }; class CoreExport LocalUser final : public User , public insp::intrusive_list_node<LocalUser> { private: /** The connect class this user is in. */ std::shared_ptr<ConnectClass> connectclass; /** Message list, can be passed to the two parameter Send(). */ static ClientProtocol::MessageList sendmsglist; /** Add a serialized message to the send queue of the user. * @param serialized Bytes to add. */ void Write(const ClientProtocol::SerializedMessage& serialized); /** Send a protocol event to the user, consisting of one or more messages. * @param protoev Event to send, may contain any number of messages. * @param msglist Message list used temporarily internally to pass to hooks and store messages * before Write(). */ void Send(ClientProtocol::Event& protoev, ClientProtocol::MessageList& msglist); public: LocalUser(int fd, const irc::sockets::sockaddrs& client, const irc::sockets::sockaddrs& server); Cullable::Result Cull() override; UserIOHandler eh; /** Serializer to use when communicating with the user */ ClientProtocol::Serializer* serializer = nullptr; /** Stats counter for bytes inbound */ unsigned int bytes_in = 0; /** Stats counter for bytes outbound */ unsigned int bytes_out = 0; /** Stats counter for commands inbound */ unsigned int cmds_in = 0; /** Stats counter for commands outbound */ unsigned int cmds_out = 0; /** Password specified by the user when they connected (if any). * This is stored even if the \<connect> block doesnt need a password, so that * modules may check it. */ std::string password; /** Get the connect class which this user belongs to. * @return A pointer to this user's connect class. */ const std::shared_ptr<ConnectClass>& GetClass() const { return connectclass; } /** Server address and port that this user is connected to. */ irc::sockets::sockaddrs server_sa; /** Recursion fix: user is out of SendQ and will be quit as soon as possible. * This can't be handled normally because QuitUser itself calls Write on other * users, which could trigger their SendQ to overrun. */ unsigned int quitting_sendq:1; /** has the user responded to their previous ping? */ unsigned int lastping:1; /** This is true if the user matched an exception (E-line). It is used to save time on ban checks. */ unsigned int exempt:1; /** The time at which this user should be pinged next. */ time_t nextping = 0; /** Time that the connection last sent a message, used to calculate idle time */ time_t idle_lastmsg = 0; /** This value contains how far into the penalty threshold the user is. * This is used either to enable fake lag or for excess flood quits */ unsigned int CommandFloodPenalty = 0; uint64_t already_sent = 0; /** Check if the user matches a G- or K-line, and disconnect them if they do. * @param doZline True if Z-lines should be checked (if IP has changed since initial connect) * Returns true if the user matched a ban, false else. */ bool CheckLines(bool doZline = false); /** Use this method to fully connect a user. * This will send the message of the day, check G/K/E-lines, etc. */ void FullConnect(); /** @copydoc User::ChangeRemoteAddress */ void ChangeRemoteAddress(const irc::sockets::sockaddrs& sa) override; /** Change the connect class for this user. * @param klass The connect class the user should be assigned to. * @param force Whether the connect class was explicitly picked (e.g. via <oper:class>). */ void ChangeConnectClass(const std::shared_ptr<ConnectClass>& klass, bool force); /** Find a new connect class for this user. * @param keepexisting If no connect class can be found should they keep their existing one if * they have one. * @return True if an allow-type connect class was found for the user. Otherwise, false. */ bool FindConnectClass(bool keepexisting = false); /** Send a NOTICE message from the local server to the user. * The message will be sent even if the user is connected to a remote server. * @param text Text to send */ void WriteRemoteNotice(const std::string& text) override; /** Change nick to uuid, unset CONN_NICK and send a nickname overruled numeric. * This is called when another user (either local or remote) needs the nick of this user and this user * isn't fully connected. */ void OverruleNick(); /** Send a protocol event to the user, consisting of one or more messages. * @param protoev Event to send, may contain any number of messages. */ void Send(ClientProtocol::Event& protoev); /** Send a single message to the user. * @param protoevprov Protocol event provider. * @param msg Message to send. */ void Send(ClientProtocol::EventProvider& protoevprov, ClientProtocol::Message& msg); }; class RemoteUser : public User { public: RemoteUser(const std::string& uid, Server* srv) : User(uid, srv, TYPE_REMOTE) { } }; class CoreExport FakeUser final : public User { public: /** Creates a new fake user with the specified sid and server details. * @param sid A server id in the format [0-9][A-Z0-9][A-Z0-9]. * @param srv The server instance to configure this fake user from. */ FakeUser(const std::string& sid, Server* srv); /** Creates a new fake user with the specified sid, server name, and server description. * @param sid A server id in the format [0-9][A-Z0-9][A-Z0-9]. * @param sname The name of the server. * @param sdesc The description of the server. */ FakeUser(const std::string& sid, const std::string& sname, const std::string& sdesc); /** @copydoc Cullable::Cull. */ Cullable::Result Cull() override; /** @copydoc User::GetMask. */ const std::string& GetMask() override; /** @copydoc User::GetRealMask. */ const std::string& GetRealMask() override; }; /* Faster than dynamic_cast */ /** Is a local user */ inline LocalUser* IS_LOCAL(User* u) { return (u != nullptr && u->usertype == User::TYPE_LOCAL) ? static_cast<LocalUser*>(u) : nullptr; } /** Is a remote user */ inline RemoteUser* IS_REMOTE(User* u) { return (u != nullptr && u->usertype == User::TYPE_REMOTE) ? static_cast<RemoteUser*>(u) : nullptr; } /** Is a server fakeuser */ inline FakeUser* IS_SERVER(User* u) { return (u != nullptr && u->usertype == User::TYPE_SERVER) ? static_cast<FakeUser*>(u) : nullptr; } inline bool User::IsModeSet(const ModeHandler* mh) const { return ((mh->GetId() != ModeParser::MODEID_MAX) && (modes[mh->GetId()])); } inline bool User::IsModeSet(const UserModeReference& moderef) const { if (!moderef) return false; return IsModeSet(*moderef); } inline void User::SetMode(const ModeHandler* mh, bool value) { if (mh && mh->GetId() != ModeParser::MODEID_MAX) modes[mh->GetId()] = value; } ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/include/utility/���������������������������������������������������������������������0000775�0000000�0000000�00000000000�14771603147�0016475�5����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/include/utility/aligned_storage.h����������������������������������������������������0000664�0000000�0000000�00000003040�14771603147�0021772�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2020-2022, 2024 Sadie Powell <sadie@witchery.services> * Copyright (C) 2014 Attila Molnar <attilamolnar@hush.com> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #pragma once namespace insp { template <typename T> class aligned_storage; } /** A block of preallocated memory which an object can be created into. */ template <typename T> class insp::aligned_storage final { private: /** The underlying aligned storage block. */ alignas(T) mutable std::byte data[sizeof(T)]; public: /** Default constructor for the aligned_storage class. */ aligned_storage() = default; /** Ignores copying via the copy constructor. */ aligned_storage(const aligned_storage&) { } /** Accessor for the underlying aligned storage block. */ T* operator->() const { return static_cast<T*>(static_cast<void*>(&data)); } /** Constant accessor for the underlying aligned storage block. */ operator T*() const { return operator->(); } }; ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/include/utility/iterator_range.h�����������������������������������������������������0000664�0000000�0000000�00000005465�14771603147�0021665�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2020-2022 Sadie Powell <sadie@witchery.services> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #pragma once namespace insp { template <typename Iterator> class iterator_range; /** Returns a range containing all elements equivalent to \p value. * @param collection The collection to search within. * @param value The value to search for. */ template <typename Collection, typename Value> auto equal_range(const Collection& collection, const Value& value) { return iterator_range(collection.equal_range(value)); } /** Returns a range representing a reverse iterator for the specified colleciton. * @param collection The collection to create a reverse iterator for. */ template <typename Collection> auto reverse_range(const Collection& collection) { return iterator_range(collection.rbegin(), collection.rend()); } } /** Represents a range of iterators. */ template <typename Iterator> class insp::iterator_range final { private: /** An iterator which points to the start of the range. */ const Iterator begini; /* An iterator which points to one past the end of the range. */ const Iterator endi; public: /** Initialises a new iterator range with the specified iterators. * @param begin An iterator which points to the start of the range. * @param end An iterator which points to one past the end of the range. */ explicit iterator_range(Iterator begin, Iterator end) : begini(begin) , endi(end) { } /** Initialises a new iterator range from a pair of iterators. * @param range A pair of iterators in the format [first, last). */ explicit iterator_range(std::pair<Iterator, Iterator> range) : begini(range.first) , endi(range.second) { } /** Determines whether the iterator range is empty. */ bool empty() const { return begini == endi; } /** Retrieves an iterator which points to the start of the range. */ const Iterator& begin() const { return begini; } /** Retrieves an iterator which points to one past the end of the range. */ const Iterator& end() const { return endi; } /** Retrieves the number of hops within the iterator range. */ typename std::iterator_traits<Iterator>::difference_type count() const { return std::distance(begini, endi); } }; �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/include/utility/map.h����������������������������������������������������������������0000664�0000000�0000000�00000004417�14771603147�0017431�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2022 Sadie Powell <sadie@witchery.services> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #pragma once namespace insp::map { /** Compares two maps and returns a list of the differences. * @param first The first map to compare. * @param second The second map to compare. * @param out The map to store the differences in. */ template<typename Key, typename Value, typename Compare, template<typename...> typename Map> void difference(const Map<Key, Value, Compare>& first, const Map<Key, Value, Compare>& second, Map<Key, std::pair<std::optional<Value>, std::optional<Value>>, Compare>& out) { auto fiter = first.cbegin(); auto siter = second.cbegin(); while (fiter != first.end()) { if (siter == second.end()) { // Store the remaining from the first. while (fiter != first.end()) { out[fiter->first] = { fiter->second, std::nullopt }; fiter++; } return; } if (fiter->first < siter->first) { // The key in first is not in second. out[fiter->first] = { fiter->second, std::nullopt }; fiter++; } else if (siter->first < fiter->first) { // The key in second is not in first. out[siter->first] = { std::nullopt, siter->second }; siter++; } else if (fiter->second != siter->second) { // The key exists in both but the value differs. out[fiter->first] = { fiter->second, siter->second }; fiter++; siter++; } else { // The key/value is identical in both. fiter++; siter++; } } // Store the remaining from the second. while (siter != second.end()) { out[siter->first] = { std::nullopt, siter->second }; siter++; } } } �������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/include/utility/string.h�������������������������������������������������������������0000664�0000000�0000000�00000005411�14771603147�0020155�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2021, 2023 Sadie Powell <sadie@witchery.services> * Copyright (C) 2016 Attila Molnar <attilamolnar@hush.com> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #pragma once #include "utility/string.h" namespace insp { /** Combines a sequence of elements into a string. * @param sequence A sequence of elements to combine. * @param separator The value to separate the elements with. Defaults to ' ' (space). */ template<typename Collection, typename Separator = char> inline std::string join(const Collection& sequence, Separator separator = ' ') { std::string joined; if (sequence.empty()) return joined; const std::string separatorstr = ConvToStr(separator); for (const auto& element : sequence) joined.append(ConvToStr(element)).append(separatorstr); joined.erase(joined.end() - separatorstr.length()); joined.shrink_to_fit(); return joined; } /** Creates a view of a subsection of a string. * @param str The string to create a view of. * @param begin The position within the string to start the view at. * @param end The position within the string to end the view at. */ template <typename Iterator> std::string_view substring_view(const std::string& str, Iterator begin, Iterator end) { std::string_view sv = str; sv.remove_prefix(std::distance(str.begin(), begin)); sv.remove_suffix(std::distance(end, str.end())); return sv; } /** Get underlying C string of the string passed as parameter. Useful in template functions. * @param str A `const char*` string. */ inline const char* tocstr(const char* str) { return str; } /** Get underlying C string of the string passed as parameter. Useful in template functions. * @param str A `std::string` string. */ inline const char* tocstr(const std::string& str) { return str.c_str(); } /** Check if two strings are equal case insensitively. * @param str1 First string to compare. * @param str2 Second string to compare. * @return True if the strings are equal case-insensitively; otherwise, false. */ template <typename S1, typename S2> inline bool equalsci(const S1& str1, const S2& str2) { return (!strcasecmp(tocstr(str1), tocstr(str2))); } } �������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/include/utility/uncopiable.h���������������������������������������������������������0000664�0000000�0000000�00000002351�14771603147�0020770�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2021 Sadie Powell <sadie@witchery.services> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #pragma once namespace insp { class uncopiable; } /** Prevents instances of an inheriting type from being copied. */ class insp::uncopiable { private: /** Prevents copying via the copy constructor. */ uncopiable(const uncopiable&) = delete; /** Prevents copying via the assignment operator. */ uncopiable& operator=(const uncopiable&) = delete; protected: /** Default constructor for the uncopiable class. */ uncopiable() = default; /** Default destructor for the uncopiable class. */ ~uncopiable() = default; }; ���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/include/xline.h����������������������������������������������������������������������0000664�0000000�0000000�00000040652�14771603147�0016271�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2019 Matt Schatz <genius3000@g3k.solutions> * Copyright (C) 2012-2013, 2018-2024 Sadie Powell <sadie@witchery.services> * Copyright (C) 2012, 2019 Robby <robby@chatbelgie.be> * Copyright (C) 2009 Daniel De Graaf <danieldg@inspircd.org> * Copyright (C) 2007-2008 Robin Burchell <robin+git@viroteck.net> * Copyright (C) 2007 Dennis Friis <peavey@inspircd.org> * Copyright (C) 2004, 2006-2008 Craig Edwards <brain@inspircd.org> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #pragma once namespace Stats { class Context; } /** Contains a username and hostname split into two strings */ typedef std::pair<std::string, std::string> UserHostPair; /** A map of xline factories */ typedef std::map<std::string, XLineFactory*> XLineFactMap; /** A map of XLines indexed by string */ typedef std::map<std::string, XLine*, irc::insensitive_swo> XLineLookup; /** A map of XLineLookup maps indexed by string */ typedef std::map<std::string, XLineLookup > XLineContainer; /** An iterator in an XLineContainer */ typedef XLineContainer::iterator ContainerIter; /** An iterator in an XLineLookup */ typedef XLineLookup::iterator LookupIter; /** XLine is the base class for ban lines such as G-lines and K-lines. * Modules may derive from this, and their xlines will automatically be * handled as expected by any protocol modules (e.g. m_spanningtree will * propagate them using AddLine). The process of translating a type+pattern * to a known line type is done by means of an XLineFactory object (see * below). */ class CoreExport XLine : public Cullable { protected: /** Default 'apply' action. Quits the user. * @param u User to apply the line against * @param bancache If true, the user will be added to the bancache if they match. Else not. */ void DefaultApply(User* u, bool bancache); public: /** Create an XLine. * @param s_time The set time * @param d The duration of the xline * @param src The sender of the xline * @param re The reason of the xline * @param t The line type, should be set by the derived class constructor */ XLine(time_t s_time, unsigned long d, const std::string& src, const std::string& re, const std::string& t) : set_time(s_time) , duration(d) , source(src) , reason(re) , type(t) { expiry = set_time + duration; } /** Change creation time of an xline. Updates expiry * to be after the creation time. */ inline void SetCreateTime(time_t created) { set_time = created; expiry = created + duration; } /** Returns true whether or not the given user is covered by this line. * @param u The Username to match against. The mechanics of the match * are defined by the derived class. * @return True if there is a match. */ virtual bool Matches(User* u) const = 0; /** Returns true whether or not the given string is covered by this line. * @param str The string to match against. The details of what must be * in this string and the mechanics of the match are defined by the * derived class. * @return True if there is a match */ virtual bool Matches(const std::string& str) const = 0; /** Apply a line against a user. The mechanics of what occurs when * the line is applied are specific to the derived class. * @param u The user to apply against */ virtual void Apply(User* u); /** Called when the line is unset either via expiry or * via explicit removal. */ virtual void Unset() { } /** Called when the expiry message is to be displayed for the * line. Usually a line in the form 'expiring X-line blah, set by...' * see the DisplayExpiry methods of GLine, ELine etc. */ virtual void DisplayExpiry(); /** Returns the displayable form of the pattern for this xline, * e.g. '*\@foo' or '*baz*'. This must always return the full pattern * in a form which can be used to construct an entire derived xline, * even if it is stored differently internally (e.g. GLine stores the * user and host parts separately but will still return user\@host * for its Displayable() method). */ virtual const std::string& Displayable() const = 0; /** Called when the xline has just been added. */ virtual void OnAdd() { } /** The time the line was added. */ time_t set_time; /** The duration of the ban, or 0 if permanent */ const unsigned long duration; /** Source of the ban. This can be a servername or an oper nickname */ const std::string source; /** Reason for the ban */ const std::string reason; /** Expiry time. Does not contain useful data if the duration is 0. */ time_t expiry; /** "Q", "K", etc. Set only by derived classes constructor to the * type of line this is. */ const std::string type; // Whether this XLine was loaded from the server config. bool from_config = false; virtual bool IsBurstable(); }; /** KLine class */ class CoreExport KLine final : public XLine { public: /** Create a K-line. * @param s_time The set time * @param d The duration of the xline * @param src The sender of the xline * @param re The reason of the xline * @param user Username to match * @param host Hostname to match */ KLine(time_t s_time, unsigned long d, const std::string& src, const std::string& re, const std::string& user, const std::string& host) : XLine(s_time, d, src, re, "K") , usermask(user) , hostmask(host) , matchtext(INSP_FORMAT("{}@{}", user, host)) { } bool Matches(User* u) const override; bool Matches(const std::string& str) const override; void Apply(User* u) override; const std::string& Displayable() const override; bool IsBurstable() override; /** Username pattern to match. */ const std::string usermask; /** Hostname pattern to match. */ const std::string hostmask; const std::string matchtext; }; /** GLine class */ class CoreExport GLine final : public XLine { public: /** Create a G-line. * @param s_time The set time * @param d The duration of the xline * @param src The sender of the xline * @param re The reason of the xline * @param user Username to match * @param host Hostname to match */ GLine(time_t s_time, unsigned long d, const std::string& src, const std::string& re, const std::string& user, const std::string& host) : XLine(s_time, d, src, re, "G") , usermask(user) , hostmask(host) , matchtext(INSP_FORMAT("{}@{}", user, host)) { } bool Matches(User* u) const override; bool Matches(const std::string& str) const override; void Apply(User* u) override; const std::string& Displayable() const override; /** Username pattern to match. */ const std::string usermask; /** Hostname pattern to match. */ const std::string hostmask; const std::string matchtext; }; /** ELine class */ class CoreExport ELine final : public XLine { public: /** Create an E-line. * @param s_time The set time * @param d The duration of the xline * @param src The sender of the xline * @param re The reason of the xline * @param user Username to match * @param host Hostname to match */ ELine(time_t s_time, unsigned long d, const std::string& src, const std::string& re, const std::string& user, const std::string& host) : XLine(s_time, d, src, re, "E") , usermask(user) , hostmask(host) , matchtext(INSP_FORMAT("{}@{}", user, host)) { } bool Matches(User* u) const override; bool Matches(const std::string& str) const override; void Unset() override; void OnAdd() override; const std::string& Displayable() const override; /** Username pattern to match. */ const std::string usermask; /** Hostname pattern to match. */ const std::string hostmask; const std::string matchtext; }; /** ZLine class */ class CoreExport ZLine final : public XLine { public: /** Create a Z-line. * @param s_time The set time * @param d The duration of the xline * @param src The sender of the xline * @param re The reason of the xline * @param ip IP to match */ ZLine(time_t s_time, unsigned long d, const std::string& src, const std::string& re, const std::string& ip) : XLine(s_time, d, src, re, "Z") , ipaddr(ip) { } bool Matches(User* u) const override; bool Matches(const std::string& str) const override; void Apply(User* u) override; const std::string& Displayable() const override; /** IP mask (no user part) */ const std::string ipaddr; }; /** QLine class */ class CoreExport QLine final : public XLine { public: /** Create a Q-line. * @param s_time The set time * @param d The duration of the xline * @param src The sender of the xline * @param re The reason of the xline * @param nickname Nickname to match */ QLine(time_t s_time, unsigned long d, const std::string& src, const std::string& re, const std::string& nickname) : XLine(s_time, d, src, re, "Q") , nick(nickname) { } bool Matches(User* u) const override; bool Matches(const std::string& str) const override; void Apply(User* u) override; const std::string& Displayable() const override; /** Nickname mask */ const std::string nick; }; /** XLineFactory is used to generate an XLine pointer, given just the * pattern, timing information and type of line to create. This is used * for example in the spanningtree module which will call an XLineFactory * to create a new XLine when it is inbound on a server link, so that it * does not have to know the specifics of the internals of an XLine class * and/or how to call its constructor. */ class CoreExport XLineFactory { protected: const std::string type; public: /** Create an XLine factory * @param t Type of XLine this factory generates */ XLineFactory(const std::string& t) : type(t) { } /** Return the type of XLine this factory generates * @return The type of XLine this factory generates */ virtual const std::string& GetType() { return type; } /** Generate a specialized XLine*. * @param set_time Time this line was created * @param duration Duration of the line * @param source The sender of the line, nickname or server * @param reason The reason for the line * @param xline_specific_mask The mask string for the line, specific to the XLine type being created. * @return A specialized XLine class of the given type for this factory. */ virtual XLine* Generate(time_t set_time, unsigned long duration, const std::string& source, const std::string& reason, const std::string& xline_specific_mask) = 0; virtual bool AutoApplyToUserList(XLine* x) { return true; } /** Destructor */ virtual ~XLineFactory() = default; }; /** XLineManager is a class used to manage G-lines, K-lines, E-lines, Z-lines and Q-lines, * or any other line created by a module. It also manages XLineFactory classes which * can generate a specialized XLine for use by another module. */ class CoreExport XLineManager final { protected: /** Used to hold XLines which have not yet been applied. */ std::vector<XLine *> pending_lines; /** Current xline factories */ XLineFactMap line_factory; /** Container of all lines, this is a map of maps which * allows for fast lookup for add/remove of a line, and * the shortest possible timed O(n) for checking a user * against a line. */ XLineContainer lookup_lines; public: /** Constructor */ XLineManager(); /** Destructor */ ~XLineManager(); /** Split a username and hostname into two separate strings. * This allows for faster matching. */ static UserHostPair SplitUserHost(const std::string& user_and_host); /** Checks what users match E-lines and sets their ban exempt flag accordingly. */ void CheckELines(); /** Get all lines of a certain type to an XLineLookup (std::map<std::string, XLine*>). * NOTE: When this function runs any expired items are removed from the list before it * is returned to the caller. * @param type The type to look up * @return A list of all XLines of the given type. */ XLineLookup* GetAll(const std::string& type); /** Remove all lines of a certain type. */ void DelAll(const std::string& type); /** Return all known types of line currently stored by the XLineManager. * @return A vector containing all known line types currently stored in the main list. */ std::vector<std::string> GetAllTypes(); /** Add a new XLine * @param line The line to be added * @param user The user adding the line or NULL for the local server * @return True if the line was added successfully */ bool AddLine(XLine* line, User* user); /** Delete an XLine * @param hostmask The xline-specific string identifying the line, e.g. "*@foo" * @param type The type of xline * @param reason The xline reason, if it is being removed successfully * @param user The user removing the line or NULL if its the local server * @param simulate If this is true, don't actually remove the line, just return * @return True if the line was deleted successfully */ bool DelLine(const std::string& hostmask, const std::string& type, std::string& reason, User* user, bool simulate = false); /** Delete an XLine * @param xline The xline to delete. * @param reason The xline reason, if it is being removed successfully * @param user The user removing the line or NULL if its the local server * @param simulate If this is true, don't actually remove the line, just return * @return True if the line was deleted successfully */ inline bool DelLine(const XLine* xline, std::string& reason, User* user, bool simulate = false) { return DelLine(xline->Displayable(), xline->type, reason, user, simulate); } /** Registers an xline factory. * An xline factory is a class which when given a particular xline type, * will generate a new XLine specialized to that type. For example if you * pass the XLineFactory that handles G-lines some data it will return a * pointer to a GLine, polymorphically represented as XLine. This is used where * you do not know the full details of the item you wish to create, e.g. in a * server protocol module like m_spanningtree, when you receive xlines from other * servers. * @param xlf XLineFactory pointer to register */ bool RegisterFactory(XLineFactory* xlf); /** Unregisters an xline factory. * You must do this when your module unloads. * @param xlf XLineFactory pointer to unregister */ bool UnregisterFactory(XLineFactory* xlf); /** Get the XLineFactory for a specific type. * Returns NULL if there is no known handler for this xline type. * @param type The type of XLine you require the XLineFactory for */ XLineFactory* GetFactory(const std::string& type); /** Check if a user matches an XLine * @param type The type of line to look up * @param user The Username to match against (what is checked is specific to the xline type) * @return The reason for the line if there is a match, or NULL if there is no match */ XLine* MatchesLine(const std::string& type, User* user); /** Check if a pattern matches an XLine * @param type The type of line to look up * @param pattern A pattern string specific to the xline type * @return The matching XLine if there is a match, or NULL if there is no match */ XLine* MatchesLine(const std::string& type, const std::string& pattern); /** Expire a line given two iterators which identify it in the main map. * @param container Iterator to the first level of entries the map * @param item Iterator to the second level of entries in the map * @param silent If true, doesn't send an expiry SNOTICE. */ void ExpireLine(ContainerIter container, LookupIter item, bool silent = false); /** Apply any new lines that are pending to be applied. * This will only apply lines in the pending_lines list, to save on * CPU time. */ void ApplyLines(); /** Generates a /STATS response for the given X-line type. * @param type The type of X-line to look up. * @param context The stats context to respond with. * @return True if a response was sent; otherwise, false. */ bool InvokeStats(const std::string& type, Stats::Context& context); /** Expire X-lines which were added by the server configuration and have been removed. */ void ExpireRemovedConfigLines(const std::string& type, const insp::flat_set<std::string>& configlines); }; ��������������������������������������������������������������������������������������inspircd-4.7.0/make/��������������������������������������������������������������������������������0000775�0000000�0000000�00000000000�14771603147�0014264�5����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/make/calcdep.pl����������������������������������������������������������������������0000775�0000000�0000000�00000013315�14771603147�0016222�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������#!/usr/bin/env perl # # InspIRCd -- Internet Relay Chat Daemon # # Copyright (C) 2015-2022 Sadie Powell <sadie@witchery.services> # Copyright (C) 2014-2015 Attila Molnar <attilamolnar@hush.com> # Copyright (C) 2012 Robby <robby@chatbelgie.be> # Copyright (C) 2009-2010 Daniel De Graaf <danieldg@inspircd.org> # # This file is part of InspIRCd. InspIRCd is free software: you can # redistribute it and/or modify it under the terms of the GNU General Public # License as published by the Free Software Foundation, version 2. # # This program is distributed in the hope that it will be useful, but WITHOUT # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS # FOR A PARTICULAR PURPOSE. See the GNU General Public License for more # details. # # You should have received a copy of the GNU General Public License # along with this program. If not, see <http://www.gnu.org/licenses/>. # use strict; use warnings FATAL => qw(all); use File::Basename qw(basename dirname); use FindBin qw($RealDir); use lib dirname $RealDir; use make::common; use constant { BUILDPATH => $ENV{BUILDPATH}, SOURCEPATH => $ENV{SOURCEPATH}, DLL_EXT => $^O eq 'darwin' ? '.dylib' : '.so' }; sub find_output; sub gendep($); sub dep_cpp($$$); sub dep_so($); sub dep_dir($$); sub run(); my %f2dep; run; exit 0; sub run() { create_directory(BUILDPATH, 0770) or die "Could not create build directory: $!"; chdir BUILDPATH or die "Could not open build directory: $!"; mkdir $_ for qw/bin modules obj/; open MAKE, '>real.mk' or die "Could not write real.mk: $!"; chdir "${\SOURCEPATH}/src"; run_dynamic(); close MAKE; } sub run_dynamic() { print MAKE <<END; # DO NOT EDIT THIS FILE # It is autogenerated by make/calcdep.pl, and will be overwritten # every time you rerun make in the main directory VPATH = \$(SOURCEPATH)/src bad-target: \@echo "This Makefile must be run by a sub-make from the source" \@echo "in order to set the correct environment variables" \@exit 1 all: inspircd coremods modules END my(@core_deps, @coremodlist, @modlist); for my $file (<*.cpp>, "socketengines/$ENV{SOCKETENGINE}.cpp") { my $out = find_output $file; dep_cpp $file, $out, 'gen-o'; # Having a module in the src directory is a bad idea because it will be linked to the core binary if ($file =~ /^(m|core)_.*\.cpp/) { my $correctsubdir = ($file =~ /^m_/ ? "modules" : "coremods"); print "Error: module $file is in the src directory, put it in src/$correctsubdir instead!\n"; exit 1; } push @core_deps, $out; } for my $directory (qw(coremods modules)) { opendir(my $moddir, $directory); my $mlist = $directory eq 'coremods' ? \@coremodlist : \@modlist; for my $file (sort readdir $moddir) { next if $file =~ /^\./; if ($directory eq 'modules' && -e "modules/extra/$file" && !-l "modules/$file") { # Incorrect symlink? print "Replacing symlink for $file found in modules/extra\n"; rename "modules/$file", "modules/$file~"; symlink "extra/$file", "modules/$file"; } if ($file =~ /^(?:core|m)_/ && -d "$directory/$file" && dep_dir "$directory/$file", "modules/$file") { mkdir "${\BUILDPATH}/obj/$file"; push @$mlist, "modules/$file${\DLL_EXT}"; } if ($file =~ /^.*\.cpp$/) { my $out = dep_so "$directory/$file"; push @$mlist, $out; } } } my $core_mk = join ' ', @core_deps; my $coremods = join ' ', @coremodlist; my $mods = join ' ', @modlist; print MAKE <<END; bin/inspircd: $core_mk @\$(SOURCEPATH)/make/unit-cc.pl core-ld \$\@ \$^ \$> inspircd: bin/inspircd coremods: $coremods modules: $mods .PHONY: all bad-target inspircd coremods modules END } sub find_output { my $file = shift; my($path,$base) = $file =~ m#^((?:.*/)?)([^/]+)\.cpp# or die "Bad file $file"; if ($path eq 'modules/' || $path eq 'coremods/') { return "modules/$base${\DLL_EXT}"; } elsif ($path eq '' || $path eq 'modes/' || $path =~ /^[a-z]+engines\/$/) { return "obj/$base.o"; } elsif ($path =~ m#modules/(m_.*)/# || $path =~ m#coremods/(core_.*)/#) { return "obj/$1/$base.o"; } else { die "Can't determine output for $file"; } } sub gendep($) { my $f = shift; my $basedir = $f =~ m#(.*)/# ? $1 : '.'; return $f2dep{$f} if exists $f2dep{$f}; $f2dep{$f} = ''; my %dep; my $link = readlink $f; if (defined $link) { $link = "$basedir/$link" unless $link =~ m#^/#; $dep{$link}++; } open my $in, '<', $f or die "Could not read $f"; while (<$in>) { if (/^\s*#\s*include\s*"([^"]+)"/) { my $inc = $1; for my $loc ("$basedir/$inc", "${\SOURCEPATH}/include/$inc", "${\SOURCEPATH}/vendor/$inc") { next unless -e $loc; $dep{$_}++ for split / /, gendep $loc; $loc =~ s#^\.\./##; $dep{$loc}++; } } } close $in; $f2dep{$f} = join ' ', sort keys %dep; $f2dep{$f}; } sub dep_cpp($$$) { my($file, $out, $type) = @_; gendep $file; print MAKE "$out: $file $f2dep{$file}\n"; print MAKE "\t@\$(SOURCEPATH)/make/unit-cc.pl $type \$\@ \$(SOURCEPATH)/src/$file \$>\n"; } sub dep_so($) { my($file) = @_; my $out = find_output $file; my $name = basename $out, DLL_EXT; print MAKE ".PHONY: $name\n"; print MAKE "$name: $out\n"; dep_cpp $file, $out, 'gen-so'; return $out; } sub dep_dir($$) { my($dir, $outdir) = @_; my @ofiles; opendir DIR, $dir; for my $file (sort readdir DIR) { next unless $file =~ /(.*)\.cpp$/; my $ofile = find_output "$dir/$file"; dep_cpp "$dir/$file", $ofile, 'gen-o'; push @ofiles, $ofile; } closedir DIR; if (@ofiles) { my $ofiles = join ' ', @ofiles; my $name = basename $outdir; print MAKE ".PHONY: $name\n"; print MAKE "$name: $outdir${\DLL_EXT}\n"; print MAKE "$outdir${\DLL_EXT}: $ofiles\n"; print MAKE "\t@\$(SOURCEPATH)/make/unit-cc.pl link-dir \$\@ ${\SOURCEPATH}/src/$dir \$^ \$>\n"; return 1; } else { return 0; } } �������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/make/common.pm�����������������������������������������������������������������������0000664�0000000�0000000�00000010020�14771603147�0016103�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������# # InspIRCd -- Internet Relay Chat Daemon # # Copyright (C) 2014-2017, 2019-2021, 2024 Sadie Powell <sadie@witchery.services> # # This file is part of InspIRCd. InspIRCd is free software: you can # redistribute it and/or modify it under the terms of the GNU General Public # License as published by the Free Software Foundation, version 2. # # This program is distributed in the hope that it will be useful, but WITHOUT # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS # FOR A PARTICULAR PURPOSE. See the GNU General Public License for more # details. # # You should have received a copy of the GNU General Public License # along with this program. If not, see <http://www.gnu.org/licenses/>. # package make::common; use v5.26.0; use strict; use warnings FATAL => qw(all); use Exporter qw(import); use File::Basename qw(basename); use File::Path qw(mkpath); use File::Spec::Functions qw(rel2abs); use make::console; our @EXPORT = qw(create_directory execute get_cpu_count get_version module_expand module_shrink read_config_file write_config_file); sub create_directory($$) { my ($location, $permissions) = @_; return eval { mkpath($location, 0, $permissions); return 1; } // 0; } sub execute(@) { say console_format "<|BOLD \$|> @_"; return system @_; } sub get_version { state %version; return %version if %version; # Attempt to retrieve version information from src/version.sh chomp(my $vf = `sh src/version.sh 2>/dev/null`); if ($vf =~ /^InspIRCd-([0-9]+)\.([0-9]+)\.([0-9]+)(?:-(\w+))?$/) { %version = ( MAJOR => $1, MINOR => $2, PATCH => $3, LABEL => $4 ); } # Attempt to retrieve missing version information from Git chomp(my $gr = `git describe --tags 2>/dev/null`); if ($gr =~ /^v([0-9]+)\.([0-9]+)\.([0-9]+)(?:[a-z]+\d+)?(?:-\d+-g(\w+))?$/) { $version{MAJOR} //= $1; $version{MINOR} //= $2; $version{PATCH} //= $3; $version{LABEL} = $4 if defined $4; } # If the user has specified a distribution label then we use it in # place of the label from src/version.sh or Git. $version{REAL_LABEL} = $version{LABEL}; $version{LABEL} = shift // $version{LABEL}; # If any of these fields are missing then the user has deleted the # version file and is not running from Git. Fill in the fields with # dummy data so we don't get into trouble with undef values later. $version{MAJOR} //= '0'; $version{MINOR} //= '0'; $version{PATCH} //= '0'; # If there is no label then the user is using a stable release which # does not have a label attached. if (defined $version{LABEL}) { $version{FULL} = "$version{MAJOR}.$version{MINOR}.$version{PATCH}-$version{LABEL}" } else { $version{LABEL} = 'release'; $version{FULL} = "$version{MAJOR}.$version{MINOR}.$version{PATCH}" } return %version; } sub get_cpu_count { my $count = 1; if ($^O =~ /bsd/) { $count = `sysctl -n hw.ncpu 2>/dev/null` || 1; } elsif ($^O eq 'darwin') { $count = `sysctl -n hw.activecpu 2>/dev/null` || 1; } elsif ($^O eq 'linux') { $count = `getconf _NPROCESSORS_ONLN 2>/dev/null` || 1; } elsif ($^O eq 'solaris') { $count = `psrinfo -p 2>/dev/null` || 1; } chomp($count); return $count; } sub module_expand($) { my $module = shift; $module = "m_$module" unless $module =~ /^(?:m|core)_/; $module = "$module.cpp" unless $module =~ /\.cpp$/; return $module; } sub module_shrink($) { my $module = basename shift; return $module =~ s/(?:^m_|\.cpp$)//gr; } sub read_config_file($) { my $path = shift; my %config; open(my $fh, $path) or return %config; while (my $line = <$fh>) { next if $line =~ /^\s*($|\#)/; my ($key, $value) = ($line =~ /^(\S+)(?:\s(.*))?$/); $config{$key} = $value; } close $fh; return %config; } sub write_config_file($%) { my $path = shift; my %config = @_; open(my $fh, '>', $path) or print_error "unable to write to $path: $!"; while (my ($key, $value) = each %config) { $value //= ''; say $fh "$key $value"; } close $fh; } 1; ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/make/configure.pm��������������������������������������������������������������������0000664�0000000�0000000�00000031366�14771603147�0016614�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������# # InspIRCd -- Internet Relay Chat Daemon # # Copyright (C) 2024 satmd <satmd@satmd.de> # Copyright (C) 2020 Nicole Kleinhoff <ilbelkyr@shalture.org> # Copyright (C) 2013-2022, 2024 Sadie Powell <sadie@witchery.services> # Copyright (C) 2012 Robby <robby@chatbelgie.be> # Copyright (C) 2007-2008 Craig Edwards <brain@inspircd.org> # # This file is part of InspIRCd. InspIRCd is free software: you can # redistribute it and/or modify it under the terms of the GNU General Public # License as published by the Free Software Foundation, version 2. # # This program is distributed in the hope that it will be useful, but WITHOUT # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS # FOR A PARTICULAR PURPOSE. See the GNU General Public License for more # details. # # You should have received a copy of the GNU General Public License # along with this program. If not, see <http://www.gnu.org/licenses/>. # package make::configure; use v5.26.0; use strict; use warnings FATAL => qw(all); use Exporter qw(import); use File::Basename qw(basename dirname); use File::Spec::Functions qw(abs2rel catdir catfile); use make::common; use make::console; use constant CONFIGURE_ROOT => dirname dirname __FILE__; use constant CONFIGURE_DIRECTORY => catdir(CONFIGURE_ROOT, '.configure'); use constant CONFIGURE_CACHE_FILE => catfile(CONFIGURE_DIRECTORY, 'cache.cfg'); use constant CONFIGURE_CACHE_VERSION => '1'; use constant CONFIGURE_ERROR_PIPE => $ENV{INSPIRCD_VERBOSE} ? '' : '1>/dev/null 2>/dev/null'; our @EXPORT = qw(CONFIGURE_CACHE_FILE CONFIGURE_CACHE_VERSION CONFIGURE_DIRECTORY cmd_clean cmd_help cmd_update run_test test_file test_header write_configure_cache get_compiler_info find_compiler parse_templates); sub __get_socketengines { my @socketengines; for (<${\CONFIGURE_ROOT}/src/socketengines/*.cpp>) { s/src\/socketengines\/(\w+)\.cpp/$1/; push @socketengines, $1; } return @socketengines; } sub __get_template_settings($$$) { # These are actually hash references my ($config, $compiler, $version) = @_; # Start off by populating with the config my %settings = %$config; # Compiler information while (my ($key, $value) = each %{$compiler}) { $settings{'COMPILER_' . $key} = $value; } # Version information while (my ($key, $value) = each %{$version}) { $settings{'VERSION_' . $key} = $value; } # Miscellaneous information $settings{CONFIGURE_DIRECTORY} = CONFIGURE_DIRECTORY; $settings{CONFIGURE_CACHE_FILE} = CONFIGURE_CACHE_FILE; $settings{SOURCE_DIR} = CONFIGURE_ROOT; $settings{SYSTEM_NAME} = lc $^O; return %settings; } sub __test_compiler($) { my $compiler = shift; return 0 unless run_test("`$compiler`", !system "$compiler --version ${\CONFIGURE_ERROR_PIPE}"); return 0 unless run_test("`$compiler`", test_file($compiler, 'compiler.cpp', '-fno-rtti'), 'compatible'); return 1; } sub cmd_clean { unlink CONFIGURE_CACHE_FILE; } sub cmd_help { my $SELIST = join ', ', __get_socketengines(); print console_format <<EOH; <|GREEN Usage:|> <|BOLD $0 [OPTIONS|>] When no options are specified, configure runs in interactive mode and you must specify any required values manually. If one or more options are specified, non-interactive configuration is started and any omitted values are defaulted. <|GREEN PATH OPTIONS|> <|BOLD --portable|> Automatically set up the installation paths for portable installation. <|BOLD --system|> Automatically set up the installation paths for system-wide installation. <|BOLD --prefix <DIR>|> The root install directory. If this is set then all subdirectories will be adjusted accordingly. [${\CONFIGURE_ROOT}/run] <|BOLD --binary-dir <DIR>|> The location where the main server binary is stored. [${\CONFIGURE_ROOT}/run/bin] <|BOLD --config-dir <DIR>|> The location where the configuration files and TLS certificates are stored. [${\CONFIGURE_ROOT}/run/conf] <|BOLD --data-dir <DIR>|> The location where the data files, such as the xline database, are stored. [${\CONFIGURE_ROOT}/run/data] <|BOLD --example-dir <DIR>|> The location where the example configuration files and SQL schemas are stored. [${\CONFIGURE_ROOT}/run/conf/examples] <|BOLD --log-dir <DIR>|> The location where the log files are stored. [${\CONFIGURE_ROOT}/run/logs] <|BOLD --manual-dir <DIR>|> The location where the manual files are stored. [${\CONFIGURE_ROOT}/run/manuals] <|BOLD --module-dir <DIR>|> The location where the loadable modules are stored. [${\CONFIGURE_ROOT}/run/modules] <|BOLD --runtime-dir <DIR>|> The location where the runtime files, such as the pid file, are stored. [${\CONFIGURE_ROOT}/run/data] <|BOLD --script-dir <DIR>|> The location where the scripts, such as the init scripts, are stored. [${\CONFIGURE_ROOT}/run] <|GREEN EXTRA MODULE OPTIONS|> <|BOLD --enable-extras <MODULE>|> Enables a comma separated list of extra modules. <|BOLD --disable-extras <MODULE>|> Disables a comma separated list of extra modules. <|BOLD --list-extras|> Shows the availability status of all extra modules. <|GREEN MISC OPTIONS|> <|BOLD --clean|> Remove the configuration cache file and start the interactive configuration wizard. <|BOLD --disable-auto-extras|> Disables automatically enabling extra modules for which the dependencies are available. <|BOLD --disable-interactive|> Disables the interactive configuration wizard. <|BOLD --disable-ownership|> Disables setting file ownership on install. <|BOLD --distribution-label <TEXT>|> Sets a distribution specific version label in the build configuration. <|BOLD --gid <ID|NAME>|> Sets the group to run InspIRCd as. <|BOLD --help|> Show this message and exit. <|BOLD --socketengine <NAME>|> Sets the socket engine to be used. Possible values are $SELIST. <|BOLD --uid [ID|NAME]|> Sets the user to run InspIRCd as. <|BOLD --update|> Updates the build environment with the settings from the cache. <|GREEN FLAGS|> <|BOLD CXX=<NAME>|> Sets the C++ compiler to use when building the server. If not specified then the build system will search for c++, g++, clang++, or icpx. <|BOLD INSPIRCD_VERBOSE=<0|1>|> Shows additional information for debugging. If you have any problems with configuring InspIRCd then visit our IRC channel at ircs://irc.teranova.net/inspircd or create a support discussion at https://github.com/inspircd/inspircd/discussions. Packagers: see https://docs.inspircd.org/packaging/ for packaging advice. EOH exit 0; } sub cmd_update { print_error "You have not run $0 before. Please do this before trying to update the generated files." unless -f CONFIGURE_CACHE_FILE; say 'Updating...'; my %config = read_config_file(CONFIGURE_CACHE_FILE); $config{EXAMPLE_DIR} //= catdir $config{CONFIG_DIR}, 'examples'; $config{RUNTIME_DIR} //= $config{DATA_DIR}; my %compiler = get_compiler_info($config{CXX}); my %version = get_version $config{DISTRIBUTION}; parse_templates(\%config, \%compiler, \%version); say 'Update complete!'; exit 0; } sub run_test($$;$) { my ($what, $result, $adjective) = @_; $adjective //= 'available'; print console_format "Checking whether <|GREEN $what|> is $adjective ... "; say console_format($result ? "<|GREEN yes|>" : "<|RED no|>"); return $result; } sub test_file($$;$) { my ($compiler, $file, $args) = @_; my $status = 0; $args //= ''; $status ||= system "$compiler -std=c++17 -o ${\CONFIGURE_ROOT}/__test_$file ${\CONFIGURE_ROOT}/make/test/$file $args ${\CONFIGURE_ERROR_PIPE}"; $status ||= system "${\CONFIGURE_ROOT}/__test_$file ${\CONFIGURE_ERROR_PIPE}"; unlink "${\CONFIGURE_ROOT}/__test_$file"; return !$status; } sub test_header($$;$) { my ($compiler, $header, $args) = @_; $args //= ''; open(my $fh, "| $compiler -E - $args ${\CONFIGURE_ERROR_PIPE}") or return 0; print $fh "#include <$header>"; close $fh; return !$?; } sub write_configure_cache(%) { unless (-e CONFIGURE_DIRECTORY) { say console_format "Creating <|GREEN ${\abs2rel CONFIGURE_DIRECTORY, CONFIGURE_ROOT}|> ..."; create_directory CONFIGURE_DIRECTORY, 0750 or print_error "unable to create ${\CONFIGURE_DIRECTORY}: $!"; } say console_format "Writing <|GREEN ${\abs2rel CONFIGURE_CACHE_FILE, CONFIGURE_ROOT}|> ..."; my %config = @_; write_config_file CONFIGURE_CACHE_FILE, %config; } sub get_compiler_info($) { my $binary = shift; my %info = (NAME => 'Unknown', VERSION => '0.0'); return %info if system "$binary -o __compiler_info ${\CONFIGURE_ROOT}/make/test/compiler.cpp ${\CONFIGURE_ERROR_PIPE}"; open(my $fh, '-|', './__compiler_info 2>/dev/null'); while (my $line = <$fh>) { $info{$1} = $2 if $line =~ /^([A-Z_]+)\s(.*)$/; } close $fh; unlink './__compiler_info'; return %info; } sub find_compiler { my @compilers = qw(c++ g++ clang++ icpx); for my $compiler (shift // @compilers) { return $compiler if __test_compiler $compiler; return "xcrun $compiler" if $^O eq 'darwin' && __test_compiler "xcrun $compiler"; } } sub parse_templates($$$) { # These are actually hash references my ($config, $compiler, $version) = @_; # Collect settings to be used when generating files my %settings = __get_template_settings($config, $compiler, $version); # Iterate through files in make/template. for my $template (<${\CONFIGURE_ROOT}/make/template/*>) { say console_format "Parsing <|GREEN ${\abs2rel $template, CONFIGURE_ROOT}|> ..."; open(my $fh, $template) or print_error "unable to read $template: $!"; my (@lines, $mode, @platforms, @targets); # First pass: parse template variables and directives. while (my $line = <$fh>) { chomp $line; # Does this line match a variable? while ($line =~ /(@(\w+?)(?:\|(\w*))?@)/) { my ($variable, $name, $default) = ($1, $2, $3); if (defined $settings{$name}) { $line =~ s/\Q$variable\E/$settings{$name}/; } elsif (defined $default) { $line =~ s/\Q$variable\E/$default/; } else { print_warning "unknown template variable '$name' in $template!"; last; } } # Does this line match a directive? if ($line =~ /^(\s*)%(\w+)\s+(.+)$/) { if ($2 eq 'define') { if ($settings{$3}) { push @lines, "#$1define $3"; } else { push @lines, "#$1undef $3"; } } elsif ($2 eq 'mode') { $mode = oct $3; } elsif ($2 eq 'platform') { push @platforms, $3; } elsif ($2 eq 'target') { push @targets, catfile CONFIGURE_ROOT, $3; } else { print_warning "unknown template command '$2' in $template!"; push @lines, $line; } next; } push @lines, $line; } close $fh; # Only proceed if this file should be templated on this platform. if ($#platforms < 0 || grep { $_ eq $^O } @platforms) { # Add a default target if the template has not defined one. unless (@targets) { push @targets, catfile(CONFIGURE_DIRECTORY, basename $template); } # Write the templated files to disk. for my $target (@targets) { # Create the directory if it doesn't already exist. my $directory = dirname $target; unless (-e $directory) { say console_format "Creating <|GREEN ${\abs2rel $directory, CONFIGURE_ROOT}|> ..."; create_directory $directory, 0750 or print_error "unable to create $directory: $!"; }; # Write the template file. say console_format "Writing <|GREEN ${\abs2rel $target, CONFIGURE_ROOT}|> ..."; open(my $fh, '>', $target) or print_error "unable to write $target: $!"; for (@lines) { say $fh $_; } close $fh; # Set file permissions. if (defined $mode) { chmod $mode, $target; } } } } } 1; ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/make/console.pm����������������������������������������������������������������������0000664�0000000�0000000�00000010153�14771603147�0016264�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������# # InspIRCd -- Internet Relay Chat Daemon # # Copyright (C) 2014-2017, 2019-2022 Sadie Powell <sadie@witchery.services> # # This file is part of InspIRCd. InspIRCd is free software: you can # redistribute it and/or modify it under the terms of the GNU General Public # License as published by the Free Software Foundation, version 2. # # This program is distributed in the hope that it will be useful, but WITHOUT # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS # FOR A PARTICULAR PURPOSE. See the GNU General Public License for more # details. # # You should have received a copy of the GNU General Public License # along with this program. If not, see <http://www.gnu.org/licenses/>. # package make::console; use v5.26.0; use strict; use warnings FATAL => qw(all); use Class::Struct qw(struct); use Exporter qw(import); use File::Path qw(mkpath); use File::Spec::Functions qw(rel2abs); our @EXPORT = qw(command execute_command console_format print_error print_warning prompt_bool prompt_dir prompt_string); my %FORMAT_CODES = ( DEFAULT => "\e[0m", BOLD => "\e[1m", ITALIC => "\e[3m", UNDERLINE => "\e[4m", RED => "\e[1;31m", GREEN => "\e[1;32m", YELLOW => "\e[1;33m", BLUE => "\e[1;34m" ); my %commands; struct 'command' => { 'callback' => '$', 'description' => '$', }; sub console_format($) { my $message = shift; while ($message =~ /(<\|(\S+)\s(.*?)\|>)/) { my ($match, $type, $text) = ($1, uc $2, $3); if (-t STDOUT && exists $FORMAT_CODES{$type}) { $message =~ s/\Q$match\E/$FORMAT_CODES{$type}$text$FORMAT_CODES{DEFAULT}/; } else { $message =~ s/\Q$match\E/$text/; } } return $message; } sub print_error { print STDERR console_format "<|RED Error:|> "; for my $line (@_) { say STDERR console_format $line; } exit 1; } sub print_warning { print STDERR console_format "<|YELLOW Warning:|> "; for my $line (@_) { say STDERR console_format $line; } } sub prompt_bool($$$) { my ($interactive, $question, $default) = @_; while (1) { my $answer = prompt_string($interactive, $question, $default ? 'yes' : 'no'); return 1 if $answer =~ /^y(?:es)?$/i; return 0 if $answer =~ /^no?$/i; print_warning "\"$answer\" is not \"yes\" or \"no\". Please try again.\n"; } } sub prompt_dir($$$;$) { my ($interactive, $question, $default, $create_now) = @_; my ($answer, $create); do { $answer = rel2abs(prompt_string($interactive, $question, $default)); $create = prompt_bool($interactive && !-d $answer, "$answer does not exist. Create it?", 'y'); if ($create && $create_now) { unless (create_directory $answer, 0750) { print_warning "unable to create $answer: $!\n"; $create = 0; } } } while (!$create); return $answer; } sub prompt_string($$$) { my ($interactive, $question, $default) = @_; return $default unless $interactive; say console_format $question; print console_format "[<|GREEN $default|>] => "; chomp(my $answer = <STDIN>); say ''; return $answer ? $answer : $default; } sub command($$$) { my ($name, $description, $callback) = @_; $commands{$name} = command->new; $commands{$name}->callback($callback); $commands{$name}->description($description); } sub command_alias($$) { my ($source, $target) = @_; command $source, undef, sub(@) { execute_command $target, @_; }; } sub execute_command(@) { my $command = defined $_[0] ? lc shift : 'help'; if ($command eq 'help') { say console_format "<|GREEN Usage:|> $0 <<|UNDERLINE COMMAND|>> [<|UNDERLINE OPTIONS...|>]"; say ''; say console_format "<|GREEN Commands:|>"; for my $key (sort keys %commands) { next unless defined $commands{$key}->description; my $name = sprintf "%-15s", $key; my $description = $commands{$key}->description; say console_format " <|BOLD $name|> # $description"; } exit 0; } elsif (!$commands{$command}) { print_error "no command called <|BOLD $command|> exists!", "See <|BOLD $0 help|> for a list of commands."; } else { return $commands{$command}->callback->(@_); } } 1; ���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/make/directive.pm��������������������������������������������������������������������0000664�0000000�0000000�00000026763�14771603147�0016616�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������# # InspIRCd -- Internet Relay Chat Daemon # # Copyright (C) 2016-2024 Sadie Powell <sadie@witchery.services> # # This file is part of InspIRCd. InspIRCd is free software: you can # redistribute it and/or modify it under the terms of the GNU General Public # License as published by the Free Software Foundation, version 2. # # This program is distributed in the hope that it will be useful, but WITHOUT # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS # FOR A PARTICULAR PURPOSE. See the GNU General Public License for more # details. # # You should have received a copy of the GNU General Public License # along with this program. If not, see <http://www.gnu.org/licenses/>. # package make::directive; use v5.26.0; use strict; use warnings FATAL => qw(all); use File::Basename qw(dirname); use File::Spec::Functions qw(catdir); use Exporter qw(import); use make::common; use make::configure; use make::console; use constant DIRECTIVE_ERROR_PIPE => $ENV{INSPIRCD_VERBOSE} ? '' : '2>/dev/null'; use constant PKG_CONFIG => $ENV{PKG_CONFIG} || 'pkg-config'; our @EXPORT = qw( get_directives get_directive execute_functions ); sub get_directives($$;$) { my ($file, $property, $functions) = @_; $functions //= 1; open(my $fh, $file) or return (); my @values; while (<$fh>) { if ($_ =~ /^\/\* \$(\S+): (.+) \*\/$/ || $_ =~ /^\/\/\/ \$(\S+): (.+)/) { next unless $1 eq $property; my $value = $functions ? execute_functions($file, $1, $2) : $2; push @values, $value; } } close $fh; return @values; } sub get_directive($$;$$) { my ($file, $property, $default, $functions) = @_; my @values = get_directives($file, $property, $functions); my $value = join ' ', @values; $value =~ s/^\s+|\s+$//g; return $value || $default; } sub execute_functions($$$) { my ($file, $name, $line) = @_; # NOTE: we have to use 'our' instead of 'my' here because of a Perl bug. for (our @parameters = (); $line =~ /([a-z_]+)\((?:\s*"([^"]*)(?{push @parameters, $2})"\s*)*\)/; undef @parameters) { my $sub = make::directive->can("__function_$1"); print_error "unknown $name function '$1' in $file!" unless $sub; # Call the subroutine and replace the function. my $result = $sub->($file, @parameters); if (defined $result) { $line = $` . $result . $'; next; } # If the subroutine returns undef then it is a sign that we should # disregard the rest of the line and stop processing it. $line = $`; } return $line; } sub __clean_flags($) { my $flags = shift; # It causes problems if a dependency tries to force a specific C++ version # so we strip it and handle it ourselves. $flags =~ s/(?:^|\s+)-std=(?:c|gnu)\+\+[A-Za-z0-9]+(?:\$|\s+)/ /g; # Strip any whitespace our changes have left behind. $flags =~ s/^\s+|\s+$//g; return $flags; } sub __environment { my ($prefix, $suffix) = @_; $suffix =~ s/[-.]/_/g; $suffix =~ s/[^A-Za-z0-9_]//g; return $prefix . uc $suffix; } sub __env_or_unset { my $name = shift; return $ENV{$name} || '<|ITALIC unset|>'; }; sub __error { my ($file, @message) = @_; push @message, ''; # If we have package details then suggest to the user that they check # that they have the packages installed.= my $dependencies = get_directive($file, 'PackageInfo'); if (defined $dependencies) { my @packages = sort grep { /^\S+$/ } split /\s/, $dependencies; push @message, 'You should make sure you have the following packages installed:'; for (@packages) { push @message, " * $_"; } } else { push @message, 'You should make sure that you have all of the required dependencies'; push @message, 'for this module installed.'; } push @message, ''; # If we have author information then tell the user to report the bug # to them. Otherwise, assume it is a bundled module and tell the user # to report it to the InspIRCd issue tracker. my @authors = get_directives($file, 'ModAuthor'); if (@authors) { push @message, 'If you believe this error to be a bug then you can try to contact the'; push @message, "author${$#authors ? \'s' : \''} of this module:"; for my $author (@authors) { push @message, " * $author"; } } else { my %version = get_version(); push @message, 'If you believe this error to be a bug then you can file a bug report'; push @message, 'at https://github.com/inspircd/inspircd/issues. Please include the'; push @message, 'following data in your report:'; push @message, " * CPPFLAGS: ${\__env_or_unset 'CPPFLAGS'}"; push @message, " * CXXFLAGS: ${\__env_or_unset 'CXXFLAGS'}"; push @message, " * LDFLAGS: ${\__env_or_unset 'LDFLAGS'}"; push @message, " * PATH: ${\__env_or_unset 'PATH'}"; push @message, " * PKG_CONFIG: ${\__env_or_unset 'PKG_CONFIG'}"; push @message, " * PKG_CONFIG_PATH: ${\__env_or_unset 'PKG_CONFIG_PATH'}"; push @message, ''; push @message, 'You can also refer to the documentation page for this module at'; push @message, "https://docs.inspircd.org/$version{MAJOR}/modules/${\module_shrink $file}."; } push @message, ''; push @message, 'If you would like help with fixing this problem then visit our IRC'; push @message, 'channel at ircs://irc.teranova.net/inspircd or create a support'; push @message, 'discussion at https://github.com/inspircd/inspircd/discussions.'; push @message, ''; print_error @message; } sub __function_error { my ($file, @messages) = @_; __error $file, @messages; } sub __function_execute { my ($file, $command, $environment, $defaults) = @_; # Try to execute the command... chomp(my $result = `$command ${\DIRECTIVE_ERROR_PIPE}`); unless ($?) { $result = __clean_flags $result; say console_format "Execution of `<|GREEN $command|>` succeeded: <|BOLD $result|>"; return $result; } # If looking up with pkg-config fails then check the environment... if (defined $environment && $environment ne '') { $environment = __environment 'INSPIRCD_', $environment; if (defined $ENV{$environment}) { say console_format "Execution of `<|GREEN $command|>` failed; using the environment: <|BOLD $ENV{$environment}|>"; return $ENV{$environment}; } } # If all else fails then look for the defaults.. if (defined $defaults) { say console_format "Execution of `<|GREEN $command|>` failed; using the defaults: <|BOLD $defaults|>"; return $defaults; } # Executing the command failed and we don't have any defaults so give up. __error $file, "`<|GREEN $command|>` exited with a non-zero exit code!"; } sub __function_find_compiler_flags { my ($file, $name, $defaults) = @_; # Try to look up the compiler flags with pkg-config... chomp(my $flags = `${\PKG_CONFIG} --cflags $name ${\DIRECTIVE_ERROR_PIPE}`); unless ($?) { $flags = __clean_flags $flags; say console_format "Found the <|GREEN $name|> compiler flags for <|GREEN ${\module_shrink $file}|> using pkg-config: <|BOLD $flags|>"; return $flags; } # If looking up with pkg-config fails then check the environment... my $key = __environment 'INSPIRCD_CXXFLAGS_', $name; if (defined $ENV{$key}) { say console_format "Found the <|GREEN $name|> compiler flags for <|GREEN ${\module_shrink $file}|> using the environment: <|BOLD $ENV{$key}|>"; return $ENV{$key}; } # If all else fails then look for the defaults.. if (defined $defaults) { say console_format "Using the default <|GREEN $name|> compiler flags for <|GREEN ${\module_shrink $file}|>: <|BOLD $defaults|>"; return $defaults; } # We can't find it via pkg-config, via the environment, or via the defaults so give up. __error $file, "unable to find the <|GREEN $name|> compiler flags for <|GREEN ${\module_shrink $file}|>!"; } sub __function_find_linker_flags { my ($file, $name, $defaults) = @_; # Try to look up the linker flags with pkg-config... chomp(my $flags = `${\PKG_CONFIG} --libs $name ${\DIRECTIVE_ERROR_PIPE}`); unless ($?) { $flags = __clean_flags $flags; say console_format "Found the <|GREEN $name|> linker flags for <|GREEN ${\module_shrink $file}|> using pkg-config: <|BOLD $flags|>"; return $flags; } # If looking up with pkg-config fails then check the environment... my $key = __environment 'INSPIRCD_CXXFLAGS_', $name; if (defined $ENV{$key}) { say console_format "Found the <|GREEN $name|> linker flags for <|GREEN ${\module_shrink $file}|> using the environment: <|BOLD $ENV{$key}|>"; return $ENV{$key}; } # If all else fails then look for the defaults.. if (defined $defaults) { say console_format "Using the default <|GREEN $name|> linker flags for <|GREEN ${\module_shrink $file}|>: <|BOLD $defaults|>"; return $defaults; } # We can't find it via pkg-config, via the environment, or via the defaults so give up. __error $file, "unable to find the <|GREEN $name|> linker flags for <|GREEN ${\module_shrink $file}|>!"; } sub __function_require_compiler { my ($file, $name, $minimum, $maximum) = @_; # Check for an inverted match. my ($ok, $err) = ("", undef); if ($name =~ s/^!//) { ($ok, $err) = ($err, $ok); } # Look up information about the compiler. return $err unless $ENV{CXX}; my %compiler = get_compiler_info($ENV{CXX}); # Check whether the current compiler is suitable. return $err unless $compiler{NAME} eq $name; return $err if defined $minimum && $compiler{VERSION} < $minimum; return $err if defined $maximum && $compiler{VERSION} > $maximum; # Requirement directives don't change anything directly. return $ok; } sub __function_require_system { my ($file, $name, $minimum, $maximum) = @_; my ($system, $system_like, $version); # Check for an inverted match. my ($ok, $err) = ("", undef); if ($name =~ s/^!//) { ($ok, $err) = ($err, $ok); } # If a system name ends in a tilde we match on alternate names. my $match_like = $name =~ s/~$//; # Linux is special and can be compared by distribution names. if ($^O eq 'linux' && $name ne 'linux') { chomp($system = lc `sh -c '. /etc/os-release 2>/dev/null && echo \$ID'`); chomp($system_like = lc `sh -c '. /etc/os-release 2>/dev/null && echo \$ID_LIKE'`); chomp($version = lc `sh -c '. /etc/os-release 2>/dev/null && echo \$VERSION_ID'`); } # Gather information on the system if we don't have it already. chomp($system ||= lc `uname -s 2>/dev/null`); chomp($version ||= lc `uname -r 2>/dev/null`); $system_like ||= ''; # We only care about the important bit of the version number so trim the rest. $version =~ s/^(\d+\.\d+).+/$1/; # Check whether the current system is suitable. if ($name ne $system) { return $err unless $match_like; return $err unless grep { $_ eq $name } split /\s+/, $system_like; } return $err if defined $minimum && $version < $minimum; return $err if defined $maximum && $version > $maximum; # Requirement directives don't change anything directly. return $ok; } sub __function_require_library { my ($file, $name, $minimum, $maximum) = @_; # Check for an inverted match. my ($ok, $err) = ("", undef); if ($name =~ s/^!//) { ($ok, $err) = ($err, $ok); } # If pkg-config isn't installed then we can't do anything here. if (system "${\PKG_CONFIG} --version 1>/dev/null 2>/dev/null") { print_warning "unable to look up the version of <|GREEN $name|> using pkg-config!"; return $err; } # Check with pkg-config whether we have the required version. return $err if system "${\PKG_CONFIG} --exists $name"; return $err if defined $minimum && system "${\PKG_CONFIG} --atleast-version $minimum $name"; return $err if defined $maximum && system "${\PKG_CONFIG} --max-version $maximum $name"; # Requirement directives don't change anything directly. return $ok; } sub __function_warning { my ($file, @messages) = @_; print_warning @messages; } 1; �������������inspircd-4.7.0/make/template/�����������������������������������������������������������������������0000775�0000000�0000000�00000000000�14771603147�0016077�5����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/make/template/apparmor���������������������������������������������������������������0000664�0000000�0000000�00000003101�14771603147�0017636�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������%platform linux # # InspIRCd -- Internet Relay Chat Daemon # # Copyright (C) 2024 Marcus Rueckert <darix@nordisch.org> # Copyright (C) 2020-2022, 2024 Sadie Powell <sadie@witchery.services> # # This file is part of InspIRCd. InspIRCd is free software: you can # redistribute it and/or modify it under the terms of the GNU General Public # License as published by the Free Software Foundation, version 2. # # This program is distributed in the hope that it will be useful, but WITHOUT # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS # FOR A PARTICULAR PURPOSE. See the GNU General Public License for more # details. # # You should have received a copy of the GNU General Public License # along with this program. If not, see <http://www.gnu.org/licenses/>. # # To use this file move it to /etc/apparmor.d/inspircd #include <tunables/global> profile inspircd @BINARY_DIR@/inspircd { include <abstractions/base> include <abstractions/nameservice> capability net_bind_service, capability setgid, capability setuid, capability sys_resource, @BINARY_DIR@/inspircd ixr, @CONFIG_DIR@/** rw, @DATA_DIR@/** rw, @MODULE_DIR@/ r, @MODULE_DIR@/core_*.so mr, @MODULE_DIR@/m_*.so mr, @LOG_DIR@/** w, @RUNTIME_DIR@/** rw, # Required by the ldap module: include <abstractions/ldapclient> # Required by the mysql module: include <abstractions/mysql> # Required by the ssl_gnutls and ssl_openssl modules: include <abstractions/ssl_certs> include <abstractions/ssl_keys> # External distro/install specific rules: include if exists <local/inspircd> } ���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/make/template/config.h���������������������������������������������������������������0000664�0000000�0000000�00000004730�14771603147�0017521�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2014, 2016, 2018-2021, 2024 Sadie Powell <sadie@witchery.services> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #pragma once /** The branch version that is shown to unprivileged users. */ #define INSPIRCD_BRANCH "InspIRCd-@VERSION_MAJOR@" /** The full version that is shown to privileged users. */ #define INSPIRCD_VERSION "InspIRCd-@VERSION_FULL@" /** Determines whether this version of InspIRCd is older than the requested version. */ #define INSPIRCD_VERSION_BEFORE(MAJOR, MINOR) (((@VERSION_MAJOR@ << 8) | @VERSION_MINOR@) < ((MAJOR << 8) | (MINOR))) /** Determines whether this version of InspIRCd is equal to or newer than the requested version. */ #define INSPIRCD_VERSION_SINCE(MAJOR, MINOR) (((@VERSION_MAJOR@ << 8) | @VERSION_MINOR@) >= ((MAJOR << 8) | (MINOR))) /** The default location that config files are stored in. */ #define INSPIRCD_CONFIG_PATH "@CONFIG_DIR@" /** The default location that example config files are stored in. */ #define INSPIRCD_EXAMPLE_PATH "@EXAMPLE_DIR@" /** The default location that data files are stored in. */ #define INSPIRCD_DATA_PATH "@DATA_DIR@" /** The default location that log files are stored in. */ #define INSPIRCD_LOG_PATH "@LOG_DIR@" /** The default location that module files are stored in. */ #define INSPIRCD_MODULE_PATH "@MODULE_DIR@" /** The default location that runtime files are stored in. */ #define INSPIRCD_RUNTIME_PATH "@RUNTIME_DIR@" /** The URL of the InspIRCd docs site. */ #define INSPIRCD_DOCS "https://docs.inspircd.org/@VERSION_MAJOR@/" #ifndef _WIN32 %target include/config.h /** Whether the arc4random_buf() function was available at compile time. */ %define HAS_ARC4RANDOM_BUF /** Whether the clock_gettime() function was available at compile time. */ %define HAS_CLOCK_GETTIME /** Whether the getentropy() function was available at compile time. */ %define HAS_GETENTROPY #endif ����������������������������������������inspircd-4.7.0/make/template/deploy-ssl.sh����������������������������������������������������������0000664�0000000�0000000�00000002104�14771603147�0020523�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������%mode 0750 #!/bin/sh set -e # IMPORTANT: This script is an example post-deploy hook for use with CertBot, # Dehydrated, or a similar SSL (TLS) renewal tool. You will need to customise # it for your setup before you use it # The location your renewal tool places your certificates. CERT_DIR="/etc/letsencrypt/live/irc.example.com" # The location of the InspIRCd config directory. INSPIRCD_CONFIG_DIR="@CONFIG_DIR@" # The location of the InspIRCd pid file. INSPIRCD_PID_FILE="@RUNTIME_DIR@/inspircd.pid" # The user:group that InspIRCd runs as. INSPIRCD_OWNER="@USER@:@GROUP@" if [ -e ${CERT_DIR} -a -e ${INSPIRCD_CONFIG_DIR} ] then cp "${CERT_DIR}/fullchain.pem" "${INSPIRCD_CONFIG_DIR}/cert.pem" cp "${CERT_DIR}/privkey.pem" "${INSPIRCD_CONFIG_DIR}/key.pem" chown ${INSPIRCD_OWNER} "${INSPIRCD_CONFIG_DIR}/cert.pem" "${INSPIRCD_CONFIG_DIR}/key.pem" if [ -r ${INSPIRCD_PID_FILE} ] then kill -USR1 $(cat ${INSPIRCD_PID_FILE}) elif [ -d /lib/systemd ] && systemctl --quiet is-active inspircd then systemctl kill --signal USR1 inspircd fi fi ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/make/template/help.txt���������������������������������������������������������������0000664�0000000�0000000�00000001361�14771603147�0017571�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������Thanks for installing InspIRCd! In order to get your server running you need to create config files. Examples can be found at `@EXAMPLE_DIR@`. If you need any help with this then you can visit our support channel at ircs://irc.teranova.net/inspircd, open a support discussion at https://git.io/JIuYv, or refer to the the docs site: https://docs.inspircd.org/@VERSION_MAJOR@/configuration https://docs.inspircd.org/@VERSION_MAJOR@/modules When you are done you can run the following command to start InspIRCd: @BINARY_DIR@/inspircd If you have installed from an official package you may need to prefix this command with `sudo -g @GROUP@ -u @USER@` to run as the correct group/user. You can also use one of the helper scripts in `@SCRIPT_DIR@`. �������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/make/template/inspircd���������������������������������������������������������������0000664�0000000�0000000�00000027603�14771603147�0017645�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������%mode 0750 #!/usr/bin/env perl # # InspIRCd -- Internet Relay Chat Daemon # # Copyright (C) 2015 Steven Van Acker <steven@singularity.be> # Copyright (C) 2015 Attila Molnar <attilamolnar@hush.com> # Copyright (C) 2014, 2016, 2019, 2021, 2023-2024 Sadie Powell <sadie@witchery.services> # Copyright (C) 2014 Dan Parsons <dparsons@nyip.net> # Copyright (C) 2012 Robby <robby@chatbelgie.be> # Copyright (C) 2011 DjSlash <djslash@djslash.org> # Copyright (C) 2009-2010 Daniel De Graaf <danieldg@inspircd.org> # Copyright (C) 2008-2009 Robin Burchell <robin+git@viroteck.net> # Copyright (C) 2008 Thomas Stagner <aquanight@gmail.com> # Copyright (C) 2007 Dennis Friis <peavey@inspircd.org> # Copyright (C) 2006 Oliver Lupton <om@inspircd.org> # Copyright (C) 2006 John Brooks <john@jbrooks.io> # Copyright (C) 2005-2006, 2008-2009 Craig Edwards <brain@inspircd.org> # Copyright (C) 2005 Craig McLure <craig@frostycoolslug.com> # # This file is part of InspIRCd. InspIRCd is free software: you can # redistribute it and/or modify it under the terms of the GNU General Public # License as published by the Free Software Foundation, version 2. # # This program is distributed in the hope that it will be useful, but WITHOUT # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS # FOR A PARTICULAR PURPOSE. See the GNU General Public License for more # details. # # You should have received a copy of the GNU General Public License # along with this program. If not, see <http://www.gnu.org/licenses/>. # # InspIRCd Start up the InspIRCd Internet Relay Chat Daemon # # chkconfig: 2345 55 25 # description: InspIRCd -- Internet Relay Chat Daemon # # processname: inspircd use strict; use POSIX; use Fcntl; # From http://refspecs.linuxbase.org/LSB_4.1.0/LSB-Core-generic/LSB-Core-generic/iniscrptact.html use constant { STATUS_EXIT_SUCCESS => 0, STATUS_EXIT_DEAD_WITH_PIDFILE => 1, STATUS_EXIT_DEAD_WITH_LOCKFILE => 2, STATUS_EXIT_NOT_RUNNING => 3, STATUS_EXIT_UNKNOWN => 4, GENERIC_EXIT_SUCCESS => 0, GENERIC_EXIT_UNSPECIFIED => 1, GENERIC_EXIT_INVALID_ARGUMENTS => 2, GENERIC_EXIT_UNIMPLEMENTED => 3, GENERIC_EXIT_INSUFFICIENT_PRIVILEGE => 4, GENERIC_EXIT_NOT_INSTALLED => 5, GENERIC_EXIT_NOT_CONFIGURED => 6, GENERIC_EXIT_NOT_RUNNING => 7 }; my $configdir = "@CONFIG_DIR@"; my @debugargs = qw(--nolog --nopid --protocoldebug); my $executable = "@BINARY_DIR@/inspircd"; my $runtimedir = "@RUNTIME_DIR@"; my $valgrindlogdir = "@LOG_DIR@/valgrind"; my @gdbargs = ( '--eval-command', 'set pagination off', '--eval-command', 'handle all nostop pass print', '--eval-command', 'run', '--args', $executable, @debugargs, ); sub expand_fragment($$) { my ($base, $fragment) = @_; if ($fragment =~ /^\//) { return $fragment; } else { return "$base/$fragment"; } } our($pid,$pidfile); # Lets see what they want to do.. Set the variable (Cause i'm a lazy coder) my $arg = shift(@ARGV); my $conf; for my $a (@ARGV) { if ($a =~ m/^--config=(.*)$/) { $conf = $1; last; } } if (!defined $conf) { $conf = expand_fragment $configdir, "inspircd.conf"; push @ARGV, '--config='.$conf; } getpidfile($conf); # System for naming script command subs: # cmd_<name> - Normal command for use by users. # dev_<name> - Developer commands. # hid_<name> - Hidden commands (ie Cheese-Sandwich) # Ideally command subs shouldn't return. my $subname = $arg; $subname =~ s/-/_/g; my $sub = main->can("cmd_$subname") || main->can("dev_$subname") || main->can("hid_$subname"); if (!defined($sub)) { print STDERR "Invalid command or none given.\n"; cmd_help(); exit GENERIC_EXIT_UNIMPLEMENTED; } else { exit $sub->(@ARGV); # Error code passed through return value } sub cmd_help() { my @subs = grep { $_ =~ m/^(cmd|dev)_/ && defined(main->can($_)) } keys(%::); my @cmds = grep /^cmd_/, @subs; my @devs = grep /^dev_/, @subs; local $_; $_ =~ s/^(cmd|dev)_// for (@cmds, @devs); $_ =~ s/_/-/g for (@cmds, @devs); print STDERR "Usage: ./inspircd (" . join("|", @cmds) . ")\n"; print STDERR "Developer arguments: (" . join("|", @devs) . ")\n"; exit GENERIC_EXIT_SUCCESS; } sub cmd_status() { if (getstatus() == 1) { my $pid = getprocessid(); print "InspIRCd is running (PID: $pid)\n"; exit STATUS_EXIT_SUCCESS; } else { print "InspIRCd is not running. (Or PID File not found)\n"; exit STATUS_EXIT_NOT_RUNNING; } } sub signal($) { my $sig = shift; if (getstatus() == 1) { my $pid = getprocessid(); kill $sig => $pid; print "InspIRCd rehashed (pid: $pid).\n"; exit GENERIC_EXIT_SUCCESS; } else { print "InspIRCd is not running. (Or PID File not found)\n"; exit GENERIC_EXIT_NOT_RUNNING; } } sub cmd_rehash() { signal 'HUP'; } sub cmd_sslrehash() { signal 'USR1'; } sub cmd_cron() { if (getstatus() == 0) { goto &cmd_start(@_); } exit GENERIC_EXIT_UNSPECIFIED; } sub cmd_version() { exec $executable, '--version' or die "Unable to execute $executable: $!" } sub cmd_restart(@) { cmd_stop(); unlink($pidfile) if (-e $pidfile); goto &cmd_start(@_); } sub cmd_start(@) { # Check to see its not 'running' already. if (getstatus() == 1) { print "InspIRCd is already running.\n"; exit GENERIC_EXIT_SUCCESS; } # If we are still alive here.. Try starting the IRCd.. print "$executable doesn't exist\n" and return 0 unless(-e $executable); print "$executable is not executable\n" and return 0 unless(-f $executable && -x $executable); exec $executable, @_; die "Failed to start IRCd: $!\n"; } sub dev_debug(@) { # Check to see its not 'running' already. if (getstatus() == 1) { print "InspIRCd is already running.\n"; return 0; } print "$executable doesn't exist\n" and return 0 unless(-e $executable); print "$executable is not executable\n" and return 0 unless(-f $executable && -x $executable); # Check we have gdb check("gdb"); # If we are still alive here.. Try starting the IRCd.. exec 'gdb', @gdbargs, @_; die "Failed to start GDB: $!\n"; } sub dev_screendebug(@) { # Check to see its not 'running' already. if (getstatus() == 1) { print "InspIRCd is already running.\n"; return 0; } print "$executable doesn't exist\n" and return 0 unless(-e $executable); #Check we have gdb check("gdb", "screen"); # If we are still alive here.. Try starting the IRCd.. print "Starting InspIRCd in `screen`, type `screen -r` when the ircd crashes to view the gdb output and get a backtrace.\n"; print "Once you're inside the screen session press ^C + d to re-detach from the session\n"; exec qw(screen -m -d gdb), @gdbargs, @_; die "Failed to start screen: $!\n"; } sub dev_valdebug(@) { # Check to see its not 'running' already. if (getstatus() == 1) { print "InspIRCd is already running.\n"; return 0; } print "$executable doesn't exist\n" and return 0 unless(-e $executable); print "$executable is not executable\n" and return 0 unless(-f $executable && -x $executable); # Check we have valgrind check("valgrind"); # If we are still alive here.. Try starting the IRCd.. # May want to do something with these args at some point: --suppressions=.inspircd.sup --gen-suppressions=yes # Could be useful when we want to stop it complaining about things we're sure aren't issues. exec qw(valgrind -v --tool=memcheck --leak-check=yes --num-callers=30), $executable, @debugargs, @_; die "Failed to start valgrind: $!\n"; } sub dev_valdebug_unattended(@) { # NOTE: To make sure valgrind generates coredumps, set soft core limit in /etc/security/limits.conf to unlimited # Check to see its not 'running' already. if (getstatus() == 1) { print "InspIRCd is already running.\n"; return 0; } print "$executable doesn't exist\n" and return 0 unless(-e $executable); print "$executable is not executable\n" and return 0 unless(-f $executable && -x $executable); # Check we have valgrind check("valgrind"); # If we are still alive here.. Try starting the IRCd.. # # NOTE: Saving the debug log (redirected stdout), while useful, is a potential security risk AND one hell of a spacehog. DO NOT SAVE THIS WHERE EVERYONE HAS ACCESS! # Redirect stdout to /dev/null if you're worried about the security. # my $pid = fork; if ($pid == 0) { POSIX::setsid(); -d $valgrindlogdir or mkdir $valgrindlogdir or die "Cannot create $valgrindlogdir: $!\n"; my $suffix = strftime("%Y%m%d-%H%M%S", localtime(time)) . ".$$"; open STDIN, '<', '/dev/null' or die "Can't redirect STDIN to /dev/null: $!\n"; sysopen STDOUT, "$valgrindlogdir/out.$suffix", O_WRONLY | O_CREAT | O_NOCTTY | O_APPEND, 0600 or die "Can't open $valgrindlogdir/out.$suffix: $!\n"; sysopen STDERR, "$valgrindlogdir/valdebug.$suffix", O_WRONLY | O_CREAT | O_NOCTTY | O_APPEND, 0666 or die "Can't open $valgrindlogdir/valdebug.$suffix: $!\n"; exec qw(valgrind -v --tool=memcheck --leak-check=full --show-reachable=yes --num-callers=30 --track-fds=yes), qw(--leak-resolution=med --time-stamp=yes --log-fd=2 --), $executable, @debugargs, @_; die "Can't execute valgrind: $!\n"; } } sub dev_screenvaldebug(@) { # Check to see its not 'running' already. if (getstatus() == 1) { print "InspIRCd is already running.\n"; return 0; } print "$executable doesn't exist\n" and return 0 unless(-e $executable); print "$executable is not executable\n" and return 0 unless(-f $executable && -x $executable); check("gdb", "screen", "valgrind"); # If we are still alive here.. Try starting the IRCd.. print "Starting InspIRCd in `screen`, type `screen -r` when the ircd crashes to view the valgrind and gdb output and get a backtrace.\n"; print "Once you're inside the screen session press ^C + d to re-detach from the session\n"; exec qw(screen -m -d valgrind -v --tool=memcheck --leak-check=yes --num-callers=30), $executable, @debugargs, @_; die "Failed to start screen: $!\n"; } sub cmd_stop() { if (getstatus() == 0) { print "InspIRCd is not running. (Or PID File not found)\n"; return GENERIC_EXIT_SUCCESS; } # Get to here, we have something to kill. my $pid = getprocessid(); print "Stopping InspIRCd (pid: $pid)...\n"; my $maxwait = (`ps -o command $pid 2>/dev/null` =~ /valgrind/i) ? 90 : 15; kill TERM => $pid or die "Cannot terminate IRCd: $!\n"; for (1..$maxwait) { sleep 1; if (getstatus() == 0) { print "InspIRCd Stopped.\n"; return GENERIC_EXIT_SUCCESS; } } print "InspIRCd not dying quietly -- forcing kill\n"; kill KILL => $pid; return GENERIC_EXIT_SUCCESS; } ### # Generic Helper Functions. ### my %filesparsed; sub getpidfile { my ($file) = @_; # Before we start, do we have a PID already? (Should never occur) if ($pid ne "") { return; } # Expand any relative paths. $file = expand_fragment $configdir, $file; # Have we checked this file before? return if $filesparsed{$file}; $filesparsed{$file} = 1; # Open the File.. open INFILE, '<', $file or return; # Grab entire file contents.. my(@lines) = <INFILE>; # Close the file close INFILE; # remove trailing spaces chomp(@lines); for my $i (@lines) { # clean it up $i =~ s/[^=]+=\s(.*)/\1/; # Does this file have a pid? if (($i =~ /<pid file=\"(\S+)\">/i) && ($i !~ /^#/)) { # Set the PID file and return. $pidfile = expand_fragment $runtimedir, $1; return; } } # If we get here, NO PID FILE! -- Check for includes for my $i (@lines) { $i =~ s/[^=]+=\s(.*)/\1/; if (($i =~ s/\<include file=\"(.+?)\"\>//i) && ($i !~ /^#/)) { # Descend into that file, and check for PIDs.. (that sounds like an STD ;/) getpidfile($1); # Was a PID found? if ($pidfile ne "") { # Yes, Return. return; } } } # End of includes / No includes found. Using default. $pidfile = expand_fragment $runtimedir, "inspircd.pid"; } sub getstatus { my $pid = getprocessid(); return 0 if $pid == 0; return kill 0, $pid; } sub getprocessid { my $pid = 0; open PIDFILE, '<', $pidfile or return 0; while(<PIDFILE>) { /^(\d+)$/ and $pid = $1; } close PIDFILE; return $pid; } sub check(@) { for my $tool (@_) { unless(`$tool --version`) { print "Couldn't start $tool: $!\n"; exit GENERIC_EXIT_UNSPECIFIED; } } } �����������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/make/template/inspircd-testssl.1�����������������������������������������������������0000664�0000000�0000000�00000002622�14771603147�0021475�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������.\" .\" InspIRCd -- Internet Relay Chat Daemon .\" .\" Copyright (C) 2020, 2024 Sadie Powell <sadie@witchery.services> .\" .\" This file is part of InspIRCd. InspIRCd is free software: you can .\" redistribute it and/or modify it under the terms of the GNU General Public .\" License as published by the Free Software Foundation, version 2. .\" .\" This program is distributed in the hope that it will be useful, but WITHOUT .\" ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS .\" FOR A PARTICULAR PURPOSE. See the GNU General Public License for more .\" details. .\" .\" You should have received a copy of the GNU General Public License .\" along with this program. If not, see <http://www.gnu.org/licenses/>. .\" .TH "InspIRCd" "1" "2024-06-28" "InspIRCd @VERSION_FULL@" "InspIRCd Manual" .SH "NAME" \t\fBInspIRCd\fR - \fIthe\fR stable, high-performance and modular Internet Relay Chat Daemon .BR .SH "SYNOPSIS" \t\fBinspircd-testssl\fR <hostip> <port> [selfsigned] .SH "OPTIONS" .TP .B "hostip" .br The hostname or IP address to connect to. .TP .B "port" .br The TCP port to connect to. .TP .br .B "selfsigned" Disables checking whether the server certificate is signed by a Certificate Authority. .SH "SUPPORT" IRC support for InspIRCd can be found at ircs://irc.teranova.net/inspircd. Bug reports and feature requests can be filed at https://github.com/inspircd/inspircd/issues. ��������������������������������������������������������������������������������������������������������������inspircd-4.7.0/make/template/inspircd.1�������������������������������������������������������������0000664�0000000�0000000�00000003517�14771603147�0020002�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������.\" .\" InspIRCd -- Internet Relay Chat Daemon .\" .\" Copyright (C) 2014, 2018, 2024 Sadie Powell <sadie@witchery.services> .\" .\" This file is part of InspIRCd. InspIRCd is free software: you can .\" redistribute it and/or modify it under the terms of the GNU General Public .\" License as published by the Free Software Foundation, version 2. .\" .\" This program is distributed in the hope that it will be useful, but WITHOUT .\" ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS .\" FOR A PARTICULAR PURPOSE. See the GNU General Public License for more .\" details. .\" .\" You should have received a copy of the GNU General Public License .\" along with this program. If not, see <http://www.gnu.org/licenses/>. .\" .TH "InspIRCd" "1" "2024-06-28" "InspIRCd @VERSION_FULL@" "InspIRCd Manual" .SH "NAME" \t\fBInspIRCd\fR - \fIthe\fR stable, high-performance and modular Internet Relay Chat Daemon .BR .SH "SYNOPSIS" \t\fBinspircd\fR [--config <file>] [--debug] [--nofork] [--nolog] [--nopid] [--protocoldebug] [--runasroot] [--version] .SH "OPTIONS" .TP .B "--config <file>" .br Sets the path to the main configuration file. Defaults to \fI@CONFIG_DIR@/inspircd.conf\fR. .TP .B "--debug" .br Log at the debug level to the standard output stream. .TP .B "--nofork" .br Don't fork into the background after starting up. .TP .B "--nolog" .br Don't write to log files. .TP .B "--nopid" .br Don't write to the PID file. .TP .B "--protocoldebug" .br Log at the raw I/O level to the standard output stream. .TP .B "--runasroot" .br Allow the server to start as root (not recommended). .TP .B "--version" .br Displays the InspIRCd version and exits. .SH "SUPPORT" IRC support for InspIRCd can be found at ircs://irc.teranova.net/inspircd. Bug reports and feature requests can be filed at https://github.com/inspircd/inspircd/issues. ���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/make/template/inspircd.service�������������������������������������������������������0000664�0000000�0000000�00000002277�14771603147�0021304�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������%platform linux # # InspIRCd -- Internet Relay Chat Daemon # # Copyright (C) 2019 Robby <robby@chatbelgie.be> # Copyright (C) 2015 Attila Molnar <attilamolnar@hush.com> # Copyright (C) 2014, 2019-2020 Sadie Powell <sadie@witchery.services> # # This file is part of InspIRCd. InspIRCd is free software: you can # redistribute it and/or modify it under the terms of the GNU General Public # License as published by the Free Software Foundation, version 2. # # This program is distributed in the hope that it will be useful, but WITHOUT # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS # FOR A PARTICULAR PURPOSE. See the GNU General Public License for more # details. # # You should have received a copy of the GNU General Public License # along with this program. If not, see <http://www.gnu.org/licenses/>. # [Unit] After=network.target Description=InspIRCd - Internet Relay Chat Daemon Documentation=https://docs.inspircd.org After=network-online.target Wants=network-online.target [Service] ExecReload=/bin/kill -HUP $MAINPID ExecStart=@BINARY_DIR@/inspircd --nofork --nopid Restart=on-failure Type=simple User=@USER@ Group=@GROUP@ [Install] WantedBy=multi-user.target ���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/make/template/logrotate��������������������������������������������������������������0000664�0000000�0000000�00000002405�14771603147�0020023�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������# # InspIRCd -- Internet Relay Chat Daemon # # Copyright (C) 2022 Wade Cline <wadecline@hotmail.com> # Copyright (C) 2020 Sadie Powell <sadie@witchery.services> # # This file is part of InspIRCd. InspIRCd is free software: you can # redistribute it and/or modify it under the terms of the GNU General Public # License as published by the Free Software Foundation, version 2. # # This program is distributed in the hope that it will be useful, but WITHOUT # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS # FOR A PARTICULAR PURPOSE. See the GNU General Public License for more # details. # # You should have received a copy of the GNU General Public License # along with this program. If not, see <http://www.gnu.org/licenses/>. # # To use this file move it to /etc/logrotate.d/inspircd @LOG_DIR@/*.log { compress create 0644 @USER@ @GROUP@ dateext delaycompress missingok notifempty rotate 8 weekly postrotate if [ -r "@RUNTIME_DIR@/inspircd.pid" ] then kill -HUP $(cat "@RUNTIME_DIR@/inspircd.pid") elif [ -d /lib/systemd ] then if systemctl --quiet is-active inspircd then systemctl kill --signal HUP inspircd fi elif [ -x "@SCRIPT_DIR@/inspircd" ] then "@SCRIPT_DIR@/inspircd" rehash fi endscript } �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/make/template/main.mk����������������������������������������������������������������0000664�0000000�0000000�00000032670�14771603147�0017364�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������%target GNUmakefile # # InspIRCd -- Internet Relay Chat Daemon # # Copyright (C) 2024 Marcus Rueckert <darix@nordisch.org> # Copyright (C) 2018 Puck Meerburg <puck@puckipedia.com> # Copyright (C) 2015 Attila Molnar <attilamolnar@hush.com> # Copyright (C) 2012-2024 Sadie Powell <sadie@witchery.services> # Copyright (C) 2012 Robby <robby@chatbelgie.be> # Copyright (C) 2012 ChrisTX <xpipe@hotmail.de> # Copyright (C) 2010 Dennis Friis <peavey@inspircd.org> # Copyright (C) 2009-2010 Daniel De Graaf <danieldg@inspircd.org> # Copyright (C) 2007 Robin Burchell <robin+git@viroteck.net> # Copyright (C) 2005-2007 Craig Edwards <brain@inspircd.org> # Copyright (C) 2005 Craig McLure <craig@frostycoolslug.com> # # This file is part of InspIRCd. InspIRCd is free software: you can # redistribute it and/or modify it under the terms of the GNU General Public # License as published by the Free Software Foundation, version 2. # # This program is distributed in the hope that it will be useful, but WITHOUT # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS # FOR A PARTICULAR PURPOSE. See the GNU General Public License for more # details. # # You should have received a copy of the GNU General Public License # along with this program. If not, see <http://www.gnu.org/licenses/>. # # # InspIRCd Main Makefile # # This file is automagically generated by configure, from # make/template/main.mk. Any changes made to the generated # files will go away whenever it is regenerated! # # Please do not edit unless you know what you're doing. # CXX = @CXX@ -std=c++17 COMPILER = @COMPILER_NAME@ SYSTEM = @SYSTEM_NAME@ SOURCEPATH = @SOURCE_DIR@ BUILDPATH ?= $(SOURCEPATH)/build/@COMPILER_NAME@-@COMPILER_VERSION@ SOCKETENGINE = @SOCKETENGINE@ CORECXXFLAGS = -fPIC -fvisibility=hidden -fvisibility-inlines-hidden -pipe -I"$(SOURCEPATH)/include" -I"$(SOURCEPATH)/vendor" -Wall -Wextra -Wfatal-errors -Woverloaded-virtual -Wpedantic -Wno-format-nonliteral -Wno-unused-parameter -DFMT_SHARED LDLIBS = @COMPILER_EXTRA_LDLIBS@ CORELDFLAGS = -fPIE -pie -L. PICLDFLAGS = -fPIC -shared DESTDIR := $(if $(DESTDIR),$(DESTDIR),"@DESTDIR|@") BINPATH = "$(DESTDIR)@BINARY_DIR@" CONPATH = "$(DESTDIR)@CONFIG_DIR@" DATPATH = "$(DESTDIR)@DATA_DIR@" EXAPATH = "$(DESTDIR)@EXAMPLE_DIR@" LOGPATH = "$(DESTDIR)@LOG_DIR@" MANPATH = "$(DESTDIR)@MANUAL_DIR@" MODPATH = "$(DESTDIR)@MODULE_DIR@" RUNPATH = "$(DESTDIR)@RUNTIME_DIR@" SCRPATH = "$(DESTDIR)@SCRIPT_DIR@" INSTALL ?= install INSTMODE_DIR ?= 0755 INSTMODE_BIN ?= 0755 INSTMODE_TXT ?= 0644 INSTMODE_PRV ?= 0640 # Use the native shared library file extension for modules. ifeq ($(SYSTEM), darwin) DLLEXT = "dylib" else DLLEXT = "so" endif # Only set the ownership of installed files when --disable-ownership # was not passed to configure. DISABLE_OWNERSHIP=@DISABLE_OWNERSHIP@ ifeq ($(DISABLE_OWNERSHIP), 1) INSTFLAGS = else INSTFLAGS = -g @GID@ -o @UID@ endif # Force the use of libc++ on macOS as on some systems it is not the # default and this breaks modern C++ support. ifeq ($(COMPILER), AppleClang) CXX += -stdlib=libc++ endif # Enable Clang-specific compiler warnings. ifeq ($(COMPILER), $(filter $(COMPILER), AppleClang IntelClang Clang)) CORECXXFLAGS += -Wshadow-all -Wshorten-64-to-32 endif # Enable GCC-specific compiler warnings. ifeq ($(COMPILER), GCC) CORECXXFLAGS += -Wshadow endif # The libc++ and libstdc++ <thread> implementation still requires # manually linking against pthreads on all systems other than macOS # and Haiku where pthreads are linked by default as part of libSystem # and libroot respectively. ifneq ($(SYSTEM), $(filter $(SYSTEM), darwin haiku)) LDLIBS += -pthread endif # On these systems we need libdl for loading modules. ifeq ($(SYSTEM), $(filter $(SYSTEM), gnu linux)) LDLIBS += -ldl endif # On these systems we need librt for clock_gettime. ifeq ($(SYSTEM), $(filter $(SYSTEM), gnu linux solaris)) LDLIBS += -lrt endif # On Haiku we need _BSD_SOURCE for common BSD extensions and # libnetwork for creating sockets. ifeq ($(SYSTEM), haiku) CORECXXFLAGS += -D_BSD_SOURCE LDLIBS += -lnetwork endif # On Solaris and derivatives we need libsocket for creating sockets. ifeq ($(SYSTEM), solaris) LDLIBS += -lsocket endif # On macOS this option is named different and on Haiku the linker # only supports dynamic libraries so this is implied. ifneq ($(SYSTEM), $(filter $(SYSTEM), darwin haiku)) CORELDFLAGS += -rdynamic PICLDFLAGS += -rdynamic endif # On macOS we need to give the linker these flags so the libraries it # generates act like they do on other UNIX-like systems. ifeq ($(SYSTEM), darwin) CORELDFLAGS += -bind_at_load -dynamic PICLDFLAGS += -twolevel_namespace -undefined dynamic_lookup endif ifndef INSPIRCD_DEBUG INSPIRCD_DEBUG=0 endif DBGOK=0 ifeq ($(INSPIRCD_DEBUG), 0) CORECXXFLAGS += -fno-rtti -O2 ifeq ($(COMPILER), GCC) CORECXXFLAGS += -g1 endif HEADER = std-header DBGOK=1 endif ifeq ($(INSPIRCD_DEBUG), 1) CORECXXFLAGS += -O0 -g3 -Werror -DINSPIRCD_ENABLE_RTTI HEADER = debug-header DBGOK=1 endif ifeq ($(INSPIRCD_DEBUG), 2) CORECXXFLAGS += -fno-rtti -O2 -g3 HEADER = debug-header DBGOK=1 endif ifeq ($(INSPIRCD_DEBUG), 3) CORECXXFLAGS += -fno-rtti -O0 -g0 -Werror HEADER = std-header DBGOK=1 endif MAKEFLAGS += --no-print-directory ifndef INSPIRCD_VERBOSE MAKEFLAGS += --silent endif # Append any flags set in the environment after the base flags so # that they can be overridden if necessary. CORECXXFLAGS += $(CPPFLAGS) $(CXXFLAGS) CORELDFLAGS += $(LDFLAGS) PICLDFLAGS += $(LDFLAGS) export BUILDPATH export CORECXXFLAGS export CORELDFLAGS export CXX export INSPIRCD_VERBOSE export LDLIBS export PICLDFLAGS export SOCKETENGINE export SOURCEPATH # Default target TARGET = all ifdef INSPIRCD_TARGET HEADER = mod-header TARGET = $(INSPIRCD_TARGET) endif ifeq ($(DBGOK), 0) HEADER = unknown-debug-level endif all: finishmessage target: $(HEADER) $(MAKEENV) perl make/calcdep.pl cd "$(BUILDPATH)"; $(MAKEENV) $(MAKE) -f real.mk $(TARGET) debug: @${MAKE} INSPIRCD_DEBUG=1 all debug-header: @echo "*************************************" @echo "* BUILDING WITH DEBUG SYMBOLS *" @echo "* *" @echo "* This will take a *long* time. *" @echo "* Please be aware that this build *" @echo "* will consume a very large amount *" @echo "* of disk space (~350MB), and may *" @echo "* run slower. Use the debug build *" @echo "* for module development or if you *" @echo "* are experiencing problems. *" @echo "* *" @echo "*************************************" mod-header: @echo 'Building specific targets:' std-header: @echo "*************************************" @echo "* BUILDING INSPIRCD *" @echo "* *" @echo "* This will take a *long* time. *" @echo "* Why not read our docs at *" @echo "* https://docs.inspircd.org *" @echo "* while you wait for Make to run? *" @echo "*************************************" finishmessage: target @echo "" @echo "*************************************" @echo "* BUILD COMPLETE! *" @echo "* *" @echo "* To install InspIRCd, type: *" @echo "* 'make install' *" @echo "*************************************" install: target @-$(INSTALL) -d $(INSTFLAGS) -m $(INSTMODE_DIR) $(BINPATH) @-$(INSTALL) -d $(INSTFLAGS) -m $(INSTMODE_DIR) $(CONPATH) @-$(INSTALL) -d $(INSTFLAGS) -m $(INSTMODE_DIR) $(DATPATH) @-$(INSTALL) -d $(INSTFLAGS) -m $(INSTMODE_DIR) $(EXAPATH)/codepages @-$(INSTALL) -d $(INSTFLAGS) -m $(INSTMODE_DIR) $(EXAPATH)/providers @-$(INSTALL) -d $(INSTFLAGS) -m $(INSTMODE_DIR) $(EXAPATH)/services @-$(INSTALL) -d $(INSTFLAGS) -m $(INSTMODE_DIR) $(EXAPATH)/sql/log_sql @-$(INSTALL) -d $(INSTFLAGS) -m $(INSTMODE_DIR) $(EXAPATH)/sql/sqloper @-$(INSTALL) -d $(INSTFLAGS) -m $(INSTMODE_DIR) $(LOGPATH) @-$(INSTALL) -d $(INSTFLAGS) -m $(INSTMODE_DIR) $(MANPATH) @-$(INSTALL) -d $(INSTFLAGS) -m $(INSTMODE_DIR) $(MODPATH) @-$(INSTALL) -d $(INSTFLAGS) -m $(INSTMODE_DIR) $(RUNPATH) @-$(INSTALL) -d $(INSTFLAGS) -m $(INSTMODE_DIR) $(SCRPATH) -$(INSTALL) $(INSTFLAGS) -m $(INSTMODE_BIN) "$(BUILDPATH)/bin/inspircd" $(BINPATH) -$(INSTALL) $(INSTFLAGS) -m $(INSTMODE_BIN) "$(BUILDPATH)/modules/"*.$(DLLEXT) $(MODPATH) -$(INSTALL) $(INSTFLAGS) -m $(INSTMODE_BIN) @CONFIGURE_DIRECTORY@/deploy-ssl.sh $(SCRPATH) 2>/dev/null -$(INSTALL) $(INSTFLAGS) -m $(INSTMODE_BIN) @CONFIGURE_DIRECTORY@/inspircd $(SCRPATH) 2>/dev/null -$(INSTALL) $(INSTFLAGS) -m $(INSTMODE_TXT) @CONFIGURE_DIRECTORY@/apparmor $(SCRPATH) 2>/dev/null -$(INSTALL) $(INSTFLAGS) -m $(INSTMODE_TXT) @CONFIGURE_DIRECTORY@/logrotate $(SCRPATH) 2>/dev/null ifeq ($(SYSTEM), darwin) -$(INSTALL) $(INSTFLAGS) -m $(INSTMODE_BIN) @CONFIGURE_DIRECTORY@/org.inspircd.plist $(SCRPATH) 2>/dev/null endif ifeq ($(SYSTEM), linux) -$(INSTALL) $(INSTFLAGS) -m $(INSTMODE_TXT) @CONFIGURE_DIRECTORY@/inspircd.service $(SCRPATH) 2>/dev/null endif -$(INSTALL) $(INSTFLAGS) -m $(INSTMODE_TXT) @CONFIGURE_DIRECTORY@/inspircd.1 $(MANPATH) 2>/dev/null -$(INSTALL) $(INSTFLAGS) -m $(INSTMODE_TXT) @CONFIGURE_DIRECTORY@/inspircd-testssl.1 $(MANPATH) 2>/dev/null -$(INSTALL) $(INSTFLAGS) -m $(INSTMODE_BIN) tools/testssl $(BINPATH)/inspircd-testssl 2>/dev/null -$(INSTALL) $(INSTFLAGS) -m $(INSTMODE_TXT) docs/conf/*.example.* $(EXAPATH) -$(INSTALL) $(INSTFLAGS) -m $(INSTMODE_TXT) docs/conf/codepages/*.example.* $(EXAPATH)/codepages -$(INSTALL) $(INSTFLAGS) -m $(INSTMODE_TXT) docs/conf/providers/*.example.* $(EXAPATH)/providers -$(INSTALL) $(INSTFLAGS) -m $(INSTMODE_TXT) docs/conf/services/*.example.* $(EXAPATH)/services -$(INSTALL) $(INSTFLAGS) -m $(INSTMODE_TXT) docs/sql/log_sql/*.sql $(EXAPATH)/sql/log_sql -$(INSTALL) $(INSTFLAGS) -m $(INSTMODE_TXT) docs/sql/sqloper/*.sql $(EXAPATH)/sql/sqloper -$(INSTALL) $(INSTFLAGS) -m $(INSTMODE_TXT) @CONFIGURE_DIRECTORY@/help.txt $(CONPATH) @echo "" @echo "*************************************" @echo "* INSTALL COMPLETE! *" @echo "*************************************" @echo 'Paths:' @echo ' Configuration:' $(CONPATH) @echo ' Binaries:' $(BINPATH) @echo ' Modules:' $(MODPATH) @echo ' Data:' $(DATPATH) @echo 'To start the ircd, run:' $(SCRPATH)/inspircd start @echo 'Remember to create your config file:' $(CONPATH)/inspircd.conf @echo 'Examples are available at:' $(EXAPATH) GNUmakefile: make/template/main.mk src/version.sh configure @CONFIGURE_CACHE_FILE@ ./configure --update clean: @echo Cleaning... -rm -f "$(BUILDPATH)/bin/inspircd" "$(BUILDPATH)/include" "$(BUILDPATH)/real.mk" -rm -rf "$(BUILDPATH)/obj" "$(BUILDPATH)/modules" @-rmdir "$(BUILDPATH)/bin" 2>/dev/null @-rmdir "$(BUILDPATH)" 2>/dev/null @echo Completed. deinstall: -rm -f $(BINPATH)/inspircd -rm -f $(BINPATH)/inspircd-testssl -rm -f $(CONPATH)/help.txt -rm -f $(EXAPATH)/*.example.* -rm -f $(EXAPATH)/codepages/*.example.* -rm -f $(EXAPATH)/providers/*.example.* -rm -f $(EXAPATH)/services/*.example.* -rm -f $(EXAPATH)/sql/*.sql -rm -f $(MANPATH)/inspircd-testssl.1 -rm -f $(MANPATH)/inspircd.1 -rm -f $(MODPATH)/core_*.$(DLLEXT) -rm -f $(MODPATH)/m_*.$(DLLEXT) -rm -f $(SCRPATH)/apparmor -rm -f $(SCRPATH)/inspircd -rm -f $(SCRPATH)/inspircd.service -rm -f $(SCRPATH)/logrotate -rm -f $(SCRPATH)/org.inspircd.plist -[ -d $(BINPATH) ] && find $(BINPATH) -type d -empty -delete -[ -d $(CONPATH) ] && find $(CONPATH) -type d -empty -delete -[ -d $(DATPATH) ] && find $(DATPATH) -type d -empty -delete -[ -d $(EXAPATH) ] && find $(EXAPATH) -type d -empty -delete -[ -d $(LOGPATH) ] && find $(LOGPATH) -type d -empty -delete -[ -d $(MANPATH) ] && find $(MANPATH) -type d -empty -delete -[ -d $(MODPATH) ] && find $(MODPATH) -type d -empty -delete -[ -d $(RUNPATH) ] && find $(RUNPATH) -type d -empty -delete -[ -d $(SCRPATH) ] && find $(SCRPATH) -type d -empty -delete configureclean: -rm -f GNUmakefile -rm -f include/config.h -rm -rf @CONFIGURE_DIRECTORY@ distclean: clean configureclean -rm -rf "$(SOURCEPATH)/run" -find "$(SOURCEPATH)/src/modules" -type l -delete help: @echo 'InspIRCd Makefile' @echo '' @echo 'Use: ${MAKE} [flags] [targets]' @echo '' @echo 'Flags:' @echo ' INSPIRCD_VERBOSE=1 Show the full command being executed instead of "BUILD: dns.cpp"' @echo ' INSPIRCD_DEBUG=1 Enable debug build, for module development or crash tracing' @echo ' INSPIRCD_DEBUG=2 Enable debug build with optimizations, for detailed backtraces' @echo ' INSPIRCD_DEBUG=3 Enable fast build with no optimisations or symbols (only for CI)' @echo ' DESTDIR= Specify a destination root directory (for tarball creation)' @echo ' -j <N> Run a parallel build using N jobs' @echo '' @echo 'Targets:' @echo ' all Complete build of InspIRCd, without installing (default)' @echo ' install Build and install InspIRCd to the directory chosen in ./configure' @echo ' debug Compile a debug build. Equivalent to "make D=1 all"' @echo '' @echo ' INSPIRCD_TARGET=target Builds a user-specified target, such as "inspircd" or "core_dns"' @echo ' Multiple targets may be separated by a space' @echo '' @echo ' clean Cleans object files produced by the compile' @echo ' distclean Cleans all generated files (build, configure, run, etc)' @echo ' deinstall Removes the files created by "make install"' @echo .NOTPARALLEL: .PHONY: all target debug debug-header mod-header mod-footer std-header finishmessage install clean deinstall configureclean help ������������������������������������������������������������������������inspircd-4.7.0/make/template/org.inspircd.plist�����������������������������������������������������0000664�0000000�0000000�00000001530�14771603147�0021554�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������%platform darwin <?xml version="1.0" encoding="UTF-8"?> <!DOCTYPE plist PUBLIC "-//Apple Computer//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd"> <plist version="1.0"> <dict> <key>Iterations</key> <integer>3</integer> <key>KeepAlive</key> <true/> <key>Label</key> <string>org.inspircd</string> <key>LowPriorityIO</key> <true/> <key>Nice</key> <integer>1</integer> <key>Program</key> <string>@BINARY_DIR@/inspircd</string> <key>ProgramArguments</key> <array> <string>inspircd</string> <string>--nofork</string> </array> <key>ServiceIPC</key> <false/> <key>StandardOutPath</key> <string>@LOG_DIR@/launchd-stdout.log</string> <key>StandardErrorPath</key> <string>@LOG_DIR@/launchd-stderr.log</string> <key>UserName</key> <string>@USER@</string> <key>GroupName</key> <string>@GROUP@</string> </dict> </plist> ������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/make/test/���������������������������������������������������������������������������0000775�0000000�0000000�00000000000�14771603147�0015243�5����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/make/test/arc4random_buf.cpp���������������������������������������������������������0000664�0000000�0000000�00000001505�14771603147�0020636�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2018 Sadie Powell <sadie@witchery.services> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include <stdlib.h> int main() { char buffer[100]; arc4random_buf(buffer, sizeof(buffer)); return 0; } �������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/make/test/clock_gettime.cpp����������������������������������������������������������0000664�0000000�0000000�00000001674�14771603147�0020570�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2013 Sadie Powell <sadie@witchery.services> * Copyright (C) 2012 Robby <robby@chatbelgie.be> * Copyright (C) 2009 Daniel De Graaf <danieldg@inspircd.org> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include <time.h> int main() { timespec time_spec; clock_gettime(CLOCK_REALTIME, &time_spec); return 0; } ��������������������������������������������������������������������inspircd-4.7.0/make/test/compiler.cpp���������������������������������������������������������������0000664�0000000�0000000�00000003425�14771603147�0017565�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2014, 2024 Sadie Powell <sadie@witchery.services> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include <iostream> #if defined __INTEL_CLANG_COMPILER // Also defines __clang__ # define INSPIRCD_COMPILER_NAME "IntelClang" # define INSPIRCD_COMPILER_VERSION (__INTEL_CLANG_COMPILER / 10000) << '.' << ((__INTEL_CLANG_COMPILER % 10000) / 100) #elif defined __clang__ // Also defines __GNUC__ # if defined __apple_build_version__ # define INSPIRCD_COMPILER_NAME "AppleClang" # else # define INSPIRCD_COMPILER_NAME "Clang" # if __clang_major__ < 9 # define INSPIRCD_EXTRA_LDLIBS "-lc++fs" # endif # endif # define INSPIRCD_COMPILER_VERSION __clang_major__ << '.' << __clang_minor__ #elif defined __GNUC__ # define INSPIRCD_COMPILER_NAME "GCC" # define INSPIRCD_COMPILER_VERSION __GNUC__ << '.' << __GNUC_MINOR__ # if __GNUC__ < 9 # define INSPIRCD_EXTRA_LDLIBS "-lstdc++fs" # endif #endif #ifndef INSPIRCD_EXTRA_LDLIBS # define INSPIRCD_EXTRA_LDLIBS "" #endif int main() { std::cout << "NAME " << INSPIRCD_COMPILER_NAME << std::endl << "VERSION " << INSPIRCD_COMPILER_VERSION << std::endl << "EXTRA_LDLIBS " << INSPIRCD_EXTRA_LDLIBS << std::endl; return 0; } �������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/make/test/getentropy.cpp�������������������������������������������������������������0000664�0000000�0000000�00000001502�14771603147�0020145�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2024 Sadie Powell <sadie@witchery.services> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include <unistd.h> int main() { char buffer[100]; return getentropy(buffer, sizeof(buffer)) != 0; } ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/make/test/kqueue.cpp�����������������������������������������������������������������0000664�0000000�0000000�00000001662�14771603147�0017253�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2013 Sadie Powell <sadie@witchery.services> * Copyright (C) 2012 Robby <robby@chatbelgie.be> * Copyright (C) 2009 Daniel De Graaf <danieldg@inspircd.org> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include <sys/types.h> #include <sys/event.h> int main() { int fd = kqueue(); return (fd < 0); } ������������������������������������������������������������������������������inspircd-4.7.0/make/unit-cc.pl����������������������������������������������������������������������0000775�0000000�0000000�00000005650�14771603147�0016174�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������#!/usr/bin/env perl # # InspIRCd -- Internet Relay Chat Daemon # # Copyright (C) 2019 iwalkalone <iwalkalone69@gmail.com> # Copyright (C) 2014 Attila Molnar <attilamolnar@hush.com> # Copyright (C) 2013, 2015-2016, 2018, 2021 Sadie Powell <sadie@witchery.services> # Copyright (C) 2012 Robby <robby@chatbelgie.be> # Copyright (C) 2009-2010 Daniel De Graaf <danieldg@inspircd.org> # # This file is part of InspIRCd. InspIRCd is free software: you can # redistribute it and/or modify it under the terms of the GNU General Public # License as published by the Free Software Foundation, version 2. # # This program is distributed in the hope that it will be useful, but WITHOUT # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS # FOR A PARTICULAR PURPOSE. See the GNU General Public License for more # details. # # You should have received a copy of the GNU General Public License # along with this program. If not, see <http://www.gnu.org/licenses/>. # use v5.26.0; use strict; use warnings FATAL => qw(all); use File::Basename qw(dirname); use File::Spec::Functions qw(abs2rel); use FindBin qw($RealDir); use lib dirname $RealDir; use make::console; use make::directive; chdir $ENV{BUILDPATH}; my $type = shift; my $out = shift; if ($type eq 'core-ld') { do_core_link(@ARGV); } elsif ($type eq 'link-dir') { do_link_dir(@ARGV); } elsif ($type eq 'gen-o') { do_compile(1, 0, @ARGV); } elsif ($type eq 'gen-so') { do_compile(1, 1, @ARGV); } elsif ($type eq 'link-so') { do_compile(0, 1, @ARGV); } else { print STDERR "Unknown unit-cc subcommand $type!\n"; } exit 1; sub message($$$) { my ($type, $file, $command) = @_; if ($ENV{INSPIRCD_VERBOSE}) { say $command; } else { say console_format "\t<|GREEN $type:|>\t\t$file"; } } sub rpath($) { my $message = shift; $message =~ s/-L(\S+)/-Wl,-rpath,$1 -L$1/g unless defined $ENV{INSPIRCD_DISABLE_RPATH}; return $message; } sub do_core_link { my $execstr = "$ENV{CXX} -o $out $ENV{CORELDFLAGS} @_ $ENV{LDLIBS}"; message 'LINK', $out, $execstr; exec $execstr; } sub do_link_dir { my ($dir, $link_flags) = (shift, ''); for my $file (<$dir/*.cpp>) { $link_flags .= rpath(get_directive($file, 'LinkerFlags', '')) . ' '; } my $execstr = "$ENV{CXX} -o $out $ENV{PICLDFLAGS} @_ $link_flags"; message 'LINK', $out, $execstr; exec $execstr; } sub do_compile { my ($do_compile, $do_link, $file) = @_; my $flags = ''; my $libs = ''; if ($do_compile) { $flags = $ENV{CORECXXFLAGS} . ' ' . get_directive($file, 'CompilerFlags', ''); if ($file =~ m#(?:^|/)((?:m|core)_[^/. ]+)(?:\.cpp|/.*\.cpp)$#) { $flags .= ' -DMODNAME=\\"'.$1.'\\"'; } } if ($do_link) { $flags = join ' ', $flags, $ENV{PICLDFLAGS}; $libs = rpath(get_directive($file, 'LinkerFlags', '')); } else { $flags .= ' -c'; } my $execstr = "$ENV{CXX} -o $out $flags $file $libs"; message 'BUILD', abs2rel($file, "$ENV{SOURCEPATH}/src"), $execstr; exec $execstr; } ����������������������������������������������������������������������������������������inspircd-4.7.0/modulemanager������������������������������������������������������������������������0000775�0000000�0000000�00000022727�14771603147�0016127�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������#!/usr/bin/env perl # # InspIRCd -- Internet Relay Chat Daemon # # Copyright (C) 2012-2014, 2017-2021, 2024-2025 Sadie Powell <sadie@witchery.services> # Copyright (C) 2012 Robby <robby@chatbelgie.be> # Copyright (C) 2010 Daniel De Graaf <danieldg@inspircd.org> # Copyright (C) 2008-2009 Robin Burchell <robin+git@viroteck.net> # # This file is part of InspIRCd. InspIRCd is free software: you can # redistribute it and/or modify it under the terms of the GNU General Public # License as published by the Free Software Foundation, version 2. # # This program is distributed in the hope that it will be useful, but WITHOUT # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS # FOR A PARTICULAR PURPOSE. See the GNU General Public License for more # details. # # You should have received a copy of the GNU General Public License # along with this program. If not, see <http://www.gnu.org/licenses/>. # BEGIN { unless (eval "use LWP::Simple; 1") { die "Your system is missing the LWP::Simple Perl module!"; } unless (eval "use Crypt::SSLeay; 1" || eval "use IO::Socket::SSL; 1") { die "Your system is missing the Crypt::SSLeay or IO::Socket::SSL Perl modules!"; } } use v5.26.0; use strict; use warnings FATAL => qw(all); use File::Basename qw(basename); use FindBin qw($RealDir); use lib $RealDir; use make::common; use make::console; use make::directive; my %installed; # $installed{name} = $version my %modules; # $modules{$name}{$version} = { # url => URL of this version # depends => [ 'm_foo 1.2.0-1.3.0', ... ] # conflicts => [ ] # from => URL of source document # mask => Reason for not installing (INSECURE/DEPRECATED) # description => some string # } my %url_seen; sub parse_url; # retrieve and parse entries from sources.list sub parse_url { chomp(my $src = shift); return if $url_seen{$src}; $url_seen{$src}++; my $ua = LWP::UserAgent->new; my $response = $ua->get($src); unless ($response->is_success) { my $err = $response->message; die "Could not retrieve $src: $err"; } my $mod; for (split /\n+/, $response->content) { s/^\s+//; # ignore whitespace at start next if /^#/; if (/^module (\S+) (\S+) (\S+)/) { my($name, $ver, $url) = ($1,$2,$3); if ($modules{$name}{$ver}) { my $origsrc = $modules{$name}{$ver}{from}; warn "Overriding module $name $ver defined from $origsrc with one from $src"; } $mod = { from => $src, url => $url, depends => [], conflicts => [], }; $modules{$name}{$ver} = $mod; } elsif (/^depends (.*)/) { push @{$mod->{depends}}, $1; } elsif (/^conflicts (.*)/) { push @{$mod->{conflicts}}, $1; } elsif (/^description (.*)/) { $mod->{description} = $1; } elsif (/^mask (.*)/) { $mod->{mask} = $1; } elsif (/^source (\S+)/) { parse_url $1; } } } # hash of installed module versions from our mini-database, key (m_foobar) to version (00abacca..). my %mod_versions = read_config_file "$RealDir/.modulemanager"; # useless helper stub sub getmodversion { my ($file) = @_; return $mod_versions{$file}; } # read in external URL sources open SRC, "$RealDir/sources.list" or die "Could not open sources.list: $!"; while (<SRC>) { next if /^\s*#/; parse_url($_); } close SRC; # determine core version my %version = get_version(); $installed{core} = "$version{MAJOR}.$version{MINOR}.$version{PATCH}"; for my $mod (keys %modules) { MODVER: for my $mver (keys %{$modules{$mod}}) { for my $dep (@{$modules{$mod}{$mver}{depends}}) { next unless $dep =~ /^core (.*)/; if (!ver_in_range($installed{core}, $1)) { delete $modules{$mod}{$mver}; next MODVER; } } } delete $modules{$mod} unless %{$modules{$mod}}; } $modules{core}{$installed{core}} = { url => 'NONE', depends => [], conflicts => [], from => 'local file', }; # set up core module list for my $modname (<$RealDir/src/modules/m_*.cpp>) { my $mod = basename($modname, '.cpp'); my $ver = getmodversion($mod) || '0.0'; $ver =~ s/\$Rev: (.*) \$/$1/; # for storing revision in SVN $installed{$mod} = $ver; next if $modules{$mod}{$ver}; $modules{$mod}{$ver} = { url => 'NONE', depends => [], conflicts => [], from => 'local file', }; } my %todo = %installed; sub ver_cmp { ($a,$b) = @_ if @_; if ($a !~ /^[0-9.]+$/ or $b !~ /^[0-9.]+$/) { # not a valid version number, don't try to sort return $a ne $b; } # else it's probably a numerical type version.. i.e. 1.0 my @a = split /\./, $a; my @b = split /\./, $b; push @a, 0 while $#a < $#b; push @b, ($_[2] || 0) while $#b < $#a; for my $i (0..$#a) { my $d = $a[$i] <=> $b[$i]; return $d if $d; } return 0; } sub ver_in_range { my($ver, $range) = @_; return 1 unless defined $range; my($l,$h) = ($range, $range); if ($range =~ /(.*)-(.*)/) { ($l,$h) = ($1,$2); } return 0 if $l && ver_cmp($ver, $l) < 0; return 0 if $h && ver_cmp($ver, $h, 9999) > 0; return 1; } sub find_mod_in_range { my($mod, $vers, $force) = @_; my @versions = keys %{$modules{$mod}}; @versions = sort { -ver_cmp() } @versions; for my $ver (@versions) { next if $modules{$mod}{$ver}{mask} && !$force; return $ver if ver_in_range($ver, $vers); } return undef; } sub resolve_deps { my($trial) = @_; my $tries = 100; my $changes = 'INIT'; my $fail = undef; while ($changes && $tries) { $tries--; $changes = ''; $fail = undef; my @modsnow = sort keys %todo; for my $mod (@modsnow) { my $ver = $todo{$mod}; my $info = $modules{$mod}{$ver} or die "no dependency information on $mod $ver"; for my $dep (@{$info->{depends}}) { $dep =~ /^(\S+)(?: (\S+))?/ or die "Bad dependency $dep from $info->{from}"; my($depmod, $depvers) = ($1,$2); next if $todo{$depmod} && ver_in_range($todo{$depmod}, $depvers); # need to install a dependency my $depver = find_mod_in_range($depmod, $depvers); if (defined $depver) { $todo{$depmod} = $depver; $changes .= " $mod-$ver->$depmod-$depver"; } else { $fail ||= "Could not find module $depmod $depvers required by $mod $ver"; } } for my $dep (@{$info->{conflicts}}) { $dep =~ /^(\S+)(?: (\S+))?/ or die "Bad dependency $dep from $info->{from}"; my($depmod, $depvers) = ($1,$2); next unless $todo{$depmod} && ver_in_range($todo{$depmod}, $depvers); # if there are changes this round, maybe the conflict won't come up after they are resolved. $fail ||= "Cannot install: module $mod ($ver) conflicts with $depmod version $todo{$depmod}"; } } } if ($trial) { return !($changes || $fail); } if ($changes) { print "Infinite dependency loop:$changes\n"; exit 1; } if ($fail) { print "$fail\n"; exit 1; } } command 'install', 'Install a third-party module', sub { for my $mod (@_) { my $hmod = module_shrink($mod); $mod = "m_$hmod"; my $vers = $mod =~ s/=([-0-9.]+)// ? $1 : undef; $mod = lc $mod; unless ($modules{$mod}) { print "Cannot find module $hmod\n"; exit 1; } my $ver = find_mod_in_range($mod, $vers, $vers ? 1 : 0); unless ($ver) { print "Cannot find suitable version of $hmod\n"; exit 1; } $todo{$mod} = $ver; } }; command 'upgrade', 'Upgrade third-party modules', sub { my @installed = sort keys %installed; for my $mod (@installed) { next unless $mod =~ /^m_/; my %saved = %todo; $todo{$mod} = find_mod_in_range($mod); if (!resolve_deps(1)) { %todo = %saved; } } }; command 'list', 'List available third-party modules', sub { my @all = sort keys %modules; for my $mod (@all) { my $hmod = module_shrink($mod); my @vers = sort { ver_cmp() } keys %{$modules{$mod}}; my $desc = ''; for my $ver (@vers) { # latest defined description wins $desc = $modules{$mod}{$ver}{description} || $desc; } next if @vers == 1 && $modules{$mod}{$vers[0]}{url} eq 'NONE'; my $instver = $installed{$mod} || ''; my $vers = join ' ', map { $_ eq $instver ? "\e[1m$_\e[m" : $_ } @vers; print "$hmod ($vers) - $desc\n"; } exit 0; }; execute_command @ARGV; resolve_deps(0); $| = 1; # immediate print of lines without \n print "Processing changes...\n"; for my $mod (keys %installed) { next if $todo{$mod}; my $hmod = module_shrink($mod); print "Uninstalling $hmod $installed{$mod}\n"; unlink "$RealDir/src/modules/$mod.cpp"; } my $count = scalar keys %todo; print "Checking $count items...\n"; for my $mod (sort keys %todo) { my $hmod = module_shrink($mod); my $ver = $todo{$mod}; my $oldver = $installed{$mod}; if ($modules{$mod}{$ver}{mask}) { print "Module $hmod $ver is masked: $modules{$mod}{$ver}{mask}\n"; } next if $oldver && $oldver eq $ver; my $url = $modules{$mod}{$ver}{url}; if ($oldver) { print "Upgrading $hmod from $oldver to $ver using $url" } else { print "Installing $hmod $ver from $url"; } $mod_versions{$mod} = $ver; my $ua = LWP::UserAgent->new; my $response = $ua->get($url); if ($response->is_success) { open(MF, '>', "$RealDir/src/modules/$mod.cpp") or die "\nFilesystem not writable: $!"; print MF $response->content; close(MF); print " - done\n"; say "You can add this module to your config with:"; say " <module name=\"$hmod\">"; for my $tag (get_directives("$RealDir/src/modules/$mod.cpp", 'ModConfig', 0)) { say " $tag" if $tag; } my @links = get_directives("$RealDir/src/modules/$mod.cpp", 'ModLink', 0); if (@links) { say "You can find out more information about this module at:"; for my $link (@links) { say " * $link" if $link; } } } else { printf "\nHTTP %s: %s\n", $response->code, $response->message; } } # write database of installed versions write_config_file "$RealDir/.modulemanager", %mod_versions; print "Finished!\n"; �����������������������������������������inspircd-4.7.0/sources.list�������������������������������������������������������������������������0000664�0000000�0000000�00000000505�14771603147�0015727�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������###### # sources.list # # This file lists sources of third party modules that are available for installation with inspircd. # To manage these, you want the ./modulemanager binary. # # Feel free to add additional sources! :) # official repository https://raw.githubusercontent.com/inspircd/inspircd-contrib/master/modules.lst �������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/src/���������������������������������������������������������������������������������0000775�0000000�0000000�00000000000�14771603147�0014136�5����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/src/bancache.cpp���������������������������������������������������������������������0000664�0000000�0000000�00000006137�14771603147�0016375�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2021-2022, 2025 Sadie Powell <sadie@witchery.services> * Copyright (C) 2012-2014 Attila Molnar <attilamolnar@hush.com> * Copyright (C) 2012 Robby <robby@chatbelgie.be> * Copyright (C) 2009 Daniel De Graaf <danieldg@inspircd.org> * Copyright (C) 2007-2008 Robin Burchell <robin+git@viroteck.net> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include "inspircd.h" BanCacheHit::BanCacheHit(const std::string& type, const std::string& reason, time_t seconds) : Type(type) , Reason(reason) , Expiry(ServerInstance->Time() + seconds) { } BanCacheHit* BanCacheManager::AddHit(const std::string& ip, const std::string& type, const std::string& reason, time_t seconds) { BanCacheHit*& b = BanHash[ip]; if (b != nullptr) // can't have two cache entries on the same IP, sorry.. return nullptr; b = new BanCacheHit(type, reason, (seconds ? seconds : 86400)); return b; } BanCacheHit* BanCacheManager::GetHit(const std::string& ip) { BanCacheHash::iterator i = this->BanHash.find(ip); if (i == this->BanHash.end()) return nullptr; // free and safe if (RemoveIfExpired(i)) return nullptr; // expired return i->second; // hit. } bool BanCacheManager::RemoveIfExpired(BanCacheHash::iterator& it) { if (ServerInstance->Time() < it->second->Expiry) return false; ServerInstance->Logs.Debug("BANCACHE", "Hit on {} is out of date, removing!", it->first); delete it->second; it = BanHash.erase(it); return true; } void BanCacheManager::RemoveEntries(const std::string& type, bool positive) { if (positive) ServerInstance->Logs.Debug("BANCACHE", "BanCacheManager::RemoveEntries(): Removing positive hits for {}", type); else ServerInstance->Logs.Debug("BANCACHE", "BanCacheManager::RemoveEntries(): Removing all negative hits"); for (BanCacheHash::iterator i = BanHash.begin(); i != BanHash.end(); ) { if (RemoveIfExpired(i)) continue; // updates the iterator if expired BanCacheHit* b = i->second; bool remove = false; if (positive) { // when removing positive hits, remove only if the type matches remove = b->IsPositive() && (b->Type == type); } else { // when removing negative hits, remove all of them remove = !b->IsPositive(); } if (remove) { /* we need to remove this one. */ ServerInstance->Logs.Debug("BANCACHE", "BanCacheManager::RemoveEntries(): Removing a hit on {}", i->first); delete b; i = BanHash.erase(i); } else ++i; } } BanCacheManager::~BanCacheManager() { for (const auto& [_, hit] : BanHash) delete hit; } ���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/src/base.cpp�������������������������������������������������������������������������0000664�0000000�0000000�00000003523�14771603147�0015557�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2020, 2022-2023 Sadie Powell <sadie@witchery.services> * Copyright (C) 2012, 2014-2015 Attila Molnar <attilamolnar@hush.com> * Copyright (C) 2012 Robby <robby@chatbelgie.be> * Copyright (C) 2009 Daniel De Graaf <danieldg@inspircd.org> * Copyright (C) 2006 Oliver Lupton <om@inspircd.org> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include "inspircd.h" #include "base.h" // This trick detects heap allocations of refcountbase objects static void* last_heap = nullptr; void* refcountbase::operator new(size_t size) { last_heap = ::operator new(size); return last_heap; } void refcountbase::operator delete(void* obj) { if (last_heap == obj) last_heap = nullptr; ::operator delete(obj); } refcountbase::refcountbase() { if (this != last_heap) throw CoreException("Reference allocate on the stack!"); } refcountbase::~refcountbase() { if (refcount && ServerInstance) { ServerInstance->Logs.Debug("CULL", "refcountbase::~ @{} with refcount {}", fmt::ptr(this), refcount); } } usecountbase::~usecountbase() { if (usecount && ServerInstance) { ServerInstance->Logs.Debug("CULL", "usecountbase::~ @{} with refcount {}", fmt::ptr(this), usecount); } } void ServiceProvider::RegisterService() { } �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/src/channelmanager.cpp���������������������������������������������������������������0000664�0000000�0000000�00000003025�14771603147�0017605�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2020-2023 Sadie Powell <sadie@witchery.services> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include "inspircd.h" bool ChannelManager::DefaultIsChannel(const std::string_view& channel) { if (channel.empty() || channel.length() > ServerInstance->Config->Limits.MaxChannel) return false; if (!ServerInstance->Channels.IsPrefix(channel[0])) return false; for (const auto chr : insp::iterator_range(channel.begin() + 1, channel.end())) { switch (chr) { case 0x07: // BELL case 0x20: // SPACE case 0x2C: // COMMA return false; } } return true; } Channel* ChannelManager::Find(const std::string& channel) const { ChannelMap::const_iterator iter = channels.find(channel); if (iter == channels.end()) return nullptr; return iter->second; } bool ChannelManager::IsPrefix(unsigned char prefix) const { // TODO: implement support for multiple channel types. return prefix == '#'; } �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/src/channels.cpp���������������������������������������������������������������������0000664�0000000�0000000�00000031660�14771603147�0016443�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2013-2016, 2018 Attila Molnar <attilamolnar@hush.com> * Copyright (C) 2013, 2016-2025 Sadie Powell <sadie@witchery.services> * Copyright (C) 2013 Adam <Adam@anope.org> * Copyright (C) 2012 Robby <robby@chatbelgie.be> * Copyright (C) 2009-2010 Daniel De Graaf <danieldg@inspircd.org> * Copyright (C) 2007 Dennis Friis <peavey@inspircd.org> * Copyright (C) 2006-2009 Robin Burchell <robin+git@viroteck.net> * Copyright (C) 2006-2008 Craig Edwards <brain@inspircd.org> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include "inspircd.h" #include "clientprotocolevent.h" #include "listmode.h" namespace { ChanModeReference ban(nullptr, "ban"); } Channel::Channel(const std::string& cname, time_t ts) : Extensible(ExtensionType::CHANNEL) , name(cname) , age(ts) { if (!ServerInstance->Channels.GetChans().emplace(cname, this).second) throw CoreException("Cannot create duplicate channel " + cname); } void Channel::SetMode(const ModeHandler* mh, bool on) { if (mh && mh->GetId() != ModeParser::MODEID_MAX) modes[mh->GetId()] = on; } void Channel::SetTopic(User* u, const std::string& ntopic, time_t topicts, const std::string* setter) { // Send a TOPIC message to the channel only if the new topic text differs if (this->topic != ntopic) { this->topic = ntopic; ClientProtocol::Messages::Topic topicmsg(u, this, this->topic); Write(ServerInstance->GetRFCEvents().topic, topicmsg); } // Always update setter and set time if (!setter) setter = ServerInstance->Config->MaskInTopic ? &u->GetMask() : &u->nick; this->setby.assign(*setter, 0, ServerInstance->Config->Limits.GetMaxMask()); this->topicset = topicts; FOREACH_MOD(OnPostTopicChange, (u, this, this->topic)); } Membership* Channel::AddUser(User* user) { std::pair<MemberMap::iterator, bool> ret = userlist.emplace(user, insp::aligned_storage<Membership>()); if (!ret.second) return nullptr; Membership* memb = new(ret.first->second) Membership(user, this); return memb; } void Channel::DelUser(User* user) { MemberMap::iterator it = userlist.find(user); if (it != userlist.end()) DelUser(it); } void Channel::CheckDestroy() { if (!userlist.empty()) return; ModResult res; FIRST_MOD_RESULT(OnChannelPreDelete, res, (this)); if (res == MOD_RES_DENY) return; // If the channel isn't in chanlist then it is already in the cull list, don't add it again ChannelMap::iterator iter = ServerInstance->Channels.GetChans().find(this->name); if ((iter == ServerInstance->Channels.GetChans().end()) || (iter->second != this)) return; FOREACH_MOD(OnChannelDelete, (this)); ServerInstance->Channels.GetChans().erase(iter); ServerInstance->GlobalCulls.AddItem(this); } void Channel::DelUser(const MemberMap::iterator& membiter) { Membership* memb = membiter->second; memb->Cull(); memb->~Membership(); userlist.erase(membiter); // If this channel became empty then it should be removed CheckDestroy(); } Membership* Channel::GetUser(User* user) const { MemberMap::const_iterator i = userlist.find(user); if (i == userlist.end()) return nullptr; return i->second; } void Channel::SetDefaultModes() { ServerInstance->Logs.Debug("CHANNELS", "Setting default modes on {}: {}", name, ServerInstance->Config->DefaultModes); irc::spacesepstream list(ServerInstance->Config->DefaultModes); std::string modeseq; std::string parameter; list.GetToken(modeseq); for (const auto modechr : modeseq) { ModeHandler* mode = ServerInstance->Modes.FindMode(modechr, MODETYPE_CHANNEL); if (mode) { if (mode->IsPrefixMode()) continue; if (mode->NeedsParam(true)) { // If the parameter is missing or begins with a ':' then it's invalid if (!list.GetToken(parameter) || parameter[0] == ':') continue; } else { // The mode does not take a parameter. parameter.clear(); } Modes::Change modechange(mode, true, parameter); mode->OnModeChange(ServerInstance->FakeClient, ServerInstance->FakeClient, this, modechange); } } } /* * add a channel to a user, creating the record for it if needed and linking * it to the user record */ Membership* Channel::JoinUser(LocalUser* user, std::string cname, bool override, const std::string& key) { if (!user->IsFullyConnected()) { ServerInstance->Logs.Debug("CHANNELS", "Attempted to join partially connected user {} to channel {}", user->uuid, cname); return nullptr; } // Crop channel name if it's too long if (cname.length() > ServerInstance->Config->Limits.MaxChannel) cname.resize(ServerInstance->Config->Limits.MaxChannel); auto* chan = ServerInstance->Channels.Find(cname); bool created_by_local = !chan; // Flag that will be passed to ForceJoin later std::string privs; // Prefix mode(letter)s to give to the joining user if (!chan) { privs = ServerInstance->Config->DefaultModes.substr(0, ServerInstance->Config->DefaultModes.find(' ')); // Ask the modules whether they're ok with the join, pass NULL as Channel* as the channel is yet to be created ModResult modres; FIRST_MOD_RESULT(OnUserPreJoin, modres, (user, nullptr, cname, privs, key, override)); if (!override && modres == MOD_RES_DENY) return nullptr; // A module wasn't happy with the join, abort chan = new Channel(cname, ServerInstance->Time()); // Set the default modes on the channel (<options:defaultmodes>) chan->SetDefaultModes(); } else { /* Already on the channel */ if (chan->HasUser(user)) return nullptr; ModResult modres; FIRST_MOD_RESULT(OnUserPreJoin, modres, (user, chan, cname, privs, key, override)); // A module explicitly denied the join and (hopefully) generated a message // describing the situation, so we may stop here without sending anything if (!override && modres == MOD_RES_DENY) return nullptr; } // We figured that this join is allowed and also created the // channel if it didn't exist before, now do the actual join return chan->ForceJoin(user, &privs, false, created_by_local); } Membership* Channel::ForceJoin(User* user, const std::string* privs, bool bursting, bool created_by_local) { if (IS_SERVER(user)) { ServerInstance->Logs.Debug("CHANNELS", "Attempted to join server user {} to channel {}", user->uuid, this->name); return nullptr; } Membership* memb = this->AddUser(user); if (!memb) return nullptr; // Already on the channel user->chans.push_front(memb); if (privs) { // If the user was granted prefix modes (in the OnUserPreJoin hook, or they're a // remote user and their own server set the modes), then set them internally now for (const auto priv : *privs) { PrefixMode* mh = ServerInstance->Modes.FindPrefixMode(priv); if (mh) { // Set the mode on the user. Modes::Change modechange(mh, true, user->nick); mh->OnModeChange(ServerInstance->FakeClient, nullptr, this, modechange); } } } // Tell modules about this join, they have the chance now to populate except_list with users we won't send the JOIN (and possibly MODE) to CUList except_list; FOREACH_MOD(OnUserJoin, (memb, bursting, created_by_local, except_list)); ClientProtocol::Events::Join joinevent(memb); this->Write(joinevent, 0, except_list); FOREACH_MOD(OnPostJoin, (memb)); return memb; } bool Channel::IsBanned(User* user) { ModResult result; FIRST_MOD_RESULT(OnCheckChannelBan, result, (user, this)); if (result != MOD_RES_PASSTHRU) return (result == MOD_RES_DENY); ListModeBase* banlm = static_cast<ListModeBase*>(*ban); if (!banlm) return false; const ListModeBase::ModeList* bans = banlm->GetList(this); if (bans) { for (const auto& entry : *bans) { if (CheckBan(user, entry.mask)) return true; } } return false; } bool Channel::CheckBan(User* user, const std::string& mask) { ModResult result; FIRST_MOD_RESULT(OnCheckBan, result, (user, this, mask)); if (result != MOD_RES_PASSTHRU) return (result == MOD_RES_DENY); std::string::size_type at = mask.find('@'); if (at == std::string::npos) return false; const std::string prefix(mask, 0, at); if (!InspIRCd::Match(user->nick + "!" + user->GetDisplayedUser(), prefix) && !InspIRCd::Match(user->nick + "!" + user->GetRealUser(), prefix)) { // Neither the nick!user or nick!duser. return false; } const std::string suffix(mask, at + 1); return InspIRCd::Match(user->GetRealHost(), suffix) || InspIRCd::Match(user->GetDisplayedHost(), suffix) || InspIRCd::MatchCIDR(user->GetAddress(), suffix); } void Channel::PartUser(const MemberMap::iterator& membiter, const std::string& reason) { User* user = membiter->first; Membership* memb = membiter->second; std::string partreason(reason); CUList except_list; FOREACH_MOD(OnUserPart, (memb, partreason, except_list)); ClientProtocol::Messages::Part partmsg(memb, partreason); Write(ServerInstance->GetRFCEvents().part, partmsg, 0, except_list); // Remove this channel from the user's chanlist user->chans.erase(memb); // Remove the Membership from this channel's userlist and destroy it this->DelUser(membiter); } void Channel::KickUser(User* src, const MemberMap::iterator& victimiter, const std::string& reason) { Membership* memb = victimiter->second; CUList except_list; FOREACH_MOD(OnUserKick, (src, memb, reason, except_list)); ClientProtocol::Messages::Kick kickmsg(src, memb, reason); Write(ServerInstance->GetRFCEvents().kick, kickmsg, 0, except_list); memb->user->chans.erase(memb); this->DelUser(victimiter); } void Channel::Write(ClientProtocol::Event& protoev, char status, const CUList& except_list) const { ModeHandler::Rank minrank = 0; if (status) { PrefixMode* mh = ServerInstance->Modes.FindPrefix(status); if (mh) minrank = mh->GetPrefixRank(); } for (const auto& [u, memb] : userlist) { LocalUser* user = IS_LOCAL(u); if ((user) && (!except_list.count(user))) { /* User doesn't have the status we're after */ if (minrank && memb->GetRank() < minrank) continue; user->Send(protoev); } } } const char* Channel::ChanModes(bool showsecret) { static std::string scratch; std::string sparam; scratch.clear(); for (const auto& [_, mh] : ServerInstance->Modes.GetModes(MODETYPE_CHANNEL)) { if (IsModeSet(mh)) { scratch.push_back(mh->GetModeChar()); ParamModeBase* pm = mh->IsParameterMode(); if (!pm) continue; if (pm->IsParameterSecret() && !showsecret) { sparam += " <" + pm->name + ">"; } else { sparam += ' '; pm->GetParameter(this, sparam); } } } scratch += sparam; return scratch.c_str(); } void Channel::WriteNotice(const std::string& text, char status) const { ClientProtocol::Messages::Privmsg privmsg(ClientProtocol::Messages::Privmsg::nocopy, ServerInstance->FakeClient, this, text, MessageType::NOTICE, status); Write(ServerInstance->GetRFCEvents().privmsg, privmsg, status); } void Channel::WriteRemoteNotice(const std::string& text, char status) const { WriteNotice(text, status); ServerInstance->PI->SendMessage(this, status, text, MessageType::NOTICE); } /* returns the status character for a given user on a channel, e.g. @ for op, * % for halfop etc. If the user has several modes set, the highest mode * the user has must be returned. */ char Membership::GetPrefixChar() const { char pf = 0; ModeHandler::Rank bestrank = 0; for (const auto* mh : modes) { if (mh->GetPrefixRank() > bestrank && mh->GetPrefix()) { bestrank = mh->GetPrefixRank(); pf = mh->GetPrefix(); } } return pf; } std::string Membership::GetAllPrefixChars() const { std::string ret; ret.reserve(modes.size()); for (const auto* mh : modes) { if (mh->GetPrefix()) ret.push_back(mh->GetPrefix()); } return ret; } std::string Membership::GetAllPrefixModes() const { std::string ret; ret.reserve(modes.size()); for (const auto* mh : modes) { if (mh->GetModeChar()) ret.push_back(mh->GetModeChar()); } return ret; } ModeHandler::Rank Channel::GetPrefixValue(User* user) const { MemberMap::const_iterator m = userlist.find(user); if (m == userlist.end()) return 0; return m->second->GetRank(); } bool Membership::SetPrefix(PrefixMode* delta_mh, bool adding) { if (adding) return modes.insert(delta_mh).second; else return modes.erase(delta_mh); } void Membership::WriteNotice(const std::string& text) const { LocalUser* const localuser = IS_LOCAL(user); if (!localuser) return; ClientProtocol::Messages::Privmsg privmsg(ClientProtocol::Messages::Privmsg::nocopy, ServerInstance->FakeClient, this->chan, text, MessageType::NOTICE); localuser->Send(ServerInstance->GetRFCEvents().privmsg, privmsg); } ��������������������������������������������������������������������������������inspircd-4.7.0/src/cidr.cpp�������������������������������������������������������������������������0000664�0000000�0000000�00000006230�14771603147�0015564�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2019, 2022-2023 Sadie Powell <sadie@witchery.services> * Copyright (C) 2014-2015 Attila Molnar <attilamolnar@hush.com> * Copyright (C) 2012 Robby <robby@chatbelgie.be> * Copyright (C) 2009-2010 Daniel De Graaf <danieldg@inspircd.org> * Copyright (C) 2008 Robin Burchell <robin+git@viroteck.net> * Copyright (C) 2008 Craig Edwards <brain@inspircd.org> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include "inspircd.h" /* Match CIDR strings, e.g. 127.0.0.1 to 127.0.0.0/8 or 3ffe:1:5:6::8 to 3ffe:1::0/32 * * This will also attempt to match any leading usernames or nicknames on the mask, using * match(), when match_with_username is true. */ bool irc::sockets::MatchCIDR(const std::string& address, const std::string& cidr_mask, bool match_with_username) { std::string address_copy; std::string cidr_copy; /* The caller is trying to match username@<mask>/bits. * Chop off the username@ portion, use match() on it * separately. */ if (match_with_username) { /* Use strchr not strrchr, because its going to be nearer to the left */ std::string::size_type username_mask_pos = cidr_mask.rfind('@'); std::string::size_type username_addr_pos = address.rfind('@'); /* Both strings have an @ symbol in them */ if (username_mask_pos != std::string::npos && username_addr_pos != std::string::npos) { /* Try and match() the strings before the @ * symbols, and recursively call MatchCIDR without * username matching enabled to match the host part. */ return (InspIRCd::Match(address.substr(0, username_addr_pos), cidr_mask.substr(0, username_mask_pos), ascii_case_insensitive_map) && MatchCIDR(address.substr(username_addr_pos + 1), cidr_mask.substr(username_mask_pos + 1), false)); } else { address_copy.assign(address, username_addr_pos + 1, std::string::npos); cidr_copy.assign(cidr_mask, username_mask_pos + 1, std::string::npos); } } else { address_copy.assign(address); cidr_copy.assign(cidr_mask); } const std::string::size_type per_pos = cidr_copy.rfind('/'); if ((per_pos != std::string::npos) && ((per_pos == cidr_copy.length()-1) || (cidr_copy.find_first_not_of("0123456789", per_pos+1) != std::string::npos) || (cidr_copy.find_first_not_of("0123456789abcdefABCDEF.:") < per_pos))) { // The CIDR mask is invalid return false; } irc::sockets::sockaddrs addr(false); if (!addr.from_ip(address_copy)) { // The address could not be parsed. return false; } irc::sockets::cidr_mask mask(cidr_copy); irc::sockets::cidr_mask mask2(addr, mask.length); return mask == mask2; } ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/src/clientprotocol.cpp���������������������������������������������������������������0000664�0000000�0000000�00000010627�14771603147�0017710�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2018-2024 Sadie Powell <sadie@witchery.services> * Copyright (C) 2018 Attila Molnar <attilamolnar@hush.com> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include "inspircd.h" ClientProtocol::Serializer::Serializer(Module* mod, const std::string& Name) : DataProvider(mod, "serializer/" + Name) , evprov(mod) { } bool ClientProtocol::Serializer::HandleTag(LocalUser* user, const std::string& tagname, std::string& tagvalue, TagMap& tags) const { // Catch and block empty tags if (tagname.empty()) return false; for (auto* subscriber : evprov.GetSubscribers()) { MessageTagProvider* const tagprov = static_cast<MessageTagProvider*>(subscriber); const ModResult res = tagprov->OnProcessTag(user, tagname, tagvalue); if (res == MOD_RES_ALLOW) return tags.emplace(tagname, MessageTagData(tagprov, tagvalue)).second; else if (res == MOD_RES_DENY) break; } // No module handles the tag but that's not an error return true; } ClientProtocol::TagSelection ClientProtocol::Serializer::MakeTagWhitelist(LocalUser* user, const TagMap& tagmap) { TagSelection tagwl; for (TagMap::const_iterator i = tagmap.begin(); i != tagmap.end(); ++i) { const MessageTagData& tagdata = i->second; if (tagdata.tagprov->ShouldSendTag(user, tagdata)) tagwl.Select(tagmap, i); } return tagwl; } const ClientProtocol::SerializedMessage& ClientProtocol::Serializer::SerializeForUser(LocalUser* user, Message& msg) { if (!msg.msginit_done) { msg.msginit_done = true; evprov.Call(&MessageTagProvider::OnPopulateTags, msg); } return msg.GetSerialized(Message::SerializedInfo(this, MakeTagWhitelist(user, msg.GetTags()))); } std::string ClientProtocol::Message::EscapeTag(const std::string& value) { std::string ret; ret.reserve(value.size()); for (const auto chr : value) { switch (chr) { case ' ': ret.append("\\s"); break; case ';': ret.append("\\:"); break; case '\\': ret.append("\\\\"); break; case '\n': ret.append("\\n"); break; case '\r': ret.append("\\r"); break; default: ret.push_back(chr); break; } } return ret; } std::string ClientProtocol::Message::UnescapeTag(const std::string& value) { std::string ret; ret.reserve(value.size()); for (std::string::const_iterator it = value.begin(); it != value.end(); ++it) { char chr = *it; if (chr != '\\') { ret.push_back(chr); continue; } it++; if (it == value.end()) break; chr = *it; switch (chr) { case 's': ret.push_back(' '); break; case ':': ret.push_back(';'); break; case '\\': ret.push_back('\\'); break; case 'n': ret.push_back('\n'); break; case 'r': ret.push_back('\r'); break; default: ret.push_back(chr); break; } } return ret; } const ClientProtocol::SerializedMessage& ClientProtocol::Message::GetSerialized(const SerializedInfo& serializeinfo) const { // First check if the serialized line they're asking for is in the cache for (const auto& [info, msg] : serlist) { if (info == serializeinfo) return msg; } // Not cached, generate it and put it in the cache for later use serlist.push_back(std::make_pair(serializeinfo, serializeinfo.serializer->Serialize(*this, serializeinfo.tagwl))); return serlist.back().second; } void ClientProtocol::Event::GetMessagesForUser(LocalUser* user, MessageList& messagelist) { if (!eventinit_done) { eventinit_done = true; event->Call(&EventHook::OnEventInit, *this); } // Most of the time there's only a single message but in rare cases there are more if (initialmsg) messagelist.assign(1, initialmsg); else messagelist = *initialmsglist; // Let modules modify the message list ModResult res = event->FirstResult(&EventHook::OnPreEventSend, user, *this, messagelist); if (res == MOD_RES_DENY) messagelist.clear(); } ���������������������������������������������������������������������������������������������������������inspircd-4.7.0/src/commands.cpp���������������������������������������������������������������������0000664�0000000�0000000�00000034221�14771603147�0016445�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2021 Herman <GermanAizek@yandex.ru> * Copyright (C) 2018-2024 Sadie Powell <sadie@witchery.services> * Copyright (C) 2012-2016, 2018 Attila Molnar <attilamolnar@hush.com> * Copyright (C) 2012 Robby <robby@chatbelgie.be> * Copyright (C) 2009-2010 Daniel De Graaf <danieldg@inspircd.org> * Copyright (C) 2007-2009 Robin Burchell <robin+git@viroteck.net> * Copyright (C) 2007 Dennis Friis <peavey@inspircd.org> * Copyright (C) 2005-2008 Craig Edwards <brain@inspircd.org> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include "inspircd.h" bool CommandParser::LoopCall(User* user, Command* handler, const CommandBase::Params& parameters, unsigned int splithere, int extra, bool usemax) { if (splithere >= parameters.size()) return false; /* First check if we have more than one item in the list, if we don't we return false here and the handler * which called us just carries on as it was. */ if (parameters[splithere].find(',') == std::string::npos) return false; /** Some lame ircds will weed out dupes using some shitty O(n^2) algorithm. * By using std::set (thanks for the idea w00t) we can cut this down a ton. * ...VOOODOOOO! * * Only check for duplicates if there is one list (allow them in JOIN). */ insp::flat_set<std::string, irc::insensitive_swo> dupes; bool check_dupes = (extra < 0); /* Create two sepstreams, if we have only one list, then initialize the second sepstream with * an empty string. The second parameter of the constructor of the sepstream tells whether * or not to allow empty tokens. * We allow empty keys, so "JOIN #a,#b ,bkey" will be interpreted as "JOIN #a", "JOIN #b bkey" */ irc::commasepstream items1(parameters[splithere]); irc::commasepstream items2(extra >= 0 ? parameters[extra] : "", true); std::string item; size_t max = 0; LocalUser* localuser = IS_LOCAL(user); /* Attempt to iterate these lists and call the command handler * for every parameter or parameter pair until there are no more * left to parse. */ CommandBase::Params splitparams(parameters); while (items1.GetToken(item) && (!usemax || max++ < ServerInstance->Config->MaxTargets)) { if ((!check_dupes) || (dupes.insert(item).second)) { splitparams[splithere] = item; if (extra >= 0) { // If we have two lists then get the next item from the second list. // In case it runs out of elements then 'item' will be an empty string. items2.GetToken(item); splitparams[extra] = item; } CmdResult result = handler->Handle(user, splitparams); if (localuser) { // Run the OnPostCommand hook with the last parameter being true to indicate // that the event is being called in a loop. item.clear(); FOREACH_MOD(OnPostCommand, (handler, splitparams, localuser, result, true)); } } } return true; } Command* CommandParser::GetHandler(const std::string& commandname) { CommandMap::iterator n = cmdlist.find(commandname); if (n != cmdlist.end()) return n->second; return nullptr; } // calls a handler function for a command CmdResult CommandParser::CallHandler(const std::string& commandname, const CommandBase::Params& parameters, User* user, Command** cmd) { /* find the command, check it exists */ Command* handler = GetHandler(commandname); if (handler) { if ((!parameters.empty()) && (parameters.back().empty()) && (!handler->allow_empty_last_param)) return CmdResult::INVALID; if (parameters.size() >= handler->min_params) { bool bOkay = false; if (IS_LOCAL(user)) { switch (handler->access_needed) { case CmdAccess::NORMAL: // Anyone can execute. bOkay = true; break; case CmdAccess::OPERATOR: // Only opers can execute. bOkay = user->HasCommandPermission(commandname); break; case CmdAccess::SERVER: // Only servers can execute. bOkay = IS_SERVER(user); break; } } else { /* remote or no flags required anyway */ bOkay = true; } if (bOkay) { if (cmd) *cmd = handler; ClientProtocol::TagMap tags; return handler->Handle(user, CommandBase::Params(parameters, tags)); } } } return CmdResult::INVALID; } void CommandParser::ProcessCommand(LocalUser* user, std::string& command, CommandBase::Params& command_p) { /* find the command, check it exists */ Command* handler = GetHandler(command); // Penalty to give if the command fails before the handler is executed unsigned int failpenalty = 0; /* Modify the user's penalty regardless of whether or not the command exists */ if (!user->HasPrivPermission("users/flood/no-throttle")) { // If it *doesn't* exist, give it a slightly heftier penalty than normal to deter flooding us crap unsigned int penalty = handler ? handler->penalty : 2000; user->CommandFloodPenalty += penalty; // Increase their penalty later if we fail and the command has 0 penalty by default (i.e. in Command::penalty) to // throttle sending ERR_* from the command parser. If the command does have a non-zero penalty then this is not // needed because we've increased their penalty above. if (penalty == 0) failpenalty = 1000; } if (!handler) { ModResult modres; FIRST_MOD_RESULT(OnPreCommand, modres, (command, command_p, user, false)); if (modres == MOD_RES_DENY) { FOREACH_MOD(OnCommandBlocked, (command, command_p, user)); return; } /* * This double lookup is in case a module (abbreviation) wishes to change a command. * Sure, the double lookup is a bit painful, but bear in mind this only happens for unknowns anyway. * * Thanks dz for making me actually understand why this is necessary! * -- w00t */ handler = GetHandler(command); if (!handler) { if (user->IsFullyConnected()) user->WriteNumeric(ERR_UNKNOWNCOMMAND, command, "Unknown command"); ServerInstance->Stats.Unknown++; FOREACH_MOD(OnCommandBlocked, (command, command_p, user)); return; } } // If we were given more parameters than max_params then append the excess parameter(s) // to command_p[maxparams-1], i.e. to the last param that is still allowed if (handler->max_params && command_p.size() > handler->max_params) { /* * command_p input (assuming max_params 1): * this * is * a * test */ // Iterator to the last parameter that will be kept const CommandBase::Params::iterator lastkeep = command_p.begin() + (handler->max_params - 1); // Iterator to the first excess parameter const CommandBase::Params::iterator firstexcess = lastkeep + 1; // Append all excess parameter(s) to the last parameter, separated by spaces for (const auto& param : insp::iterator_range(firstexcess, command_p.end())) { lastkeep->push_back(' '); lastkeep->append(param); } // Erase the excess parameter(s) command_p.erase(firstexcess, command_p.end()); } /* * We call OnPreCommand here separately if the command exists, so the magic above can * truncate to max_params if necessary. -- w00t */ ModResult modres; FIRST_MOD_RESULT(OnPreCommand, modres, (command, command_p, user, false)); if (modres == MOD_RES_DENY) { FOREACH_MOD(OnCommandBlocked, (command, command_p, user)); return; } /* activity resets the ping pending timer */ user->nextping = ServerInstance->Time() + user->GetClass()->pingtime; switch (handler->access_needed) { case CmdAccess::NORMAL: break; // Nothing special too do. case CmdAccess::OPERATOR: { if (!user->IsOper()) { user->CommandFloodPenalty += failpenalty; user->WriteNumeric(ERR_NOPRIVILEGES, "Permission Denied - You do not have the required operator privileges"); FOREACH_MOD(OnCommandBlocked, (command, command_p, user)); return; } if (!user->HasCommandPermission(command)) { user->CommandFloodPenalty += failpenalty; user->WriteNumeric(ERR_NOPRIVILEGES, INSP_FORMAT("Permission Denied - Oper type {} does not have access to command {}", user->oper->GetType(), command)); FOREACH_MOD(OnCommandBlocked, (command, command_p, user)); return; } break; } case CmdAccess::SERVER: { if (user->IsFullyConnected()) user->WriteNumeric(ERR_UNKNOWNCOMMAND, command, "Unknown command"); ServerInstance->Stats.Unknown++; FOREACH_MOD(OnCommandBlocked, (command, command_p, user)); break; } } if (!user->IsFullyConnected() && !handler->works_before_reg) { user->CommandFloodPenalty += failpenalty; handler->TellNotFullyConnected(user, command_p); FOREACH_MOD(OnCommandBlocked, (command, command_p, user)); return; } if ((!command_p.empty()) && (command_p.back().empty()) && (!handler->allow_empty_last_param)) command_p.pop_back(); if (command_p.size() < handler->min_params) { user->CommandFloodPenalty += failpenalty; handler->TellNotEnoughParameters(user, command_p); FOREACH_MOD(OnCommandBlocked, (command, command_p, user)); } else { /* passed all checks.. first, do the (ugly) stats counters. */ handler->use_count++; /* module calls too */ FIRST_MOD_RESULT(OnPreCommand, modres, (command, command_p, user, true)); if (modres == MOD_RES_DENY) { FOREACH_MOD(OnCommandBlocked, (command, command_p, user)); return; } /* * WARNING: be careful, the user may be deleted soon */ CmdResult result = handler->Handle(user, command_p); FOREACH_MOD(OnPostCommand, (handler, command_p, user, result, false)); } } void CommandParser::RemoveCommand(Command* x) { CommandMap::iterator n = cmdlist.find(x->name); if (n != cmdlist.end() && n->second == x) cmdlist.erase(n); } void CommandParser::ProcessBuffer(LocalUser* user, const std::string& buffer) { ClientProtocol::ParseOutput parseoutput; if (!user->serializer->Parse(user, buffer, parseoutput)) return; std::string& command = parseoutput.cmd; std::transform(command.begin(), command.end(), command.begin(), ::toupper); CommandBase::Params parameters(parseoutput.params, parseoutput.tags); ProcessCommand(user, command, parameters); } bool CommandParser::AddCommand(Command* cmd) { return cmdlist.emplace(cmd->name, cmd).second; } std::string CommandParser::TranslateUIDs(const std::vector<TranslateType>& to, const CommandBase::Params& source, bool prefix_final, CommandBase* custom_translator) { std::vector<TranslateType>::const_iterator types = to.begin(); std::string dest; for (unsigned int i = 0; i < source.size(); i++) { TranslateType t = TR_TEXT; // They might supply less translation types than parameters, // in that case pretend that all remaining types are TR_TEXT if (types != to.end()) { t = *types; types++; } bool last = (i == (source.size() - 1)); if (prefix_final && last) dest.push_back(':'); TranslateSingleParam(t, source[i], dest, custom_translator, i); if (!last) dest.push_back(' '); } return dest; } void CommandParser::TranslateSingleParam(TranslateType to, const std::string& item, std::string& dest, CommandBase* custom_translator, unsigned int paramnumber) { switch (to) { case TR_NICK: { /* Translate single nickname */ auto* user = ServerInstance->Users.Find(item); if (user) dest.append(user->uuid); else dest.append(item); break; } case TR_CUSTOM: { if (custom_translator) { std::string translated = item; custom_translator->EncodeParameter(translated, paramnumber); dest.append(translated); break; } // If no custom translator was given, fall through } [[fallthrough]]; default: /* Do nothing */ dest.append(item); break; } } CommandBase::CommandBase(Module* mod, const std::string& cmd, unsigned int minpara, unsigned int maxpara) : ServiceProvider(mod, cmd, SERVICE_COMMAND) , min_params(minpara) , max_params(maxpara) { } void CommandBase::EncodeParameter(std::string& parameter, unsigned int index) { } RouteDescriptor CommandBase::GetRouting(User* user, const Params& parameters) { return ROUTE_LOCALONLY; } Command::Command(Module* mod, const std::string& cmd, unsigned int minpara, unsigned int maxpara) : CommandBase(mod, cmd, minpara, maxpara) { } Command::~Command() { ServerInstance->Parser.RemoveCommand(this); } void Command::RegisterService() { if (!ServerInstance->Parser.AddCommand(this)) throw ModuleException(creator, "Command already exists: " + name); } void Command::TellNotEnoughParameters(LocalUser* user, const Params& parameters) { user->WriteNumeric(ERR_NEEDMOREPARAMS, name, "Not enough parameters."); if (ServerInstance->Config->SyntaxHints && user->IsFullyConnected()) { for (const auto& syntaxline : this->syntax) user->WriteNumeric(RPL_SYNTAX, name, syntaxline); } } void Command::TellNotFullyConnected(LocalUser* user, const Params& parameters) { user->WriteNumeric(ERR_NOTREGISTERED, name, "You must be fully connected to use this command."); } SplitCommand::SplitCommand(Module* me, const std::string& cmd, unsigned int minpara, unsigned int maxpara) : Command(me, cmd, minpara, maxpara) { } CmdResult SplitCommand::Handle(User* user, const Params& parameters) { switch (user->usertype) { case User::TYPE_LOCAL: return HandleLocal(static_cast<LocalUser*>(user), parameters); case User::TYPE_REMOTE: return HandleRemote(static_cast<RemoteUser*>(user), parameters); case User::TYPE_SERVER: return HandleServer(static_cast<FakeUser*>(user), parameters); } ServerInstance->Logs.Debug("COMMAND", "Unknown user type {} in command (uuid={})!", user->usertype, user->uuid); return CmdResult::INVALID; } CmdResult SplitCommand::HandleLocal(LocalUser* user, const Params& parameters) { return CmdResult::INVALID; } CmdResult SplitCommand::HandleRemote(RemoteUser* user, const Params& parameters) { return CmdResult::INVALID; } CmdResult SplitCommand::HandleServer(FakeUser* user, const Params& parameters) { return CmdResult::INVALID; } �������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/src/configparser.cpp�����������������������������������������������������������������0000664�0000000�0000000�00000046117�14771603147�0017335�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2018 linuxdaemon <linuxdaemon.irc@gmail.com> * Copyright (C) 2013-2014, 2016-2025 Sadie Powell <sadie@witchery.services> * Copyright (C) 2012-2014 Attila Molnar <attilamolnar@hush.com> * Copyright (C) 2012 Robby <robby@chatbelgie.be> * Copyright (C) 2009-2010 Daniel De Graaf <danieldg@inspircd.org> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include <cinttypes> #include <filesystem> #include <fstream> #include "inspircd.h" #include "configparser.h" #include "timeutils.h" #include "utility/string.h" #ifdef _WIN32 # define pclose _pclose # define popen _popen #else # include <unistd.h> #endif enum ParseFlags { // Executable includes are disabled. FLAG_NO_EXEC = 2, // All includes are disabled. FLAG_NO_INC = 4, // &env.FOO; is disabled. FLAG_NO_ENV = 8, // It's okay if an include doesn't exist. FLAG_MISSING_OKAY = 16 }; struct Parser final { ParseStack& stack; int flags; FilePtr file; FilePosition current; FilePosition last_tag; std::shared_ptr<ConfigTag> tag; int ungot = -1; std::string mandatory_tag; Parser(ParseStack& me, int myflags, FilePtr conf, const std::string& name, const std::string& mandatorytag) : stack(me) , flags(myflags) , file(std::move(conf)) , current(name, 1, 0) , last_tag(name, 0, 0) , mandatory_tag(mandatorytag) { } int next(bool eof_ok = false) { if (ungot != -1) { int ch = ungot; ungot = -1; return ch; } int ch = fgetc(file.get()); if (ch == EOF && !eof_ok) { throw CoreException("Unexpected end-of-file"); } else if (ch == '\n') { current.line++; current.column = 1; } else { current.column++; } return ch; } void unget(int ch) { if (ungot != -1) throw CoreException("INTERNAL ERROR: cannot unget twice"); ungot = ch; } void comment() { while (true) { int ch = next(true); if (ch == '\n') return; if (ch == EOF) { unget(ch); return; } } } static bool wordchar(int ch) { return isalnum(ch) || ch == '-' || ch == '.' || ch == '_'; } void nextword(std::string& rv) { int ch = next(); while (isspace(ch)) ch = next(); while (wordchar(ch)) { rv.push_back(ch); ch = next(); } unget(ch); } bool kv() { std::string key; nextword(key); int ch = next(); if (ch == '>' && key.empty()) { return false; } else if (ch == '#' && key.empty()) { comment(); return true; } else if (ch != '=') { throw CoreException("Invalid character " + std::string(1, ch) + " in key (" + key + ")"); } std::string value; ch = next(); if (ch != '"') { throw CoreException("Invalid character in value of <" + tag->name + ":" + key + ">"); } while (true) { ch = next(); if (ch == '&') { std::string varname; while (true) { ch = next(); if (wordchar(ch) || (varname.empty() && ch == '#')) varname.push_back(ch); else if (ch == ';') break; else { stack.errstr << "Invalid XML entity name in value of <" + tag->name + ":" + key + ">\n" << "To include an ampersand or quote, use &amp; or &quot;\n"; throw CoreException("Parse error"); } } if (varname.empty()) throw CoreException("Empty XML entity reference"); else if (varname[0] == '#' && (varname.size() == 1 || (varname.size() == 2 && varname[1] == 'x'))) throw CoreException("Empty numeric character reference"); else if (varname[0] == '#') { const char* cvarname = varname.c_str(); char* endptr; unsigned long lvalue; if (cvarname[1] == 'x') lvalue = strtoul(cvarname + 2, &endptr, 16); else lvalue = strtoul(cvarname + 1, &endptr, 10); if (*endptr != '\0' || lvalue > 255) throw CoreException("Invalid numeric character reference '&" + varname + ";'"); value.push_back(static_cast<char>(lvalue)); } else if (varname.compare(0, 4, "env.") == 0) { if (flags & FLAG_NO_ENV) throw CoreException("XML environment entity reference in file included with noenv=\"yes\""); const char* envstr = getenv(varname.c_str() + 4); if (!envstr) throw CoreException("Undefined XML environment entity reference '&" + varname + ";'"); value.append(envstr); } else { insp::flat_map<std::string, std::string>::iterator var = stack.vars.find(varname); if (var == stack.vars.end()) throw CoreException("Undefined XML entity reference '&" + varname + ";'"); value.append(var->second); } } else if (ch == '"') break; else if (ch != '\r') value.push_back(ch); } if (!tag->GetItems().insert({key, value}).second) throw CoreException("Duplicate key '" + key + "' found"); return true; } void dotag() { last_tag = current; std::string name; nextword(name); int spc = next(); if (spc == '>') unget(spc); else if (!isspace(spc)) throw CoreException("Invalid character in tag name"); if (name.empty()) throw CoreException("Empty tag name"); tag = std::make_shared<ConfigTag>(name, last_tag); while (kv()) { // Do nothing here (silences a GCC warning). } if (name == mandatory_tag) { // Found the mandatory tag mandatory_tag.clear(); } if (insp::equalsci(name, "include")) { stack.DoInclude(tag, flags); } else if (insp::equalsci(name, "files")) { for (const auto& [key, value] : tag->GetItems()) stack.DoReadFile(key, value, flags, false); } else if (insp::equalsci(name, "execfiles")) { for (const auto& [key, value] : tag->GetItems()) stack.DoReadFile(key, value, flags, true); } else if (insp::equalsci(name, "define")) { const std::string varname = tag->getString("name"); if (varname.empty()) throw CoreException("Variable definition must include a variable name, at " + tag->source.str()); if (stack.vars.find(varname) == stack.vars.end() || tag->getBool("replace", true)) stack.vars[varname] = tag->getString("value"); } else { stack.output.emplace(name, tag); } // this is not a leak; shared_ptr takes care of the delete tag = nullptr; } bool outer_parse() { try { while (true) { int ch = next(true); switch (ch) { case EOF: // this is the one place where an EOF is not an error if (!mandatory_tag.empty()) throw CoreException("Mandatory tag \"" + mandatory_tag + "\" not found"); return true; case '#': comment(); break; case '<': dotag(); break; case ' ': case '\r': case '\t': case '\n': break; case 0xFE: case 0xFF: stack.errstr << "Do not save your files as UTF-16 or UTF-32, use UTF-8!\n"; [[fallthrough]]; default: throw CoreException("Syntax error - start of tag expected"); } } } catch (const CoreException& err) { stack.errstr << err.GetReason() << " at " << current.str(); if (tag) stack.errstr << " (inside <" << tag->name << "> tag on line " << tag->source.line << ")"; else if (last_tag.line) stack.errstr << " (last tag was on line " << last_tag.line << ")"; stack.errstr << '\n'; } return false; } }; FilePosition::FilePosition(const std::string& Name, unsigned long Line, unsigned long Column) : name(Name) , line(Line) , column(Column) { } std::string FilePosition::str() const { return INSP_FORMAT("{}:{}:{}", name, line, column); } void ParseStack::DoInclude(const std::shared_ptr<ConfigTag>& tag, int flags) { if (flags & FLAG_NO_INC) throw CoreException("Invalid <include> tag in file included with noinclude=\"yes\""); std::string mandatorytag; tag->readString("mandatorytag", mandatorytag); std::string name; if (tag->readString("file", name)) { if (tag->getBool("noinclude", false)) flags |= FLAG_NO_INC; if (tag->getBool("noexec", false)) flags |= FLAG_NO_EXEC; if (tag->getBool("noenv", false)) flags |= FLAG_NO_ENV; if (tag->getBool("missingokay", false)) flags |= FLAG_MISSING_OKAY; else flags &= ~FLAG_MISSING_OKAY; if (!ParseFile(name, flags, mandatorytag)) throw CoreException("Included"); } else if (tag->readString("directory", name)) { if (tag->getBool("noinclude", false)) flags |= FLAG_NO_INC; if (tag->getBool("noexec", false)) flags |= FLAG_NO_EXEC; if (tag->getBool("noenv", false)) flags |= FLAG_NO_ENV; const std::string includedir = ServerInstance->Config->Paths.PrependConfig(name); std::set<std::string> configs; try { for (const auto& entry : std::filesystem::directory_iterator(includedir)) { if (!entry.is_regular_file()) continue; const std::string path = entry.path().string(); if (InspIRCd::Match(path, "*.conf")) configs.insert(path); } } catch (const std::filesystem::filesystem_error& err) { throw CoreException("Unable to read directory for include " + includedir + ": " + err.what()); } for (const auto& config : configs) { if (!ParseFile(config, flags, mandatorytag)) throw CoreException("Included"); } } else if (tag->readString("executable", name)) { if (flags & FLAG_NO_EXEC) throw CoreException("Invalid <include:executable> tag in file included with noexec=\"yes\""); if (tag->getBool("noinclude", false)) flags |= FLAG_NO_INC; if (tag->getBool("noexec", true)) flags |= FLAG_NO_EXEC; if (tag->getBool("noenv", true)) flags |= FLAG_NO_ENV; if (!ParseFile(name, flags, mandatorytag, true)) throw CoreException("Included"); } } FilePtr ParseStack::DoOpenFile(const std::string& name, bool isexec) { if (isexec) { ServerInstance->Logs.Debug("CONFIG", "Opening executable: {}", name); return FilePtr(popen(name.c_str(), "r"), pclose); } const std::string path = ServerInstance->Config->Paths.PrependConfig(name); ServerInstance->Logs.Debug("CONFIG", "Opening file: {}", path); #ifndef _WIN32 struct stat pathinfo; if (stat(path.c_str(), &pathinfo) == 0) { if (getegid() != pathinfo.st_gid) { ServerInstance->Logs.Warning("CONFIG", "Possible configuration error: {} is owned by group {} but the server is running as group {}.", path, pathinfo.st_gid, getegid()); } if (geteuid() != pathinfo.st_uid) { ServerInstance->Logs.Warning("CONFIG", "Possible configuration error: {} is owned by user {} but the server is running as user {}.", path, pathinfo.st_uid, geteuid()); } } #endif return FilePtr(fopen(path.c_str(), "r"), fclose); } void ParseStack::DoReadFile(const std::string& key, const std::string& name, int flags, bool exec) { if (flags & FLAG_NO_INC) throw CoreException("Invalid <files> tag in file included with noinclude=\"yes\""); if (exec && (flags & FLAG_NO_EXEC)) throw CoreException("Invalid <execfiles> tag in file included with noexec=\"yes\""); if (FilesOutput.emplace(key, std::make_pair(name, exec)).second) { ServerInstance->Logs.Debug("CONFIG", "Stored config key: {} => {} (executable: {}).", key, name, exec ? "yes" : "no"); } } ParseStack::ParseStack(ServerConfig* conf) : output(conf->config_data) , FilesOutput(conf->filesources) , errstr(conf->errstr) { vars = { // Special character escapes. { "newline", "\n" }, { "nl", "\n" }, // XML escapes. { "amp", "&" }, { "apos", "'" }, { "gt", ">" }, { "lt", "<" }, { "quot", "\"" }, // Directories that were set at build time. { "dir.config", INSPIRCD_CONFIG_PATH }, { "dir.example", INSPIRCD_EXAMPLE_PATH }, { "dir.data", INSPIRCD_DATA_PATH }, { "dir.log", INSPIRCD_LOG_PATH }, { "dir.module", INSPIRCD_MODULE_PATH }, { "dir.runtime", INSPIRCD_RUNTIME_PATH }, // IRC formatting codes. { "irc.bold", "\x02" }, { "irc.color", "\x03" }, { "irc.colour", "\x03" }, { "irc.hexcolor", "\x04" }, { "irc.hexcolour", "\x04" }, { "irc.italic", "\x1D" }, { "irc.monospace", "\x11" }, { "irc.reset", "\x0F" }, { "irc.reverse", "\x16" }, { "irc.strikethrough", "\x1E" }, { "irc.underline", "\x1F" }, }; } bool ParseStack::ParseFile(const std::string& path, int flags, const std::string& mandatory_tag, bool isexec) { if (stdalgo::isin(reading, path)) throw CoreException((isexec ? "Executable " : "File ") + path + " is included recursively (looped inclusion)"); /* It's not already included, add it to the list of files we've loaded */ FilePtr file = DoOpenFile(path, isexec); if (!file) { if (flags & FLAG_MISSING_OKAY) return true; throw CoreException(INSP_FORMAT("Could not read \"{}\" for include: {}", path, strerror(errno))); } reading.push_back(path); Parser p(*this, flags, std::move(file), path, mandatory_tag); bool ok = p.outer_parse(); reading.pop_back(); return ok; } void ConfigTag::LogMalformed(const std::string& key, const std::string& val, const std::string& def, const std::string& reason) const { ServerInstance->Logs.Warning("CONFIG", "The value of <{}:{}> at {} ({}) is {}; using the default ({}) instead.", name, key, source.str(), val, reason, def); } bool ConfigTag::readString(const std::string& key, std::string& value, bool allow_lf) const { for (const auto& [ikey, ivalue] : items) { if (!insp::equalsci(ikey, key)) continue; value = ivalue; if (!allow_lf && (value.find('\n') != std::string::npos)) { ServerInstance->Logs.Warning("CONFIG", "Value of <" + name + ":" + key + "> at " + source.str() + " contains a linefeed, and linefeeds in this value are not permitted -- stripped to spaces."); for (auto& chr : value) { if (chr == '\n') chr = ' '; } } return true; } return false; } std::string ConfigTag::getString(const std::string& key, const std::string& def, const std::function<bool(const std::string&)>& validator) const { std::string res; if (!readString(key, res)) return def; if (!validator(res)) { LogMalformed(key, res, def, "not valid"); return def; } return res; } std::string ConfigTag::getString(const std::string& key, const std::string& def, size_t minlen, size_t maxlen) const { std::string res; if (!readString(key, res)) return def; if (res.length() < minlen || res.length() > maxlen) { LogMalformed(key, res, def, INSP_FORMAT("not between {} and {} characters in length", minlen, maxlen)); return def; } return res; } namespace { /** Check for an invalid magnitude specifier. If one is found a warning is logged and the * value is corrected (set to \p def). * @param tag The tag name; used in the warning message. * @param key The key name; used in the warning message. * @param val The full value set in the config as a string. * @param num The value to verify and modify if needed. * @param def The default value, \p res will be set to this if \p tail does not contain a. * valid magnitude specifier. * @param tail The location in the config value at which the magnifier is located. */ template <typename Numeric> void CheckMagnitude(const ConfigTag* tag, const std::string& key, const std::string& val, Numeric& num, Numeric def, const char* tail) { // If this is NULL then no magnitude specifier was given. if (!*tail) return; switch (toupper(*tail)) { case 'K': num *= 1024; return; case 'M': num *= 1024 * 1024; return; case 'G': num *= 1024 * 1024 * 1024; return; default: num = def; tag->LogMalformed(key, val, ConvToStr(def), INSP_FORMAT("contains an invalid magnitude specifier ({})", *tail)); return; } } /** Check for an out of range value. If the value falls outside the boundaries a warning is * logged and the value is corrected (set to \p def). * @param tag The tag name; used in the warning message. * @param key The key name; used in the warning message. * @param num The value to verify and modify if needed. * @param def The default value, \p res will be set to this if (min <= res <= max) doesn't hold true. * @param min Minimum accepted value for \p res. * @param max Maximum accepted value for \p res. */ template <typename Numeric> void CheckRange(const ConfigTag* tag, const std::string& key, Numeric& num, Numeric def, Numeric min, Numeric max) { if (num >= min && num <= max) return; tag->LogMalformed(key, ConvToStr(num), ConvToStr(def), INSP_FORMAT("not between {} and {}", min, max)); num = def; } } intmax_t ConfigTag::getSInt(const std::string& key, intmax_t def, intmax_t min, intmax_t max) const { std::string result; if(!readString(key, result) || result.empty()) return def; const char* res_cstr = result.c_str(); char* res_tail = nullptr; intmax_t res = strtoimax(res_cstr, &res_tail, 0); if (res_tail == res_cstr) return def; CheckMagnitude(this, key, result, res, def, res_tail); CheckRange(this, key, res, def, min, max); return res; } uintmax_t ConfigTag::getUInt(const std::string& key, uintmax_t def, uintmax_t min, uintmax_t max) const { std::string result; if (!readString(key, result) || result.empty()) return def; const char* res_cstr = result.c_str(); char* res_tail = nullptr; uintmax_t res = strtoumax(res_cstr, &res_tail, 0); if (res_tail == res_cstr) return def; CheckMagnitude(this, key, result, res, def, res_tail); CheckRange(this, key, res, def, min, max); return res; } unsigned long ConfigTag::getDuration(const std::string& key, unsigned long def, unsigned long min, unsigned long max) const { std::string duration; if (!readString(key, duration) || duration.empty()) return def; unsigned long ret; if (!Duration::TryFrom(duration, ret)) { LogMalformed(key, duration, ConvToStr(def), "is not a duration"); return def; } CheckRange(this, key, ret, def, min, max); return ret; } long double ConfigTag::getFloat(const std::string& key, long double def, long double min, long double max) const { std::string result; if (!readString(key, result)) return def; long double res = strtold(result.c_str(), nullptr); CheckRange(this, key, res, def, min, max); return res; } bool ConfigTag::getBool(const std::string& key, bool def) const { std::string result; if(!readString(key, result) || result.empty()) return def; if (insp::equalsci(result, "yes") || insp::equalsci(result, "true") || insp::equalsci(result, "on")) return true; if (insp::equalsci(result, "no") || insp::equalsci(result, "false") || insp::equalsci(result, "off")) return false; LogMalformed(key, result, def ? "yes" : "no", "is not a boolean"); return def; } unsigned char ConfigTag::getCharacter(const std::string& key, unsigned char def, bool emptynul) const { std::string result; if (!readString(key, result)) return def; if (result.size() != 1) return result.empty() && emptynul ? 0 : def; return result[0]; } ConfigTag::ConfigTag(const std::string& Name, const FilePosition& Source) : name(Name) , source(Source) { } �������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/src/configreader.cpp�����������������������������������������������������������������0000664�0000000�0000000�00000057306�14771603147�0017305�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2013-2016 Attila Molnar <attilamolnar@hush.com> * Copyright (C) 2013-2014, 2016-2025 Sadie Powell <sadie@witchery.services> * Copyright (C) 2012 Robby <robby@chatbelgie.be> * Copyright (C) 2012 ChrisTX <xpipe@hotmail.de> * Copyright (C) 2009-2010 Daniel De Graaf <danieldg@inspircd.org> * Copyright (C) 2008 Thomas Stagner <aquanight@gmail.com> * Copyright (C) 2007, 2009-2010 Robin Burchell <robin+git@viroteck.net> * Copyright (C) 2007 Dennis Friis <peavey@inspircd.org> * Copyright (C) 2006-2008 Craig Edwards <brain@inspircd.org> * Copyright (C) 2006 Oliver Lupton <om@inspircd.org> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include <filesystem> #ifndef _WIN32 # include <unistd.h> #endif #include "inspircd.h" #include "configparser.h" #include "utility/string.h" ServerConfig::ReadResult::ReadResult(const std::string& c, const std::string& e) : contents(c) , error(e) { } ServerConfig::ServerLimits::ServerLimits(const std::shared_ptr<ConfigTag>& tag) : MaxLine(tag->getNum<size_t>("maxline", 512, 512)) , MaxNick(tag->getNum<size_t>("maxnick", 30, 1, MaxLine)) , MaxChannel(tag->getNum<size_t>("maxchan", 60, 1, MaxLine)) , MaxModes(tag->getNum<size_t>("maxmodes", 20, 1)) , MaxUser(tag->getNum<size_t>("maxuser", tag->getNum<size_t>("maxident", 10, 1, MaxLine), 1, MaxLine)) , MaxQuit(tag->getNum<size_t>("maxquit", 300, 0, MaxLine)) , MaxTopic(tag->getNum<size_t>("maxtopic", 330, 1, MaxLine)) , MaxKick(tag->getNum<size_t>("maxkick", 300, 1, MaxLine)) , MaxReal(tag->getNum<size_t>("maxreal", 130, 1, MaxLine)) , MaxAway(tag->getNum<size_t>("maxaway", 200, 1, MaxLine)) , MaxHost(tag->getNum<size_t>("maxhost", 64, 1, MaxLine)) { } ServerConfig::ServerPaths::ServerPaths(const std::shared_ptr<ConfigTag>& tag) : Config(tag->getString("configdir", INSPIRCD_CONFIG_PATH, 1)) , Data(tag->getString("datadir", INSPIRCD_DATA_PATH, 1)) , Log(tag->getString("logdir", INSPIRCD_LOG_PATH, 1)) , Module(tag->getString("moduledir", INSPIRCD_MODULE_PATH, 1)) , Runtime(tag->getString("runtimedir", INSPIRCD_RUNTIME_PATH, 1)) { } std::string ServerConfig::ServerPaths::ExpandPath(const std::string& base, const std::string& fragment) { // The fragment is an absolute path, don't modify it. if (std::filesystem::path(fragment).is_absolute()) return fragment; if (!fragment.compare(0, 2, "~/", 2)) { // The fragment is relative to a home directory, expand that. const auto* homedir = getenv("HOME"); if (homedir && *homedir) return INSP_FORMAT("{}/{}", homedir, fragment.substr(2)); } if (std::filesystem::path(base).is_relative()) { // The base is relative to the working directory, expand that. const auto cwd = std::filesystem::current_path(); if (!cwd.empty()) return INSP_FORMAT("{}/{}/{}", cwd.string(), base, fragment); } return INSP_FORMAT("{}/{}", base, fragment); } ServerConfig::ServerConfig() : EmptyTag(std::make_shared<ConfigTag>("empty", FilePosition("<auto>", 0, 0))) , Limits(EmptyTag) , Paths(EmptyTag) { } ServerConfig::ReadResult ServerConfig::ReadFile(const std::string& file, time_t mincache) { auto contents = filecontents.find(file); if (contents != filecontents.end()) { if (!mincache || contents->second.second >= mincache) return ReadResult(contents->second.first, {}); filecontents.erase(contents); } bool executable = false; std::string name = file; std::string path = file; // If the caller specified a short name (e.g. <file motd="motd.txt">) then look it up. auto source = filesources.find(file); if (source != filesources.end()) { name = source->first; path = source->second.first; executable = source->second.second; } // Try to open the file and error out if it fails. auto fh = ParseStack::DoOpenFile(path, executable); if (!fh) return ReadResult({}, strerror(errno)); std::stringstream datastream; char databuf[4096]; while (fgets(databuf, sizeof(databuf), fh.get())) { size_t len = strlen(databuf); if (len) datastream.write(databuf, len); } filecontents[name] = { datastream.str(), ServerInstance->Time() }; return ReadResult(filecontents[name].first, {}); } void ServerConfig::CrossCheckOperBlocks() { std::unordered_map<std::string, std::shared_ptr<ConfigTag>> operclass; for (const auto& [_, tag] : ConfTags("class")) { const std::string name = tag->getString("name"); if (name.empty()) throw CoreException("<class:name> missing from tag at " + tag->source.str()); if (!operclass.emplace(name, tag).second) throw CoreException("Duplicate class block with name " + name + " at " + tag->source.str()); } for (const auto& [_, tag] : ConfTags("type")) { const std::string name = tag->getString("name"); if (name.empty()) throw CoreException("<type:name> is missing from tag at " + tag->source.str()); auto type = std::make_shared<OperType>(name, nullptr); // Copy the settings from the oper class. irc::spacesepstream classlist(tag->getString("classes")); for (std::string classname; classlist.GetToken(classname); ) { auto klass = operclass.find(classname); if (klass == operclass.end()) throw CoreException("Oper type " + name + " has missing class " + classname + " at " + tag->source.str()); // Apply the settings from the class. type->Configure(klass->second, false); } // Once the classes have been applied we can apply this. type->Configure(tag, true); if (!OperTypes.emplace(name, type).second) throw CoreException("Duplicate type block with name " + name + " at " + tag->source.str()); } for (const auto& [_, tag] : ConfTags("oper")) { const auto name = tag->getString("name"); if (name.empty()) throw CoreException("<oper:name> missing from tag at " + tag->source.str()); const auto typestr = tag->getString("type"); if (typestr.empty()) throw CoreException("<oper:type> missing from tag at " + tag->source.str()); if (tag->getString("password").empty() && !tag->getBool("nopassword")) throw CoreException("<oper:password> missing from tag at " + tag->source.str()); const auto type = OperTypes.find(typestr); if (type == OperTypes.end()) throw CoreException("Oper block " + name + " has missing type " + typestr + " at " + tag->source.str()); auto account = std::make_shared<OperAccount>(name, type->second, tag); if (!OperAccounts.emplace(name, account).second) throw CoreException("Duplicate oper block with name " + name + " at " + tag->source.str()); } } void ServerConfig::CrossCheckConnectBlocks(ServerConfig* current) { typedef std::map<std::pair<std::string, ConnectClass::Type>, std::shared_ptr<ConnectClass>> ClassMap; ClassMap oldBlocksByMask; if (current) { for (const auto& c : current->Classes) { switch (c->type) { case ConnectClass::ALLOW: case ConnectClass::DENY: oldBlocksByMask[std::make_pair(insp::join(c->GetHosts()), c->type)] = c; break; case ConnectClass::NAMED: oldBlocksByMask[std::make_pair(c->GetName(), c->type)] = c; break; } } } size_t blk_count = config_data.count("connect"); if (blk_count == 0) { // No connect blocks found; make a trivial default block auto tag = std::make_shared<ConfigTag>("connect", FilePosition("<auto>", 0, 0)); tag->GetItems()["allow"] = "*"; config_data.emplace("connect", tag); blk_count = 1; } Classes.resize(blk_count); std::map<std::string, size_t> names; bool try_again = true; for(size_t tries = 0; try_again; tries++) { try_again = false; size_t i = 0; for (const auto& [_, tag] : ConfTags("connect")) { if (Classes[i]) { i++; continue; } std::shared_ptr<ConnectClass> parent; std::string parentName = tag->getString("parent"); if (!parentName.empty()) { std::map<std::string, size_t>::const_iterator parentIter = names.find(parentName); if (parentIter == names.end()) { try_again = true; // couldn't find parent this time. If it's the last time, we'll never find it. if (tries >= blk_count) throw CoreException("Could not find parent connect class \"" + parentName + "\" for connect block at " + tag->source.str()); i++; continue; } parent = Classes[parentIter->second]; } std::string name = tag->getString("name"); std::string mask; ConnectClass::Type type; if (tag->readString("allow", mask, false) && !mask.empty()) type = ConnectClass::ALLOW; else if (tag->readString("deny", mask, false) && !mask.empty()) type = ConnectClass::DENY; else if (!name.empty()) type = ConnectClass::NAMED; else throw CoreException("Connect class must have allow, deny, or name specified at " + tag->source.str()); if (name.empty()) name = INSP_FORMAT("unnamed-{}", i); if (names.find(name) != names.end()) throw CoreException("Two connect classes with name \"" + name + "\" defined!"); names[name] = i; std::vector<std::string> masks; irc::spacesepstream maskstream(mask); for (std::string maskentry; maskstream.GetToken(maskentry); ) masks.push_back(maskentry); auto me = parent ? std::make_shared<ConnectClass>(tag, type, masks, parent) : std::make_shared<ConnectClass>(tag, type, masks); me->Configure(name, tag); ClassMap::iterator oldMask = oldBlocksByMask.find(std::make_pair(mask, me->type)); if (oldMask != oldBlocksByMask.end()) { std::shared_ptr<ConnectClass> old = oldMask->second; oldBlocksByMask.erase(oldMask); old->Update(me); me = old; } Classes[i] = me; i++; } } } namespace { // Attempts to find something to use as a default server hostname. std::string GetServerHost() { char hostname[256]; if (gethostname(hostname, sizeof(hostname)) == 0) { std::string name(hostname); if (name.find('.') == std::string::npos) name.append(".local"); if (name.length() <= ServerInstance->Config->Limits.MaxHost && InspIRCd::IsFQDN(name)) return name; } return "irc.example.com"; } // Checks whether the system can create IPv6 sockets. bool CanCreateIPv6Socket() { int fd = socket(AF_INET6, SOCK_STREAM, 0); if (fd < 0) return false; SocketEngine::Close(fd); return true; } } void ServerConfig::Fill() { // Read the <server> config. const auto& server = ConfValue("server"); if (ServerId.empty()) { ServerName = server->getString("name", GetServerHost(), InspIRCd::IsFQDN); ServerId = server->getString("id"); if (!ServerId.empty() && !InspIRCd::IsSID(ServerId)) throw CoreException(ServerId + " is not a valid server ID. A server ID must be 3 characters long, with the first character a digit and the next two characters a digit or letter."); } else { if (server->getString("name", ServerName, 1) != ServerName) throw CoreException("You must restart to change the server name!"); if (server->getString("id", ServerId, 1) != ServerId) throw CoreException("You must restart to change the server id!"); } ServerDesc = server->getString("description", ServerName, 1); Network = server->getString("network", ServerName, 1); // Read the <options> config. const auto& options = ConfValue("options"); DefaultModes = options->getString("defaultmodes", "not"); MaskInList = options->getBool("maskinlist"); MaskInTopic = options->getBool("maskintopic", options->getBool("hostintopic")); NoSnoticeStack = options->getBool("nosnoticestack"); SyntaxHints = options->getBool("syntaxhints"); XLineMessage = options->getString("xlinemessage", "You're banned!", 1); XLineQuit = options->getString("xlinequit", "%fulltype%: %reason%", 1); RestrictBannedUsers = options->getEnum("restrictbannedusers", ServerConfig::BUT_RESTRICT_NOTIFY, { { "no", ServerConfig::BUT_NORMAL }, { "silent", ServerConfig::BUT_RESTRICT_SILENT }, { "yes", ServerConfig::BUT_RESTRICT_NOTIFY }, }); WildcardIPv6 = options->getEnum("defaultbind", CanCreateIPv6Socket(), { { "auto", CanCreateIPv6Socket() }, { "ipv4", false }, { "ipv6", true }, }); // Read the <performance> config. const auto& performance = ConfValue("performance"); MaxConn = performance->getNum<int>("somaxconn", SOMAXCONN, 1); NetBufferSize = performance->getNum<size_t>("netbuffersize", 10240, 1024, 65534); SoftLimit = performance->getNum<size_t>("softlimit", (SocketEngine::GetMaxFds() > 0 ? SocketEngine::GetMaxFds() : SIZE_MAX), 10); TimeSkipWarn = performance->getDuration("timeskipwarn", 2, 0, 30); // Read the <security> config. const auto& security = ConfValue("security"); CustomVersion = security->getString("customversion"); HideServer = security->getString("hideserver", {}, InspIRCd::IsFQDN); MaxTargets = security->getNum<size_t>("maxtargets", 5, 1, 50); XLineQuitPublic = security->getString("publicxlinequit", security->getBool("hidebans") ? "%fulltype%" : ""); // Read the <cidr> config. const auto& cidr = ConfValue("cidr"); IPv4Range = cidr->getNum<unsigned char>("ipv4clone", 32, 1, 32); IPv6Range = cidr->getNum<unsigned char>("ipv6clone", 128, 1, 128); // Read any left over config tags. Limits = ServerLimits(ConfValue("limits")); Paths = ServerPaths(ConfValue("path")); } // WARNING: it is not safe to use most of the codebase in this function, as it // will run in the config reader thread void ServerConfig::Read() { /* Load and parse the config file, if there are any errors then explode */ ParseStack stack(this); try { valid = stack.ParseFile(ServerInstance->ConfigFileName, 0); } catch (const CoreException& err) { valid = false; errstr << err.GetReason() << std::endl; } } void ServerConfig::Apply(ServerConfig* old, const std::string& useruid) { valid = true; if (old) { /* * These values can only be set on boot. Keep their old values. Do it before we send messages so we actually have a servername. */ this->CaseMapping = old->CaseMapping; this->CommandLine = old->CommandLine; this->ServerId = old->ServerId; this->ServerName = old->ServerName; } /* The stuff in here may throw CoreException, be sure we're in a position to catch it. */ try { // Ensure the user has actually edited ther config. auto dietags = ConfTags("die"); if (!dietags.empty()) { errstr << "Your configuration has not been edited correctly!" << std::endl; for (const auto& [_, tag] : dietags) { const std::string reason = tag->getString("reason", "You left a <die> tag in your config", 1); errstr << reason << " (at " << tag->source.str() << ")" << std::endl; } } // Reject the broken configs that outdated tutorials keep pushing. if (!ConfValue("power")->getString("pause").empty()) { errstr << "You appear to be using a config file from an ancient outdated tutorial!" << std::endl << "This will almost certainly not work. You should instead create a config" << std::endl << "file using the examples shipped with InspIRCd or by referring to the" << std::endl << "docs available at " INSPIRCD_DOCS "configuration." << std::endl; } Fill(); // Handle special items CrossCheckOperBlocks(); CrossCheckConnectBlocks(old); } catch (const CoreException& ce) { errstr << ce.GetReason() << std::endl; } // Check errors before dealing with failed binds, since continuing on failed bind is wanted in some circumstances. valid = errstr.str().empty(); auto binds = ConfTags("bind"); if (binds.empty()) errstr << "Possible configuration error: you have not defined any <bind> blocks." << std::endl << "You will need to do this if you want clients to be able to connect!" << std::endl; if (old && valid) { // On first run, ports are bound later on FailedPortList pl; ServerInstance->BindPorts(pl); if (!pl.empty()) { errstr << "Warning! Some of your listener" << (pl.size() == 1 ? "s" : "") << " failed to bind:" << std::endl; for (const auto& fp : pl) { if (fp.sa.family() != AF_UNSPEC) errstr << " " << fp.sa.str() << ": "; errstr << fp.error << std::endl << " " << "Created from <bind> tag at " << fp.tag->source.str() << std::endl; } } } auto* user = ServerInstance->Users.FindUUID(useruid); if (!valid) { ServerInstance->Logs.Normal("CONFIG", "There were errors in your configuration file:"); Classes.clear(); } while (errstr.good()) { std::string line; getline(errstr, line, '\n'); if (line.empty()) continue; // On startup, print out to console (still attached at this point) if (!old) fmt::println("{}", line); // If a user is rehashing, tell them directly if (user) user->WriteRemoteNotice("*** {}", line); // Also tell opers ServerInstance->SNO.WriteGlobalSno('r', line); } errstr.clear(); errstr.str(std::string()); /* No old configuration -> initial boot, nothing more to do here */ if (!old) { if (!valid) { ServerInstance->Exit(EXIT_FAILURE); } return; } // If there were errors processing configuration, don't touch modules. if (!valid) return; ApplyModules(user); if (user) user->WriteRemoteNotice("*** Successfully rehashed server."); ServerInstance->SNO.WriteGlobalSno('r', "*** Successfully rehashed server."); } void ServerConfig::ApplyModules(User* user) const { std::vector<std::string> added_modules; ModuleManager::ModuleMap removed_modules = ServerInstance->Modules.GetModules(); for (const auto& module : GetModules()) { const std::string name = ModuleManager::ExpandModName(module); // if this module is already loaded, the erase will succeed, so we need do nothing // otherwise, we need to add the module (which will be done later) if (removed_modules.erase(name) == 0) added_modules.push_back(name); } for (const auto& [modname, mod] : removed_modules) { // Don't remove core_*, just remove m_* if (InspIRCd::Match(modname, "core_*", ascii_case_insensitive_map)) continue; if (ServerInstance->Modules.Unload(mod)) { const std::string message = INSP_FORMAT("The {} module was unloaded.", modname); if (user) user->WriteNumeric(RPL_UNLOADEDMODULE, modname, message); ServerInstance->SNO.WriteGlobalSno('r', message); } else { const std::string message = INSP_FORMAT("Failed to unload the {} module: {}", modname, ServerInstance->Modules.LastError()); if (user) user->WriteNumeric(ERR_CANTUNLOADMODULE, modname, message); ServerInstance->SNO.WriteGlobalSno('r', message); } } for (const auto& modname : added_modules) { // Skip modules which are already loaded. if (ServerInstance->Modules.Find(modname)) continue; if (ServerInstance->Modules.Load(modname)) { const std::string message = INSP_FORMAT("The {} module was loaded.", modname); if (user) user->WriteNumeric(RPL_LOADEDMODULE, modname, message); ServerInstance->SNO.WriteGlobalSno('r', message); } else { const std::string message = INSP_FORMAT("Failed to load the {} module: {}", modname, ServerInstance->Modules.LastError()); if (user) user->WriteNumeric(ERR_CANTLOADMODULE, modname, message); ServerInstance->SNO.WriteGlobalSno('r', message); } } } const std::shared_ptr<ConfigTag>& ServerConfig::ConfValue(const std::string& tag, const std::shared_ptr<ConfigTag>& def) const { auto tags = insp::equal_range(config_data, tag); if (tags.empty()) return def ? def : EmptyTag; if (tags.count() > 1) { ServerInstance->Logs.Warning("CONFIG", "Multiple ({}) <{}> tags found; only the first will be used (first at {}, last at {})", tags.count(), tag, tags.begin()->second->source.str(), std::prev(tags.end())->second->source.str()); } return tags.begin()->second; } ServerConfig::TagList ServerConfig::ConfTags(const std::string& tag, std::optional<TagList> def) const { auto range = insp::equal_range(config_data, tag); return range.empty() && def ? *def : range; } std::string ServerConfig::Escape(const std::string& str) { std::stringstream escaped; for (const auto chr : str) { switch (chr) { case '"': escaped << "&quot;"; break; case '&': escaped << "&amp;"; break; default: escaped << chr; break; } } return escaped.str(); } std::vector<std::string> ServerConfig::GetModules() const { auto tags = ConfTags("module"); std::vector<std::string> modules; modules.reserve(tags.count()); for (const auto& [_, tag] : tags) { const std::string shortname = ModuleManager::ShrinkModName(tag->getString("name")); if (shortname.empty()) { ServerInstance->Logs.Warning("CONFIG", "Malformed <module> tag at " + tag->source.str() + "; skipping ..."); continue; } // Rewrite the old names of renamed modules. if (insp::equalsci(shortname, "cgiirc")) modules.push_back("gateway"); else if (insp::equalsci(shortname, "cloaking")) { modules.push_back("cloak"); modules.push_back("cloak_md5"); } else if (insp::equalsci(shortname, "gecosban")) modules.push_back("realnameban"); else if (insp::equalsci(shortname, "helpop")) { modules.push_back("help"); modules.push_back("helpmode"); } else if (insp::equalsci(shortname, "mlock")) modules.push_back("services"); else if (insp::equalsci(shortname, "namesx")) modules.push_back("multiprefix"); else if (insp::equalsci(shortname, "regex_pcre")) modules.push_back("regex_pcre2"); else if (insp::equalsci(shortname, "sha256")) modules.push_back("sha2"); else if (insp::equalsci(shortname, "services_account")) { modules.push_back("account"); modules.push_back("services"); } else if (insp::equalsci(shortname, "servprotect")) modules.push_back("services"); else if (insp::equalsci(shortname, "svshold")) modules.push_back("services"); else if (insp::equalsci(shortname, "topiclock")) modules.push_back("services"); else { // No need to rewrite this module name. modules.push_back(shortname); } } return modules; } void ConfigReaderThread::OnStart() { Config->Read(); done = true; } void ConfigReaderThread::OnStop() { ServerConfig* old = ServerInstance->Config; ServerInstance->Logs.Normal("CONFIG", "Switching to new configuration..."); ServerInstance->Config = this->Config; Config->Apply(old, UUID); if (Config->valid) { /* * Apply the changed configuration from the rehash. * * XXX: The order of these is IMPORTANT, do not reorder them without testing * thoroughly!!! */ ServerInstance->Users.RehashCloneCounts(); auto* user = ServerInstance->Users.FindUUID(UUID); ConfigStatus status(user); for (const auto& [modname, mod] : ServerInstance->Modules.GetModules()) { try { ServerInstance->Logs.Debug("MODULE", "Rehashing {}", modname); mod->ReadConfig(status); } catch (const CoreException& modex) { ServerInstance->Logs.Critical("MODULE", "Unable to read the configuration for {}: {}", mod->ModuleFile, modex.what()); if (user) user->WriteNotice(modname + ": " + modex.GetReason()); } } // The description of this server may have changed - update it for WHOIS etc. ServerInstance->FakeClient->server->description = Config->ServerDesc; ServerInstance->Users.RehashServices(); try { ServerInstance->Logs.CloseLogs(); ServerInstance->Logs.OpenLogs(true); } catch (const CoreException& ex) { ServerInstance->Logs.Critical("LOG", "Cannot open log files: " + ex.GetReason()); if (user) user->WriteNotice("Cannot open log files: " + ex.GetReason()); } if (Config->RawLog && !old->RawLog) { for (auto* luser : ServerInstance->Users.GetLocalUsers()) Log::NotifyRawIO(luser, MessageType::PRIVMSG); } Config = old; } else { // whoops, abort! ServerInstance->Config = old; } } ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/src/coremods/������������������������������������������������������������������������0000775�0000000�0000000�00000000000�14771603147�0015751�5����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/src/coremods/core_channel/�����������������������������������������������������������0000775�0000000�0000000�00000000000�14771603147�0020371�5����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/src/coremods/core_channel/cmd_invite.cpp���������������������������������������������0000664�0000000�0000000�00000013341�14771603147�0023220�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2018, 2020-2024 Sadie Powell <sadie@witchery.services> * Copyright (C) 2018 linuxdaemon <linuxdaemon.irc@gmail.com> * Copyright (C) 2017 B00mX0r <b00mx0r@aureus.pw> * Copyright (C) 2013-2016, 2018 Attila Molnar <attilamolnar@hush.com> * Copyright (C) 2012 Robby <robby@chatbelgie.be> * Copyright (C) 2009-2010 Daniel De Graaf <danieldg@inspircd.org> * Copyright (C) 2008 Thomas Stagner <aquanight@gmail.com> * Copyright (C) 2008 Robin Burchell <robin+git@viroteck.net> * Copyright (C) 2007 Dennis Friis <peavey@inspircd.org> * Copyright (C) 2005-2008 Craig Edwards <brain@inspircd.org> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include "inspircd.h" #include "clientprotocolmsg.h" #include "numerichelper.h" #include "timeutils.h" #include "core_channel.h" #include "invite.h" enum { // From RFC 1459. RPL_INVITING = 341, ERR_USERONCHANNEL = 443, // From ircd-hybrid. RPL_INVITELIST = 336, RPL_ENDOFINVITELIST = 337 }; CommandInvite::CommandInvite(Module* parent, Invite::APIImpl& invapiimpl) : Command(parent, "INVITE") , invapi(invapiimpl) { penalty = 4000; syntax = { "[<nick> <channel> [<time>]]" }; } CmdResult CommandInvite::Handle(User* user, const Params& parameters) { ModResult modres; if (parameters.size() >= 2) { User* u; if (IS_LOCAL(user)) u = ServerInstance->Users.FindNick(parameters[0], true); else u = ServerInstance->Users.Find(parameters[0], true); auto* c = ServerInstance->Channels.Find(parameters[1]); time_t timeout = 0; if (parameters.size() >= 3) { if (IS_LOCAL(user)) { unsigned long duration; if (!Duration::TryFrom(parameters[2], duration)) { user->WriteNotice("*** Invalid duration for invite"); return CmdResult::FAILURE; } timeout = ServerInstance->Time() + duration; } else if (parameters.size() > 3) timeout = ConvToNum<time_t>(parameters[3]); } if (!c) { user->WriteNumeric(Numerics::NoSuchChannel(parameters[1])); return CmdResult::FAILURE; } if (!u) { user->WriteNumeric(Numerics::NoSuchNick(parameters[0])); return CmdResult::FAILURE; } // Verify channel timestamp if the INVITE is coming from a remote server if (!IS_LOCAL(user)) { // Remote INVITE commands must carry a channel timestamp if (parameters.size() < 3) return CmdResult::INVALID; // Drop the invite if our channel TS is lower time_t RemoteTS = ConvToNum<time_t>(parameters[2]); if (c->age < RemoteTS) return CmdResult::FAILURE; } if ((IS_LOCAL(user)) && (!c->HasUser(user))) { user->WriteNumeric(ERR_NOTONCHANNEL, c->name, "You're not on that channel!"); return CmdResult::FAILURE; } if (c->HasUser(u)) { user->WriteNumeric(ERR_USERONCHANNEL, u->nick, c->name, "is already on channel"); return CmdResult::FAILURE; } FIRST_MOD_RESULT(OnUserPreInvite, modres, (user, u, c, timeout)); if (modres == MOD_RES_DENY) { return CmdResult::FAILURE; } else if (modres == MOD_RES_PASSTHRU) { if (IS_LOCAL(user)) { ModeHandler::Rank rank = c->GetPrefixValue(user); if (rank < HALFOP_VALUE) { user->WriteNumeric(Numerics::ChannelPrivilegesNeeded(c, HALFOP_VALUE, "send an invite")); return CmdResult::FAILURE; } } } LocalUser* const localtargetuser = IS_LOCAL(u); if (localtargetuser) { invapi.Create(localtargetuser, c, timeout); ClientProtocol::Messages::Invite invitemsg(user, localtargetuser, c); localtargetuser->Send(ServerInstance->GetRFCEvents().invite, invitemsg); } if (IS_LOCAL(user)) { user->WriteNumeric(RPL_INVITING, u->nick, c->name); if (u->IsAway()) user->WriteNumeric(RPL_AWAY, u->nick, u->away->message); } char prefix = 0; ModeHandler::Rank minrank = 0; switch (invapi.announceinvites) { case Invite::ANNOUNCE_OPS: { prefix = '@'; minrank = OP_VALUE; break; } case Invite::ANNOUNCE_DYNAMIC: { PrefixMode* mh = ServerInstance->Modes.FindNearestPrefixMode(HALFOP_VALUE); if (mh) { prefix = mh->GetPrefix(); minrank = mh->GetPrefixRank(); } else { prefix = '@'; minrank = OP_VALUE; } break; } default: break; } CUList excepts; FOREACH_MOD(OnUserInvite, (user, u, c, timeout, minrank, excepts)); if (invapi.announceinvites != Invite::ANNOUNCE_NONE) { excepts.insert(user); ClientProtocol::Messages::Privmsg privmsg(ServerInstance->FakeClient, c, INSP_FORMAT("*** {} invited {} into the channel", user->nick, u->nick), MessageType::NOTICE); c->Write(ServerInstance->GetRFCEvents().privmsg, privmsg, prefix, excepts); } } else if (IS_LOCAL(user)) { // pinched from ircu - invite with not enough parameters shows channels // youve been invited to but haven't joined yet. const Invite::List* list = invapi.GetList(IS_LOCAL(user)); if (list) { for (const auto* invite : *list) user->WriteNumeric(RPL_INVITELIST, invite->chan->name); } user->WriteNumeric(RPL_ENDOFINVITELIST, "End of INVITE list"); } return CmdResult::SUCCESS; } RouteDescriptor CommandInvite::GetRouting(User* user, const Params& parameters) { return (IS_LOCAL(user) ? ROUTE_LOCALONLY : ROUTE_BROADCAST); } �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/src/coremods/core_channel/cmd_join.cpp�����������������������������������������������0000664�0000000�0000000�00000003701�14771603147�0022660�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2018, 2020, 2022 Sadie Powell <sadie@witchery.services> * Copyright (C) 2017 B00mX0r <b00mx0r@aureus.pw> * Copyright (C) 2013-2014 Attila Molnar <attilamolnar@hush.com> * Copyright (C) 2012 Robby <robby@chatbelgie.be> * Copyright (C) 2009-2010 Daniel De Graaf <danieldg@inspircd.org> * Copyright (C) 2006, 2008 Craig Edwards <brain@inspircd.org> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include "inspircd.h" #include "core_channel.h" CommandJoin::CommandJoin(Module* parent) : SplitCommand(parent, "JOIN", 1, 2) { penalty = 2000; syntax = { "<channel>[,<channel>]+ [<key>[,<key>]+]" }; } CmdResult CommandJoin::HandleLocal(LocalUser* user, const Params& parameters) { if (parameters.size() > 1) { if (CommandParser::LoopCall(user, this, parameters, 0, 1, false)) return CmdResult::SUCCESS; if (ServerInstance->Channels.IsChannel(parameters[0])) { Channel::JoinUser(user, parameters[0], false, parameters[1]); return CmdResult::SUCCESS; } } else { if (CommandParser::LoopCall(user, this, parameters, 0, -1, false)) return CmdResult::SUCCESS; if (ServerInstance->Channels.IsChannel(parameters[0])) { Channel::JoinUser(user, parameters[0]); return CmdResult::SUCCESS; } } user->WriteNumeric(ERR_BADCHANMASK, parameters[0], "Invalid channel name"); return CmdResult::FAILURE; } ���������������������������������������������������������������inspircd-4.7.0/src/coremods/core_channel/cmd_kick.cpp�����������������������������������������������0000664�0000000�0000000�00000010020�14771603147�0022632�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2017-2018, 2020, 2022-2023, 2025 Sadie Powell <sadie@witchery.services> * Copyright (C) 2017 B00mX0r <b00mx0r@aureus.pw> * Copyright (C) 2013-2014, 2016 Attila Molnar <attilamolnar@hush.com> * Copyright (C) 2012 Robby <robby@chatbelgie.be> * Copyright (C) 2009-2010 Daniel De Graaf <danieldg@inspircd.org> * Copyright (C) 2008 Thomas Stagner <aquanight@gmail.com> * Copyright (C) 2007-2008 Dennis Friis <peavey@inspircd.org> * Copyright (C) 2006 Craig Edwards <brain@inspircd.org> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include "inspircd.h" #include "numerichelper.h" #include "core_channel.h" CommandKick::CommandKick(Module* parent) : Command(parent, "KICK", 2, 3) { allow_empty_last_param = true; syntax = { "<channel> <nick>[,<nick>]+ [:<reason>]" }; } CmdResult CommandKick::Handle(User* user, const Params& parameters) { auto* c = ServerInstance->Channels.Find(parameters[0]); User* u; if (CommandParser::LoopCall(user, this, parameters, 1)) return CmdResult::SUCCESS; if (IS_LOCAL(user)) u = ServerInstance->Users.FindNick(parameters[1], true); else u = ServerInstance->Users.Find(parameters[1], true); if (!c) { user->WriteNumeric(Numerics::NoSuchChannel(parameters[0])); return CmdResult::FAILURE; } if (!u) { user->WriteNumeric(Numerics::NoSuchNick(parameters[1])); return CmdResult::FAILURE; } Membership* srcmemb = nullptr; if (IS_LOCAL(user)) { srcmemb = c->GetUser(user); if (!srcmemb) { user->WriteNumeric(ERR_NOTONCHANNEL, parameters[0], "You're not on that channel!"); return CmdResult::FAILURE; } } const Channel::MemberMap::iterator victimiter = c->userlist.find(u); if (victimiter == c->userlist.end()) { user->WriteNumeric(ERR_USERNOTINCHANNEL, u->nick, c->name, "They are not on that channel"); return CmdResult::FAILURE; } Membership* const memb = victimiter->second; // KICKs coming from servers can carry a membership id if ((!IS_LOCAL(user)) && (parameters.size() > 3)) { // If the current membership id is not equal to the one in the message then the user rejoined if (memb->id != Membership::IdFromString(parameters[2])) { ServerInstance->Logs.Debug(MODNAME, "Dropped KICK due to membership id mismatch: {} != {}", memb->id, parameters[2]); return CmdResult::FAILURE; } } const bool has_reason = (parameters.size() > 2); const std::string reason((has_reason ? parameters.back() : user->nick), 0, ServerInstance->Config->Limits.MaxKick); // Do the following checks only if the KICK is done by a local user; // each server enforces its own rules. if (srcmemb) { // Modules are allowed to explicitly allow or deny kicks done by local users ModResult res; FIRST_MOD_RESULT(OnUserPreKick, res, (user, memb, reason)); if (res == MOD_RES_DENY) return CmdResult::FAILURE; if (res == MOD_RES_PASSTHRU) { ModeHandler::Rank them = srcmemb->GetRank(); ModeHandler::Rank req = HALFOP_VALUE; for (const auto* mh : memb->modes) { if (mh->GetLevelRequired(true) > req) req = mh->GetLevelRequired(true); } if (them < req) { user->WriteNumeric(Numerics::ChannelPrivilegesNeeded(memb->chan, req, "kick a more privileged user")); return CmdResult::FAILURE; } } } c->KickUser(user, victimiter, reason); return CmdResult::SUCCESS; } RouteDescriptor CommandKick::GetRouting(User* user, const Params& parameters) { return (IS_LOCAL(user) ? ROUTE_LOCALONLY : ROUTE_BROADCAST); } ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/src/coremods/core_channel/cmd_names.cpp����������������������������������������������0000664�0000000�0000000�00000007314�14771603147�0023030�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2021 Val Lorentz <progval+git@progval.net> * Copyright (C) 2018-2022 Sadie Powell <sadie@witchery.services> * Copyright (C) 2018 Dylan Frank <b00mx0r@aureus.pw> * Copyright (C) 2013-2016 Attila Molnar <attilamolnar@hush.com> * Copyright (C) 2012 Robby <robby@chatbelgie.be> * Copyright (C) 2009 Daniel De Graaf <danieldg@inspircd.org> * Copyright (C) 2007 Robin Burchell <robin+git@viroteck.net> * Copyright (C) 2007 Dennis Friis <peavey@inspircd.org> * Copyright (C) 2006, 2008 Craig Edwards <brain@inspircd.org> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include "inspircd.h" #include "modules/names.h" #include "numericbuilder.h" #include "core_channel.h" enum { // From RFC 1459. RPL_NAMREPLY = 353, RPL_ENDOFNAMES = 366, }; CommandNames::CommandNames(Module* parent) : SplitCommand(parent, "NAMES") , secretmode(parent, "secret") , privatemode(parent, "private") , invisiblemode(parent, "invisible") , namesevprov(parent, "event/names") { syntax = { "[<channel>[,<channel>]+]" }; } CmdResult CommandNames::HandleLocal(LocalUser* user, const Params& parameters) { Channel* c; if (parameters.empty()) { user->WriteNumeric(RPL_ENDOFNAMES, '*', "End of /NAMES list."); return CmdResult::SUCCESS; } if (CommandParser::LoopCall(user, this, parameters, 0)) return CmdResult::SUCCESS; c = ServerInstance->Channels.Find(parameters[0]); if (c) { // Show the NAMES list if one of the following is true: // - the channel is not secret // - the user doing the /NAMES is inside the channel // - the user doing the /NAMES has the channels/auspex privilege // If the user is inside the channel or has privs, instruct SendNames() to show invisible (+i) members bool show_invisible = ((c->HasUser(user)) || (user->HasPrivPermission("channels/auspex"))); if ((show_invisible) || (!c->IsModeSet(secretmode))) { SendNames(user, c, show_invisible); return CmdResult::SUCCESS; } } user->WriteNumeric(RPL_ENDOFNAMES, parameters[0], "End of /NAMES list."); return CmdResult::FAILURE; } void CommandNames::SendNames(LocalUser* user, Channel* chan, bool show_invisible) { Numeric::Builder<' '> reply(user, RPL_NAMREPLY, false, chan->name.size() + 3); Numeric::Numeric& numeric = reply.GetNumeric(); if (chan->IsModeSet(secretmode)) numeric.push(std::string(1, '@')); else if (chan->IsModeSet(privatemode)) numeric.push(std::string(1, '*')); else numeric.push(std::string(1, '=')); numeric.push(chan->name); numeric.push(std::string()); std::string prefixlist; std::string nick; for (const auto& [u, memb] : chan->GetUsers()) { if ((!show_invisible) && (u->IsModeSet(invisiblemode))) { // Member is invisible and we are not supposed to show them continue; } prefixlist.clear(); char prefix = memb->GetPrefixChar(); if (prefix) prefixlist.push_back(prefix); nick = u->nick; ModResult res = namesevprov.FirstResult(&Names::EventListener::OnNamesListItem, user, memb, prefixlist, nick); if (res != MOD_RES_DENY) reply.Add(prefixlist, nick); } reply.Flush(); user->WriteNumeric(RPL_ENDOFNAMES, chan->name, "End of /NAMES list."); } ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/src/coremods/core_channel/cmd_topic.cpp����������������������������������������������0000664�0000000�0000000�00000006757�14771603147�0023055�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2019 Matt Schatz <genius3000@g3k.solutions> * Copyright (C) 2017-2018, 2020-2024 Sadie Powell <sadie@witchery.services> * Copyright (C) 2017 B00mX0r <b00mx0r@aureus.pw> * Copyright (C) 2013-2016 Attila Molnar <attilamolnar@hush.com> * Copyright (C) 2012 Robby <robby@chatbelgie.be> * Copyright (C) 2009 Daniel De Graaf <danieldg@inspircd.org> * Copyright (C) 2008 Robin Burchell <robin+git@viroteck.net> * Copyright (C) 2007 Dennis Friis <peavey@inspircd.org> * Copyright (C) 2006 Craig Edwards <brain@inspircd.org> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include "inspircd.h" #include "numerichelper.h" #include "core_channel.h" enum { // From RFC 1459. RPL_NOTOPICSET = 331, RPL_TOPIC = 332, // From ircu. RPL_TOPICTIME = 333, }; CommandTopic::CommandTopic(Module* parent) : SplitCommand(parent, "TOPIC", 1, 2) , exemptionprov(parent) , secretmode(parent, "secret") , topiclockmode(parent, "topiclock") { allow_empty_last_param = true; penalty = 2000; syntax = { "<channel> [:<topic>]" }; } CmdResult CommandTopic::HandleLocal(LocalUser* user, const Params& parameters) { auto* c = ServerInstance->Channels.Find(parameters[0]); if (!c) { user->WriteNumeric(Numerics::NoSuchChannel(parameters[0])); return CmdResult::FAILURE; } if (parameters.size() == 1) { if ((c->IsModeSet(secretmode)) && (!c->HasUser(user) && !user->HasPrivPermission("channels/auspex"))) { user->WriteNumeric(Numerics::NoSuchChannel(c->name)); return CmdResult::FAILURE; } if (c->topic.length()) { Topic::ShowTopic(user, c); } else { user->WriteNumeric(RPL_NOTOPICSET, c->name, "No topic is set."); } return CmdResult::SUCCESS; } std::string t = parameters[1]; // needed, in case a module wants to change it ModResult res; FIRST_MOD_RESULT(OnPreTopicChange, res, (user, c, t)); if (res == MOD_RES_DENY) return CmdResult::FAILURE; if (res != MOD_RES_ALLOW) { if (!c->HasUser(user)) { user->WriteNumeric(ERR_NOTONCHANNEL, c->name, "You're not on that channel!"); return CmdResult::FAILURE; } if (c->IsModeSet(topiclockmode)) { ModResult modres = exemptionprov.Check(user, c, "topiclock"); if (!modres.check(c->GetPrefixValue(user) >= HALFOP_VALUE)) { user->WriteNumeric(Numerics::ChannelPrivilegesNeeded(c, HALFOP_VALUE, "change the topic")); return CmdResult::FAILURE; } } } // Make sure the topic is not longer than the limit in the config if (t.length() > ServerInstance->Config->Limits.MaxTopic) t.erase(ServerInstance->Config->Limits.MaxTopic); // Only change if the new topic is different than the current one if (c->topic != t) c->SetTopic(user, t, ServerInstance->Time()); return CmdResult::SUCCESS; } void Topic::ShowTopic(LocalUser* user, Channel* chan) { user->WriteNumeric(RPL_TOPIC, chan->name, chan->topic); user->WriteNumeric(RPL_TOPICTIME, chan->name, chan->setby, chan->topicset); } �����������������inspircd-4.7.0/src/coremods/core_channel/cmode_k.cpp������������������������������������������������0000664�0000000�0000000�00000005601�14771603147�0022500�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2017, 2019-2023 Sadie Powell <sadie@witchery.services> * Copyright (C) 2014 Attila Molnar <attilamolnar@hush.com> * Copyright (C) 2012 Robby <robby@chatbelgie.be> * Copyright (C) 2009 Uli Schlachter <psychon@znc.in> * Copyright (C) 2009 Robin Burchell <robin+git@viroteck.net> * Copyright (C) 2009 Daniel De Graaf <danieldg@inspircd.org> * Copyright (C) 2006 Craig Edwards <brain@inspircd.org> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include "inspircd.h" #include "core_channel.h" enum { // From RFC 1459. ERR_KEYSET = 467, }; ModeChannelKey::ModeChannelKey(Module* Creator) : ParamMode<ModeChannelKey, StringExtItem>(Creator, "key", 'k', PARAM_ALWAYS) { syntax = "<key>"; } bool ModeChannelKey::OnModeChange(User* source, User*, Channel* channel, Modes::Change& change) { const std::string* key = ext.Get(channel); bool exists = (key != nullptr); if (IS_LOCAL(source)) { if (exists == change.adding) return false; if (exists && (change.param != *key)) { /* Key is currently set and the correct key wasn't given */ source->WriteNumeric(ERR_KEYSET, channel->name, "Channel key already set"); return false; } } else { if (exists && change.adding && change.param == *key) { /* no-op, don't show */ return false; } } if (change.adding) { // When joining a channel multiple keys are delimited with a comma so we strip // them out here to avoid creating channels that are unjoinable. size_t commapos; while ((commapos = change.param.find(',')) != std::string::npos) change.param.erase(commapos, 1); // Truncate the parameter to the maximum key length. if (change.param.length() > maxkeylen) change.param.erase(maxkeylen); // If the password is empty here then it only consisted of commas. This is not // acceptable so we reject the mode change. if (change.param.empty()) return false; ext.Set(channel, change.param); } else ext.Unset(channel); channel->SetMode(this, change.adding); return true; } void ModeChannelKey::SerializeParam(Channel* chan, const std::string* key, std::string& out) { out += *key; } bool ModeChannelKey::OnSet(User* source, Channel* chan, std::string& param) { // Dummy function, never called return false; } bool ModeChannelKey::IsParameterSecret() { return true; } �������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/src/coremods/core_channel/core_channel.cpp�������������������������������������������0000664�0000000�0000000�00000030707�14771603147�0023524�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2019 Robby <robby@chatbelgie.be> * Copyright (C) 2018 linuxdaemon <linuxdaemon.irc@gmail.com> * Copyright (C) 2018 Dylan Frank <b00mx0r@aureus.pw> * Copyright (C) 2017-2024 Sadie Powell <sadie@witchery.services> * Copyright (C) 2014-2015, 2018 Attila Molnar <attilamolnar@hush.com> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include "inspircd.h" #include "clientprotocolevent.h" #include "listmode.h" #include "modules/isupport.h" #include "utility/string.h" #include "core_channel.h" #include "invite.h" enum { // From RFC 1459. ERR_TOOMANYCHANNELS = 405, ERR_CHANNELISFULL = 471, ERR_INVITEONLYCHAN = 473, ERR_BADCHANNELKEY = 475, }; namespace { /** Hook that sends a MODE after a JOIN if the user in the JOIN has some modes prefix set. * This happens e.g. when modules such as operprefix explicitly set prefix modes on the joining * user, or when a member with prefix modes does a host cycle. */ class JoinHook final : public ClientProtocol::EventHook { ClientProtocol::Messages::Mode modemsg; Modes::ChangeList modechangelist; const User* joininguser; public: /** If true, MODE changes after JOIN will be sourced from the user, rather than the server */ bool modefromuser; JoinHook(Module* mod) : ClientProtocol::EventHook(mod, "JOIN") { } void OnEventInit(const ClientProtocol::Event& ev) override { const ClientProtocol::Events::Join& join = static_cast<const ClientProtocol::Events::Join&>(ev); const Membership& memb = *join.GetMember(); modechangelist.clear(); for (const auto& mode : memb.modes) modechangelist.push_add(mode, memb.user->nick); if (modechangelist.empty()) { // Member got no modes on join joininguser = nullptr; return; } joininguser = memb.user; // Prepare a mode protocol event that we can append to the message list in OnPreEventSend() modemsg.SetParams(memb.chan, nullptr, modechangelist); if (modefromuser) modemsg.SetSource(join); else modemsg.SetSourceUser(ServerInstance->FakeClient); } ModResult OnPreEventSend(LocalUser* user, const ClientProtocol::Event& ev, ClientProtocol::MessageList& messagelist) override { // If joininguser is NULL then they didn't get any modes on join, skip. // Also don't show their own modes to them, they get that in the NAMES list not via MODE. if ((joininguser) && (user != joininguser)) messagelist.push_back(&modemsg); return MOD_RES_PASSTHRU; } }; } class CoreModChannel final : public Module , public CheckExemption::EventListener , public ISupport::EventListener { Invite::APIImpl invapi; CommandInvite cmdinvite; CommandJoin cmdjoin; CommandKick cmdkick; CommandNames cmdnames; CommandTopic cmdtopic; Events::ModuleEventProvider evprov; JoinHook joinhook; ModeChannelBan banmode; SimpleChannelMode inviteonlymode; ModeChannelKey keymode; ModeChannelLimit limitmode; SimpleChannelMode moderatedmode; SimpleChannelMode noextmsgmode; ModeChannelOp opmode; SimpleChannelMode privatemode; SimpleChannelMode secretmode; SimpleChannelMode topiclockmode; ModeChannelVoice voicemode; insp::flat_map<std::string, char> exemptions; ExtBanManager extbanmgr; ModResult IsInvited(User* user, Channel* chan) { LocalUser* localuser = IS_LOCAL(user); if ((localuser) && (invapi.IsInvited(localuser, chan))) return MOD_RES_ALLOW; return MOD_RES_PASSTHRU; } public: CoreModChannel() : Module(VF_CORE | VF_VENDOR, "Provides the INVITE, JOIN, KICK, NAMES, and TOPIC commands") , CheckExemption::EventListener(this, UINT_MAX) , ISupport::EventListener(this) , invapi(this) , cmdinvite(this, invapi) , cmdjoin(this) , cmdkick(this) , cmdnames(this) , cmdtopic(this) , evprov(this, "event/channel") , joinhook(this) , banmode(this) , inviteonlymode(this, "inviteonly", 'i') , keymode(this) , limitmode(this) , moderatedmode(this, "moderated", 'm') , noextmsgmode(this, "noextmsg", 'n') , opmode(this) , privatemode(this, "private", 'p') , secretmode(this, "secret", 's') , topiclockmode(this, "topiclock", 't') , voicemode(this) , extbanmgr(this, banmode) { } void ReadConfig(ConfigStatus& status) override { const auto& optionstag = ServerInstance->Config->ConfValue("options"); std::string current; irc::spacesepstream defaultstream(optionstag->getString("exemptchanops")); insp::flat_map<std::string, char> exempts; while (defaultstream.GetToken(current)) { std::string::size_type pos = current.find(':'); if (pos == std::string::npos || (pos + 2) > current.size()) throw ModuleException(this, "Invalid exemptchanops value '" + current + "' at " + optionstag->source.str()); const std::string restriction = current.substr(0, pos); const char prefix = current[pos + 1]; ServerInstance->Logs.Debug(MODNAME, "Exempting prefix {} from {}", prefix, restriction); exempts[restriction] = prefix; } ExtBan::Format newformat = optionstag->getEnum("extbanformat", ExtBan::Format::ANY, { { "any", ExtBan::Format::ANY }, { "name", ExtBan::Format::NAME }, { "letter", ExtBan::Format::LETTER }, }); const auto& securitytag = ServerInstance->Config->ConfValue("security"); Invite::AnnounceState newannouncestate = securitytag->getEnum("announceinvites", Invite::ANNOUNCE_DYNAMIC, { { "all", Invite::ANNOUNCE_ALL }, { "dynamic", Invite::ANNOUNCE_DYNAMIC }, { "none", Invite::ANNOUNCE_NONE }, { "ops", Invite::ANNOUNCE_OPS }, }); // Config is valid, apply it // Validates and applies <maxlist> tags, so do it first banmode.DoRehash(); exemptions.swap(exempts); extbanmgr.format = newformat; invapi.announceinvites = newannouncestate; joinhook.modefromuser = optionstag->getBool("cyclehostsfromuser"); Implementation events[] = { I_OnCheckKey, I_OnCheckLimit, I_OnCheckChannelBan }; if (optionstag->getBool("invitebypassmodes", true)) ServerInstance->Modules.Attach(events, this, sizeof(events)/sizeof(Implementation)); else ServerInstance->Modules.Detach(events, this, sizeof(events)/sizeof(Implementation)); const auto& limitstag = ServerInstance->Config->ConfValue("limits"); keymode.maxkeylen = limitstag->getNum<size_t>("maxkey", 32, 1, ModeParser::MODE_PARAM_MAX); } void OnBuildISupport(ISupport::TokenMap& tokens) override { tokens["KEYLEN"] = ConvToStr(keymode.maxkeylen); extbanmgr.BuildISupport(tokens["EXTBAN"]); std::vector<std::string> limits; std::string vlist; for (auto* lm : ServerInstance->Modes.GetListModes()) { limits.push_back(INSP_FORMAT("{}:{}", lm->GetModeChar(), lm->GetLowerLimit())); if (lm->HasVariableLength()) vlist.push_back(lm->GetModeChar()); } if (!vlist.empty()) tokens["VLIST"] = vlist; std::sort(limits.begin(), limits.end()); tokens["MAXLIST"] = insp::join(limits, ','); } void OnBuildClassISupport(const std::shared_ptr<ConnectClass>& klass, ISupport::TokenMap& tokens) override { tokens["CHANLIMIT"] = INSP_FORMAT("#:{}", klass->maxchans); } ModResult OnUserPreJoin(LocalUser* user, Channel* chan, const std::string& cname, std::string& privs, const std::string& keygiven, bool override) override { if (override) { // Don't enforce limits on overrides. return MOD_RES_PASSTHRU; } else { /* We don't restrict the number of channels that remote users or users that are override-joining may be in. * We restrict local users to <connect:maxchans> channels. * We restrict local operators to <oper:maxchans> channels. */ unsigned long maxchans = user->GetClass()->maxchans; if (user->IsOper()) maxchans = user->oper->GetConfig()->getNum<unsigned long>("maxchans", maxchans, maxchans); if (user->chans.size() >= maxchans) { user->WriteNumeric(ERR_TOOMANYCHANNELS, cname, "You are on too many channels"); return MOD_RES_DENY; } } if (!chan) return MOD_RES_PASSTHRU; // Can't have limits on a new channel. // Check whether the channel key is correct. const std::string ckey = chan->GetModeParameter(&keymode); if (!ckey.empty()) { ModResult modres; FIRST_MOD_RESULT(OnCheckKey, modres, (user, chan, keygiven)); if (!modres.check(InspIRCd::TimingSafeCompare(ckey, keygiven))) { // If no key provided, or key is not the right one, and can't bypass +k (not invited or option not enabled) user->WriteNumeric(ERR_BADCHANNELKEY, chan->name, "Cannot join channel (incorrect channel key)"); return MOD_RES_DENY; } } // Check whether the invite only mode is set. if (chan->IsModeSet(inviteonlymode)) { ModResult modres; FIRST_MOD_RESULT(OnCheckInvite, modres, (user, chan)); if (modres != MOD_RES_ALLOW) { user->WriteNumeric(ERR_INVITEONLYCHAN, chan->name, "Cannot join channel (invite only)"); return MOD_RES_DENY; } } // Check whether the limit would be exceeded by this user joining. if (chan->IsModeSet(limitmode)) { ModResult modres; FIRST_MOD_RESULT(OnCheckLimit, modres, (user, chan)); if (!modres.check(chan->GetUsers().size() < static_cast<size_t>(limitmode.ext.Get(chan)))) { user->WriteNumeric(ERR_CHANNELISFULL, chan->name, "Cannot join channel (channel is full)"); return MOD_RES_DENY; } } // Check whether the user is banned from joining the channel. if (chan->IsBanned(user)) { user->WriteNumeric(ERR_BANNEDFROMCHAN, chan->name, "Cannot join channel (you're banned)"); return MOD_RES_DENY; } // Everything looks okay. return MOD_RES_PASSTHRU; } void OnPostJoin(Membership* memb) override { Channel* const chan = memb->chan; LocalUser* const localuser = IS_LOCAL(memb->user); if (localuser) { // Remove existing invite, if any invapi.Remove(localuser, chan); if (chan->topic.length()) Topic::ShowTopic(localuser, chan); // Show all members of the channel, including invisible (+i) users cmdnames.SendNames(localuser, chan, true); } } ModResult OnCheckKey(User* user, Channel* chan, const std::string& keygiven) override { // Hook only runs when being invited bypasses +bkl return IsInvited(user, chan); } ModResult OnCheckChannelBan(User* user, Channel* chan) override { // Hook only runs when being invited bypasses +bkl return IsInvited(user, chan); } ModResult OnCheckLimit(User* user, Channel* chan) override { // Hook only runs when being invited bypasses +bkl return IsInvited(user, chan); } ModResult OnCheckInvite(User* user, Channel* chan) override { // Hook always runs return IsInvited(user, chan); } void OnUserDisconnect(LocalUser* user) override { invapi.RemoveAll(user); } void OnChannelDelete(Channel* chan) override { // Make sure the channel won't appear in invite lists from now on, don't wait for cull to unset the ext invapi.RemoveAll(chan); } ModResult OnCheckBan(User* user, Channel* chan, const std::string& mask) override { bool inverted; std::string name; std::string value; if (!ExtBan::Parse(mask, name, value, inverted)) return MOD_RES_PASSTHRU; ExtBan::Base* extban = nullptr; if (name.size() == 1) extban = extbanmgr.FindLetter(name[0]); else extban = extbanmgr.FindName(name); // It is formatted like an extban but isn't a matching extban. if (!extban || extban->GetType() != ExtBan::Type::MATCHING) return MOD_RES_PASSTHRU; return extban->IsMatch(user, chan, value) != inverted ? MOD_RES_DENY : MOD_RES_PASSTHRU; } ModResult OnCheckExemption(User* user, Channel* chan, const std::string& restriction) override { if (!exemptions.count(restriction)) return MOD_RES_PASSTHRU; ModeHandler::Rank mypfx = chan->GetPrefixValue(user); char minmode = exemptions[restriction]; PrefixMode* mh = ServerInstance->Modes.FindPrefixMode(minmode); if (mh && mypfx >= mh->GetPrefixRank()) return MOD_RES_ALLOW; if (mh || minmode == '*') return MOD_RES_DENY; return MOD_RES_PASSTHRU; } void Prioritize() override { ServerInstance->Modules.SetPriority(this, I_OnPostJoin, PRIORITY_FIRST); ServerInstance->Modules.SetPriority(this, I_OnUserPreJoin, PRIORITY_LAST); } }; MODULE_INIT(CoreModChannel) ���������������������������������������������������������inspircd-4.7.0/src/coremods/core_channel/core_channel.h���������������������������������������������0000664�0000000�0000000�00000011745�14771603147�0023172�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2017, 2019-2024 Sadie Powell <sadie@witchery.services> * Copyright (C) 2014-2015 Attila Molnar <attilamolnar@hush.com> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #pragma once #include "inspircd.h" #include "listmode.h" #include "modules/exemption.h" #include "modules/extban.h" namespace Topic { void ShowTopic(LocalUser* user, Channel* chan); } namespace Invite { class APIImpl; } class CommandInvite final : public Command { private: Invite::APIImpl& invapi; public: CommandInvite(Module* parent, Invite::APIImpl& invapiimpl); CmdResult Handle(User* user, const Params& parameters) override; RouteDescriptor GetRouting(User* user, const Params& parameters) override; }; class CommandJoin final : public SplitCommand { public: CommandJoin(Module* parent); CmdResult HandleLocal(LocalUser* user, const Params& parameters) override; }; class CommandTopic final : public SplitCommand { private: CheckExemption::EventProvider exemptionprov; ChanModeReference secretmode; ChanModeReference topiclockmode; public: CommandTopic(Module* parent); CmdResult HandleLocal(LocalUser* user, const Params& parameters) override; }; class CommandNames final : public SplitCommand { private: ChanModeReference secretmode; ChanModeReference privatemode; UserModeReference invisiblemode; Events::ModuleEventProvider namesevprov; public: CommandNames(Module* parent); CmdResult HandleLocal(LocalUser* user, const Params& parameters) override; /** Spool the NAMES list for a given channel to the given user * @param user User to spool the NAMES list to * @param chan Channel whose nicklist to send * @param show_invisible True to show invisible (+i) members to the user, false to omit them from the list */ void SendNames(LocalUser* user, Channel* chan, bool show_invisible); }; class CommandKick final : public Command { public: CommandKick(Module* parent); CmdResult Handle(User* user, const Params& parameters) override; RouteDescriptor GetRouting(User* user, const Params& parameters) override; }; class ModeChannelBan final : public ListModeBase { private: ExtBan::ManagerRef extbanmgr; public: ModeChannelBan(Module* Creator); bool CompareEntry(const std::string& entry, const std::string& value) const override; bool ValidateParam(LocalUser* user, Channel* channel, std::string& parameter) override; }; class ModeChannelKey final : public ParamMode<ModeChannelKey, StringExtItem> { public: std::string::size_type maxkeylen; ModeChannelKey(Module* Creator); bool OnModeChange(User* source, User* dest, Channel* channel, Modes::Change& change) override; void SerializeParam(Channel* chan, const std::string* key, std::string& out); bool OnSet(User* source, Channel* chan, std::string& param) override; bool IsParameterSecret() override; }; class ModeChannelLimit final : public ParamMode<ModeChannelLimit, IntExtItem> { public: ModeChannelLimit(Module* Creator); bool ResolveModeConflict(const std::string& their_param, const std::string& our_param, Channel* channel) override; void SerializeParam(Channel* chan, intptr_t n, std::string& out); bool OnSet(User* source, Channel* channel, std::string& parameter) override; }; class ModeChannelOp final : public PrefixMode { public: ModeChannelOp(Module* Creator); }; class ModeChannelVoice final : public PrefixMode { public: ModeChannelVoice(Module* Creator); }; class ExtBanManager final : public ExtBan::Manager { private: ModeChannelBan& banmode; Events::ModuleEventProvider evprov; LetterMap byletter; NameMap byname; public: ExtBan::Format format; ExtBanManager(Module* Creator, ModeChannelBan& bm) : ExtBan::Manager(Creator) , banmode(bm) , evprov(Creator, "event/extban") { } void AddExtBan(ExtBan::Base* extban) override; bool Canonicalize(std::string& text) const override; ExtBan::Comparison CompareEntry(const ListModeBase* lm, const std::string& entry, const std::string& value) const override; void DelExtBan(ExtBan::Base* extban) override; ExtBan::Format GetFormat() const override { return format; } const LetterMap& GetLetterMap() const override { return byletter; } const NameMap& GetNameMap() const override { return byname; } ModResult GetStatus(ExtBan::ActingBase* extban, User* user, Channel* channel) const override; ExtBan::Base* FindName(const std::string& name) const override; ExtBan::Base* FindLetter(ExtBan::Letter letter) const override; void BuildISupport(std::string& out); }; ���������������������������inspircd-4.7.0/src/coremods/core_channel/extban.cpp�������������������������������������������������0000664�0000000�0000000�00000012746�14771603147�0022370�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2020, 2022-2025 Sadie Powell <sadie@witchery.services> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include "inspircd.h" #include "core_channel.h" void ExtBanManager::AddExtBan(ExtBan::Base* extban) { if (extban->GetLetter()) { auto lit = byletter.emplace(extban->GetLetter(), extban); if (!lit.second) throw ModuleException(creator, "ExtBan letter \"{}\" is already in use by the {} extban from {}", extban->GetLetter(), lit.first->second->GetName(), lit.first->second->creator->ModuleFile); } auto nit = byname.emplace(extban->GetName(), extban); if (!nit.second) { if (extban->GetLetter()) byletter.erase(extban->GetLetter()); throw ModuleException(creator, "ExtBan name \"{}\" is already in use by the {} extban from {}", extban->GetName(), nit.first->second->GetLetter(), nit.first->second->creator->ModuleFile); } } bool ExtBanManager::Canonicalize(std::string& text) const { bool inverted; // Intentionally unused std::string xbname; std::string xbvalue; if (!ExtBan::Parse(text, xbname, xbvalue, inverted)) return false; // Not an extban. ExtBan::Base* extban = nullptr; if (xbname.size() == 1) extban = FindLetter(xbname[0]); else extban = FindName(xbname); if (!extban) return false; // Looks like an extban but it isn't. // Canonicalize the extban. text.assign(inverted ? "!" : ""); switch (format) { case ExtBan::Format::NAME: text.append(extban->GetName()); break; case ExtBan::Format::LETTER: if (extban->GetLetter()) text.push_back(extban->GetLetter()); else text.append(extban->GetName()); // ExtBan has no letter. break; default: text.append(xbname); break; } extban->Canonicalize(xbvalue); text.append(":").append(xbvalue); return true; } ExtBan::Comparison ExtBanManager::CompareEntry(const ListModeBase* lm, const std::string& entry, const std::string& value) const { bool entry_inverted; std::string entry_xbname; std::string entry_xbvalue; bool entry_result = ExtBan::Parse(entry, entry_xbname, entry_xbvalue, entry_inverted); bool value_inverted; std::string value_xbname; std::string value_xbvalue; bool value_result = ExtBan::Parse(value, value_xbname, value_xbvalue, value_inverted); if (!entry_result && !value_result) return ExtBan::Comparison::NOT_AN_EXTBAN; // If we've reached this point at least one looks like an extban. auto entry_extban = entry_result ? Find(entry_xbname) : nullptr; auto value_extban = value_result ? Find(value_xbname) : nullptr; if (!entry_extban || !value_extban) return entry_extban == value_extban ? ExtBan::Comparison::NOT_AN_EXTBAN : ExtBan::Comparison::NOT_MATCH; // If we've reached this point both are extbans so we can just do a simple comparison. if (entry_inverted != value_inverted || entry_extban != value_extban) return ExtBan::Comparison::NOT_MATCH; // Compare the values recursively. return lm->CompareEntry(entry_xbvalue, value_xbvalue) ? ExtBan::Comparison::MATCH : ExtBan::Comparison::NOT_MATCH; } void ExtBanManager::BuildISupport(std::string& out) { for (const auto& extban : byletter) out.push_back(extban.first); std::sort(out.begin(), out.end()); out.insert(0, ","); } ModResult ExtBanManager::GetStatus(ExtBan::ActingBase* extban, User* user, Channel* channel) const { ModResult res = evprov.FirstResult(&ExtBan::EventListener::OnExtBanCheck, user, channel, extban); if (res != MOD_RES_PASSTHRU) return res; ListModeBase::ModeList* list = banmode.GetList(channel); if (!list) return MOD_RES_PASSTHRU; for (const auto& ban : *list) { bool inverted; std::string xbname; std::string xbvalue; if (!ExtBan::Parse(ban.mask, xbname, xbvalue, inverted)) continue; if (xbname.size() == 1) { // It is an extban but not this extban. if (xbname[0] != extban->GetLetter()) continue; } else { // It is an extban but not this extban. if (!irc::equals(xbname, extban->GetName())) continue; } // For a non-inverted (regular) extban we want to match but for an // inverted extban we want to not match. if (extban->IsMatch(user, channel, xbvalue) != inverted) return MOD_RES_DENY; } return MOD_RES_PASSTHRU; } void ExtBanManager::DelExtBan(ExtBan::Base* extban) { if (extban->GetLetter()) { auto lit = byletter.find(extban->GetLetter()); if (lit != byletter.end() && lit->second->creator.ptr() == extban->creator.ptr()) byletter.erase(lit); } auto nit = byname.find(extban->GetName()); if (nit != byname.end() && nit->second->creator.ptr() == extban->creator.ptr()) byname.erase(nit); } ExtBan::Base* ExtBanManager::FindName(const std::string& xbname) const { NameMap::const_iterator iter = byname.find(xbname); if (iter == byname.end()) return nullptr; return iter->second; } ExtBan::Base* ExtBanManager::FindLetter(ExtBan::Letter letter) const { LetterMap::const_iterator iter = byletter.find(letter); if (iter == byletter.end()) return nullptr; return iter->second; } ��������������������������inspircd-4.7.0/src/coremods/core_channel/invite.cpp�������������������������������������������������0000664�0000000�0000000�00000011703�14771603147�0022375�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2018-2019, 2021-2023 Sadie Powell <sadie@witchery.services> * Copyright (C) 2015 Attila Molnar <attilamolnar@hush.com> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include "inspircd.h" #include "invite.h" class InviteExpireTimer final : public Timer { Invite::Invite* const inv; bool Tick() override; public: InviteExpireTimer(Invite::Invite* invite, time_t timeout); }; static Invite::APIImpl* apiimpl; void RemoveInvite(Invite::Invite* inv, bool remove_user, bool remove_chan) { apiimpl->Destruct(inv, remove_user, remove_chan); } void UnserializeInvite(LocalUser* user, const std::string& str) { apiimpl->Unserialize(user, str); } Invite::APIBase::APIBase(Module* parent) : DataProvider(parent, "core_channel_invite") { } Invite::APIImpl::APIImpl(Module* parent) : APIBase(parent) , userext(parent, "invite_user") , chanext(parent, "invite_chan") { apiimpl = this; } void Invite::APIImpl::Destruct(Invite* inv, bool remove_user, bool remove_chan) { Store<LocalUser>* ustore = userext.Get(inv->user); if (ustore) { ustore->invites.erase(inv); if ((remove_user) && (ustore->invites.empty())) userext.Unset(inv->user); } Store<Channel>* cstore = chanext.Get(inv->chan); if (cstore) { cstore->invites.erase(inv); if ((remove_chan) && (cstore->invites.empty())) chanext.Unset(inv->chan); } delete inv; } bool Invite::APIImpl::Remove(LocalUser* user, Channel* chan) { Invite* inv = Find(user, chan); if (inv) { Destruct(inv); return true; } return false; } void Invite::APIImpl::Create(LocalUser* user, Channel* chan, time_t timeout) { if ((timeout != 0) && (ServerInstance->Time() >= timeout)) // Expired, don't bother return; ServerInstance->Logs.Debug(MODNAME, "Invite::APIImpl::Create(): user={} chan={} timeout={}", user->uuid, chan->name, timeout); Invite* inv = Find(user, chan); if (inv) { // We only ever extend invites, so nothing to do if the existing one is not timed if (!inv->IsTimed()) return; ServerInstance->Logs.Debug(MODNAME, "Invite::APIImpl::Create(): changing expiration in {}", fmt::ptr(inv)); if (timeout == 0) { // Convert timed invite to non-expiring stdalgo::delete_zero(inv->expiretimer); } else if (inv->expiretimer->GetTrigger() >= ServerInstance->Time() + timeout) { // New expiration time is further than the current, extend the expiration inv->expiretimer->SetInterval(timeout - ServerInstance->Time()); } } else { inv = new Invite(user, chan); if (timeout) { inv->expiretimer = new InviteExpireTimer(inv, timeout - ServerInstance->Time()); ServerInstance->Timers.AddTimer(inv->expiretimer); } userext.Get(user, true)->invites.push_front(inv); chanext.Get(chan, true)->invites.push_front(inv); ServerInstance->Logs.Debug(MODNAME, "Invite::APIImpl::Create(): created new Invite {}", fmt::ptr(inv)); } } Invite::Invite* Invite::APIImpl::Find(LocalUser* user, Channel* chan) { const List* list = APIImpl::GetList(user); if (!list) return nullptr; for (auto* inv : *list) { if (inv->chan == chan) return inv; } return nullptr; } const Invite::List* Invite::APIImpl::GetList(LocalUser* user) { Store<LocalUser>* list = userext.Get(user); if (list) return &list->invites; return nullptr; } void Invite::APIImpl::Unserialize(LocalUser* user, const std::string& value) { irc::spacesepstream ss(value); for (std::string channame, exptime; (ss.GetToken(channame) && ss.GetToken(exptime)); ) { auto* chan = ServerInstance->Channels.Find(channame); if (chan) Create(user, chan, ConvToNum<time_t>(exptime)); } } Invite::Invite::Invite(LocalUser* u, Channel* c) : user(u) , chan(c) { } Invite::Invite::~Invite() { delete expiretimer; ServerInstance->Logs.Debug(MODNAME, "Invite::~ {}", fmt::ptr(this)); } void Invite::Invite::Serialize(bool human, bool show_chans, std::string& out) { if (show_chans) out.append(this->chan->name); else out.append(human ? user->nick : user->uuid); out.push_back(' '); if (expiretimer) out.append(ConvToStr(expiretimer->GetTrigger())); else out.push_back('0'); out.push_back(' '); } InviteExpireTimer::InviteExpireTimer(Invite::Invite* invite, time_t timeout) : Timer(timeout, false) , inv(invite) { } bool InviteExpireTimer::Tick() { ServerInstance->Logs.Debug(MODNAME, "InviteExpireTimer::Tick(): expired {}", fmt::ptr(inv)); apiimpl->Destruct(inv); return false; } �������������������������������������������������������������inspircd-4.7.0/src/coremods/core_channel/invite.h���������������������������������������������������0000664�0000000�0000000�00000007270�14771603147�0022046�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2019-2022 Sadie Powell <sadie@witchery.services> * Copyright (C) 2015 Attila Molnar <attilamolnar@hush.com> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #pragma once #include "extension.h" #include "modules/invite.h" namespace Invite { template<typename T> struct Store final { typedef insp::intrusive_list<Invite, T> List; /** List of pending Invites */ List invites; }; template<typename T, ExtensionType ExtType> class ExtItem; class APIImpl; } extern void RemoveInvite(Invite::Invite* inv, bool remove_user, bool remove_chan); extern void UnserializeInvite(LocalUser* user, const std::string& value); template<typename T, ExtensionType ExtType> class Invite::ExtItem final : public ExtensionItem { private: static std::string ToString(void* item, bool human) { std::string ret; Store<T>* store = static_cast<Store<T>*>(item); for (auto* inv : store->invites) inv->Serialize(human, (ExtType == ExtensionType::USER), ret); if (!ret.empty()) ret.erase(ret.length()-1); return ret; } public: ExtItem(Module* owner, const char* extname) : ExtensionItem(owner, extname, ExtType) { } Store<T>* Get(Extensible* ext, bool create = false) { Store<T>* store = static_cast<Store<T>*>(GetRaw(ext)); if ((create) && (!store)) { store = new Store<T>; SetRaw(ext, store); } return store; } void Unset(Extensible* ext) { void* store = UnsetRaw(ext); if (store) Delete(ext, store); } void Delete(Extensible* container, void* item) override { Store<T>* store = static_cast<Store<T>*>(item); for (typename Store<T>::List::iterator i = store->invites.begin(); i != store->invites.end(); ) { Invite* inv = *i; // Destructing the Invite invalidates the iterator, so move it now ++i; RemoveInvite(inv, (ExtType != ExtensionType::USER), (ExtType == ExtensionType::USER)); } delete store; } std::string ToHuman(const Extensible* container, void* item) const noexcept override { return ToString(item, true); } std::string ToInternal(const Extensible* container, void* item) const noexcept override { return ToString(item, false); } void FromInternal(Extensible* container, const std::string& value) noexcept override { if (ExtType != ExtensionType::CHANNEL) UnserializeInvite(static_cast<LocalUser*>(container), value); } }; class Invite::APIImpl final : public APIBase { private: ExtItem<LocalUser, ExtensionType::USER> userext; ExtItem<Channel, ExtensionType::CHANNEL> chanext; public: AnnounceState announceinvites; APIImpl(Module* owner); void Create(LocalUser* user, Channel* chan, time_t timeout) override; Invite* Find(LocalUser* user, Channel* chan) override; bool Remove(LocalUser* user, Channel* chan) override; const List* GetList(LocalUser* user) override; AnnounceState GetAnnounceState() const override { return announceinvites; } void RemoveAll(LocalUser* user) { userext.Unset(user); } void RemoveAll(Channel* chan) { chanext.Unset(chan); } void Destruct(Invite* inv, bool remove_chan = true, bool remove_user = true); void Unserialize(LocalUser* user, const std::string& value); }; ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/src/coremods/core_channel/modes.cpp��������������������������������������������������0000664�0000000�0000000�00000006404�14771603147�0022210�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2017, 2019, 2021-2023 Sadie Powell <sadie@witchery.services> * Copyright (C) 2014 Attila Molnar <attilamolnar@hush.com> * Copyright (C) 2012 Robby <robby@chatbelgie.be> * Copyright (C) 2009 Daniel De Graaf <danieldg@inspircd.org> * Copyright (C) 2007 Dennis Friis <peavey@inspircd.org> * Copyright (C) 2006 Craig Edwards <brain@inspircd.org> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include "inspircd.h" #include "numerichelper.h" #include "core_channel.h" enum { // From RFC 1459. RPL_BANLIST = 367, RPL_ENDOFBANLIST = 368, }; ModeChannelBan::ModeChannelBan(Module* Creator) : ListModeBase(Creator, "ban", 'b', RPL_BANLIST, RPL_ENDOFBANLIST) , extbanmgr(Creator) { syntax = "<mask>"; } bool ModeChannelBan::CompareEntry(const std::string& entry, const std::string& value) const { if (extbanmgr) { auto res = extbanmgr->CompareEntry(this, entry, value); if (res != ExtBan::Comparison::NOT_AN_EXTBAN) return res == ExtBan::Comparison::MATCH; } return irc::equals(entry, value); } bool ModeChannelBan::ValidateParam(LocalUser* user, Channel* channel, std::string& parameter) { if (!extbanmgr || !extbanmgr->Canonicalize(parameter)) ModeParser::CleanMask(parameter); return true; } ModeChannelLimit::ModeChannelLimit(Module* Creator) : ParamMode<ModeChannelLimit, IntExtItem>(Creator, "limit", 'l') { syntax = "<limit>"; } bool ModeChannelLimit::ResolveModeConflict(const std::string& their_param, const std::string& our_param, Channel* channel) { // When the timestamps are equal the higher channel limit wins. return ConvToNum<intptr_t>(their_param) < ConvToNum<intptr_t>(our_param); } bool ModeChannelLimit::OnSet(User* user, Channel* chan, std::string& parameter) { size_t limit = ConvToNum<size_t>(parameter); if (limit < 1 || limit > INTPTR_MAX) { if (IS_LOCAL(user)) { // If the setter is local then we can safely just reject this here. user->WriteNumeric(Numerics::InvalidModeParameter(chan, this, parameter)); return false; } else { // If the setter is remote we *must* set the mode to avoid a desync // so instead clamp it to the allowed range instead. limit = std::clamp<size_t>(limit, 1, INTPTR_MAX); } } ext.Set(chan, limit); return true; } void ModeChannelLimit::SerializeParam(Channel* chan, intptr_t limit, std::string& out) { out += ConvToStr(static_cast<size_t>(limit)); } ModeChannelOp::ModeChannelOp(Module* Creator) : PrefixMode(Creator, "op", 'o', OP_VALUE, '@') { ranktoset = ranktounset = OP_VALUE; } ModeChannelVoice::ModeChannelVoice(Module* Creator) : PrefixMode(Creator, "voice", 'v', VOICE_VALUE, '+') { selfremove = false; ranktoset = ranktounset = HALFOP_VALUE; } ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/src/coremods/core_clients.cpp��������������������������������������������������������0000664�0000000�0000000�00000002455�14771603147�0021134�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2021-2023 Sadie Powell <sadie@witchery.services> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include "inspircd.h" #include "utility/string.h" class CoreModClients final : public Module { private: public: CoreModClients() : Module(VF_CORE | VF_VENDOR, "Accepts connections to the server.") { } ModResult OnAcceptConnection(int nfd, ListenSocket* from, const irc::sockets::sockaddrs& client, const irc::sockets::sockaddrs& server) override { if (!insp::equalsci(from->bind_tag->getString("type", "clients", 1), "clients")) return MOD_RES_PASSTHRU; ServerInstance->Users.AddUser(nfd, from, client, server); return MOD_RES_ALLOW; } }; MODULE_INIT(CoreModClients) �������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/src/coremods/core_dns.cpp������������������������������������������������������������0000664�0000000�0000000�00000061225�14771603147�0020257�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2021 Dominic Hamon * Copyright (C) 2019 Robby <robby@chatbelgie.be> * Copyright (C) 2015, 2018-2023, 2025 Sadie Powell <sadie@witchery.services> * Copyright (C) 2014-2016 Attila Molnar <attilamolnar@hush.com> * Copyright (C) 2013, 2015-2016, 2021 Adam <Adam@anope.org> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include "inspircd.h" #include "modules/dns.h" #include "modules/stats.h" #include "stringutils.h" #include <fstream> #ifdef _WIN32 #include <Iphlpapi.h> #pragma comment(lib, "Iphlpapi.lib") #endif namespace DNS { /** Maximum value of a dns request id, 16 bits wide, 0xFFFF. */ const unsigned int MAX_REQUEST_ID = 0xFFFF; } using namespace DNS; /** A full packet sent or received to/from the nameserver */ class Packet final : public Query { private: const Module* creator; void PackName(unsigned char* output, unsigned short output_size, unsigned short& pos, const std::string& name) { if (pos + name.length() + 2 > output_size) throw Exception(creator, "Unable to pack name"); ServerInstance->Logs.Debug(MODNAME, "Packing name {}", name); irc::sepstream sep(name, '.'); std::string token; while (sep.GetToken(token)) { output[pos++] = token.length(); memcpy(&output[pos], token.data(), token.length()); pos += token.length(); } output[pos++] = 0; } std::string UnpackName(const unsigned char* input, unsigned short input_size, unsigned short& pos) { std::string name; unsigned short pos_ptr = pos; unsigned short lowest_ptr = input_size; bool compressed = false; if (pos_ptr >= input_size) throw Exception(creator, "Unable to unpack name - no input"); while (input[pos_ptr] > 0) { unsigned short offset = input[pos_ptr]; if (offset & POINTER) { if ((offset & POINTER) != POINTER) throw Exception(creator, "Unable to unpack name - bogus compression header"); if (pos_ptr + 1 >= input_size) throw Exception(creator, "Unable to unpack name - bogus compression header"); /* Place pos at the second byte of the first (farthest) compression pointer */ if (!compressed) { ++pos; compressed = true; } pos_ptr = (offset & LABEL) << 8 | input[pos_ptr + 1]; /* Pointers can only go back */ if (pos_ptr >= lowest_ptr) throw Exception(creator, "Unable to unpack name - bogus compression pointer"); lowest_ptr = pos_ptr; } else { if (pos_ptr + offset + 1 >= input_size) throw Exception(creator, "Unable to unpack name - offset too large"); if (!name.empty()) name += "."; for (unsigned i = 1; i <= offset; ++i) name += input[pos_ptr + i]; pos_ptr += offset + 1; if (!compressed) /* Move up pos */ pos = pos_ptr; } } /* +1 pos either to one byte after the compression pointer or one byte after the ending \0 */ ++pos; if (name.empty()) throw Exception(creator, "Unable to unpack name - no name"); ServerInstance->Logs.Debug(MODNAME, "Unpack name {}", name); return name; } Question UnpackQuestion(const unsigned char* input, unsigned short input_size, unsigned short& pos) { Question q; q.name = this->UnpackName(input, input_size, pos); if (pos + 4 > input_size) throw Exception(creator, "Unable to unpack question"); q.type = static_cast<QueryType>(input[pos] << 8 | input[pos + 1]); pos += 2; // Skip over query class code pos += 2; return q; } ResourceRecord UnpackResourceRecord(const unsigned char* input, unsigned short input_size, unsigned short& pos) { ResourceRecord record = static_cast<ResourceRecord>(this->UnpackQuestion(input, input_size, pos)); if (pos + 6 > input_size) throw Exception(creator, "Unable to unpack resource record"); record.ttl = (input[pos] << 24) | (input[pos + 1] << 16) | (input[pos + 2] << 8) | input[pos + 3]; pos += 4; uint16_t rdlength = input[pos] << 8 | input[pos + 1]; pos += 2; switch (record.type) { case QUERY_A: { if (pos + 4 > input_size) throw Exception(creator, "Unable to unpack A resource record"); irc::sockets::sockaddrs addrs; addrs.in4.sin_family = AF_INET; addrs.in4.sin_addr.s_addr = input[pos] | (input[pos + 1] << 8) | (input[pos + 2] << 16) | (input[pos + 3] << 24); pos += 4; record.rdata = addrs.addr(); break; } case QUERY_AAAA: { if (pos + 16 > input_size) throw Exception(creator, "Unable to unpack AAAA resource record"); irc::sockets::sockaddrs addrs; addrs.in6.sin6_family = AF_INET6; for (int j = 0; j < 16; ++j) addrs.in6.sin6_addr.s6_addr[j] = input[pos + j]; pos += 16; record.rdata = addrs.addr(); break; } case QUERY_CNAME: case QUERY_PTR: { record.rdata = this->UnpackName(input, input_size, pos); if (!InspIRCd::IsHost(record.rdata, true)) throw Exception(creator, "Invalid name in CNAME/PTR resource record"); break; } case QUERY_TXT: { if (pos + rdlength > input_size) throw Exception(creator, "Unable to unpack TXT resource record"); record.rdata = std::string(reinterpret_cast<const char* >(input + pos), rdlength); pos += rdlength; if (record.rdata.find_first_of("\r\n\0", 0, 3) != std::string::npos) throw Exception(creator, "Invalid character in TXT resource record"); break; } case QUERY_SRV: { if (rdlength < 6 || pos + rdlength > input_size) throw Exception(creator, "Unable to unpack SRV resource record"); auto srv = std::make_shared<Record::SRV>(); srv->priority = input[pos] << 8 | input[pos + 1]; pos += 2; srv->weight = input[pos] << 8 | input[pos + 1]; pos += 2; srv->port = input[pos] << 8 | input[pos + 1]; pos += 2; srv->host = this->UnpackName(input, input_size, pos); if (!InspIRCd::IsHost(srv->host, true)) throw Exception(creator, "Invalid name in SRV resource record"); record.rdata = INSP_FORMAT("{} {} {} {}", srv->priority, srv->weight, srv->port, srv->host); record.rdataobj = srv; break; } default: { if (pos + rdlength > input_size) throw Exception(creator, "Unable to skip resource record"); pos += rdlength; break; } } if (!record.name.empty() && !record.rdata.empty()) ServerInstance->Logs.Debug(MODNAME, "{} -> {}", record.name, record.rdata); return record; } public: static constexpr int POINTER = 0xC0; static constexpr int LABEL = 0x3F; static constexpr int HEADER_LENGTH = 12; /* ID for this packet */ RequestId id = 0; /* Flags on the packet */ unsigned short flags = 0; Packet(const Module* mod) : creator(mod) { } void Fill(const unsigned char* input, unsigned short len) { if (len < HEADER_LENGTH) throw Exception(creator, "Unable to fill packet"); unsigned short packet_pos = 0; this->id = (input[packet_pos] << 8) | input[packet_pos + 1]; packet_pos += 2; this->flags = (input[packet_pos] << 8) | input[packet_pos + 1]; packet_pos += 2; unsigned short qdcount = (input[packet_pos] << 8) | input[packet_pos + 1]; packet_pos += 2; unsigned short ancount = (input[packet_pos] << 8) | input[packet_pos + 1]; packet_pos += 2; unsigned short nscount = (input[packet_pos] << 8) | input[packet_pos + 1]; packet_pos += 2; unsigned short arcount = (input[packet_pos] << 8) | input[packet_pos + 1]; packet_pos += 2; ServerInstance->Logs.Debug(MODNAME, "qdcount: {} ancount: {} nscount: {} arcount: {}", qdcount, ancount, nscount, arcount); if (qdcount != 1) throw Exception(creator, "Question count != 1 in incoming packet"); this->question = this->UnpackQuestion(input, len, packet_pos); for (unsigned i = 0; i < ancount; ++i) this->answers.push_back(this->UnpackResourceRecord(input, len, packet_pos)); } unsigned short Pack(unsigned char* output, unsigned short output_size) { if (output_size < HEADER_LENGTH) throw Exception(creator, "Unable to pack oversized packet header"); unsigned short pos = 0; output[pos++] = this->id >> 8; output[pos++] = this->id & 0xFF; output[pos++] = this->flags >> 8; output[pos++] = this->flags & 0xFF; output[pos++] = 0; // Question count, high byte output[pos++] = 1; // Question count, low byte output[pos++] = 0; // Answer count, high byte output[pos++] = 0; // Answer count, low byte output[pos++] = 0; output[pos++] = 0; output[pos++] = 0; output[pos++] = 0; { Question& q = this->question; if (q.type == QUERY_PTR) { irc::sockets::sockaddrs ip(false); if (!ip.from_ip(q.name)) throw Exception(creator, "Unable to pack packet with malformed IP for PTR lookup"); if (q.name.find(':') != std::string::npos) { // ::1 => 1.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.ip6.arpa char reverse_ip[128]; unsigned reverse_ip_count = 0; for (int j = 15; j >= 0; --j) { reverse_ip[reverse_ip_count++] = Hex::TABLE_LOWER[ip.in6.sin6_addr.s6_addr[j] & 0xF]; reverse_ip[reverse_ip_count++] = '.'; reverse_ip[reverse_ip_count++] = Hex::TABLE_LOWER[ip.in6.sin6_addr.s6_addr[j] >> 4]; reverse_ip[reverse_ip_count++] = '.'; } reverse_ip[reverse_ip_count++] = 0; q.name = reverse_ip; q.name += "ip6.arpa"; } else { // 127.0.0.1 => 1.0.0.127.in-addr.arpa unsigned int forward = ip.in4.sin_addr.s_addr; ip.in4.sin_addr.s_addr = forward << 24 | (forward & 0xFF00) << 8 | (forward & 0xFF0000) >> 8 | forward >> 24; q.name = ip.addr() + ".in-addr.arpa"; } } this->PackName(output, output_size, pos, q.name); if (pos + 4 >= output_size) throw Exception(creator, "Unable to pack oversized packet body"); short s = htons(q.type); memcpy(&output[pos], &s, 2); pos += 2; // Query class, always IN output[pos++] = 0; output[pos++] = 1; } return pos; } }; class MyManager final : public Manager , public Timer , public EventHandler { typedef std::unordered_map<Question, Query, Question::hash> cache_map; cache_map cache; irc::sockets::sockaddrs myserver; bool unloading = false; /** Maximum number of entries in cache */ static constexpr unsigned int MAX_CACHE_SIZE = 1000; static bool IsExpired(const Query& record) { const ResourceRecord& req = record.answers[0]; return (req.created + static_cast<time_t>(req.ttl) < ServerInstance->Time()); } /** Check the DNS cache to see if request can be handled by a cached result * @return true if a cached result was found. */ bool CheckCache(DNS::Request* req, const DNS::Question& question) { ServerInstance->Logs.Critical(MODNAME, "cache: Checking cache for {}", question.name); cache_map::iterator it = this->cache.find(question); if (it == this->cache.end()) return false; Query& record = it->second; if (IsExpired(record)) { this->cache.erase(it); return false; } ServerInstance->Logs.Debug(MODNAME, "cache: Using cached result for {}", question.name); record.cached = true; req->OnLookupComplete(&record); return true; } /** Add a record to the dns cache * @param r The record */ void AddCache(Query& r) { if (cache.size() >= MAX_CACHE_SIZE) cache.clear(); // Determine the lowest TTL value and use that as the TTL of the cache entry unsigned int cachettl = UINT_MAX; for (const auto& rr : r.answers) { if (rr.ttl < cachettl) cachettl = rr.ttl; } cachettl = std::min<unsigned int>(cachettl, 5*60); ResourceRecord& rr = r.answers.front(); // Set TTL to what we've determined to be the lowest rr.ttl = cachettl; ServerInstance->Logs.Debug(MODNAME, "cache: added cache for {} -> {} ttl: {}", rr.name, rr.rdata, rr.ttl); this->cache[r.question] = r; } public: DNS::Request* requests[MAX_REQUEST_ID+1]; size_t stats_total = 0; size_t stats_success = 0; size_t stats_failure = 0; MyManager(Module* c) : Manager(c) , Timer(5*60, true) { for (unsigned int i = 0; i <= MAX_REQUEST_ID; ++i) requests[i] = nullptr; ServerInstance->Timers.AddTimer(this); } ~MyManager() override { // Ensure Process() will fail for new requests Close(); unloading = true; for (unsigned int i = 0; i <= MAX_REQUEST_ID; ++i) { DNS::Request* request = requests[i]; if (!request) continue; Query rr(request->question); rr.error = ERROR_UNKNOWN; request->OnError(&rr); delete request; } } void Close() { // Shutdown the socket if it exists. if (HasFd()) { SocketEngine::Shutdown(this, 2); SocketEngine::Close(this); } // Remove all entries from the cache. cache.clear(); } void Process(DNS::Request* req) override { if ((unloading) || (req->creator->dying)) throw Exception(creator, "Module is being unloaded"); if (!HasFd()) { Query rr(req->question); rr.error = ERROR_DISABLED; req->OnError(&rr); return; } ServerInstance->Logs.Debug(MODNAME, "Processing request to lookup {} of type {} to {}", req->question.name, (int)req->question.type, this->myserver.addr()); /* Create an id */ unsigned int tries = 0; long id; do { id = ServerInstance->GenRandomInt(DNS::MAX_REQUEST_ID+1); if (++tries == DNS::MAX_REQUEST_ID*5) { // If we couldn't find an empty slot this many times, do a sequential scan as a last // resort. If an empty slot is found that way, go on, otherwise throw an exception id = -1; for (unsigned int i = 0; i <= DNS::MAX_REQUEST_ID; i++) { if (!this->requests[i]) { id = i; break; } } if (id == -1) throw Exception(creator, "DNS: All ids are in use"); break; } } while (this->requests[id]); req->id = id; this->requests[req->id] = req; Packet p(creator); p.flags = QUERYFLAGS_RD; p.id = req->id; p.question = req->question; unsigned char buffer[524]; unsigned short len = p.Pack(buffer, sizeof(buffer)); /* Note that calling Pack() above can actually change the contents of p.question.name, if the query is a PTR, * to contain the value that would be in the DNS cache, which is why this is here. */ if (req->use_cache && this->CheckCache(req, p.question)) { ServerInstance->Logs.Debug(MODNAME, "Using cached result"); delete req; return; } // For PTR lookups we rewrite the original name to use the special in-addr.arpa/ip6.arpa // domains so we need to update the original request so that question checking works. req->question.name = p.question.name; if (SocketEngine::SendTo(this, buffer, len, 0, this->myserver) != len) throw Exception(creator, "DNS: Unable to send query"); // Add timer for timeout ServerInstance->Timers.AddTimer(req); } void RemoveRequest(DNS::Request* req) override { if (requests[req->id] == req) requests[req->id] = nullptr; } std::string GetErrorStr(Error e) override { switch (e) { case ERROR_UNLOADED: return "Module is unloading"; case ERROR_TIMEDOUT: return "Request timed out"; case ERROR_NOT_AN_ANSWER: case ERROR_NONSTANDARD_QUERY: case ERROR_FORMAT_ERROR: case ERROR_MALFORMED: return "Malformed answer"; case ERROR_SERVER_FAILURE: case ERROR_NOT_IMPLEMENTED: case ERROR_REFUSED: case ERROR_INVALIDTYPE: return "Nameserver failure"; case ERROR_DOMAIN_NOT_FOUND: case ERROR_NO_RECORDS: return "Domain not found"; case ERROR_DISABLED: return "DNS lookups are disabled"; case ERROR_NONE: case ERROR_UNKNOWN: break; } return "Unknown error"; } std::string GetTypeStr(QueryType qt) override { switch (qt) { case QUERY_A: return "A"; case QUERY_AAAA: return "AAAA"; case QUERY_CNAME: return "CNAME"; case QUERY_PTR: return "PTR"; case QUERY_TXT: return "TXT"; case QUERY_SRV: return "SRV"; default: return "UNKNOWN"; } } void OnEventHandlerError(int errcode) override { ServerInstance->Logs.Debug(MODNAME, "UDP socket got an error event"); } void OnEventHandlerRead() override { unsigned char buffer[524]; irc::sockets::sockaddrs from(false); socklen_t x = sizeof(from); ssize_t length = SocketEngine::RecvFrom(this, buffer, sizeof(buffer), 0, &from.sa, &x); if (length < Packet::HEADER_LENGTH) return; if (myserver != from) { std::string server1 = from.str(); std::string server2 = myserver.str(); ServerInstance->Logs.Debug(MODNAME, "Got a result from the wrong server! Bad NAT or DNS forging attempt? '{}' != '{}'", server1, server2); return; } Packet recv_packet(creator); bool valid = false; try { recv_packet.Fill(buffer, length); valid = true; } catch (const Exception& ex) { ServerInstance->Logs.Debug(MODNAME, ex.GetReason()); } // recv_packet.id must be filled in here DNS::Request* request = this->requests[recv_packet.id]; if (!request) { ServerInstance->Logs.Debug(MODNAME, "Received an answer for something we didn't request"); return; } if (request->question != recv_packet.question) { // This can happen under high latency, drop it silently, do not fail the request ServerInstance->Logs.Debug(MODNAME, "Received an answer that isn't for a question we asked"); return; } if (!valid) { this->stats_failure++; recv_packet.error = ERROR_MALFORMED; request->OnError(&recv_packet); } else if (recv_packet.flags & QUERYFLAGS_OPCODE) { ServerInstance->Logs.Debug(MODNAME, "Received a nonstandard query"); this->stats_failure++; recv_packet.error = ERROR_NONSTANDARD_QUERY; request->OnError(&recv_packet); } else if (!(recv_packet.flags & QUERYFLAGS_QR) || (recv_packet.flags & QUERYFLAGS_RCODE)) { Error error = ERROR_UNKNOWN; switch (recv_packet.flags & QUERYFLAGS_RCODE) { case 1: ServerInstance->Logs.Debug(MODNAME, "format error"); error = ERROR_FORMAT_ERROR; break; case 2: ServerInstance->Logs.Debug(MODNAME, "server error"); error = ERROR_SERVER_FAILURE; break; case 3: ServerInstance->Logs.Debug(MODNAME, "domain not found"); error = ERROR_DOMAIN_NOT_FOUND; break; case 4: ServerInstance->Logs.Debug(MODNAME, "not implemented"); error = ERROR_NOT_IMPLEMENTED; break; case 5: ServerInstance->Logs.Debug(MODNAME, "refused"); error = ERROR_REFUSED; break; default: break; } this->stats_failure++; recv_packet.error = error; request->OnError(&recv_packet); } else if (recv_packet.answers.empty()) { ServerInstance->Logs.Debug(MODNAME, "No resource records returned"); this->stats_failure++; recv_packet.error = ERROR_NO_RECORDS; request->OnError(&recv_packet); } else { ServerInstance->Logs.Debug(MODNAME, "Lookup complete for {}", request->question.name); this->stats_success++; request->OnLookupComplete(&recv_packet); this->AddCache(recv_packet); } this->stats_total++; /* Request's destructor removes it from the request map */ delete request; } bool Tick() override { unsigned long expired = 0; for (cache_map::iterator it = this->cache.begin(); it != this->cache.end(); ) { const Query& query = it->second; if (IsExpired(query)) { expired++; this->cache.erase(it++); } else ++it; } if (expired) ServerInstance->Logs.Debug(MODNAME, "cache: purged {} expired DNS entries", expired); return true; } void Rehash(const std::string& dnsserver, std::string sourceaddr, in_port_t sourceport) { myserver.from_ip_port(dnsserver, DNS::PORT); /* Initialize mastersocket */ Close(); int s = socket(myserver.family(), SOCK_DGRAM, 0); this->SetFd(s); /* Have we got a socket? */ if (this->HasFd()) { SocketEngine::SetOption<int>(s, SOL_SOCKET, SO_REUSEADDR, 1); SocketEngine::NonBlocking(s); if (sourceaddr.empty()) { // set a sourceaddr based on the servers af type if (myserver.family() == AF_INET) sourceaddr = "0.0.0.0"; else if (myserver.family() == AF_INET6) sourceaddr = "::"; } irc::sockets::sockaddrs bindto; bindto.from_ip_port(sourceaddr, sourceport); if (SocketEngine::Bind(this, bindto) < 0) { /* Failed to bind */ ServerInstance->Logs.Critical(MODNAME, "Error binding dns socket - hostnames will NOT resolve"); SocketEngine::Close(this->GetFd()); this->SetFd(-1); } else if (!SocketEngine::AddFd(this, FD_WANT_POLL_READ | FD_WANT_NO_WRITE)) { ServerInstance->Logs.Critical(MODNAME, "Internal error starting DNS - hostnames will NOT resolve."); SocketEngine::Close(this->GetFd()); this->SetFd(-1); } if (bindto.family() != myserver.family()) ServerInstance->Logs.Warning(MODNAME, "Nameserver address family differs from source address family - hostnames might not resolve"); } else { ServerInstance->Logs.Critical(MODNAME, "Error creating DNS socket - hostnames will NOT resolve"); } } }; class ModuleDNS final : public Module , public Stats::EventListener { MyManager manager; std::string DNSServer; std::string SourceIP; in_port_t SourcePort = 0; void FindDNSServer() { #ifdef _WIN32 // attempt to look up their nameserver from the system ServerInstance->Logs.Normal(MODNAME, "WARNING: <dns:server> not defined, attempting to find a working server in the system settings..."); PFIXED_INFO pFixedInfo; DWORD dwBufferSize = sizeof(FIXED_INFO); pFixedInfo = (PFIXED_INFO) HeapAlloc(GetProcessHeap(), 0, sizeof(FIXED_INFO)); if (pFixedInfo) { if (GetNetworkParams(pFixedInfo, &dwBufferSize) == ERROR_BUFFER_OVERFLOW) { HeapFree(GetProcessHeap(), 0, pFixedInfo); pFixedInfo = (PFIXED_INFO) HeapAlloc(GetProcessHeap(), 0, dwBufferSize); } if (pFixedInfo) { if (GetNetworkParams(pFixedInfo, &dwBufferSize) == NO_ERROR) DNSServer = pFixedInfo->DnsServerList.IpAddress.String; HeapFree(GetProcessHeap(), 0, pFixedInfo); } if (!DNSServer.empty()) { ServerInstance->Logs.Normal(MODNAME, "<dns:server> set to '{}' as first active resolver in the system settings.", DNSServer); return; } } ServerInstance->Logs.Warning(MODNAME, "No viable nameserver found! Defaulting to nameserver '127.0.0.1'!"); #else // attempt to look up their nameserver from /etc/resolv.conf ServerInstance->Logs.Normal(MODNAME, "WARNING: <dns:server> not defined, attempting to find working server in /etc/resolv.conf..."); std::ifstream resolv("/etc/resolv.conf"); while (resolv >> DNSServer) { if (DNSServer == "nameserver") { resolv >> DNSServer; if (DNSServer.find_first_not_of("0123456789.") == std::string::npos || DNSServer.find_first_not_of("0123456789ABCDEFabcdef:") == std::string::npos) { ServerInstance->Logs.Normal(MODNAME, "<dns:server> set to '{}' as first resolver in /etc/resolv.conf.", DNSServer); return; } } } ServerInstance->Logs.Warning(MODNAME, "/etc/resolv.conf contains no viable nameserver entries! Defaulting to nameserver '127.0.0.1'!"); #endif DNSServer = "127.0.0.1"; } public: ModuleDNS() : Module(VF_CORE | VF_VENDOR, "Provides support for DNS lookups") , Stats::EventListener(this) , manager(this) { } void ReadConfig(ConfigStatus& status) override { const auto& tag = ServerInstance->Config->ConfValue("dns"); if (!tag->getBool("enabled", true)) { // Clear these so they get reset if DNS is enabled again. DNSServer.clear(); SourceIP.clear(); SourcePort = 0; this->manager.Close(); return; } const std::string oldserver = DNSServer; DNSServer = tag->getString("server"); const std::string oldip = SourceIP; SourceIP = tag->getString("sourceip"); const in_port_t oldport = SourcePort; SourcePort = tag->getNum<in_port_t>("sourceport", 0); if (DNSServer.empty()) FindDNSServer(); if (oldserver != DNSServer || oldip != SourceIP || oldport != SourcePort || !SourcePort) this->manager.Rehash(DNSServer, SourceIP, SourcePort); } ModResult OnStats(Stats::Context& stats) override { if (stats.GetSymbol() == 'T') { stats.AddGenericRow(INSP_FORMAT("DNS requests: {} ({} succeeded, {} failed)", manager.stats_total, manager.stats_success, manager.stats_failure)); } return MOD_RES_PASSTHRU; } void OnUnloadModule(Module* mod) override { for (unsigned int i = 0; i <= MAX_REQUEST_ID; ++i) { DNS::Request* req = this->manager.requests[i]; if (!req) continue; if (req->creator == mod) { Query rr(req->question); rr.error = ERROR_UNLOADED; req->OnError(&rr); delete req; } } } }; MODULE_INIT(ModuleDNS) ���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/src/coremods/core_hostname_lookup.cpp������������������������������������������������0000664�0000000�0000000�00000016277�14771603147�0022711�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2013, 2018-2023, 2025 Sadie Powell <sadie@witchery.services> * Copyright (C) 2013, 2016 Adam <Adam@anope.org> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #ifndef _WIN32 # include <arpa/inet.h> #endif #include "inspircd.h" #include "extension.h" #include "modules/dns.h" namespace { BoolExtItem* dl; } class UserResolver : public DNS::Request { protected: // The socket address that the associated user was connected from at the time of lookup. const irc::sockets::sockaddrs sa; // The UUID of the user we are looking up the hostname of. const std::string uuid; UserResolver(DNS::Manager* mgr, Module* me, LocalUser* user, const std::string& to_resolve, DNS::QueryType qt) : DNS::Request(mgr, me, to_resolve, qt) , sa(user->client_sa) , uuid(user->uuid) { } // Handles errors which happen during DNS resolution. static void HandleError(LocalUser* user, const std::string& message) { user->WriteNotice("*** " + message + "; using your IP address (" + user->GetAddress() + ") instead."); bool display_is_real = user->GetDisplayedHost() == user->GetRealHost(); user->ChangeRealHost(user->GetAddress(), display_is_real); dl->Unset(user); } /** Logs the result of a DNS lookup. */ inline void LogLookup(const DNS::ResourceRecord& rr, bool cached) const { ServerInstance->Logs.Debug(MODNAME, "DNS {} result for {}: '{}' -> '{}'{}", manager->GetTypeStr(question.type), uuid, rr.name, rr.rdata, cached ? " (cached)" : ""); } public: void OnError(const DNS::Query* query) override { LocalUser* user = ServerInstance->Users.FindUUID<LocalUser>(uuid); if (user && user->client_sa == sa) HandleError(user, "Could not resolve your hostname: " + this->manager->GetErrorStr(query->error)); } }; // Handles checking the retrieved PTR record against its A/AAAA records. class UserIPResolver final : public UserResolver { public: UserIPResolver(DNS::Manager* mgr, Module* me, LocalUser* user, const std::string& host) : UserResolver(mgr, me, user, host, user->client_sa.family() == AF_INET6 ? DNS::QUERY_AAAA : DNS::QUERY_A) { } void OnLookupComplete(const DNS::Query* query) override { LocalUser* user = ServerInstance->Users.FindUUID<LocalUser>(uuid); if (!user || user->client_sa != sa) return; bool hasrecord = false; bool matches = false; const DNS::QueryType qt = user->client_sa.family() == AF_INET6 ? DNS::QUERY_AAAA : DNS::QUERY_A; for (const auto& rr : query->answers) { if (rr.type != qt) continue; // We've seen an A/AAAA record. hasrecord = true; switch (user->client_sa.family()) { case AF_INET: { // Does this result match the user's IPv4 address? struct in_addr v4addr; if (inet_pton(AF_INET, rr.rdata.c_str(), &v4addr) == 1) matches = !memcmp(&user->client_sa.in4.sin_addr, &v4addr, sizeof(v4addr)); break; } case AF_INET6: { // Does this result match the user's IPv6 address? struct in6_addr v6addr; if (inet_pton(AF_INET6, rr.rdata.c_str(), &v6addr) == 1) matches = !memcmp(&user->client_sa.in6.sin6_addr, &v6addr, sizeof(v6addr)); break; } } // If we've found a valid match then stop processing records. if (matches) { LogLookup(rr, query->cached); break; } } if (matches) { // We have found the hostname for the user. user->WriteNotice("*** Found your hostname (" + this->question.name + (query->cached ? ") -- cached" : ")")); bool display_is_real = user->GetDisplayedHost() == user->GetRealHost(); user->ChangeRealHost(this->question.name, display_is_real); dl->Unset(user); } else if (hasrecord) { // The hostname has A/AAAA records but none of them are the IP address of the user. HandleError(user, "Your hostname does not match up with your IP address"); } else { // The hostname has no A/AAAA records. HandleError(user, "Could not resolve your hostname: No " + this->manager->GetTypeStr(this->question.type) + " records found"); } } }; // Handles retrieving the PTR record for users. class UserHostResolver final : public UserResolver { public: UserHostResolver(DNS::Manager* mgr, Module* me, LocalUser* user) : UserResolver(mgr, me, user, user->GetAddress(), DNS::QUERY_PTR) { } void OnLookupComplete(const DNS::Query* query) override { LocalUser* user = ServerInstance->Users.FindUUID<LocalUser>(uuid); if (!user || user->client_sa != sa) return; // An IP can have multiple PTR records but it is considered bad practise to have // more than one so to simplify the lookup logic we only use the first. const DNS::ResourceRecord* rr = query->FindAnswerOfType(DNS::QUERY_PTR); if (!rr) { HandleError(user, "Could not resolve your hostname: No " + this->manager->GetTypeStr(this->question.type) + " records found"); return; } LogLookup(*rr, query->cached); auto* res_forward = new UserIPResolver(this->manager, this->creator, user, rr->rdata); try { this->manager->Process(res_forward); } catch (const DNS::Exception& e) { delete res_forward; ServerInstance->Logs.Debug(MODNAME, "Error in resolver: {}", e.GetReason()); HandleError(user, "There was an internal error resolving your host"); } } }; class ModuleHostnameLookup final : public Module { private: BoolExtItem dnsLookup; DNS::ManagerRef DNS; public: ModuleHostnameLookup() : Module(VF_CORE | VF_VENDOR, "Provides support for DNS lookups on connecting clients") , dnsLookup(this, "dns-lookup", ExtensionType::USER) , DNS(this) { dl = &dnsLookup; } void OnChangeRemoteAddress(LocalUser* user) override { // If core_dns is not loaded or hostname resolution is disabled for the user's // connect class then the logic in this function does not apply. if (!DNS || user->quitting || !user->GetClass()->resolvehostnames) return; // Clients can't have a DNS hostname if they aren't connected via IPv4 or IPv6. if (!user->client_sa.is_ip()) return; user->WriteNotice("*** Looking up your hostname..."); auto* res_reverse = new UserHostResolver(*this->DNS, this, user); try { /* If both the reverse and forward queries are cached, the user will be able to pass DNS completely * before Process() completes, which is why dnsLookup.set() is here, before Process() */ this->dnsLookup.Set(user); this->DNS->Process(res_reverse); } catch (const DNS::Exception& e) { this->dnsLookup.Unset(user); delete res_reverse; ServerInstance->Logs.Debug(MODNAME, "Error in resolver: {}", e.GetReason()); } } ModResult OnCheckReady(LocalUser* user) override { return this->dnsLookup.Get(user) ? MOD_RES_DENY : MOD_RES_PASSTHRU; } }; MODULE_INIT(ModuleHostnameLookup) ���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/src/coremods/core_info/��������������������������������������������������������������0000775�0000000�0000000�00000000000�14771603147�0017714�5����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/src/coremods/core_info/cmd_admin.cpp�������������������������������������������������0000664�0000000�0000000�00000003502�14771603147�0022333�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2018, 2020-2022 Sadie Powell <sadie@witchery.services> * Copyright (C) 2014, 2016 Attila Molnar <attilamolnar@hush.com> * Copyright (C) 2012 Robby <robby@chatbelgie.be> * Copyright (C) 2009 Uli Schlachter <psychon@znc.in> * Copyright (C) 2009 Daniel De Graaf <danieldg@inspircd.org> * Copyright (C) 2006 Craig Edwards <brain@inspircd.org> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include "inspircd.h" #include "core_info.h" enum { // From RFC 1459. RPL_ADMINME = 256, RPL_ADMINLOC1 = 257, RPL_ADMINLOC2 = 258, RPL_ADMINEMAIL = 259, }; CommandAdmin::CommandAdmin(Module* parent) : ServerTargetCommand(parent, "ADMIN") { penalty = 2000; syntax = { "[<servername>]" }; } CmdResult CommandAdmin::Handle(User* user, const Params& parameters) { if (!parameters.empty() && !irc::equals(parameters[0], ServerInstance->Config->ServerName)) return CmdResult::SUCCESS; user->WriteRemoteNumeric(RPL_ADMINME, ServerInstance->Config->GetServerName(), "Administrative info"); user->WriteRemoteNumeric(RPL_ADMINLOC1, adminname); if (!admindesc.empty()) user->WriteRemoteNumeric(RPL_ADMINLOC2, admindesc); user->WriteRemoteNumeric(RPL_ADMINEMAIL, adminemail); return CmdResult::SUCCESS; } ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/src/coremods/core_info/cmd_commands.cpp����������������������������������������������0000664�0000000�0000000�00000005513�14771603147�0023050�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2017, 2020-2024 Sadie Powell <sadie@witchery.services> * Copyright (C) 2014, 2016 Attila Molnar <attilamolnar@hush.com> * Copyright (C) 2012 Robby <robby@chatbelgie.be> * Copyright (C) 2009 Uli Schlachter <psychon@znc.in> * Copyright (C) 2009 Daniel De Graaf <danieldg@inspircd.org> * Copyright (C) 2007-2008 Craig Edwards <brain@inspircd.org> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include "inspircd.h" #include "core_info.h" enum { // InspIRCd-specific. RPL_COMMANDS = 700, RPL_COMMANDSEND = 701 }; CommandCommands::CommandCommands(Module* parent) : SplitCommand(parent, "COMMANDS") { penalty = 3000; } CmdResult CommandCommands::HandleLocal(LocalUser* user, const Params& parameters) { std::vector<Numeric::Numeric> numerics; numerics.reserve(ServerInstance->Parser.GetCommands().size()); for (const auto& [_, command] : ServerInstance->Parser.GetCommands()) { // Don't show privileged commands to users without the privilege. bool usable = true; switch (command->access_needed) { case CmdAccess::NORMAL: // Everyone can use user commands. break; case CmdAccess::OPERATOR: // Only opers can use oper commands. usable = user->HasCommandPermission(command->name); break; case CmdAccess::SERVER: // Nobody can use server commands. usable = false; break; } // Only send this command to the user if: // 1. It is usable by the caller. // 2. The caller has the servers/auspex priv. if (!usable && !user->HasPrivPermission("servers/auspex")) continue; Numeric::Numeric numeric(RPL_COMMANDS); numeric.push(command->name); numeric.push(ModuleManager::ShrinkModName(command->creator->ModuleFile)); numeric.push(command->min_params); if (command->max_params < command->min_params) numeric.push("*"); else numeric.push(command->max_params); numeric.push(command->penalty); numerics.push_back(numeric); } // Sort alphabetically by command name. std::sort(numerics.begin(), numerics.end(), [](const auto& lhs, const auto& rhs) { return lhs.GetParams()[0] > rhs.GetParams()[0]; }); for (const auto& numeric : numerics) user->WriteNumeric(numeric); user->WriteNumeric(RPL_COMMANDSEND, "End of COMMANDS list"); return CmdResult::SUCCESS; } �������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/src/coremods/core_info/cmd_info.cpp��������������������������������������������������0000664�0000000�0000000�00000006173�14771603147�0022205�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2020-2022, 2024 Sadie Powell <sadie@witchery.services> * Copyright (C) 2015 Robin Burchell <robin+git@viroteck.net> * Copyright (C) 2013-2014, 2016 Attila Molnar <attilamolnar@hush.com> * Copyright (C) 2012, 2019 Robby <robby@chatbelgie.be> * Copyright (C) 2009-2010 Daniel De Graaf <danieldg@inspircd.org> * Copyright (C) 2007 Craig Edwards <brain@inspircd.org> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include "inspircd.h" #include "core_info.h" enum { // From RFC 1459 RPL_INFO = 371, RPL_ENDOFINFO = 374, }; CommandInfo::CommandInfo(Module* parent) : SplitCommand(parent, "INFO") { penalty = 3000; } static const char* const lines[] = { " -/\\- \002InspIRCd\002 -\\/-", " November 2002 - Present", " ", "\002Core Developers\002:", " Matt Schatz (genius3000) Sadie Powell (Sadie)", " ", "\002Former Developers\002:", " Attila Molnar (Attila) Daniel De Graaf (danieldg)", " Dennis Friis (peavey) John Brooks (special)", " Matt Smith (dz) Oliver Lupton (Om)", " Thomas Stagner (aquanight) Uli Schlachter (psychon)", " ", "\002Founding Developers\002:", " Craig Edwards (Brain) Craig McLure (FrostyCoolSlug)", " Robin Burchell (w00t)", " ", "\002Active Contributors\002:", " Adam progval", " ", "\002Former Contributors\002:", " Adremelech Ankit AnMaster Bricker", " BuildSmart Burlex CC ChrisTX", " Dan djGrrr dmb eggy", " fraggeln GreenReaper HiroP jackmcbarn", " jamie Jason jilles John2", " kaniini LeaChim linuxdaemon MacGyver", " majic Namegduf owine Phoenix", " pippijn praetorian Quension Robby", " satmd Shawn Sheogorath Shutter", " skenmy Skip Stskeeps Taros", " ThaPrince Thunderhacker typobox43 Zaba", " ", "\002Thanks To\002:", " Asmo Brik dan- Duck", " jwheare prawnsalad", " ", " Best experienced with \002an IRC client\002", nullptr }; CmdResult CommandInfo::HandleLocal(LocalUser* user, const Params& parameters) { for (size_t idx = 0; lines[idx]; ++idx) user->WriteRemoteNumeric(RPL_INFO, lines[idx]); user->WriteRemoteNumeric(RPL_ENDOFINFO, "End of /INFO list"); return CmdResult::SUCCESS; } �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/src/coremods/core_info/cmd_modules.cpp�����������������������������������������������0000664�0000000�0000000�00000005025�14771603147�0022715�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2017-2022, 2024 Sadie Powell <sadie@witchery.services> * Copyright (C) 2014, 2016 Attila Molnar <attilamolnar@hush.com> * Copyright (C) 2013 Daniel Vassdal <shutter@canternet.org> * Copyright (C) 2012 Robby <robby@chatbelgie.be> * Copyright (C) 2009 Uli Schlachter <psychon@znc.in> * Copyright (C) 2009 Daniel De Graaf <danieldg@inspircd.org> * Copyright (C) 2007 Dennis Friis <peavey@inspircd.org> * Copyright (C) 2005, 2007 Craig Edwards <brain@inspircd.org> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include "inspircd.h" #include "dynamic.h" #include "core_info.h" enum { // From ircd-ratbox with an InspIRCd-specific format. RPL_MODLIST = 702, RPL_ENDOFMODLIST = 703 }; CommandModules::CommandModules(Module* parent) : ServerTargetCommand(parent, "MODULES") { penalty = 4000; syntax = { "[<servername>]" }; } CmdResult CommandModules::Handle(User* user, const Params& parameters) { // Don't ask remote servers about their modules unless the local user asking is an oper // 2.0 asks anyway, so let's handle that the same way bool for_us = (parameters.empty() || irc::equals(parameters[0], ServerInstance->Config->ServerName)); if ((!for_us) || (!IS_LOCAL(user))) { if (!user->IsOper()) { user->WriteNotice("*** You cannot check what modules other servers have loaded."); return CmdResult::FAILURE; } // From an oper and not for us, forward if (!for_us) return CmdResult::SUCCESS; } bool has_priv = IS_LOCAL(user) && user->HasPrivPermission("servers/auspex"); for (const auto& [modname, mod] : ServerInstance->Modules.GetModules()) { const auto version = has_priv ? mod->GetVersion() : "*"; const auto props = has_priv ? mod->GetPropertyString() : "*"; user->WriteRemoteNumeric(RPL_MODLIST, ModuleManager::ShrinkModName(modname), version, props, mod->description); } user->WriteRemoteNumeric(RPL_ENDOFMODLIST, "End of MODULES list"); return CmdResult::SUCCESS; } �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/src/coremods/core_info/cmd_motd.cpp��������������������������������������������������0000664�0000000�0000000�00000004453�14771603147�0022214�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2018, 2020-2023 Sadie Powell <sadie@witchery.services> * Copyright (C) 2013-2016 Attila Molnar <attilamolnar@hush.com> * Copyright (C) 2012 Robby <robby@chatbelgie.be> * Copyright (C) 2009-2010 Daniel De Graaf <danieldg@inspircd.org> * Copyright (C) 2006 Craig Edwards <brain@inspircd.org> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include "inspircd.h" #include "core_info.h" enum { // From RFC 1459 RPL_MOTD = 372, RPL_MOTDSTART = 375, RPL_ENDOFMOTD = 376, ERR_NOMOTD = 422, }; CommandMotd::CommandMotd(Module* parent) : ServerTargetCommand(parent, "MOTD") { syntax = { "[<servername>]" }; } CmdResult CommandMotd::Handle(User* user, const Params& parameters) { if (!parameters.empty() && !irc::equals(parameters[0], ServerInstance->Config->ServerName)) { // Give extra penalty if a non-oper queries the /MOTD of a remote server LocalUser* localuser = IS_LOCAL(user); if ((localuser) && (!user->IsOper())) localuser->CommandFloodPenalty += 2000; return CmdResult::SUCCESS; } auto tag = ServerInstance->Config->EmptyTag; LocalUser* localuser = IS_LOCAL(user); if (localuser) tag = localuser->GetClass()->config; const std::string motd_name = tag->getString("motd", "motd", 1); auto motd = motds.find(motd_name); if (motd == motds.end()) { user->WriteRemoteNumeric(ERR_NOMOTD, "There is no message of the day."); return CmdResult::SUCCESS; } user->WriteRemoteNumeric(RPL_MOTDSTART, INSP_FORMAT("{} message of the day:", ServerInstance->Config->GetServerName())); for (const auto& line : motd->second) user->WriteRemoteNumeric(RPL_MOTD, line); user->WriteRemoteNumeric(RPL_ENDOFMOTD, "End of message of the day."); return CmdResult::SUCCESS; } ���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/src/coremods/core_info/cmd_servlist.cpp����������������������������������������������0000664�0000000�0000000�00000003632�14771603147�0023122�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2020-2022 Sadie Powell <sadie@witchery.services> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include "inspircd.h" #include "core_info.h" enum { // From RFC 2812. RPL_SERVLIST = 234, RPL_SERVLISTEND = 235 }; CommandServList::CommandServList(Module* parent) : SplitCommand(parent, "SERVLIST") , invisiblemode(parent, "invisible") { syntax = { "[<nick> [<oper-type>]]" }; } CmdResult CommandServList::HandleLocal(LocalUser* user, const Params& parameters) { const std::string& mask = parameters.empty() ? "*" : parameters[0]; const bool has_type = parameters.size() > 1; for (const auto* serviceuser : ServerInstance->Users.all_services) { if (serviceuser->IsModeSet(invisiblemode) || !InspIRCd::Match(serviceuser->nick, mask)) continue; if (has_type && (!serviceuser->IsOper() || !InspIRCd::Match(serviceuser->oper->GetType(), parameters[2]))) continue; Numeric::Numeric numeric(RPL_SERVLIST); numeric .push(serviceuser->nick) .push(serviceuser->server->GetPublicName()) .push("*") .push(serviceuser->IsOper() ? serviceuser->oper->GetType() : "*") .push(0) .push(serviceuser->GetRealName()); user->WriteNumeric(numeric); } user->WriteNumeric(RPL_SERVLISTEND, mask, has_type ? parameters[1] : "*", "End of service listing"); return CmdResult::SUCCESS; } ������������������������������������������������������������������������������������������������������inspircd-4.7.0/src/coremods/core_info/cmd_time.cpp��������������������������������������������������0000664�0000000�0000000�00000003324�14771603147�0022203�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2018, 2020, 2022-2023, 2025 Sadie Powell <sadie@witchery.services> * Copyright (C) 2014, 2016 Attila Molnar <attilamolnar@hush.com> * Copyright (C) 2012 Robby <robby@chatbelgie.be> * Copyright (C) 2009-2010 Daniel De Graaf <danieldg@inspircd.org> * Copyright (C) 2009 Uli Schlachter <psychon@znc.in> * Copyright (C) 2007 Dennis Friis <peavey@inspircd.org> * Copyright (C) 2006 Craig Edwards <brain@inspircd.org> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include "inspircd.h" #include "timeutils.h" #include "core_info.h" CommandTime::CommandTime(Module* parent) : ServerTargetCommand(parent, "TIME") { syntax = { "[<servername>]" }; } CmdResult CommandTime::Handle(User* user, const Params& parameters) { if (!parameters.empty() && !irc::equals(parameters[0], ServerInstance->Config->ServerName)) return CmdResult::SUCCESS; auto timestr = Time::ToString(ServerInstance->Time(), Time::DEFAULT_LONG); timestr += INSP_FORMAT(" ({})", ServerInstance->Time()); user->WriteRemoteNumeric(RPL_TIME, ServerInstance->Config->GetServerName(), timestr); return CmdResult::SUCCESS; } ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/src/coremods/core_info/cmd_version.cpp�����������������������������������������������0000664�0000000�0000000�00000003720�14771603147�0022732�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2018, 2020, 2022-2023 Sadie Powell <sadie@witchery.services> * Copyright (C) 2014 Attila Molnar <attilamolnar@hush.com> * Copyright (C) 2012 Robby <robby@chatbelgie.be> * Copyright (C) 2009 Uli Schlachter <psychon@znc.in> * Copyright (C) 2009 Daniel De Graaf <danieldg@inspircd.org> * Copyright (C) 2006 Craig Edwards <brain@inspircd.org> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include "inspircd.h" #include "core_info.h" CommandVersion::CommandVersion(Module* parent, ISupportManager& isupportmgr) : Command(parent, "VERSION") , isupport(isupportmgr) , operversion(RPL_VERSION) , version(RPL_VERSION) { syntax = { "[<servername>]" }; } void CommandVersion::BuildNumerics() { version.GetParams().clear(); version.push(INSPIRCD_BRANCH "."); version.push(ServerInstance->Config->GetServerName()); version.push(ServerInstance->Config->CustomVersion); operversion.GetParams().clear(); operversion.push(INSPIRCD_VERSION "."); operversion.push(ServerInstance->Config->ServerName); operversion.push("[" + ServerInstance->Config->ServerId + "] " + ServerInstance->Config->CustomVersion); } CmdResult CommandVersion::Handle(User* user, const Params& parameters) { user->WriteNumeric(user->IsOper() ? operversion : version); LocalUser* luser = IS_LOCAL(user); if (luser) isupport.SendTo(luser); return CmdResult::SUCCESS; } ������������������������������������������������inspircd-4.7.0/src/coremods/core_info/core_info.cpp�������������������������������������������������0000664�0000000�0000000�00000016746�14771603147�0022401�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2021 Herman <GermanAizek@yandex.ru> * Copyright (C) 2018-2025 Sadie Powell <sadie@witchery.services> * Copyright (C) 2018 linuxdaemon <linuxdaemon.irc@gmail.com> * Copyright (C) 2014, 2016, 2018 Attila Molnar <attilamolnar@hush.com> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include "inspircd.h" #include "clientprotocolmsg.h" #include "timeutils.h" #include "core_info.h" enum { // From RFC 2812. RPL_WELCOME = 1, RPL_YOURHOST = 2, RPL_CREATED = 3, RPL_MYINFO = 4 }; RouteDescriptor ServerTargetCommand::GetRouting(User* user, const Params& parameters) { // Parameter must be a server name, not a nickname or uuid if ((!parameters.empty()) && (parameters[0].find('.') != std::string::npos)) return ROUTE_UNICAST(parameters[0]); return ROUTE_LOCALONLY; } struct ISupportAction final : public ActionBase { ISupportManager& isupport; ISupportAction(ISupportManager& i) : isupport(i) { } void Call() override { isupport.Build(); ServerInstance->GlobalCulls.AddItem(this); } }; class CoreModInfo final : public Module , public ISupport::EventListener { private: CommandAdmin cmdadmin; CommandCommands cmdcommands; CommandInfo cmdinfo; CommandModules cmdmodules; CommandMotd cmdmotd; CommandServList cmdservlist; CommandTime cmdtime; ISupportManager isupport; CommandVersion cmdversion; Numeric::Numeric numeric003; Numeric::Numeric numeric004; /** Returns a list of user or channel mode characters. * Used for constructing the parts of the mode list in the 004 numeric. * @param mt Controls whether to list user modes or channel modes * @param needparam Return modes only if they require a parameter to be set * @return The available mode letters that satisfy the given conditions */ static std::string CreateModeList(ModeType mt, bool needparam = false) { std::string modestr; for (const auto& [_, mh] : ServerInstance->Modes.GetModes(mt)) { if (!needparam || mh->NeedsParam(true)) modestr.push_back(mh->GetModeChar()); } std::sort(modestr.begin(), modestr.end()); return modestr; } void Rebuild004() { std::vector<std::string>& params = numeric004.GetParams(); params.erase(params.begin()+2, params.end()); // Create lists of modes // 1. User modes // 2. Channel modes // 3. Channel modes that require a parameter when set numeric004.push(CreateModeList(MODETYPE_USER)); numeric004.push(CreateModeList(MODETYPE_CHANNEL)); numeric004.push(CreateModeList(MODETYPE_CHANNEL, true)); } public: CoreModInfo() : Module(VF_CORE | VF_VENDOR, "Provides the ADMIN, COMMANDS, INFO, MODULES, MOTD, TIME, SERVLIST, and VERSION commands") , ISupport::EventListener(this) , cmdadmin(this) , cmdcommands(this) , cmdinfo(this) , cmdmodules(this) , cmdmotd(this) , cmdservlist(this) , cmdtime(this) , isupport(this) , cmdversion(this, isupport) , numeric003(RPL_CREATED) , numeric004(RPL_MYINFO) { numeric003.push(Time::ToString(ServerInstance->startup_time, "This server was created on %d %b %Y at %H:%M:%S %Z", true)); numeric004.push(ServerInstance->Config->GetServerName()); numeric004.push(INSPIRCD_BRANCH); } void ReadConfig(ConfigStatus& status) override { // Process the escape codes in the MOTDs. CommandMotd::MessageCache newmotds; for (const auto& klass : ServerInstance->Config->Classes) { // Don't process the file if it has already been processed. const std::string motd = klass->config->getString("motd", "motd"); if (newmotds.find(motd) != newmotds.end()) continue; auto file = ServerInstance->Config->ReadFile(motd); if (!file) { // We can't process the file if it doesn't exist. ServerInstance->Logs.Warning(MODNAME, "Unable to read motd for connect class \"{}\" at {}: {}", klass->GetName(), klass->config->source.str(), file.error); continue; } // Process the MOTD entry. auto& newmotd = newmotds[motd]; irc::sepstream linestream(file.contents, '\n', true); for (std::string line; linestream.GetToken(line); ) { // Some clients can not handle receiving RPL_MOTD with an empty // trailing parameter so if a line is empty we replace it with // a single space. InspIRCd::ProcessColors(line); newmotd.push_back(line.empty() ? " " : line); } } cmdmotd.motds.swap(newmotds); const auto& tag = ServerInstance->Config->ConfValue("admin"); cmdadmin.adminname = tag->getString("name", tag->getString("nick", ServerInstance->Config->Network + " Admins", 1)); cmdadmin.admindesc = tag->getString("description"); cmdadmin.adminemail = tag->getString("email", "noreply@" + ServerInstance->Config->GetServerName(), 1); Rebuild004(); cmdversion.BuildNumerics(); ServerInstance->AtomicActions.AddAction(new ISupportAction(isupport)); } void OnChangeConnectClass(LocalUser* user, const std::shared_ptr<ConnectClass>& klass, bool force) override { // TODO: this should be OnPostChangeConnectClass but we need the old // connect class which isn't exposed to the module interface and we // can't break the API in a stable release. For now we use this and // prioritise it to be after core_user checks whether the user needs // to die. if (user->IsFullyConnected() && !user->quitting) isupport.ChangeClass(user, user->GetClass(), klass); } void OnUserConnect(LocalUser* user) override { user->WriteNumeric(RPL_WELCOME, INSP_FORMAT("Welcome to the {} IRC Network {}", ServerInstance->Config->Network, user->GetRealMask())); user->WriteNumeric(RPL_YOURHOST, INSP_FORMAT("Your host is {}, running version {}", ServerInstance->Config->GetServerName(), INSPIRCD_BRANCH)); user->WriteNumeric(numeric003); user->WriteNumeric(numeric004); isupport.SendTo(user); /* Trigger MOTD and LUSERS output, give modules a chance too */ ModResult modres; std::string command("LUSERS"); CommandBase::Params parameters; FIRST_MOD_RESULT(OnPreCommand, modres, (command, parameters, user, true)); if (!modres) ServerInstance->Parser.CallHandler(command, parameters, user); modres = MOD_RES_PASSTHRU; command = "MOTD"; FIRST_MOD_RESULT(OnPreCommand, modres, (command, parameters, user, true)); if (!modres) ServerInstance->Parser.CallHandler(command, parameters, user); if (ServerInstance->Config->RawLog) Log::NotifyRawIO(user, MessageType::PRIVMSG); } void OnLoadModule(Module* mod) override { isupport.Build(); } void OnUnloadModule(Module* mod) override { isupport.Build(); } void OnServiceAdd(ServiceProvider& service) override { if (service.service == SERVICE_MODE) Rebuild004(); } void OnServiceDel(ServiceProvider& service) override { if (service.service == SERVICE_MODE) Rebuild004(); } void Prioritize() override { ServerInstance->Modules.SetPriority(this, I_OnUserConnect, PRIORITY_FIRST); } void OnBuildClassISupport(const std::shared_ptr<ConnectClass>& klass, ISupport::TokenMap& tokens) override { if (klass->fakelag) tokens["SAFERATE"]; } }; MODULE_INIT(CoreModInfo) ��������������������������inspircd-4.7.0/src/coremods/core_info/core_info.h���������������������������������������������������0000664�0000000�0000000�00000011700�14771603147�0022027�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2018-2025 Sadie Powell <sadie@witchery.services> * Copyright (C) 2014, 2016 Attila Molnar <attilamolnar@hush.com> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #pragma once #include "inspircd.h" #include "modules/isupport.h" /** This class manages the generation and transmission of ISUPPORT. */ class ISupportManager final { private: /** The generated numerics which are sent to clients. */ typedef std::vector<Numeric::Numeric> NumericList; typedef insp::flat_map<std::shared_ptr<ConnectClass>, NumericList> NumericMap; NumericMap cachednumerics; /** The tokens which were generated by the last update. */ typedef insp::flat_map<std::shared_ptr<ConnectClass>, ISupport::TokenMap> TokenMap; TokenMap cachedtokens; /** Provider for the ISupport::EventListener event. */ ISupport::EventProvider isupportevprov; /** Escapes an ISUPPORT token value and appends it to the buffer. * @param buffer The buffer to append to. * @param value An ISUPPORT token value. */ static void AppendValue(std::string& buffer, const std::string& value); // Builds the ISUPPORT tokens for a specific connect class. void BuildClass(ISupport::TokenMap& newtokens, NumericList& newnumerics, NumericList& diffnumerics, const std::shared_ptr<ConnectClass>& klass); /** Builds the ISUPPORT numerics from a list of tokens. * @param tokens The tokens to build from. * @param numerics The location to store the built numeric lists. */ static void BuildNumerics(ISupport::TokenMap& tokens, std::vector<Numeric::Numeric>& numerics); public: ISupportManager(Module* mod); /** (Re)build the ISUPPORT vector. * Called by the core on boot after all modules have been loaded, and every time when a module is loaded * or unloaded. Calls the OnBuildISupport hook, letting modules manipulate the ISUPPORT tokens. */ void Build(); /** Sends an 005 (ISUPPORT) diff from the old class to the new one. * @param user The user to send the diff to. * @param oldclass The connect class the user is moving from. * @param newclass The conenct class the user is moving to. */ void ChangeClass(LocalUser* user, const std::shared_ptr<ConnectClass>& oldclass, const std::shared_ptr<ConnectClass>& newclass); /** Send the 005 numerics (ISUPPORT) to a user. * @param user The user to send the ISUPPORT numerics to */ void SendTo(LocalUser* user); }; /** These commands require no parameters, but if there is a parameter it is a server name where the command will be routed to. */ class ServerTargetCommand : public Command { public: ServerTargetCommand(Module* mod, const std::string& Name) : Command(mod, Name) { } RouteDescriptor GetRouting(User* user, const Params& parameters) override; }; class CommandAdmin final : public ServerTargetCommand { public: std::string adminname; std::string admindesc; std::string adminemail; CommandAdmin(Module* parent); CmdResult Handle(User* user, const Params& parameters) override; }; class CommandCommands final : public SplitCommand { public: CommandCommands(Module* parent); CmdResult HandleLocal(LocalUser* user, const Params& parameters) override; }; class CommandInfo final : public SplitCommand { public: CommandInfo(Module* parent); CmdResult HandleLocal(LocalUser* user, const Params& parameters) override; }; class CommandModules final : public ServerTargetCommand { public: CommandModules(Module* parent); CmdResult Handle(User* user, const Params& parameters) override; }; class CommandMotd final : public ServerTargetCommand { public: typedef insp::flat_map<std::string, std::vector<std::string>> MessageCache; MessageCache motds; CommandMotd(Module* parent); CmdResult Handle(User* user, const Params& parameters) override; }; class CommandServList final : public SplitCommand { private: UserModeReference invisiblemode; public: CommandServList(Module* parent); CmdResult HandleLocal(LocalUser* user, const Params& parameters) override; }; class CommandTime final : public ServerTargetCommand { public: CommandTime(Module* parent); CmdResult Handle(User* user, const Params& parameters) override; }; class CommandVersion final : public Command { private: ISupportManager& isupport; Numeric::Numeric operversion; Numeric::Numeric version; public: CommandVersion(Module* parent, ISupportManager& isupportmgr); void BuildNumerics(); CmdResult Handle(User* user, const Params& parameters) override; }; ����������������������������������������������������������������inspircd-4.7.0/src/coremods/core_info/isupport.cpp��������������������������������������������������0000664�0000000�0000000�00000015766�14771603147�0022324�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2020-2025 Sadie Powell <sadie@witchery.services> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include "inspircd.h" #include "utility/map.h" #include "core_info.h" namespace { void TokenDifference(ISupport::TokenMap& tokendiff, const ISupport::TokenMap& oldtokens, const ISupport::TokenMap& newtokens) { std::map<std::string, std::pair<std::optional<std::string>, std::optional<std::string>>, irc::insensitive_swo> changedtokens; insp::map::difference(oldtokens, newtokens, changedtokens); for (const auto& [name, values] : changedtokens) { if (values.first && !values.second) { // The token was removed. tokendiff["-" + name]; } else if (values.second) { // The token was added or its value changed. tokendiff[name] = *values.second; } } } } ISupportManager::ISupportManager(Module* mod) : isupportevprov(mod) { } void ISupportManager::AppendValue(std::string& buffer, const std::string& value) { // If this token has no value then we have nothing to do. if (value.empty()) return; // This function implements value escaping according to the rules of the ISUPPORT draft: // https://tools.ietf.org/html/draft-brocklesby-irc-isupport-03 buffer.push_back('='); for (const auto chr : value) { // The value must be escaped if: // (1) It is a banned character in an IRC <middle> parameter (NUL, LF, CR, SPACE). // (2) It has special meaning within an ISUPPORT token (EQUALS, BACKSLASH). if (chr == '\0' || chr == '\n' || chr == '\r' || chr == ' ' || chr == '=' || chr == '\\') buffer.append(INSP_FORMAT("\\x{:02X}", chr)); else buffer.push_back(chr); } } void ISupportManager::BuildClass(ISupport::TokenMap& newtokens, NumericList& newnumerics, NumericList& diffnumerics, const std::shared_ptr<ConnectClass> &klass) { isupportevprov.Call(&ISupport::EventListener::OnBuildClassISupport, klass, newtokens); // Transform the map into a list of numerics ready to be sent to clients. BuildNumerics(newtokens, newnumerics); // Extract the tokens which have been updated. auto oldtokens = cachedtokens.find(klass); if (oldtokens != cachedtokens.end()) { // Build the updated numeric diff to send to to existing users. ISupport::TokenMap difftokens; TokenDifference(difftokens, oldtokens->second, newtokens); BuildNumerics(difftokens, diffnumerics); } } void ISupportManager::Build() { // Modules can add new tokens and also edit or remove existing tokens. ISupport::TokenMap tokens = { { "AWAYLEN", ConvToStr(ServerInstance->Config->Limits.MaxAway) }, { "CASEMAPPING", ServerInstance->Config->CaseMapping }, { "CHANNELLEN", ConvToStr(ServerInstance->Config->Limits.MaxChannel) }, { "CHANTYPES", "#" }, { "HOSTLEN", ConvToStr(ServerInstance->Config->Limits.MaxHost) }, { "KICKLEN", ConvToStr(ServerInstance->Config->Limits.MaxKick) }, { "LINELEN", ConvToStr(ServerInstance->Config->Limits.MaxLine) }, { "MAXTARGETS", ConvToStr(ServerInstance->Config->MaxTargets) }, { "MODES", ConvToStr(ServerInstance->Config->Limits.MaxModes) }, { "NETWORK", ServerInstance->Config->Network }, { "NAMELEN", ConvToStr(ServerInstance->Config->Limits.MaxReal) }, { "NICKLEN", ConvToStr(ServerInstance->Config->Limits.MaxNick) }, { "TOPICLEN", ConvToStr(ServerInstance->Config->Limits.MaxTopic) }, { "USERLEN", ConvToStr(ServerInstance->Config->Limits.MaxUser) }, }; isupportevprov.Call(&ISupport::EventListener::OnBuildISupport, tokens); NumericMap diffnumerics; NumericMap newnumerics; TokenMap newtokens; for (const auto& klass : ServerInstance->Config->Classes) { ServerInstance->Logs.Debug(MODNAME, "Rebuilding isupport for {}", klass->GetName()); newtokens[klass] = tokens; BuildClass(newtokens[klass], newnumerics[klass], diffnumerics[klass], klass); } // Send out the numeric diffs. if (!diffnumerics.empty()) { for (LocalUser* user : ServerInstance->Users.GetLocalUsers()) { const auto& klass = user->GetClass(); if (!(user->connected & User::CONN_FULL)) continue; // User hasn't received 005 yet. auto numerics = diffnumerics.find(klass); if (numerics == diffnumerics.end()) { // The user is in a class which has been removed from the server // config; we need to build a class for them. ServerInstance->Logs.Debug(MODNAME, "Rebuilding isupport for {} (dead)", klass->GetName()); newtokens[klass] = tokens; BuildClass(newtokens[klass], newnumerics[klass], diffnumerics[klass], klass); numerics = diffnumerics.find(klass); } if (numerics == diffnumerics.end()) continue; // Should never happen. for (const auto& numeric : numerics->second) user->WriteNumeric(numeric); } } // Apply the new ISUPPORT values. cachednumerics.swap(newnumerics); cachedtokens.swap(newtokens); } void ISupportManager::BuildNumerics(ISupport::TokenMap& tokens, std::vector<Numeric::Numeric>& numerics) { Numeric::Numeric numeric(RPL_ISUPPORT); for (ISupport::TokenMap::const_iterator it = tokens.begin(); it != tokens.end(); ++it) { numeric.push(it->first); std::string& token = numeric.GetParams().back(); AppendValue(token, it->second); if (numeric.GetParams().size() == 12 || std::distance(it, tokens.cend()) == 1) { // Reached maximum number of tokens for this line or the current token // is the last one; finalize the line and store it for later use. numeric.push("are supported by this server"); numerics.push_back(numeric); numeric.GetParams().clear(); } } } void ISupportManager::ChangeClass(LocalUser* user, const std::shared_ptr<ConnectClass>& oldclass, const std::shared_ptr<ConnectClass>& newclass) { auto oldtokens = cachedtokens.find(oldclass); auto newtokens = cachedtokens.find(newclass); if (oldtokens == cachedtokens.end() || newtokens == cachedtokens.end()) return; // Should never happen. ISupport::TokenMap difftokens; TokenDifference(difftokens, oldtokens->second, newtokens->second); std::vector<Numeric::Numeric> diffnumerics; BuildNumerics(difftokens, diffnumerics); for (const auto& numeric : diffnumerics) user->WriteNumeric(numeric); } void ISupportManager::SendTo(LocalUser* user) { auto numerics = cachednumerics.find(user->GetClass()); if (numerics == cachednumerics.end()) return; // Should never happen. for (const auto& numeric : numerics->second) user->WriteNumeric(numeric); } ����������inspircd-4.7.0/src/coremods/core_list.cpp�����������������������������������������������������������0000664�0000000�0000000�00000015372�14771603147�0020450�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2017-2024 Sadie Powell <sadie@witchery.services> * Copyright (C) 2015 Daniel Vassdal <shutter@canternet.org> * Copyright (C) 2013-2016 Attila Molnar <attilamolnar@hush.com> * Copyright (C) 2012 Robby <robby@chatbelgie.be> * Copyright (C) 2009 Daniel De Graaf <danieldg@inspircd.org> * Copyright (C) 2008 Robin Burchell <robin+git@viroteck.net> * Copyright (C) 2007 Dennis Friis <peavey@inspircd.org> * Copyright (C) 2005-2007 Craig Edwards <brain@inspircd.org> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include "inspircd.h" #include "modules/isupport.h" enum class ShowModes : uint8_t { NOBODY, OPERS, ALL, }; class CommandList final : public Command { private: ChanModeReference secretmode; ChanModeReference privatemode; /** Parses the creation time or topic set time out of a LIST parameter. * @param value The parameter containing a minute count. * @return The UNIX time at \p value minutes ago. */ static time_t ParseMinutes(const std::string& value) { time_t minutes = ConvToNum<time_t>(value.c_str() + 2); if (!minutes) return 0; return ServerInstance->Time() - (minutes * 60); } public: // Whether to show modes in the LIST response. ShowModes showmodes; CommandList(Module* parent) : Command(parent, "LIST") , secretmode(creator, "secret") , privatemode(creator, "private") { penalty = 5000; } CmdResult Handle(User* user, const Params& parameters) override; }; CmdResult CommandList::Handle(User* user, const Params& parameters) { // C: Searching based on creation time, via the "C<val" and "C>val" modifiers // to search for a channel creation time that is lower or higher than val // respectively. time_t mincreationtime = 0; time_t maxcreationtime = 0; // M: Searching based on mask. std::string match; // N: Searching based on !mask. std::string notmatch; // T: Searching based on topic time, via the "T<val" and "T>val" modifiers to // search for a topic time that is lower or higher than val respectively. time_t mintopictime = 0; time_t maxtopictime = 0; // U: Searching based on user count within the channel, via the "<val" and // ">val" modifiers to search for a channel that has less than or more than // val users respectively. size_t minusers = 0; size_t maxusers = 0; if (!parameters.empty()) { irc::commasepstream constraints(parameters[0]); for (std::string constraint; constraints.GetToken(constraint); ) { if (constraint[0] == '<') { maxusers = ConvToNum<size_t>(constraint.c_str() + 1); } else if (constraint[0] == '>') { minusers = ConvToNum<size_t>(constraint.c_str() + 1); } else if (!constraint.compare(0, 2, "C<", 2) || !constraint.compare(0, 2, "c<", 2)) { mincreationtime = ParseMinutes(constraint); } else if (!constraint.compare(0, 2, "C>", 2) || !constraint.compare(0, 2, "c>", 2)) { maxcreationtime = ParseMinutes(constraint); } else if (!constraint.compare(0, 2, "T<", 2) || !constraint.compare(0, 2, "t<", 2)) { mintopictime = ParseMinutes(constraint); } else if (!constraint.compare(0, 2, "T>", 2) || !constraint.compare(0, 2, "t>", 2)) { maxtopictime = ParseMinutes(constraint); } else if (constraint[0] == '!') { // Ensure that the user didn't just run "LIST !". if (constraint.length() > 2) notmatch = constraint.substr(1); } else { match = constraint; } } } const bool has_privs = user->HasPrivPermission("channels/auspex"); const bool show_modes = (showmodes == ShowModes::ALL) || (showmodes == ShowModes::OPERS && has_privs); user->WriteNumeric(RPL_LISTSTART, "Channel", "Users Name"); for (const auto& [_, chan] : ServerInstance->Channels.GetChans()) { // Check the user count if a search has been specified. const size_t users = chan->GetUsers().size(); if ((minusers && users <= minusers) || (maxusers && users >= maxusers)) continue; // Check the creation ts if a search has been specified. const time_t creationtime = chan->age; if ((mincreationtime && creationtime <= mincreationtime) || (maxcreationtime && creationtime >= maxcreationtime)) continue; // Check the topic ts if a search has been specified. const time_t topictime = chan->topicset; if ((mintopictime && (!topictime || topictime <= mintopictime)) || (maxtopictime && (!topictime || topictime >= maxtopictime))) continue; // Attempt to match a glob pattern. if (!match.empty() && !InspIRCd::Match(chan->name, match) && !InspIRCd::Match(chan->topic, match)) continue; // Attempt to match an inverted glob pattern. if (!notmatch.empty() && (InspIRCd::Match(chan->name, notmatch) || InspIRCd::Match(chan->topic, notmatch))) continue; // if the channel is not private/secret, OR the user is on the channel anyway bool n = (has_privs || chan->HasUser(user)); // If we're not in the channel and +s is set on it, we want to ignore it if ((n) || (!chan->IsModeSet(secretmode))) { if ((!n) && (chan->IsModeSet(privatemode))) { // Channel is private (+p) and user is outside/not privileged user->WriteNumeric(RPL_LIST, '*', users, ""); } else if (show_modes) { // Show the list response with the modes and topic. user->WriteNumeric(RPL_LIST, chan->name, users, INSP_FORMAT("[+{}] {}", chan->ChanModes(n), chan->topic)); } else { // Show the list response with just the modes. user->WriteNumeric(RPL_LIST, chan->name, users, chan->topic); } } } user->WriteNumeric(RPL_LISTEND, "End of channel list."); return CmdResult::SUCCESS; } class CoreModList final : public Module , public ISupport::EventListener { private: CommandList cmd; public: CoreModList() : Module(VF_CORE | VF_VENDOR, "Provides the LIST command") , ISupport::EventListener(this) , cmd(this) { } void ReadConfig(ConfigStatus& status) override { const auto& tag = ServerInstance->Config->ConfValue("options"); cmd.showmodes = tag->getEnum("showmodes", ShowModes::OPERS, { { "no", ShowModes::NOBODY }, { "opers", ShowModes::OPERS }, { "yes", ShowModes::ALL }, }); } void OnBuildISupport(ISupport::TokenMap& tokens) override { tokens["ELIST"] = "CMNTU"; tokens["SAFELIST"]; } }; MODULE_INIT(CoreModList) ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/src/coremods/core_loadmodule.cpp�����������������������������������������������������0000664�0000000�0000000�00000006540�14771603147�0021617�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2018-2023 Sadie Powell <sadie@witchery.services> * Copyright (C) 2014, 2016 Attila Molnar <attilamolnar@hush.com> * Copyright (C) 2012 Robby <robby@chatbelgie.be> * Copyright (C) 2009 Daniel De Graaf <danieldg@inspircd.org> * Copyright (C) 2008 Thomas Stagner <aquanight@gmail.com> * Copyright (C) 2007 Dennis Friis <peavey@inspircd.org> * Copyright (C) 2006 Craig Edwards <brain@inspircd.org> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include "inspircd.h" class CommandLoadmodule final : public Command { public: CommandLoadmodule(Module* parent) : Command(parent, "LOADMODULE", 1, 1) { access_needed = CmdAccess::OPERATOR; syntax = { "<modulename>" }; } CmdResult Handle(User* user, const Params& parameters) override; }; CmdResult CommandLoadmodule::Handle(User* user, const Params& parameters) { if (ServerInstance->Modules.Load(parameters[0])) { ServerInstance->SNO.WriteGlobalSno('a', "NEW MODULE: {} loaded {}", user->nick, parameters[0]); user->WriteNumeric(RPL_LOADEDMODULE, parameters[0], "Module successfully loaded."); return CmdResult::SUCCESS; } else { user->WriteNumeric(ERR_CANTLOADMODULE, parameters[0], ServerInstance->Modules.LastError()); return CmdResult::FAILURE; } } class CommandUnloadmodule final : public Command { public: CommandUnloadmodule(Module* parent) : Command(parent, "UNLOADMODULE", 1) { access_needed = CmdAccess::OPERATOR; syntax = { "<modulename>" }; } CmdResult Handle(User* user, const Params& parameters) override; }; CmdResult CommandUnloadmodule::Handle(User* user, const Params& parameters) { if (InspIRCd::Match(parameters[0], "core_*", ascii_case_insensitive_map)) { user->WriteNumeric(ERR_CANTUNLOADMODULE, parameters[0], "You cannot unload core commands!"); return CmdResult::FAILURE; } Module* m = ServerInstance->Modules.Find(parameters[0]); if (m == creator) { user->WriteNumeric(ERR_CANTUNLOADMODULE, parameters[0], "You cannot unload module loading commands!"); return CmdResult::FAILURE; } if (m && ServerInstance->Modules.Unload(m)) { ServerInstance->SNO.WriteGlobalSno('a', "MODULE UNLOADED: {} unloaded {}", user->nick, parameters[0]); user->WriteNumeric(RPL_UNLOADEDMODULE, parameters[0], "Module successfully unloaded."); } else { user->WriteNumeric(ERR_CANTUNLOADMODULE, parameters[0], (m ? ServerInstance->Modules.LastError() : "No such module")); return CmdResult::FAILURE; } return CmdResult::SUCCESS; } class CoreModLoadModule final : public Module { CommandLoadmodule cmdloadmod; CommandUnloadmodule cmdunloadmod; public: CoreModLoadModule() : Module(VF_CORE | VF_VENDOR, "Provides the LOADMODULE and UNLOADMODULE commands") , cmdloadmod(this) , cmdunloadmod(this) { } }; MODULE_INIT(CoreModLoadModule) ����������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/src/coremods/core_lusers.cpp���������������������������������������������������������0000664�0000000�0000000�00000013223�14771603147�0021003�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2018-2025 Sadie Powell <sadie@witchery.services> * Copyright (C) 2012-2013 Attila Molnar <attilamolnar@hush.com> * Copyright (C) 2012 Robby <robby@chatbelgie.be> * Copyright (C) 2009-2010 Daniel De Graaf <danieldg@inspircd.org> * Copyright (C) 2006 Craig Edwards <brain@inspircd.org> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include "inspircd.h" #include "modules/server.h" enum { // From ircu. RPL_STATSCONN = 250, // From RFC 1459. RPL_LUSERCLIENT = 251, RPL_LUSERUNKNOWN = 253, RPL_LUSERCHANNELS = 254, RPL_LUSERME = 255, // From ircd-ratbox? RPL_LOCALUSERS = 265, RPL_GLOBALUSERS = 266, }; struct LusersCounters final { size_t max_local; size_t max_global; size_t max_conns; size_t invisible = 0; size_t global_servers; size_t local_servers; LusersCounters(UserModeReference& invisiblemode) : max_local(ServerInstance->Users.LocalUserCount()) , max_global(ServerInstance->Users.GlobalUserCount()) { for (const auto& [_, u] : ServerInstance->Users.GetUsers()) { if (u->IsModeSet(invisiblemode)) invisible++; } UpdateServerCount(); max_conns = local_servers + max_local; } inline void UpdateMaxUsers() { size_t current = ServerInstance->Users.LocalUserCount(); if (current > max_local) max_local = current; current = ServerInstance->Users.GlobalUserCount(); if (current > max_global) max_global = current; current = local_servers + max_local; if (current > max_conns) max_conns = current; } inline void UpdateServerCount() { // XXX: Currently we don't have a way to find out whether a // server is directly connected from a Server object so we // have to do this via the protocol interface. ProtocolInterface::ServerList serverlist; ServerInstance->PI->GetServerList(serverlist); // If spanningtree is not loaded GetServerList does nothing. global_servers = std::max<size_t>(serverlist.size(), 1); local_servers = 0; for (const auto& server : serverlist) { if (server.parentname == ServerInstance->Config->ServerName) local_servers++; } } }; class CommandLusers final : public Command { private: LusersCounters& counters; public: CommandLusers(Module* parent, LusersCounters& Counters) : Command(parent, "LUSERS") , counters(Counters) { } CmdResult Handle(User* user, const Params& parameters) override; }; CmdResult CommandLusers::Handle(User* user, const Params& parameters) { counters.UpdateMaxUsers(); user->WriteNumeric(RPL_LUSERCLIENT, INSP_FORMAT("There are {} users and {} invisible on {} servers", ServerInstance->Users.GlobalUserCount() - counters.invisible, counters.invisible, counters.global_servers)); size_t opercount = ServerInstance->Users.all_opers.size(); if (opercount) user->WriteNumeric(RPL_LUSEROP, opercount, "operator(s) online"); if (ServerInstance->Users.UnknownUserCount()) user->WriteNumeric(RPL_LUSERUNKNOWN, ServerInstance->Users.UnknownUserCount(), "unknown connections"); user->WriteNumeric(RPL_LUSERCHANNELS, ServerInstance->Channels.GetChans().size(), "channels formed"); user->WriteNumeric(RPL_LUSERME, INSP_FORMAT("I have {} clients and {} servers", ServerInstance->Users.LocalUserCount(), counters.local_servers)); user->WriteNumeric(RPL_LOCALUSERS, INSP_FORMAT("Current local users: {} Max: {}", ServerInstance->Users.LocalUserCount(), counters.max_local)); user->WriteNumeric(RPL_GLOBALUSERS, INSP_FORMAT("Current global users: {} Max: {}", ServerInstance->Users.GlobalUserCount(), counters.max_global)); user->WriteNumeric(RPL_STATSCONN, INSP_FORMAT("Highest connection count: {} ({} clients) ({} connections received)", counters.max_conns, counters.max_local, ServerInstance->Stats.Connects)); return CmdResult::SUCCESS; } class InvisibleWatcher final : public ModeWatcher { size_t& invisible; public: InvisibleWatcher(Module* mod, size_t& Invisible) : ModeWatcher(mod, "invisible", MODETYPE_USER) , invisible(Invisible) { } void AfterMode(User* source, User* dest, Channel* channel, const Modes::Change& change) override { if (!dest->IsFullyConnected()) return; if (change.adding) invisible++; else invisible--; } }; class ModuleLusers final : public Module , public ServerProtocol::LinkEventListener { UserModeReference invisiblemode; LusersCounters counters; CommandLusers cmd; InvisibleWatcher mw; public: ModuleLusers() : Module(VF_CORE | VF_VENDOR, "Provides the LUSERS command") , ServerProtocol::LinkEventListener(this) , invisiblemode(this, "invisible") , counters(invisiblemode) , cmd(this, counters) , mw(this, counters.invisible) { } void OnPostConnect(User* user) override { counters.UpdateMaxUsers(); if (user->IsModeSet(invisiblemode)) counters.invisible++; } void OnUserQuit(User* user, const std::string& message, const std::string& oper_message) override { if (user->IsModeSet(invisiblemode)) counters.invisible--; } void OnServerLink(const Server* server) override { counters.UpdateServerCount(); } void OnServerSplit(const Server* server, bool error) override { counters.UpdateServerCount(); } }; MODULE_INIT(ModuleLusers) �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/src/coremods/core_message.cpp��������������������������������������������������������0000664�0000000�0000000�00000035372�14771603147�0021123�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2017-2024 Sadie Powell <sadie@witchery.services> * Copyright (C) 2013, 2018 Attila Molnar <attilamolnar@hush.com> * Copyright (C) 2012 Robby <robby@chatbelgie.be> * Copyright (C) 2009 Daniel De Graaf <danieldg@inspircd.org> * Copyright (C) 2006-2008 Craig Edwards <brain@inspircd.org> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include "inspircd.h" #include "clientprotocolmsg.h" #include "numericbuilder.h" #include "numerichelper.h" #include "utility/string.h" class MessageDetailsImpl final : public MessageDetails { public: MessageDetailsImpl(MessageType mt, const std::string& msg, const ClientProtocol::TagMap& tags) : MessageDetails(mt, msg, tags) { } bool IsCTCP(std::string_view& name, std::string_view& body) const override { if (!this->IsCTCP()) return false; size_t end_of_name = text.find(' ', 2); size_t end_of_ctcp = text.back() == '\x1' ? 1 : 0; if (end_of_name == std::string::npos) { // The CTCP only contains a name. name = insp::substring_view(text, text.begin() + 1, text.end() - end_of_ctcp); body = std::string_view(); return true; } // The CTCP contains a name and a body. name = insp::substring_view(text, text.begin() + 1, text.begin() + end_of_name); size_t start_of_body = text.find_first_not_of(' ', end_of_name + 1); if (start_of_body == std::string::npos) { // The CTCP body is provided but empty. body = std::string_view(); return true; } // The CTCP body provided was non-empty. body = insp::substring_view(text, text.begin() + start_of_body, text.end() - end_of_ctcp); return true; } bool IsCTCP(std::string_view& name) const override { if (!this->IsCTCP()) return false; size_t end_of_name = text.find(' ', 2); if (end_of_name == std::string::npos) { // The CTCP only contains a name. size_t end_of_ctcp = text.back() == '\x1' ? 1 : 0; name = insp::substring_view(text, text.begin() + 1, text.end() - end_of_ctcp); return true; } // The CTCP contains a name and a body. name = insp::substring_view(text, text.begin() + 1, text.begin() + end_of_name); return true; } bool IsCTCP() const override { // According to draft-oakley-irc-ctcp-02 a valid CTCP must begin with SOH and // contain at least one octet which is not NUL, SOH, CR, LF, or SPACE. As most // of these are restricted at the protocol level we only need to check for SOH // and SPACE. return (text.length() >= 2) && (text[0] == '\x1') && (text[1] != '\x1') && (text[1] != ' '); } }; class CommandMessage final : public Command { private: const MessageType msgtype; static bool FirePreEvents(User* source, MessageTarget& msgtarget, MessageDetails& msgdetails) { // Inform modules that a message wants to be sent. ModResult modres; FIRST_MOD_RESULT(OnUserPreMessage, modres, (source, msgtarget, msgdetails)); if (modres == MOD_RES_DENY) { // Inform modules that a module blocked the message. FOREACH_MOD(OnUserMessageBlocked, (source, msgtarget, msgdetails)); return false; } // Check whether a module zapped the message body. if (msgdetails.text.empty()) { source->WriteNumeric(ERR_NOTEXTTOSEND, "No text to send"); return false; } // Inform modules that a message is about to be sent. FOREACH_MOD(OnUserMessage, (source, msgtarget, msgdetails)); return true; } static CmdResult FirePostEvent(User* source, const MessageTarget& msgtarget, const MessageDetails& msgdetails) { // If the source is local and was not sending a CTCP reply then update their idle time. LocalUser* lsource = IS_LOCAL(source); if (lsource && msgdetails.update_idle && (msgdetails.type != MessageType::NOTICE || !msgdetails.IsCTCP())) lsource->idle_lastmsg = ServerInstance->Time(); // Inform modules that a message was sent. FOREACH_MOD(OnUserPostMessage, (source, msgtarget, msgdetails)); return CmdResult::SUCCESS; } CmdResult HandleChannelTarget(User* source, const Params& parameters, const char* target, PrefixMode* pm) { auto* chan = ServerInstance->Channels.Find(target); if (!chan) { // The target channel does not exist. source->WriteNumeric(Numerics::NoSuchChannel(parameters[0])); return CmdResult::FAILURE; } // Fire the pre-message events. MessageTarget msgtarget(chan, pm ? pm->GetPrefix() : 0); MessageDetailsImpl msgdetails(msgtype, parameters[1], parameters.GetTags()); msgdetails.exemptions.insert(source); if (!FirePreEvents(source, msgtarget, msgdetails)) return CmdResult::FAILURE; // Send the message to the members of the channel. ClientProtocol::Messages::Privmsg privmsg(ClientProtocol::Messages::Privmsg::nocopy, source, chan, msgdetails.text, msgdetails.type, msgtarget.status); privmsg.AddTags(msgdetails.tags_out); privmsg.SetSideEffect(true); chan->Write(ServerInstance->GetRFCEvents().privmsg, privmsg, msgtarget.status, msgdetails.exemptions); // Create the outgoing message and message event. return FirePostEvent(source, msgtarget, msgdetails); } CmdResult HandleServerTarget(User* source, const Params& parameters) { // If the source isn't allowed to mass message users then reject // the attempt to mass-message users. if (!source->HasPrivPermission("users/mass-message")) { source->WriteNumeric(ERR_NOPRIVILEGES, "Permission Denied - You do not have the required operator privileges"); return CmdResult::FAILURE; } // Extract the server glob match from the target parameter. std::string servername(parameters[0], 1); // Fire the pre-message events. MessageTarget msgtarget(&servername); MessageDetailsImpl msgdetails(msgtype, parameters[1], parameters.GetTags()); if (!FirePreEvents(source, msgtarget, msgdetails)) return CmdResult::FAILURE; // If the current server name matches the server name glob then send // the message out to the local users. if (InspIRCd::Match(ServerInstance->Config->ServerName, servername)) { // Create the outgoing message and message event. ClientProtocol::Messages::Privmsg message(ClientProtocol::Messages::Privmsg::nocopy, source, "$*", msgdetails.text, msgdetails.type); message.AddTags(msgdetails.tags_out); message.SetSideEffect(true); ClientProtocol::Event messageevent(ServerInstance->GetRFCEvents().privmsg, message); for (auto* luser : ServerInstance->Users.GetLocalUsers()) { // Don't send to partially connected users or the user who is the source. if (!luser->IsFullyConnected() || luser == source) continue; // Only send to non-exempt users. if (!msgdetails.exemptions.count(luser)) luser->Send(messageevent); } } // Fire the post-message event. return FirePostEvent(source, msgtarget, msgdetails); } CmdResult HandleUserTarget(User* source, const Params& parameters) { User* target; if (IS_LOCAL(source)) { // Local sources can specify either a nick or a nick@server mask as the target. const char* targetserver = strchr(parameters[0].c_str(), '@'); if (targetserver) { // The target is a user on a specific server (e.g. jto@tolsun.oulu.fi). target = ServerInstance->Users.FindNick(parameters[0].substr(0, targetserver - parameters[0].c_str()), true); if (target && strcasecmp(target->server->GetPublicName().c_str(), targetserver + 1) != 0) target = nullptr; } else { // If the source is a local user then we only look up the target by nick. target = ServerInstance->Users.FindNick(parameters[0], true); } } else { // Remote users can only specify a nick or UUID as the target. target = ServerInstance->Users.Find(parameters[0], true); } if (!target) { // The target user does not exist or is not fully connected. source->WriteNumeric(Numerics::NoSuchNick(parameters[0])); return CmdResult::FAILURE; } // Fire the pre-message events. MessageTarget msgtarget(target); MessageDetailsImpl msgdetails(msgtype, parameters[1], parameters.GetTags()); if (!FirePreEvents(source, msgtarget, msgdetails)) return CmdResult::FAILURE; // If the target is away then inform the user. if (target->IsAway() && msgdetails.type == MessageType::PRIVMSG) source->WriteNumeric(RPL_AWAY, target->nick, target->away->message); LocalUser* const localtarget = IS_LOCAL(target); if (localtarget) { // Servers can fake the target of a message when it is sent to an individual user. auto context_tag = parameters.GetTags().find("~context"); const std::string& msgcontext = context_tag == parameters.GetTags().end() ? localtarget->nick : context_tag->second.value; // Send to the target if they are a local user. ClientProtocol::Messages::Privmsg privmsg(ClientProtocol::Messages::Privmsg::nocopy, source, msgcontext, msgdetails.text, msgdetails.type); privmsg.AddTags(msgdetails.tags_out); privmsg.SetSideEffect(true); localtarget->Send(ServerInstance->GetRFCEvents().privmsg, privmsg); } // Fire the post-message event. return FirePostEvent(source, msgtarget, msgdetails); } public: CommandMessage(Module* parent, MessageType mt) : Command(parent, ClientProtocol::Messages::Privmsg::CommandStrFromMsgType(mt), 2, 2) , msgtype(mt) { allow_empty_last_param = true; syntax = { "<target>[,<target>]+ :<message>" }; } CmdResult Handle(User* user, const Params& parameters) override { if (CommandParser::LoopCall(user, this, parameters, 0)) return CmdResult::SUCCESS; // The specified message was empty. if (parameters[1].empty()) { user->WriteNumeric(ERR_NOTEXTTOSEND, "No text to send"); return CmdResult::FAILURE; } // The target is a server glob. if (parameters[0][0] == '$') return HandleServerTarget(user, parameters); // If the message begins with one or more status characters then look them up. const char* target = parameters[0].c_str(); PrefixMode* targetpfx = nullptr; for (PrefixMode* pfx; (pfx = ServerInstance->Modes.FindPrefix(target[0])); ++target) { // We want the lowest ranked prefix specified. if (!targetpfx || pfx->GetPrefixRank() < targetpfx->GetPrefixRank()) targetpfx = pfx; } if (!target[0]) { // The target consisted solely of prefix modes. user->WriteNumeric(ERR_NORECIPIENT, "No recipient given"); return CmdResult::FAILURE; } // The target is a channel name. if (ServerInstance->Channels.IsPrefix(*target)) return HandleChannelTarget(user, parameters, target, targetpfx); // The target is a nickname. return HandleUserTarget(user, parameters); } RouteDescriptor GetRouting(User* user, const Params& parameters) override { if (IS_LOCAL(user)) // This is handled by the OnUserPostMessage hook to split the LoopCall pieces return ROUTE_LOCALONLY; else return ROUTE_MESSAGE(parameters[0]); } }; class CommandSQuery final : public Command { public: CommandSQuery(Module* Creator) : Command(Creator, "SQUERY", 2, 2) { allow_empty_last_param = true; syntax = { "<service> :<message>" }; translation = { TR_NICK, TR_TEXT }; } CmdResult Handle(User* user, const Params& parameters) override { // The specified message was empty. if (parameters[1].empty()) { user->WriteRemoteNumeric(ERR_NOTEXTTOSEND, "No text to send"); return CmdResult::FAILURE; } User* target; if (IS_LOCAL(user)) { // Local sources can specify either a nick or a nick@server mask as the target. const char* targetserver = strchr(parameters[0].c_str(), '@'); if (targetserver) { // The target is a user on a specific server (e.g. jto@tolsun.oulu.fi). target = ServerInstance->Users.FindNick(parameters[0].substr(0, targetserver - parameters[0].c_str()), true); if (target && strcasecmp(target->server->GetPublicName().c_str(), targetserver + 1) != 0) target = nullptr; } else { // If the source is a local user then we only look up the target by nick. target = ServerInstance->Users.FindNick(parameters[0], true); } } else { // Remote users can only specify a nick or UUID as the target. target = ServerInstance->Users.Find(parameters[0], true); } if (!target || !target->server->IsService()) { // The target user does not exist, is not fully connected, or is not a service. user->WriteRemoteNumeric(ERR_NOSUCHSERVICE, parameters[0], "No such service"); return CmdResult::FAILURE; } // The SQUERY command targets a service on a services server. This can // never be on the server local to the source so we can just unicast it // to the server in question. return CmdResult::SUCCESS; } RouteDescriptor GetRouting(User* user, const Params& parameters) override { return ROUTE_UNICAST(parameters[0]); } }; class ModuleCoreMessage final : public Module { private: CommandMessage cmdprivmsg; CommandMessage cmdnotice; CommandSQuery cmdsquery; ChanModeReference moderatedmode; ChanModeReference noextmsgmode; public: ModuleCoreMessage() : Module(VF_CORE | VF_VENDOR, "Provides the NOTICE, PRIVMSG, and SQUERY commands") , cmdprivmsg(this, MessageType::PRIVMSG) , cmdnotice(this, MessageType::NOTICE) , cmdsquery(this) , moderatedmode(this, "moderated") , noextmsgmode(this, "noextmsg") { } ModResult OnUserPreMessage(User* user, MessageTarget& target, MessageDetails& details) override { if (!IS_LOCAL(user) || target.type != MessageTarget::TYPE_CHANNEL) return MOD_RES_PASSTHRU; auto* chan = target.Get<Channel>(); if (chan->IsModeSet(noextmsgmode) && !chan->HasUser(user)) { // The noextmsg mode is set and the user is not in the channel. user->WriteNumeric(Numerics::CannotSendTo(chan, "external messages", *noextmsgmode)); return MOD_RES_DENY; } bool no_chan_priv = chan->GetPrefixValue(user) < VOICE_VALUE; if (no_chan_priv && chan->IsModeSet(moderatedmode)) { // The moderated mode is set and the user has no status rank. user->WriteNumeric(Numerics::CannotSendTo(chan, "messages", *moderatedmode)); return MOD_RES_DENY; } if (no_chan_priv && ServerInstance->Config->RestrictBannedUsers != ServerConfig::BUT_NORMAL && chan->IsBanned(user)) { // The user is banned in the channel and restrictbannedusers is enabled. if (ServerInstance->Config->RestrictBannedUsers == ServerConfig::BUT_RESTRICT_NOTIFY) user->WriteNumeric(Numerics::CannotSendTo(chan, "You cannot send messages to this channel whilst banned.")); return MOD_RES_DENY; } return MOD_RES_PASSTHRU; } }; MODULE_INIT(ModuleCoreMessage) ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/src/coremods/core_mode.cpp�����������������������������������������������������������0000664�0000000�0000000�00000026672�14771603147�0020426�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2021 Andrio Celos <AndrioCelos@users.noreply.github.com> * Copyright (C) 2021 Andrio Celos * Copyright (C) 2019 linuxdaemon <linuxdaemon.irc@gmail.com> * Copyright (C) 2018-2024 Sadie Powell <sadie@witchery.services> * Copyright (C) 2017 B00mX0r <b00mx0r@aureus.pw> * Copyright (C) 2014-2016 Attila Molnar <attilamolnar@hush.com> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include "inspircd.h" #include "modules/isupport.h" #include "numerichelper.h" enum { // From RFC 1459. RPL_UMODEIS = 221, RPL_CHANNELMODEIS = 324, ERR_USERSDONTMATCH = 502, // From ircu? RPL_CHANNELCREATED = 329, // From UnrealIRCd. RPL_SNOMASKIS = 8, // InspIRCd-specific. RPL_OTHERUMODEIS = 803, RPL_OTHERSNOMASKIS = 804, }; class CommandMode final : public Command { private: unsigned int sent[256]; unsigned int seq = 0; ChanModeReference secretmode; ChanModeReference privatemode; UserModeReference snomaskmode; /** Show the list of one or more list modes to a user. * @param user User to send to. * @param chan Channel whose lists to show. * @param mode_sequence Mode letters to show the lists of. */ void DisplayListModes(User* user, Channel* chan, const std::string& mode_sequence); /** Show the current modes of a channel or a user to a user. * @param user User to show the modes to. * @param targetuser User whose modes to show. NULL if showing the modes of a channel. * @param targetchannel Channel whose modes to show. NULL if showing the modes of a user. */ void DisplayCurrentModes(User* user, User* targetuser, Channel* targetchannel); bool CanSeeChan(User* user, Channel* chan) { // A user can always see the channel modes if they are: // (1) In the channel. // (2) An oper with the channels/auspex privilege. if (chan->HasUser(user) || user->HasPrivPermission("channels/auspex")) return true; // Otherwise, they can only see the modes when the channel is not +p or +s. return !chan->IsModeSet(secretmode) && !chan->IsModeSet(privatemode); } std::string GetSnomasks(const User* user); public: CommandMode(Module* parent); CmdResult Handle(User* user, const Params& parameters) override; RouteDescriptor GetRouting(User* user, const Params& parameters) override; }; CommandMode::CommandMode(Module* parent) : Command(parent, "MODE", 1) , secretmode(creator, "secret") , privatemode(creator, "private") , snomaskmode(creator, "snomask") { syntax = { "<target> [[(+|-)]<modes> [<mode-parameters>]]" }; memset(&sent, 0, sizeof(sent)); } CmdResult CommandMode::Handle(User* user, const Params& parameters) { const std::string& target = parameters[0]; auto* targetchannel = ServerInstance->Channels.Find(target); User* targetuser = nullptr; if (!targetchannel) { if (IS_LOCAL(user)) targetuser = ServerInstance->Users.FindNick(target); else targetuser = ServerInstance->Users.Find(target); } if ((!targetchannel || !CanSeeChan(user, targetchannel)) && (!targetuser)) { if (ServerInstance->Channels.IsPrefix(target[0])) user->WriteNumeric(Numerics::NoSuchChannel(target)); else user->WriteNumeric(Numerics::NoSuchNick(target)); return CmdResult::FAILURE; } if (parameters.size() == 1) { this->DisplayCurrentModes(user, targetuser, targetchannel); return CmdResult::SUCCESS; } // Populate a temporary Modes::ChangeList with the parameters Modes::ChangeList changelist; ModeType type = targetchannel ? MODETYPE_CHANNEL : MODETYPE_USER; ServerInstance->Modes.ModeParamsToChangeList(user, type, parameters, changelist); ModResult modres; FIRST_MOD_RESULT(OnPreMode, modres, (user, targetuser, targetchannel, changelist)); ModeParser::ModeProcessFlag flags = ModeParser::MODE_NONE; if (IS_LOCAL(user)) { if (modres == MOD_RES_PASSTHRU) { if ((targetuser) && (user != targetuser)) { // Local users may only change the modes of other users if a module explicitly allows it user->WriteNumeric(ERR_USERSDONTMATCH, "Can't change mode for other users"); return CmdResult::FAILURE; } // This is a mode change by a local user and modules didn't explicitly allow/deny. // Ensure access checks will happen for each mode being changed. flags |= ModeParser::MODE_CHECKACCESS; } else if (modres == MOD_RES_DENY) return CmdResult::FAILURE; // Entire mode change denied by a module } else flags |= ModeParser::MODE_LOCALONLY; if (IS_LOCAL(user)) ServerInstance->Modes.ProcessSingle(user, targetchannel, targetuser, changelist, flags); else ServerInstance->Modes.Process(user, targetchannel, targetuser, changelist, flags); if ((ServerInstance->Modes.GetLastChangeList().empty()) && (targetchannel) && (parameters.size() == 2)) { /* Special case for displaying the list for listmodes, * e.g. MODE #chan b, or MODE #chan +b without a parameter */ this->DisplayListModes(user, targetchannel, parameters[1]); } return CmdResult::SUCCESS; } RouteDescriptor CommandMode::GetRouting(User* user, const Params& parameters) { return (IS_LOCAL(user) ? ROUTE_LOCALONLY : ROUTE_BROADCAST); } void CommandMode::DisplayListModes(User* user, Channel* chan, const std::string& mode_sequence) { seq++; for (const auto mletter : mode_sequence) { if (mletter == '+') continue; ModeHandler* mh = ServerInstance->Modes.FindMode(mletter, MODETYPE_CHANNEL); if (!mh || !mh->IsListMode()) return; /* Ensure the user doesnt request the same mode twice, * so they can't flood themselves off out of idiocy. */ if (sent[static_cast<unsigned char>(mletter)] == seq) continue; sent[static_cast<unsigned char>(mletter)] = seq; ServerInstance->Modes.ShowListModeList(user, chan, mh); } } std::string CommandMode::GetSnomasks(const User* user) { std::string snomaskstr = snomaskmode->GetUserParameter(user); // snomaskstr is empty if the snomask mode isn't set, otherwise it begins with a '+'. // In the former case output a "+", not an empty string. if (snomaskstr.empty()) snomaskstr.push_back('+'); return snomaskstr; } namespace { void GetModeList(Numeric::Numeric& num, Channel* chan, User* user) { // We should only show the value of secret parameters (i.e. key) if // the user is a member of the channel. bool show_secret = chan->HasUser(user); size_t modepos = num.push("+").GetParams().size() - 1; std::string modes; std::string param; for (const auto& [_, mh] : ServerInstance->Modes.GetModes(MODETYPE_CHANNEL)) { // Check that the mode is set. if (!chan->IsModeSet(mh)) continue; // Add the mode to the set list. modes.push_back(mh->GetModeChar()); // If the mode has a parameter we need to include that too. ParamModeBase* pm = mh->IsParameterMode(); if (!pm) continue; // If a mode has a secret parameter and the user is not privy to // the value of it then we use <name> instead of the value. if (pm->IsParameterSecret() && !show_secret) { num.push("<" + pm->name + ">"); continue; } // Retrieve the parameter and add it to the mode list. pm->GetParameter(chan, param); num.push(param); param.clear(); } num.GetParams()[modepos].append(modes); } } void CommandMode::DisplayCurrentModes(User* user, User* targetuser, Channel* targetchannel) { if (targetchannel) { // Display channel's current mode string Numeric::Numeric modenum(RPL_CHANNELMODEIS); modenum.push(targetchannel->name); GetModeList(modenum, targetchannel, user); user->WriteNumeric(modenum); user->WriteNumeric(RPL_CHANNELCREATED, targetchannel->name, targetchannel->age); } else { if (targetuser == user) { // Display user's current mode string user->WriteNumeric(RPL_UMODEIS, targetuser->GetModeLetters()); if (targetuser->IsOper()) user->WriteNumeric(RPL_SNOMASKIS, GetSnomasks(targetuser), "Server notice mask"); } else if (user->HasPrivPermission("users/auspex")) { // Querying the modes of another user. // We cannot use RPL_UMODEIS because that's only for showing the user's own modes. user->WriteNumeric(RPL_OTHERUMODEIS, targetuser->nick, targetuser->GetModeLetters()); if (targetuser->IsOper()) user->WriteNumeric(RPL_OTHERSNOMASKIS, targetuser->nick, GetSnomasks(targetuser), "Server notice mask"); } else { user->WriteNumeric(ERR_USERSDONTMATCH, "Can't view modes for other users"); } } } class CoreModMode final : public Module , public ISupport::EventListener { private: CommandMode cmdmode; static std::string GenerateModeList(ModeType mt) { // Type A: Modes that add or remove an address to or from a list. These // modes MUST always have a parameter when sent from the server to a // client. A client MAY issue the mode without an argument to obtain the // current contents of the list. std::string type1; // Type B: Modes that change a setting on a channel. These modes MUST // always have a parameter. std::string type2; // Type C: Modes that change a setting on a channel. These modes MUST // have a parameter when being set, and MUST NOT have a parameter when // being unset. std::string type3; // Type D: Modes that change a setting on a channel. These modes MUST // NOT have a parameter. std::string type4; for (const auto& [_, mh] : ServerInstance->Modes.GetModes(mt)) { if (mh->NeedsParam(true)) { PrefixMode* pm = mh->IsPrefixMode(); if (mh->IsListMode() && (!pm || !pm->GetPrefix())) { type1 += mh->GetModeChar(); continue; } if (mh->NeedsParam(false)) { if (!pm) type2 += mh->GetModeChar(); } else { type3 += mh->GetModeChar(); } } else { type4 += mh->GetModeChar(); } } // These don't need to be alphabetically ordered but it looks nicer. std::sort(type1.begin(), type1.end()); std::sort(type2.begin(), type2.end()); std::sort(type3.begin(), type3.end()); std::sort(type4.begin(), type4.end()); return INSP_FORMAT("{},{},{},{}", type1, type2, type3, type4); } static std::string GeneratePrefixList(bool includemodechars) { std::vector<PrefixMode*> prefixes; for (auto* pm : ServerInstance->Modes.GetPrefixModes()) { if (pm->GetPrefix()) prefixes.push_back(pm); } std::sort(prefixes.begin(), prefixes.end(), [](PrefixMode* lhs, PrefixMode* rhs) { return lhs->GetPrefixRank() < rhs->GetPrefixRank(); }); std::string modechars; std::string prefixchars; for (const auto* pm : insp::reverse_range(prefixes)) { modechars += pm->GetModeChar(); prefixchars += pm->GetPrefix(); } return includemodechars ? "(" + modechars + ")" + prefixchars : prefixchars; } public: CoreModMode() : Module(VF_CORE | VF_VENDOR, "Provides the MODE command") , ISupport::EventListener(this) , cmdmode(this) { } void OnBuildISupport(ISupport::TokenMap& tokens) override { tokens["CHANMODES"] = GenerateModeList(MODETYPE_CHANNEL); tokens["USERMODES"] = GenerateModeList(MODETYPE_USER); tokens["PREFIX"] = GeneratePrefixList(true); tokens["STATUSMSG"] = GeneratePrefixList(false); } }; MODULE_INIT(CoreModMode) ����������������������������������������������������������������������inspircd-4.7.0/src/coremods/core_oper/��������������������������������������������������������������0000775�0000000�0000000�00000000000�14771603147�0017726�5����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/src/coremods/core_oper/cmd_die.cpp���������������������������������������������������0000664�0000000�0000000�00000004333�14771603147�0022021�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2018-2023 Sadie Powell <sadie@witchery.services> * Copyright (C) 2018 linuxdaemon <linuxdaemon.irc@gmail.com> * Copyright (C) 2014-2015, 2018 Attila Molnar <attilamolnar@hush.com> * Copyright (C) 2012 Robby <robby@chatbelgie.be> * Copyright (C) 2009 Uli Schlachter <psychon@znc.in> * Copyright (C) 2009 Daniel De Graaf <danieldg@inspircd.org> * Copyright (C) 2008 Craig Edwards <brain@inspircd.org> * Copyright (C) 2007 Robin Burchell <robin+git@viroteck.net> * Copyright (C) 2007 Dennis Friis <peavey@inspircd.org> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include "inspircd.h" #include "clientprotocolmsg.h" #include "core_oper.h" CommandDie::CommandDie(Module* parent) : Command(parent, "DIE", 1, 1) { access_needed = CmdAccess::OPERATOR; syntax = { "<servername>" }; } void DieRestart::SendError(const std::string& message) { ClientProtocol::Messages::Error errormsg(message); ClientProtocol::Event errorevent(ServerInstance->GetRFCEvents().error, errormsg); for (auto* user : ServerInstance->Users.GetLocalUsers()) { if (user->IsFullyConnected()) { user->WriteNotice(message); } else { // Partially connected users receive ERROR, not a NOTICE user->Send(errorevent); } } } CmdResult CommandDie::Handle(User* user, const Params& parameters) { if (irc::equals(parameters[0], ServerInstance->Config->ServerName)) { const std::string diebuf = "*** DIE command from " + user->GetMask() + ". Terminating."; ServerInstance->Logs.Critical(MODNAME, diebuf); DieRestart::SendError(diebuf); ServerInstance->Exit(EXIT_FAILURE); } return CmdResult::FAILURE; } �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/src/coremods/core_oper/cmd_kill.cpp��������������������������������������������������0000664�0000000�0000000�00000011746�14771603147�0022221�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2017-2024 Sadie Powell <sadie@witchery.services> * Copyright (C) 2016 Adam <Adam@anope.org> * Copyright (C) 2012-2014, 2016, 2018 Attila Molnar <attilamolnar@hush.com> * Copyright (C) 2012 Robby <robby@chatbelgie.be> * Copyright (C) 2009-2010 Daniel De Graaf <danieldg@inspircd.org> * Copyright (C) 2007 Robin Burchell <robin+git@viroteck.net> * Copyright (C) 2007 Dennis Friis <peavey@inspircd.org> * Copyright (C) 2007 Craig Edwards <brain@inspircd.org> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include "inspircd.h" #include "numerichelper.h" #include "core_oper.h" CommandKill::CommandKill(Module* parent) : Command(parent, "KILL", 2, 2) , protoev(parent, name) { access_needed = CmdAccess::OPERATOR; syntax = { "<nick>[,<nick>]+ :<reason>" }; translation = { TR_CUSTOM, TR_CUSTOM }; } class KillMessage final : public ClientProtocol::Message { public: KillMessage(ClientProtocol::EventProvider& protoev, User* user, LocalUser* target, const std::string& text, const std::string& hidenick) : ClientProtocol::Message("KILL", nullptr) { if (hidenick.empty()) SetSourceUser(user); else SetSource(hidenick); PushParamRef(target->nick); PushParamRef(text); } }; CmdResult CommandKill::Handle(User* user, const Params& parameters) { /* Allow comma separated lists of users for /KILL (thanks w00t) */ if (CommandParser::LoopCall(user, this, parameters, 0)) { // If we got a colon delimited list of nicks then the handler ran for each nick, // and KILL commands were broadcast for remote targets. return CmdResult::FAILURE; } auto* target = ServerInstance->Users.Find(parameters[0]); if (!target) { user->WriteNumeric(Numerics::NoSuchNick(parameters[0])); return CmdResult::FAILURE; } /* * Here, we need to decide how to munge kill messages. Whether to hide killer, what to show opers, etc. * We only do this when the command is being issued LOCALLY, for remote KILL, we just copy the message we got. * * This conditional is so that we only append the "Killed (" prefix ONCE. If killer is remote, then the kill * just gets processed and passed on, otherwise, if they are local, it gets prefixed. Makes sense :-) -- w00t */ if (IS_LOCAL(user)) { /* * Moved this event inside the IS_LOCAL check also, we don't want half the network killing a user * and the other half not. This would be a bad thing. ;p -- w00t */ ModResult modres; FIRST_MOD_RESULT(OnKill, modres, (user, target, parameters[1])); if (modres == MOD_RES_DENY) return CmdResult::FAILURE; killreason = "Killed ("; if (!hidenick.empty()) { // hidekills is on, use it killreason += hidenick; } else { // hidekills is off, do nothing killreason += user->nick; } killreason += " (" + parameters[1] + "))"; } else { /* Leave it alone, remote server has already formatted it */ killreason.assign(parameters[1], 0, ServerInstance->Config->Limits.MaxQuit); } if ((!hideservicekills) || (!user->server->IsService())) { if (IS_LOCAL(user) && IS_LOCAL(target)) ServerInstance->SNO.WriteGlobalSno('k', "Local kill by {}: {} ({})", user->nick, target->GetRealMask(), parameters[1]); else ServerInstance->SNO.WriteToSnoMask('K', "Remote kill by {}: {} ({})", user->nick, target->GetRealMask(), parameters[1]); } if (IS_LOCAL(target)) { LocalUser* localu = IS_LOCAL(target); KillMessage msg(protoev, user, localu, killreason, hidenick); ClientProtocol::Event killevent(protoev, msg); localu->Send(killevent); this->lastuuid.clear(); } else { this->lastuuid = target->uuid; } // send the quit out ServerInstance->Users.QuitUser(target, killreason); return CmdResult::SUCCESS; } RouteDescriptor CommandKill::GetRouting(User* user, const Params& parameters) { // FindNick() doesn't work here because we quit the target user in Handle() which // removes it from the nicklist, so we check lastuuid: if it's empty then this KILL // was for a local user, otherwise it contains the uuid of the user who was killed. if (lastuuid.empty()) return ROUTE_LOCALONLY; return ROUTE_BROADCAST; } void CommandKill::EncodeParameter(std::string& param, unsigned int index) { // Manually translate the nick -> uuid (see above), and also the reason (params[1]) // because we decorate it if the oper is local and want remote servers to see the // decorated reason not the original. param = ((index == 0) ? lastuuid : killreason); } ��������������������������inspircd-4.7.0/src/coremods/core_oper/cmd_oper.cpp��������������������������������������������������0000664�0000000�0000000�00000005155�14771603147�0022230�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2018, 2020, 2022-2024 Sadie Powell <sadie@witchery.services> * Copyright (C) 2014 Attila Molnar <attilamolnar@hush.com> * Copyright (C) 2012 Robby <robby@chatbelgie.be> * Copyright (C) 2009 Daniel De Graaf <danieldg@inspircd.org> * Copyright (C) 2006, 2008 Craig Edwards <brain@inspircd.org> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include "inspircd.h" #include "core_oper.h" namespace { CmdResult FailedOper(LocalUser* user, const std::string& name) { user->WriteNumeric(ERR_NOOPERHOST, INSP_FORMAT("Failed to log into the \x02{}\x02 oper account (check the server log for details).", name)); user->CommandFloodPenalty += 10'000; return CmdResult::FAILURE; } } CommandOper::CommandOper(Module* parent) : SplitCommand(parent, "OPER", 1, 2) { syntax = { "<username> [<password>]" }; } CmdResult CommandOper::HandleLocal(LocalUser* user, const Params& parameters) { // Check whether the account exists. auto it = ServerInstance->Config->OperAccounts.find(parameters[0]); if (it == ServerInstance->Config->OperAccounts.end()) { ServerInstance->SNO.WriteGlobalSno('o', "{} ({}) [{}] failed to log into the \x02{}\x02 oper account because no account with that name exists.", user->nick, user->GetRealUserHost(), user->GetAddress(), parameters[0]); return FailedOper(user, parameters[0]); } // Check whether the password is correct. auto account = it->second; const auto& password = parameters.size() > 1 ? parameters[1] : ""; if (!account->CheckPassword(password)) { ServerInstance->SNO.WriteGlobalSno('o', "{} ({}) [{}] failed to log into the \x02{}\x02 oper account because they specified the wrong password.", user->nick, user->GetRealUserHost(), user->GetAddress(), parameters[0]); return FailedOper(user, parameters[0]); } // Attempt to log the user into the account (modules will log if this fails). if (!user->OperLogin(account)) return FailedOper(user, parameters[0]); // If they have reached this point then the login succeeded, return CmdResult::SUCCESS; } �������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/src/coremods/core_oper/cmd_rehash.cpp������������������������������������������������0000664�0000000�0000000�00000006212�14771603147�0022530�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2018-2020, 2022-2023 Sadie Powell <sadie@witchery.services> * Copyright (C) 2013 Adam <Adam@anope.org> * Copyright (C) 2012-2015 Attila Molnar <attilamolnar@hush.com> * Copyright (C) 2012 Robby <robby@chatbelgie.be> * Copyright (C) 2009 Matt Smith <dz@inspircd.org> * Copyright (C) 2009 Daniel De Graaf <danieldg@inspircd.org> * Copyright (C) 2008 Robin Burchell <robin+git@viroteck.net> * Copyright (C) 2007-2008 Craig Edwards <brain@inspircd.org> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include <filesystem> #include "inspircd.h" #include "core_oper.h" enum { // From RFC 1459. RPL_REHASHING = 382, }; CommandRehash::CommandRehash(Module* parent) : Command(parent, "REHASH", 0) { access_needed = CmdAccess::OPERATOR; penalty = 2000; syntax = { "[<servermask>]" }; } CmdResult CommandRehash::Handle(User* user, const Params& parameters) { std::string param = parameters.empty() ? "" : parameters[0]; FOREACH_MOD(OnPreRehash, (user, param)); if (param.empty()) { // standard rehash of local server } else if (param.find_first_of("*.") != std::string::npos) { // rehash of servers by server name (with wildcard) if (!InspIRCd::Match(ServerInstance->Config->ServerName, parameters[0])) { // Doesn't match us. PreRehash is already done, nothing left to do return CmdResult::SUCCESS; } } else { // parameterized rehash // the leading "-" is optional; remove it if present. if (param[0] == '-') param.erase(param.begin()); FOREACH_MOD(OnModuleRehash, (user, param)); return CmdResult::SUCCESS; } // Rehash for me. Try to start the rehash thread if (!ServerInstance->ConfigThread) { const std::string configfile = std::filesystem::path(ServerInstance->ConfigFileName).filename().string(); user->WriteRemoteNumeric(RPL_REHASHING, configfile, "Rehashing " + ServerInstance->Config->ServerName); ServerInstance->SNO.WriteGlobalSno('r', "{} is rehashing {} on {}", user->nick, configfile, ServerInstance->Config->ServerName); /* Don't do anything with the logs here -- logs are restarted * after the config thread has completed. */ ServerInstance->Rehash(user->uuid); } else { /* * A rehash is already in progress! ahh shit. * XXX, todo: we should find some way to kill runaway rehashes that are blocking, this is a major problem for unrealircd users */ user->WriteRemoteNotice("*** Could not rehash: A rehash is already in progress."); } // Always return success so spanningtree forwards an incoming REHASH even if we failed return CmdResult::SUCCESS; } ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/src/coremods/core_oper/cmd_restart.cpp�����������������������������������������������0000664�0000000�0000000�00000005164�14771603147�0022747�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2018-2020, 2022-2023 Sadie Powell <sadie@witchery.services> * Copyright (C) 2017 Jordyn/The Linux Geek <onlinecloud1@gmail.com> * Copyright (C) 2012, 2014-2015 Attila Molnar <attilamolnar@hush.com> * Copyright (C) 2012 Robby <robby@chatbelgie.be> * Copyright (C) 2009 Uli Schlachter <psychon@znc.in> * Copyright (C) 2009 Daniel De Graaf <danieldg@inspircd.org> * Copyright (C) 2006 Craig Edwards <brain@inspircd.org> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #ifdef _WIN32 # include <process.h> #else # include <fcntl.h> # include <unistd.h> #endif #include "inspircd.h" #include "core_oper.h" CommandRestart::CommandRestart(Module* parent) : Command(parent, "RESTART", 1, 1) { access_needed = CmdAccess::OPERATOR; syntax = { "<servername>" }; } CmdResult CommandRestart::Handle(User* user, const Params& parameters) { ServerInstance->Logs.Normal(MODNAME, "Restart: {}", user->nick); if (irc::equals(parameters[0], ServerInstance->Config->ServerName)) { ServerInstance->SNO.WriteGlobalSno('a', "RESTART command from {}, restarting server.", user->GetRealMask()); DieRestart::SendError("Server restarting."); #ifdef FD_CLOEXEC /* XXX: This hack sets FD_CLOEXEC on all possible file descriptors, so they're closed if the execvp() below succeeds. * Certainly, this is not a nice way to do things and it's slow when the fd limit is high. * * A better solution would be to set the close-on-exec flag for each fd we create (or create them with O_CLOEXEC), * however there is no guarantee that third party libs will do the same. */ for (int i = (int)SocketEngine::GetMaxFds(); --i > 2; ) { int flags = fcntl(i, F_GETFD); if (flags != -1) fcntl(i, F_SETFD, flags | FD_CLOEXEC); } #endif execvp(ServerInstance->Config->CommandLine.argv[0], ServerInstance->Config->CommandLine.argv); ServerInstance->SNO.WriteGlobalSno('a', "Failed RESTART - could not execute '{}' ({})", ServerInstance->Config->CommandLine.argv[0], strerror(errno)); } return CmdResult::FAILURE; } ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/src/coremods/core_oper/core_oper.cpp�������������������������������������������������0000664�0000000�0000000�00000020265�14771603147�0022414�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2018-2025 Sadie Powell <sadie@witchery.services> * Copyright (C) 2018 linuxdaemon <linuxdaemon.irc@gmail.com> * Copyright (C) 2014 Attila Molnar <attilamolnar@hush.com> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include "inspircd.h" #include "extension.h" #include "modules/stats.h" #include "timeutils.h" #include "core_oper.h" class CoreModOper final : public Module , public Stats::EventListener { private: CommandDie cmddie; CommandKill cmdkill; CommandOper cmdoper; CommandRehash cmdrehash; CommandRestart cmdrestart; ModeUserOperator operatormode; ModeUserServerNoticeMask snomaskmode; BoolExtItem hasoperclass; static std::string NoneIfEmpty(const std::string& field) { return field.empty() ? "\x1Dnone\x1D" : field; } public: CoreModOper() : Module(VF_CORE | VF_VENDOR, "Provides the DIE, KILL, OPER, REHASH, and RESTART commands") , Stats::EventListener(this, UINT_MAX) , cmddie(this) , cmdkill(this) , cmdoper(this) , cmdrehash(this) , cmdrestart(this) , operatormode(this) , snomaskmode(this) , hasoperclass(this, "has-oper-class", ExtensionType::USER) { } void ReadConfig(ConfigStatus& status) override { const auto& security = ServerInstance->Config->ConfValue("security"); cmdkill.hidenick = security->getString("hidekills"); cmdkill.hideservicekills = security->getBool("hideservicekills", security->getBool("hideulinekills")); } void OnPostConnect(User* user) override { LocalUser* luser = IS_LOCAL(user); if (!luser) return; // Find an auto-oper block for this user. for (const auto& [_, account] : ServerInstance->Config->OperAccounts) { if (!account->CanAutoLogin(luser)) continue; // No autologin for this account. if (user->OperLogin(account, true)) break; // Successfully logged in to the account. } } ModResult OnPreOperLogin(LocalUser* user, const std::shared_ptr<OperAccount>& oper, bool automatic) override { const std::string hosts = oper->GetConfig()->getString("host"); if (InspIRCd::MatchMask(hosts, user->GetRealUserHost(), user->GetUserAddress())) return MOD_RES_PASSTHRU; // Host matches. if (!automatic) { ServerInstance->SNO.WriteGlobalSno('o', "{} ({}) [{}] failed to log into the \x02{}\x02 oper account because they are connecting from the wrong user@host.", user->nick, user->GetRealUserHost(), user->GetAddress(), oper->GetName()); } return MOD_RES_DENY; // Host does not match. } void OnPostOperLogin(User* user, bool automatic) override { LocalUser* luser = IS_LOCAL(user); if (!luser) return; luser->WriteNumeric(RPL_YOUAREOPER, INSP_FORMAT("You are now {} {}", strchr("AEIOUaeiou", user->oper->GetType()[0]) ? "an" : "a", user->oper->GetType())); ServerInstance->SNO.WriteToSnoMask('o', "{} ({}) [{}] is now a server operator of type \x02{}\x02 ({}using account \x02{}\x02).", user->nick, user->GetRealUserHost(), user->GetAddress(), user->oper->GetType(), automatic ? "automatically " : "", user->oper->GetName()); const std::string vhost = luser->oper->GetConfig()->getString("vhost"); if (!vhost.empty()) user->ChangeDisplayedHost(vhost); const std::string klassname = luser->oper->GetConfig()->getString("class"); if (!klassname.empty()) { for (const auto& klass : ServerInstance->Config->Classes) { if (klassname == klass->GetName()) { luser->ChangeConnectClass(klass, true); hasoperclass.Set(user, true); break; } } } } void OnPostOperLogout(User* user, const std::shared_ptr<OperAccount>& oper) override { LocalUser* luser = IS_LOCAL(user); if (!luser || luser->quitting) return; if (hasoperclass.Get(luser)) { if (!luser->FindConnectClass(true)) { ServerInstance->Logs.Normal("CONNECTCLASS", "Unable to find a non-operator connect class for {} ({}); keeping their existing one.", user->nick, user->GetRealUserHost()); } hasoperclass.Unset(luser); } } ModResult OnStats(Stats::Context& stats) override { switch (stats.GetSymbol()) { case 'o': { // Server operator accounts. for (const auto& [_, account] : ServerInstance->Config->OperAccounts) { const std::string hosts = account->GetConfig()->getString("host"); const std::string chanmodes = account->GetModes(MODETYPE_CHANNEL); const std::string usermodes = account->GetModes(MODETYPE_USER); const std::string snomasks = account->GetSnomasks(); const std::string commands = account->GetCommands(true); const std::string privileges = account->GetPrivileges(); stats.AddGenericRow(INSP_FORMAT( "\x02{}\x02 (hosts: {}, type: {}, channel modes: {}, user modes: {}, snomasks: {}, commands: {}, privileges: {})", account->GetName(), NoneIfEmpty(hosts), account->GetType(), NoneIfEmpty(chanmodes), NoneIfEmpty(usermodes), NoneIfEmpty(snomasks), NoneIfEmpty(commands), NoneIfEmpty(privileges) )) .AddTags(stats, { { "name", account->GetName() }, { "hosts", hosts }, { "chan-modes", chanmodes }, { "user-modes", usermodes }, { "snomasks", snomasks }, { "commands", commands }, { "privileges", privileges }, }); } return MOD_RES_DENY; } case 'O': { // Server operator types. for (const auto& [_, type] : ServerInstance->Config->OperTypes) { const std::string chanmodes = type->GetModes(MODETYPE_CHANNEL); const std::string usermodes = type->GetModes(MODETYPE_USER); const std::string snomasks = type->GetSnomasks(); const std::string commands = type->GetCommands(true); const std::string privileges = type->GetPrivileges(); stats.AddGenericRow(INSP_FORMAT( "\x02{}\02 (channel modes: {}, user modes: {}, snomasks: {}, commands: {}, privileges: {})", type->GetName(), NoneIfEmpty(chanmodes), NoneIfEmpty(usermodes), NoneIfEmpty(snomasks), NoneIfEmpty(commands), NoneIfEmpty(privileges) )) .AddTags(stats, { { "name", type->GetName() }, { "chan-modes", chanmodes }, { "user-modes", usermodes }, { "snomasks", snomasks }, { "commands", commands }, { "privileges", privileges }, }); } return MOD_RES_DENY; } case 'P': { // Online server operators. for (auto* oper : ServerInstance->Users.all_opers) { if (oper->server->IsService()) continue; std::string extra; if (oper->IsAway()) { const std::string awayperiod = Duration::ToLongString(ServerInstance->Time() - oper->away->time, true); const std::string awaytime = Time::ToString(oper->away->time); extra = INSP_FORMAT(": away for {} [since {}] ({})", awayperiod, awaytime, oper->away->message); } auto* loper = IS_LOCAL(oper); if (loper) { const std::string idleperiod = Duration::ToLongString(ServerInstance->Time() - loper->idle_lastmsg, true); const std::string idletime = Time::ToString(loper->idle_lastmsg); extra += INSP_FORMAT("{} idle for {} [since {}]", extra.empty() ? ':' : ',', idleperiod, idletime); } stats.AddGenericRow(INSP_FORMAT("\x02{}\x02 ({}){}", oper->nick, oper->GetUserHost(), extra)); } // Sort opers alphabetically. std::sort(stats.GetRows().begin(), stats.GetRows().end(), [](const auto& lhs, const auto& rhs) { return lhs.GetParams()[1] < rhs.GetParams()[1]; }); stats.AddGenericRow(INSP_FORMAT("{} server operator{} total", stats.GetRows().size(), stats.GetRows().size() ? "s" : "")); return MOD_RES_DENY; } } return MOD_RES_PASSTHRU; } }; MODULE_INIT(CoreModOper) �������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/src/coremods/core_oper/core_oper.h���������������������������������������������������0000664�0000000�0000000�00000006460�14771603147�0022062�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2018-2023 Sadie Powell <sadie@witchery.services> * Copyright (C) 2014-2015, 2018 Attila Molnar <attilamolnar@hush.com> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #pragma once #include "inspircd.h" enum { // From RFC 1459. RPL_YOUAREOPER = 381, ERR_NOOPERHOST = 491, }; namespace DieRestart { /** Send an ERROR to partially connected users and a NOTICE to fully connected users * @param message Message to send */ void SendError(const std::string& message); } class CommandDie final : public Command { public: CommandDie(Module* parent); CmdResult Handle(User* user, const Params& parameters) override; }; class CommandKill final : public Command { std::string lastuuid; std::string killreason; ClientProtocol::EventProvider protoev; public: /** Set to a non empty string to obfuscate nicknames prepended to a KILL. */ std::string hidenick; /** Set to hide kills from clients of services servers in snotices. */ bool hideservicekills; CommandKill(Module* parent); CmdResult Handle(User* user, const Params& parameters) override; RouteDescriptor GetRouting(User* user, const Params& parameters) override; void EncodeParameter(std::string& param, unsigned int index) override; }; class CommandOper final : public SplitCommand { public: CommandOper(Module* parent); CmdResult HandleLocal(LocalUser* user, const Params& parameters) override; }; class CommandRehash final : public Command { public: CommandRehash(Module* parent); CmdResult Handle(User* user, const Params& parameters) override; }; class CommandRestart final : public Command { public: CommandRestart(Module* parent); CmdResult Handle(User* user, const Params& parameters) override; }; class ModeUserServerNoticeMask final : public ModeHandler { private: /** Process a snomask modifier string, e.g. +abc-de * @param user The target user * @param input A sequence of notice mask characters * @return The cleaned mode sequence which can be output, * e.g. in the above example if masks c and e are not * valid, this function will return +ab-d */ std::string ProcessNoticeMasks(User* user, const std::string& input); public: ModeUserServerNoticeMask(Module* Creator); bool OnModeChange(User* source, User* dest, Channel* channel, Modes::Change& change) override; /** Create a displayable mode string of the snomasks set on a given user * @param user The user whose notice masks to format * @return The notice mask character sequence */ std::string GetUserParameter(const User* user) const override; }; class ModeUserOperator final : public SimpleUserMode { public: ModeUserOperator(Module* Creator); bool OnModeChange(User* source, User* dest, Channel* channel, Modes::Change& change) override; }; ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/src/coremods/core_oper/umode_o.cpp���������������������������������������������������0000664�0000000�0000000�00000003572�14771603147�0022070�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2017, 2020-2021, 2023 Sadie Powell <sadie@witchery.services> * Copyright (C) 2012 Robby <robby@chatbelgie.be> * Copyright (C) 2009 Daniel De Graaf <danieldg@inspircd.org> * Copyright (C) 2006 Craig Edwards <brain@inspircd.org> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include "inspircd.h" #include "core_oper.h" ModeUserOperator::ModeUserOperator(Module* Creator) : SimpleUserMode(Creator, "oper", 'o', true) { } bool ModeUserOperator::OnModeChange(User* source, User* dest, Channel*, Modes::Change& change) { // Only services pseudoclients and server operators can log out a // server operator. if (!source->server->IsService() && !source->IsOper()) return false; // The setting of the oper mode is done in User::OperLogin without // calling the handler so reject any attempt to manually set it. if (change.adding) return false; // Notify server operators of the logout. char snomask = IS_LOCAL(dest) ? 'o' : 'O'; ServerInstance->SNO.WriteToSnoMask(snomask, "{} ({}) [{}] logged {}{}out of their server operator account.", source->nick, source->GetRealUserHost(), source->GetAddress(), source == dest ? "" : dest->nick, source == dest ? "" : " "); // Log the server operator out of their account. dest->OperLogout(); return true; } ��������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/src/coremods/core_oper/umode_s.cpp���������������������������������������������������0000664�0000000�0000000�00000010552�14771603147�0022070�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2021 Herman <GermanAizek@yandex.ru> * Copyright (C) 2017, 2020-2021, 2023 Sadie Powell <sadie@witchery.services> * Copyright (C) 2013, 2016 Attila Molnar <attilamolnar@hush.com> * Copyright (C) 2012 Robby <robby@chatbelgie.be> * Copyright (C) 2009 Daniel De Graaf <danieldg@inspircd.org> * Copyright (C) 2008 Craig Edwards <brain@inspircd.org> * Copyright (C) 2006 Robin Burchell <robin+git@viroteck.net> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include "inspircd.h" #include "core_oper.h" ModeUserServerNoticeMask::ModeUserServerNoticeMask(Module* Creator) : ModeHandler(Creator, "snomask", 's', PARAM_SETONLY, MODETYPE_USER) { oper = true; syntax = "(+|-)<snomasks>|*"; } bool ModeUserServerNoticeMask::OnModeChange(User* source, User* dest, Channel*, Modes::Change& change) { if (change.adding) { dest->SetMode(this, true); // Process the parameter (remove chars we don't understand, remove redundant chars, etc.) change.param = ProcessNoticeMasks(dest, change.param); return true; } else { if (dest->IsModeSet(this)) { dest->SetMode(this, false); dest->snomasks.reset(); return true; } } // Mode not set and trying to unset, deny return false; } std::string ModeUserServerNoticeMask::GetUserParameter(const User* user) const { std::string ret; if (!user->IsModeSet(this)) return ret; ret.push_back('+'); for (unsigned char n = 0; n < 64; n++) { if (user->snomasks[n]) ret.push_back(n + 'A'); } return ret; } std::string ModeUserServerNoticeMask::ProcessNoticeMasks(User* user, const std::string& input) { bool adding = true; std::bitset<64> curr = user->snomasks; for (const auto snomask : input) { switch (snomask) { case '+': adding = true; break; case '-': adding = false; break; case '*': for (size_t j = 0; j < 64; j++) { const char chr = j + 'A'; if (user->HasSnomaskPermission(chr) && ServerInstance->SNO.IsSnomaskUsable(chr)) curr[j] = adding; } break; default: // For local users check whether the given snomask is valid and enabled - IsSnomaskUsable() tests both. // For remote users accept what we were told, unless the snomask char is not a letter. if (IS_LOCAL(user)) { if (!ServerInstance->SNO.IsSnomaskUsable(snomask)) { user->WriteNumeric(ERR_UNKNOWNSNOMASK, snomask, "is an unknown snomask character"); continue; } else if (!user->IsOper()) { user->WriteNumeric(ERR_NOPRIVILEGES, INSP_FORMAT("Permission Denied - Only operators may {} snomask {}", adding ? "set" : "unset", snomask)); continue; } else if (!user->HasSnomaskPermission(snomask)) { user->WriteNumeric(ERR_NOPRIVILEGES, INSP_FORMAT("Permission Denied - Oper type {} does not have access to snomask {}", user->oper->GetType(), snomask)); continue; } } else if (!((snomask >= 'a' && snomask <= 'z') || (snomask >= 'A' && snomask <= 'Z'))) continue; size_t index = (snomask - 'A'); curr[index] = adding; break; } } std::string plus = "+"; std::string minus = "-"; // Apply changes and construct two strings consisting of the newly added and the removed snomask chars for (size_t i = 0; i < 64; i++) { bool isset = curr[i]; if (user->snomasks[i] != isset) { user->snomasks[i] = isset; std::string& appendhere = (isset ? plus : minus); appendhere.push_back(i+'A'); } } // Create the final string that will be shown to the user and sent to servers // Form: "+ABc-de" std::string output; if (plus.length() > 1) output = std::move(plus); if (minus.length() > 1) output += minus; // Unset the snomask usermode itself if every snomask was unset if (user->snomasks.none()) user->SetMode(this, false); return output; } ������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/src/coremods/core_reloadmodule.cpp���������������������������������������������������0000664�0000000�0000000�00000052011�14771603147�0022140�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2018-2024 Sadie Powell <sadie@witchery.services> * Copyright (C) 2014-2016, 2018 Attila Molnar <attilamolnar@hush.com> * Copyright (C) 2012 Robby <robby@chatbelgie.be> * Copyright (C) 2009 Daniel De Graaf <danieldg@inspircd.org> * Copyright (C) 2007 Craig Edwards <brain@inspircd.org> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include "inspircd.h" #include "listmode.h" #include "modules/reload.h" static Events::ModuleEventProvider* reloadevprov; static ClientProtocol::Serializer* dummyserializer; class DummySerializer final : public ClientProtocol::Serializer { bool Parse(LocalUser* user, const std::string& line, ClientProtocol::ParseOutput& parseoutput) override { return false; } ClientProtocol::SerializedMessage Serialize(const ClientProtocol::Message& msg, const ClientProtocol::TagSelection& tagwl) const override { return {}; } public: DummySerializer(Module* mod) : ClientProtocol::Serializer(mod, "dummy") { } }; class CommandReloadmodule final : public Command { Events::ModuleEventProvider evprov; DummySerializer dummyser; public: CommandReloadmodule(Module* parent) : Command(parent, "RELOADMODULE", 1) , evprov(parent, "event/reloadmodule") , dummyser(parent) { reloadevprov = &evprov; dummyserializer = &dummyser; access_needed = CmdAccess::OPERATOR; syntax = { "<modulename>" }; } CmdResult Handle(User* user, const Params& parameters) override; }; namespace ReloadModule { class DataKeeper final { /** Data we save for each mode and extension provided by the module */ struct ProviderInfo final { std::string itemname; union { ModeHandler* mh; ExtensionItem* extitem; ClientProtocol::Serializer* serializer; }; ProviderInfo(ModeHandler* mode) : itemname(mode->name) , mh(mode) { } ProviderInfo(ExtensionItem* ei) : itemname(ei->name) , extitem(ei) { } ProviderInfo(ClientProtocol::Serializer* ser) : itemname(ser->name) , serializer(ser) { } }; struct InstanceData final { /** Position of the ModeHandler or ExtensionItem that the serialized data belongs to */ size_t index; /** Serialized data */ std::string serialized; InstanceData(size_t Index, const std::string& Serialized) : index(Index) , serialized(Serialized) { } }; struct ModesExts { /** Mode data for the object, one entry per mode set by the module being reloaded */ std::vector<InstanceData> modelist; /** Extensions for the object, one entry per extension set by the module being reloaded */ std::vector<InstanceData> extlist; bool empty() const { return ((modelist.empty()) && (extlist.empty())); } void swap(ModesExts& other) { modelist.swap(other.modelist); extlist.swap(other.extlist); } }; struct OwnedModesExts : public ModesExts { /** User uuid or channel name */ std::string owner; OwnedModesExts(const std::string& Owner) : owner(Owner) { } }; // Data saved for each channel struct ChanData final : public OwnedModesExts { /** Type of data stored for each member who has any affected modes or extensions set */ typedef OwnedModesExts MemberData; /** List of data (modes and extensions) about each member */ std::vector<MemberData> memberdatalist; ChanData(Channel* chan) : OwnedModesExts(chan->name) { } }; // Data saved for each user struct UserData final : public OwnedModesExts { static constexpr size_t UNUSED_INDEX = SIZE_MAX; size_t serializerindex; UserData(User* user, size_t serializeridx) : OwnedModesExts(user->uuid) , serializerindex(serializeridx) { } }; /** Module being reloaded */ Module* mod; /** Stores all user and channel modes provided by the module */ std::vector<ProviderInfo> handledmodes[2]; /** Stores all extensions provided by the module */ std::vector<ProviderInfo> handledexts; /** Stores all serializers provided by the module */ std::vector<ProviderInfo> handledserializers; /** Stores all of the module data related to users */ std::vector<UserData> userdatalist; /** Stores all of the module data related to channels and memberships */ std::vector<ChanData> chandatalist; /** Data attached by modules */ ReloadModule::CustomData moddata; void SaveExtensions(Extensible* extensible, std::vector<InstanceData>& extdatalist); void SaveMemberData(Channel* chan, std::vector<ChanData::MemberData>& memberdatalist); static void SaveListModes(Channel* chan, ListModeBase* lm, size_t index, ModesExts& currdata); size_t SaveSerializer(User* user); /** Get the index of a ProviderInfo representing the serializer in the handledserializers list. * If the serializer is not already in the list it is added. * @param serializer Serializer to get an index to. * @return Index of the ProviderInfo representing the serializer. */ size_t GetSerializerIndex(ClientProtocol::Serializer* serializer); void CreateModeList(ModeType modetype); void DoSaveUsers(); void DoSaveChans(); /** Link previously saved extension names to currently available ExtensionItems */ void LinkExtensions(); /** Link previously saved mode names to currently available ModeHandlers * @param modetype Type of the modes to look for */ void LinkModes(ModeType modetype); /** Link previously saved serializer names to currently available Serializers */ void LinkSerializers(); void DoRestoreUsers(); void DoRestoreChans(); void DoRestoreModules(); /** Restore previously saved modes and extensions on an Extensible. * The extensions are set directly on the extensible, the modes are added into the provided mode change list. * @param data Data to unserialize from * @param extensible Object to restore * @param modetype MODETYPE_USER if the object being restored is a User, MODETYPE_CHANNEL otherwise * (for Channels and Memberships). * @param modechange Mode change to populate with the modes */ void RestoreObj(const OwnedModesExts& data, Extensible* extensible, ModeType modetype, Modes::ChangeList& modechange); /** Restore all previously saved extensions on an Extensible * @param list List of extensions and their serialized data to restore * @param extensible Target Extensible */ void RestoreExtensions(const std::vector<InstanceData>& list, Extensible* extensible); /** Restore all previously saved modes on a User, Channel or Membership * @param list List of modes to restore * @param modetype MODETYPE_USER if the object being restored is a User, MODETYPE_CHANNEL otherwise * @param modechange Mode change to populate with the modes */ void RestoreModes(const std::vector<InstanceData>& list, ModeType modetype, Modes::ChangeList& modechange); /** Restore previously saved serializer on a User. * Quit the user if the serializer cannot be restored. * @param serializerindex Saved serializer index to restore. * @param user User whose serializer to restore. If not local then calling this method is a no-op. * @return True if the serializer didn't need restoring or was restored successfully. * False if the serializer should have been restored but the required serializer is unavailable and the user was quit. */ bool RestoreSerializer(size_t serializerindex, User* user); /** Restore all modes and extensions of all members on a channel * @param chan Channel whose members are being restored * @param memberdatalist Data to restore * @param modechange Mode change to populate with prefix modes */ void RestoreMemberData(Channel* chan, const std::vector<ChanData::MemberData>& memberdatalist, Modes::ChangeList& modechange); /** Verify that a service which had its data saved is available and owned by the module that owned it previously * @param service Service descriptor * @param type Human-readable type of the service for log messages */ void VerifyServiceProvider(const ProviderInfo& service, const char* type); public: /** Save module state * @param currmod Module whose data to save */ void Save(Module* currmod); /** Restore module state * @param newmod Newly loaded instance of the module which had its data saved */ void Restore(Module* newmod); /** Handle reload failure */ void Fail(); }; void DataKeeper::DoSaveUsers() { ModesExts currdata; for (const auto& [_, user] : ServerInstance->Users.GetUsers()) { // Serialize user modes for (size_t j = 0; j < handledmodes[MODETYPE_USER].size(); j++) { ModeHandler* mh = handledmodes[MODETYPE_USER][j].mh; if (user->IsModeSet(mh)) currdata.modelist.emplace_back(j, mh->GetUserParameter(user)); } // Serialize all extensions attached to the User SaveExtensions(user, currdata.extlist); // Save serializer name if applicable and get an index to it size_t serializerindex = SaveSerializer(user); // Add to list if the user has any modes or extensions set that we are interested in, otherwise we don't // have to do anything with this user when restoring if ((!currdata.empty()) || (serializerindex != UserData::UNUSED_INDEX)) { userdatalist.emplace_back(user, serializerindex); userdatalist.back().swap(currdata); } } } size_t DataKeeper::GetSerializerIndex(ClientProtocol::Serializer* serializer) { for (size_t i = 0; i < handledserializers.size(); i++) { if (handledserializers[i].serializer == serializer) return i; } handledserializers.emplace_back(serializer); return handledserializers.size()-1; } size_t DataKeeper::SaveSerializer(User* user) { LocalUser* const localuser = IS_LOCAL(user); if ((!localuser) || (!localuser->serializer)) return UserData::UNUSED_INDEX; if (localuser->serializer->creator != mod) return UserData::UNUSED_INDEX; const size_t serializerindex = GetSerializerIndex(localuser->serializer); localuser->serializer = dummyserializer; return serializerindex; } void DataKeeper::SaveExtensions(Extensible* extensible, std::vector<InstanceData>& extdata) { const Extensible::ExtensibleStore& setexts = extensible->GetExtList(); // Position of the extension saved in the handledexts list size_t index = 0; for (const auto& prov : handledexts) { ExtensionItem* const item = prov.extitem; Extensible::ExtensibleStore::const_iterator it = setexts.find(item); if (it == setexts.end()) continue; std::string value = item->ToInternal(extensible, it->second); // If the serialized value is empty the extension won't be saved and restored if (!value.empty()) extdata.emplace_back(index, value); } } void DataKeeper::SaveListModes(Channel* chan, ListModeBase* lm, size_t index, ModesExts& currdata) { const ListModeBase::ModeList* list = lm->GetList(chan); if (!list) return; for (const auto& listitem : *list) currdata.modelist.emplace_back(index, listitem.mask); } void DataKeeper::DoSaveChans() { ModesExts currdata; std::vector<OwnedModesExts> currmemberdata; for (const auto& [_, chan] : ServerInstance->Channels.GetChans()) { // Serialize channel modes for (size_t j = 0; j < handledmodes[MODETYPE_CHANNEL].size(); j++) { ModeHandler* mh = handledmodes[MODETYPE_CHANNEL][j].mh; ListModeBase* lm = mh->IsListModeBase(); if (lm) SaveListModes(chan, lm, j, currdata); else if (chan->IsModeSet(mh)) currdata.modelist.emplace_back(j, chan->GetModeParameter(mh)); } // Serialize all extensions attached to the Channel SaveExtensions(chan, currdata.extlist); // Serialize all extensions attached to and all modes set on all members of the channel SaveMemberData(chan, currmemberdata); // Same logic as in DoSaveUsers() plus we consider the modes and extensions of all members if ((!currdata.empty()) || (!currmemberdata.empty())) { chandatalist.emplace_back(chan); chandatalist.back().swap(currdata); chandatalist.back().memberdatalist.swap(currmemberdata); } } } void DataKeeper::SaveMemberData(Channel* chan, std::vector<OwnedModesExts>& memberdatalist) { ModesExts currdata; for (const auto& [_, memb] : chan->GetUsers()) { for (size_t j = 0; j < handledmodes[MODETYPE_CHANNEL].size(); j++) { ModeHandler* mh = handledmodes[MODETYPE_CHANNEL][j].mh; const PrefixMode* const pm = mh->IsPrefixMode(); if ((pm) && (memb->HasMode(pm))) currdata.modelist.emplace_back(j, memb->user->uuid); // Need to pass the user's uuid to the mode parser to set the mode later } SaveExtensions(memb, currdata.extlist); // Same logic as in DoSaveUsers() if (!currdata.empty()) { memberdatalist.emplace_back(memb->user->uuid); memberdatalist.back().swap(currdata); } } } void DataKeeper::RestoreMemberData(Channel* chan, const std::vector<ChanData::MemberData>& memberdatalist, Modes::ChangeList& modechange) { for (const auto& md : memberdatalist) { User* const user = ServerInstance->Users.FindUUID(md.owner); if (!user) { ServerInstance->Logs.Debug(MODNAME, "User {} is gone (while processing {})", md.owner, chan->name); continue; } Membership* const memb = chan->GetUser(user); if (!memb) { ServerInstance->Logs.Debug(MODNAME, "Member {} is no longer on channel {}", md.owner, chan->name); continue; } RestoreObj(md, memb, MODETYPE_CHANNEL, modechange); } } void DataKeeper::CreateModeList(ModeType modetype) { for (const auto& [_, mh] : ServerInstance->Modes.GetModes(modetype)) { if (mh->creator == mod) handledmodes[modetype].emplace_back(mh); } } void DataKeeper::Save(Module* currmod) { this->mod = currmod; for (const auto& [_, ext] : ServerInstance->Extensions.GetExts()) { if (ext->creator == mod) handledexts.emplace_back(ext); } CreateModeList(MODETYPE_USER); DoSaveUsers(); CreateModeList(MODETYPE_CHANNEL); DoSaveChans(); reloadevprov->Call(&ReloadModule::EventListener::OnReloadModuleSave, mod, this->moddata); ServerInstance->Logs.Debug(MODNAME, "Saved data about {} users {} chans {} modules", userdatalist.size(), chandatalist.size(), moddata.list.size()); } void DataKeeper::VerifyServiceProvider(const ProviderInfo& service, const char* type) { const ServiceProvider* sp = service.extitem; if (!sp) ServerInstance->Logs.Debug(MODNAME, "{} \"{}\" is no longer available", type, service.itemname); else if (sp->creator != mod) ServerInstance->Logs.Debug(MODNAME, "{} \"{}\" is now handled by {}", type, service.itemname, (sp->creator ? sp->creator->ModuleFile : "<core>")); } void DataKeeper::LinkModes(ModeType modetype) { for (auto& item : handledmodes[modetype]) { item.mh = ServerInstance->Modes.FindMode(item.itemname, modetype); VerifyServiceProvider(item, (modetype == MODETYPE_USER ? "User mode" : "Channel mode")); } } void DataKeeper::LinkExtensions() { for (auto& item : handledexts) { item.extitem = ServerInstance->Extensions.GetItem(item.itemname); VerifyServiceProvider(item.extitem, "Extension"); } } void DataKeeper::LinkSerializers() { for (auto& item : handledserializers) { item.serializer = ServerInstance->Modules.FindDataService<ClientProtocol::Serializer>(item.itemname); VerifyServiceProvider(item.serializer, "Serializer"); } } void DataKeeper::Restore(Module* newmod) { this->mod = newmod; // Find the new extension items LinkExtensions(); LinkModes(MODETYPE_USER); LinkModes(MODETYPE_CHANNEL); LinkSerializers(); // Restore DoRestoreUsers(); DoRestoreChans(); DoRestoreModules(); ServerInstance->Logs.Debug(MODNAME, "Restore finished"); } void DataKeeper::Fail() { this->mod = nullptr; ServerInstance->Logs.Debug(MODNAME, "Restore failed, notifying modules"); DoRestoreModules(); } void DataKeeper::RestoreObj(const OwnedModesExts& data, Extensible* extensible, ModeType modetype, Modes::ChangeList& modechange) { RestoreExtensions(data.extlist, extensible); RestoreModes(data.modelist, modetype, modechange); } void DataKeeper::RestoreExtensions(const std::vector<InstanceData>& list, Extensible* extensible) { for (const auto& id : list) handledexts[id.index].extitem->FromInternal(extensible, id.serialized); } void DataKeeper::RestoreModes(const std::vector<InstanceData>& list, ModeType modetype, Modes::ChangeList& modechange) { for (const auto& id : list) modechange.push_add(handledmodes[modetype][id.index].mh, id.serialized); } bool DataKeeper::RestoreSerializer(size_t serializerindex, User* user) { if (serializerindex == UserData::UNUSED_INDEX) return true; // The following checks are redundant LocalUser* const localuser = IS_LOCAL(user); if (!localuser) return true; if (localuser->serializer != dummyserializer) return true; const ProviderInfo& provinfo = handledserializers[serializerindex]; if (!provinfo.serializer) { // Users cannot exist without a serializer ServerInstance->Users.QuitUser(user, "Serializer lost in reload"); return false; } localuser->serializer = provinfo.serializer; return true; } void DataKeeper::DoRestoreUsers() { ServerInstance->Logs.Debug(MODNAME, "Restoring user data"); Modes::ChangeList modechange; for (const auto& userdata : userdatalist) { User* const user = ServerInstance->Users.FindUUID(userdata.owner); if (!user) { ServerInstance->Logs.Debug(MODNAME, "User {} is gone", userdata.owner); continue; } // Attempt to restore serializer first, if it fails it's a fatal error and RestoreSerializer() quits them if (!RestoreSerializer(userdata.serializerindex, user)) continue; RestoreObj(userdata, user, MODETYPE_USER, modechange); ServerInstance->Modes.Process(ServerInstance->FakeClient, nullptr, user, modechange, ModeParser::MODE_LOCALONLY); modechange.clear(); } } void DataKeeper::DoRestoreChans() { ServerInstance->Logs.Debug(MODNAME, "Restoring channel data"); Modes::ChangeList modechange; for (const auto& chandata : chandatalist) { Channel* const chan = ServerInstance->Channels.Find(chandata.owner); if (!chan) { ServerInstance->Logs.Debug(MODNAME, "Channel {} not found", chandata.owner); continue; } RestoreObj(chandata, chan, MODETYPE_CHANNEL, modechange); // Process the mode change before applying any prefix modes ServerInstance->Modes.Process(ServerInstance->FakeClient, chan, nullptr, modechange, ModeParser::MODE_LOCALONLY); modechange.clear(); // Restore all member data RestoreMemberData(chan, chandata.memberdatalist, modechange); ServerInstance->Modes.Process(ServerInstance->FakeClient, chan, nullptr, modechange, ModeParser::MODE_LOCALONLY); modechange.clear(); } } void DataKeeper::DoRestoreModules() { for (const auto& data : moddata.list) { ServerInstance->Logs.Debug(MODNAME, "Calling module data handler {}", fmt::ptr(data.handler)); data.handler->OnReloadModuleRestore(mod, data.data); } } } // namespace ReloadModule class ReloadAction final : public ActionBase { Module* const mod; const std::string uuid; const std::string passedname; public: ReloadAction(Module* m, const std::string& uid, const std::string& passedmodname) : mod(m) , uuid(uid) , passedname(passedmodname) { } void Call() override { ReloadModule::DataKeeper datakeeper; datakeeper.Save(mod); std::string name = mod->ModuleFile; ServerInstance->Modules.DoSafeUnload(mod); ServerInstance->GlobalCulls.Apply(); bool result = ServerInstance->Modules.Load(name); if (result) { Module* newmod = ServerInstance->Modules.Find(name); datakeeper.Restore(newmod); ServerInstance->SNO.WriteGlobalSno('a', "The {} module was reloaded.", passedname); } else { datakeeper.Fail(); ServerInstance->SNO.WriteGlobalSno('a', "Failed to reload the {} module.", passedname); } auto* user = ServerInstance->Users.FindUUID(uuid); if (user) { if (result) user->WriteNumeric(RPL_LOADEDMODULE, passedname, INSP_FORMAT("The {} module was reloaded.", passedname)); else user->WriteNumeric(ERR_CANTUNLOADMODULE, passedname, INSP_FORMAT("Failed to reload the {} module.", passedname)); } ServerInstance->GlobalCulls.AddItem(this); } }; CmdResult CommandReloadmodule::Handle(User* user, const Params& parameters) { Module* m = ServerInstance->Modules.Find(parameters[0]); if (m == creator) { user->WriteNumeric(ERR_CANTUNLOADMODULE, parameters[0], "You cannot reload core_reloadmodule (unload and load it)"); return CmdResult::FAILURE; } if (creator->dying) return CmdResult::FAILURE; if ((m) && (ServerInstance->Modules.CanUnload(m))) { ServerInstance->AtomicActions.AddAction(new ReloadAction(m, user->uuid, parameters[0])); return CmdResult::SUCCESS; } else { user->WriteNumeric(ERR_CANTUNLOADMODULE, parameters[0], "Could not find a loaded module by that name"); return CmdResult::FAILURE; } } class CoreModReloadmodule final : public Module { private: CommandReloadmodule cmd; public: CoreModReloadmodule() : Module(VF_CORE | VF_VENDOR, "Provides the RELOADMODULE command") , cmd(this) { } }; MODULE_INIT(CoreModReloadmodule) �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/src/coremods/core_serialize_rfc.cpp��������������������������������������������������0000664�0000000�0000000�00000017233�14771603147�0022314�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2021 Herman <GermanAizek@yandex.ru> * Copyright (C) 2018-2023 Sadie Powell <sadie@witchery.services> * Copyright (C) 2018 Attila Molnar <attilamolnar@hush.com> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include "inspircd.h" enum { // From ircu. ERR_INPUTTOOLONG = 417 }; class RFCSerializer final : public ClientProtocol::Serializer { /** The maximum size of client-originated message tags in an incoming message including the `@`. */ static constexpr std::string::size_type MAX_CLIENT_MESSAGE_TAG_LENGTH = 4095; /** The maximum size of server-originated message tags in an outgoing message including the `@`. */ static constexpr std::string::size_type MAX_SERVER_MESSAGE_TAG_LENGTH = 4095; static void SerializeTags(const ClientProtocol::TagMap& tags, const ClientProtocol::TagSelection& tagwl, std::string& line); public: RFCSerializer(Module* mod) : ClientProtocol::Serializer(mod, "rfc") { } bool Parse(LocalUser* user, const std::string& line, ClientProtocol::ParseOutput& parseoutput) override; ClientProtocol::SerializedMessage Serialize(const ClientProtocol::Message& msg, const ClientProtocol::TagSelection& tagwl) const override; }; bool RFCSerializer::Parse(LocalUser* user, const std::string& line, ClientProtocol::ParseOutput& parseoutput) { size_t start = line.find_first_not_of(' '); if (start == std::string::npos) { // Discourage the user from flooding the server. user->CommandFloodPenalty += 2000; return false; } // Work out how long the message can actually be. size_t maxline = ServerInstance->Config->Limits.MaxLine - start - 2; if (line[start] == '@') maxline += MAX_CLIENT_MESSAGE_TAG_LENGTH + 1; irc::tokenstream tokens(line, start, maxline); ServerInstance->Logs.RawIO("USERINPUT", "C[{}] I {}", user->uuid, tokens.GetMessage()); // This will always exist because of the check at the start of the function. std::string token; tokens.GetMiddle(token); if (token[0] == '@') { // Check that the client tags fit within the client tag space. if (token.length() > MAX_CLIENT_MESSAGE_TAG_LENGTH) { user->WriteNumeric(ERR_INPUTTOOLONG, "Input line was too long"); user->CommandFloodPenalty += 2000; return false; } // Truncate the RFC part of the message if it is too long. size_t maxrfcline = token.length() + ServerInstance->Config->Limits.MaxLine - 1; if (tokens.GetMessage().length() > maxrfcline) tokens.GetMessage().erase(maxrfcline); // Line begins with message tags, parse them. std::string tagval; irc::sepstream ss(token.substr(1), ';'); while (ss.GetToken(token)) { // Two or more tags with the same key must not be sent, but if a client violates that we accept // the first occurrence of duplicate tags and ignore all later occurrences. // // Another option is to reject the message entirely but there is no standard way of doing that. const std::string::size_type p = token.find('='); if (p != std::string::npos) { // Tag has a value tagval.assign(token, p+1, std::string::npos); token.erase(p); } else tagval.clear(); HandleTag(user, token, tagval, parseoutput.tags); } // Try to read the prefix or command name. if (!tokens.GetMiddle(token)) { // Discourage the user from flooding the server. user->CommandFloodPenalty += 2000; return false; } } if (token[0] == ':') { // If this exists then the client sent a prefix as part of their // message. Section 2.3 of RFC 1459 technically says we should only // allow the nick of the client here but in practise everyone just // ignores it so we will copy them. // Try to read the command name. if (!tokens.GetMiddle(token)) { // Discourage the user from flooding the server. user->CommandFloodPenalty += 2000; return false; } } parseoutput.cmd.assign(token); // Build the parameter map. We intentionally do not respect the RFC 1459 // thirteen parameter limit here. while (tokens.GetTrailing(token)) parseoutput.params.push_back(token); return true; } namespace { void CheckTagLength(std::string& line, size_t prevsize, size_t& length, size_t maxlength) { const std::string::size_type diffsize = line.size() - prevsize; if (length + diffsize > maxlength) line.erase(prevsize); else length += diffsize; } } void RFCSerializer::SerializeTags(const ClientProtocol::TagMap& tags, const ClientProtocol::TagSelection& tagwl, std::string& line) { size_t client_tag_length = 0; size_t server_tag_length = 0; for (ClientProtocol::TagMap::const_iterator i = tags.begin(); i != tags.end(); ++i) { if (!tagwl.IsSelected(tags, i)) continue; const std::string::size_type prevsize = line.size(); line.push_back(prevsize ? ';' : '@'); line.append(i->first); const std::string& val = i->second.value; if (!val.empty()) { line.push_back('='); line.append(val); } // The tags part of the message must not contain more client and server tags than allowed by the // message tags specification. This is complicated by the tag space having separate limits for // both server-originated and client-originated tags. If either of the tag limits is exceeded then // the most recently added tag is removed. if (i->first[0] == '+') CheckTagLength(line, prevsize, client_tag_length, MAX_CLIENT_MESSAGE_TAG_LENGTH); else CheckTagLength(line, prevsize, server_tag_length, MAX_SERVER_MESSAGE_TAG_LENGTH); } if (!line.empty()) line.push_back(' '); } ClientProtocol::SerializedMessage RFCSerializer::Serialize(const ClientProtocol::Message& msg, const ClientProtocol::TagSelection& tagwl) const { std::string line; SerializeTags(msg.GetTags(), tagwl, line); // Save position for length calculation later const std::string::size_type rfcmsg_begin = line.size(); if (msg.GetSource()) { line.push_back(':'); line.append(*msg.GetSource()); line.push_back(' '); } line.append(msg.GetCommand()); const ClientProtocol::Message::ParamList& params = msg.GetParams(); if (!params.empty()) { for (ClientProtocol::Message::ParamList::const_iterator i = params.begin(); i != params.end()-1; ++i) { const std::string& param = *i; line.push_back(' '); line.append(param); } line.append(" :", 2).append(params.back()); } // Truncate if too long std::string::size_type maxline = ServerInstance->Config->Limits.MaxLine - 2; if (line.length() - rfcmsg_begin > maxline) line.erase(rfcmsg_begin + maxline); line.append("\r\n", 2); return line; } class ModuleCoreRFCSerializer final : public Module { RFCSerializer rfcserializer; public: ModuleCoreRFCSerializer() : Module(VF_CORE | VF_VENDOR, "RFC client protocol serializer and unserializer") , rfcserializer(this) { } void OnCleanup(ExtensionType type, Extensible* item) override { if (type != ExtensionType::USER) return; LocalUser* const user = IS_LOCAL(static_cast<User*>(item)); if ((user) && (user->serializer == &rfcserializer)) ServerInstance->Users.QuitUser(user, "Protocol serializer module unloading"); } void OnUserInit(LocalUser* user) override { if (!user->serializer) user->serializer = &rfcserializer; } }; MODULE_INIT(ModuleCoreRFCSerializer) ���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/src/coremods/core_stats.cpp����������������������������������������������������������0000664�0000000�0000000�00000032706�14771603147�0020633�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������ /* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2018 Puck Meerburg <puck@puckipedia.com> * Copyright (C) 2016, 2018-2024 Sadie Powell <sadie@witchery.services> * Copyright (C) 2012-2016 Attila Molnar <attilamolnar@hush.com> * Copyright (C) 2012 Robby <robby@chatbelgie.be> * Copyright (C) 2012 ChrisTX <xpipe@hotmail.de> * Copyright (C) 2012 Adam <Adam@anope.org> * Copyright (C) 2009-2010 Daniel De Graaf <danieldg@inspircd.org> * Copyright (C) 2007 Dennis Friis <peavey@inspircd.org> * Copyright (C) 2006 Craig Edwards <brain@inspircd.org> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include "inspircd.h" #include "modules/cap.h" #include "modules/stats.h" #include "utility/string.h" #include "xline.h" #ifdef _WIN32 # include <psapi.h> #else # include <netinet/in.h> # include <sys/resource.h> #endif class StatsTagsProvider : public ClientProtocol::MessageTagProvider { private: Cap::Capability statscap; public: StatsTagsProvider(Module* mod) : ClientProtocol::MessageTagProvider(mod) , statscap(mod, "inspircd.org/stats-tags") { } bool ShouldSendTag(LocalUser* user, const ClientProtocol::MessageTagData& tagdata) override { return statscap.IsEnabled(user); } }; class CommandStats final : public Command { private: Events::ModuleEventProvider statsevprov; StatsTagsProvider statstags; void DoStats(Stats::Context& stats); public: /** STATS characters which non-opers can request. */ std::string userstats; CommandStats(Module* Creator) : Command(Creator, "STATS", 1, 2) , statsevprov(Creator, "event/stats") , statstags(Creator) { syntax = { "<symbol> [<servername>]" }; } CmdResult Handle(User* user, const Params& parameters) override; RouteDescriptor GetRouting(User* user, const Params& parameters) override { if ((parameters.size() > 1) && (parameters[1].find('.') != std::string::npos)) return ROUTE_UNICAST(parameters[1]); return ROUTE_LOCALONLY; } }; static void GenerateStatsLl(Stats::Context& stats) { stats.AddRow(211, INSP_FORMAT("nick[user@{}] sendq cmds_out bytes_out cmds_in bytes_in time_open", stats.GetSymbol() == 'l' ? "host" : "ip")); for (auto* u : ServerInstance->Users.GetLocalUsers()) stats.AddRow(211, u->nick+"["+u->GetDisplayedUser()+"@"+(stats.GetSymbol() == 'l' ? u->GetDisplayedHost() : u->GetAddress())+"] "+ConvToStr(u->eh.GetSendQSize())+" "+ConvToStr(u->cmds_out)+" "+ConvToStr(u->bytes_out)+" "+ConvToStr(u->cmds_in)+" "+ConvToStr(u->bytes_in)+" "+ConvToStr(ServerInstance->Time() - u->signon)); } void CommandStats::DoStats(Stats::Context& stats) { User* const user = stats.GetSource(); const char statschar = stats.GetSymbol(); bool isPublic = userstats.find(statschar) != std::string::npos; bool isRemoteOper = IS_REMOTE(user) && (user->IsOper()); bool isLocalOperWithPrivs = IS_LOCAL(user) && user->HasPrivPermission("servers/auspex"); if (!isPublic && !isRemoteOper && !isLocalOperWithPrivs) { const char* what = IS_LOCAL(user) ? "Stats" : "Remote stats"; ServerInstance->SNO.WriteToSnoMask('t', "{} '{}' denied for {} ({})", what, statschar, user->nick, user->GetRealUserHost()); stats.AddRow(481, (std::string("Permission Denied - STATS ") + statschar + " requires the servers/auspex priv.")); return; } ModResult res = statsevprov.FirstResult(&Stats::EventListener::OnStats, stats); if (res == MOD_RES_DENY) { const char* what = IS_LOCAL(user) ? "Stats" : "Remote stats"; ServerInstance->SNO.WriteToSnoMask('t', "{} '{}' requested by {} ({})", what, statschar, user->nick, user->GetRealUserHost()); stats.AddRow(219, statschar, "End of /STATS report"); return; } switch (statschar) { /* stats p (show listening ports) */ case 'p': { for (const auto* ls : ServerInstance->ports) { std::stringstream portentry; const std::string type = ls->bind_tag->getString("type", "clients", 1); portentry << ls->bind_sa.str() << " (type: " << type; const char* protocol = nullptr; if (ls->bind_sa.family() == AF_UNIX) protocol = "unix"; #ifdef IPPROTO_SCTP else if (ls->bind_protocol == IPPROTO_SCTP) protocol = "sctp"; #endif else if (ls->bind_sa.family() == AF_INET || ls->bind_sa.family() == AF_INET6) protocol = "tcp"; if (protocol) portentry << ", protocol: " << protocol; const std::string hook = ls->bind_tag->getString("hook"); if (!hook.empty()) portentry << ", hook: " << hook; const std::string sslprofile = ls->bind_tag->getString("sslprofile"); if (!sslprofile.empty()) portentry << ", tls profile: " << sslprofile; portentry << ')'; stats.AddRow(249, portentry.str()); } } break; case 'i': { for (const auto& c : ServerInstance->Config->Classes) { Stats::Row row(215); row.push("I").push(c->name); std::string param; if (c->type == ConnectClass::ALLOW) param.push_back('+'); if (c->type == ConnectClass::DENY) param.push_back('-'); if (c->type == ConnectClass::NAMED) param.push_back('*'); else param.append(insp::join(c->GetHosts(), ',')); row.push(param).push(c->config->getString("port", "*", 1)); row.push(c->recvqmax).push(c->softsendqmax).push(c->hardsendqmax).push(c->commandrate); param = ConvToStr(c->penaltythreshold); if (c->fakelag) param.push_back('*'); row.push(param); stats.AddRow(row); } } break; case 'Y': { int idx = 0; for (const auto& c : ServerInstance->Config->Classes) { for (const auto& host : c->GetHosts()) stats.AddRow(215, 'i', "NOMATCH", '*', host, (c->limit ? c->limit : SocketEngine::GetMaxFds()), idx, ServerInstance->Config->ServerName, '*'); stats.AddRow(218, 'Y', idx, c->pingtime, '0', c->hardsendqmax, ConvToStr(c->recvqmax) + " " + ConvToStr(c->connection_timeout)); idx++; } } break; case 'k': ServerInstance->XLines->InvokeStats("K", stats); break; case 'g': ServerInstance->XLines->InvokeStats("G", stats); break; case 'q': ServerInstance->XLines->InvokeStats("Q", stats); break; case 'Z': ServerInstance->XLines->InvokeStats("Z", stats); break; case 'e': ServerInstance->XLines->InvokeStats("E", stats); break; case 'E': { const SocketEngine::Statistics& sestats = SocketEngine::GetStats(); stats.AddRow(249, "Total events: "+ConvToStr(sestats.TotalEvents)); stats.AddRow(249, "Read events: "+ConvToStr(sestats.ReadEvents)); stats.AddRow(249, "Write events: "+ConvToStr(sestats.WriteEvents)); stats.AddRow(249, "Error events: "+ConvToStr(sestats.ErrorEvents)); break; } /* stats m (list number of times each command has been used, plus bytecount) */ case 'm': { for (const auto& [_, command] : ServerInstance->Parser.GetCommands()) { if (command->use_count) { /* RPL_STATSCOMMANDS */ stats.AddRow(212, command->name, command->use_count); } } } break; /* stats z (debug and memory info) */ case 'z': { stats.AddRow(249, "Users: "+ConvToStr(ServerInstance->Users.GetUsers().size())); stats.AddRow(249, "Channels: "+ConvToStr(ServerInstance->Channels.GetChans().size())); stats.AddRow(249, "Commands: "+ConvToStr(ServerInstance->Parser.GetCommands().size())); float kbitpersec_in; float kbitpersec_out; float kbitpersec_total; SocketEngine::GetStats().GetBandwidth(kbitpersec_in, kbitpersec_out, kbitpersec_total); stats.AddRow(249, INSP_FORMAT("Bandwidth total: {:03.5} kilobits/sec", kbitpersec_total)); stats.AddRow(249, INSP_FORMAT("Bandwidth out: {:03.5} kilobits/sec", kbitpersec_out)); stats.AddRow(249, INSP_FORMAT("Bandwidth in: {:03.5} kilobits/sec", kbitpersec_in)); #ifndef _WIN32 /* Moved this down here so all the not-windows stuff (look w00tie, I didn't say win32!) is in one ifndef. * Also cuts out some identical code in both branches of the ifndef. -- Om */ rusage R; /* Not sure why we were doing '0' with a RUSAGE_SELF comment rather than just using RUSAGE_SELF -- Om */ if (!getrusage(RUSAGE_SELF,&R)) /* RUSAGE_SELF */ { #ifndef __HAIKU__ stats.AddRow(249, "Total allocation: "+ConvToStr(R.ru_maxrss)+"K"); stats.AddRow(249, "Signals: "+ConvToStr(R.ru_nsignals)); stats.AddRow(249, "Page faults: "+ConvToStr(R.ru_majflt)); stats.AddRow(249, "Swaps: "+ConvToStr(R.ru_nswap)); stats.AddRow(249, "Context Switches: Voluntary; "+ConvToStr(R.ru_nvcsw)+" Involuntary; "+ConvToStr(R.ru_nivcsw)); #endif float n_elapsed = (ServerInstance->Time() - ServerInstance->Stats.LastSampled.tv_sec) * 1000000 + (ServerInstance->Time_ns() - ServerInstance->Stats.LastSampled.tv_nsec) / 1000; float n_eaten = ((R.ru_utime.tv_sec - ServerInstance->Stats.LastCPU.tv_sec) * 1000000 + R.ru_utime.tv_usec - ServerInstance->Stats.LastCPU.tv_usec); float per = (n_eaten / n_elapsed) * 100; stats.AddRow(249, INSP_FORMAT("CPU Use (now): {:03.5}%", per)); n_elapsed = ServerInstance->Time() - ServerInstance->startup_time; n_eaten = (float)R.ru_utime.tv_sec + R.ru_utime.tv_usec / 100000.0; per = (n_eaten / n_elapsed) * 100; stats.AddRow(249, INSP_FORMAT("CPU Use (total): {:03.5}%", per)); } #else PROCESS_MEMORY_COUNTERS MemCounters; if (GetProcessMemoryInfo(GetCurrentProcess(), &MemCounters, sizeof(MemCounters))) { stats.AddRow(249, "Total allocation: "+ConvToStr((MemCounters.WorkingSetSize + MemCounters.PagefileUsage) / 1024)+"K"); stats.AddRow(249, "Pagefile usage: "+ConvToStr(MemCounters.PagefileUsage / 1024)+"K"); stats.AddRow(249, "Page faults: "+ConvToStr(MemCounters.PageFaultCount)); } FILETIME CreationTime; FILETIME ExitTime; FILETIME KernelTime; FILETIME UserTime; LARGE_INTEGER ThisSample; if(GetProcessTimes(GetCurrentProcess(), &CreationTime, &ExitTime, &KernelTime, &UserTime) && QueryPerformanceCounter(&ThisSample)) { KernelTime.dwHighDateTime += UserTime.dwHighDateTime; KernelTime.dwLowDateTime += UserTime.dwLowDateTime; double n_eaten = (double)( ( (uint64_t)(KernelTime.dwHighDateTime - ServerInstance->Stats.LastSampled.dwHighDateTime) << 32 ) + (uint64_t)(KernelTime.dwLowDateTime - ServerInstance->Stats.LastSampled.dwLowDateTime) )/100000; double n_elapsed = (double)(ThisSample.QuadPart - ServerInstance->Stats.LastCPU.QuadPart) / ServerInstance->Stats.BootCPU.QuadPart; double per = (n_eaten/n_elapsed); stats.AddRow(249, INSP_FORMAT("CPU Use (now): {:03.5}%", per)); n_elapsed = ServerInstance->Time() - ServerInstance->startup_time; n_eaten = (double)(( (uint64_t)(KernelTime.dwHighDateTime) << 32 ) + (uint64_t)(KernelTime.dwLowDateTime))/100000; per = (n_eaten / n_elapsed); stats.AddRow(249, INSP_FORMAT("CPU Use (total): {:03.5}%", per)); } #endif } break; case 'T': { stats.AddRow(249, "accepts "+ConvToStr(ServerInstance->Stats.Accept)+" refused "+ConvToStr(ServerInstance->Stats.Refused)); stats.AddRow(249, "unknown commands "+ConvToStr(ServerInstance->Stats.Unknown)); stats.AddRow(249, "nick collisions "+ConvToStr(ServerInstance->Stats.Collisions)); stats.AddRow(249, "connection count "+ConvToStr(ServerInstance->Stats.Connects)); stats.AddRow(249, INSP_FORMAT("bytes sent {:5.2}K recv {:5.2}K", ServerInstance->Stats.Sent / 1024.0, ServerInstance->Stats.Recv / 1024.0)); } break; /* stats l (show user I/O stats) */ case 'l': /* stats L (show user I/O stats with IP addresses) */ case 'L': GenerateStatsLl(stats); break; /* stats u (show server uptime) */ case 'u': { unsigned int up = static_cast<unsigned int>(ServerInstance->Time() - ServerInstance->startup_time); stats.AddRow(242, INSP_FORMAT("Server up {} days, {:02}:{:02}:{:02}", up / 86400, (up / 3600) % 24, (up / 60) % 60, up % 60)); } break; default: break; } stats.AddRow(219, statschar, "End of /STATS report"); ServerInstance->SNO.WriteToSnoMask('t', "{} '{}' requested by {} ({}@{})", (IS_LOCAL(user) ? "Stats" : "Remote stats"), statschar, user->nick, user->GetRealUser(), user->GetRealHost()); } CmdResult CommandStats::Handle(User* user, const Params& parameters) { if (parameters.size() > 1 && !irc::equals(parameters[1], ServerInstance->Config->ServerName)) { // Give extra penalty if a non-oper does /STATS <remoteserver> LocalUser* localuser = IS_LOCAL(user); if ((localuser) && (!user->IsOper())) localuser->CommandFloodPenalty += 2000; return CmdResult::SUCCESS; } Stats::Context stats(statstags, user, parameters[0][0]); DoStats(stats); for (const auto& row : stats.GetRows()) user->WriteRemoteNumeric(row); return CmdResult::SUCCESS; } class CoreModStats final : public Module { private: CommandStats cmd; public: CoreModStats() : Module(VF_CORE | VF_VENDOR, "Provides the STATS command") , cmd(this) { } void init() override { ServerInstance->SNO.EnableSnomask('t', "STATS"); } void ReadConfig(ConfigStatus& status) override { const auto& security = ServerInstance->Config->ConfValue("security"); cmd.userstats = security->getString("userstats", "Pu"); } }; MODULE_INIT(CoreModStats) ����������������������������������������������������������inspircd-4.7.0/src/coremods/core_stub.cpp�����������������������������������������������������������0000664�0000000�0000000�00000010134�14771603147�0020441�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2019-2023 Sadie Powell <sadie@witchery.services> * Copyright (C) 2014-2016 Attila Molnar <attilamolnar@hush.com> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include "inspircd.h" enum { // From RFC 1459. ERR_SUMMONDISABLED = 445, ERR_USERSDISABLED = 446 }; class CommandCapab final : public Command { public: CommandCapab(Module* parent) : Command(parent, "CAPAB") { works_before_reg = true; } CmdResult Handle(User* user, const Params& parameters) override { if (user->connected == User::CONN_NONE) { // The CAPAB command is used in the server protocol for negotiating // the protocol version when initiating a server connection. There // is no legitimate reason for a user to send this so we disconnect // users who sent it in order to help out server admins who have // misconfigured their server. ServerInstance->Users.QuitUser(user, "You can not connect a server to a client port. Read " INSPIRCD_DOCS "modules/spanningtree for docs on how to link a server."); } return CmdResult::FAILURE; } }; class CommandConnect final : public Command { public: CommandConnect(Module* parent) : Command(parent, "CONNECT", 1) { access_needed = CmdAccess::OPERATOR; syntax = { "<servermask>" }; } CmdResult Handle(User* user, const Params& parameters) override { /* * This is handled by the server linking module, if necessary. Do not remove this stub. */ user->WriteNotice("Look into loading a linking module (like m_spanningtree) if you want this to do anything useful."); return CmdResult::SUCCESS; } }; class CommandLinks final : public Command { public: CommandLinks(Module* parent) : Command(parent, "LINKS") { } CmdResult Handle(User* user, const Params& parameters) override { user->WriteNumeric(RPL_LINKS, ServerInstance->Config->GetServerName(), ServerInstance->Config->GetServerName(), INSP_FORMAT("0 {}", ServerInstance->Config->GetServerDesc())); user->WriteNumeric(RPL_ENDOFLINKS, '*', "End of /LINKS list."); return CmdResult::SUCCESS; } }; class CommandSquit final : public Command { public: CommandSquit(Module* parent) : Command(parent, "SQUIT", 1, 2) { access_needed = CmdAccess::OPERATOR; syntax = { "<servermask>" }; } CmdResult Handle(User* user, const Params& parameters) override { user->WriteNotice("Look into loading a linking module (like m_spanningtree) if you want this to do anything useful."); return CmdResult::FAILURE; } }; class CommandSummon final : public SplitCommand { public: CommandSummon(Module* Creator) : SplitCommand(Creator, "SUMMON", 1) { } CmdResult HandleLocal(LocalUser* user, const Params& parameters) override { user->WriteNumeric(ERR_SUMMONDISABLED, "SUMMON has been disabled"); return CmdResult::SUCCESS; } }; class CommandUsers final : public SplitCommand { public: CommandUsers(Module* Creator) : SplitCommand(Creator, "USERS") { } CmdResult HandleLocal(LocalUser* user, const Params& parameters) override { user->WriteNumeric(ERR_USERSDISABLED, "USERS has been disabled"); return CmdResult::SUCCESS; } }; class CoreModStub final : public Module { private: CommandCapab cmdcapab; CommandConnect cmdconnect; CommandLinks cmdlinks; CommandSquit cmdsquit; CommandSummon cmdsummon; CommandUsers cmdusers; public: CoreModStub() : Module(VF_CORE | VF_VENDOR, "Provides stubs for unimplemented commands") , cmdcapab(this) , cmdconnect(this) , cmdlinks(this) , cmdsquit(this) , cmdsummon(this) , cmdusers(this) { } }; MODULE_INIT(CoreModStub) ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/src/coremods/core_user/��������������������������������������������������������������0000775�0000000�0000000�00000000000�14771603147�0017737�5����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/src/coremods/core_user/cmd_away.cpp��������������������������������������������������0000664�0000000�0000000�00000004612�14771603147�0022232�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2018, 2020, 2023 Sadie Powell <sadie@witchery.services> * Copyright (C) 2013-2014, 2016 Attila Molnar <attilamolnar@hush.com> * Copyright (C) 2012 Robby <robby@chatbelgie.be> * Copyright (C) 2009 Uli Schlachter <psychon@znc.in> * Copyright (C) 2009 Daniel De Graaf <danieldg@inspircd.org> * Copyright (C) 2006 Craig Edwards <brain@inspircd.org> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include "inspircd.h" #include "core_user.h" enum { // From RFC 1459. RPL_UNAWAY = 305, RPL_NOWAWAY = 306 }; CommandAway::CommandAway(Module* parent) : Command(parent, "AWAY", 0, 1) , awayevprov(parent) { syntax = { "[:<message>]" }; works_before_reg = true; } CmdResult CommandAway::Handle(User* user, const Params& parameters) { LocalUser* luser = IS_LOCAL(user); if (!parameters.empty()) { std::string message(parameters[0]); if (luser) { ModResult res = awayevprov.FirstResult(&Away::EventListener::OnUserPreAway, luser, message); if (res == MOD_RES_DENY) return CmdResult::FAILURE; } const auto prevstate = user->away; user->away.emplace(message); user->WriteNumeric(RPL_NOWAWAY, "You have been marked as being away"); awayevprov.Call(&Away::EventListener::OnUserAway, user, prevstate); } else { if (luser) { ModResult res = awayevprov.FirstResult(&Away::EventListener::OnUserPreBack, luser); if (res == MOD_RES_DENY) return CmdResult::FAILURE; } const auto prevstate = user->away; user->away.reset(); user->WriteNumeric(RPL_UNAWAY, "You are no longer marked as being away"); awayevprov.Call(&Away::EventListener::OnUserBack, user, prevstate); } return CmdResult::SUCCESS; } RouteDescriptor CommandAway::GetRouting(User* user, const Params& parameters) { return (IS_LOCAL(user) ? ROUTE_LOCALONLY : ROUTE_BROADCAST); } ����������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/src/coremods/core_user/cmd_ison.cpp��������������������������������������������������0000664�0000000�0000000�00000003667�14771603147�0022252�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2018-2022 Sadie Powell <sadie@witchery.services> * Copyright (C) 2014-2016 Attila Molnar <attilamolnar@hush.com> * Copyright (C) 2012 Robby <robby@chatbelgie.be> * Copyright (C) 2009 Daniel De Graaf <danieldg@inspircd.org> * Copyright (C) 2007 Dennis Friis <peavey@inspircd.org> * Copyright (C) 2007 Craig Edwards <brain@inspircd.org> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include "inspircd.h" #include "numericbuilder.h" #include "core_user.h" enum { // From RFC 1459. RPL_ISON = 303, }; class IsonReplyBuilder final : public Numeric::Builder<' ', true> { public: IsonReplyBuilder(LocalUser* user) : Numeric::Builder<' ', true>(user, RPL_ISON) { } void AddNick(const std::string& nickname) { User* const user = ServerInstance->Users.FindNick(nickname, true); if (user) Add(user->nick); } }; CmdResult CommandIson::HandleLocal(LocalUser* user, const Params& parameters) { IsonReplyBuilder reply(user); for (std::vector<std::string>::const_iterator i = parameters.begin(); i != parameters.end()-1; ++i) { const std::string& targetstr = *i; reply.AddNick(targetstr); } // Last parameter can be a space separated list irc::spacesepstream ss(parameters.back()); for (std::string token; ss.GetToken(token); ) reply.AddNick(token); reply.Flush(); return CmdResult::SUCCESS; } �������������������������������������������������������������������������inspircd-4.7.0/src/coremods/core_user/cmd_nick.cpp��������������������������������������������������0000664�0000000�0000000�00000006103�14771603147�0022212�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2014, 2016 Attila Molnar <attilamolnar@hush.com> * Copyright (C) 2013, 2016, 2018, 2020-2024 Sadie Powell <sadie@witchery.services> * Copyright (C) 2012 Robby <robby@chatbelgie.be> * Copyright (C) 2009-2010 Daniel De Graaf <danieldg@inspircd.org> * Copyright (C) 2008 Robin Burchell <robin+git@viroteck.net> * Copyright (C) 2007 Craig Edwards <brain@inspircd.org> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include "inspircd.h" #include "core_user.h" CommandNick::CommandNick(Module* parent) : SplitCommand(parent, "NICK", 1) { allow_empty_last_param = true; penalty = 0; syntax = { "<newnick>" }; works_before_reg = true; } /** Handle nick changes from users. * NOTE: If you are used to ircds based on ircd2.8, and are looking * for the client introduction code in here, youre in the wrong place. * You need to look in the spanningtree module for this! */ CmdResult CommandNick::HandleLocal(LocalUser* user, const Params& parameters) { std::string newnick = parameters[0]; // anything except the initial NICK gets a flood penalty if (user->IsFullyConnected()) user->CommandFloodPenalty += 4000; if (newnick.empty()) { user->WriteNumeric(ERR_NONICKNAMEGIVEN, "No nickname given"); return CmdResult::FAILURE; } if (newnick == "0") { newnick = user->uuid; } else if (!ServerInstance->IsNick(newnick)) { user->WriteNumeric(ERR_ERRONEUSNICKNAME, newnick, "Erroneous Nickname"); return CmdResult::FAILURE; } ModResult modres; FIRST_MOD_RESULT(OnUserPreNick, modres, (user, newnick)); // If a module denied the change, abort now if (modres == MOD_RES_DENY) return CmdResult::FAILURE; // Disallow the nick change if <security:restrictbannedusers> is on and there is a ban matching this user in // one of the channels they are on if (ServerInstance->Config->RestrictBannedUsers != ServerConfig::BUT_NORMAL) { for (const auto* memb : user->chans) { if (memb->chan->GetPrefixValue(user) < VOICE_VALUE && memb->chan->IsBanned(user)) { if (ServerInstance->Config->RestrictBannedUsers == ServerConfig::BUT_RESTRICT_NOTIFY) user->WriteNumeric(ERR_CANTCHANGENICK, INSP_FORMAT("Cannot change nickname while on {} (you're banned)", memb->chan->name)); return CmdResult::FAILURE; } } } if (!user->ChangeNick(newnick)) return CmdResult::FAILURE; if (user->connected < User::CONN_NICKUSER) { user->connected |= User::CONN_NICK; return CommandUser::CheckRegister(user); } return CmdResult::SUCCESS; } �������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/src/coremods/core_user/cmd_part.cpp��������������������������������������������������0000664�0000000�0000000�00000004337�14771603147�0022243�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2018, 2020, 2022-2023 Sadie Powell <sadie@witchery.services> * Copyright (C) 2017 B00mX0r <b00mx0r@aureus.pw> * Copyright (C) 2012-2016 Attila Molnar <attilamolnar@hush.com> * Copyright (C) 2012 Robby <robby@chatbelgie.be> * Copyright (C) 2009 Uli Schlachter <psychon@znc.in> * Copyright (C) 2009 Daniel De Graaf <danieldg@inspircd.org> * Copyright (C) 2008 Robin Burchell <robin+git@viroteck.net> * Copyright (C) 2007 Dennis Friis <peavey@inspircd.org> * Copyright (C) 2006 Craig Edwards <brain@inspircd.org> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include "inspircd.h" #include "numerichelper.h" #include "core_user.h" CommandPart::CommandPart(Module* parent) : Command(parent, "PART", 1, 2) { allow_empty_last_param = true; penalty = 5000; syntax = { "<channel>[,<channel>]+ [:<reason>]" }; } CmdResult CommandPart::Handle(User* user, const Params& parameters) { std::string reason; if (parameters.size() > 1) { if (IS_LOCAL(user)) msgwrap.Wrap(parameters[1], reason); else reason = parameters[1]; } if (CommandParser::LoopCall(user, this, parameters, 0)) return CmdResult::SUCCESS; auto* c = ServerInstance->Channels.Find(parameters[0]); if (!c) { user->WriteNumeric(Numerics::NoSuchChannel(parameters[0])); return CmdResult::FAILURE; } if (!c->PartUser(user, reason)) { user->WriteNumeric(ERR_NOTONCHANNEL, c->name, "You're not on that channel"); return CmdResult::FAILURE; } return CmdResult::SUCCESS; } RouteDescriptor CommandPart::GetRouting(User* user, const Params& parameters) { return (IS_LOCAL(user) ? ROUTE_LOCALONLY : ROUTE_BROADCAST); } �������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/src/coremods/core_user/cmd_quit.cpp��������������������������������������������������0000664�0000000�0000000�00000003454�14771603147�0022256�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2018-2022 Sadie Powell <sadie@witchery.services> * Copyright (C) 2013-2014 Attila Molnar <attilamolnar@hush.com> * Copyright (C) 2012 Robby <robby@chatbelgie.be> * Copyright (C) 2009 Uli Schlachter <psychon@znc.in> * Copyright (C) 2009 Daniel De Graaf <danieldg@inspircd.org> * Copyright (C) 2006 Craig Edwards <brain@inspircd.org> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include "inspircd.h" #include "core_user.h" CommandQuit::CommandQuit(Module* parent) : Command(parent, "QUIT", 0, 1) , operquit(parent, "operquit", ExtensionType::USER, true) { allow_empty_last_param = true; works_before_reg = true; syntax = { "[:<message>]" }; } CmdResult CommandQuit::Handle(User* user, const Params& parameters) { std::string quitmsg; if (parameters.empty()) quitmsg = "Client exited"; else if (IS_LOCAL(user)) msgwrap.Wrap(parameters[0], quitmsg); else quitmsg = parameters[0]; std::string* operquitmsg = operquit.Get(user); ServerInstance->Users.QuitUser(user, quitmsg, operquitmsg); return CmdResult::SUCCESS; } RouteDescriptor CommandQuit::GetRouting(User* user, const Params& parameters) { return (IS_LOCAL(user) ? ROUTE_LOCALONLY : ROUTE_BROADCAST); } ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/src/coremods/core_user/cmd_user.cpp��������������������������������������������������0000664�0000000�0000000�00000005033�14771603147�0022245�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2017-2018, 2020, 2022-2024 Sadie Powell <sadie@witchery.services> * Copyright (C) 2014-2015 Attila Molnar <attilamolnar@hush.com> * Copyright (C) 2012 Robby <robby@chatbelgie.be> * Copyright (C) 2009 Daniel De Graaf <danieldg@inspircd.org> * Copyright (C) 2007 Robin Burchell <robin+git@viroteck.net> * Copyright (C) 2007 Craig Edwards <brain@inspircd.org> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include "inspircd.h" #include "core_user.h" enum { // From ircu. ERR_INVALIDUSERNAME = 468 }; CommandUser::CommandUser(Module* parent) : SplitCommand(parent, "USER", 4, 4) { penalty = 0; syntax = { "<username> <unused> <unused> :<realname>" }; works_before_reg = true; } CmdResult CommandUser::HandleLocal(LocalUser* user, const Params& parameters) { /* A user may only send the USER command once */ if (!(user->connected & User::CONN_USER)) { if (!ServerInstance->IsUser(parameters[0])) { user->WriteNumeric(ERR_INVALIDUSERNAME, name, "Your username is not valid"); return CmdResult::FAILURE; } else { user->ChangeRealUser(parameters[0], true); user->ChangeRealName(parameters[3]); user->connected |= User::CONN_USER; } } else { user->WriteNumeric(ERR_ALREADYREGISTERED, "You may not resend the USER command"); user->CommandFloodPenalty += 1000; return CmdResult::FAILURE; } /* parameters 2 and 3 are local and remote hosts, and are ignored */ return CheckRegister(user); } CmdResult CommandUser::CheckRegister(LocalUser* user) { // If the user is fully connected, return CmdResult::SUCCESS/CmdResult::FAILURE depending on // what modules say, otherwise just return CmdResult::SUCCESS without doing anything, knowing // the other handler will call us again if (user->connected == User::CONN_NICKUSER) { ModResult modres; FIRST_MOD_RESULT(OnUserRegister, modres, (user)); if (modres == MOD_RES_DENY) return CmdResult::FAILURE; } return CmdResult::SUCCESS; } �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/src/coremods/core_user/cmd_userhost.cpp����������������������������������������������0000664�0000000�0000000�00000003741�14771603147�0023147�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2017-2020, 2022-2023 Sadie Powell <sadie@witchery.services> * Copyright (C) 2013-2016 Attila Molnar <attilamolnar@hush.com> * Copyright (C) 2012 Robby <robby@chatbelgie.be> * Copyright (C) 2009 Uli Schlachter <psychon@znc.in> * Copyright (C) 2009 Daniel De Graaf <danieldg@inspircd.org> * Copyright (C) 2007 Dennis Friis <peavey@inspircd.org> * Copyright (C) 2006 Craig Edwards <brain@inspircd.org> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include "inspircd.h" #include "core_user.h" enum { // From RFC 1459. RPL_USERHOST = 302, }; CmdResult CommandUserhost::Handle(User* user, const Params& parameters) { const bool has_privs = user->HasPrivPermission("users/auspex"); std::string retbuf; size_t paramcount = std::min<size_t>(parameters.size(), 5); for (size_t i = 0; i < paramcount; ++i) { auto* u = ServerInstance->Users.FindNick(parameters[i], true); if (u) { retbuf += u->nick; if (u->IsOper()) { // XXX: +H hidden opers must not be shown as opers if ((u == user) || (has_privs) || (!u->IsModeSet(hideopermode))) retbuf += '*'; } retbuf += '='; retbuf += (u->IsAway() ? '-' : '+'); retbuf += u->GetUser(u == user || has_privs); retbuf += '@'; retbuf += u->GetHost(u == user || has_privs); retbuf += ' '; } } user->WriteNumeric(RPL_USERHOST, retbuf); return CmdResult::SUCCESS; } �������������������������������inspircd-4.7.0/src/coremods/core_user/core_user.cpp�������������������������������������������������0000664�0000000�0000000�00000021206�14771603147�0022432�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2017-2024 Sadie Powell <sadie@witchery.services> * Copyright (C) 2014-2015, 2018 Attila Molnar <attilamolnar@hush.com> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include "inspircd.h" #include "clientprotocolmsg.h" #include "utility/string.h" #include "core_user.h" enum { // From RFC 1459. ERR_NOORIGIN = 409, ERR_NOPERMFORHOST = 463, ERR_PASSWDMISMATCH = 464, }; class CommandPass final : public SplitCommand { public: CommandPass(Module* parent) : SplitCommand(parent, "PASS", 1, 1) { penalty = 0; syntax = { "<password>" }; works_before_reg = true; } CmdResult HandleLocal(LocalUser* user, const Params& parameters) override { if (user->IsFullyConnected()) { user->CommandFloodPenalty += 1000; user->WriteNumeric(ERR_ALREADYREGISTERED, "You may not resend the PASS command"); return CmdResult::FAILURE; } user->password = parameters[0]; return CmdResult::SUCCESS; } }; class CommandPing final : public SplitCommand { public: CommandPing(Module* parent) : SplitCommand(parent, "PING", 1) { syntax = { "<cookie> [<servername>]" }; } CmdResult HandleLocal(LocalUser* user, const Params& parameters) override { size_t origin = parameters.size() > 1 ? 1 : 0; if (parameters[origin].empty()) { user->WriteNumeric(ERR_NOORIGIN, "No origin specified"); return CmdResult::FAILURE; } ClientProtocol::Messages::Pong pong(parameters[0], origin ? parameters[1] : ServerInstance->Config->GetServerName()); user->Send(ServerInstance->GetRFCEvents().pong, pong); return CmdResult::SUCCESS; } }; class CommandPong final : public Command { public: CommandPong(Module* parent) : Command(parent, "PONG", 1) { penalty = 0; syntax = { "<cookie> [<servername>]" }; } CmdResult Handle(User* user, const Params& parameters) override { size_t origin = parameters.size() > 1 ? 1 : 0; if (parameters[origin].empty()) { user->WriteNumeric(ERR_NOORIGIN, "No origin specified"); return CmdResult::FAILURE; } // set the user as alive so they survive to next ping LocalUser* localuser = IS_LOCAL(user); if (localuser) { // Increase penalty unless we've sent a PING and this is the reply if (localuser->lastping) localuser->CommandFloodPenalty += 1000; else localuser->lastping = 1; } return CmdResult::SUCCESS; } }; void MessageWrapper::Wrap(const std::string& message, std::string& out) { // If there is a fixed message, it is stored in prefix. Otherwise prefix contains // only the prefix, so append the message and the suffix out.assign(prefix); if (!fixed) out.append(message).append(suffix); } void MessageWrapper::ReadConfig(const char* prefixname, const char* suffixname, const char* fixedname) { const auto& tag = ServerInstance->Config->ConfValue("options"); fixed = tag->readString(fixedname, prefix); if (!fixed) { prefix = tag->getString(prefixname); suffix = tag->getString(suffixname); } } class CoreModUser final : public Module { private: CommandAway cmdaway; CommandNick cmdnick; CommandPart cmdpart; CommandPass cmdpass; CommandPing cmdping; CommandPong cmdpong; CommandQuit cmdquit; CommandUser cmduser; CommandIson cmdison; CommandUserhost cmduserhost; SimpleUserMode invisiblemode; bool clonesonconnect; public: CoreModUser() : Module(VF_CORE | VF_VENDOR, "Provides the AWAY, ISON, NICK, PART, PASS, PING, PONG, QUIT, USERHOST, and USER commands") , cmdaway(this) , cmdnick(this) , cmdpart(this) , cmdpass(this) , cmdping(this) , cmdpong(this) , cmdquit(this) , cmduser(this) , cmdison(this) , cmduserhost(this) , invisiblemode(this, "invisible", 'i') { } ModResult OnPreChangeConnectClass(LocalUser* user, const std::shared_ptr<ConnectClass>& klass, std::optional<Numeric::Numeric>& errnum) override { bool conndone = user->connected != User::CONN_NONE; if (klass->config->getBool("connected", klass->config->getBool("registered", conndone)) != conndone) { ServerInstance->Logs.Debug("CONNECTCLASS", "The {} connect class is not suitable as it requires that the user is {}.", klass->GetName(), conndone ? "not fully connected" : "fully connected"); return MOD_RES_DENY; } bool hostmatches = false; for (const auto& host : klass->GetHosts()) { if (InspIRCd::MatchCIDR(user->GetAddress(), host) || InspIRCd::MatchCIDR(user->GetRealHost(), host)) { hostmatches = true; break; } } if (!hostmatches) { ServerInstance->Logs.Debug("CONNECTCLASS", "The {} connect class is not suitable as neither the host ({}) nor the IP ({}) matches {}.", klass->GetName(), user->GetRealHost(), user->GetAddress(), insp::join(klass->GetHosts())); return MOD_RES_DENY; } if (klass->limit && klass->use_count >= klass->limit) { ServerInstance->Logs.Debug("CONNECTCLASS", "The {} connect class is not suitable as it has reached its user limit ({}/{}).", klass->GetName(), klass->use_count, klass->limit); return MOD_RES_DENY; } if (conndone && !klass->password.empty() && !InspIRCd::CheckPassword(klass->password, klass->passwordhash, user->password)) { const char* error = user->password.empty() ? "one was not provided" : "the provided password was incorrect"; ServerInstance->Logs.Debug("CONNECTCLASS", "The {} connect class is not suitable as requires a password and {}.", klass->GetName(), error); errnum = ERR_PASSWDMISMATCH; errnum->push_fmt("A password is required and {}.", error); return MOD_RES_DENY; } if (!klass->ports.empty() && !klass->ports.count(user->server_sa.port())) { ServerInstance->Logs.Debug("CONNECTCLASS", "The {} connect class is not suitable as the connection port ({}) is not any of {}.", klass->GetName(), user->server_sa.port(), insp::join(klass->ports)); return MOD_RES_DENY; } return MOD_RES_PASSTHRU; } void OnChangeConnectClass(LocalUser* user, const std::shared_ptr<ConnectClass>& klass, bool force) override { if (klass->type == ConnectClass::DENY) { const std::string reason = klass->config->getString("reason", "You are not allowed to connect to this server.", 1); user->WriteNumeric(ERR_NOPERMFORHOST, reason); ServerInstance->Users.QuitUser(user, reason); return; } // If a user wasn't forced into a class (e.g. via <oper:class>) then we need to check limits. if (!force && (clonesonconnect || user->connected != User::CONN_NONE)) { const UserManager::CloneCounts& clonecounts = ServerInstance->Users.GetCloneCounts(user); if (klass->maxlocal && clonecounts.local > klass->maxlocal) { ServerInstance->Users.QuitUser(user, "No more local connections allowed from your host via this connect class."); if (klass->maxconnwarn) { ServerInstance->SNO.WriteToSnoMask('a', "WARNING: maximum local connections for the {} class ({}) exceeded by {}", klass->GetName(), klass->maxlocal, user->GetAddress()); } return; } if (klass->maxglobal && clonecounts.global > klass->maxglobal) { ServerInstance->Users.QuitUser(user, "No more global connections allowed from your host via this connect class."); if (klass->maxconnwarn) { ServerInstance->SNO.WriteToSnoMask('a', "WARNING: maximum global connections for the {} class ({}) exceeded by {}", klass->GetName(), klass->maxglobal, user->GetAddress()); } return; } } } void OnUserPart(Membership* memb, std::string& partmessage, CUList& excepts) override { if (memb->GetRank() < VOICE_VALUE && ServerInstance->Config->RestrictBannedUsers != ServerConfig::BUT_NORMAL && memb->chan->IsBanned(memb->user)) { // The user is banned in the channel and restrictbannedusers is enabled. partmessage.clear(); } } void ReadConfig(ConfigStatus& status) override { cmdpart.msgwrap.ReadConfig("prefixpart", "suffixpart", "fixedpart"); cmdquit.msgwrap.ReadConfig("prefixquit", "suffixquit", "fixedquit"); const auto& performance = ServerInstance->Config->ConfValue("performance"); clonesonconnect = performance->getBool("clonesonconnect", true); } void Prioritize() override { ServerInstance->Modules.SetPriority(this, I_OnChangeConnectClass, PRIORITY_FIRST); } }; MODULE_INIT(CoreModUser) ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/src/coremods/core_user/core_user.h���������������������������������������������������0000664�0000000�0000000�00000007646�14771603147�0022113�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2017-2022 Sadie Powell <sadie@witchery.services> * Copyright (C) 2014 Attila Molnar <attilamolnar@hush.com> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #pragma once #include "inspircd.h" #include "listmode.h" #include "modules/away.h" enum { // From RFC 1459. ERR_ALREADYREGISTERED = 462, }; class MessageWrapper final { std::string prefix; std::string suffix; bool fixed; public: /** * Wrap the given message according to the config rules * @param message The message to wrap * @param out String where the result is placed */ void Wrap(const std::string& message, std::string& out); /** * Read the settings from the given config keys (options block) * @param prefixname Name of the config key to read the prefix from * @param suffixname Name of the config key to read the suffix from * @param fixedname Name of the config key to read the fixed string string from. * If this key has a non-empty value, all messages will be replaced with it. */ void ReadConfig(const char* prefixname, const char* suffixname, const char* fixedname); }; class CommandAway final : public Command { private: Away::EventProvider awayevprov; public: CommandAway(Module* parent); CmdResult Handle(User* user, const Params& parameters) override; RouteDescriptor GetRouting(User* user, const Params& parameters) override; }; class CommandIson final : public SplitCommand { public: CommandIson(Module* parent) : SplitCommand(parent, "ISON", 1) { syntax = { "<nick> [<nick>]+" }; } CmdResult HandleLocal(LocalUser* user, const Params& parameters) override; }; class CommandNick final : public SplitCommand { public: CommandNick(Module* parent); CmdResult HandleLocal(LocalUser* user, const Params& parameters) override; }; class CommandPart final : public Command { public: MessageWrapper msgwrap; CommandPart(Module* parent); CmdResult Handle(User* user, const Params& parameters) override; RouteDescriptor GetRouting(User* user, const Params& parameters) override; }; class CommandQuit final : public Command { private: StringExtItem operquit; public: MessageWrapper msgwrap; CommandQuit(Module* parent); CmdResult Handle(User* user, const Params& parameters) override; RouteDescriptor GetRouting(User* user, const Params& parameters) override; }; class CommandUser final : public SplitCommand { public: CommandUser(Module* parent); CmdResult HandleLocal(LocalUser* user, const Params& parameters) override; /** Run the OnUserRegister hook if the user has sent both NICK and USER. Called after a partially connected user * successfully executes the USER or the NICK command. * @param user User to inspect and possibly pass to the OnUserRegister hook * @return CmdResult::FAILURE if OnUserRegister was called and it returned MOD_RES_DENY, CmdResult::SUCCESS in every other case * (i.e. if the hook wasn't fired because the user still needs to send NICK/USER or if it was fired and finished with * a non-MOD_RES_DENY result). */ static CmdResult CheckRegister(LocalUser* user); }; class CommandUserhost final : public Command { private: UserModeReference hideopermode; public: CommandUserhost(Module* parent) : Command(parent, "USERHOST", 1) , hideopermode(parent, "hideoper") { syntax = { "<nick> [<nick>]+" }; } CmdResult Handle(User* user, const Params& parameters) override; }; ������������������������������������������������������������������������������������������inspircd-4.7.0/src/coremods/core_wallops.cpp��������������������������������������������������������0000664�0000000�0000000�00000004524�14771603147�0021153�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2018-2022 Sadie Powell <sadie@witchery.services> * Copyright (C) 2013-2014, 2018 Attila Molnar <attilamolnar@hush.com> * Copyright (C) 2012 Robby <robby@chatbelgie.be> * Copyright (C) 2009 Uli Schlachter <psychon@znc.in> * Copyright (C) 2009 Daniel De Graaf <danieldg@inspircd.org> * Copyright (C) 2007 Dennis Friis <peavey@inspircd.org> * Copyright (C) 2006 Craig Edwards <brain@inspircd.org> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include "inspircd.h" class CommandWallops final : public Command { SimpleUserMode wallopsmode; ClientProtocol::EventProvider protoevprov; public: CommandWallops(Module* parent) : Command(parent, "WALLOPS", 1, 1) , wallopsmode(parent, "wallops", 'w') , protoevprov(parent, name) { access_needed = CmdAccess::OPERATOR; allow_empty_last_param = true; syntax = { ":<message>" }; } CmdResult Handle(User* user, const Params& parameters) override; RouteDescriptor GetRouting(User* user, const Params& parameters) override { return ROUTE_BROADCAST; } }; CmdResult CommandWallops::Handle(User* user, const Params& parameters) { if (parameters[0].empty()) { user->WriteNumeric(ERR_NOTEXTTOSEND, "No text to send"); return CmdResult::FAILURE; } ClientProtocol::Message msg("WALLOPS", user); msg.PushParamRef(parameters[0]); ClientProtocol::Event wallopsevent(protoevprov, msg); for (auto* curr : ServerInstance->Users.GetLocalUsers()) { if (curr->IsModeSet(wallopsmode)) curr->Send(wallopsevent); } return CmdResult::SUCCESS; } class CoreModWallops final : public Module { private: CommandWallops cmd; public: CoreModWallops() : Module(VF_CORE | VF_VENDOR, "Provides the WALLOPS command") , cmd(this) { } }; MODULE_INIT(CoreModWallops) ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/src/coremods/core_who.cpp������������������������������������������������������������0000664�0000000�0000000�00000051265�14771603147�0020273�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2024 Glen Miner <shaggie76@gmail.com> * Copyright (C) 2019 linuxdaemon <linuxdaemon.irc@gmail.com> * Copyright (C) 2018 Adam <Adam@anope.org> * Copyright (C) 2017-2023 Sadie Powell <sadie@witchery.services> * Copyright (C) 2013-2014, 2016 Attila Molnar <attilamolnar@hush.com> * Copyright (C) 2012 Robby <robby@chatbelgie.be> * Copyright (C) 2009-2010 Daniel De Graaf <danieldg@inspircd.org> * Copyright (C) 2009 John Brooks <john@jbrooks.io> * Copyright (C) 2008 Robin Burchell <robin+git@viroteck.net> * Copyright (C) 2007-2008 Craig Edwards <brain@inspircd.org> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include "inspircd.h" #include "modules/account.h" #include "modules/isupport.h" #include "modules/who.h" #include "timeutils.h" enum { // From RFC 1459. RPL_ENDOFWHO = 315, RPL_WHOREPLY = 352, // From ircu. RPL_WHOSPCRPL = 354 }; static constexpr char whox_field_order[] = "tcuihsnfdlaor"; static constexpr char who_field_order[] = "cuhsnf"; struct WhoData final : public Who::Request { bool GetFieldIndex(char flag, size_t& out) const override { if (!whox) { const char* pos = strchr(who_field_order, flag); if (!pos) return false; out = pos - who_field_order; return true; } if (!whox_fields[flag]) return false; out = 0; for (const char* c = whox_field_order; *c && *c != flag; ++c) { if (whox_fields[*c]) ++out; } return whox_field_order[out]; } WhoData(const CommandBase::Params& parameters) { // Find the matchtext and swap the 0 for a * so we can use InspIRCd::Match on it. matchtext = parameters.size() > 2 ? parameters[2] : parameters[0]; if (matchtext == "0") matchtext = "*"; // If flags have been specified by the source. if (parameters.size() > 1) { CharState* current_bitset = &flags; for (std::string::const_iterator iter = parameters[1].begin(); iter != parameters[1].end(); ++iter) { unsigned char chr = static_cast<unsigned char>(*iter); // If the source specifies a percentage the rest of the flags are WHOX fields. if (chr == '%') { whox = true; current_bitset = &whox_fields; continue; } // If we are in WHOX mode and the source specifies a comma // the rest of the parameter is the query type. if (whox && chr == ',') { whox_querytype.assign(++iter, parameters[1].end()); break; } // The source specified a matching flag. current_bitset->set(chr); } } // Fuzzy matches are when the source has not specified a specific user. fuzzy_match = flags.any() || (matchtext.find_first_of("*?.") != std::string::npos); } }; class CommandWho final : public SplitCommand { private: Account::API accountapi; ChanModeReference secretmode; ChanModeReference privatemode; UserModeReference invisiblemode; Events::ModuleEventProvider whoevprov; Events::ModuleEventProvider whomatchevprov; Events::ModuleEventProvider whovisibleevprov; void BuildOpLevels() { // Build a map of prefixes ordered descending by their rank. std::multimap<ModeHandler::Rank, const PrefixMode*, std::greater<>> ranks; for (const auto* pm : ServerInstance->Modes.GetPrefixModes()) ranks.insert(std::make_pair(pm->GetPrefixRank(), pm)); // Now we have the ranks ordered we can assign them levels. ModeHandler::Rank lastrank = 0; unsigned int oplevel = 0; for (const auto& [_, pm] : ranks) { if (lastrank && pm->GetPrefixRank() != lastrank) oplevel++; // Keep the same op level for modes with the same prefix rank. lastrank = pm->GetPrefixRank(); oplevels[pm->GetModeChar()] = ConvToStr(oplevel); ServerInstance->Logs.Debug(MODNAME, "Assigned oplevel {} to the {} ({}) prefix mode.", oplevel, pm->GetModeChar(), pm->name); } } /** Determines whether a user can view the users of a channel. */ bool CanView(Channel* chan, User* user) { // If we are in a channel we can view all users in it. if (chan->HasUser(user)) return true; // Opers with the users/auspex priv can see everything. if (user->HasPrivPermission("users/auspex")) return true; // You can see inside a channel from outside unless it is secret or private. return !chan->IsModeSet(secretmode) && !chan->IsModeSet(privatemode); } /** Gets the first channel which is visible between the source and the target users. */ Membership* GetFirstVisibleChannel(const WhoData& data, LocalUser* source, User* user) { for (auto* memb : user->chans) { // Let a module handle this first if it wants to. ModResult res = whovisibleevprov.FirstResult(&Who::VisibleEventListener::OnWhoVisible, data, source, memb); if (res == MOD_RES_ALLOW) return memb; // Module explicitly picked this chan. if (res == MOD_RES_DENY) continue; // Module explicitly rejected this chan. // A module didn't specify either way so use the default behaviour: // 1. The requesting user is getting a WHO response for themself. // 2. The +s (secret) and +p (private) channel modes are not set. // 3. The requesting user is a member of the channel. if (source == user || (!memb->chan->IsModeSet(secretmode) && !memb->chan->IsModeSet(privatemode)) || memb->chan->HasUser(source)) return memb; } return nullptr; } /** Determines whether WHO flags match a specific channel user. */ static bool MatchChannel(LocalUser* source, Membership* memb, WhoData& data); /** Determines whether WHO flags match a specific user. */ bool MatchUser(LocalUser* source, User* target, WhoData& data); /** Performs a WHO request on a channel. */ void WhoChannel(LocalUser* source, const std::vector<std::string>& parameters, WhoData& data); /** Template for getting a user from various types of collection. */ template<typename T> static User* GetUser(T& t); /** Performs a WHO request on a list of users. */ template<typename T> void WhoUsers(LocalUser* source, const std::vector<std::string>& parameters, const T& users, WhoData& data); public: insp::flat_map<char, std::string> oplevels; CommandWho(Module* parent) : SplitCommand(parent, "WHO", 1, 3) , accountapi(parent) , secretmode(parent, "secret") , privatemode(parent, "private") , invisiblemode(parent, "invisible") , whoevprov(parent, "event/who") , whomatchevprov(parent, "event/who-match") , whovisibleevprov(parent, "event/who-visible") { syntax = { "<server>|<nick>|<channel>|<realname>|<host>|0 [Aafhilmnoprstux]%[acdfhilnorstu]", "<unused> [Aafhilmnoprstux]%[acdfhilnorstu] :<server>|<nick>|<channel>|<realname>|<host>|0]" }; } /** Sends a WHO reply to a user. */ void SendWhoLine(LocalUser* user, const std::vector<std::string>& parameters, Membership* memb, User* u, WhoData& data); CmdResult HandleLocal(LocalUser* user, const Params& parameters) override; }; template<> User* CommandWho::GetUser(UserManager::OperList::const_iterator& t) { return *t; } template<> User* CommandWho::GetUser(UserMap::const_iterator& t) { return t->second; } bool CommandWho::MatchChannel(LocalUser* source, Membership* memb, WhoData& data) { bool source_has_users_auspex = source->HasPrivPermission("users/auspex"); bool source_can_see_server = ServerInstance->Config->HideServer.empty() || source_has_users_auspex; // The source only wants remote users. This user is eligible if: // (1) The source can't see server information. // (2) The source is not local to the current server. LocalUser* lu = IS_LOCAL(memb->user); if (data.flags['f'] && source_can_see_server && lu) return false; // The source only wants local users. This user is eligible if: // (1) The source can't see server information. // (2) The source is local to the current server. if (data.flags['l'] && source_can_see_server && !lu) return false; // Only show operators if the oper flag has been specified. if (data.flags['o'] && !memb->user->IsOper()) return false; // All other flags are ignored for channels. return true; } bool CommandWho::MatchUser(LocalUser* source, User* user, WhoData& data) { // Users who are not fully connected can never match. if (!user->IsFullyConnected()) return false; bool source_has_users_auspex = source->HasPrivPermission("users/auspex"); bool source_can_see_target = source == user || source_has_users_auspex; bool source_can_see_server = ServerInstance->Config->HideServer.empty() || source_has_users_auspex; // The source only wants remote users. This user is eligible if: // (1) The source can't see server information. // (2) The source is not local to the current server. LocalUser* lu = IS_LOCAL(user); if (data.flags['f'] && source_can_see_server && lu) return false; // The source only wants local users. This user is eligible if: // (1) The source can't see server information. // (2) The source is local to the current server. if (data.flags['l'] && source_can_see_server && !lu) return false; // Let a module handle this first if it wants to. ModResult res = whomatchevprov.FirstResult(&Who::MatchEventListener::OnWhoMatch, data, source, user); if (res == MOD_RES_ALLOW) return true; // Module explicitly matched. else if (res == MOD_RES_DENY) return false; // Module explicitly rejected. // The source wants to match against users' away messages. bool match = false; if (data.flags['A']) match = user->IsAway() && InspIRCd::Match(user->away->message, data.matchtext, ascii_case_insensitive_map); // The source wants to match against users' account names. else if (data.flags['a']) { const std::string* account = accountapi ? accountapi->GetAccountName(user) : nullptr; match = account && InspIRCd::Match(*account, data.matchtext); } // The source wants to match against users' hostnames. else if (data.flags['h']) { const std::string host = user->GetHost(source_can_see_target && data.flags['x']); match = InspIRCd::Match(host, data.matchtext, ascii_case_insensitive_map); } // The source wants to match against users' IP addresses. else if (data.flags['i']) match = source_can_see_target && InspIRCd::MatchCIDR(user->GetAddress(), data.matchtext, ascii_case_insensitive_map); // The source wants to match against users' modes. else if (data.flags['m']) { if (source_can_see_target) { bool set = true; for (const auto chr : data.matchtext) { switch (chr) { // The following user modes should be set. case '+': set = true; break; // The following user modes should be unset. case '-': set = false; break; default: if (user->IsModeSet(chr) != set) return false; break; } } // All of the modes matched. return true; } } // The source wants to match against users' nicks. else if (data.flags['n']) match = InspIRCd::Match(user->nick, data.matchtext); // The source wants to match against users' connection ports. else if (data.flags['p']) { if (source_can_see_target && lu) { irc::portparser portrange(data.matchtext, false); while (long port = portrange.GetToken()) { if (port >= std::numeric_limits<in_port_t>::min() && port <= std::numeric_limits<in_port_t>::max() && static_cast<in_port_t>(port) == lu->server_sa.port()) { match = true; break; } } } } // The source wants to match against users' real names. else if (data.flags['r']) match = InspIRCd::Match(user->GetRealName(), data.matchtext, ascii_case_insensitive_map); else if (data.flags['s']) { bool show_real_server_name = ServerInstance->Config->HideServer.empty() || (source->HasPrivPermission("servers/auspex") && data.flags['x']); const std::string server = show_real_server_name ? user->server->GetName() : ServerInstance->Config->HideServer; match = InspIRCd::Match(server, data.matchtext, ascii_case_insensitive_map); } // The source wants to match against users' connection times. else if (data.flags['t']) { time_t seconds = ServerInstance->Time() - Duration::From(data.matchtext); if (user->signon >= seconds) match = true; } // The source wants to match against users' usernames. else if (data.flags['u']) { const std::string username = user->GetUser(source_can_see_target && data.flags['x']); match = InspIRCd::Match(username, data.matchtext, ascii_case_insensitive_map); } // The <name> passed to WHO is matched against users' host, server, // real name and nickname if the channel <name> cannot be found. else { const std::string hostname = user->GetHost(source_can_see_target && data.flags['x']); match = InspIRCd::Match(hostname, data.matchtext, ascii_case_insensitive_map); if (!match) { bool show_real_server_name = ServerInstance->Config->HideServer.empty() || (source->HasPrivPermission("servers/auspex") && data.flags['x']); const std::string server = show_real_server_name ? user->server->GetName() : ServerInstance->Config->HideServer; match = InspIRCd::Match(server, data.matchtext, ascii_case_insensitive_map); } if (!match) match = InspIRCd::Match(user->GetRealName(), data.matchtext, ascii_case_insensitive_map); if (!match) match = InspIRCd::Match(user->nick, data.matchtext); } return match; } void CommandWho::WhoChannel(LocalUser* source, const std::vector<std::string>& parameters, WhoData& data) { if (!CanView(data.matchchan, source)) return; bool inside = data.matchchan->HasUser(source); for (const auto& [user, memb] : data.matchchan->GetUsers()) { // Only show invisible users if the source is in the channel or has the users/auspex priv. if (!inside && user->IsModeSet(invisiblemode) && !source->HasPrivPermission("users/auspex")) continue; // Skip the user if it doesn't match the query. if (!MatchChannel(source, memb, data)) continue; SendWhoLine(source, parameters, memb, user, data); } } template<typename T> void CommandWho::WhoUsers(LocalUser* source, const std::vector<std::string>& parameters, const T& users, WhoData& data) { bool source_has_users_auspex = source->HasPrivPermission("users/auspex"); for (typename T::const_iterator iter = users.begin(); iter != users.end(); ++iter) { User* user = GetUser(iter); // Only show users in response to a fuzzy WHO if we can see them normally. bool can_see_normally = user == source || !user->IsModeSet(invisiblemode) || source->SharesChannelWith(user); if (data.fuzzy_match && !can_see_normally && !source_has_users_auspex) continue; // Skip the user if it doesn't match the query. if (!MatchUser(source, user, data)) continue; SendWhoLine(source, parameters, nullptr, user, data); } } void CommandWho::SendWhoLine(LocalUser* source, const std::vector<std::string>& parameters, Membership* memb, User* user, WhoData& data) { if (!memb) memb = GetFirstVisibleChannel(data, source, user); bool source_can_see_target = source == user || source->HasPrivPermission("users/auspex"); Numeric::Numeric wholine(data.whox ? RPL_WHOSPCRPL : RPL_WHOREPLY); if (data.whox) { // The source used WHOX so we send a fancy customised response. // Include the query type in the reply. if (data.whox_fields['t']) wholine.push(data.whox_querytype.empty() || data.whox_querytype.length() > 3 ? "0" : data.whox_querytype); // Include the first channel name. if (data.whox_fields['c']) wholine.push(memb ? memb->chan->name : "*"); // Include the user's username. if (data.whox_fields['u']) wholine.push(user->GetUser(source_can_see_target && data.flags['x'])); // Include the user's IP address. if (data.whox_fields['i']) wholine.push(source_can_see_target ? user->GetAddress() : "255.255.255.255"); // Include the user's hostname. if (data.whox_fields['h']) wholine.push(user->GetHost(source_can_see_target && data.flags['x'])); // Include the server name. if (data.whox_fields['s']) { if (ServerInstance->Config->HideServer.empty() || (source->HasPrivPermission("servers/auspex") && data.flags['x'])) wholine.push(user->server->GetName()); else wholine.push(ServerInstance->Config->HideServer); } // Include the user's nickname. if (data.whox_fields['n']) wholine.push(user->nick); // Include the user's flags. if (data.whox_fields['f']) { // Away state. std::string flags(user->IsAway() ? "G" : "H"); // Operator status. if (user->IsOper()) flags.push_back('*'); // Membership prefix. if (memb) { char prefix = memb->GetPrefixChar(); if (prefix) flags.push_back(prefix); } wholine.push(flags); } // Include the number of hops between the users. if (data.whox_fields['d']) wholine.push("0"); // Include the user's idle time. if (data.whox_fields['l']) { LocalUser* lu = IS_LOCAL(user); unsigned long idle = lu ? ServerInstance->Time() - lu->idle_lastmsg : 0; wholine.push(ConvToStr(idle)); } // Include the user's account name. if (data.whox_fields['a']) { const std::string* account = accountapi ? accountapi->GetAccountName(user) : nullptr; wholine.push(account ? *account : "0"); } // Include the user's operator rank level. if (data.whox_fields['o']) { // If we haven't built a table to convert from InspIRCd member // ranks to WHOX oplevels yet we need to do that here. if (oplevels.empty()) BuildOpLevels(); wholine.push(memb && memb->GetModeChar() ? oplevels[memb->GetModeChar()] : "n/a"); } // Include the user's real name. if (data.whox_fields['r']) wholine.push(user->GetRealName()); } else { // We are not using WHOX so we just send a plain RFC response. // Include the channel name. wholine.push(memb ? memb->chan->name : "*"); // Include the user's username. wholine.push(user->GetUser(source_can_see_target && data.flags['x'])); // Include the user's hostname. wholine.push(user->GetHost(source_can_see_target && data.flags['x'])); // Include the server name. if (ServerInstance->Config->HideServer.empty() || (source->HasPrivPermission("servers/auspex") && data.flags['x'])) wholine.push(user->server->GetName()); else wholine.push(ServerInstance->Config->HideServer); // Include the user's nick. wholine.push(user->nick); // Include the user's flags. { // Away state. std::string flags(user->IsAway() ? "G" : "H"); // Operator status. if (user->IsOper()) flags.push_back('*'); // Membership prefix. if (memb) { char prefix = memb->GetPrefixChar(); if (prefix) flags.push_back(prefix); } wholine.push(flags); } // Include the number of hops between the users and the user's real name. wholine.push("0 "); wholine.GetParams().back().append(user->GetRealName()); } ModResult res = whoevprov.FirstResult(&Who::EventListener::OnWhoLine, data, source, user, memb, wholine); if (res != MOD_RES_DENY) data.results.push_back(wholine); } CmdResult CommandWho::HandleLocal(LocalUser* user, const Params& parameters) { WhoData data(parameters); // Is the source running a WHO on a channel? data.matchchan = ServerInstance->Channels.Find(data.matchtext); if (data.matchchan) WhoChannel(user, parameters, data); // If we only want to match against opers we only have to iterate the oper list. else if (data.flags['o']) WhoUsers(user, parameters, ServerInstance->Users.all_opers, data); // Otherwise we have to use the global user list. else WhoUsers(user, parameters, ServerInstance->Users.GetUsers(), data); // Send the results to the source. for (const auto& numeric : data.results) user->WriteNumeric(numeric); user->WriteNumeric(RPL_ENDOFWHO, (data.matchtext.empty() ? "*" : data.matchtext.c_str()), "End of /WHO list."); // Penalize the source a bit for large queries with one unit of penalty per 200 results. user->CommandFloodPenalty += data.results.size() * 5; return CmdResult::SUCCESS; } class CoreModWho final : public Module , public ISupport::EventListener { private: CommandWho cmd; public: CoreModWho() : Module(VF_CORE | VF_VENDOR, "Provides the WHO command") , ISupport::EventListener(this) , cmd(this) { } void OnBuildISupport(ISupport::TokenMap& tokens) override { tokens["WHOX"]; } void OnServiceAdd(ServiceProvider& provider) override { // If the service is a prefix mode we need to rebuild the oplevel map. if (provider.service == SERVICE_MODE && static_cast<ModeHandler&>(provider).IsPrefixMode()) cmd.oplevels.clear(); } void OnServiceDel(ServiceProvider& provider) override { this->OnServiceAdd(provider); } }; MODULE_INIT(CoreModWho) �������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/src/coremods/core_whois.cpp����������������������������������������������������������0000664�0000000�0000000�00000024771�14771603147�0020631�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2018 Dylan Frank <b00mx0r@aureus.pw> * Copyright (C) 2017-2024 Sadie Powell <sadie@witchery.services> * Copyright (C) 2013-2016 Attila Molnar <attilamolnar@hush.com> * Copyright (C) 2012, 2019 Robby <robby@chatbelgie.be> * Copyright (C) 2009 Daniel De Graaf <danieldg@inspircd.org> * Copyright (C) 2007 Robin Burchell <robin+git@viroteck.net> * Copyright (C) 2007 Dennis Friis <peavey@inspircd.org> * Copyright (C) 2006, 2008 Craig Edwards <brain@inspircd.org> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include "inspircd.h" #include "modules/whois.h" #include "numericbuilder.h" #include "numerichelper.h" enum SplitWhoisState { // Don't split private/secret channels into a separate RPL_WHOISCHANNELS numeric. SPLITWHOIS_NONE, // Split private/secret channels into a separate RPL_WHOISCHANNELS numeric. SPLITWHOIS_SPLIT, // Split private/secret channels into a separate RPL_WHOISCHANNELS numeric with RPL_CHANNELSMSG to explain the split. SPLITWHOIS_SPLITMSG }; class WhoisContextImpl final : public Whois::Context { Events::ModuleEventProvider& lineevprov; public: WhoisContextImpl(LocalUser* sourceuser, User* targetuser, Events::ModuleEventProvider& evprov) : Whois::Context(sourceuser, targetuser) , lineevprov(evprov) { } using Whois::Context::SendLine; void SendLine(Numeric::Numeric& numeric) override; }; void WhoisContextImpl::SendLine(Numeric::Numeric& numeric) { ModResult res = lineevprov.FirstResult(&Whois::LineEventListener::OnWhoisLine, *this, numeric); if (res != MOD_RES_DENY) source->WriteNumeric(numeric); } class CommandWhois final : public SplitCommand { ChanModeReference secretmode; ChanModeReference privatemode; UserModeReference snomaskmode; Events::ModuleEventProvider evprov; Events::ModuleEventProvider lineevprov; void DoWhois(LocalUser* user, User* dest, time_t signon, unsigned long idle); void SendChanList(WhoisContextImpl& whois); public: /** If true then all opers are shown with a generic 'is a server operator' line rather than the oper type. */ bool genericoper; /** How to handle private/secret channels in the WHOIS response. */ SplitWhoisState splitwhois; CommandWhois(Module* parent) : SplitCommand(parent, "WHOIS", 1) , secretmode(parent, "secret") , privatemode(parent, "private") , snomaskmode(parent, "snomask") , evprov(parent, "event/whois") , lineevprov(parent, "event/whoisline") { allow_empty_last_param = true; penalty = 2000; syntax = { "[<servername>] <nick>[,<nick>]+" }; } CmdResult HandleLocal(LocalUser* user, const Params& parameters) override; CmdResult HandleRemote(RemoteUser* target, const Params& parameters) override; }; class WhoisNumericSink final { WhoisContextImpl& whois; public: WhoisNumericSink(WhoisContextImpl& whoisref) : whois(whoisref) { } void operator()(Numeric::Numeric& numeric) const { whois.SendLine(numeric); } }; class WhoisChanListNumericBuilder final : public Numeric::GenericBuilder<' ', false, WhoisNumericSink> { public: WhoisChanListNumericBuilder(WhoisContextImpl& whois) : Numeric::GenericBuilder<' ', false, WhoisNumericSink>(WhoisNumericSink(whois), RPL_WHOISCHANNELS, false, whois.GetSource()->nick.size() + whois.GetTarget()->nick.size() + 1) { GetNumeric().push(whois.GetTarget()->nick).push(std::string()); } }; class WhoisChanList final { const SplitWhoisState& splitwhois; WhoisChanListNumericBuilder num; WhoisChanListNumericBuilder secretnum; std::string prefixstr; void AddMember(const Membership* memb, WhoisChanListNumericBuilder& out) { prefixstr.clear(); const char prefix = memb->GetPrefixChar(); if (prefix) prefixstr.push_back(prefix); out.Add(prefixstr, memb->chan->name); } public: WhoisChanList(WhoisContextImpl& whois, const SplitWhoisState& sws) : splitwhois(sws) , num(whois) , secretnum(whois) { } void AddVisible(const Membership* memb) { AddMember(memb, num); } void AddHidden(const Membership* memb) { AddMember(memb, splitwhois == SPLITWHOIS_NONE ? num : secretnum); } void Flush(WhoisContextImpl& whois) { num.Flush(); if (!secretnum.IsEmpty() && splitwhois == SPLITWHOIS_SPLITMSG) whois.SendLine(RPL_CHANNELSMSG, "is on private/secret channels:"); secretnum.Flush(); } }; void CommandWhois::SendChanList(WhoisContextImpl& whois) { WhoisChanList chanlist(whois, splitwhois); User* const target = whois.GetTarget(); bool hasoperpriv = whois.GetSource()->HasPrivPermission("users/channel-spy"); for (const auto* memb : target->chans) { Channel* c = memb->chan; // Anyone can view channels which are not private or secret. if (!c->IsModeSet(privatemode) && !c->IsModeSet(secretmode)) chanlist.AddVisible(memb); // Hidden channels are visible when the following conditions are true: // (1) The source user and the target user are the same. // (2) The source user is a member of the hidden channel. // (3) The source user is an oper with the users/channel-spy privilege. else if (whois.IsSelfWhois() || c->HasUser(whois.GetSource()) || hasoperpriv) chanlist.AddHidden(memb); } chanlist.Flush(whois); } void CommandWhois::DoWhois(LocalUser* user, User* dest, time_t signon, unsigned long idle) { WhoisContextImpl whois(user, dest, lineevprov); whois.SendLine(RPL_WHOISUSER, dest->GetDisplayedUser(), dest->GetDisplayedHost(), '*', dest->GetRealName()); if (!dest->server->IsService() && (whois.IsSelfWhois() || user->HasPrivPermission("users/auspex"))) { whois.SendLine(RPL_WHOISACTUALLY, dest->GetRealUserHost(), dest->GetAddress(), "is connecting from"); } SendChanList(whois); if (!whois.IsSelfWhois() && !ServerInstance->Config->HideServer.empty() && !user->HasPrivPermission("servers/auspex")) { whois.SendLine(RPL_WHOISSERVER, ServerInstance->Config->HideServer, ServerInstance->Config->Network); } else { whois.SendLine(RPL_WHOISSERVER, dest->server->GetName(), dest->server->GetDesc()); } if (dest->IsAway()) { whois.SendLine(RPL_AWAY, dest->away->message); } if (dest->IsOper()) { if (genericoper) whois.SendLine(RPL_WHOISOPERATOR, dest->server->IsService() ? "is a network service" : "is a server operator"); else whois.SendLine(RPL_WHOISOPERATOR, INSP_FORMAT("is {} {}", (strchr("AEIOUaeiou", dest->oper->GetType()[0]) ? "an" : "a"), dest->oper->GetType())); } if (whois.IsSelfWhois() || user->HasPrivPermission("users/auspex")) { if (dest->IsModeSet(snomaskmode)) { whois.SendLine(RPL_WHOISMODES, INSP_FORMAT("is using modes {} {}", dest->GetModeLetters(), snomaskmode->GetUserParameter(dest))); } else { whois.SendLine(RPL_WHOISMODES, INSP_FORMAT("is using modes {}", dest->GetModeLetters())); } } evprov.Call(&Whois::EventListener::OnWhois, whois); /* * We only send these if we've been provided them. That is, if hideserver is turned off, and user is local, or * if remote whois is queried, too. This is to keep the user hidden, and also since you can't reliably tell remote time. -- w00t */ if ((idle) || (signon)) { whois.SendLine(RPL_WHOISIDLE, idle, signon, "seconds idle, signon time"); } whois.SendLine(RPL_ENDOFWHOIS, "End of /WHOIS list."); } CmdResult CommandWhois::HandleRemote(RemoteUser* target, const Params& parameters) { if (parameters.size() < 2) return CmdResult::FAILURE; auto* user = ServerInstance->Users.FindUUID(parameters[0]); if (!user) return CmdResult::FAILURE; // User doing the whois must be on this server LocalUser* localuser = IS_LOCAL(user); if (!localuser) return CmdResult::FAILURE; unsigned long idle = ConvToNum<unsigned long>(parameters.back()); DoWhois(localuser, target, target->signon, idle); return CmdResult::SUCCESS; } CmdResult CommandWhois::HandleLocal(LocalUser* user, const Params& parameters) { User* dest; unsigned int userindex = 0; unsigned long idle = 0; time_t signon = 0; if (CommandParser::LoopCall(user, this, parameters, 0)) return CmdResult::SUCCESS; /* * If 2 parameters are specified (/whois nick nick), ignore the first one like spanningtree * does, and use the second one, otherwise, use the only parameter. -- djGrrr */ if (parameters.size() > 1) userindex = 1; if (parameters[userindex].empty()) { user->WriteNumeric(ERR_NONICKNAMEGIVEN, "No nickname given"); return CmdResult::FAILURE; } dest = ServerInstance->Users.FindNick(parameters[userindex], true); if (dest) { /* * Okay. Umpteenth attempt at doing this, so let's re-comment... * For local users (/w localuser), we show idletime if hideserver is disabled * For local users (/w localuser localuser), we always show idletime, hence parameters.size() > 1 check. * For remote users (/w remoteuser), we do NOT show idletime * For remote users (/w remoteuser remoteuser), spanningtree will handle calling do_whois, so we can ignore this case. * Thanks to djGrrr for not being impatient while I have a crap day coding. :p -- w00t */ LocalUser* localuser = IS_LOCAL(dest); if (localuser && (ServerInstance->Config->HideServer.empty() || parameters.size() > 1)) { idle = ServerInstance->Time() - localuser->idle_lastmsg; signon = dest->signon; } DoWhois(user, dest, signon, idle); } else { /* no such nick/channel */ user->WriteNumeric(Numerics::NoSuchNick(parameters[userindex])); user->WriteNumeric(RPL_ENDOFWHOIS, parameters[userindex], "End of /WHOIS list."); return CmdResult::FAILURE; } return CmdResult::SUCCESS; } class CoreModWhois final : public Module { private: CommandWhois cmd; public: CoreModWhois() : Module(VF_CORE | VF_VENDOR, "Provides the WHOIS command") , cmd(this) { } void ReadConfig(ConfigStatus&) override { const auto& options = ServerInstance->Config->ConfValue("options"); cmd.splitwhois = options->getEnum("splitwhois", SPLITWHOIS_NONE, { { "no", SPLITWHOIS_NONE }, { "split", SPLITWHOIS_SPLIT }, { "splitmsg", SPLITWHOIS_SPLITMSG }, }); const auto& security = ServerInstance->Config->ConfValue("security"); cmd.genericoper = security->getBool("genericoper"); } }; MODULE_INIT(CoreModWhois) �������inspircd-4.7.0/src/coremods/core_whowas.cpp���������������������������������������������������������0000664�0000000�0000000�00000031756�14771603147�0021011�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2022 Val Lorentz <progval+git@progval.net> * Copyright (C) 2017-2024 Sadie Powell <sadie@witchery.services> * Copyright (C) 2012, 2014-2016 Attila Molnar <attilamolnar@hush.com> * Copyright (C) 2012 Robby <robby@chatbelgie.be> * Copyright (C) 2009 Uli Schlachter <psychon@znc.in> * Copyright (C) 2009 Daniel De Graaf <danieldg@inspircd.org> * Copyright (C) 2008 Robin Burchell <robin+git@viroteck.net> * Copyright (C) 2006-2007 Dennis Friis <peavey@inspircd.org> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include "inspircd.h" #include "modules/stats.h" #include "modules/whois.h" #include "timeutils.h" enum { // From RFC 1459. RPL_WHOWASUSER = 314, RPL_ENDOFWHOWAS = 369, ERR_WASNOSUCHNICK = 406, }; namespace WhoWas { /** One entry for a nick. There may be multiple entries for a nick. */ struct Entry final { /** Real hostname */ const std::string host; /** Displayed hostname */ const std::string dhost; /** Real username */ const std::string user; /** Displayed username */ const std::string duser; /** Server name */ const std::string server; /** Real name */ const std::string real; /** IP address or UNIX socket path. */ const std::string address; /** Signon time */ const time_t signon; /** Initialize this Entry with a user */ Entry(User* user); /** Retrieves the real hostname of the user. */ const auto& GetHost() const { return host.empty() ? dhost : host; } /** Retrieves the real username of the user. */ const auto& GetUser() const { return user.empty() ? duser : user; } }; /** Everything known about one nick */ struct Nick final : public insp::intrusive_list_node<Nick> { /** A group of users related by nickname */ typedef std::deque<Entry*> List; /** Container where each element has information about one occurrence of this nick */ List entries; /** Time this nick was added to the database */ const time_t addtime; /** Nickname whose information is stored in this class */ const std::string nick; /** Constructor to initialize fields */ Nick(const std::string& nickname); /** Destructor, deallocates all elements in the entries container */ ~Nick(); }; class Manager final { public: struct Stats final { /** Number of currently existing WhoWas::Entry objects */ size_t entrycount; }; /** Add a user to the whowas database. Called when a user quits. * @param user The user to add to the database */ void Add(User* user, const std::string& nickname); /** Retrieves statistics about the whowas database * @return Whowas statistics as a WhoWas::Manager::Stats struct */ Stats GetStats() const; /** Expires old entries */ void Maintain(); /** Updates the current configuration which may result in the database being pruned if the * new values are lower than the current ones. * @param NewGroupSize Maximum number of nicks allowed in the database. In case there are this many nicks * in the database and one more is added, the oldest one is removed (FIFO). * @param NewMaxGroups Maximum number of entries per nick * @param NewMaxKeep Seconds how long each nick should be kept */ void UpdateConfig(unsigned int NewGroupSize, unsigned int NewMaxGroups, unsigned long NewMaxKeep); /** Retrieves all data known about a given nick * @param nick Nickname to find, case insensitive (IRC casemapping) * @return A pointer to a WhoWas::Nick if the nick was found, NULL otherwise */ const Nick* FindNick(const std::string& nick) const; /** Returns true if WHOWAS is enabled according to the current configuration * @return True if WHOWAS is enabled according to the configuration, false if WHOWAS is disabled */ bool IsEnabled() const; /** Destructor */ ~Manager(); private: /** Order in which the users were added into the map, used to remove oldest nick */ typedef insp::intrusive_list_tail<Nick> FIFO; /** Sets of users in the whowas system */ typedef std::unordered_map<std::string, WhoWas::Nick*, irc::insensitive, irc::StrHashComp> whowas_users; /** Primary container, links nicknames tracked by WHOWAS to a list of records */ whowas_users whowas; /** List of nicknames in the order they were inserted into the map */ FIFO whowas_fifo; /** Max number of WhoWas entries per user. */ unsigned int GroupSize = 0; /** Max number of cumulative user-entries in WhoWas. * When max reached and added to, push out oldest entry FIFO style. */ unsigned int MaxGroups = 0; /** Max seconds a user is kept in WhoWas before being pruned. */ unsigned long MaxKeep = 0; /** Shrink all data structures to honor the current settings */ void Prune(); /** Remove a nick (and all entries belonging to it) from the database * @param it Iterator to the nick to purge */ void PurgeNick(whowas_users::iterator it); /** Remove a nick (and all entries belonging to it) from the database * @param nick Nick to purge */ void PurgeNick(WhoWas::Nick* nick); }; } class CommandWhowas final : public Command { public: // Manager handling all whowas database related tasks WhoWas::Manager manager; CommandWhowas(Module* parent); CmdResult Handle(User* user, const Params& parameters) override; }; CommandWhowas::CommandWhowas( Module* parent) : Command(parent, "WHOWAS", 1) { allow_empty_last_param = true; penalty = 2000; syntax = { "<nick> [<count>]" }; } CmdResult CommandWhowas::Handle(User* user, const Params& parameters) { /* if whowas disabled in config */ if (!manager.IsEnabled()) { user->WriteNumeric(ERR_UNKNOWNCOMMAND, name, "This command has been disabled."); return CmdResult::FAILURE; } if (parameters[0].empty()) { user->WriteNumeric(ERR_NONICKNAMEGIVEN, "No nickname given"); return CmdResult::FAILURE; } const WhoWas::Nick* const nick = manager.FindNick(parameters[0]); if (!nick) { user->WriteNumeric(ERR_WASNOSUCHNICK, parameters[0], "There was no such nickname"); } else { WhoWas::Nick::List::const_reverse_iterator last = nick->entries.rend(); if (parameters.size() > 1) { size_t count = ConvToNum<size_t>(parameters[1]); if (count > 0 && (size_t) std::distance(nick->entries.rbegin(), last) > count) last = nick->entries.rbegin() + count; } for (const auto* u : insp::iterator_range(nick->entries.rbegin(), last)) { user->WriteNumeric(RPL_WHOWASUSER, parameters[0], u->duser, u->dhost, '*', u->real); if (user->HasPrivPermission("users/auspex")) user->WriteNumeric(RPL_WHOISACTUALLY, parameters[0], INSP_FORMAT("{}@{}", u->GetUser(), u->GetHost()), u->address, "was connecting from"); const std::string signon = Time::ToString(u->signon); bool hide_server = (!ServerInstance->Config->HideServer.empty() && !user->HasPrivPermission("servers/auspex")); user->WriteNumeric(RPL_WHOISSERVER, parameters[0], (hide_server ? ServerInstance->Config->HideServer : u->server), signon); } } user->WriteNumeric(RPL_ENDOFWHOWAS, parameters[0], "End of WHOWAS"); return CmdResult::SUCCESS; } const WhoWas::Nick* WhoWas::Manager::FindNick(const std::string& nickname) const { whowas_users::const_iterator it = whowas.find(nickname); if (it == whowas.end()) return nullptr; return it->second; } WhoWas::Manager::Stats WhoWas::Manager::GetStats() const { size_t entrycount = 0; for (const auto& [_, nick] : whowas) entrycount += nick->entries.size(); Stats stats; stats.entrycount = entrycount; return stats; } void WhoWas::Manager::Add(User* user, const std::string& nickname) { if (!IsEnabled()) return; // Insert nick if it doesn't exist // 'first' will point to the newly inserted element or to the existing element with an equivalent key std::pair<whowas_users::iterator, bool> ret = whowas.emplace(nickname, nullptr); if (ret.second) // If inserted { // This nick is new, create a list for it and add the first record to it auto* nick = new WhoWas::Nick(ret.first->first); nick->entries.push_back(new Entry(user)); ret.first->second = nick; // Add this nick to the fifo too whowas_fifo.push_back(nick); if (whowas.size() > this->MaxGroups) { // Too many nicks, remove the nick which was inserted the longest time ago from both the map and the fifo PurgeNick(whowas_fifo.front()); } } else { // We've met this nick before, add a new record to the list WhoWas::Nick::List& list = ret.first->second->entries; list.push_back(new Entry(user)); // If there are too many records for this nick, remove the oldest (front) if (list.size() > this->GroupSize) { delete list.front(); list.pop_front(); } } } /* on rehash, refactor maps according to new conf values */ void WhoWas::Manager::Prune() { time_t min = ServerInstance->Time() - this->MaxKeep; /* first cut the list to new size (maxgroups) and also prune entries that are timed out. */ while (!whowas_fifo.empty()) { WhoWas::Nick* nick = whowas_fifo.front(); if ((whowas_fifo.size() > this->MaxGroups) || (nick->addtime < min)) PurgeNick(nick); else break; } /* Then cut the whowas sets to new size (groupsize) */ for (whowas_users::iterator i = whowas.begin(); i != whowas.end(); ) { WhoWas::Nick::List& list = i->second->entries; while (list.size() > this->GroupSize) { delete list.front(); list.pop_front(); } if (list.empty()) PurgeNick(i++); else ++i; } } /* call maintain once an hour to remove expired nicks */ void WhoWas::Manager::Maintain() { time_t min = ServerInstance->Time() - this->MaxKeep; for (whowas_users::iterator i = whowas.begin(); i != whowas.end(); ) { WhoWas::Nick::List& list = i->second->entries; while (!list.empty() && list.front()->signon < min) { delete list.front(); list.pop_front(); } if (list.empty()) PurgeNick(i++); else ++i; } } WhoWas::Manager::~Manager() { for (const auto& [_, nick] : whowas) delete nick; } bool WhoWas::Manager::IsEnabled() const { return ((GroupSize != 0) && (MaxGroups != 0)); } void WhoWas::Manager::UpdateConfig(unsigned int NewGroupSize, unsigned int NewMaxGroups, unsigned long NewMaxKeep) { if ((NewGroupSize == GroupSize) && (NewMaxGroups == MaxGroups) && (NewMaxKeep == MaxKeep)) return; GroupSize = NewGroupSize; MaxGroups = NewMaxGroups; MaxKeep = NewMaxKeep; Prune(); } void WhoWas::Manager::PurgeNick(whowas_users::iterator it) { WhoWas::Nick* nick = it->second; whowas_fifo.erase(nick); whowas.erase(it); delete nick; } void WhoWas::Manager::PurgeNick(WhoWas::Nick* nick) { whowas_users::iterator it = whowas.find(nick->nick); if (it == whowas.end()) { ServerInstance->Logs.Debug(MODNAME, "BUG: Inconsistency detected in whowas database, please report"); return; } PurgeNick(it); } WhoWas::Entry::Entry(User* u) : host(u->GetRealHost() == u->GetDisplayedHost() ? "" : u->GetRealHost()) , dhost(u->GetDisplayedHost()) , user(u->GetRealUser() == u->GetDisplayedUser() ? "" : u->GetRealUser()) , duser(u->GetDisplayedUser()) , server(u->server->GetName()) , real(u->GetRealName()) , address(u->GetAddress()) , signon(u->signon) { } WhoWas::Nick::Nick(const std::string& nickname) : addtime(ServerInstance->Time()) , nick(nickname) { } WhoWas::Nick::~Nick() { stdalgo::delete_all(entries); } class ModuleWhoWas final : public Module , public Stats::EventListener { public: CommandWhowas cmd; bool nickupdate; public: ModuleWhoWas() : Module(VF_CORE | VF_VENDOR, "Provides the WHOWAS command") , Stats::EventListener(this) , cmd(this) { } void OnGarbageCollect() override { // Remove all entries older than MaxKeep cmd.manager.Maintain(); } void OnUserQuit(User* user, const std::string& message, const std::string& oper_message) override { if (user->nick != user->uuid) cmd.manager.Add(user, user->nick); } void OnUserPostNick(User* user, const std::string& oldnick) override { if (nickupdate && oldnick != user->uuid) cmd.manager.Add(user, oldnick); } ModResult OnStats(Stats::Context& stats) override { if (stats.GetSymbol() == 'z') stats.AddRow(249, "Whowas entries: "+ConvToStr(cmd.manager.GetStats().entrycount)); return MOD_RES_PASSTHRU; } void ReadConfig(ConfigStatus& status) override { const auto& tag = ServerInstance->Config->ConfValue("whowas"); const auto groupsize = tag->getNum<unsigned int>("groupsize", 10); const auto maxgroups = tag->getNum<unsigned int>("maxgroups", 10000); const auto maxkeep = tag->getDuration("maxkeep", 7*24*60*60, 60*60); nickupdate = tag->getBool("nickupdate", true); cmd.manager.UpdateConfig(groupsize, maxgroups, maxkeep); } }; MODULE_INIT(ModuleWhoWas) ������������������inspircd-4.7.0/src/coremods/core_xline/�������������������������������������������������������������0000775�0000000�0000000�00000000000�14771603147�0020100�5����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/src/coremods/core_xline/cmd_eline.cpp������������������������������������������������0000664�0000000�0000000�00000006460�14771603147�0022531�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2019 Matt Schatz <genius3000@g3k.solutions> * Copyright (C) 2018, 2020-2023, 2025 Sadie Powell <sadie@witchery.services> * Copyright (C) 2018 linuxdaemon <linuxdaemon.irc@gmail.com> * Copyright (C) 2014 Attila Molnar <attilamolnar@hush.com> * Copyright (C) 2012, 2019 Robby <robby@chatbelgie.be> * Copyright (C) 2009 Daniel De Graaf <danieldg@inspircd.org> * Copyright (C) 2008 Robin Burchell <robin+git@viroteck.net> * Copyright (C) 2006-2008 Craig Edwards <brain@inspircd.org> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include "inspircd.h" #include "xline.h" #include "core_xline.h" CommandEline::CommandEline(Module* parent) : Command(parent, "ELINE", 1, 3) { access_needed = CmdAccess::OPERATOR; syntax = { "<user@host>[,<user@host>]+ [[<duration>] :<reason>]" }; } CmdResult CommandEline::Handle(User* user, const Params& parameters) { if (CommandParser::LoopCall(user, this, parameters, 0)) return CmdResult::SUCCESS; std::string target = parameters[0]; if (parameters.size() > 1) { UserHostPair ih; auto* find = ServerInstance->Users.Find(target, true); if (find) { ih.first = find->GetBanUser(true); ih.second = find->GetAddress(); target = ih.first + "@" + ih.second; } else ih = XLineManager::SplitUserHost(target); if (ih.first.empty()) { user->WriteNotice("*** Target not found."); return CmdResult::FAILURE; } InsaneBan::IPHostMatcher matcher; if (InsaneBan::MatchesEveryone(ih.first + "@" + ih.second, matcher, user, 'E', "hostmasks")) return CmdResult::FAILURE; unsigned long duration = 0; if (parameters.size() > 2 && !Duration::TryFrom(parameters[1], duration)) { user->WriteNotice("*** Invalid duration for E-line."); return CmdResult::FAILURE; } auto* el = new ELine(ServerInstance->Time(), duration, user->nick, parameters.back(), ih.first, ih.second); if (ServerInstance->XLines->AddLine(el, user)) { if (!duration) { ServerInstance->SNO.WriteToSnoMask('x', "{} added a permanent E-line on {}: {}", user->nick, target, el->reason); } else { ServerInstance->SNO.WriteToSnoMask('x', "{} added a timed E-line on {}, expires in {} (on {}): {}", user->nick, target, Duration::ToLongString(duration), Time::FromNow(duration), el->reason); } } else { delete el; user->WriteNotice("*** E-line for " + target + " already exists."); } } else { std::string reason; if (ServerInstance->XLines->DelLine(target, "E", reason, user)) { ServerInstance->SNO.WriteToSnoMask('x', "{} removed E-line on {}: {}", user->nick, target, reason); } else { user->WriteNotice("*** E-line " + target + " not found on the list."); } } return CmdResult::SUCCESS; } ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/src/coremods/core_xline/cmd_gline.cpp������������������������������������������������0000664�0000000�0000000�00000007074�14771603147�0022535�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2019 Matt Schatz <genius3000@g3k.solutions> * Copyright (C) 2018, 2020-2023, 2025 Sadie Powell <sadie@witchery.services> * Copyright (C) 2018 linuxdaemon <linuxdaemon.irc@gmail.com> * Copyright (C) 2014 Attila Molnar <attilamolnar@hush.com> * Copyright (C) 2012, 2019 Robby <robby@chatbelgie.be> * Copyright (C) 2009 Uli Schlachter <psychon@znc.in> * Copyright (C) 2009 Daniel De Graaf <danieldg@inspircd.org> * Copyright (C) 2007-2008 Robin Burchell <robin+git@viroteck.net> * Copyright (C) 2006-2008 Craig Edwards <brain@inspircd.org> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include "inspircd.h" #include "xline.h" #include "core_xline.h" CommandGline::CommandGline(Module* parent) : Command(parent, "GLINE", 1, 3) { access_needed = CmdAccess::OPERATOR; syntax = { "<user@host>[,<user@host>]+ [[<duration>] :<reason>]" }; } CmdResult CommandGline::Handle(User* user, const Params& parameters) { if (CommandParser::LoopCall(user, this, parameters, 0)) return CmdResult::SUCCESS; std::string target = parameters[0]; if (parameters.size() > 1) { UserHostPair ih; auto* find = ServerInstance->Users.Find(target, true); if (find) { ih.first = find->GetBanUser(true); ih.second = find->GetAddress(); target = ih.first + "@" + ih.second; } else ih = XLineManager::SplitUserHost(target); if (ih.first.empty()) { user->WriteNotice("*** Target not found."); return CmdResult::FAILURE; } InsaneBan::IPHostMatcher matcher; if (InsaneBan::MatchesEveryone(ih.first + "@" + ih.second, matcher, user, 'G', "hostmasks")) return CmdResult::FAILURE; else if (target.find('!') != std::string::npos) { user->WriteNotice("*** G-line cannot operate on nick!user@host masks."); return CmdResult::FAILURE; } unsigned long duration = 0; if (parameters.size() > 2 && !Duration::TryFrom(parameters[1], duration)) { user->WriteNotice("*** Invalid duration for G-line."); return CmdResult::FAILURE; } auto* gl = new GLine(ServerInstance->Time(), duration, user->nick, parameters.back(), ih.first, ih.second); if (ServerInstance->XLines->AddLine(gl, user)) { if (!duration) { ServerInstance->SNO.WriteToSnoMask('x', "{} added a permanent G-line on {}: {}", user->nick, target, gl->reason); } else { ServerInstance->SNO.WriteToSnoMask('x', "{} added a timed G-line on {}, expires in {} (on {}): {}", user->nick, target, Duration::ToLongString(duration), Time::FromNow(duration), gl->reason); } ServerInstance->XLines->ApplyLines(); } else { delete gl; user->WriteNotice("** G-line for " + target + " already exists."); } } else { std::string reason; if (ServerInstance->XLines->DelLine(target, "G", reason, user)) { ServerInstance->SNO.WriteToSnoMask('x', "{} removed G-line on {}: {}", user->nick, target, reason); } else { user->WriteNotice("*** G-line " + target + " not found on the list."); } } return CmdResult::SUCCESS; } ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/src/coremods/core_xline/cmd_kline.cpp������������������������������������������������0000664�0000000�0000000�00000007067�14771603147�0022543�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2019 Matt Schatz <genius3000@g3k.solutions> * Copyright (C) 2018, 2020-2023, 2025 Sadie Powell <sadie@witchery.services> * Copyright (C) 2018 linuxdaemon <linuxdaemon.irc@gmail.com> * Copyright (C) 2014 Attila Molnar <attilamolnar@hush.com> * Copyright (C) 2012, 2019 Robby <robby@chatbelgie.be> * Copyright (C) 2009 Uli Schlachter <psychon@znc.in> * Copyright (C) 2009 Daniel De Graaf <danieldg@inspircd.org> * Copyright (C) 2007-2008 Robin Burchell <robin+git@viroteck.net> * Copyright (C) 2006-2008 Craig Edwards <brain@inspircd.org> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include "inspircd.h" #include "xline.h" #include "core_xline.h" CommandKline::CommandKline(Module* parent) : Command(parent, "KLINE", 1, 3) { access_needed = CmdAccess::OPERATOR; syntax = { "<user@host>[,<user@host>]+ [[<duration>] :<reason>]" }; } CmdResult CommandKline::Handle(User* user, const Params& parameters) { if (CommandParser::LoopCall(user, this, parameters, 0)) return CmdResult::SUCCESS; std::string target = parameters[0]; if (parameters.size() > 1) { UserHostPair ih; auto* find = ServerInstance->Users.Find(target, true); if (find) { ih.first = find->GetBanUser(true); ih.second = find->GetAddress(); target = ih.first + "@" + ih.second; } else ih = XLineManager::SplitUserHost(target); if (ih.first.empty()) { user->WriteNotice("*** Target not found."); return CmdResult::FAILURE; } InsaneBan::IPHostMatcher matcher; if (InsaneBan::MatchesEveryone(ih.first + "@" + ih.second, matcher, user, 'K', "hostmasks")) return CmdResult::FAILURE; if (target.find('!') != std::string::npos) { user->WriteNotice("*** K-line cannot operate on nick!user@host masks."); return CmdResult::FAILURE; } unsigned long duration = 0; if (parameters.size() > 2 && !Duration::TryFrom(parameters[1], duration)) { user->WriteNotice("*** Invalid duration for K-line."); return CmdResult::FAILURE; } auto* kl = new KLine(ServerInstance->Time(), duration, user->nick, parameters.back(), ih.first, ih.second); if (ServerInstance->XLines->AddLine(kl, user)) { if (!duration) { ServerInstance->SNO.WriteToSnoMask('x', "{} added a permanent K-line on {}: {}", user->nick, target, kl->reason); } else { ServerInstance->SNO.WriteToSnoMask('x', "{} added a timed K-line on {}, expires in {} (on {}): {}", user->nick, target, Duration::ToLongString(duration), Time::FromNow(duration), kl->reason); } ServerInstance->XLines->ApplyLines(); } else { delete kl; user->WriteNotice("*** K-line for " + target + " already exists."); } } else { std::string reason; if (ServerInstance->XLines->DelLine(target, "K", reason, user)) { ServerInstance->SNO.WriteToSnoMask('x', "{} removed K-line on {}: {}", user->nick, target, reason); } else { user->WriteNotice("*** K-line " + target + " not found on the list."); } } return CmdResult::SUCCESS; } �������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/src/coremods/core_xline/cmd_qline.cpp������������������������������������������������0000664�0000000�0000000�00000006703�14771603147�0022545�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2019 Matt Schatz <genius3000@g3k.solutions> * Copyright (C) 2018, 2020, 2022-2023, 2025 Sadie Powell <sadie@witchery.services> * Copyright (C) 2018 linuxdaemon <linuxdaemon.irc@gmail.com> * Copyright (C) 2014 Attila Molnar <attilamolnar@hush.com> * Copyright (C) 2012, 2019 Robby <robby@chatbelgie.be> * Copyright (C) 2009 Daniel De Graaf <danieldg@inspircd.org> * Copyright (C) 2008 Thomas Stagner <aquanight@gmail.com> * Copyright (C) 2007 Robin Burchell <robin+git@viroteck.net> * Copyright (C) 2006-2008 Craig Edwards <brain@inspircd.org> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include "inspircd.h" #include "xline.h" #include "core_xline.h" CommandQline::CommandQline(Module* parent) : Command(parent, "QLINE", 1, 3) { access_needed = CmdAccess::OPERATOR; syntax = { "<nickmask>[,<nickmask>]+ [[<duration>] :<reason>]" }; } CmdResult CommandQline::Handle(User* user, const Params& parameters) { if (CommandParser::LoopCall(user, this, parameters, 0)) return CmdResult::SUCCESS; if (parameters.size() > 1) { NickMatcher matcher; if (InsaneBan::MatchesEveryone(parameters[0], matcher, user, 'Q', "nickmasks")) return CmdResult::FAILURE; if (parameters[0].find('@') != std::string::npos || parameters[0].find('!') != std::string::npos || parameters[0].find('.') != std::string::npos) { user->WriteNotice("*** A Q-line only bans a nick pattern, not a nick!user@host pattern."); return CmdResult::FAILURE; } unsigned long duration = 0; if (parameters.size() > 2 && !Duration::TryFrom(parameters[1], duration)) { user->WriteNotice("*** Invalid duration for Q-line."); return CmdResult::FAILURE; } auto* ql = new QLine(ServerInstance->Time(), duration, user->nick, parameters.back(), parameters[0]); if (ServerInstance->XLines->AddLine(ql, user)) { if (!duration) { ServerInstance->SNO.WriteToSnoMask('x', "{} added a permanent Q-line on {}: {}", user->nick, parameters[0], ql->reason); } else { ServerInstance->SNO.WriteToSnoMask('x', "{} added a timed Q-line on {}, expires in {} (on {}): {}", user->nick, parameters[0], Duration::ToLongString(duration), Time::FromNow(duration), ql->reason); } ServerInstance->XLines->ApplyLines(); } else { delete ql; user->WriteNotice("*** Q-line for " + parameters[0] + " already exists."); } } else { std::string reason; if (ServerInstance->XLines->DelLine(parameters[0], "Q", reason, user)) { ServerInstance->SNO.WriteToSnoMask('x', "{} removed Q-line on {}: {}", user->nick, parameters[0], reason); } else { user->WriteNotice("*** Q-line " + parameters[0] + " not found on the list."); return CmdResult::FAILURE; } } return CmdResult::SUCCESS; } bool CommandQline::NickMatcher::Check(User* user, const std::string& nick) const { return InspIRCd::Match(user->nick, nick); } �������������������������������������������������������������inspircd-4.7.0/src/coremods/core_xline/cmd_zline.cpp������������������������������������������������0000664�0000000�0000000�00000007323�14771603147�0022555�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2019 Matt Schatz <genius3000@g3k.solutions> * Copyright (C) 2018, 2020, 2022-2023, 2025 Sadie Powell <sadie@witchery.services> * Copyright (C) 2018 linuxdaemon <linuxdaemon.irc@gmail.com> * Copyright (C) 2014 Attila Molnar <attilamolnar@hush.com> * Copyright (C) 2012, 2019 Robby <robby@chatbelgie.be> * Copyright (C) 2009 Uli Schlachter <psychon@znc.in> * Copyright (C) 2009 Matt Smith <dz@inspircd.org> * Copyright (C) 2009 Daniel De Graaf <danieldg@inspircd.org> * Copyright (C) 2007-2008 Robin Burchell <robin+git@viroteck.net> * Copyright (C) 2007-2008 Craig Edwards <brain@inspircd.org> * Copyright (C) 2007 Dennis Friis <peavey@inspircd.org> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include "inspircd.h" #include "xline.h" #include "core_xline.h" CommandZline::CommandZline(Module* parent) : Command(parent, "ZLINE", 1, 3) { access_needed = CmdAccess::OPERATOR; syntax = { "<ipmask>[,<ipmask>]+ [[<duration>] :<reason>]" }; } CmdResult CommandZline::Handle(User* user, const Params& parameters) { if (CommandParser::LoopCall(user, this, parameters, 0)) return CmdResult::SUCCESS; std::string target = parameters[0]; if (parameters.size() > 1) { if (target.find('!') != std::string::npos) { user->WriteNotice("*** You cannot include a nickname in a Z-line, a Z-line must ban only an IP mask."); return CmdResult::FAILURE; } auto* u = ServerInstance->Users.Find(target, true); if (u) { target = u->GetAddress(); } const char* ipaddr = target.c_str(); if (strchr(ipaddr, '@')) { while (*ipaddr != '@') ipaddr++; ipaddr++; } IPMatcher matcher; if (InsaneBan::MatchesEveryone(ipaddr, matcher, user, 'Z', "ipmasks")) return CmdResult::FAILURE; unsigned long duration = 0; if (parameters.size() > 2 && !Duration::TryFrom(parameters[1], duration)) { user->WriteNotice("*** Invalid duration for Z-line."); return CmdResult::FAILURE; } auto* zl = new ZLine(ServerInstance->Time(), duration, user->nick, parameters.back(), ipaddr); if (ServerInstance->XLines->AddLine(zl, user)) { if (!duration) { ServerInstance->SNO.WriteToSnoMask('x', "{} added a permanent Z-line on {}: {}", user->nick, ipaddr, zl->reason); } else { ServerInstance->SNO.WriteToSnoMask('x', "{} added a timed Z-line on {}, expires in {} (on {}): {}", user->nick, ipaddr, Duration::ToLongString(duration), Time::FromNow(duration), zl->reason); } ServerInstance->XLines->ApplyLines(); } else { delete zl; user->WriteNotice("*** Z-line for " + std::string(ipaddr) + " already exists."); } } else { std::string reason; if (ServerInstance->XLines->DelLine(target, "Z", reason, user)) { ServerInstance->SNO.WriteToSnoMask('x', "{} removed Z-line on {}: {}", user->nick, target, reason); } else { user->WriteNotice("*** Z-line " + target + " not found on the list."); return CmdResult::FAILURE; } } return CmdResult::SUCCESS; } bool CommandZline::IPMatcher::Check(User* user, const std::string& ip) const { return InspIRCd::MatchCIDR(user->GetAddress(), ip, ascii_case_insensitive_map); } �������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/src/coremods/core_xline/core_xline.cpp�����������������������������������������������0000664�0000000�0000000�00000013411�14771603147�0022733�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2019-2024 Sadie Powell <sadie@witchery.services> * Copyright (C) 2019 linuxdaemon <linuxdaemon.irc@gmail.com> * Copyright (C) 2019 Robby <robby@chatbelgie.be> * Copyright (C) 2019 Matt Schatz <genius3000@g3k.solutions> * Copyright (C) 2014 Attila Molnar <attilamolnar@hush.com> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include "inspircd.h" #include "xline.h" #include "core_xline.h" bool InsaneBan::MatchesEveryone(const std::string& mask, MatcherBase& test, User* user, char bantype, const char* confkey) { const auto& insane = ServerInstance->Config->ConfValue("insane"); if (insane->getBool(confkey)) return false; float itrigger = insane->getNum<float>("trigger", 95.5, 0.0, 100.0); long matches = test.Run(mask); if (!matches) return false; float percent = ((float)matches / (float)ServerInstance->Users.GetUsers().size()) * 100; if (percent > itrigger) { const char* article = strchr("AEIOUaeiou", bantype) ? "an" : "a"; ServerInstance->SNO.WriteToSnoMask('x', "\002WARNING\002: {} tried to set add {} {}-line on {} which covers {:.2}% of the network which is more than the maximum of {:.2}%!", user->nick, article, bantype, mask, percent, itrigger); user->WriteNotice("*** Unable to add {} {}-line on {} which covers {:.2}% of the network which is more than the maximum of {:.2}%!", article, bantype, mask, percent, itrigger); return true; } return false; } bool InsaneBan::IPHostMatcher::Check(User* user, const std::string& mask) const { return ((InspIRCd::MatchCIDR(user->GetRealUserHost(), mask, ascii_case_insensitive_map)) || (InspIRCd::MatchCIDR(user->GetUserAddress(), mask, ascii_case_insensitive_map))); } class CoreModXLine final : public Module { private: CommandEline cmdeline; CommandGline cmdgline; CommandKline cmdkline; CommandQline cmdqline; CommandZline cmdzline; static void ReadXLine(const std::string& tag, const std::string& key, const std::string& type) { XLineFactory* make = ServerInstance->XLines->GetFactory(type); if (!make) throw CoreException("BUG: Unable to find the " + type + "-line factory!"); insp::flat_set<std::string> configlines; for (const auto& [_, ctag] : ServerInstance->Config->ConfTags(tag)) { const std::string mask = ctag->getString(key); if (mask.empty()) throw CoreException("<" + tag + ":" + key + "> missing at " + ctag->source.str()); const std::string reason = ctag->getString("reason"); if (reason.empty()) throw CoreException("<" + tag + ":reason> missing at " + ctag->source.str()); XLine* xl = make->Generate(ServerInstance->Time(), 0, ServerInstance->Config->ServerName, reason, mask); xl->from_config = true; configlines.insert(xl->Displayable()); if (!ServerInstance->XLines->AddLine(xl, nullptr)) delete xl; } ServerInstance->XLines->ExpireRemovedConfigLines(make->GetType(), configlines); } public: CoreModXLine() : Module(VF_CORE | VF_VENDOR, "Provides the ELINE, GLINE, KLINE, QLINE, and ZLINE commands") , cmdeline(this) , cmdgline(this) , cmdkline(this) , cmdqline(this) , cmdzline(this) { } void init() override { ServerInstance->SNO.EnableSnomask('x', "XLINE"); } void ReadConfig(ConfigStatus& status) override { ReadXLine("badip", "ipmask", "Z"); ReadXLine("badnick", "nick", "Q"); ReadXLine("badhost", "host", "K"); ReadXLine("exception", "host", "E"); ServerInstance->XLines->CheckELines(); ServerInstance->XLines->ApplyLines(); } void OnChangeRemoteAddress(LocalUser* user) override { if (user->quitting) return; user->exempt = (ServerInstance->XLines->MatchesLine("E", user) != nullptr); user->CheckLines(true); } void OnPostChangeRealHost(User* user) override { LocalUser* luser = IS_LOCAL(user); if (!luser || luser->quitting) return; luser->exempt = (ServerInstance->XLines->MatchesLine("E", user) != nullptr); luser->CheckLines(false); } void OnPostChangeRealUser(User* user) override { LocalUser* luser = IS_LOCAL(user); if (!luser || luser->quitting) return; luser->exempt = !!ServerInstance->XLines->MatchesLine("E", user); luser->CheckLines(false); } ModResult OnUserPreNick(LocalUser* user, const std::string& newnick) override { // Check Q-lines (for local nick changes only, remote servers have our Q-lines to enforce themselves) XLine* xline = ServerInstance->XLines->MatchesLine("Q", newnick); if (!xline) return MOD_RES_PASSTHRU; // No match // A Q-line matched the new nick, tell opers if the user is fully connected if (user->IsFullyConnected()) { ServerInstance->SNO.WriteGlobalSno('x', "Q-lined nickname {} from {}: {}", newnick, user->GetRealMask(), xline->reason); } // Send a numeric because if we deny then the core doesn't reply anything user->WriteNumeric(ERR_ERRONEUSNICKNAME, newnick, INSP_FORMAT("Invalid nickname: {}", xline->reason)); return MOD_RES_DENY; } void OnGarbageCollect() override { // HACK: ELines are not expired properly at the moment but it can't be fixed // as the XLine system is a spaghetti nightmare. Instead we skip over expired // ELines in XLineManager::CheckELines() and expire them here instead. ServerInstance->XLines->GetAll("E"); } }; MODULE_INIT(CoreModXLine) �������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/src/coremods/core_xline/core_xline.h�������������������������������������������������0000664�0000000�0000000�00000006217�14771603147�0022406�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2019, 2021-2023 Sadie Powell <sadie@witchery.services> * Copyright (C) 2014 Attila Molnar <attilamolnar@hush.com> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #pragma once #include "inspircd.h" #include "timeutils.h" class InsaneBan final { public: class MatcherBase { public: virtual long Run(const std::string& mask) = 0; }; template <typename T> class Matcher : public MatcherBase { public: long Run(const std::string& mask) override { long matches = 0; auto c = static_cast<T*>(this); for (const auto& [_, user] : ServerInstance->Users.GetUsers()) { if (c->Check(user, mask)) matches++; } return matches; } }; class IPHostMatcher final : public Matcher<IPHostMatcher> { public: bool Check(User* user, const std::string& mask) const; }; /** Check if the given mask matches too many users according to the config, send an announcement if yes * @param mask A mask to match against * @param test The test that determines if a user matches the mask or not * @param user A user whose nick will be included in the announcement if one is made * @param bantype Type of the ban being set, will be used in the announcement if one is made * @param confkey Name of the config key (inside the insane tag) which if false disables any checking * @return True if the given mask matches too many users, false if not */ static bool MatchesEveryone(const std::string& mask, MatcherBase& test, User* user, char bantype, const char* confkey); }; class CommandEline final : public Command { public: CommandEline(Module* parent); CmdResult Handle(User* user, const Params& parameters) override; }; class CommandGline final : public Command { public: CommandGline(Module* parent); CmdResult Handle(User* user, const Params& parameters) override; }; class CommandKline final : public Command { public: CommandKline(Module* parent); CmdResult Handle(User* user, const Params& parameters) override; }; class CommandQline final : public Command { private: class NickMatcher final : public InsaneBan::Matcher<NickMatcher> { public: bool Check(User* user, const std::string& mask) const; }; public: CommandQline(Module* parent); CmdResult Handle(User* user, const Params& parameters) override; }; class CommandZline final : public Command { private: class IPMatcher final : public InsaneBan::Matcher<IPMatcher> { public: bool Check(User* user, const std::string& mask) const; }; public: CommandZline(Module* parent); CmdResult Handle(User* user, const Params& parameters) override; }; ���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/src/cull.cpp�������������������������������������������������������������������������0000664�0000000�0000000�00000007112�14771603147�0015602�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2019-2023 Sadie Powell <sadie@witchery.services> * Copyright (C) 2015 Attila Molnar <attilamolnar@hush.com> * Copyright (C) 2012 Robby <robby@chatbelgie.be> * Copyright (C) 2011 jackmcbarn <jackmcbarn@inspircd.org> * Copyright (C) 2009 Daniel De Graaf <danieldg@inspircd.org> * Copyright (C) 2007 Dennis Friis <peavey@inspircd.org> * Copyright (C) 2007 Craig Edwards <brain@inspircd.org> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include "inspircd.h" #ifdef INSPIRCD_ENABLE_RTTI # include <typeinfo> #endif #include <unordered_set> Cullable::Cullable() { #ifdef INSPIRCD_ENABLE_RTTI if (ServerInstance) { ServerInstance->Logs.Debug("CULL", "Cullable::+{} @{}", typeid(*this).name(), fmt::ptr(this)); } #endif } Cullable::~Cullable() { #ifdef INSPIRCD_ENABLE_RTTI if (ServerInstance) { ServerInstance->Logs.Debug("CULL", "Cullable::~{} @{}", typeid(*this).name(), fmt::ptr(this)); } #endif } Cullable::Result Cullable::Cull() { #ifdef INSPIRCD_ENABLE_RTTI if (ServerInstance) { ServerInstance->Logs.Debug("CULL", "Cullable::-{} @{}", typeid(*this).name(), fmt::ptr(this)); } #endif return {}; } void CullList::Apply() { std::vector<LocalUser *> working; while (!SQlist.empty()) { working.swap(SQlist); for (auto* u : working) { ServerInstance->SNO.WriteGlobalSno('a', "User {} SendQ exceeds connect class maximum of {}", u->nick, u->GetClass()->hardsendqmax); ServerInstance->Users.QuitUser(u, "SendQ exceeded"); } working.clear(); } std::unordered_set<Cullable*> culled; std::vector<Cullable*> deletable; culled.reserve(list.size() + 32); // IMPORTANT: we can't use a range-based for loop here as culling an object // may invalidate the list iterators. for (size_t idx = 0; idx < list.size(); ++idx) { auto* c = list[idx]; if (culled.insert(c).second) { #ifdef INSPIRCD_ENABLE_RTTI ServerInstance->Logs.Debug("CULL", "Culling {} @{}", typeid(*c).name(), fmt::ptr(c)); #endif c->Cull(); // IMPORTANT: we have to use two containers here because some objects // have to be deleted in the same order they were culled in. deletable.push_back(c); } else { #ifdef INSPIRCD_ENABLE_RTTI ServerInstance->Logs.Debug("CULL", "BUG: {} @{} was added to the cull list twice!", typeid(*c).name(), fmt::ptr(c)); #else ServerInstance->Logs.Debug("CULL", "BUG: @{} was added to the cull list twice!", fmt::ptr(c)); #endif } } list.clear(); for (auto* c : deletable) { #ifdef INSPIRCD_ENABLE_RTTI ServerInstance->Logs.Debug("CULL", "Deleting {} @{}", typeid(*c).name(), fmt::ptr(c)); #endif delete c; } if (!list.empty()) { ServerInstance->Logs.Debug("CULL", "BUG: {} objects were added to the cull list from a destructor", list.size()); Apply(); } } void ActionList::Run() { // IMPORTANT: we can't use a range-based for loop here as adding to the list // may invalidate the list iterators. for (size_t idx = 0; idx < list.size(); ++idx) list[idx]->Call(); list.clear(); } ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/src/dynamic.cpp����������������������������������������������������������������������0000664�0000000�0000000�00000006013�14771603147�0016266�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2020 Matt Schatz <genius3000@g3k.solutions> * Copyright (C) 2017-2020, 2022-2023 Sadie Powell <sadie@witchery.services> * Copyright (C) 2012 Robby <robby@chatbelgie.be> * Copyright (C) 2012 ChrisTX <xpipe@hotmail.de> * Copyright (C) 2009-2010 Daniel De Graaf <danieldg@inspircd.org> * Copyright (C) 2009 Uli Schlachter <psychon@znc.in> * Copyright (C) 2007 Robin Burchell <robin+git@viroteck.net> * Copyright (C) 2003, 2006 Craig Edwards <brain@inspircd.org> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #ifndef _WIN32 # include <dlfcn.h> #endif #include "inspircd.h" #include "dynamic.h" DLLManager::DLLManager(const std::string& name) : libname(name) { const static size_t extlen = strlen(DLL_EXTENSION); if (name.length() <= extlen || name.compare(name.length() - extlen, name.length(), DLL_EXTENSION)) { err.assign(name + " is not a module (no " DLL_EXTENSION " extension)"); return; } #ifdef _WIN32 lib = LoadLibraryA(name.c_str()); #else lib = dlopen(name.c_str(), RTLD_NOW|RTLD_LOCAL); #endif if (!lib) RetrieveLastError(); } DLLManager::~DLLManager() { if (!lib) return; #ifdef _WIN32 FreeLibrary(lib); #else dlclose(lib); #endif } Module* DLLManager::CallInit() { if (!lib) return nullptr; const unsigned long* abi = GetSymbol<const unsigned long>(MODULE_STR_ABI); if (!abi) { err.assign(libname + " is not a module (no ABI symbol)"); return nullptr; } else if (*abi != MODULE_ABI) { const char* version = GetVersion(); err.assign(INSP_FORMAT("{} was built against {} ({}) which is too {} to use with {} ({}).", libname, version ? version : "an unknown version", *abi, *abi < MODULE_ABI ? "old" : "new", INSPIRCD_VERSION, MODULE_ABI)); return nullptr; } union { void* vptr; Module* (*fptr)(); }; vptr = GetSymbol(MODULE_STR_INIT); if (!vptr) { err.assign(libname + " is not a module (no init symbol)"); return nullptr; } return (*fptr)(); } void* DLLManager::GetSymbol(const char* name) const { if (!lib) return nullptr; #if defined _WIN32 return GetProcAddress(lib, name); #else return dlsym(lib, name); #endif } void DLLManager::RetrieveLastError() { #ifdef _WIN32 err = GetErrorMessage(GetLastError()); SetLastError(ERROR_SUCCESS); #else const char* errmsg = dlerror(); err = errmsg ? errmsg : "Unknown error"; #endif for (size_t pos = 0; ((pos = err.find_first_of("\r\n", pos)) != std::string::npos); ) err[pos] = ' '; } ���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/src/extensible.cpp�������������������������������������������������������������������0000664�0000000�0000000�00000017117�14771603147�0017013�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2019-2024 Sadie Powell <sadie@witchery.services> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include "inspircd.h" #include "extension.h" bool ExtensionManager::Register(ExtensionItem* item) { return types.emplace(item->name, item).second; } void ExtensionManager::BeginUnregister(Module* module, std::vector<ExtensionItem*>& items) { for (ExtMap::iterator type = types.begin(); type != types.end(); ) { ExtMap::iterator thistype = type++; ExtensionItem* item = thistype->second; if (item->creator == module) { items.push_back(item); types.erase(thistype); } } } ExtensionItem* ExtensionManager::GetItem(const std::string& name) { ExtMap::iterator iter = types.find(name); if (iter == types.end()) return nullptr; return iter->second; } Extensible::Extensible(ExtensionType exttype) : extype(exttype) , culled(false) { } Extensible::~Extensible() { if ((!extensions.empty() || !culled) && ServerInstance) { ServerInstance->Logs.Debug("CULL", "Extensible was deleted without being culled: @{}", fmt::ptr(this)); } } Cullable::Result Extensible::Cull() { FreeAllExtItems(); culled = true; return Cullable::Cull(); } void Extensible::FreeAllExtItems() { for (const auto& [extension, item] : extensions) extension->Delete(this, item); extensions.clear(); } void Extensible::UnhookExtensions(const std::vector<ExtensionItem*>& items) { for (auto* item : items) { ExtensibleStore::iterator iter = extensions.find(item); if (iter != extensions.end()) { item->Delete(this, iter->second); extensions.erase(iter); } } } ExtensionItem::ExtensionItem(Module* mod, const std::string& Key, ExtensionType exttype) : ServiceProvider(mod, Key, SERVICE_METADATA) , extype(exttype) { } void ExtensionItem::OnSync(const Extensible* container, void* item, Server* server) { } void ExtensionItem::RegisterService() { if (!ServerInstance->Extensions.Register(this)) throw ModuleException(creator, "Extension already exists: " + name); } void* ExtensionItem::GetRaw(const Extensible* container) const { auto iter = container->extensions.find(const_cast<ExtensionItem*>(this)); if (iter == container->extensions.end()) return nullptr; return iter->second; } void* ExtensionItem::SetRaw(Extensible* container, void* value) { auto result = container->extensions.emplace(this, value); if (result.second) return nullptr; void* old = result.first->second; result.first->second = value; return old; } void* ExtensionItem::UnsetRaw(Extensible* container) { auto iter = container->extensions.find(this); if (iter == container->extensions.end()) return nullptr; void* result = iter->second; container->extensions.erase(iter); return result; } void ExtensionItem::Sync(const Extensible* container, void* item) { const std::string networkstr = item ? ToNetwork(container, item) : ""; ServerInstance->PI->SendMetadata(container, name, networkstr); OnSync(container, item, nullptr); } void ExtensionItem::FromInternal(Extensible* container, const std::string& value) noexcept { } void ExtensionItem::FromNetwork(Extensible* container, const std::string& value) noexcept { } std::string ExtensionItem::ToHuman(const Extensible* container, void* item) const noexcept { // Try to use the network form by default. std::string ret = ToNetwork(container, item); // If there's no network form then fall back to the internal form. if (ret.empty()) ret = ToInternal(container, item); return ret; } std::string ExtensionItem::ToInternal(const Extensible* container, void* item) const noexcept { return {}; } std::string ExtensionItem::ToNetwork(const Extensible* container, void* item) const noexcept { return {}; } BoolExtItem::BoolExtItem(Module* owner, const std::string& key, ExtensionType exttype, bool sync) : ExtensionItem(owner, key, exttype) , synced(sync) { } void BoolExtItem::Delete(Extensible* container, void* item) { // Intentionally left blank. } void BoolExtItem::FromInternal(Extensible* container, const std::string& value) noexcept { if (ConvToNum<intptr_t>(value)) Set(container, false); else Unset(container, false); } std::string BoolExtItem::ToHuman(const Extensible* container, void* item) const noexcept { return item ? "set" : "unset"; } void BoolExtItem::FromNetwork(Extensible* container, const std::string& value) noexcept { if (synced) FromInternal(container, value); } std::string BoolExtItem::ToInternal(const Extensible* container, void* item) const noexcept { return ConvToStr(!!item); } std::string BoolExtItem::ToNetwork(const Extensible* container, void* item) const noexcept { return synced ? ToInternal(container, item) : std::string(); } bool BoolExtItem::Get(const Extensible* container) const { return GetRaw(container); } void BoolExtItem::Set(Extensible* container, bool sync) { if (container->extype != this->extype) return; SetRaw(container, reinterpret_cast<void*>(1)); if (sync && synced) Sync(container, reinterpret_cast<void*>(1)); } void BoolExtItem::Unset(Extensible* container, bool sync) { if (container->extype != this->extype) return; UnsetRaw(container); if (sync && synced) Sync(container, reinterpret_cast<void*>(0)); } IntExtItem::IntExtItem(Module* owner, const std::string& key, ExtensionType exttype, bool sync) : ExtensionItem(owner, key, exttype) , synced(sync) { } void IntExtItem::Delete(Extensible* container, void* item) { // Intentionally left blank. } void IntExtItem::FromInternal(Extensible* container, const std::string& value) noexcept { Set(container, ConvToNum<intptr_t>(value), false); } void IntExtItem::FromNetwork(Extensible* container, const std::string& value) noexcept { if (synced) FromInternal(container, value); } intptr_t IntExtItem::Get(const Extensible* container) const { return reinterpret_cast<intptr_t>(GetRaw(container)); } void IntExtItem::Set(Extensible* container, intptr_t value, bool sync) { if (container->extype != this->extype) return; if (value) SetRaw(container, reinterpret_cast<void*>(value)); else UnsetRaw(container); if (sync && synced) Sync(container, GetRaw(container)); } std::string IntExtItem::ToInternal(const Extensible* container, void* item) const noexcept { return ConvToStr(reinterpret_cast<intptr_t>(item)); } std::string IntExtItem::ToNetwork(const Extensible* container, void* item) const noexcept { return synced ? ToInternal(container, item) : std::string(); } void IntExtItem::Unset(Extensible* container, bool sync) { if (container->extype != this->extype) return; UnsetRaw(container); if (sync && synced) Sync(container, nullptr); } StringExtItem::StringExtItem(Module* owner, const std::string& key, ExtensionType exttype, bool sync) : SimpleExtItem(owner, key, exttype, sync) { } void StringExtItem::FromInternal(Extensible* container, const std::string& value) noexcept { if (value.empty()) Unset(container, false); else Set(container, value, false); } std::string StringExtItem::ToInternal(const Extensible* container, void* item) const noexcept { return item ? *static_cast<std::string*>(item) : std::string(); } �������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/src/hashcomp.cpp���������������������������������������������������������������������0000664�0000000�0000000�00000022644�14771603147�0016454�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2013, 2018-2023 Sadie Powell <sadie@witchery.services> * Copyright (C) 2013 Adam <Adam@anope.org> * Copyright (C) 2012-2013, 2015 Attila Molnar <attilamolnar@hush.com> * Copyright (C) 2012 Robby <robby@chatbelgie.be> * Copyright (C) 2009 Daniel De Graaf <danieldg@inspircd.org> * Copyright (C) 2008 Robin Burchell <robin+git@viroteck.net> * Copyright (C) 2007 Dennis Friis <peavey@inspircd.org> * Copyright (C) 2005-2007 Craig Edwards <brain@inspircd.org> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include "inspircd.h" /****************************************************** * * The hash functions of InspIRCd are the centrepoint * of the entire system. If these functions are * inefficient or wasteful, the whole program suffers * as a result. A lot of C programmers in the ircd * scene spend a lot of time debating (arguing) about * the best way to write hash functions to hash irc * nicknames, channels etc. * We are lucky as C++ developers as unordered_map does * a lot of this for us. It does intelligent memory * requests, bucketing, search functions, insertion * and deletion etc. All we have to do is write some * overloaded comparison and hash value operators which * cause it to act in an irc-like way. The features we * add to the standard hash_map are: * * Case insensitivity: The hash_map will be case * insensitive. * * Scandinavian Comparisons: The characters [, ], \ will * be considered the lowercase of {, } and |. * ******************************************************/ /** * A case insensitive mapping of characters from upper case to lower case for * the ASCII character set. */ const unsigned char ascii_case_insensitive_map[256] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, // 0-9 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, // 10-19 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, // 20-29 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, // 30-39 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, // 40-49 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, // 50-59 60, 61, 62, 63, 64, 97, 98, 99, 100, 101, // 60-69 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, // 70-79 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, // 80-89 122, 91, 92, 93, 94, 95, 96, 97, 98, 99, // 90-99 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, // 100-109 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, // 110-119 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, // 120-129 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, // 130-139 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, // 140-149 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, // 150-159 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, // 160-169 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, // 170-179 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, // 180-189 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, // 190-199 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, // 200-209 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, // 210-219 220, 221, 222, 223, 224, 225, 226, 227, 228, 229, // 220-229 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, // 230-249 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, // 240-249 250, 251, 252, 253, 254, 255, // 250-255 }; bool irc::equals(const std::string_view& s1, const std::string_view& s2) { if (s1.size() != s2.size()) return false; for (size_t idx = 0; idx < s1.length(); ++idx) { const unsigned char c1 = s1[idx]; const unsigned char c2 = s2[idx]; if (national_case_insensitive_map[c1] != national_case_insensitive_map[c2]) return false; } return true; } size_t irc::find(const std::string_view& haystack, const std::string_view& needle) { // The haystack can't contain the needle if it is smaller than it. if (needle.length() > haystack.length()) return std::string::npos; // The inner loop checks the characters between haystack_last and the end of the haystack. size_t haystack_last = haystack.length() - needle.length(); for (size_t hpos = 0; hpos <= haystack_last; ++hpos) { // Check for the needle at the current haystack position. bool found = true; for (size_t npos = 0; npos < needle.length(); ++npos) { unsigned char unpos = needle[npos]; unsigned char uhpos = haystack[hpos + npos]; if (national_case_insensitive_map[unpos] != national_case_insensitive_map[uhpos]) { // Uh-oh, characters at the current haystack position don't match. found = false; break; } } // The entire needle was found in the haystack! if (found) return hpos; } // We didn't find anything. return std::string::npos; } bool irc::insensitive_swo::operator()(const std::string& a, const std::string& b) const { std::string::size_type asize = a.size(); std::string::size_type bsize = b.size(); std::string::size_type maxsize = std::min(asize, bsize); for (std::string::size_type i = 0; i < maxsize; i++) { unsigned char A = national_case_insensitive_map[static_cast<unsigned char>(a[i])]; unsigned char B = national_case_insensitive_map[static_cast<unsigned char>(b[i])]; if (A > B) return false; else if (A < B) return true; } return (asize < bsize); } size_t irc::insensitive::operator()(const std::string& s) const { /* XXX: NO DATA COPIES! :) * The hash function here is practically * a copy of the one in STL's hash_fun.h, * only with *x replaced with national_case_insensitive_map[*x]. * This avoids a copy to use hash<const char*> */ size_t t = 0; for (const auto c : s) t = 5 * t + national_case_insensitive_map[static_cast<unsigned char>(c)]; return t; } irc::tokenstream::tokenstream(const std::string& msg, size_t start, size_t end) : message(msg, start, end) { } bool irc::tokenstream::GetMiddle(std::string& token) { // If we are past the end of the string we can't do anything. if (position >= message.length()) { token.clear(); return false; } // If we can't find another separator this is the last token in the message. size_t separator = message.find(' ', position); if (separator == std::string::npos) { token.assign(message, position, std::string::npos); position = message.length(); return true; } token.assign(message, position, separator - position); position = message.find_first_not_of(' ', separator); return true; } bool irc::tokenstream::GetTrailing(std::string& token) { // If we are past the end of the string we can't do anything. if (position >= message.length()) { token.clear(); return false; } // If this is true then we have a <trailing> token! if (message[position] == ':') { token.assign(message, position + 1, std::string::npos); position = message.length(); return true; } // There is no <trailing> token so it must be a <middle> token. return GetMiddle(token); } irc::sepstream::sepstream(const std::string& source, char separator, bool allowempty) : tokens(source) , sep(separator) , allow_empty(allowempty) { } bool irc::sepstream::GetToken(std::string& token) { if (this->StreamEnd()) { token.clear(); return false; } if (!this->allow_empty) { this->pos = this->tokens.find_first_not_of(this->sep, this->pos); if (this->pos == std::string::npos) { this->pos = this->tokens.length() + 1; token.clear(); return false; } } size_t p = this->tokens.find(this->sep, this->pos); if (p == std::string::npos) p = this->tokens.length(); token.assign(tokens, this->pos, p - this->pos); this->pos = p + 1; return true; } std::string irc::sepstream::GetRemaining() { return !this->StreamEnd() ? this->tokens.substr(this->pos) : ""; } bool irc::sepstream::StreamEnd() { return this->pos > this->tokens.length(); } irc::portparser::portparser(const std::string& source, bool allow_overlapped) : sep(source) , overlapped(allow_overlapped) { } bool irc::portparser::Overlaps(long val) { if (overlapped) return false; return (!overlap_set.insert(val).second); } long irc::portparser::GetToken() { if (in_range > 0) { in_range++; if (in_range <= range_end) { if (!Overlaps(in_range)) { return in_range; } else { while (((Overlaps(in_range)) && (in_range <= range_end))) in_range++; if (in_range <= range_end) return in_range; } } else in_range = 0; } std::string x; sep.GetToken(x); if (x.empty()) return 0; while (Overlaps(ConvToNum<long>(x))) { if (!sep.GetToken(x)) return 0; } std::string::size_type dash = x.rfind('-'); if (dash != std::string::npos) { std::string sbegin(x, 0, dash); range_begin = ConvToNum<long>(sbegin); range_end = ConvToNum<long>(x.c_str() + dash + 1); if ((range_begin > 0) && (range_end > 0) && (range_begin < 65536) && (range_end < 65536) && (range_begin < range_end)) { in_range = range_begin; return in_range; } else { /* Assume its just the one port */ return ConvToNum<long>(sbegin); } } else { return ConvToNum<long>(x); } } ��������������������������������������������������������������������������������������������inspircd-4.7.0/src/helperfuncs.cpp������������������������������������������������������������������0000664�0000000�0000000�00000043343�14771603147�0017167�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2019 Matt Schatz <genius3000@g3k.solutions> * Copyright (C) 2018 linuxdaemon <linuxdaemon.irc@gmail.com> * Copyright (C) 2012-2013 Attila Molnar <attilamolnar@hush.com> * Copyright (C) 2012, 2014, 2017-2018, 2020-2025 Sadie Powell <sadie@witchery.services> * Copyright (C) 2012 Robby <robby@chatbelgie.be> * Copyright (C) 2012 ChrisTX <xpipe@hotmail.de> * Copyright (C) 2009-2010 Daniel De Graaf <danieldg@inspircd.org> * Copyright (C) 2007 Dennis Friis <peavey@inspircd.org> * Copyright (C) 2006-2008 Robin Burchell <robin+git@viroteck.net> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include <random> #ifndef _WIN32 # include <unistd.h> #endif #include "inspircd.h" #include "timeutils.h" #include "utility/string.h" #include "xline.h" bool InspIRCd::CheckPassword(const std::string& password, const std::string& passwordhash, const std::string& value) { ModResult res; FIRST_MOD_RESULT(OnCheckPassword, res, (password, passwordhash, value)); if (res == MOD_RES_ALLOW) return true; // Password explicitly valid. if (res == MOD_RES_DENY) return false; // Password explicitly invalid. // The hash algorithm wasn't recognised by any modules. If its plain // text then we can check it internally. if (passwordhash.empty() || insp::equalsci(passwordhash, "plaintext")) return TimingSafeCompare(password, value); // The password was invalid. return false; } bool InspIRCd::IsValidMask(const std::string& mask) { const char* dest = mask.c_str(); int exclamation = 0; int atsign = 0; for (const char* i = dest; *i; i++) { /* out of range character, bad mask */ if (*i < 32 || *i > 126) { return false; } switch (*i) { case '!': exclamation++; break; case '@': atsign++; break; } } /* valid masks only have 1 ! and @ */ if (exclamation != 1 || atsign != 1) return false; if (mask.length() > ServerInstance->Config->Limits.GetMaxMask()) return false; return true; } void InspIRCd::StripColor(std::string& line) { for (size_t idx = 0; idx < line.length(); ) { switch (line[idx]) { case '\x02': // Bold case '\x1D': // Italic case '\x11': // Monospace case '\x16': // Reverse case '\x1E': // Strikethrough case '\x1F': // Underline case '\x0F': // Reset line.erase(idx, 1); break; case '\x03': // Color { auto start = idx; while (++idx < line.length() && idx - start < 6) { const auto chr = line[idx]; if (chr != ',' && (chr < '0' || chr > '9')) break; } line.erase(start, idx - start); idx = start; break; } case '\x04': // Hex Color { auto start = idx; while (++idx < line.length() && idx - start < 14) { const auto chr = line[idx]; if (chr != ',' && (chr < '0' || chr > '9') && (chr < 'A' || chr > 'F') && (chr < 'a' || chr > 'f')) break; } line.erase(start, idx - start); idx = start; break; } default: // Non-formatting character. idx++; break; } } } void InspIRCd::ProcessColors(std::vector<std::string>& input) { for (auto& line : input) ProcessColors(line); } void InspIRCd::ProcessColors(std::string& line) { static const insp::flat_map<std::string::value_type, std::string> formats = { { '\\', "\\" }, // Escape { '{', "{" }, // Escape { '}', "}" }, // Escape { 'b', "\x02" }, // Bold { 'c', "\x03" }, // Color { 'h', "\x04" }, // Hex Color { 'i', "\x1D" }, // Italic { 'm', "\x11" }, // Monospace { 'r', "\x16" }, // Reverse { 's', "\x1E" }, // Strikethrough { 'u', "\x1F" }, // Underline { 'x', "\x0F" }, // Reset }; static const insp::flat_map<std::string, uint8_t, irc::insensitive_swo> colors = { { "white", 0 }, { "black", 1 }, { "blue", 2 }, { "green", 3 }, { "red", 4 }, { "brown", 5 }, { "magenta", 6 }, { "orange", 7 }, { "yellow", 8 }, { "light green", 9 }, { "cyan", 10 }, { "light cyan", 11 }, { "light blue", 12 }, { "pink", 13 }, { "gray", 14 }, { "grey", 14 }, { "light gray", 15 }, { "light grey", 15 }, { "default", 99 }, }; for (size_t idx = 0; idx < line.length(); ) { if (line[idx] != '\\') { // Regular character. idx++; continue; } auto start = idx; if (++idx >= line.length()) continue; // Stray \ at the end of the string; skip. const auto chr = line[idx]; const auto it = formats.find(chr); if (it == formats.end()) continue; // Unknown escape, skip. line.replace(start, 2, it->second); idx = start + it->second.length(); if (chr != 'c') continue; // Only colors can have values. start = idx; if (idx >= line.length() || line[idx] != '{') continue; // No color value. const auto fgend = line.find_first_of(",}", idx + 1); if (fgend == std::string::npos) { // Malformed color value, strip. line.erase(start); break; } size_t bgend = std::string::npos; if (line[fgend] == ',') { bgend = line.find_first_of('}', fgend + 1); if (bgend == std::string::npos) { // Malformed color value, strip. line.erase(start); break; } } const auto fg = colors.find(line.substr(start + 1, fgend - start - 1)); auto tmp = ConvToStr(fg == colors.end() ? 99 : fg->second); if (bgend != std::string::npos) { const auto bg = colors.find(line.substr(fgend + 1, bgend - fgend - 1)); tmp.push_back(','); tmp.append(ConvToStr(bg == colors.end() ? 99 : bg->second)); } const auto end = bgend == std::string::npos ? fgend : bgend; line.replace(start, end - start + 1, tmp); } } /* true for valid nickname, false else */ bool InspIRCd::DefaultIsNick(const std::string_view& n) { if (n.empty() || n.length() > ServerInstance->Config->Limits.MaxNick) return false; for (std::string_view::const_iterator i = n.begin(); i != n.end(); ++i) { if ((*i >= 'A') && (*i <= '}')) { /* "A"-"}" can occur anywhere in a nickname */ continue; } if ((((*i >= '0') && (*i <= '9')) || (*i == '-')) && (i != n.begin())) { /* "0"-"9", "-" can occur anywhere BUT the first char of a nickname */ continue; } /* invalid character! abort */ return false; } return true; } /* return true for good username, false else */ bool InspIRCd::DefaultIsUser(const std::string_view& n) { if (n.empty()) return false; for (const auto chr : n) { if (chr >= 'A' && chr <= '}') continue; if ((chr >= '0' && chr <= '9') || chr == '-' || chr == '.') continue; return false; } return true; } bool InspIRCd::IsHost(const std::string_view& host, bool allowsimple) { // Hostnames must be non-empty and shorter than the maximum hostname length. if (host.empty() || host.length() > ServerInstance->Config->Limits.MaxHost) return false; unsigned int numdashes = 0; unsigned int numdots = 0; bool seendot = false; const auto hostend = host.end() - 1; for (auto iter = host.begin(); iter != host.end(); ++iter) { const auto chr = static_cast<unsigned char>(*iter); // If the current character is a label separator. if (chr == '.') { numdots++; // Consecutive separators are not allowed and dashes can not exist at the start or end // of labels and separators must only exist between labels. if (seendot || numdashes || iter == host.begin() || iter == hostend) return false; seendot = true; continue; } // If this point is reached then the character is not a dot. seendot = false; // If the current character is a dash. if (chr == '-') { // Consecutive separators are not allowed and dashes can not exist at the start or end // of labels and separators must only exist between labels. if (seendot || numdashes >= 2 || iter == host.begin() || iter == hostend) return false; numdashes += 1; continue; } // If this point is reached then the character is not a dash. numdashes = 0; // Alphanumeric characters are allowed at any position. if ((chr >= '0' && chr <= '9') || (chr >= 'A' && chr <= 'Z') || (chr >= 'a' && chr <= 'z')) continue; return false; } // Whilst simple hostnames (e.g. localhost) are valid we do not allow the server to use // them to prevent issues with clients that differentiate between short client and server // prefixes by checking whether the nickname contains a dot. return numdots || allowsimple; } bool InspIRCd::IsSID(const std::string_view& str) { /* Returns true if the string given is exactly 3 characters long, * starts with a digit, and the other two characters are A-Z or digits */ return ((str.length() == 3) && isdigit(str[0]) && ((str[1] >= 'A' && str[1] <= 'Z') || isdigit(str[1])) && ((str[2] >= 'A' && str[2] <= 'Z') || isdigit(str[2]))); } namespace { constexpr const auto SECONDS_PER_MINUTE = 60; constexpr const auto SECONDS_PER_HOUR = SECONDS_PER_MINUTE * 60; constexpr const auto SECONDS_PER_DAY = SECONDS_PER_HOUR * 24; constexpr const auto SECONDS_PER_WEEK = SECONDS_PER_DAY * 7; constexpr const auto SECONDS_PER_YEAR = (SECONDS_PER_DAY * 365); constexpr const auto SECONDS_PER_AVG_YEAR = SECONDS_PER_YEAR + (SECONDS_PER_HOUR * 6); } /** A lookup table of values for multiplier characters used by * Duration::{Try,}From(). In this lookup table, the indexes for * the ascii values 'm' and 'M' have the value '60', the indexes * for the ascii values 'D' and 'd' have a value of '86400', etc. */ static constexpr unsigned int duration_multi[] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, SECONDS_PER_DAY, 0, 0, 0, SECONDS_PER_HOUR, 0, 0, 0, 0, SECONDS_PER_MINUTE, 0, 0, 0, 0, 0, 1, 0, 0, 0, SECONDS_PER_WEEK, 0, SECONDS_PER_AVG_YEAR, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, SECONDS_PER_DAY, 0, 0, 0, SECONDS_PER_HOUR, 0, 0, 0, 0, SECONDS_PER_MINUTE, 0, 0, 0, 0, 0, 1, 0, 0, 0, SECONDS_PER_WEEK, 0, SECONDS_PER_AVG_YEAR, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, }; bool Duration::TryFrom(const std::string& str, unsigned long& duration) { unsigned long total = 0; unsigned long subtotal = 0; /* Iterate each item in the string, looking for number or multiplier */ for (const auto chr : str) { /* Found a number, queue it onto the current number */ if (chr >= '0' && chr <= '9') { subtotal = (subtotal * 10) + (chr - '0'); } else { /* Found something that's not a number, find out how much * it multiplies the built up number by, multiply the total * and reset the built up number. */ unsigned int multiplier = duration_multi[static_cast<unsigned char>(chr)]; if (multiplier == 0) return false; total += subtotal * multiplier; /* Next subtotal please */ subtotal = 0; } } /* Any trailing values built up are treated as raw seconds */ duration = total + subtotal; return true; } unsigned long Duration::From(const std::string& str) { unsigned long out = 0; Duration::TryFrom(str, out); return out; } bool Duration::IsValid(const std::string& duration) { for (const auto c : duration) { if (((c >= '0') && (c <= '9'))) continue; if (!duration_multi[static_cast<unsigned char>(c)]) return false; } return true; } std::string Duration::ToString(unsigned long duration) { if (duration == 0) return "0s"; std::string ret; const auto years = (duration / SECONDS_PER_YEAR); if (years) { ret = INSP_FORMAT("{}y", years); duration -= (years * SECONDS_PER_YEAR); } const auto weeks = (duration / SECONDS_PER_WEEK); if (weeks) { ret += INSP_FORMAT("{}w", weeks); duration -= (weeks * SECONDS_PER_WEEK); } const auto days = (duration / SECONDS_PER_DAY); if (days) { ret += INSP_FORMAT("{}d", days); duration -= (days * SECONDS_PER_DAY); } const auto hours = (duration / SECONDS_PER_HOUR); if (hours) { ret += INSP_FORMAT("{}h", hours); duration -= (hours * SECONDS_PER_HOUR); } const auto minutes = (duration / SECONDS_PER_MINUTE); if (minutes) { ret += INSP_FORMAT("{}m", minutes); duration -= (minutes * SECONDS_PER_MINUTE); } if (duration) ret += INSP_FORMAT("{}s", duration); return ret; } std::string Duration::ToLongString(unsigned long duration, bool brief) { if (duration == 0) return "0 seconds"; if (brief) { // This will get inlined when compiled with optimisations. auto nearest = [](unsigned long seconds, unsigned long roundto) { if ((seconds % roundto) <= (roundto / 2)) return seconds - (seconds % roundto); return seconds - (seconds % roundto) + roundto; }; // In order to get a shorter result we round to the nearest period. if (duration >= SECONDS_PER_YEAR) duration = nearest(duration, SECONDS_PER_DAY); // Nearest day if its more than a year else if (duration >= SECONDS_PER_DAY) duration = nearest(duration, SECONDS_PER_HOUR); // Nearest hour if its more than a day else if (duration >= SECONDS_PER_HOUR) duration = nearest(duration, SECONDS_PER_MINUTE); // Nearest minute if its more than an hour } std::string ret; const auto years = (duration / SECONDS_PER_YEAR); if (years) { ret = INSP_FORMAT("{} {}", years, years == 1 ? "year" : "years"); duration -= (years * SECONDS_PER_YEAR); } const auto weeks = (duration / SECONDS_PER_WEEK); if (weeks) { ret += ret.empty() ? "" : ", "; ret += INSP_FORMAT("{} {}", weeks, weeks == 1 ? "week" : "weeks"); duration -= (weeks * SECONDS_PER_WEEK); } const auto days = (duration / SECONDS_PER_DAY); if (days) { ret += ret.empty() ? "" : ", "; ret += INSP_FORMAT("{} {}", days, days == 1 ? "day" : "days"); duration -= (days * SECONDS_PER_DAY); } const auto hours = (duration / SECONDS_PER_HOUR); if (hours) { ret += ret.empty() ? "" : ", "; ret += INSP_FORMAT("{} {}", hours, hours == 1 ? "hour" : "hours"); duration -= (hours * SECONDS_PER_HOUR); } const auto minutes = (duration / SECONDS_PER_MINUTE); if (minutes) { ret += ret.empty() ? "" : ", "; ret += INSP_FORMAT("{} {}", minutes, minutes == 1 ? "minute" : "minutes"); duration -= (minutes * SECONDS_PER_MINUTE); } if (duration) { ret += ret.empty() ? "" : ", "; ret += INSP_FORMAT("{} {}", duration, duration == 1 ? "second" : "seconds"); } const auto first_comma = ret.find(','); const auto last_comma = ret.rfind(','); if (first_comma != std::string::npos) { if (first_comma == last_comma) { // BEFORE: 1 minute, 2 seconds // AFTER: 1 minute and 2 seconds ret.replace(last_comma, 1, " and"); } else { // BEFORE: 1 hour, 2 minutes, 3 seconds // AFTER: 1 hour, 2 minutes, and 3 seconds ret.insert(last_comma + 1, " and"); } } return ret; } std::string Time::ToString(time_t curtime, const char* format, bool utc) { #ifdef _WIN32 if (curtime < 0) curtime = 0; #endif struct tm* timeinfo = utc ? gmtime(&curtime) : localtime(&curtime); if (!timeinfo) { curtime = 0; timeinfo = localtime(&curtime); } // If the calculated year exceeds four digits or is less than the year 1000, // the behavior of asctime() is undefined if (timeinfo->tm_year + 1900 > 9999) timeinfo->tm_year = 9999 - 1900; else if (timeinfo->tm_year + 1900 < 1000) timeinfo->tm_year = 0; // This is the default format used by asctime without the terminating new line. if (!format) format = Time::DEFAULT_SHORT; char buffer[512]; if (!strftime(buffer, sizeof(buffer), format, timeinfo)) buffer[0] = '\0'; return buffer; } std::string InspIRCd::GenRandomStr(size_t length) const { static const char chars[] = { 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z', 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', }; std::string buf; buf.reserve(length); for (size_t idx = 0; idx < length; ++idx) buf.push_back(chars[GenRandomInt(std::size(chars))]); return buf; } std::string InspIRCd::GenRandomStr(size_t length, bool printable) const { if (printable) return GenRandomStr(length); // DEPRECATED std::vector<char> str(length); GenRandom(str.data(), length); return std::string(str.data(), str.size()); } // NOTE: this has a slight bias for lower values if max is not a power of 2. // Don't use it if that matters. unsigned long InspIRCd::GenRandomInt(unsigned long max) const { unsigned long rv; GenRandom(reinterpret_cast<char*>(&rv), sizeof(rv)); return rv % max; } // This is overridden by a higher-quality algorithm when TLS support is loaded void InspIRCd::DefaultGenRandom(char* output, size_t max) { #ifdef HAS_GETENTROPY if (getentropy(output, max) == 0) return; #endif #ifdef HAS_ARC4RANDOM_BUF arc4random_buf(output, max); #else static std::random_device device; static std::mt19937 engine(device()); static std::uniform_int_distribution<short> dist(CHAR_MIN, CHAR_MAX); for (size_t i = 0; i < max; ++i) output[i] = static_cast<char>(dist(engine)); #endif } ���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/src/inspircd.cpp���������������������������������������������������������������������0000664�0000000�0000000�00000050142�14771603147�0016457�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2018 Chris Novakovic * Copyright (C) 2013, 2017-2025 Sadie Powell <sadie@witchery.services> * Copyright (C) 2013 Adam <Adam@anope.org> * Copyright (C) 2012-2014, 2018 Attila Molnar <attilamolnar@hush.com> * Copyright (C) 2012-2013 ChrisTX <xpipe@hotmail.de> * Copyright (C) 2012 Robby <robby@chatbelgie.be> * Copyright (C) 2012 Ariadne Conill <ariadne@dereferenced.org> * Copyright (C) 2009-2010 Daniel De Graaf <danieldg@inspircd.org> * Copyright (C) 2008 Uli Schlachter <psychon@znc.in> * Copyright (C) 2007-2008 Robin Burchell <robin+git@viroteck.net> * Copyright (C) 2007, 2009 Dennis Friis <peavey@inspircd.org> * Copyright (C) 2006 Oliver Lupton <om@inspircd.org> * Copyright (C) 2005-2009 Craig Edwards <brain@inspircd.org> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include <filesystem> #include <fstream> #include <iostream> #include <fmt/color.h> #include <lyra/lyra.hpp> #include "inspircd.h" #include "timeutils.h" #include "xline.h" #ifndef _WIN32 # include <fcntl.h> # include <grp.h> # include <pwd.h> # include <sys/resource.h> # include <unistd.h> #else # define STDIN_FILENO 0 # define STDOUT_FILENO 1 # define STDERR_FILENO 2 # include <process.h> #endif InspIRCd* ServerInstance = nullptr; /** Separate from the other casemap tables so that code *can* still exclusively rely on RFC casemapping * if it must. * * This is provided as a pointer so that modules can change it to their custom mapping tables, * e.g. for national character support. */ const unsigned char* national_case_insensitive_map = ascii_case_insensitive_map; namespace { [[noreturn]] void VoidSignalHandler(int); // Warns a user running as root that they probably shouldn't. void CheckRoot() { #ifndef _WIN32 if (getegid() != 0 && geteuid() != 0) return; fmt::println("{} You have started as root. Running as root is generally not required", fmt::styled("Warning!", fmt::emphasis::bold | fmt::fg(fmt::terminal_color::red))); fmt::println("and may allow an attacker to gain access to your system if they find a way to"); fmt::println("exploit your IRC server."); fmt::println(""); if (isatty(fileno(stdout))) { fmt::println("InspIRCd will start in 30 seconds. If you are sure that you need to run as root"); fmt::println("then you can pass the {} option to disable this wait.", fmt::styled("--runasroot", fmt::emphasis::bold)); sleep(30); } else { fmt::println("If you are sure that you need to run as root then you can pass the {}", fmt::styled("--runasroot", fmt::emphasis::bold)); fmt::println("option to disable this error."); ServerInstance->Exit(EXIT_FAILURE); } #endif } // Collects performance statistics for the STATS command. void CollectStats() { #ifndef _WIN32 static rusage ru; if (getrusage(RUSAGE_SELF, &ru) == -1) return; // Should never happen. ServerInstance->Stats.LastSampled.tv_sec = ServerInstance->Time(); ServerInstance->Stats.LastSampled.tv_nsec = ServerInstance->Time_ns(); ServerInstance->Stats.LastCPU = ru.ru_utime; #else if (!QueryPerformanceCounter(&ServerInstance->Stats.LastCPU)) return; // Should never happen. FILETIME CreationTime; FILETIME ExitTime; FILETIME KernelTime; FILETIME UserTime; GetProcessTimes(GetCurrentProcess(), &CreationTime, &ExitTime, &KernelTime, &UserTime); ServerInstance->Stats.LastSampled.dwHighDateTime = KernelTime.dwHighDateTime + UserTime.dwHighDateTime; ServerInstance->Stats.LastSampled.dwLowDateTime = KernelTime.dwLowDateTime + UserTime.dwLowDateTime; #endif } // Checks whether the server clock has skipped too much and warn about it if it has. void CheckTimeSkip(time_t oldtime, time_t newtime) { if (!ServerInstance->Config->TimeSkipWarn) return; time_t timediff = newtime - oldtime; if (timediff > ServerInstance->Config->TimeSkipWarn) { ServerInstance->SNO.WriteToSnoMask('a', "\002Performance warning!\002 Server clock jumped forwards by {} (from {} to {})!", Duration::ToLongString(timediff), Time::ToString(oldtime), Time::ToString(newtime)); } else if (timediff < -ServerInstance->Config->TimeSkipWarn) { ServerInstance->SNO.WriteToSnoMask('a', "\002Performance warning!\002 Server clock jumped backwards by {} (from {} to {})!", Duration::ToLongString(std::abs(timediff)), Time::ToString(oldtime), Time::ToString(newtime)); } } // Drops to the unprivileged user/group specified in <security:runas{user,group}>. void DropRoot() { #ifndef _WIN32 const auto& security = ServerInstance->Config->ConfValue("security"); const std::string SetGroup = security->getString("runasgroup"); if (!SetGroup.empty()) { errno = 0; if (setgroups(0, nullptr) == -1) { ServerInstance->Logs.Critical("STARTUP", "setgroups() failed (wtf?): {}", strerror(errno)); exit(EXIT_FAILURE); } struct group* g = getgrnam(SetGroup.c_str()); if (!g) { ServerInstance->Logs.Critical("STARTUP", "getgrnam({}) failed (wrong group?): {}", SetGroup, strerror(errno)); exit(EXIT_FAILURE); } if (setgid(g->gr_gid) == -1) { ServerInstance->Logs.Critical("STARTUP", "setgid({}) failed (wrong group?): {}", g->gr_gid, strerror(errno)); exit(EXIT_FAILURE); } } const std::string SetUser = security->getString("runasuser"); if (!SetUser.empty()) { errno = 0; struct passwd* u = getpwnam(SetUser.c_str()); if (!u) { ServerInstance->Logs.Critical("STARTUP", "getpwnam({}) failed (wrong user?): {}", SetUser, strerror(errno)); exit(EXIT_FAILURE); } if (setuid(u->pw_uid) == -1) { ServerInstance->Logs.Critical("STARTUP", "setuid({}) failed (wrong user?): {}", u->pw_uid, strerror(errno)); exit(EXIT_FAILURE); } } #endif } // Expands a path relative to the current working directory. std::string ExpandPath(const char* path) { #ifdef _WIN32 TCHAR configPath[MAX_PATH + 1]; if (GetFullPathName(path, MAX_PATH, configPath, nullptr) > 0) return configPath; #else char configPath[PATH_MAX + 1]; if (realpath(path, configPath)) return configPath; #endif return path; } // Attempts to fork into the background. void ForkIntoBackground() { #ifndef _WIN32 // We use VoidSignalHandler whilst forking to avoid breaking daemon scripts // if the parent process exits with SIGTERM (15) instead of EXIT_SUCCESS (0). signal(SIGTERM, VoidSignalHandler); errno = 0; int childpid = fork(); if (childpid < 0) { ServerInstance->Logs.Critical("STARTUP", "fork() failed: {}", strerror(errno)); fmt::println("{} unable to fork into background: {}", fmt::styled("Error:", fmt::emphasis::bold | fmt::fg(fmt::terminal_color::red)), strerror(errno)); ServerInstance->Exit(EXIT_FAILURE); } else if (childpid > 0) { // Wait until the child process kills the parent so that the shell prompt // doesnt display over the output. Sending a kill with a signal of 0 just // checks that the child pid is still running. If it is not then an error // happened and the parent should exit. while (kill(childpid, 0) != -1) sleep(1); exit(EXIT_FAILURE); } else { setsid(); signal(SIGTERM, InspIRCd::SetSignal); SocketEngine::RecoverFromFork(); } #endif } // Increase the size of a core dump file to improve debugging problems. void IncreaseCoreDumpSize() { #ifndef _WIN32 errno = 0; rlimit rl; if (getrlimit(RLIMIT_CORE, &rl) == -1) { ServerInstance->Logs.Warning("STARTUP", "Unable to increase core dump size: getrlimit(RLIMIT_CORE) failed: {}", strerror(errno)); return; } rl.rlim_cur = rl.rlim_max; if (setrlimit(RLIMIT_CORE, &rl) == -1) ServerInstance->Logs.Warning("STARTUP", "Unable to increase core dump size: setrlimit(RLIMIT_CORE) failed: {}", strerror(errno)); #endif } // Parses the command line options. void ParseOptions() { std::string config = ServerInstance->Config->Paths.PrependConfig("inspircd.conf"); bool do_debug = false; bool do_help = false; bool do_nofork = false; bool do_nolog = false; bool do_nopid = false; bool do_protocoldebug = false; bool do_runasroot = false; bool do_version = false; auto cli = lyra::cli() | lyra::opt(config, "FILE") ["-c"]["--config"] ("The location of the main config file.") | lyra::opt(do_debug) ["-d"]["--debug"] ("Start in debug mode.") | lyra::opt(do_nofork) ["-F"]["--nofork"] ("Disable forking into the background.") | lyra::opt(do_help) ["-h"]["--help"] ("Show help and exit.") | lyra::opt(do_nolog) ["-L"]["--nolog"] ("Disable writing logs to disk.") | lyra::opt(do_protocoldebug) ["-p"]["--protocoldebug"] ("Start in protocol debug mode.") | lyra::opt(do_nopid) ["-P"]["--nopid"] ("Disable writing the pid file.") | lyra::opt(do_runasroot) ["-r"]["--runasroot"] ("Allow starting as root (not recommended).") | lyra::opt(do_version) ["-v"]["--version"] ("Show version and exit."); auto result = cli.parse({ServerInstance->Config->CommandLine.argc, ServerInstance->Config->CommandLine.argv}); if (!result) { fmt::println(stderr, "{} {}", fmt::styled("Error:", fmt::emphasis::bold | fmt::fg(fmt::terminal_color::red)), result.message()); ServerInstance->Exit(EXIT_FAILURE); } if (do_help) { std::cout << cli << std::endl; ServerInstance->Exit(EXIT_SUCCESS); } if (do_version) { fmt::println(INSPIRCD_VERSION); ServerInstance->Exit(EXIT_SUCCESS); } // Store the relevant parsed arguments if (!config.empty()) ServerInstance->ConfigFileName = ExpandPath(config.c_str()); ServerInstance->Config->CommandLine.forcedebug = do_debug || do_protocoldebug; ServerInstance->Config->CommandLine.forceprotodebug = do_protocoldebug; ServerInstance->Config->CommandLine.nofork = ServerInstance->Config->CommandLine.forcedebug || do_nofork; ServerInstance->Config->CommandLine.runasroot = do_runasroot; ServerInstance->Config->CommandLine.writelog = !do_nolog; ServerInstance->Config->CommandLine.writepid = !do_nopid; } // Sets handlers for various process signals. void SetSignals() { #ifndef _WIN32 signal(SIGALRM, SIG_IGN); signal(SIGCHLD, SIG_IGN); signal(SIGHUP, InspIRCd::SetSignal); signal(SIGPIPE, SIG_IGN); signal(SIGUSR1, SIG_IGN); signal(SIGUSR2, SIG_IGN); signal(SIGXFSZ, SIG_IGN); #endif signal(SIGTERM, InspIRCd::SetSignal); } void TryBindPorts() { FailedPortList pl; ServerInstance->BindPorts(pl); if (!pl.empty()) { fmt::println("{} Some of your listeners failed to bind:", fmt::styled("Warning!", fmt::emphasis::bold | fmt::fg(fmt::terminal_color::red))); fmt::println(""); for (const auto& fp : pl) { fmt::print(" "); if (fp.sa.family() != AF_UNSPEC) fmt::print("{}: ", fmt::styled(fp.sa.str(), fmt::emphasis::bold)); fmt::println("{}.", fp.error); fmt::println("Created from <bind> tag at {}", fp.tag->source.str()); fmt::println(""); } fmt::println("{}", fmt::styled("Hints:", fmt::emphasis::bold)); fmt::println("- For TCP/IP listeners try using a public IP address in <bind:address> instead"); fmt::println(" of * or leaving it blank."); fmt::println("- For UNIX socket listeners try enabling <bind:replace> to replace old sockets."); } } // Required for returning the proper value of EXIT_SUCCESS for the parent process. void VoidSignalHandler(int) { exit(EXIT_SUCCESS); } } void InspIRCd::Cleanup() { // Close all listening sockets for (auto* port : ports) { port->Cull(); delete port; } ports.clear(); // Tell modules that we're shutting down. const std::string quitmsg = "Server shutting down"; FOREACH_MOD(OnShutdown, (quitmsg)); // Disconnect all local users const UserManager::LocalList& list = Users.GetLocalUsers(); while (!list.empty()) ServerInstance->Users.QuitUser(list.front(), quitmsg); GlobalCulls.Apply(); Modules.UnloadAll(); /* Delete objects dynamically allocated in constructor (destructor would be more appropriate, but we're likely exiting) */ /* Must be deleted before modes as it decrements modelines */ if (FakeClient) { delete FakeClient->server; FakeClient->Cull(); } stdalgo::delete_zero(this->FakeClient); stdalgo::delete_zero(this->XLines); stdalgo::delete_zero(this->Config); SocketEngine::Deinit(); Logs.CloseLogs(); } void InspIRCd::WritePID() { if (!ServerInstance->Config->CommandLine.writepid) { this->Logs.Normal("STARTUP", "--nopid specified on command line; PID file not written."); return; } const std::string pidfile = ServerInstance->Config->ConfValue("pid")->getString("file", "inspircd.pid", 1); std::ofstream outfile(ServerInstance->Config->Paths.PrependRuntime(pidfile)); if (outfile.is_open()) { outfile << getpid(); outfile.close(); } else { fmt::println("Failed to write PID-file '{}', exiting.", pidfile); this->Logs.Critical("STARTUP", "Failed to write PID-file '{}', exiting.", pidfile); Exit(EXIT_FAILURE); } } InspIRCd::InspIRCd(int argc, char** argv) { ServerInstance = this; UpdateTime(); this->startup_time = Time(); IncreaseCoreDumpSize(); SocketEngine::Init(); this->Config = new ServerConfig; dynamic_reference_base::reset_all(); this->XLines = new XLineManager; this->Config->CommandLine.argv = argv; this->Config->CommandLine.argc = argc; ParseOptions(); { ServiceProvider* provs[] = { &rfcevents.numeric, &rfcevents.join, &rfcevents.part, &rfcevents.kick, &rfcevents.quit, &rfcevents.nick, &rfcevents.mode, &rfcevents.topic, &rfcevents.privmsg, &rfcevents.invite, &rfcevents.ping, &rfcevents.pong, &rfcevents.error }; Modules.AddServices(provs, sizeof(provs)/sizeof(provs[0])); } fmt::println("{}", fmt::styled("InspIRCd - Internet Relay Chat Daemon", fmt::emphasis::bold | fmt::fg(fmt::terminal_color::green))); fmt::println("See {} for contributors & authors", fmt::styled("/INFO", fmt::emphasis::bold | fmt::fg(fmt::terminal_color::green))); fmt::println(""); Logs.RegisterServices(); if (Config->CommandLine.forcedebug) Logs.EnableDebugMode(); std::error_code ec; if (!std::filesystem::is_regular_file(ConfigFileName, ec)) { this->Logs.Critical("STARTUP", "Unable to open config file {}", ConfigFileName); fmt::println("ERROR: Cannot open config file: {}", ConfigFileName); fmt::println("Exiting..."); Exit(EXIT_FAILURE); } SetSignals(); if (!Config->CommandLine.runasroot) CheckRoot(); if (!Config->CommandLine.nofork) ForkIntoBackground(); fmt::println("InspIRCd Process ID: {}", fmt::styled(getpid(), fmt::emphasis::bold | fmt::fg(fmt::terminal_color::green))); /* During startup we read the configuration now, not in * a separate thread */ this->Config->Read(); this->Config->Apply(nullptr, ""); try { Logs.CloseLogs(); Logs.OpenLogs(false); } catch (const CoreException& ex) { fmt::println("ERROR: Cannot open log files: {}", ex.GetReason()); fmt::println("Exiting..."); Exit(EXIT_FAILURE); } // We only do this on boot because we might not be able to after dropping root. WritePID(); // If we don't have a SID, generate one based on the server name and the server description if (Config->ServerId.empty()) Config->ServerId = UIDGenerator::GenerateSID(Config->ServerName, Config->ServerDesc); // Initialize the UID generator with our sid this->UIDGen.init(Config->ServerId); // Create the server user for this server this->FakeClient = new FakeUser(Config->ServerId, Config->ServerName, Config->ServerDesc); // This is needed as all new XLines are marked pending until ApplyLines() is called this->XLines->ApplyLines(); fmt::println(""); TryBindPorts(); this->Modules.LoadAll(); try { // We reopen logs again after modules to allow module loggers to have a chance to register. Logs.CloseLogs(); Logs.OpenLogs(true); } catch (const CoreException& ex) { fmt::println("ERROR: Cannot open log files: {}", ex.GetReason()); fmt::println("Exiting..."); Exit(EXIT_FAILURE); } fmt::println("InspIRCd is now running as '{}'[{}] with {} max open sockets", Config->ServerName, Config->ServerId, SocketEngine::GetMaxFds()); #ifndef _WIN32 if (!Config->CommandLine.nofork) { if (kill(getppid(), SIGTERM) == -1) { fmt::println("Error killing parent process: {}", strerror(errno)); Logs.Warning("STARTUP", "Error killing parent process: {}", strerror(errno)); } } /* Explicitly shut down stdio's stdin/stdout/stderr. * * The previous logic here was to only do this if stdio was connected to a controlling * terminal. However, we must do this always to avoid information leaks and other * problems related to stdio. * * The only exception is if we are in debug mode. * * -- nenolod */ if (!Config->CommandLine.nofork) { int fd = open("/dev/null", O_RDWR); fclose(stdin); fclose(stderr); fclose(stdout); if (dup2(fd, STDIN_FILENO) < 0) Logs.Warning("STARTUP", "Failed to dup /dev/null to stdin."); if (dup2(fd, STDOUT_FILENO) < 0) Logs.Warning("STARTUP", "Failed to dup /dev/null to stdout."); if (dup2(fd, STDERR_FILENO) < 0) Logs.Warning("STARTUP", "Failed to dup /dev/null to stderr."); close(fd); } else { fflush(stderr); fflush(stdout); Logs.Normal("STARTUP", "Keeping pseudo-tty open as we are running in the foreground."); } #else /* Set win32 service as running, if we are running as a service */ SetServiceRunning(); // Handle forking if(!Config->CommandLine.nofork) { FreeConsole(); } QueryPerformanceFrequency(&this->Stats.BootCPU); #endif DropRoot(); Logs.Normal("STARTUP", "Startup complete as '{}'[{}], {} max open sockets", Config->ServerName, Config->ServerId, SocketEngine::GetMaxFds()); } void InspIRCd::UpdateTime() { #if defined HAS_CLOCK_GETTIME clock_gettime(CLOCK_REALTIME, &ts); #elif defined _WIN32 SYSTEMTIME st; GetSystemTime(&st); ts.tv_sec = time(nullptr); ts.tv_nsec = st.wMilliseconds; #else struct timeval tv; gettimeofday(&tv, nullptr); ts.tv_sec = tv.tv_sec; ts.tv_nsec = tv.tv_usec * 1000; #endif } void InspIRCd::Run() { UpdateTime(); auto oldtime = Time(); while (true) { /* Check if there is a config thread which has finished executing but has not yet been freed */ if (this->ConfigThread && this->ConfigThread->IsDone()) { /* Rehash has completed */ this->Logs.Normal("CONFIG", "New configuration has been read, applying..."); ConfigThread->Stop(); stdalgo::delete_zero(ConfigThread); } UpdateTime(); // Normally we want to limit the mainloop to processing data // once a second but this can cause problems with testing // software like irctest. Don't define this unless you know // what you are doing. #ifndef INSPIRCD_UNLIMITED_MAINLOOP if (Time() != oldtime) #endif { CollectStats(); CheckTimeSkip(oldtime, Time()); oldtime = Time(); if ((Time() % 3600) == 0) FOREACH_MOD(OnGarbageCollect, ()); Timers.TickTimers(); Users.DoBackgroundUserStuff(); if ((Time() % 5) == 0) { FOREACH_MOD(OnBackgroundTimer, (Time())); SNO.FlushSnotices(); } } /* Call the socket engine to wait on the active * file descriptors. The socket engine has everything's * descriptors in its list... dns, modules, users, * servers... so its nice and easy, just one call. * This will cause any read or write events to be * dispatched to their handlers. */ SocketEngine::DispatchTrialWrites(); SocketEngine::DispatchEvents(); /* if any users were quit, take them out */ GlobalCulls.Apply(); AtomicActions.Run(); if (lastsignal) { HandleSignal(lastsignal); lastsignal = 0; } } } sig_atomic_t InspIRCd::lastsignal = 0; void InspIRCd::SetSignal(int signal) { lastsignal = signal; } #ifdef _WIN32 int smain(int argc, char** argv) #else int main(int argc, char** argv) #endif { new InspIRCd(argc, argv); ServerInstance->Run(); delete ServerInstance; return 0; } ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/src/listensocket.cpp�����������������������������������������������������������������0000664�0000000�0000000�00000021456�14771603147�0017361�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2021 Dominic Hamon * Copyright (C) 2019 Matt Schatz <genius3000@g3k.solutions> * Copyright (C) 2013-2016 Attila Molnar <attilamolnar@hush.com> * Copyright (C) 2013, 2016-2024 Sadie Powell <sadie@witchery.services> * Copyright (C) 2013 Daniel Vassdal <shutter@canternet.org> * Copyright (C) 2012 Robby <robby@chatbelgie.be> * Copyright (C) 2012 ChrisTX <xpipe@hotmail.de> * Copyright (C) 2009-2010 Daniel De Graaf <danieldg@inspircd.org> * Copyright (C) 2008 Robin Burchell <robin+git@viroteck.net> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include "inspircd.h" #include "iohook.h" #ifndef _WIN32 # include <netinet/tcp.h> # include <sys/stat.h> # include <unistd.h> #endif namespace { // Removes a dead UNIX socket so we can bind over it. bool RemoveSocket(ListenSocket* ls) { const bool replace = ls->bind_tag->getBool("replace", true); if (!replace || !irc::sockets::isunix(ls->bind_sa.str())) return true; return unlink(ls->bind_sa.str().c_str()) != -1; } int SetDeferAccept(ListenSocket* ls) { // Default defer to on for TLS listeners because in TLS the client always speaks first. unsigned int timeoutdef = ls->bind_tag->getString("sslprofile").empty() ? 0 : 5; int timeout = static_cast<int>(ls->bind_tag->getDuration("defer", timeoutdef, 0, 60)); if (!timeout) return 0; #if defined TCP_DEFER_ACCEPT return SocketEngine::SetOption(ls, IPPROTO_TCP, TCP_DEFER_ACCEPT, timeout); #elif defined SO_ACCEPTFILTER struct accept_filter_arg afa; memset(&afa, 0, sizeof(afa)); strcpy(afa.af_name, "dataready"); return SocketEngine::SetOption(ls, SOL_SOCKET, SO_ACCEPTFILTER, afa); #else return 0; #endif } // Allows binding to an IP address which is not available yet. int SetFreeBind(ListenSocket* ls) { #if defined IP_FREEBIND // Linux 2.4+ return SocketEngine::SetOption<int>(ls, SOL_IP, IP_FREEBIND, 1); #elif defined IP_BINDANY // FreeBSD return SocketEngine::SetOption<int>(ls, IPPROTO_IP, IP_BINDANY, 1); #elif defined SO_BINDANY // NetBSD, OpenBSD return SocketEngine::SetOption<int>(ls, SOL_SOCKET, SO_BINDANY, 1); #else return 0; #endif } // Sets the filesystem permissions for a UNIX socket. int SetPermissions(ListenSocket* ls) { const std::string permissionstr = ls->bind_tag->getString("permissions"); unsigned long permissions = strtoul(permissionstr.c_str(), nullptr, 8); if (!permissions || permissions > 07777) return 0; // This cast is safe thanks to the above check. return chmod(ls->bind_sa.str().c_str(), static_cast<int>(permissions)); } // Allow binding on IPv4 with an IPv6 socket. void SetIPv6Only(ListenSocket* ls) { #ifdef IPV6_V6ONLY /* This OS supports IPv6 sockets that can also listen for IPv4 * connections. If listening on all interfaces we enable both v4 and v6 * to allow for simpler configuration on dual-stack hosts. Otherwise, * if it is "::" or an IPv6 address we disable support so that an IPv4 * bind will work on the same port (by us or another application). */ const std::string address = ls->bind_tag->getString("address"); // IMPORTANT: This must be >= sizeof(DWORD) on Windows. const int enable = (address.empty() || address == "*") ? 0 : 1; // Intentionally ignore the result of this so we can fall back to default behaviour. SocketEngine::SetOption(ls, IPPROTO_IPV6, IPV6_V6ONLY, enable); #endif } } ListenSocket::ListenSocket(const std::shared_ptr<ConfigTag>& tag, const irc::sockets::sockaddrs& bind_to, sa_family_t protocol) : bind_tag(tag) , bind_sa(bind_to) , bind_protocol(protocol) { if (bind_to.family() == AF_UNIX && !RemoveSocket(this)) return; SetFd(socket(bind_to.family(), SOCK_STREAM, protocol)); if (!HasFd()) return; // Its okay if these fails. if (bind_to.family() == AF_INET6) SetIPv6Only(this); SocketEngine::SetOption<int>(this, SOL_SOCKET, SO_REUSEADDR, 1); int rv = 0; if (bind_to.is_ip() && tag->getBool("free")) rv = SetFreeBind(this); if (rv != -1) rv = SocketEngine::Bind(this, bind_to); if (rv != -1) rv = SocketEngine::Listen(this, ServerInstance->Config->MaxConn); if (rv != -1) { if (bind_to.family() == AF_UNIX) rv = SetPermissions(this); else if (bind_to.is_ip() && protocol == IPPROTO_TCP) rv = SetDeferAccept(this); } if (rv == -1) { #ifdef _WIN32 int errstore = WSAGetLastError(); #else int errstore = errno; #endif SocketEngine::Shutdown(this, 2); SocketEngine::Close(GetFd()); SetFd(-1); #ifdef _WIN32 WSASetLastError(errstore); #else errno = errstore; #endif } else { SocketEngine::NonBlocking(GetFd()); SocketEngine::AddFd(this, FD_WANT_POLL_READ | FD_WANT_NO_WRITE); this->ResetIOHookProvider(); } } ListenSocket::~ListenSocket() { if (this->HasFd()) { ServerInstance->Logs.Debug("SOCKET", "Shut down listener on fd {}", GetFd()); SocketEngine::Shutdown(this, 2); if (SocketEngine::Close(this) != 0) ServerInstance->Logs.Warning("SOCKET", "Failed to close listener: {}", strerror(errno)); if (bind_sa.family() == AF_UNIX && unlink(bind_sa.un.sun_path)) ServerInstance->Logs.Warning("SOCKET", "Failed to unlink UNIX socket: {}", strerror(errno)); } } void ListenSocket::OnEventHandlerRead() { irc::sockets::sockaddrs client(false); socklen_t length = sizeof(client); int incomingfd = SocketEngine::Accept(this, &client.sa, &length); if (incomingfd < 0) { ServerInstance->Logs.Debug("SOCKET", "Refused connection to {}: {}", bind_sa.str(), strerror(errno)); ServerInstance->Stats.Refused++; return; } ServerInstance->Logs.Debug("SOCKET", "Accepted connection to {} with fd {}", bind_sa.str(), incomingfd); irc::sockets::sockaddrs server(bind_sa); length = sizeof(server); if (getsockname(incomingfd, &server.sa, &length)) { ServerInstance->Logs.Debug("SOCKET", "Unable to get peer name for fd {}: {}", incomingfd, strerror(errno)); } if (client.family() == AF_INET6) { /* * This case is the be all and end all patch to catch and nuke 4in6 * instead of special-casing shit all over the place and wreaking merry * havoc with crap, instead, we just recreate sockaddr and strip ::ffff: prefix * if it's a 4in6 IP. * * This is, of course, much improved over the older way of handling this * (pretend it doesn't exist + hack around it -- yes, both were done!) * * Big, big thanks to danieldg for his work on this. * -- w00t */ static constexpr unsigned char prefix4in6[12] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0xFF, 0xFF }; if (!memcmp(prefix4in6, &client.in6.sin6_addr, 12)) { // recreate as a sockaddr_in using the IPv4 IP in_port_t sport = client.in6.sin6_port; client.in4.sin_family = AF_INET; client.in4.sin_port = sport; memcpy(&client.in4.sin_addr.s_addr, client.in6.sin6_addr.s6_addr + 12, sizeof(uint32_t)); sport = server.in6.sin6_port; server.in4.sin_family = AF_INET; server.in4.sin_port = sport; memcpy(&server.in4.sin_addr.s_addr, server.in6.sin6_addr.s6_addr + 12, sizeof(uint32_t)); } } else if (client.family() == AF_UNIX) { // Clients connecting via UNIX sockets don't have paths so give them // the server path as defined in RFC 1459 section 8.1.1. // // strcpy is safe here because sizeof(sockaddr_un.sun_path) is equal on both. strcpy(client.un.sun_path, server.un.sun_path); } SocketEngine::NonBlocking(incomingfd); ModResult res; FIRST_MOD_RESULT(OnAcceptConnection, res, (incomingfd, this, client, server)); if (res == MOD_RES_ALLOW) { ServerInstance->Stats.Accept++; return; } ServerInstance->Stats.Refused++; ServerInstance->Logs.Normal("SOCKET", "Refusing connection on {} - {}", bind_sa.str(), res == MOD_RES_DENY ? "Connection refused by module" : "Module for this port not found"); SocketEngine::Close(incomingfd); } void ListenSocket::ResetIOHookProvider() { iohookprovs[0].SetProvider(bind_tag->getString("hook")); // Check that all non-last hooks support being in the middle for (IOHookProvList::iterator i = iohookprovs.begin(); i != iohookprovs.end()-1; ++i) { IOHookProvRef& curr = *i; // Ignore if cannot be in the middle if ((curr) && (!curr->IsMiddle())) curr.ClearProvider(); } std::string provname = bind_tag->getString("sslprofile"); if (!provname.empty()) provname.insert(0, "ssl/"); // TLS should be the last iohookprovs.back().SetProvider(provname); } ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/src/listmode.cpp���������������������������������������������������������������������0000664�0000000�0000000�00000015560�14771603147�0016471�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2018 linuxdaemon <linuxdaemon.irc@gmail.com> * Copyright (C) 2018 B00mX0r <b00mx0r@aureus.pw> * Copyright (C) 2017-2023, 2025 Sadie Powell <sadie@witchery.services> * Copyright (C) 2013-2014 Attila Molnar <attilamolnar@hush.com> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include "inspircd.h" #include "listmode.h" ListModeBase::ListModeBase(Module* Creator, const std::string& Name, char modechar, unsigned int lnum, unsigned int eolnum) : ModeHandler(Creator, Name, modechar, PARAM_ALWAYS, MODETYPE_CHANNEL, MC_LIST) , listnumeric(lnum) , endoflistnumeric(eolnum) , extItem(Creator, "list-mode-" + name, ExtensionType::CHANNEL) { list = true; } void ListModeBase::DisplayList(User* user, Channel* channel) { ChanData* cd = extItem.Get(channel); if (!cd || cd->list.empty()) { this->DisplayEmptyList(user, channel); return; } for (const auto& item : cd->list) user->WriteNumeric(listnumeric, channel->name, item.mask, item.setter, item.time); user->WriteNumeric(endoflistnumeric, channel->name, INSP_FORMAT("End of channel {} list.", name)); } void ListModeBase::DisplayEmptyList(User* user, Channel* channel) { user->WriteNumeric(endoflistnumeric, channel->name, INSP_FORMAT("Channel {} list is empty.", name)); } void ListModeBase::RemoveMode(Channel* channel, Modes::ChangeList& changelist) { ChanData* cd = extItem.Get(channel); if (cd) { for (const auto& entry : cd->list) changelist.push_remove(this, entry.mask); } } void ListModeBase::DoRehash() { limitlist newlimits; bool seen_default = false; for (const auto& [_, c] : ServerInstance->Config->ConfTags("maxlist")) { const std::string mname = c->getString("mode"); if (!mname.empty() && !insp::equalsci(mname, name) && !(mname.length() == 1 && GetModeChar() == mname[0])) continue; ListLimit limit(c->getString("chan", "*", 1), c->getNum<size_t>("limit", DEFAULT_LIST_SIZE)); if (limit.mask.empty()) throw ModuleException(creator, "<maxlist:chan> is empty, at {}", c->source.str()); if (limit.mask == "*" || limit.mask == "#*") seen_default = true; newlimits.push_back(limit); } // If no default limit has been specified then insert one. if (!seen_default) { ServerInstance->Logs.Warning("MODE", "No default <maxlist> entry was found for the {} mode; defaulting to {}", name, DEFAULT_LIST_SIZE); newlimits.push_back(ListLimit("*", DEFAULT_LIST_SIZE)); } // Most of the time our settings are unchanged, so we can avoid iterating the chanlist if (chanlimits == newlimits) return; chanlimits.swap(newlimits); for (const auto& [_, chan] : ServerInstance->Channels.GetChans()) { ChanData* cd = extItem.Get(chan); if (cd) cd->maxitems.reset(); } } size_t ListModeBase::FindLimit(const std::string& channame) { for (const auto& chanlimit : chanlimits) { if (InspIRCd::Match(channame, chanlimit.mask)) { // We have a pattern matching the channel return chanlimit.limit; } } return 0; } size_t ListModeBase::GetLimitInternal(const std::string& channame, ChanData* cd) { if (!cd->maxitems) cd->maxitems = FindLimit(channame); return cd->maxitems.value(); } size_t ListModeBase::GetLimit(Channel* channel) { ChanData* cd = extItem.Get(channel); if (!cd) // just find the limit return FindLimit(channel->name); return GetLimitInternal(channel->name, cd); } size_t ListModeBase::GetLowerLimit() { if (chanlimits.empty()) return DEFAULT_LIST_SIZE; size_t limit = std::numeric_limits<size_t>::max(); for (const auto& chanlimit : chanlimits) { if (chanlimit.limit < limit) limit = chanlimit.limit; } return limit; } bool ListModeBase::OnModeChange(User* source, User*, Channel* channel, Modes::Change& change) { LocalUser* lsource = IS_LOCAL(source); if (change.adding) { // Try to canonicalise the parameter locally. if (lsource && !ValidateParam(lsource, channel, change.param)) return false; ChanData* cd = extItem.Get(channel); if (cd) { // Check if the item already exists in the list for (const auto& entry : cd->list) { if (!CompareEntry(entry.mask, change.param)) continue; // Doesn't match the proposed addition. if (lsource) TellAlreadyOnList(lsource, channel, change.param); return false; } } else { // There's no channel list currently; create one. cd = new ChanData; extItem.Set(channel, cd); } if (lsource) { size_t limit = GetLimitInternal(channel->name, cd); if (cd->list.size() >= limit) { // The list size might be 0 so we have to check even if just created. TellListTooLong(lsource, channel, change.param, limit); return false; } } // Add the new entry to the list. cd->list.emplace_back( change.param, change.set_by.value_or(ServerInstance->Config->MaskInList ? source->GetMask() : source->nick), change.set_at.value_or(ServerInstance->Time()) ); return true; } else { ChanData* cd = extItem.Get(channel); if (cd) { // We have a list and we're removing; is the entry in it? for (ModeList::iterator it = cd->list.begin(); it != cd->list.end(); ++it) { if (!CompareEntry(it->mask, change.param)) continue; // Doesn't match the proposed removal. change.param = it->mask; stdalgo::vector::swaperase(cd->list, it); return true; } } if (lsource) TellNotSet(lsource, channel, change.param); return false; } } bool ListModeBase::ValidateParam(LocalUser* user, Channel* channel, std::string& parameter) { return true; } void ListModeBase::OnParameterMissing(User* source, User* dest, Channel* channel) { // Intentionally left blank. } void ListModeBase::TellListTooLong(LocalUser* source, Channel* channel, const std::string& parameter, size_t limit) { source->WriteNumeric(ERR_BANLISTFULL, channel->name, parameter, mode, INSP_FORMAT("Channel {} list is full ({} entries)", name, limit)); } void ListModeBase::TellAlreadyOnList(LocalUser* source, Channel* channel, const std::string& parameter) { source->WriteNumeric(ERR_LISTMODEALREADYSET, channel->name, parameter, mode, INSP_FORMAT("Channel {} list already contains {}", name, parameter)); } void ListModeBase::TellNotSet(LocalUser* source, Channel* channel, const std::string& parameter) { source->WriteNumeric(ERR_LISTMODENOTSET, channel->name, parameter, mode, INSP_FORMAT("Channel {} list does not contain {}", name, parameter)); } ������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/src/logging.cpp����������������������������������������������������������������������0000664�0000000�0000000�00000022734�14771603147�0016300�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2022-2025 Sadie Powell <sadie@witchery.services> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include "inspircd.h" #include "clientprotocolmsg.h" #include "timeutils.h" #include <fmt/color.h> const char* Log::LevelToString(Log::Level level) { switch (level) { case Log::Level::CRITICAL: return "critical"; case Log::Level::WARNING: return "warning"; case Log::Level::NORMAL: return "normal"; case Log::Level::DEBUG: return "debug"; case Log::Level::RAWIO: return "rawio"; } // Should never happen. return "unknown"; } void Log::NotifyRawIO(LocalUser* user, MessageType type) { ClientProtocol::Messages::Privmsg msg(ServerInstance->FakeClient, user, "*** Raw I/O logging is enabled on this server. All messages, passwords, and commands are being recorded.", type); user->Send(ServerInstance->GetRFCEvents().privmsg, msg); } class DebugLogMethod final : public Log::Method { public: void OnLog(time_t time, Log::Level level, const std::string& type, const std::string& message) override { fmt::println("{} {}: {}", fmt::styled(Time::ToString(time, "%d %b %H:%M:%S"), fmt::fg(fmt::terminal_color::yellow)), fmt::styled(type, fmt::fg(fmt::terminal_color::green)), message ); } }; Log::FileMethod::FileMethod(const std::string& n, FILE* fh, unsigned long fl, bool ac) : Timer(15*60, true) , autoclose(ac) , file(fh) , flush(fl) , name(n) { if (flush > 1) ServerInstance->Timers.AddTimer(this); } Log::FileMethod::~FileMethod() { if (autoclose) fclose(file); } void Log::FileMethod::OnLog(time_t time, Level level, const std::string& type, const std::string& message) { static time_t prevtime = 0; static std::string timestr; if (prevtime != time) { prevtime = time; timestr = Time::ToString(prevtime); } fputs(timestr.c_str(), file); fputs(" ", file); fputs(type.c_str(), file); fputs(": ", file); fputs(message.c_str(), file); #if defined _WIN32 fputs("\r\n", file); #else fputs("\n", file); #endif if (!(++lines % flush)) fflush(file); if (ferror(file)) throw CoreException(INSP_FORMAT("Unable to write to {}: {}", name, strerror(errno))); } bool Log::FileMethod::Tick() { fflush(file); return true; } Log::Engine::Engine(Module* Creator, const std::string& Name) : DataProvider(Creator, "log/" + Name) { } Log::Engine::~Engine() { if (creator) ServerInstance->Logs.UnloadEngine(this); } Log::FileEngine::FileEngine(Module* Creator) : Engine(Creator, "file") { } Log::MethodPtr Log::FileEngine::Create(const std::shared_ptr<ConfigTag>& tag) { const std::string target = tag->getString("target"); if (target.empty()) throw CoreException("<log:target> must be specified for file logger at " + tag->source.str()); const std::string fulltarget = ServerInstance->Config->Paths.PrependLog(Time::ToString(ServerInstance->Time(), target.c_str())); auto* fh = fopen(fulltarget.c_str(), "a"); if (!fh) { throw CoreException(INSP_FORMAT("Unable to open {} for file logger at {}: {}", fulltarget, tag->source.str(), strerror(errno))); } const unsigned long flush = tag->getNum<unsigned long>("flush", 20, 1); return std::make_shared<FileMethod>(fulltarget, fh, flush, true); } Log::StreamEngine::StreamEngine(Module* Creator, const std::string& Name, FILE* fh) : Engine(Creator, Name) , file(fh) { } Log::MethodPtr Log::StreamEngine::Create(const std::shared_ptr<ConfigTag>& tag) { return std::make_shared<FileMethod>(name, file, 1, false); } Log::Manager::CachedMessage::CachedMessage(time_t ts, Level l, const std::string& t, const std::string& m) : time(ts) , level(l) , type(t) , message(m) { } Log::Manager::Info::Info(Level l, TokenList t, MethodPtr m, bool c, const Engine* e) : config(c) , level(l) , types(std::move(t)) , method(std::move(m)) , engine(e) { } bool Log::Manager::Info::Suitable(Level l, const std::string& t) const { return level >= l && types.Contains(t) && !dead; } Log::Manager::Manager() : filelog(nullptr) , stderrlog(nullptr, "stderr", stderr) , stdoutlog(nullptr, "stdout", stdout) { } void Log::Manager::CloseLogs() { logging = true; // Prevent writing to dying loggers. loggers.erase(std::remove_if(loggers.begin(), loggers.end(), [](const Info& info) { return info.config; }), loggers.end()); logging = false; } void Log::Manager::EnableDebugMode() { TokenList types = std::string("*"); MethodPtr method = std::make_shared<DebugLogMethod>(); if (ServerInstance->Config->CommandLine.forceprotodebug) { // If we are doing a protocol debug we need to warn users. loggers.emplace_back(Level::RAWIO, std::move(types), std::move(method), false, &stdoutlog); ServerInstance->Config->RawLog = true; } else { loggers.emplace_back(Level::DEBUG, std::move(types), std::move(method), false, &stdoutlog); } } void Log::Manager::OpenLogs(bool requiremethods) { // If the server is started in debug mode we don't write logs. if (ServerInstance->Config->CommandLine.forcedebug) { const auto* option = ServerInstance->Config->CommandLine.forceprotodebug ? "--protocoldebug" : "--debug"; Normal("LOG", "Not opening loggers because we were started with {}", option); CheckLevel(); return; } // If the server is started with logging disabled we don't write logs. if (!ServerInstance->Config->CommandLine.writelog) { Normal("LOG", "Not opening loggers because we were started with --nolog"); CheckLevel(); return; } for (const auto& [_, tag] : ServerInstance->Config->ConfTags("log")) { const std::string methodstr = tag->getString("method", "file", 1); Log::Engine* engine = ServerInstance->Modules.FindDataService<Log::Engine>("log/" + methodstr); if (!engine) { if (!requiremethods) continue; // We will open this later. throw CoreException(methodstr + " is not a valid logging method at " + tag->source.str()); } const Level level = tag->getEnum("level", Level::NORMAL, { { "critical", Level::CRITICAL }, { "warning", Level::WARNING }, { "normal", Level::NORMAL }, { "debug", Level::DEBUG }, { "rawio", Level::RAWIO }, // Deprecated v3 names. { "sparse", Level::CRITICAL }, { "verbose", Level::WARNING }, { "default", Level::NORMAL }, }); TokenList types = tag->getString("type", "*", 1); MethodPtr method = engine->Create(tag); loggers.emplace_back(level, std::move(types), method, true, engine); } if (requiremethods && caching) { // The server has finished starting up so we can write out any cached log messages. for (auto& logger : loggers) { if (logger.dead || !logger.method->AcceptsCachedMessages()) continue; // Does not support logging. for (const auto& message : cache) { if (!logger.Suitable(message.level, message.type)) continue; try { logger.method->OnLog(message.time, message.level, message.type, message.message); } catch (const CoreException& err) { logger.dead = true; logger.method.reset(); ServerInstance->SNO.WriteGlobalSno('a', "A logger threw an exception: {}", err.GetReason()); break; } } } cache.clear(); cache.shrink_to_fit(); caching = false; } CheckLevel(); } void Log::Manager::RegisterServices() { ServiceProvider* coreloggers[] = { &filelog, &stderrlog, &stdoutlog }; ServerInstance->Modules.AddServices(coreloggers, sizeof(coreloggers)/sizeof(ServiceProvider*)); } void Log::Manager::UnloadEngine(const Engine* engine) { logging = true; // Prevent writing to dying loggers. size_t logger_count = loggers.size(); loggers.erase(std::remove_if(loggers.begin(), loggers.end(), [&engine](const Info& info) { return info.engine == engine; }), loggers.end()); logging = false; Normal("LOG", "The {} log engine is unloading; removed {}/{} loggers.", engine->name.c_str(), logger_count - loggers.size(), logger_count); } void Log::Manager::CheckLevel() { // There might be a logger not from the config so we need to check this outside of the creation loop. auto newmaxlevel = Level::LOWEST; for (const auto& logger : loggers) { if (logger.level > newmaxlevel) newmaxlevel = logger.level; } std::swap(maxlevel, newmaxlevel); ServerInstance->Config->RawLog = (newmaxlevel >= Level::RAWIO); Debug("LOG", "Changed maximum log level from {} to {}", LevelToString(newmaxlevel), LevelToString(maxlevel)); } void Log::Manager::Write(Level level, const std::string& type, const std::string& message) { if (logging) return; // Avoid log loops. if (maxlevel < level && !caching) return; // No loggers care about this message. logging = true; time_t time = ServerInstance->Time(); for (auto& logger : loggers) { if (!logger.Suitable(level, type)) continue; try { logger.method->OnLog(time, level, type, message); } catch (const CoreException& err) { logger.dead = true; logger.method.reset(); ServerInstance->SNO.WriteGlobalSno('a', "A logger threw an exception: {}", err.GetReason()); break; } } if (caching) cache.emplace_back(time, level, type, message); logging = false; } ������������������������������������inspircd-4.7.0/src/mode.cpp�������������������������������������������������������������������������0000664�0000000�0000000�00000055657�14771603147�0015610�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2021 Dominic Hamon * Copyright (C) 2017-2025 Sadie Powell <sadie@witchery.services> * Copyright (C) 2017 B00mX0r <b00mx0r@aureus.pw> * Copyright (C) 2012-2016, 2018 Attila Molnar <attilamolnar@hush.com> * Copyright (C) 2012 Shawn Smith <ShawnSmith0828@gmail.com> * Copyright (C) 2012 Robby <robby@chatbelgie.be> * Copyright (C) 2009-2010 Daniel De Graaf <danieldg@inspircd.org> * Copyright (C) 2008 Thomas Stagner <aquanight@gmail.com> * Copyright (C) 2008 Robin Burchell <robin+git@viroteck.net> * Copyright (C) 2007 Dennis Friis <peavey@inspircd.org> * Copyright (C) 2006-2008 Craig Edwards <brain@inspircd.org> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include "inspircd.h" #include "clientprotocolevent.h" #include "numerichelper.h" ModeHandler::ModeHandler(Module* Creator, const std::string& Name, char modeletter, ParamSpec Params, ModeType type, Class mclass) : ServiceProvider(Creator, Name, SERVICE_MODE) , modeid(ModeParser::MODEID_MAX) , parameters_taken(Params) , mode(ServerInstance->Config->ConfValue("modes")->getCharacter(Name, modeletter)) , m_type(type) , type_id(mclass) { } Cullable::Result ModeHandler::Cull() { if (ServerInstance) ServerInstance->Modes.DelMode(this); return Cullable::Cull(); } bool ModeHandler::NeedsParam(bool adding) const { switch (parameters_taken) { case PARAM_ALWAYS: return true; case PARAM_SETONLY: return adding; case PARAM_NONE: break; } return false; } std::string ModeHandler::GetUserParameter(const User* user) const { return ""; } ModResult ModeHandler::AccessCheck(User*, Channel*, Modes::Change&) { return MOD_RES_PASSTHRU; } bool ModeHandler::OnModeChange(User*, User*, Channel*, Modes::Change&) { return false; } void ModeHandler::DisplayList(User*, Channel*) { } void ModeHandler::DisplayEmptyList(User*, Channel*) { } void ModeHandler::OnParameterMissing(User* user, User* dest, Channel* channel) { std::string message = INSP_FORMAT("You must specify a parameter for the {} mode.", name); if (!syntax.empty()) message.append(INSP_FORMAT(" Syntax: {}.", syntax)); if (channel) user->WriteNumeric(Numerics::InvalidModeParameter(channel, this, "*", message)); else user->WriteNumeric(Numerics::InvalidModeParameter(dest, this, "*", message)); } void ModeHandler::OnParameterInvalid(User* user, Channel* targetchannel, User* targetuser, const std::string& parameter) { if (targetchannel) user->WriteNumeric(Numerics::InvalidModeParameter(targetchannel, this, "*")); else user->WriteNumeric(Numerics::InvalidModeParameter(targetuser, this, "*")); } bool ModeHandler::ResolveModeConflict(const std::string& theirs, const std::string& ours, Channel*) { return (theirs < ours); } void ModeHandler::RegisterService() { ServerInstance->Modes.AddMode(this); ServerInstance->Modules.AddReferent((GetModeType() == MODETYPE_CHANNEL ? "mode/" : "umode/") + name, this); } bool SimpleUserMode::OnModeChange(User* source, User* dest, Channel* channel, Modes::Change& change) { /* We're either trying to add a mode we already have or remove a mode we don't have, deny. */ if (dest->IsModeSet(this) == change.adding) return false; /* adding will be either true or false, depending on if we are adding or removing the mode, since we already checked to make sure we aren't adding a mode we have or that we aren't removing a mode we don't have, we don't have to do any other checks here to see if it's true or false, just add or remove the mode */ dest->SetMode(this, change.adding); return true; } bool SimpleChannelMode::OnModeChange(User* source, User* dest, Channel* channel, Modes::Change& change) { /* We're either trying to add a mode we already have or remove a mode we don't have, deny. */ if (channel->IsModeSet(this) == change.adding) return false; /* adding will be either true or false, depending on if we are adding or removing the mode, since we already checked to make sure we aren't adding a mode we have or that we aren't removing a mode we don't have, we don't have to do any other checks here to see if it's true or false, just add or remove the mode */ channel->SetMode(this, change.adding); return true; } ModeWatcher::ModeWatcher(Module* Creator, const std::string& modename, ModeType type) : mode(modename) , m_type(type) , creator(Creator) { ServerInstance->Modes.AddModeWatcher(this); } ModeWatcher::~ModeWatcher() { ServerInstance->Modes.DelModeWatcher(this); } bool ModeWatcher::BeforeMode(User*, User*, Channel*, Modes::Change&) { return true; } void ModeWatcher::AfterMode(User*, User*, Channel*, const Modes::Change&) { } PrefixMode::PrefixMode(Module* Creator, const std::string& Name, char ModeLetter, Rank PrefixRank, char PrefixChar) : ModeHandler(Creator, Name, ModeLetter, PARAM_ALWAYS, MODETYPE_CHANNEL, MC_PREFIX) , prefix(PrefixChar) , prefixrank(PrefixRank) { list = true; syntax = "<nick>"; } ModResult PrefixMode::AccessCheck(User* src, Channel*, Modes::Change& change) { if (!change.adding && src->nick == change.param && selfremove) return MOD_RES_ALLOW; return MOD_RES_PASSTHRU; } bool PrefixMode::OnModeChange(User* source, User*, Channel* chan, Modes::Change& change) { User* target; if (IS_LOCAL(source)) target = ServerInstance->Users.FindNick(change.param); else target = ServerInstance->Users.Find(change.param); if (!target) { source->WriteNumeric(Numerics::NoSuchNick(change.param)); return false; } Membership* memb = chan->GetUser(target); if (!memb) { source->WriteNumeric(ERR_USERNOTINCHANNEL, target->nick, chan->name, "They are not on that channel"); return false; } change.param = target->nick; return memb->SetPrefix(this, change.adding); } void PrefixMode::Update(ModeHandler::Rank rank, ModeHandler::Rank setrank, ModeHandler::Rank unsetrank, bool selfrm) { prefixrank = rank; ranktoset = setrank; ranktounset = unsetrank; selfremove = selfrm; } bool ParamModeBase::OnModeChange(User* source, User*, Channel* chan, Modes::Change& change) { if (change.adding) { if (chan->GetModeParameter(this) == change.param) return false; if (!OnSet(source, chan, change.param)) return false; chan->SetMode(this, true); // Handler might have changed the parameter internally change.param.clear(); this->GetParameter(chan, change.param); } else { if (!chan->IsModeSet(this)) return false; this->OnUnsetInternal(source, chan); chan->SetMode(this, false); } return true; } bool ModeParser::TryMode(User* user, User* targetuser, Channel* chan, Modes::Change& mcitem, bool SkipACL) { ModeType type = chan ? MODETYPE_CHANNEL : MODETYPE_USER; ModeHandler* mh = mcitem.mh; const bool needs_param = mh->NeedsParam(mcitem.adding); // crop mode parameter size to MODE_PARAM_MAX characters if (mcitem.param.length() > MODE_PARAM_MAX && mcitem.adding) mcitem.param.erase(MODE_PARAM_MAX); ModResult modres; FIRST_MOD_RESULT(OnRawMode, modres, (user, chan, mcitem)); if (IS_LOCAL(user) && (modres == MOD_RES_DENY)) return false; const char modechar = mh->GetModeChar(); if (chan && !SkipACL && (modres != MOD_RES_ALLOW)) { modres = mh->AccessCheck(user, chan, mcitem); if (modres == MOD_RES_DENY) return false; if (modres == MOD_RES_PASSTHRU) { ModeHandler::Rank neededrank = mh->GetLevelRequired(mcitem.adding); ModeHandler::Rank ourrank = chan->GetPrefixValue(user); if (ourrank < neededrank) { user->WriteNumeric(Numerics::ChannelPrivilegesNeeded(chan, neededrank, INSP_FORMAT("{} channel mode {} ({})", mcitem.adding ? "set" : "unset", mh->GetModeChar(), mh->name))); return false; } } } // Ask mode watchers whether this mode change is OK for (const auto& [_, mw] : insp::equal_range(modewatchermap, mh->name)) { if (mw->GetModeType() == type) { if (!mw->BeforeMode(user, targetuser, chan, mcitem)) return false; // A module whacked the parameter completely, and there was one. Abort. if ((needs_param) && (mcitem.param.empty())) return false; } } if ((chan || (!chan && mcitem.adding)) && IS_LOCAL(user) && mh->NeedsOper() && !user->HasModePermission(mh)) { /* It's an oper only mode, and they don't have access to it. */ if (user->IsOper()) { user->WriteNumeric(ERR_NOPRIVILEGES, INSP_FORMAT("Permission Denied - Oper type {} does not have access to {} {} mode {}", user->oper->GetType(), mcitem.adding ? "set" : "unset", type == MODETYPE_CHANNEL ? "channel" : "user", modechar)); } else { user->WriteNumeric(ERR_NOPRIVILEGES, INSP_FORMAT("Permission Denied - Only operators may {} {} mode {}", mcitem.adding ? "set" : "unset", type == MODETYPE_CHANNEL ? "channel" : "user", modechar)); } return false; } /* Call the handler for the mode */ if (!mh->OnModeChange(user, targetuser, chan, mcitem)) return false; if ((needs_param) && (mcitem.param.empty())) return false; for (const auto& [_, mw] : insp::equal_range(modewatchermap, mh->name)) { if (mw->GetModeType() == type) mw->AfterMode(user, targetuser, chan, mcitem); } return true; } void ModeParser::ModeParamsToChangeList(User* user, ModeType type, const std::vector<std::string>& parameters, Modes::ChangeList& changelist, size_t beginindex, size_t endindex) { if (endindex > parameters.size()) endindex = parameters.size(); bool adding = true; size_t param_at = beginindex+1; for (const auto modechar : parameters[beginindex]) { if (modechar == '+' || modechar == '-') { adding = (modechar == '+'); continue; } ModeHandler* mh = this->FindMode(modechar, type); if (!mh) { /* No mode handler? Unknown mode character then. */ int numeric = (type == MODETYPE_CHANNEL ? ERR_UNKNOWNMODE : ERR_UNKNOWNSNOMASK); const char* typestr = (type == MODETYPE_CHANNEL ? "channel" : "user"); user->WriteNumeric(numeric, modechar, INSP_FORMAT("is not a recognised {} mode.", typestr)); continue; } std::string parameter; if ((mh->NeedsParam(adding)) && (param_at < endindex)) parameter = parameters[param_at++]; changelist.push(mh, adding, parameter); } } static bool IsModeParamValid(User* user, Channel* targetchannel, User* targetuser, const Modes::Change& item) { // An empty parameter is never acceptable if (item.param.empty()) { item.mh->OnParameterMissing(user, targetuser, targetchannel); return false; } // The parameter cannot begin with a ':' character or contain a space if ((item.param[0] == ':') || (item.param.find(' ') != std::string::npos)) { item.mh->OnParameterInvalid(user, targetchannel, targetuser, item.param); return false; } return true; } // Returns true if we should apply a merged mode, false if we should skip it static bool ShouldApplyMergedMode(Channel* chan, const Modes::Change& item) { ModeHandler* mh = item.mh; if ((!chan) || (!chan->IsModeSet(mh)) || (mh->IsListMode())) // Mode not set here or merge is not applicable, apply the incoming mode return true; // Mode handler decides const std::string ours = chan->GetModeParameter(mh); return mh->ResolveModeConflict(item.param, ours, chan); } void ModeParser::Process(User* user, Channel* targetchannel, User* targetuser, Modes::ChangeList& changelist, ModeProcessFlag flags) { // Call ProcessSingle until the entire list is processed, but at least once to ensure // LastParse and LastChangeList are cleared size_t processed = 0; do { processed += ProcessSingle(user, targetchannel, targetuser, changelist, flags, processed); } while (processed < changelist.size()); } size_t ModeParser::ProcessSingle(User* user, Channel* targetchannel, User* targetuser, Modes::ChangeList& changelist, ModeProcessFlag flags, size_t beginindex) { LastChangeList.clear(); size_t modes_processed = 0; Modes::ChangeList::List& list = changelist.getlist(); for (auto& item : insp::iterator_range(list.begin() + beginindex, list.end())) { modes_processed++; ModeHandler* mh = item.mh; // If a mode change has been given for a mode that does not exist then reject // it. This can happen when core_reloadmodule attempts to restore a mode that // no longer exists. if (!mh) continue; // If the mode is supposed to have a parameter then we first take a look at item.param // and, if we were asked to, also handle mode merges now if (mh->NeedsParam(item.adding)) { // Skip the mode if the parameter does not pass basic validation if (!IsModeParamValid(user, targetchannel, targetuser, item)) continue; // If this is a merge and we won we don't apply this mode if ((flags & MODE_MERGE) && (!ShouldApplyMergedMode(targetchannel, item))) continue; } if (!TryMode(user, targetuser, targetchannel, item, (!(flags & MODE_CHECKACCESS)))) continue; LastChangeList.push(mh, item.adding, item.param); if (LastChangeList.size() >= ServerInstance->Config->Limits.MaxModes) { /* mode sequence is getting too long */ break; } } if (!LastChangeList.empty()) { ClientProtocol::Events::Mode modeevent(user, targetchannel, targetuser, LastChangeList); if (targetchannel) { targetchannel->Write(modeevent); } else { LocalUser* localtarget = IS_LOCAL(targetuser); if (localtarget) localtarget->Send(modeevent); } FOREACH_MOD(OnMode, (user, targetuser, targetchannel, LastChangeList, flags)); } return modes_processed; } void ModeParser::ShowListModeList(User* user, Channel* chan, ModeHandler* mh) { { Modes::Change modechange(mh, true, ""); ModResult modres; FIRST_MOD_RESULT(OnRawMode, modres, (user, chan, modechange)); if (modres == MOD_RES_DENY) return; bool display = true; // Ask mode watchers whether it's OK to show the list for (const auto& [_, mw] : insp::equal_range(modewatchermap, mh->name)) { if (mw->GetModeType() == MODETYPE_CHANNEL) { if (!mw->BeforeMode(user, nullptr, chan, modechange)) { // A mode watcher doesn't want us to show the list display = false; break; } } } if (display) mh->DisplayList(user, chan); else mh->DisplayEmptyList(user, chan); } } void ModeParser::CleanMask(std::string& mask) { auto pos_of_pling = mask.find_first_of('!'); auto pos_of_at = mask.find_first_of('@', pos_of_pling == std::string::npos ? 0 : pos_of_pling); auto pos_of_hostchar = mask.find_first_of(":.", pos_of_at == std::string::npos ? 0 : pos_of_at); if (pos_of_pling == mask.length()-1 || pos_of_at == mask.length()-1) { // Malformed mask; needs * after the ! or @. mask.append("*"); } if (pos_of_pling == 0 || pos_of_at == 0) { // Malformed mask; needs * before the ! or @. mask.insert(0, "*"); } if (pos_of_pling == std::string::npos && pos_of_at == std::string::npos) { if (pos_of_hostchar == std::string::npos) mask.append("!*@*"); // The mask looks like "nick". else mask.insert(0, "*!*@"); // The mask looks like "host". } else if (pos_of_pling == std::string::npos && pos_of_at != std::string::npos) { // The mask looks like "user@host". mask.insert(0, "*!"); } else if (pos_of_pling != std::string::npos && pos_of_at == std::string::npos) { // The mask looks like "nick!user". mask.append("@*"); } else if (pos_of_at-pos_of_pling == 1) { // The mask looks like "nick!@host". mask.insert(pos_of_at, "*"); } } ModeHandler::Id ModeParser::AllocateModeId(ModeHandler* mh) { for (ModeHandler::Id i = 0; i != MODEID_MAX; ++i) { if (!modehandlersbyid[mh->GetModeType()][i]) return i; } throw ModuleException(mh->creator, "Out of mode ids"); } void ModeParser::AddMode(ModeHandler* mh) { if (!ModeParser::IsModeChar(mh->GetModeChar())) throw ModuleException(mh->creator, "Mode letter for {} is invalid: {}", mh->name, mh->GetModeChar()); /* A mode prefix of ',' is not acceptable, it would fuck up server to server. * A mode prefix of ':' will fuck up both server to server, and client to server. * A mode prefix of '#' will mess up /whois and /privmsg */ PrefixMode* pm = mh->IsPrefixMode(); if (pm) { if ((pm->GetPrefix() > 126) || (pm->GetPrefix() == ',') || (pm->GetPrefix() == ':') || ServerInstance->Channels.IsPrefix(pm->GetPrefix())) throw ModuleException(mh->creator, "Mode prefix for {} is invalid: {}", mh->name, pm->GetPrefix()); PrefixMode* otherpm = FindPrefix(pm->GetPrefix()); if (otherpm) { throw ModuleException(mh->creator, "Mode prefix for {} already used by {} from {}: {}", mh->name, otherpm->name, otherpm->creator->ModuleFile, pm->GetPrefix()); } } ModeHandler*& slot = modehandlers[mh->GetModeType()][ModeParser::GetModeIndex(mh->GetModeChar())]; if (slot) { throw ModuleException(mh->creator, "Mode letter for {} already used by {} from {}: {}", mh->name, slot->name, slot->creator->ModuleFile, mh->GetModeChar()); } // The mode needs an id if it is either a user mode, a simple mode (flag) or a parameter mode. // Otherwise (for listmodes and prefix modes) the id remains MODEID_MAX, which is invalid. ModeHandler::Id modeid = MODEID_MAX; if ((mh->GetModeType() == MODETYPE_USER) || (mh->IsParameterMode()) || (!mh->IsListMode())) modeid = AllocateModeId(mh); std::pair<ModeHandlerMap::iterator, bool> res = modehandlersbyname[mh->GetModeType()].emplace(mh->name, mh); if (!res.second) { ModeHandler* othermh = res.first->second; throw ModuleException(mh->creator, "Mode name {} already used by {} from {}", mh->name, othermh->GetModeChar(), othermh->creator->ModuleFile); } // Everything is fine, add the mode // If we allocated an id for this mode then save it and put the mode handler into the slot if (modeid != MODEID_MAX) { mh->modeid = modeid; modehandlersbyid[mh->GetModeType()][modeid] = mh; } slot = mh; if (pm) mhlist.prefix.push_back(pm); else if (mh->IsListModeBase()) mhlist.list.push_back(mh->IsListModeBase()); } bool ModeParser::DelMode(ModeHandler* mh) { if (!ModeParser::IsModeChar(mh->GetModeChar())) return false; ModeHandlerMap& mhmap = modehandlersbyname[mh->GetModeType()]; ModeHandlerMap::iterator mhmapit = mhmap.find(mh->name); if ((mhmapit == mhmap.end()) || (mhmapit->second != mh)) return false; ModeHandler*& slot = modehandlers[mh->GetModeType()][ModeParser::GetModeIndex(mh->GetModeChar())]; if (slot != mh) return false; /* Note: We can't stack here, as we have modes potentially being removed across many different channels. * To stack here we have to make the algorithm slower. Discuss. */ switch (mh->GetModeType()) { case MODETYPE_USER: { const UserMap& users = ServerInstance->Users.GetUsers(); for (UserMap::const_iterator i = users.begin(); i != users.end(); ) { User* user = i->second; ++i; mh->RemoveMode(user); } } break; case MODETYPE_CHANNEL: { const ChannelMap& chans = ServerInstance->Channels.GetChans(); for (ChannelMap::const_iterator i = chans.begin(); i != chans.end(); ) { // The channel may not be in the hash after RemoveMode(), see m_permchannels Channel* chan = i->second; ++i; Modes::ChangeList changelist; mh->RemoveMode(chan, changelist); this->Process(ServerInstance->FakeClient, chan, nullptr, changelist, MODE_LOCALONLY); } } break; } mhmap.erase(mhmapit); if (mh->GetId() != MODEID_MAX) modehandlersbyid[mh->GetModeType()][mh->GetId()] = nullptr; slot = nullptr; if (mh->IsPrefixMode()) mhlist.prefix.erase(std::find(mhlist.prefix.begin(), mhlist.prefix.end(), mh->IsPrefixMode())); else if (mh->IsListModeBase()) mhlist.list.erase(std::find(mhlist.list.begin(), mhlist.list.end(), mh->IsListModeBase())); return true; } ModeHandler* ModeParser::FindMode(const std::string& modename, ModeType mt) { ModeHandlerMap& mhmap = modehandlersbyname[mt]; ModeHandlerMap::const_iterator it = mhmap.find(modename); if (it != mhmap.end()) return it->second; return nullptr; } ModeHandler* ModeParser::FindMode(unsigned char modeletter, ModeType mt) { if (!ModeParser::IsModeChar(modeletter)) return nullptr; return modehandlers[mt][ModeParser::GetModeIndex(modeletter)]; } PrefixMode* ModeParser::FindPrefixMode(unsigned char modeletter) { ModeHandler* mh = FindMode(modeletter, MODETYPE_CHANNEL); if (!mh) return nullptr; return mh->IsPrefixMode(); } PrefixMode* ModeParser::FindNearestPrefixMode(ModeHandler::Rank rank) const { PrefixMode* pm = nullptr; for (auto* thispm : GetPrefixModes()) { if (thispm->GetPrefixRank() < rank) continue; // Not ranked high enough. // Is it lower than the last checked mode? if (!pm || thispm->GetPrefixRank() < pm->GetPrefixRank()) pm = thispm; } return pm; } PrefixMode* ModeParser::FindPrefix(unsigned char pfxletter) const { for (auto* pm : GetPrefixModes()) { if (pm->GetPrefix() == pfxletter) return pm; } return nullptr; } void ModeParser::AddModeWatcher(ModeWatcher* mw) { modewatchermap.emplace(mw->GetModeName(), mw); } bool ModeParser::DelModeWatcher(ModeWatcher* mw) { std::pair<ModeWatcherMap::iterator, ModeWatcherMap::iterator> itpair = modewatchermap.equal_range(mw->GetModeName()); for (ModeWatcherMap::iterator i = itpair.first; i != itpair.second; ++i) { if (i->second == mw) { modewatchermap.erase(i); return true; } } return false; } void ModeHandler::RemoveMode(User* user) { // Remove the mode if it's set on the user if (user->IsModeSet(this)) { Modes::ChangeList changelist; changelist.push_remove(this); ServerInstance->Modes.Process(ServerInstance->FakeClient, nullptr, user, changelist, ModeParser::MODE_LOCALONLY); } } void ModeHandler::RemoveMode(Channel* channel, Modes::ChangeList& changelist) { if (channel->IsModeSet(this)) { if (this->NeedsParam(false)) // Removing this mode requires a parameter changelist.push_remove(this, channel->GetModeParameter(this)); else changelist.push_remove(this); } } void PrefixMode::RemoveMode(Channel* chan, Modes::ChangeList& changelist) { for (const auto& [user, memb] : chan->GetUsers()) { if (memb->HasMode(this)) changelist.push_remove(this, user->nick); } } bool ModeParser::IsModeChar(char chr) { return ((chr >= '0' && chr <= '9') || (chr >= 'A' && chr <= 'Z') || (chr >= 'a' && chr <= 'z')); } size_t ModeParser::GetModeIndex(char chr) { // Bitset layout: // 0123456789 = 10 [0-9] // ABCDEFGHIJKLMNOPQRSTUVWXYZ = 26 [10-35] // abcdefghijklmnopqrstuvwxyz = 26 [36-61] if (chr >= '0' && chr <= '9') return chr - '0'; if (chr >= 'A' && chr <= 'Z') return chr - 'A' + 10; // [0-9] = 10 if (chr >= 'a' && chr <= 'z') return chr - 'a' + 36; // [0-9]+[A-Z] = 10+26 = 36 return ModeParser::MODEID_MAX; } ModeParser::ModeParser() { /* Clear mode handler list */ memset(modehandlers, 0, sizeof(modehandlers)); memset(modehandlersbyid, 0, sizeof(modehandlersbyid)); } ���������������������������������������������������������������������������������inspircd-4.7.0/src/modulemanager.cpp����������������������������������������������������������������0000664�0000000�0000000�00000010366�14771603147�0017470�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2013, 2015, 2019-2024 Sadie Powell <sadie@witchery.services> * Copyright (C) 2013 Adam <Adam@anope.org> * Copyright (C) 2012-2013, 2015 Attila Molnar <attilamolnar@hush.com> * Copyright (C) 2012 Robby <robby@chatbelgie.be> * Copyright (C) 2009-2010 Daniel De Graaf <danieldg@inspircd.org> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include <filesystem> #include <fmt/color.h> #include "inspircd.h" #include "dynamic.h" bool ModuleManager::Load(const std::string& modname, bool defer) { /* Don't allow people to specify paths for modules, it doesn't work as expected */ if (modname.find_first_of("\\/") != std::string::npos) { LastModuleError = "You can't load modules with a path: " + modname; return false; } const std::string filename = ExpandModName(modname); const std::string moduleFile = ServerInstance->Config->Paths.PrependModule(filename); std::error_code ec; if (!std::filesystem::is_regular_file(moduleFile, ec)) { LastModuleError = "Module file could not be found: " + filename; ServerInstance->Logs.Critical("MODULE", LastModuleError); return false; } if (Modules.find(filename) != Modules.end()) { LastModuleError = "Module " + filename + " is already loaded, cannot load a module twice!"; ServerInstance->Logs.Critical("MODULE", LastModuleError); return false; } Module* newmod = nullptr; auto* newhandle = new DLLManager(moduleFile); ServiceList newservices; if (!defer) this->NewServices = &newservices; try { newmod = newhandle->CallInit(); this->NewServices = nullptr; if (newmod) { newmod->ModuleFile = filename; newmod->ModuleDLL = newhandle; Modules[filename] = newmod; if (!defer) { AttachAll(newmod); AddServices(newservices); ConfigStatus confstatus; newmod->init(); newmod->ReadConfig(confstatus); } ServerInstance->Logs.Normal("MODULE", "New module introduced: {} (version {}, properties {})", filename, newmod->GetVersion(), newmod->GetPropertyString()); } else { LastModuleError = "Unable to load " + filename + ": " + newhandle->LastError(); ServerInstance->Logs.Critical("MODULE", LastModuleError); delete newhandle; return false; } } catch (const CoreException& modexcept) { this->NewServices = nullptr; // failure in module constructor if (newmod) { DoSafeUnload(newmod); ServerInstance->GlobalCulls.AddItem(newhandle); } else delete newhandle; LastModuleError = "Unable to load " + filename + ": " + modexcept.GetReason(); ServerInstance->Logs.Critical("MODULE", LastModuleError); return false; } if (defer) return true; FOREACH_MOD(OnLoadModule, (newmod)); PrioritizeHooks(); return true; } /* We must load the modules AFTER initializing the socket engine, now */ void ModuleManager::LoadCoreModules(std::map<std::string, ServiceList>& servicemap) { fmt::print("Loading core modules "); fflush(stdout); try { for (const auto& entry : std::filesystem::directory_iterator(ServerInstance->Config->Paths.Module)) { if (!entry.is_regular_file()) continue; const std::string name = entry.path().filename().string(); if (!InspIRCd::Match(name, "core_*" DLL_EXTENSION)) continue; fmt::print("."); fflush(stdout); this->NewServices = &servicemap[name]; if (!Load(name, true)) { fmt::println(""); fmt::println("[{}] {}", fmt::styled("*", fmt::emphasis::bold | fmt::fg(fmt::terminal_color::red)), LastError()); fmt::println(""); ServerInstance->Exit(EXIT_FAILURE); } } } catch (const std::filesystem::filesystem_error& err) { fmt::println("failed: {}", err.what()); ServerInstance->Exit(EXIT_FAILURE); } fmt::println(""); } ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/src/modules.cpp����������������������������������������������������������������������0000664�0000000�0000000�00000065303�14771603147�0016321�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2019 iwalkalone <iwalkalone69@gmail.com> * Copyright (C) 2017-2024 Sadie Powell <sadie@witchery.services> * Copyright (C) 2013 Daniel Vassdal <shutter@canternet.org> * Copyright (C) 2013 Adam <Adam@anope.org> * Copyright (C) 2012-2016, 2018 Attila Molnar <attilamolnar@hush.com> * Copyright (C) 2012 Robby <robby@chatbelgie.be> * Copyright (C) 2009-2010 Daniel De Graaf <danieldg@inspircd.org> * Copyright (C) 2008 Thomas Stagner <aquanight@gmail.com> * Copyright (C) 2007 Robin Burchell <robin+git@viroteck.net> * Copyright (C) 2007 Oliver Lupton <om@inspircd.org> * Copyright (C) 2007 Dennis Friis <peavey@inspircd.org> * Copyright (C) 2006-2009 Craig Edwards <brain@inspircd.org> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include <fmt/color.h> #include "inspircd.h" #include "dynamic.h" #include "utility/map.h" static insp::intrusive_list<dynamic_reference_base>* dynrefs = nullptr; void dynamic_reference_base::reset_all() { if (!dynrefs) return; for (auto* dynref : *dynrefs) dynref->resolve(); } Module::Module(int mprops, const std::string& mdesc) : Module(mprops, "", mdesc) { } Module::Module(int mprops, const std::string& mversion, const std::string& mdesc) : description(mdesc) , properties(mprops) , version(mversion) { } Cullable::Result Module::Cull() { if (ModuleDLL) { ServerInstance->GlobalCulls.AddItem(ModuleDLL); ModuleDLL = nullptr; } return Cullable::Cull(); } void Module::CompareLinkData(const LinkData& otherdata, LinkDataDiff& diffs) { std::string unused; LinkData data; this->GetLinkData(data, unused); insp::map::difference(data, otherdata, diffs); } std::string Module::GetPropertyString() const { // D = VF_CORE ("default") // V = VF_VENDOR // C = VF_COMMON // O = VF_OPTCOMMON std::string propstr("DVCO"); size_t pos = 0; for (int mult = VF_CORE; mult <= VF_OPTCOMMON; mult *= 2, ++pos) if (!(this->properties & mult)) propstr[pos] = '-'; return propstr; } std::string Module::GetVersion() const { if (!version.empty()) return version; const auto* dll_version = ModuleDLL->GetVersion(); return dll_version ? dll_version : "unknown"; } void Module::DetachEvent(Implementation i) { ServerInstance->Modules.Detach(i, this); } void Module::GetLinkData(LinkData&, std::string&) { } void Module::Prioritize() { } void Module::ReadConfig(ConfigStatus& status) { } ModResult Module::OnSendSnotice(char& snomask, std::string& type, const std::string& message) { DetachEvent(I_OnSendSnotice); return MOD_RES_PASSTHRU; } void Module::OnUserConnect(LocalUser*) { DetachEvent(I_OnUserConnect); } ModResult Module::OnUserPreQuit(LocalUser*, std::string&, std::string&) { DetachEvent(I_OnUserPreQuit); return MOD_RES_PASSTHRU; } void Module::OnUserQuit(User*, const std::string&, const std::string&) { DetachEvent(I_OnUserQuit); } void Module::OnUserDisconnect(LocalUser*) { DetachEvent(I_OnUserDisconnect); } void Module::OnUserJoin(Membership*, bool, bool, CUList&) { DetachEvent(I_OnUserJoin); } void Module::OnPostJoin(Membership*) { DetachEvent(I_OnPostJoin); } void Module::OnUserPart(Membership*, std::string&, CUList&) { DetachEvent(I_OnUserPart); } void Module::OnPreRehash(User*, const std::string&) { DetachEvent(I_OnPreRehash); } void Module::OnModuleRehash(User*, const std::string&) { DetachEvent(I_OnModuleRehash); } ModResult Module::OnUserPreJoin(LocalUser*, Channel*, const std::string&, std::string&, const std::string&, bool) { DetachEvent(I_OnUserPreJoin); return MOD_RES_PASSTHRU; } void Module::OnMode(User*, User*, Channel*, const Modes::ChangeList&, ModeParser::ModeProcessFlag) { DetachEvent(I_OnMode); } ModResult Module::OnUserPreInvite(User*, User*, Channel*, time_t) { DetachEvent(I_OnUserPreInvite); return MOD_RES_PASSTHRU; } ModResult Module::OnUserPreMessage(User*, MessageTarget&, MessageDetails&) { DetachEvent(I_OnUserPreMessage); return MOD_RES_PASSTHRU; } ModResult Module::OnUserPreNick(LocalUser*, const std::string&) { DetachEvent(I_OnUserPreNick); return MOD_RES_PASSTHRU; } void Module::OnUserPostNick(User*, const std::string&) { DetachEvent(I_OnUserPostNick); } ModResult Module::OnPreMode(User*, User*, Channel*, Modes::ChangeList&) { DetachEvent(I_OnPreMode); return MOD_RES_PASSTHRU; } ModResult Module::OnKill(User*, User*, const std::string&) { DetachEvent(I_OnKill); return MOD_RES_PASSTHRU; } void Module::OnLoadModule(Module*) { DetachEvent(I_OnLoadModule); } void Module::OnUnloadModule(Module*) { DetachEvent(I_OnUnloadModule); } void Module::OnBackgroundTimer(time_t) { DetachEvent(I_OnBackgroundTimer); } ModResult Module::OnPreCommand(std::string&, CommandBase::Params&, LocalUser*, bool) { DetachEvent(I_OnPreCommand); return MOD_RES_PASSTHRU; } void Module::OnPostCommand(Command*, const CommandBase::Params&, LocalUser*, CmdResult, bool) { DetachEvent(I_OnPostCommand); } void Module::OnCommandBlocked(const std::string&, const CommandBase::Params&, LocalUser*) { DetachEvent(I_OnCommandBlocked); } void Module::OnUserInit(LocalUser*) { DetachEvent(I_OnUserInit); } void Module::OnUserPostInit(LocalUser*) { DetachEvent(I_OnUserPostInit); } ModResult Module::OnCheckReady(LocalUser*) { DetachEvent(I_OnCheckReady); return MOD_RES_PASSTHRU; } ModResult Module::OnUserRegister(LocalUser*) { DetachEvent(I_OnUserRegister); return MOD_RES_PASSTHRU; } ModResult Module::OnUserPreKick(User*, Membership*, const std::string&) { DetachEvent(I_OnUserPreKick); return MOD_RES_PASSTHRU; } void Module::OnUserKick(User*, Membership*, const std::string&, CUList&) { DetachEvent(I_OnUserKick); } ModResult Module::OnRawMode(User*, Channel*, const Modes::Change&) { DetachEvent(I_OnRawMode); return MOD_RES_PASSTHRU; } ModResult Module::OnCheckInvite(User*, Channel*) { DetachEvent(I_OnCheckInvite); return MOD_RES_PASSTHRU; } ModResult Module::OnCheckKey(User*, Channel*, const std::string&) { DetachEvent(I_OnCheckKey); return MOD_RES_PASSTHRU; } ModResult Module::OnCheckLimit(User*, Channel*) { DetachEvent(I_OnCheckLimit); return MOD_RES_PASSTHRU; } ModResult Module::OnCheckChannelBan(User*, Channel*) { DetachEvent(I_OnCheckChannelBan); return MOD_RES_PASSTHRU; } ModResult Module::OnCheckBan(User*, Channel*, const std::string&) { DetachEvent(I_OnCheckBan); return MOD_RES_PASSTHRU; } ModResult Module::OnPreTopicChange(User*, Channel*, const std::string&) { DetachEvent(I_OnPreTopicChange); return MOD_RES_PASSTHRU; } ModResult Module::OnCheckPassword(const std::string&, const std::string&, const std::string&) { DetachEvent(I_OnCheckPassword); return MOD_RES_PASSTHRU; } void Module::OnPostConnect(User*) { DetachEvent(I_OnPostConnect); } void Module::OnUserPostMessage(User*, const MessageTarget&, const MessageDetails&) { DetachEvent(I_OnUserPostMessage); } void Module::OnUserMessageBlocked(User*, const MessageTarget&, const MessageDetails&) { DetachEvent(I_OnUserMessageBlocked); } void Module::OnUserInvite(User*, User*, Channel*, time_t, ModeHandler::Rank, CUList&) { DetachEvent(I_OnUserInvite); } void Module::OnPostTopicChange(User*, Channel*, const std::string&) { DetachEvent(I_OnPostTopicChange); } void Module::OnDecodeMetadata(Extensible*, const std::string&, const std::string&) { DetachEvent(I_OnDecodeMetadata); } void Module::OnChangeHost(User*, const std::string&) { DetachEvent(I_OnChangeHost); } void Module::OnChangeRealHost(User*, const std::string&) { DetachEvent(I_OnChangeRealHost); } void Module::OnPostChangeRealHost(User*) { DetachEvent(I_OnPostChangeRealHost); } void Module::OnChangeRealName(User*, const std::string&) { DetachEvent(I_OnChangeRealName); } void Module::OnChangeUser(User*, const std::string&) { DetachEvent(I_OnChangeUser); } void Module::OnChangeRealUser(User*, const std::string&) { DetachEvent(I_OnChangeRealUser); } void Module::OnPostChangeRealUser(User*) { DetachEvent(I_OnPostChangeRealUser); } void Module::OnAddLine(User*, XLine*) { DetachEvent(I_OnAddLine); } void Module::OnDelLine(User*, XLine*) { DetachEvent(I_OnDelLine); } void Module::OnExpireLine(XLine*) { DetachEvent(I_OnExpireLine); } void Module::OnCleanup(ExtensionType, Extensible*) { } ModResult Module::OnChannelPreDelete(Channel*) { DetachEvent(I_OnChannelPreDelete); return MOD_RES_PASSTHRU; } void Module::OnChannelDelete(Channel*) { DetachEvent(I_OnChannelDelete); } void Module::OnBuildNeighborList(User*, User::NeighborList&, User::NeighborExceptions&) { DetachEvent(I_OnBuildNeighborList); } void Module::OnGarbageCollect() { DetachEvent(I_OnGarbageCollect); } void Module::OnUserMessage(User*, const MessageTarget&, const MessageDetails&) { DetachEvent(I_OnUserMessage); } ModResult Module::OnNumeric(User*, const Numeric::Numeric&) { DetachEvent(I_OnNumeric); return MOD_RES_PASSTHRU; } ModResult Module::OnAcceptConnection(int, ListenSocket*, const irc::sockets::sockaddrs&, const irc::sockets::sockaddrs&) { DetachEvent(I_OnAcceptConnection); return MOD_RES_PASSTHRU; } void Module::OnChangeRemoteAddress(LocalUser*) { DetachEvent(I_OnChangeRemoteAddress); } void Module::OnServiceAdd(ServiceProvider&) { DetachEvent(I_OnServiceAdd); } void Module::OnServiceDel(ServiceProvider&) { DetachEvent(I_OnServiceDel); } ModResult Module::OnUserWrite(LocalUser*, ClientProtocol::Message&) { DetachEvent(I_OnUserWrite); return MOD_RES_PASSTHRU; } void Module::OnShutdown(const std::string& reason) { DetachEvent(I_OnShutdown); } ModResult Module::OnPreOperLogin(LocalUser*, const std::shared_ptr<OperAccount>&, bool) { DetachEvent(I_OnPreOperLogin); return MOD_RES_PASSTHRU; } void Module::OnOperLogin(User*, const std::shared_ptr<OperAccount>&, bool) { DetachEvent(I_OnOperLogin); } void Module::OnPostOperLogin(User*, bool) { DetachEvent(I_OnPostOperLogin); } void Module::OnOperLogout(User*) { DetachEvent(I_OnOperLogout); } void Module::OnPostOperLogout(User*, const std::shared_ptr<OperAccount>&) { DetachEvent(I_OnPostOperLogout); } ModResult Module::OnPreChangeConnectClass(LocalUser*, const std::shared_ptr<ConnectClass>&, std::optional<Numeric::Numeric>&) { DetachEvent(I_OnPreChangeConnectClass); return MOD_RES_PASSTHRU; } void Module::OnChangeConnectClass(LocalUser*, const std::shared_ptr<ConnectClass>&, bool) { DetachEvent(I_OnChangeConnectClass); } void Module::OnPostChangeConnectClass(LocalUser*, bool) { DetachEvent(I_OnPostChangeConnectClass); } ServiceProvider::ServiceProvider(Module* Creator, const std::string& Name, ServiceType Type) : creator(Creator) , name(Name) , service(Type) { if ((ServerInstance) && (ServerInstance->Modules.NewServices)) ServerInstance->Modules.NewServices->push_back(this); } void ServiceProvider::DisableAutoRegister() { if ((ServerInstance) && (ServerInstance->Modules.NewServices)) stdalgo::erase(*ServerInstance->Modules.NewServices, this); } const char* ServiceProvider::GetTypeString() const { switch (service) { case SERVICE_COMMAND: return "command"; case SERVICE_MODE: return "mode"; case SERVICE_METADATA: return "metadata"; case SERVICE_IOHOOK: return "iohook"; case SERVICE_DATA: return "data service"; case SERVICE_CUSTOM: return "module service"; } return "unknown service"; } bool ModuleManager::Attach(Implementation i, Module* mod) { if (stdalgo::isin(EventHandlers[i], mod)) return false; EventHandlers[i].push_back(mod); return true; } bool ModuleManager::Detach(Implementation i, Module* mod) { return stdalgo::erase(EventHandlers[i], mod); } void ModuleManager::Attach(const Implementation* i, Module* mod, size_t sz) { for (size_t n = 0; n < sz; ++n) Attach(i[n], mod); } void ModuleManager::Detach(const Implementation* i, Module* mod, size_t sz) { for (size_t n = 0; n < sz; ++n) Detach(i[n], mod); } void ModuleManager::AttachAll(Module* mod) { for (size_t i = 0; i != I_END; ++i) Attach(static_cast<Implementation>(i), mod); } void ModuleManager::DetachAll(Module* mod) { for (size_t n = 0; n != I_END; ++n) Detach(static_cast<Implementation>(n), mod); } void ModuleManager::SetPriority(Module* mod, Priority s) { for (size_t n = 0; n != I_END; ++n) SetPriority(mod, static_cast<Implementation>(n), s); } bool ModuleManager::SetPriority(Module* mod, Implementation i, Priority s, Module* which) { /** To change the priority of a module, we first find its position in the vector, * then we find the position of the other modules in the vector that this module * wants to be before/after. We pick off either the first or last of these depending * on which they want, and we make sure our module is *at least* before or after * the first or last of this subset, depending again on the type of priority. */ size_t my_pos = 0; /* Locate our module. This is O(n) but it only occurs on module load so we're * not too bothered about it */ for (size_t x = 0; x != EventHandlers[i].size(); ++x) { if (EventHandlers[i][x] == mod) { my_pos = x; goto found_src; } } /* Eh? this module doesnt exist, probably trying to set priority on an event * they're not attached to. */ return false; found_src: // The modules registered for a hook are called in reverse order (to allow for easier removal // of list entries while looping), meaning that the Priority given to us has the exact opposite effect // on the list, e.g.: PRIORITY_BEFORE will actually put 'mod' after 'which', etc. size_t swap_pos; switch (s) { case PRIORITY_LAST: { if (prioritizationState != PRIO_STATE_FIRST) return true; swap_pos = 0; break; } case PRIORITY_FIRST: { if (prioritizationState != PRIO_STATE_FIRST) return true; swap_pos = EventHandlers[i].size() - 1; break; } case PRIORITY_BEFORE: { /* Find the latest possible position, only searching AFTER our position */ for (size_t x = EventHandlers[i].size() - 1; x > my_pos; --x) { if (EventHandlers[i][x] == which) { swap_pos = x; goto swap_now; } } // didn't find it - either not loaded or we're already after return true; } /* Place this module before a set of other modules */ case PRIORITY_AFTER: { for (size_t x = 0; x < my_pos; ++x) { if (EventHandlers[i][x] == which) { swap_pos = x; goto swap_now; } } // didn't find it - either not loaded or we're already before return true; } default: return true; // Should never happen. } swap_now: /* Do we need to swap? */ if (swap_pos != my_pos) { // We are going to change positions; we'll need to run again to verify all requirements if (prioritizationState == PRIO_STATE_LAST) prioritizationState = PRIO_STATE_AGAIN; /* Suggestion from Phoenix, "shuffle" the modules to better retain call order */ int increment = 1; if (my_pos > swap_pos) increment = -1; for (size_t j = my_pos; j != swap_pos; j += increment) { if ((j + increment > EventHandlers[i].size() - 1) || ((increment == -1) && (j == 0))) continue; std::swap(EventHandlers[i][j], EventHandlers[i][j+increment]); } } return true; } bool ModuleManager::PrioritizeHooks() { /* We give every module a chance to re-prioritize when we introduce a new one, * not just the one that's loading, as the new module could affect the preference * of others */ for (int tries = 0; tries < 20; tries++) { prioritizationState = tries > 0 ? PRIO_STATE_LAST : PRIO_STATE_FIRST; for (const auto& [_, mod] : Modules) mod->Prioritize(); if (prioritizationState == PRIO_STATE_LAST) break; if (tries == 19) { ServerInstance->Logs.Debug("MODULE", "Hook priority dependency loop detected"); return false; } } return true; } bool ModuleManager::CanUnload(Module* mod) { std::map<std::string, Module*>::iterator modfind = Modules.find(mod->ModuleFile); if ((modfind == Modules.end()) || (modfind->second != mod) || (mod->dying)) { LastModuleError = "Module " + mod->ModuleFile + " is not loaded, cannot unload it!"; ServerInstance->Logs.Critical("MODULE", LastModuleError); return false; } mod->dying = true; return true; } void ModuleManager::UnregisterModes(Module* mod, ModeType modetype) { const ModeParser::ModeHandlerMap& modes = ServerInstance->Modes.GetModes(modetype); for (ModeParser::ModeHandlerMap::const_iterator i = modes.begin(); i != modes.end(); ) { ModeHandler* const mh = i->second; ++i; if (mh->creator == mod) this->DelService(*mh); } } void ModuleManager::DoSafeUnload(Module* mod) { // First, notify all modules that a module is about to be unloaded, so in case // they pass execution to the soon to be unloaded module, it will happen now, // i.e. before we unregister the services of the module being unloaded FOREACH_MOD(OnUnloadModule, (mod)); std::map<std::string, Module*>::iterator modfind = Modules.find(mod->ModuleFile); // Unregister modes before extensions because modes may require their extension to show the mode being unset UnregisterModes(mod, MODETYPE_USER); UnregisterModes(mod, MODETYPE_CHANNEL); std::vector<ExtensionItem*> items; ServerInstance->Extensions.BeginUnregister(modfind->second, items); /* Give the module a chance to tidy out all its metadata */ const ChannelMap& chans = ServerInstance->Channels.GetChans(); for (ChannelMap::const_iterator c = chans.begin(); c != chans.end(); ) { Channel* chan = c->second; ++c; mod->OnCleanup(ExtensionType::CHANNEL, chan); chan->UnhookExtensions(items); for (const auto& [_, memb] : chan->GetUsers()) { mod->OnCleanup(ExtensionType::MEMBERSHIP, memb); memb->UnhookExtensions(items); } } const UserMap& users = ServerInstance->Users.GetUsers(); for (UserMap::const_iterator u = users.begin(); u != users.end(); ) { User* user = u->second; // The module may quit the user (e.g. TLS mod unloading) and that will remove it from the container ++u; mod->OnCleanup(ExtensionType::USER, user); user->UnhookExtensions(items); } for (DataProviderMap::iterator i = DataProviders.begin(); i != DataProviders.end(); ) { DataProviderMap::iterator curr = i++; if (curr->second->creator == mod) { DataProviders.erase(curr); FOREACH_MOD(OnServiceDel, (*curr->second)); } } dynamic_reference_base::reset_all(); DetachAll(mod); Modules.erase(modfind); ServerInstance->GlobalCulls.AddItem(mod); ServerInstance->Logs.Normal("MODULE", "The {} module was unloaded", mod->ModuleFile); } void ModuleManager::UnloadAll() { /* We do this more than once, so that any service providers get a * chance to be unhooked by the modules using them, but then get * a chance to be removed themselves. * * Note: this deliberately does NOT delete the DLLManager objects */ for (int tries = 0; tries < 4; tries++) { std::map<std::string, Module*>::iterator i = Modules.begin(); while (i != Modules.end()) { std::map<std::string, Module*>::iterator me = i++; if (CanUnload(me->second)) { DoSafeUnload(me->second); } } ServerInstance->GlobalCulls.Apply(); } } namespace { struct UnloadAction final : public ActionBase { Module* const mod; UnloadAction(Module* m) : mod(m) { } void Call() override { ServerInstance->Modules.DoSafeUnload(mod); ServerInstance->GlobalCulls.Apply(); ServerInstance->GlobalCulls.AddItem(this); } }; } bool ModuleManager::Unload(Module* mod) { if (!CanUnload(mod)) return false; ServerInstance->AtomicActions.AddAction(new UnloadAction(mod)); return true; } void ModuleManager::LoadAll() { std::map<std::string, ServiceList> servicemap; LoadCoreModules(servicemap); // Step 1: load all of the modules. for (const auto& shortname : ServerInstance->Config->GetModules()) { // Skip modules which are already loaded. const std::string name = ExpandModName(shortname); if (Modules.find(name) != Modules.end()) continue; this->NewServices = &servicemap[name]; fmt::println("[{}] Loading module:\t{}", fmt::styled("*", fmt::emphasis::bold | fmt::fg(fmt::terminal_color::green)), name); if (!this->Load(name, true)) { fmt::println(""); fmt::println("[{}] {}", fmt::styled("*", fmt::emphasis::bold | fmt::fg(fmt::terminal_color::red)), LastError()); fmt::println(""); ServerInstance->Exit(EXIT_FAILURE); } } // Step 2: initialize the modules and register their services. for (const auto& [modname, mod] : Modules) { try { ServerInstance->Logs.Debug("MODULE", "Initializing {}", modname); AttachAll(mod); AddServices(servicemap[modname]); mod->init(); } catch (const CoreException& modexcept) { LastModuleError = "Unable to initialize " + modname + ": " + modexcept.GetReason(); ServerInstance->Logs.Critical("MODULE", LastModuleError); fmt::println(""); fmt::println("[{}] {}", fmt::styled("*", fmt::emphasis::bold | fmt::fg(fmt::terminal_color::red)), LastModuleError); fmt::println(""); ServerInstance->Exit(EXIT_FAILURE); } } this->NewServices = nullptr; ConfigStatus confstatus(nullptr, true); // Step 3: Read the configuration for the modules. This must be done as part of // its own step so that services provided by modules can be registered before // the configuration is read. for (const auto& [modname, mod] : Modules) { try { ServerInstance->Logs.Debug("MODULE", "Reading configuration for {}", modname); mod->ReadConfig(confstatus); } catch (const CoreException& modexcept) { LastModuleError = "Unable to read the configuration for " + modname + ": " + modexcept.GetReason(); ServerInstance->Logs.Critical("MODULE", LastModuleError); fmt::println(""); fmt::println("[{}] {}", fmt::styled("*", fmt::emphasis::bold | fmt::fg(fmt::terminal_color::red)), LastModuleError); fmt::println(""); ServerInstance->Exit(EXIT_FAILURE); } } if (!PrioritizeHooks()) ServerInstance->Exit(EXIT_FAILURE); } std::string& ModuleManager::LastError() { return LastModuleError; } void ModuleManager::AddServices(const ServiceList& list) { for (auto* service : list) AddService(*service); } void ModuleManager::AddService(ServiceProvider& item) { ServerInstance->Logs.Debug("SERVICE", "Adding {} {} provided by {}", item.name, item.GetTypeString(), item.creator ? item.creator->ModuleFile : "the core"); switch (item.service) { case SERVICE_DATA: case SERVICE_IOHOOK: { if ((!item.name.compare(0, 5, "mode/", 5)) || (!item.name.compare(0, 6, "umode/", 6))) throw ModuleException(item.creator, "The \"mode/\" and the \"umode\" service name prefixes are reserved."); DataProviders.emplace(item.name, &item); std::string::size_type slash = item.name.find('/'); if (slash != std::string::npos) { // Also register foo/bar as foo. DataProviders.emplace(item.name.substr(0, slash), &item); } dynamic_reference_base::reset_all(); break; } default: item.RegisterService(); } FOREACH_MOD(OnServiceAdd, (item)); } void ModuleManager::DelService(ServiceProvider& item) { ServerInstance->Logs.Debug("SERVICE", "Deleting {} {} provided by {}", item.name, item.GetTypeString(), item.creator ? item.creator->ModuleFile : "the core"); switch (item.service) { case SERVICE_MODE: if (!ServerInstance->Modes.DelMode(static_cast<ModeHandler*>(&item))) throw ModuleException(item.creator, "Mode " + std::string(item.name) + " does not exist."); [[fallthrough]]; case SERVICE_DATA: case SERVICE_IOHOOK: { DelReferent(&item); break; } default: throw ModuleException(item.creator, "Cannot delete unknown service type"); } FOREACH_MOD(OnServiceDel, (item)); } ServiceProvider* ModuleManager::FindService(ServiceType type, const std::string& name) { switch (type) { case SERVICE_DATA: case SERVICE_IOHOOK: { DataProviderMap::iterator i = DataProviders.find(name); if (i != DataProviders.end() && i->second->service == type) return i->second; return nullptr; } // TODO implement finding of the other types default: throw CoreException("Cannot find unknown service type"); } } std::string ModuleManager::ExpandModName(const std::string& modname) { const static size_t extlen = strlen(DLL_EXTENSION); std::string fullname; if (modname.compare(0, 5, "core_") != 0 && modname.compare(0, 2, "m_") != 0) fullname.append("m_"); fullname.append(modname); if (modname.length() < extlen || modname.compare(modname.size() - extlen, extlen, DLL_EXTENSION) != 0) fullname.append(DLL_EXTENSION); return fullname; } std::string ModuleManager::ShrinkModName(const std::string& modname) { const static size_t extlen = strlen(DLL_EXTENSION); size_t startpos = modname.compare(0, 2, "m_", 2) ? 0 : 2; size_t endpos = modname.length() < extlen || modname.compare(modname.length() - extlen, extlen, DLL_EXTENSION, extlen) ? 0 : extlen; return modname.substr(startpos, modname.length() - endpos - startpos); } dynamic_reference_base::dynamic_reference_base(Module* Creator, const std::string& Name) : name(Name) , creator(Creator) { if (!dynrefs) dynrefs = new insp::intrusive_list<dynamic_reference_base>; dynrefs->push_front(this); // Resolve unless there is no ModuleManager (part of class InspIRCd) if (ServerInstance) resolve(); } dynamic_reference_base::~dynamic_reference_base() { dynrefs->erase(this); if (dynrefs->empty()) stdalgo::delete_zero(dynrefs); } void dynamic_reference_base::SetProvider(const std::string& newname) { name = newname; resolve(); } void dynamic_reference_base::ClearProvider() { name.clear(); value = nullptr; } void dynamic_reference_base::resolve() { // Because find() may return any element with a matching key in case count(key) > 1 use lower_bound() // to ensure a dynref with the same name as another one resolves to the same object ModuleManager::DataProviderMap::iterator i = ServerInstance->Modules.DataProviders.lower_bound(name); if ((i != ServerInstance->Modules.DataProviders.end()) && (i->first == this->name)) { ServiceProvider* newvalue = i->second; if (value != newvalue) { value = newvalue; if (hook) hook->OnCapture(); } } else value = nullptr; } Module* ModuleManager::Find(const std::string& name) { std::map<std::string, Module*>::const_iterator modfind = Modules.find(ExpandModName(name)); if (modfind == Modules.end()) return nullptr; else return modfind->second; } void ModuleManager::AddReferent(const std::string& name, ServiceProvider* service) { DataProviders.emplace(name, service); dynamic_reference_base::reset_all(); } void ModuleManager::DelReferent(ServiceProvider* service) { for (DataProviderMap::iterator i = DataProviders.begin(); i != DataProviders.end(); ) { ServiceProvider* curr = i->second; if (curr == service) DataProviders.erase(i++); else ++i; } dynamic_reference_base::reset_all(); } �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/src/modules/�������������������������������������������������������������������������0000775�0000000�0000000�00000000000�14771603147�0015606�5����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/src/modules/extra/�������������������������������������������������������������������0000775�0000000�0000000�00000000000�14771603147�0016731�5����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/src/modules/extra/README�������������������������������������������������������������0000664�0000000�0000000�00000002006�14771603147�0017607�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������This directory stores modules which require external libraries to compile. For example, m_regex_pcre2 requires the PCRE2 library. To compile any of these modules first ensure you have the required dependencies (read the online documentation at https://docs.inspircd.org) and then symlink the .cpp file from this directory into the parent directory (src/modules/). Alternatively, use the command: ./configure --enable-extras=m_extra.cpp, which will automatically take care of symlinking the module of that name and any headers it needs from the extras directory. You can also use ./configure --list-extras to see what modules are available, and whether they are enabled or not. You still are responsible for resolving any external dependencies however (ie, PCRE, MySQL, GnuTLS, etc). NOTE: Some modules require you to copy other dependencies too, such as a related header. If you get missing header errors when building these modules, check that the header is not within modules/extra before checking for external dependencies. ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/src/modules/extra/m_argon2.cpp�������������������������������������������������������0000664�0000000�0000000�00000011167�14771603147�0021147�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2020-2024 Sadie Powell <sadie@witchery.services> * Copyright (C) 2020 Daniel Vassdal <shutter@canternet.org> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ /// $CompilerFlags: find_compiler_flags("libargon2") /// $LinkerFlags: find_linker_flags("libargon2") /// $PackageInfo: require_system("alpine") argon2-dev pkgconf /// $PackageInfo: require_system("arch") argon2 pkgconf /// $PackageInfo: require_system("darwin") argon2 pkg-config /// $PackageInfo: require_system("debian~") libargon2-dev pkg-config #include "inspircd.h" #include "modules/hash.h" #include <argon2.h> class ProviderConfig final { public: uint32_t iterations; uint32_t memory; uint32_t outlen; uint32_t saltlen; uint32_t threads; ProviderConfig() { // Nothing interesting happens here. } ProviderConfig(const std::string& tagname, ProviderConfig* def) { const auto& tag = ServerInstance->Config->ConfValue(tagname); uint32_t def_iterations = def ? def->iterations : 3; this->iterations = tag->getNum<uint32_t>("iterations", def_iterations, 1); uint32_t def_memory = def ? def->memory : 131072; // 128 MiB this->memory = tag->getNum<uint32_t>("memory", def_memory, ARGON2_MIN_MEMORY, ARGON2_MAX_MEMORY); uint32_t def_outlen = def ? def->outlen : 32; this->outlen = tag->getNum<int32_t>("length", def_outlen, ARGON2_MIN_OUTLEN, ARGON2_MAX_OUTLEN); uint32_t def_saltlen = def ? def->saltlen : 16; this->saltlen = tag->getNum<uint32_t>("saltlength", def_saltlen, ARGON2_MIN_SALT_LENGTH, ARGON2_MAX_SALT_LENGTH); uint32_t def_threads = def ? def->threads : 1; this->threads = tag->getNum<uint32_t>("threads", def_threads, ARGON2_MIN_THREADS, ARGON2_MAX_THREADS); } }; class HashArgon2 final : public HashProvider { private: const Argon2_type argon2Type; public: ProviderConfig config; bool Compare(const std::string& input, const std::string& hash) override { int result = argon2_verify( hash.c_str(), input.c_str(), input.length(), argon2Type); return result == ARGON2_OK; } std::string GenerateRaw(const std::string& data) override { std::vector<char> salt(config.saltlen); ServerInstance->GenRandom(salt.data(), salt.size()); size_t encodedLen = argon2_encodedlen( config.iterations, config.memory, config.threads, config.saltlen, config.outlen, argon2Type); std::vector<char> raw_data(config.outlen); std::vector<char> encoded_data(encodedLen + 1); int argonResult = argon2_hash( config.iterations, config.memory, config.threads, data.c_str(), data.length(), salt.data(), salt.size(), raw_data.data(), raw_data.size(), encoded_data.data(), encoded_data.size(), argon2Type, ARGON2_VERSION_NUMBER); if (argonResult != ARGON2_OK) throw ModuleException(creator, "Argon2 hashing failed: " + std::string(argon2_error_message(argonResult))); // This isn't the raw version, but we don't have // the facilities to juggle around the extra state required // to do anything useful with them if we don't encode them. // So we pretend this is the raw version, and instead make // ToPrintable return its input. return std::string(encoded_data.data(), encoded_data.size()); } std::string ToPrintable(const std::string& raw) override { return raw; } HashArgon2(Module* parent, const std::string& hashName, Argon2_type type) : HashProvider(parent, hashName) , argon2Type(type) { } }; class ModuleArgon2 final : public Module { private: HashArgon2 argon2i; HashArgon2 argon2d; HashArgon2 argon2id; public: ModuleArgon2() : Module(VF_VENDOR, "Allows other modules to generate Argon2 hashes.") , argon2i(this, "argon2i", Argon2_i) , argon2d(this, "argon2d", Argon2_d) , argon2id(this, "argon2id", Argon2_id) { } void ReadConfig(ConfigStatus& status) override { ProviderConfig defaultConfig("argon2", nullptr); argon2i.config = ProviderConfig("argon2i", &defaultConfig); argon2d.config = ProviderConfig("argon2d", &defaultConfig); argon2id.config = ProviderConfig("argon2id", &defaultConfig); } }; MODULE_INIT(ModuleArgon2) ���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/src/modules/extra/m_geo_maxmind.cpp��������������������������������������������������0000664�0000000�0000000�00000014656�14771603147�0022254�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2019-2025 Sadie Powell <sadie@witchery.services> * Copyright (C) 2019 Matt Schatz <genius3000@g3k.solutions> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ /// $CompilerFlags: find_compiler_flags("libmaxminddb") /// $LinkerFlags: find_linker_flags("libmaxminddb") /// $PackageInfo: require_system("alpine") libmaxminddb-dev pkgconf /// $PackageInfo: require_system("arch") libmaxminddb pkgconf /// $PackageInfo: require_system("darwin") libmaxminddb pkg-config /// $PackageInfo: require_system("debian~") libmaxminddb-dev pkg-config /// $PackageInfo: require_system("rhel~") libmaxminddb-devel pkgconfig #ifdef _WIN32 # pragma comment(lib, "maxminddb.lib") #endif #include <maxminddb.h> #include "inspircd.h" #include "extension.h" #include "modules/geolocation.h" class GeolocationExtItem final : public ExtensionItem { public: GeolocationExtItem(Module* parent) : ExtensionItem(parent, "geolocation", ExtensionType::USER) { } std::string ToHuman(const Extensible* container, void* item) const noexcept override { Geolocation::Location* location = static_cast<Geolocation::Location*>(item); return location->GetName() + " [" + location->GetCode() + "]"; } void Delete(Extensible* container, void* item) override { Geolocation::Location* old = static_cast<Geolocation::Location*>(item); if (old) old->refcount_dec(); } Geolocation::Location* Get(const User* user) const { return static_cast<Geolocation::Location*>(GetRaw(user)); } void Set(User* user, Geolocation::Location* value) { value->refcount_inc(); Delete(user, SetRaw(user, value)); } void Unset(User* user) { Delete(user, UnsetRaw(user)); } }; typedef insp::flat_map<std::string, Geolocation::Location*> LocationMap; class GeolocationAPIImpl final : public Geolocation::APIBase { public: GeolocationExtItem ext; LocationMap locations; MMDB_s mmdb; GeolocationAPIImpl(Module* parent) : Geolocation::APIBase(parent) , ext(parent) { } Geolocation::Location* GetLocation(User* user) override { // If we have the location cached then use that instead. Geolocation::Location* location = ext.Get(user); if (location) return location; // Attempt to locate this user. location = GetLocation(user->client_sa); if (!location) return nullptr; // We found the user. Cache their location for future use. ext.Set(user, location); return location; } Geolocation::Location* GetLocation(irc::sockets::sockaddrs& sa) override { // Skip trying to look up a UNIX socket. if (!sa.is_ip()) return nullptr; // Attempt to look up the socket address. int result; MMDB_lookup_result_s lookup = MMDB_lookup_sockaddr(&mmdb, &sa.sa, &result); if (result != MMDB_SUCCESS || !lookup.found_entry) return nullptr; // Attempt to retrieve the country code. MMDB_entry_data_s country_code; result = MMDB_get_value(&lookup.entry, &country_code, "country", "iso_code", nullptr); if (result != MMDB_SUCCESS || !country_code.has_data || country_code.type != MMDB_DATA_TYPE_UTF8_STRING || country_code.data_size != 2) return nullptr; // If the country has been seen before then use our cached Location object. const std::string code(country_code.utf8_string, country_code.data_size); LocationMap::iterator liter = locations.find(code); if (liter != locations.end()) return liter->second; // Attempt to retrieve the country name. MMDB_entry_data_s country_name; result = MMDB_get_value(&lookup.entry, &country_name, "country", "names", "en", nullptr); if (result != MMDB_SUCCESS || !country_name.has_data || country_name.type != MMDB_DATA_TYPE_UTF8_STRING) return nullptr; // Create a Location object and cache it. const std::string cname(country_name.utf8_string, country_name.data_size); auto* location = new Geolocation::Location(code, cname); locations[code] = location; return location; } }; class ModuleGeoMaxMind final : public Module { private: GeolocationAPIImpl geoapi; public: ModuleGeoMaxMind() : Module(VF_VENDOR, "Allows the server to perform geolocation lookups on both IP addresses and users.") , geoapi(this) { memset(&geoapi.mmdb, 0, sizeof(geoapi.mmdb)); } ~ModuleGeoMaxMind() override { MMDB_close(&geoapi.mmdb); } void init() override { ServerInstance->Logs.Normal(MODNAME, "{} is running against libmaxminddb version {}", MODNAME, MMDB_lib_version()); } void ReadConfig(ConfigStatus& status) override { const auto& tag = ServerInstance->Config->ConfValue("maxmind"); const std::string file = ServerInstance->Config->Paths.PrependConfig(tag->getString("file", "GeoLite2-Country.mmdb", 1)); // Try to read the new database. MMDB_s mmdb; int result = MMDB_open(file.c_str(), MMDB_MODE_MMAP, &mmdb); if (result != MMDB_SUCCESS) throw ModuleException(this, "Unable to load the MaxMind database ({}): {}", file, MMDB_strerror(result)); // Swap the new database with the old database. std::swap(mmdb, geoapi.mmdb); // Free the old database. MMDB_close(&mmdb); } void OnGarbageCollect() override { for (LocationMap::iterator iter = geoapi.locations.begin(); iter != geoapi.locations.end(); ) { Geolocation::Location* location = iter->second; if (location->GetUseCount()) { ServerInstance->Logs.Debug(MODNAME, "Preserving geolocation data for {} ({}) with use count {}... ", location->GetName(), location->GetCode(), location->GetUseCount()); iter++; } else { ServerInstance->Logs.Debug(MODNAME, "Deleting unused geolocation data for {} ({})", location->GetName(), location->GetCode()); delete location; iter = geoapi.locations.erase(iter); } } geoapi.locations.shrink_to_fit(); } void OnChangeRemoteAddress(LocalUser* user) override { // Unset the extension so that the location of this user is looked // up again next time it is requested. geoapi.ext.Unset(user); } }; MODULE_INIT(ModuleGeoMaxMind) ����������������������������������������������������������������������������������inspircd-4.7.0/src/modules/extra/m_ldap.cpp���������������������������������������������������������0000664�0000000�0000000�00000044142�14771603147�0020676�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2021 Dominic Hamon * Copyright (C) 2020 Joel Sing <joel@sing.id.au> * Copyright (C) 2019 linuxdaemon <linuxdaemon.irc@gmail.com> * Copyright (C) 2016-2017, 2019-2024 Sadie Powell <sadie@witchery.services> * Copyright (C) 2014 Attila Molnar <attilamolnar@hush.com> * Copyright (C) 2013-2015 Adam <Adam@anope.org> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ /// $CompilerFlags: find_compiler_flags("lber" "") find_compiler_flags("ldap" "") /// $LinkerFlags: find_linker_flags("lber" "-llber") find_linker_flags("ldap" "-lldap_r") /// $PackageInfo: require_system("alpine") openldap-dev pkgconf /// $PackageInfo: require_system("arch") libldap pkgconf /// $PackageInfo: require_system("darwin") openldap pkg-config /// $PackageInfo: require_system("debian~") libldap2-dev pkg-config /// $PackageInfo: require_system("rhel~") openldap-devel pkg-config #include "inspircd.h" #include "modules/ldap.h" #include "threadsocket.h" #include "utility/string.h" #if defined LDAP_API_FEATURE_X_OPENLDAP_REENTRANT && !LDAP_API_FEATURE_X_OPENLDAP_REENTRANT # error InspIRCd requires OpenLDAP to be built as reentrant. #endif // Ignore OpenLDAP deprecation warnings on OS X Yosemite and newer. #if defined __APPLE__ # pragma GCC diagnostic push # pragma GCC diagnostic ignored "-Wdeprecated-declarations" #endif #ifdef _WIN32 # include <Wininet.h> # include <Winldap.h> # include <WinBer.h> # define LDAP_OPT_SUCCESS LDAP_SUCCESS # define LDAP_OPT_NETWORK_TIMEOUT LDAP_OPT_SEND_TIMEOUT # define LDAP_STR(X) const_cast<PSTR>((X).c_str()) # define LDAP_SASL_SIMPLE static_cast<PSTR>(0) # define LDAP_TIME(X) reinterpret_cast<PLDAP_TIMEVAL>(&(X)) # define LDAP_VENDOR_VERSION_MAJOR (LDAP_VERSION / 100) # define LDAP_VENDOR_VERSION_MINOR (LDAP_VERSION / 10 % 10) # define LDAP_VENDOR_VERSION_PATCH (LDAP_VERSION / 10) # define ldap_first_message ldap_first_entry # define ldap_next_message ldap_next_entry # define ldap_unbind_ext(LDAP, UNUSED1, UNUSED2) ldap_unbind(LDAP) # pragma comment(lib, "Wininet.lib") # pragma comment(lib, "Wldap32.lib") #else # include <ldap.h> # define LDAP_STR(X) ((X).c_str()) # define LDAP_TIME(X) (&(X)) #endif #ifdef __APPLE__ # pragma GCC diagnostic pop #endif class LDAPService; class LDAPRequest { public: LDAPService* service; LDAPInterface* inter; LDAPMessage* message = nullptr; /* message returned by ldap_ */ LDAPResult* result = nullptr; /* final result */ struct timeval tv; QueryType type; int success; LDAPRequest(LDAPService* s, LDAPInterface* i, int c) : service(s) , inter(i) , success(c) { type = QUERY_UNKNOWN; tv.tv_sec = 0; tv.tv_usec = 100000; } virtual ~LDAPRequest() { delete result; if (message != nullptr) ldap_msgfree(message); } virtual int run() = 0; virtual std::string info() = 0; }; class LDAPBind final : public LDAPRequest { std::string who, pass; public: LDAPBind(LDAPService* s, LDAPInterface* i, const std::string& w, const std::string& p) : LDAPRequest(s, i, LDAP_SUCCESS) , who(w) , pass(p) { type = QUERY_BIND; } int run() override; std::string info() override; }; class LDAPSearchRequest final : public LDAPRequest { std::string base; int searchscope; std::string filter; public: LDAPSearchRequest(LDAPService* s, LDAPInterface* i, const std::string& b, int se, const std::string& f) : LDAPRequest(s, i, LDAP_SUCCESS) , base(b) , searchscope(se) , filter(f) { type = QUERY_SEARCH; } int run() override; std::string info() override; }; class LDAPAdd final : public LDAPRequest { std::string dn; LDAPMods attributes; public: LDAPAdd(LDAPService* s, LDAPInterface* i, const std::string& d, const LDAPMods& attr) : LDAPRequest(s, i, LDAP_SUCCESS) , dn(d) , attributes(attr) { type = QUERY_ADD; } int run() override; std::string info() override; }; class LDAPDel final : public LDAPRequest { std::string dn; public: LDAPDel(LDAPService* s, LDAPInterface* i, const std::string& d) : LDAPRequest(s, i, LDAP_SUCCESS) , dn(d) { type = QUERY_DELETE; } int run() override; std::string info() override; }; class LDAPModify final : public LDAPRequest { std::string base; LDAPMods attributes; public: LDAPModify(LDAPService* s, LDAPInterface* i, const std::string& b, const LDAPMods& attr) : LDAPRequest(s, i, LDAP_SUCCESS) , base(b) , attributes(attr) { type = QUERY_MODIFY; } int run() override; std::string info() override; }; class LDAPCompare final : public LDAPRequest { std::string dn, attr, val; public: LDAPCompare(LDAPService* s, LDAPInterface* i, const std::string& d, const std::string& a, const std::string& v) : LDAPRequest(s, i, LDAP_COMPARE_TRUE) , dn(d) , attr(a) , val(v) { type = QUERY_COMPARE; } int run() override; std::string info() override; }; class LDAPService final : public LDAPProvider , public SocketThread { private: LDAP* con = nullptr; std::shared_ptr<ConfigTag> config; time_t last_connect = 0; int searchscope; time_t timeout; #ifdef _WIN32 // Windows LDAP does not implement this so we need to do it. int ldap_initialize(LDAP** ldap, const char* url) { URL_COMPONENTS urlComponents; memset(&urlComponents, 0, sizeof(urlComponents)); urlComponents.dwStructSize = sizeof(urlComponents); std::vector<char> schemebuf(16); urlComponents.lpszScheme = schemebuf.data(); urlComponents.dwSchemeLength = schemebuf.size(); std::vector<char> hostbuf(1024); urlComponents.lpszHostName = hostbuf.data(); urlComponents.dwHostNameLength = hostbuf.size(); if (!InternetCrackUrlA(url, 0, 0, &urlComponents)) return LDAP_CONNECT_ERROR; // Malformed url. unsigned long port = 389; // Default plaintext port. bool secure = false; // LDAP defaults to plaintext. if (urlComponents.dwSchemeLength > 0) { const std::string scheme(urlComponents.lpszScheme); if (insp::equalsci(scheme, "ldaps")) { port = 636; // Default encrypted port. secure = true; } else if (!insp::equalsci(scheme, "ldap")) return LDAP_CONNECT_ERROR; // Invalid protocol. } if (urlComponents.nPort > 0) port = urlComponents.nPort; *ldap = ldap_sslinit(urlComponents.lpszHostName, port, secure); if (!*ldap) return LdapGetLastError(); // Something went wrong, find out what. // We're connected to the LDAP server! return LDAP_SUCCESS; } #endif public: static LDAPMod** BuildMods(const LDAPMods& attributes) { LDAPMod** mods = new LDAPMod*[attributes.size() + 1]; memset(mods, 0, sizeof(LDAPMod*) * (attributes.size() + 1)); for (unsigned int x = 0; x < attributes.size(); ++x) { const LDAPModification& l = attributes[x]; auto* mod = new LDAPMod(); mods[x] = mod; if (l.op == LDAPModification::LDAP_ADD) mod->mod_op = LDAP_MOD_ADD; else if (l.op == LDAPModification::LDAP_DEL) mod->mod_op = LDAP_MOD_DELETE; else if (l.op == LDAPModification::LDAP_REPLACE) mod->mod_op = LDAP_MOD_REPLACE; else if (l.op != 0) { FreeMods(mods); throw LDAPException("Unknown LDAP operation"); } mod->mod_type = strdup(l.name.c_str()); mod->mod_values = new char*[l.values.size() + 1]; memset(mod->mod_values, 0, sizeof(char*) * (l.values.size() + 1)); for (unsigned int j = 0, c = 0; j < l.values.size(); ++j) if (!l.values[j].empty()) mod->mod_values[c++] = strdup(l.values[j].c_str()); } return mods; } static void FreeMods(LDAPMod** mods) { for (unsigned int i = 0; mods[i] != nullptr; ++i) { LDAPMod* mod = mods[i]; if (mod->mod_type != nullptr) free(mod->mod_type); if (mod->mod_values != nullptr) { for (unsigned int j = 0; mod->mod_values[j] != nullptr; ++j) free(mod->mod_values[j]); delete[] mod->mod_values; } } delete[] mods; } private: void Reconnect() { // Only try one connect a minute. It is an expensive blocking operation if (last_connect > ServerInstance->Time() - 60) throw LDAPException("Unable to connect to LDAP service " + this->name + ": reconnecting too fast"); last_connect = ServerInstance->Time(); ldap_unbind_ext(this->con, nullptr, nullptr); Connect(); } int SetOption(int option, const void* value) { int ret = ldap_set_option(this->con, option, value); if (ret != LDAP_OPT_SUCCESS) { ldap_unbind_ext(this->con, nullptr, nullptr); this->con = nullptr; } return ret; } void QueueRequest(LDAPRequest* r) { this->LockQueue(); this->queries.push_back(r); this->UnlockQueueWakeup(); } public: typedef std::vector<LDAPRequest*> query_queue; query_queue queries, results; std::mutex process_mutex; /* held when processing requests not in either queue */ LDAPService(Module* c, const std::shared_ptr<ConfigTag>& tag) : LDAPProvider(c, "LDAP/" + tag->getString("id")) , config(tag) { std::string scope = config->getString("searchscope"); if (insp::equalsci(scope, "base")) searchscope = LDAP_SCOPE_BASE; else if (insp::equalsci(scope, "onelevel")) searchscope = LDAP_SCOPE_ONELEVEL; else searchscope = LDAP_SCOPE_SUBTREE; timeout = config->getDuration("timeout", 5); Connect(); } ~LDAPService() override { this->LockQueue(); for (auto* req : this->queries) { /* queries have no results yet */ req->result = new LDAPResult(); req->result->type = req->type; req->result->error = "LDAP Interface is going away"; req->inter->OnError(*req->result); delete req; } this->queries.clear(); for (auto* req : this->results) { /* even though this may have already finished successfully we return that it didn't */ req->result->error = "LDAP Interface is going away"; req->inter->OnError(*req->result); delete req; } this->results.clear(); this->UnlockQueue(); ldap_unbind_ext(this->con, nullptr, nullptr); } void Connect() { std::string server = config->getString("server"); int i = ldap_initialize(&this->con, server.c_str()); if (i != LDAP_SUCCESS) throw LDAPException("Unable to connect to LDAP service " + this->name + ": " + ldap_err2string(i)); const int version = LDAP_VERSION3; i = SetOption(LDAP_OPT_PROTOCOL_VERSION, &version); if (i != LDAP_OPT_SUCCESS) throw LDAPException("Unable to set protocol version for " + this->name + ": " + ldap_err2string(i)); const struct timeval tv = { 0, 0 }; i = SetOption(LDAP_OPT_NETWORK_TIMEOUT, &tv); if (i != LDAP_OPT_SUCCESS) throw LDAPException("Unable to set timeout for " + this->name + ": " + ldap_err2string(i)); } void BindAsManager(LDAPInterface* i) override { std::string binddn = config->getString("binddn"); std::string bindauth = config->getString("bindauth"); this->Bind(i, binddn, bindauth); } void Bind(LDAPInterface* i, const std::string& who, const std::string& pass) override { QueueRequest(new LDAPBind(this, i, who, pass)); } void Search(LDAPInterface* i, const std::string& base, const std::string& filter) override { if (!i) throw LDAPException("No interface"); QueueRequest(new LDAPSearchRequest(this, i, base, searchscope, filter)); } void Add(LDAPInterface* i, const std::string& dn, LDAPMods& attributes) override { QueueRequest(new LDAPAdd(this, i, dn, attributes)); } void Del(LDAPInterface* i, const std::string& dn) override { QueueRequest(new LDAPDel(this, i, dn)); } void Modify(LDAPInterface* i, const std::string& base, LDAPMods& attributes) override { QueueRequest(new LDAPModify(this, i, base, attributes)); } void Compare(LDAPInterface* i, const std::string& dn, const std::string& attr, const std::string& val) override { QueueRequest(new LDAPCompare(this, i, dn, attr, val)); } private: void BuildReply(int res, LDAPRequest* req) { LDAPResult* ldap_result = req->result = new LDAPResult(); req->result->type = req->type; if (res != req->success) { ldap_result->error = INSP_FORMAT("{} ({})", ldap_err2string(res), req->info()); return; } if (!req->message) { return; } /* a search result */ for (LDAPMessage* cur = ldap_first_message(this->con, req->message); cur; cur = ldap_next_message(this->con, cur)) { LDAPAttributes attributes; char* dn = ldap_get_dn(this->con, cur); if (dn != nullptr) { attributes["dn"].push_back(dn); ldap_memfree(dn); dn = nullptr; } BerElement* ber = nullptr; for (char* attr = ldap_first_attribute(this->con, cur, &ber); attr; attr = ldap_next_attribute(this->con, cur, ber)) { berval** vals = ldap_get_values_len(this->con, cur, attr); int count = ldap_count_values_len(vals); std::vector<std::string> attrs; for (int j = 0; j < count; ++j) attrs.emplace_back(vals[j]->bv_val); attributes[attr] = attrs; ldap_value_free_len(vals); ldap_memfree(attr); } if (ber != nullptr) ber_free(ber, 0); ldap_result->messages.push_back(attributes); } } void SendRequests() { process_mutex.lock(); query_queue q; this->LockQueue(); queries.swap(q); this->UnlockQueue(); if (q.empty()) { process_mutex.unlock(); return; } for (auto* req : q) { int ret = req->run(); if (ret == LDAP_SERVER_DOWN || ret == LDAP_TIMEOUT) { /* try again */ try { Reconnect(); } catch (const LDAPException&) { } ret = req->run(); } BuildReply(ret, req); this->LockQueue(); this->results.push_back(req); this->UnlockQueue(); } this->NotifyParent(); process_mutex.unlock(); } public: void OnStart() override { while (!this->IsStopping()) { this->LockQueue(); if (this->queries.empty()) this->WaitForQueue(); this->UnlockQueue(); SendRequests(); } } void OnNotify() override { query_queue r; this->LockQueue(); this->results.swap(r); this->UnlockQueue(); for (auto* req : r) { LDAPInterface* li = req->inter; LDAPResult* res = req->result; if (!res->error.empty()) li->OnError(*res); else li->OnResult(*res); delete req; } } LDAP* GetConnection() { return con; } }; class ModuleLDAP final : public Module { typedef insp::flat_map<std::string, LDAPService*> ServiceMap; ServiceMap LDAPServices; public: void init() override { ServerInstance->Logs.Normal(MODNAME, "Module was compiled against LDAP ({}) version {}.{}.{}", LDAP_VENDOR_NAME, LDAP_VENDOR_VERSION_MAJOR, LDAP_VENDOR_VERSION_MINOR, LDAP_VENDOR_VERSION_PATCH); } void ReadConfig(ConfigStatus& status) override { ServiceMap conns; for (const auto& [_, tag] : ServerInstance->Config->ConfTags("database")) { if (!insp::equalsci(tag->getString("module"), "ldap")) continue; std::string id = tag->getString("id"); ServiceMap::iterator curr = LDAPServices.find(id); if (curr == LDAPServices.end()) { auto* conn = new LDAPService(this, tag); conns[id] = conn; ServerInstance->Modules.AddService(*conn); conn->Start(); } else { conns.insert(*curr); LDAPServices.erase(curr); } } for (auto& [_, conn] : LDAPServices) { ServerInstance->Modules.DelService(*conn); conn->Stop(); conn->OnNotify(); delete conn; } LDAPServices.swap(conns); } void OnUnloadModule(Module* m) override { for (const auto& [_, s] : LDAPServices) { s->process_mutex.lock(); s->LockQueue(); for (size_t i = s->queries.size(); i > 0; --i) { LDAPRequest* req = s->queries[i - 1]; LDAPInterface* li = req->inter; if (li->creator == m) { s->queries.erase(s->queries.begin() + i - 1); delete req; } } for (size_t i = s->results.size(); i > 0; --i) { LDAPRequest* req = s->results[i - 1]; LDAPInterface* li = req->inter; if (li->creator == m) { s->results.erase(s->results.begin() + i - 1); delete req; } } s->UnlockQueue(); s->process_mutex.unlock(); } } ModuleLDAP() : Module(VF_VENDOR, "Provides the ability for LDAP modules to query a LDAP directory.") { } ~ModuleLDAP() override { for (auto& [_, conn] : LDAPServices) { conn->Stop(); conn->OnNotify(); delete conn; } } }; int LDAPBind::run() { berval cred; cred.bv_val = strdup(pass.c_str()); cred.bv_len = pass.length(); int i = ldap_sasl_bind_s(service->GetConnection(), LDAP_STR(who), LDAP_SASL_SIMPLE, &cred, nullptr, nullptr, nullptr); free(cred.bv_val); return i; } std::string LDAPBind::info() { return "bind dn=" + who; } int LDAPSearchRequest::run() { return ldap_search_ext_s(service->GetConnection(), LDAP_STR(base), searchscope, LDAP_STR(filter), nullptr, 0, nullptr, nullptr, LDAP_TIME(tv), 0, &message); } std::string LDAPSearchRequest::info() { return "search base=" + base + " filter=" + filter; } int LDAPAdd::run() { LDAPMod** mods = LDAPService::BuildMods(attributes); int i = ldap_add_ext_s(service->GetConnection(), LDAP_STR(dn), mods, nullptr, nullptr); LDAPService::FreeMods(mods); return i; } std::string LDAPAdd::info() { return "add dn=" + dn; } int LDAPDel::run() { return ldap_delete_ext_s(service->GetConnection(), LDAP_STR(dn), nullptr, nullptr); } std::string LDAPDel::info() { return "del dn=" + dn; } int LDAPModify::run() { LDAPMod** mods = LDAPService::BuildMods(attributes); int i = ldap_modify_ext_s(service->GetConnection(), LDAP_STR(base), mods, nullptr, nullptr); LDAPService::FreeMods(mods); return i; } std::string LDAPModify::info() { return "modify base=" + base; } int LDAPCompare::run() { berval cred; cred.bv_val = strdup(val.c_str()); cred.bv_len = val.length(); #ifdef _WIN32 int ret = ldap_compare_ext_s(service->GetConnection(), LDAP_STR(dn), LDAP_STR(attr), nullptr, &cred, nullptr, nullptr); #else int ret = ldap_compare_ext_s(service->GetConnection(), dn.c_str(), attr.c_str(), &cred, nullptr, nullptr); #endif free(cred.bv_val); return ret; } std::string LDAPCompare::info() { return "compare dn=" + dn + " attr=" + attr; } MODULE_INIT(ModuleLDAP) ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/src/modules/extra/m_log_json.cpp�����������������������������������������������������0000664�0000000�0000000�00000015021�14771603147�0021562�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2022-2025 Sadie Powell <sadie@witchery.services> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ /// $CompilerFlags: require_library("yyjson") find_compiler_flags("yyjson") -DHAS_YYJSON /// $CompilerFlags: require_library("!yyjson") find_compiler_flags("RapidJSON") warning("Building log_json against RapidJSON is deprecated. Please build against yyjson instead.") /// $LinkerFlags: require_library("yyjson") find_linker_flags("yyjson") /// $PackageInfo: require_system("alpine") pkgconf yyjson-dev /// $PackageInfo: require_system("arch") pkgconf yyjson /// $PackageInfo: require_system("darwin") pkg-config yyjson /// $PackageInfo: require_system("debian~") rapidjson-dev pkg-config #ifdef _WIN32 # define HAS_YYJSON # pragma comment(lib, "yyjson.lib") #endif #ifdef HAS_YYJSON # include <yyjson.h> #else # include <rapidjson/ostreamwrapper.h> # include <rapidjson/writer.h> #endif #include "inspircd.h" #include "timeutils.h" class JSONMethod final : public Log::Method , public Timer { private: // Whether to autoclose the file on exit. bool autoclose; // The file to which the log is written. FILE* file; // How often the file stream should be flushed. const unsigned long flush; // The number of lines which have been written since the file stream was created. unsigned long lines = 0; /// The name the underlying file. const std::string name; public: // RapidJSON API: The type of character that this writer accepts. typedef char Ch; JSONMethod(const std::string& n, FILE* fh, unsigned long fl, bool ac) ATTR_NOT_NULL(3) : Timer(15*60, true) , autoclose(ac) , file(fh) , flush(fl) , name(n) { if (flush > 1) ServerInstance->Timers.AddTimer(this); } ~JSONMethod() override { if (autoclose) fclose(file); } #ifndef HAS_YYJSON // RapidJSON API: We implement our own flushing in OnLog. void Flush() { } #endif void OnLog(time_t time, Log::Level level, const std::string& type, const std::string& message) override { static time_t prevtime = 0; static std::string timestr; if (prevtime != time) { prevtime = time; timestr = Time::ToString(prevtime, Time::ISO_8601); } const auto* levelstr = Log::LevelToString(level); #ifdef HAS_YYJSON auto* doc = yyjson_mut_doc_new(nullptr); auto* root = yyjson_mut_obj(doc); yyjson_mut_doc_set_root(doc, root); auto error = false; error |= yyjson_mut_obj_add_strn(doc, root, "time", timestr.c_str(), timestr.length()); error |= yyjson_mut_obj_add_strn(doc, root, "type", type.c_str(), type.length()); error |= yyjson_mut_obj_add_strn(doc, root, "level", levelstr, strlen(levelstr)); error |= yyjson_mut_obj_add_strn(doc, root, "message", message.c_str(), message.length()); yyjson_write_err errmsg; error |= yyjson_mut_write_fp(file, doc, YYJSON_WRITE_ALLOW_INVALID_UNICODE | YYJSON_WRITE_NEWLINE_AT_END, nullptr, &errmsg); yyjson_mut_doc_free(doc); if (error) throw CoreException(INSP_FORMAT("Unable to generate JSON for {}: {}", name, errmsg.msg ? errmsg.msg : "unknown error")); #else rapidjson::Writer writer(*this); writer.StartObject(); { writer.Key("time", 4); writer.String(timestr.c_str(), static_cast<rapidjson::SizeType>(timestr.size())); writer.Key("type", 4); writer.String(type.c_str(), static_cast<rapidjson::SizeType>(type.size())); writer.Key("level", 5); writer.String(levelstr, static_cast<rapidjson::SizeType>(strlen(levelstr))); writer.Key("message", 7); writer.Key(message.c_str(), static_cast<rapidjson::SizeType>(message.size())); } writer.EndObject(); # ifdef _WIN32 fputs("\r\n", file); # else fputs("\n", file); # endif #endif if (!(++lines % flush)) fflush(file); if (ferror(file)) throw CoreException(INSP_FORMAT("Unable to write to {}: {}", name, strerror(errno))); } #ifndef HAS_YYJSON // RapidJSON API: Write a character to the file. void Put(Ch c) { fputc(c, file); } #endif bool Tick() override { fflush(file); return true; } }; class JSONFileEngine final : public Log::Engine { public: JSONFileEngine(Module* Creator) ATTR_NOT_NULL(2) : Log::Engine(Creator, "json") { } Log::MethodPtr Create(const std::shared_ptr<ConfigTag>& tag) override { const std::string target = tag->getString("target"); if (target.empty()) throw CoreException("<log:target> must be specified for JSON logger at " + tag->source.str()); const std::string fulltarget = ServerInstance->Config->Paths.PrependLog(Time::ToString(ServerInstance->Time(), target.c_str())); auto* fh = fopen(fulltarget.c_str(), "a"); if (!fh) { throw CoreException(INSP_FORMAT("Unable to open {} for JSON logger at {}: {}", fulltarget, tag->source.str(), strerror(errno))); } const unsigned long flush = tag->getNum<unsigned long>("flush", 20, 1); return std::make_shared<JSONMethod>(fulltarget, fh, flush, true); } }; class JSONStreamEngine final : public Log::Engine { private: FILE* file; public: JSONStreamEngine(Module* Creator, const std::string& Name, FILE* fh) ATTR_NOT_NULL(2, 4) : Log::Engine(Creator, Name) , file(fh) { } Log::MethodPtr Create(const std::shared_ptr<ConfigTag>& tag) override { return std::make_shared<JSONMethod>(name, file, 1, false); } }; class ModuleLogJSON final : public Module { private: JSONFileEngine log; JSONStreamEngine stderrlog; JSONStreamEngine stdoutlog; public: ModuleLogJSON() : Module(VF_VENDOR, "Provides the ability to log to JSON.") , log(this) , stderrlog(this, "json-stderr", stderr) , stdoutlog(this, "json-stdout", stdout) { } void init() override { #ifdef HAS_YYJSON const auto yyversion = yyjson_version(); ServerInstance->Logs.Normal(MODNAME, "Module was compiled against yyjson version {} and is running against version {}.{}.{}", YYJSON_VERSION_STRING, (yyversion >> 16) & 0xFF, (yyversion >> 8) & 0xFF, yyversion & 0xFF); #else ServerInstance->Logs.Normal(MODNAME, "Module was compiled against RapidJSON version {}", RAPIDJSON_VERSION_STRING); #endif } }; MODULE_INIT(ModuleLogJSON) ���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/src/modules/extra/m_log_syslog.cpp���������������������������������������������������0000664�0000000�0000000�00000004001�14771603147�0022125�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2022-2023 Sadie Powell <sadie@witchery.services> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include "inspircd.h" #include <syslog.h> class SyslogMethod final : public Log::Method { private: // Converts an InspIRCd log level to syslog priority. static int LevelToPriority(Log::Level level) { switch (level) { case Log::Level::CRITICAL: return LOG_ERR; case Log::Level::WARNING: return LOG_WARNING; case Log::Level::NORMAL: return LOG_NOTICE; case Log::Level::DEBUG: case Log::Level::RAWIO: return LOG_DEBUG; } // Should never happen. return LOG_NOTICE; } public: void OnLog(time_t time, Log::Level level, const std::string& type, const std::string& message) override { syslog(LevelToPriority(level), "%s: %s", type.c_str(), message.c_str()); } }; class SyslogEngine final : public Log::Engine { public: SyslogEngine(Module* Creator) ATTR_NOT_NULL(2) : Log::Engine(Creator, "syslog") { } Log::MethodPtr Create(const std::shared_ptr<ConfigTag>& tag) override { return std::make_shared<SyslogMethod>(); } }; class ModuleLogSyslog final : public Module { private: SyslogEngine engine; public: ModuleLogSyslog() : Module(VF_VENDOR, "Provides the ability to log to syslog.") , engine(this) { openlog("inspircd", LOG_NDELAY|LOG_PID, LOG_USER); } ~ModuleLogSyslog() override { closelog(); } }; MODULE_INIT(ModuleLogSyslog) �������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/src/modules/extra/m_mysql.cpp��������������������������������������������������������0000664�0000000�0000000�00000042221�14771603147�0021117�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2021 Dominic Hamon * Copyright (C) 2015 Daniel Vassdal <shutter@canternet.org> * Copyright (C) 2013-2014 Attila Molnar <attilamolnar@hush.com> * Copyright (C) 2013, 2016-2025 Sadie Powell <sadie@witchery.services> * Copyright (C) 2012 Robby <robby@chatbelgie.be> * Copyright (C) 2012 ChrisTX <xpipe@hotmail.de> * Copyright (C) 2009-2010 Daniel De Graaf <danieldg@inspircd.org> * Copyright (C) 2009 Uli Schlachter <psychon@znc.in> * Copyright (C) 2007, 2009 Dennis Friis <peavey@inspircd.org> * Copyright (C) 2005, 2008-2009 Craig Edwards <brain@inspircd.org> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ /// $CompilerFlags: execute("mysql_config --include" "MYSQL_CXXFLAGS") /// $LinkerFlags: execute("mysql_config --libs_r" "MYSQL_LDFLAGS" "-lmysqlclient") /// $PackageInfo: require_system("alpine") mariadb-dev /// $PackageInfo: require_system("arch") mariadb-libs /// $PackageInfo: require_system("darwin") mysql-client /// $PackageInfo: require_system("debian~") libmysqlclient-dev /// $PackageInfo: require_system("rhel~") mariadb-connector-c-devel #include <mysql.h> #include "inspircd.h" #include "modules/sql.h" #include "threadsocket.h" #include "utility/string.h" #ifdef _WIN32 # pragma comment(lib, "libmysql.lib") #endif /* VERSION 3 API: With nonblocking (threaded) requests */ /* THE NONBLOCKING MYSQL API! * * MySQL provides no nonblocking (asynchronous) API of its own, and its developers recommend * that instead, you should thread your program. This is what i've done here to allow for * asynchronous SQL requests via mysql. The way this works is as follows: * * The module spawns a thread via class Thread, and performs its mysql queries in this thread, * using a queue with priorities. There is a mutex on either end which prevents two threads * adjusting the queue at the same time, and crashing the ircd. Every 50 milliseconds, the * worker thread wakes up, and checks if there is a request at the head of its queue. * If there is, it processes this request, blocking the worker thread but leaving the ircd * thread to go about its business as usual. During this period, the ircd thread is able * to insert further pending requests into the queue. * * Once the processing of a request is complete, it is removed from the incoming queue to * an outgoing queue, and initialized as a 'response'. The worker thread then signals the * ircd thread (via a loopback socket) of the fact a result is available, by sending the * connection ID through the connection. * * The ircd thread then mutexes the queue once more, reads the outbound response off the head * of the queue, and sends it on its way to the original calling module. * * XXX: You might be asking "why doesnt it just send the response from within the worker thread?" * The answer to this is simple. The majority of InspIRCd, and in fact most ircd's are not * threadsafe. This module is designed to be threadsafe and is careful with its use of threads, * however, if we were to call a module's OnRequest even from within a thread which was not the * one the module was originally instantiated upon, there is a chance of all hell breaking loose * if a module is ever put in a reentrant state (stack corruption could occur, crashes, data * corruption, and worse, so DONT think about it until the day comes when InspIRCd is 100% * guaranteed threadsafe!) */ class SQLConnection; class MySQLresult; class DispatcherThread; namespace { template<typename Numeric> bool IsMySQLError(Numeric num) { // MySQL regularly returns -1 on error in unsigned fields. return num == static_cast<Numeric>(-1); } } struct QueryQueueItem final { // An SQL database which this query is executed on. SQLConnection* connection; // An object which handles the result of the query. SQL::Query* query; // The SQL query which is to be executed. std::string querystr; QueryQueueItem(SQL::Query* q, const std::string& s, SQLConnection* c) : connection(c) , query(q) , querystr(s) { } }; struct ResultQueueItem final { // An object which handles the result of the query. SQL::Query* query; // The result returned from executing the MySQL query. MySQLresult* result; ResultQueueItem(SQL::Query* q, MySQLresult* r) : query(q) , result(r) { } }; typedef insp::flat_map<std::string, SQLConnection*> ConnMap; typedef std::deque<QueryQueueItem> QueryQueue; typedef std::deque<ResultQueueItem> ResultQueue; /** MySQL module * */ class ModuleSQL final : public Module { public: DispatcherThread* Dispatcher = nullptr; QueryQueue qq; // MUST HOLD MUTEX ResultQueue rq; // MUST HOLD MUTEX ConnMap connections; // main thread only void init() override; ModuleSQL(); ~ModuleSQL() override; void ReadConfig(ConfigStatus& status) override; void OnUnloadModule(Module* mod) override; }; class DispatcherThread final : public SocketThread { private: ModuleSQL* const Parent; public: DispatcherThread(ModuleSQL* CreatorModule) : Parent(CreatorModule) { } void OnStart() override; void OnNotify() override; }; /** Represents a mysql result set */ class MySQLresult final : public SQL::Result { public: SQL::Error err; int currentrow = 0; int rows = 0; std::vector<std::string> colnames; std::vector<SQL::Row> fieldlists; MySQLresult(MYSQL_RES* res, unsigned long affected_rows) : err(SQL::SUCCESS) { if (affected_rows >= 1 && !IsMySQLError(affected_rows)) { rows = int(affected_rows); fieldlists.resize(rows); } unsigned int field_count = 0; if (res) { MYSQL_ROW row; int n = 0; while ((row = mysql_fetch_row(res))) { if (fieldlists.size() < (size_t)rows+1) { fieldlists.resize(fieldlists.size()+1); } field_count = 0; MYSQL_FIELD *fields = mysql_fetch_fields(res); if(mysql_num_fields(res) == 0) break; if (fields && mysql_num_fields(res)) { colnames.clear(); while (field_count < mysql_num_fields(res)) { std::string a = (fields[field_count].name ? fields[field_count].name : ""); if (row[field_count]) fieldlists[n].emplace_back(row[field_count]); else fieldlists[n].emplace_back(); colnames.push_back(a); field_count++; } n++; } rows++; } mysql_free_result(res); } } MySQLresult(SQL::Error& e) : err(e) { } int Rows() override { return rows; } void GetCols(std::vector<std::string>& result) override { result.assign(colnames.begin(), colnames.end()); } bool HasColumn(const std::string& column, size_t& index) override { for (size_t i = 0; i < colnames.size(); ++i) { if (colnames[i] == column) { index = i; return true; } } return false; } SQL::Field GetValue(int row, int column) { if ((row >= 0) && (row < rows) && (column >= 0) && (column < (int)fieldlists[row].size())) { return fieldlists[row][column]; } return std::nullopt; } bool GetRow(SQL::Row& result) override { if (currentrow < rows) { result.assign(fieldlists[currentrow].begin(), fieldlists[currentrow].end()); currentrow++; return true; } else { result.clear(); return false; } } }; /** Represents a connection to a mysql database */ class SQLConnection final : public SQL::Provider { private: bool EscapeString(SQL::Query* query, const std::string& in, std::string& out) const { // In the worst case each character may need to be encoded as using two bytes and one // byte is the NUL terminator. std::vector<char> buffer(in.length() * 2 + 1); // The return value of mysql_escape_string() is either an error or the length of the // encoded string not including the NUL terminator. // // Unfortunately, someone genius decided that mysql_escape_string should return an // unsigned type even though -1 is returned on error so checking whether an error // happened is a bit cursed. unsigned long escapedsize = mysql_escape_string(buffer.data(), in.c_str(), in.length()); if (IsMySQLError(escapedsize)) { SQL::Error err(SQL::QSEND_FAIL, INSP_FORMAT("{}: {}", mysql_errno(connection), mysql_error(connection))); query->OnError(err); return false; } out.append(buffer.data(), escapedsize); return true; } public: std::shared_ptr<ConfigTag> config; MYSQL* connection = nullptr; std::mutex lock; // This constructor creates an SQLConnection object with the given credentials, but does not connect yet. SQLConnection(Module* p, const std::shared_ptr<ConfigTag>& tag) : SQL::Provider(p, tag->getString("id")) , config(tag) { } ~SQLConnection() override { mysql_close(connection); } // This method connects to the database using the credentials supplied to the constructor, and returns // true upon success. bool Connect() { if (connection) { mysql_close(connection); connection = NULL; } connection = mysql_init(connection); // Set the connection timeout. unsigned int timeout = static_cast<unsigned int>(config->getDuration("timeout", 5, 1, 30)); mysql_options(connection, MYSQL_OPT_CONNECT_TIMEOUT, &timeout); // Enable SSL if requested. #if defined LIBMYSQL_VERSION_ID && LIBMYSQL_VERSION_ID > 80000 unsigned int ssl = config->getBool("ssl") ? SSL_MODE_REQUIRED : SSL_MODE_PREFERRED; mysql_options(connection, MYSQL_OPT_SSL_MODE, &ssl); #endif // Attempt to connect to the database. const std::string host = config->getString("host"); const std::string user = config->getString("user"); const std::string pass = config->getString("pass"); const std::string dbname = config->getString("name"); MYSQL* result; #if defined LIBMYSQL_VERSION_ID && LIBMYSQL_VERSION_ID > 80000 if (config->getBool("srv")) { result = mysql_real_connect_dns_srv(connection, host.c_str(), user.c_str(), pass.c_str(), dbname.c_str(), CLIENT_IGNORE_SIGPIPE); } else #endif { auto port = config->getNum<unsigned int>("port", 3306, 1, 65535); result = mysql_real_connect(connection, host.c_str(), user.c_str(), pass.c_str(), dbname.c_str(), port, nullptr, CLIENT_IGNORE_SIGPIPE); } if (!result) { ServerInstance->Logs.Critical(MODNAME, "Unable to connect to the {} MySQL server: {}", GetId(), mysql_error(connection)); return false; } // Set the default character set. const std::string charset = config->getString("charset"); if (!charset.empty() && mysql_set_character_set(connection, charset.c_str())) { ServerInstance->Logs.Critical(MODNAME, "Could not set character set for {} to \"{}\": {}", GetId(), charset, mysql_error(connection)); return false; } // Execute the initial SQL query. const std::string initialquery = config->getString("initialquery"); if (!initialquery.empty() && mysql_real_query(connection, initialquery.data(), initialquery.length())) { ServerInstance->Logs.Critical(MODNAME, "Could not execute initial query \"{}\" for {}: {}", initialquery, name, mysql_error(connection)); return false; } return true; } ModuleSQL* Parent() { return static_cast<ModuleSQL*>(creator.ptr()); } MySQLresult* DoBlockingQuery(const std::string& query) { /* Parse the command string and dispatch it to mysql */ if (CheckConnection() && !mysql_real_query(connection, query.data(), query.length())) { /* Successful query */ MYSQL_RES* res = mysql_use_result(connection); unsigned long rows = mysql_affected_rows(connection); return new MySQLresult(res, rows); } else { /* XXX: See /usr/include/mysql/mysqld_error.h for a list of * possible error numbers and error messages */ SQL::Error e(SQL::QREPLY_FAIL, INSP_FORMAT("{}: {}", mysql_errno(connection), mysql_error(connection))); return new MySQLresult(e); } } bool CheckConnection() { if (!connection || mysql_ping(connection) != 0) return Connect(); return true; } void Submit(SQL::Query* q, const std::string& qs) override { ServerInstance->Logs.Debug(MODNAME, "Executing MySQL query: {}", qs); Parent()->Dispatcher->LockQueue(); Parent()->qq.emplace_back(q, qs, this); Parent()->Dispatcher->UnlockQueueWakeup(); } void Submit(SQL::Query* call, const std::string& q, const SQL::ParamList& p) override { std::string res; unsigned int param = 0; for (const auto chr : q) { if (chr != '?') res.push_back(chr); else if (param < p.size() && !EscapeString(call, p[param++], res)) return; } Submit(call, res); } void Submit(SQL::Query* call, const std::string& q, const SQL::ParamMap& p) override { std::string res; for(std::string::size_type i = 0; i < q.length(); i++) { if (q[i] != '$') res.push_back(q[i]); else { std::string field; i++; while (i < q.length() && isalnum(q[i])) field.push_back(q[i++]); i--; SQL::ParamMap::const_iterator it = p.find(field); if (it != p.end() && !EscapeString(call, it->second, res)) return; } } Submit(call, res); } }; void ModuleSQL::init() { if (mysql_library_init(0, nullptr, nullptr)) throw ModuleException(this, "Unable to initialise the MySQL library!"); ServerInstance->Logs.Normal(MODNAME, "Module was compiled against MySQL version {}.{}.{} and is running against version {}", MYSQL_VERSION_ID / 10000, MYSQL_VERSION_ID / 100 % 100, MYSQL_VERSION_ID % 100, mysql_get_client_info()); Dispatcher = new DispatcherThread(this); Dispatcher->Start(); } ModuleSQL::ModuleSQL() : Module(VF_VENDOR, "Provides the ability for SQL modules to query a MySQL database.") { } ModuleSQL::~ModuleSQL() { if (Dispatcher) { Dispatcher->Stop(); Dispatcher->OnNotify(); delete Dispatcher; } for (const auto& [_, connection] : connections) delete connection; mysql_library_end(); } void ModuleSQL::ReadConfig(ConfigStatus& status) { ConnMap conns; for (const auto& [_, tag] : ServerInstance->Config->ConfTags("database")) { if (!insp::equalsci(tag->getString("module"), "mysql")) continue; std::string id = tag->getString("id"); ConnMap::iterator curr = connections.find(id); if (curr == connections.end()) { auto* conn = new SQLConnection(this, tag); conns.emplace(id, conn); ServerInstance->Modules.AddService(*conn); } else { conns.insert(*curr); connections.erase(curr); } } // now clean up the deleted databases Dispatcher->LockQueue(); SQL::Error err(SQL::BAD_DBID); for (const auto& [_, connection] : connections) { ServerInstance->Modules.DelService(*connection); // it might be running a query on this database. Wait for that to complete connection->lock.lock(); connection->lock.unlock(); // now remove all active queries to this DB for (size_t j = qq.size(); j > 0; j--) { size_t k = j - 1; if (qq[k].connection == connection) { qq[k].query->OnError(err); delete qq[k].query; qq.erase(qq.begin() + k); } } // finally, nuke the connection delete connection; } Dispatcher->UnlockQueue(); connections.swap(conns); } void ModuleSQL::OnUnloadModule(Module* mod) { SQL::Error err(SQL::BAD_DBID); Dispatcher->LockQueue(); size_t i = qq.size(); while (i > 0) { i--; if (qq[i].query->creator == mod) { if (i == 0) { // need to wait until the query is done // (the result will be discarded) qq[i].connection->lock.lock(); } qq[i].query->OnError(err); delete qq[i].query; qq.erase(qq.begin() + i); } } Dispatcher->UnlockQueue(); // clean up any result queue entries Dispatcher->OnNotify(); } void DispatcherThread::OnStart() { this->LockQueue(); while (!this->IsStopping()) { if (!Parent->qq.empty()) { QueryQueueItem i = Parent->qq.front(); i.connection->lock.lock(); this->UnlockQueue(); MySQLresult* res = i.connection->DoBlockingQuery(i.querystr); i.connection->lock.unlock(); /* * At this point, the main thread could be working on: * Rehash - delete i.connection out from under us. We don't care about that. * UnloadModule - delete i.query and the qq item. Need to avoid reporting results. */ this->LockQueue(); if (!Parent->qq.empty() && Parent->qq.front().query == i.query) { Parent->qq.pop_front(); Parent->rq.emplace_back(i.query, res); NotifyParent(); } else { // UnloadModule ate the query delete res; } } else { /* We know the queue is empty, we can safely hang this thread until * something happens */ this->WaitForQueue(); } } this->UnlockQueue(); } void DispatcherThread::OnNotify() { // this could unlock during the dispatch, but OnResult isn't expected to take that long this->LockQueue(); for (const auto& item : Parent->rq) { MySQLresult* res = item.result; if (res->err.code == SQL::SUCCESS) item.query->OnResult(*res); else item.query->OnError(res->err); delete item.query; delete item.result; } Parent->rq.clear(); this->UnlockQueue(); } MODULE_INIT(ModuleSQL) �������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/src/modules/extra/m_pgsql.cpp��������������������������������������������������������0000664�0000000�0000000�00000036761�14771603147�0021114�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2024 Larry Williamson <l422y@l422y.com> * Copyright (C) 2015 Daniel Vassdal <shutter@canternet.org> * Copyright (C) 2013, 2017, 2019-2025 Sadie Powell <sadie@witchery.services> * Copyright (C) 2012-2015 Attila Molnar <attilamolnar@hush.com> * Copyright (C) 2012 Robby <robby@chatbelgie.be> * Copyright (C) 2009-2010 Daniel De Graaf <danieldg@inspircd.org> * Copyright (C) 2008 Thomas Stagner <aquanight@gmail.com> * Copyright (C) 2007, 2009 Dennis Friis <peavey@inspircd.org> * Copyright (C) 2007, 2009 Craig Edwards <brain@inspircd.org> * Copyright (C) 2007 Robin Burchell <robin+git@viroteck.net> * Copyright (C) 2006 Oliver Lupton <om@inspircd.org> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ /// $CompilerFlags: find_compiler_flags("libpq") /// $LinkerFlags: find_linker_flags("libpq") /// $PackageInfo: require_system("alpine") pcre2-dev pkgconf /// $PackageInfo: require_system("arch") pkgconf postgresql-libs /// $PackageInfo: require_system("darwin") libpq pkg-config /// $PackageInfo: require_system("debian~") libpq-dev pkg-config /// $PackageInfo: require_system("rhel~") pkg-config postgresql-devel #include <libpq-fe.h> #include <pg_config.h> #include "inspircd.h" #include "modules/sql.h" #include "utility/string.h" /* SQLConn rewritten by peavey to * use EventHandler instead of * BufferedSocket. This is much neater * and gives total control of destroy * and delete of resources. */ /* Forward declare, so we can have the typedef neatly at the top */ class SQLConn; class ModulePgSQL; typedef insp::flat_map<std::string, SQLConn*> ConnMap; enum SQLstatus { // The connection has died. DEAD, // Connecting and wants read event. CREAD, // Connecting and wants write event. CWRITE, // Connected/working and wants read event. WREAD, // Connected/working and wants write event. WWRITE }; class ReconnectTimer final : public Timer { private: ModulePgSQL* mod; public: ReconnectTimer(ModulePgSQL* m) : Timer(5, false) , mod(m) { } bool Tick() override; }; struct QueueItem final { SQL::Query* c; std::string q; QueueItem(SQL::Query* C, const std::string& Q) : c(C) , q(Q) { } }; /** PgSQLresult is a subclass of the mostly-pure-virtual class SQLresult. * All SQL providers must create their own subclass and define it's methods using that * database library's data retrieval functions. The aim is to avoid a slow and inefficient process * of converting all data to a common format before it reaches the result structure. This way * data is passes to the module nearly as directly as if it was using the API directly itself. */ class PgSQLresult final : public SQL::Result { PGresult* res; int currentrow = 0; int rows = 0; std::vector<std::string> colnames; void getColNames() { colnames.resize(PQnfields(res)); for(unsigned int i=0; i < colnames.size(); i++) { colnames[i] = PQfname(res, i); } } public: PgSQLresult(PGresult* result) : res(result) { rows = PQntuples(res); if (!rows) rows = ConvToNum<int>(PQcmdTuples(res)); } ~PgSQLresult() override { PQclear(res); } int Rows() override { return rows; } void GetCols(std::vector<std::string>& result) override { if (colnames.empty()) getColNames(); result = colnames; } bool HasColumn(const std::string& column, size_t& index) override { if (colnames.empty()) getColNames(); for (size_t i = 0; i < colnames.size(); ++i) { if (colnames[i] == column) { index = i; return true; } } return false; } SQL::Field GetValue(int row, int column) { char* v = PQgetvalue(res, row, column); if (!v || PQgetisnull(res, row, column)) return std::nullopt; return std::string(v, PQgetlength(res, row, column)); } bool GetRow(SQL::Row& result) override { if (currentrow >= PQntuples(res)) return false; int ncols = PQnfields(res); result.clear(); for(int i = 0; i < ncols; i++) { result.push_back(GetValue(currentrow, i)); } currentrow++; return true; } }; /** SQLConn represents one SQL session. */ class SQLConn final : public SQL::Provider , public EventHandler { public: std::shared_ptr<ConfigTag> conf; /* The <database> entry */ std::deque<QueueItem> queue; PGconn* sql = nullptr; /* PgSQL database connection handle */ SQLstatus status = CWRITE; /* PgSQL database connection status */ QueueItem qinprog; /* If there is currently a query in progress */ SQLConn(Module* Creator, const std::shared_ptr<ConfigTag>& tag) : SQL::Provider(Creator, tag->getString("id")) , conf(tag) , qinprog(nullptr, "") { if (!DoConnect()) DelayReconnect(); } Cullable::Result Cull() override { this->SQL::Provider::Cull(); ServerInstance->Modules.DelService(*this); return this->EventHandler::Cull(); } ~SQLConn() override { SQL::Error err(SQL::BAD_DBID); if (qinprog.c) { qinprog.c->OnError(err); delete qinprog.c; } for (const auto& item : queue) { SQL::Query* q = item.c; q->OnError(err); delete q; } Close(); } void OnEventHandlerRead() override { DoEvent(); } void OnEventHandlerWrite() override { DoEvent(); } void OnEventHandlerError(int errornum) override { DelayReconnect(); } std::string EscapeDSN(const std::string& str) { std::string out; out.reserve(str.size()); for (std::string::const_iterator it = str.begin(); it != str.end(); ++it) { char chr = *it; switch (chr) { case '\\': out.append("\\\\"); break; case '\'': out.append("\\'"); break; default: out.push_back(chr); break; } } return out; } std::string GetDSN() { std::ostringstream conninfo("connect_timeout = '5'"); std::string item; if (conf->readString("host", item)) conninfo << " host = '" << EscapeDSN(item) << "'"; if (conf->readString("port", item)) conninfo << " port = '" << EscapeDSN(item) << "'"; if (conf->readString("name", item)) conninfo << " dbname = '" << EscapeDSN(item) << "'"; if (conf->readString("user", item)) conninfo << " user = '" << EscapeDSN(item) << "'"; if (conf->readString("pass", item)) conninfo << " password = '" << EscapeDSN(item) << "'"; if (conf->getBool("tls", conf->getBool("ssl", true))) conninfo << " sslmode = 'require'"; else conninfo << " sslmode = 'disable'"; return conninfo.str(); } bool HandleConnectError(const char* reason) { ServerInstance->Logs.Critical(MODNAME, "Could not connect to the \"{}\" database: {}", GetId(), reason); return false; } bool DoConnect() { sql = PQconnectStart(GetDSN().c_str()); if (!sql) return HandleConnectError("PQconnectStart returned NULL"); if(PQstatus(sql) == CONNECTION_BAD) return HandleConnectError("connection status is bad"); if(PQsetnonblocking(sql, 1) == -1) return HandleConnectError("unable to mark fd as non-blocking"); /* OK, we've initialised the connection, now to get it hooked into the socket engine * and then start polling it. */ SetFd(PQsocket(sql)); if(!HasFd()) return HandleConnectError("PQsocket returned an invalid fd"); if (!SocketEngine::AddFd(this, FD_WANT_NO_WRITE | FD_WANT_NO_READ)) return HandleConnectError("could not add the pgsql socket to the socket engine"); /* Socket all hooked into the engine, now to tell PgSQL to start connecting */ if (!DoPoll()) return HandleConnectError("could not poll the connection state"); return true; } bool DoPoll() { switch(PQconnectPoll(sql)) { case PGRES_POLLING_WRITING: SocketEngine::ChangeEventMask(this, FD_WANT_POLL_WRITE | FD_WANT_NO_READ); status = CWRITE; return true; case PGRES_POLLING_READING: SocketEngine::ChangeEventMask(this, FD_WANT_POLL_READ | FD_WANT_NO_WRITE); status = CREAD; return true; case PGRES_POLLING_FAILED: SocketEngine::ChangeEventMask(this, FD_WANT_NO_READ | FD_WANT_NO_WRITE); status = DEAD; return false; case PGRES_POLLING_OK: SocketEngine::ChangeEventMask(this, FD_WANT_POLL_READ | FD_WANT_NO_WRITE); status = WWRITE; DoConnectedPoll(); return true; default: return true; } } void DoConnectedPoll() { restart: while (qinprog.q.empty() && !queue.empty()) { /* There's no query currently in progress, and there's queries in the queue. */ DoQuery(queue.front()); queue.pop_front(); } if (PQconsumeInput(sql)) { if (PQisBusy(sql)) { /* Nothing happens here */ } else if (qinprog.c) { /* Fetch the result.. */ PGresult* result = PQgetResult(sql); /* PgSQL would allow a query string to be sent which has multiple * queries in it, this isn't portable across database backends and * we don't want modules doing it. But just in case we make sure we * drain any results there are and just use the last one. * If the module devs are behaving there will only be one result. */ while (PGresult* temp = PQgetResult(sql)) { PQclear(result); result = temp; } /* ..and the result */ PgSQLresult reply(result); switch(PQresultStatus(result)) { case PGRES_EMPTY_QUERY: case PGRES_BAD_RESPONSE: case PGRES_FATAL_ERROR: { SQL::Error err(SQL::QREPLY_FAIL, PQresultErrorMessage(result)); qinprog.c->OnError(err); break; } default: /* Other values are not errors */ qinprog.c->OnResult(reply); } delete qinprog.c; qinprog = QueueItem(nullptr, ""); goto restart; } else { qinprog.q.clear(); } } else { /* I think we'll assume this means the server died...it might not, * but I think that any error serious enough we actually get here * deserves to reconnect [/excuse] * Returning true so the core doesn't try and close the connection. */ DelayReconnect(); } } void DelayReconnect(); void DoEvent() { if((status == CREAD) || (status == CWRITE)) { DoPoll(); } else if (status == WREAD || status == WWRITE) { DoConnectedPoll(); } } void Submit(SQL::Query* req, const std::string& q) override { ServerInstance->Logs.Debug(MODNAME, "Executing PostgreSQL query: {}", q); if (qinprog.q.empty()) { DoQuery(QueueItem(req, q)); } else { // wait your turn. queue.emplace_back(req, q); } } void Submit(SQL::Query* req, const std::string& q, const SQL::ParamList& p) override { std::string res; unsigned int param = 0; for (const auto chr : q) { if (chr != '?') res.push_back(chr); else { if (param < p.size()) { std::string parm = p[param++]; std::vector<char> buffer(parm.length() * 2 + 1); int error; size_t escapedsize = PQescapeStringConn(sql, buffer.data(), parm.data(), parm.length(), &error); if (error) ServerInstance->Logs.Debug(MODNAME, "BUG: Apparently PQescapeStringConn() failed"); res.append(buffer.data(), escapedsize); } } } Submit(req, res); } void Submit(SQL::Query* req, const std::string& q, const SQL::ParamMap& p) override { std::string res; for(std::string::size_type i = 0; i < q.length(); i++) { if (q[i] != '$') res.push_back(q[i]); else { std::string field; i++; while (i < q.length() && isalnum(q[i])) field.push_back(q[i++]); i--; SQL::ParamMap::const_iterator it = p.find(field); if (it != p.end()) { std::string parm = it->second; std::vector<char> buffer(parm.length() * 2 + 1); int error; size_t escapedsize = PQescapeStringConn(sql, buffer.data(), parm.data(), parm.length(), &error); if (error) ServerInstance->Logs.Debug(MODNAME, "BUG: Apparently PQescapeStringConn() failed"); res.append(buffer.data(), escapedsize); } } } Submit(req, res); } void DoQuery(const QueueItem& req) { if (status != WREAD && status != WWRITE) { // whoops, not connected... SQL::Error err(SQL::BAD_CONN); req.c->OnError(err); delete req.c; return; } if(PQsendQuery(sql, req.q.c_str())) { qinprog = req; } else { SQL::Error err(SQL::QSEND_FAIL, PQerrorMessage(sql)); req.c->OnError(err); delete req.c; } } void Close() { status = DEAD; if (HasFd() && SocketEngine::HasFd(GetFd())) SocketEngine::DelFd(this); if(sql) { PQfinish(sql); sql = nullptr; } } }; class ModulePgSQL final : public Module { public: ConnMap connections; ReconnectTimer* retimer = nullptr; ModulePgSQL() : Module(VF_VENDOR, "Provides the ability for SQL modules to query a PostgreSQL database.") { } ~ModulePgSQL() override { delete retimer; ClearAllConnections(); } void init() override { int pqversion = PQlibVersion(); int minor = pqversion / 100 % 100; int revision = pqversion % 100; if (pqversion >= 10'00'00) { // Ref: https://www.postgresql.org/docs/current/libpq-misc.html#LIBPQ-PQLIBVERSION minor = revision; revision = 0; } ServerInstance->Logs.Normal(MODNAME, "Module was compiled against libpq version {} and is running against version {}.{}.{}", PG_VERSION, pqversion / 10000, minor, revision); } void ReadConfig(ConfigStatus& status) override { ReadConf(); } void ReadConf() { ConnMap conns; for (const auto& [_, tag] : ServerInstance->Config->ConfTags("database")) { if (!insp::equalsci(tag->getString("module"), "pgsql")) continue; std::string id = tag->getString("id"); ConnMap::iterator curr = connections.find(id); if (curr == connections.end()) { auto* conn = new SQLConn(this, tag); if (conn->status != DEAD) { conns.emplace(id, conn); ServerInstance->Modules.AddService(*conn); } // If the connection is dead it has already been queued for culling // at the end of the main loop so we don't need to delete it here. } else { conns.insert(*curr); connections.erase(curr); } } ClearAllConnections(); conns.swap(connections); } void ClearAllConnections() { for (const auto& [_, conn] : connections) { conn->Cull(); delete conn; } connections.clear(); } void OnUnloadModule(Module* mod) override { SQL::Error err(SQL::BAD_DBID); for (const auto& [_, conn] : connections) { if (conn->qinprog.c && conn->qinprog.c->creator == mod) { conn->qinprog.c->OnError(err); delete conn->qinprog.c; conn->qinprog.c = nullptr; } std::deque<QueueItem>::iterator j = conn->queue.begin(); while (j != conn->queue.end()) { SQL::Query* q = j->c; if (q->creator == mod) { q->OnError(err); delete q; j = conn->queue.erase(j); } else j++; } } } }; bool ReconnectTimer::Tick() { mod->retimer = nullptr; mod->ReadConf(); delete this; return false; } void SQLConn::DelayReconnect() { status = DEAD; auto* mod = static_cast<ModulePgSQL*>(creator.ptr()); ConnMap::iterator it = mod->connections.find(conf->getString("id")); if (it != mod->connections.end()) mod->connections.erase(it); ServerInstance->GlobalCulls.AddItem((EventHandler*)this); if (!mod->retimer) { mod->retimer = new ReconnectTimer(mod); ServerInstance->Timers.AddTimer(mod->retimer); } } MODULE_INIT(ModulePgSQL) ���������������inspircd-4.7.0/src/modules/extra/m_regex_pcre2.cpp��������������������������������������������������0000664�0000000�0000000�00000011122�14771603147�0022153�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2021-2024 Sadie Powell <sadie@witchery.services> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ /// $CompilerFlags: find_compiler_flags("libpcre2-8") /// $LinkerFlags: find_linker_flags("libpcre2-8") /// $PackageInfo: require_system("alpine") pcre2-devel /// $PackageInfo: require_system("arch") pcre2 /// $PackageInfo: require_system("darwin") pcre2 /// $PackageInfo: require_system("debian~") libpcre2-dev /// $PackageInfo: require_system("rhel~") pcre2-devel #include "inspircd.h" #include "modules/regex.h" #define PCRE2_CODE_UNIT_WIDTH 8 #include <pcre2.h> #ifdef _WIN32 # pragma comment(lib, "pcre2-8.lib") #endif class PCREPattern final : public Regex::Pattern { private: pcre2_code* regex; public: PCREPattern(const Module* mod, const std::string& pattern, uint8_t options) : Regex::Pattern(pattern, options) { int flags = 0; if (options & Regex::OPT_CASE_INSENSITIVE) flags |= PCRE2_CASELESS; int errorcode; PCRE2_SIZE erroroffset; regex = pcre2_compile(reinterpret_cast<PCRE2_SPTR8>(pattern.c_str()), pattern.length(), flags, &errorcode, &erroroffset, nullptr); if (!regex) { PCRE2_UCHAR errorstr[128]; pcre2_get_error_message(errorcode, errorstr, sizeof errorstr); throw Regex::Exception(mod, pattern, reinterpret_cast<const char*>(errorstr), erroroffset); } } ~PCREPattern() override { pcre2_code_free(regex); } bool IsMatch(const std::string& text) override { pcre2_match_data* unused = pcre2_match_data_create_from_pattern(regex, nullptr); int result = pcre2_match(regex, reinterpret_cast<PCRE2_SPTR8>(text.c_str()), text.length(), 0, 0, unused, nullptr); pcre2_match_data_free(unused); return result >= 0; } std::optional<Regex::MatchCollection> Matches(const std::string& text) override { pcre2_match_data* data = pcre2_match_data_create_from_pattern(regex, nullptr); int result = pcre2_match(regex, reinterpret_cast<PCRE2_SPTR8>(text.c_str()), text.length(), 0, 0, data, nullptr); if (result < 0) { pcre2_match_data_free(data); return std::nullopt; } PCRE2_SIZE* ovector = pcre2_get_ovector_pointer(data); uint32_t capturecount; Regex::Captures captures; if (!pcre2_pattern_info(regex, PCRE2_INFO_CAPTURECOUNT, &capturecount) && capturecount) { for (uint32_t idx = 0; idx <= capturecount; ++idx) { PCRE2_UCHAR* bufferptr; PCRE2_SIZE bufferlen; if (!pcre2_substring_get_bynumber(data, idx, &bufferptr, &bufferlen)) captures.emplace_back(reinterpret_cast<const char*>(bufferptr), bufferlen); } } uint32_t namedcapturecount; Regex::NamedCaptures namedcaptures; if (!pcre2_pattern_info(regex, PCRE2_INFO_NAMECOUNT, &namedcapturecount) && namedcapturecount) { uint32_t nameentrysize; PCRE2_SPTR nametable; if (!pcre2_pattern_info(regex, PCRE2_INFO_NAMEENTRYSIZE, &nameentrysize) && !pcre2_pattern_info(regex, PCRE2_INFO_NAMETABLE, &nametable)) { for (uint32_t idx = 0; idx < namedcapturecount; ++idx) { int matchidx = (nametable[0] << 8) | nametable[1]; const std::string matchname(reinterpret_cast<const char*>(nametable + 2), nameentrysize - 3); const std::string matchvalue(text.c_str() + ovector[2 * matchidx], ovector[ 2 * matchidx + 1] - ovector[2 * matchidx]); namedcaptures.emplace(matchname, matchvalue); nametable += nameentrysize; } } } pcre2_match_data_free(data); return Regex::MatchCollection(captures, namedcaptures); } }; class ModuleRegexPCRE final : public Module { private: Regex::SimpleEngine<PCREPattern> regex; public: ModuleRegexPCRE() : Module(VF_VENDOR, "Provides the pcre regular expression engine which uses the PCRE2 library.") , regex(this, "pcre") { } void init() override { std::vector<char> pcre_version(16); if (pcre2_config(PCRE2_CONFIG_VERSION, pcre_version.data()) < 0) return; ServerInstance->Logs.Normal(MODNAME, "Module was compiled against PCRE2 version {}.{} and is running against version {}", PCRE2_MAJOR, PCRE2_MINOR, pcre_version.data()); } }; MODULE_INIT(ModuleRegexPCRE) ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/src/modules/extra/m_regex_posix.cpp��������������������������������������������������0000664�0000000�0000000�00000005420�14771603147�0022306�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2020-2023 Sadie Powell <sadie@witchery.services> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include "inspircd.h" #include "modules/regex.h" #ifdef _WIN32 # include "pcre2posix.h" # pragma comment(lib, "pcre2-posix.lib") #else # include <regex.h> # include <sys/types.h> #endif class POSIXPattern final : public Regex::Pattern { private: regex_t regex; public: POSIXPattern(const Module* mod, const std::string& pattern, uint8_t options) : Regex::Pattern(pattern, options) { int flags = REG_EXTENDED; if (options & Regex::OPT_CASE_INSENSITIVE) flags |= REG_ICASE; int error = regcomp(&regex, pattern.c_str(), flags); if (!error) return; // Retrieve the size of the error message and allocate a buffer. size_t errorsize = regerror(error, &regex, nullptr, 0); std::vector<char> errormsg(errorsize); // Retrieve the error message and free the buffer. regerror(error, &regex, errormsg.data(), errormsg.size()); regfree(&regex); throw Regex::Exception(mod, pattern, std::string(errormsg.data(), errormsg.size() - 1)); } ~POSIXPattern() override { regfree(&regex); } bool IsMatch(const std::string& text) override { return !regexec(&regex, text.c_str(), 0, nullptr, 0); } std::optional<Regex::MatchCollection> Matches(const std::string& text) override { std::vector<regmatch_t> matches(32); int result = regexec(&regex, text.c_str(), matches.size(), matches.data(), 0); if (result) return std::nullopt; Regex::Captures captures; for (const auto& match : matches) { if (match.rm_so == -1 || match.rm_eo == -1) break; captures.emplace_back(text.c_str() + match.rm_so, match.rm_eo - match.rm_so); } captures.shrink_to_fit(); // The posix engine does not support named captures. static const Regex::NamedCaptures unusednc; return Regex::MatchCollection(captures, unusednc); } }; class ModuleRegexPOSIX final : public Module { private: Regex::SimpleEngine<POSIXPattern> regex; public: ModuleRegexPOSIX() : Module(VF_VENDOR, "Provides the posix regular expression engine which uses the POSIX.2 regular expression matching system.") , regex(this, "posix") { } }; MODULE_INIT(ModuleRegexPOSIX) ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/src/modules/extra/m_regex_re2.cpp����������������������������������������������������0000664�0000000�0000000�00000005400�14771603147�0021632�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2013, 2016, 2019-2022, 2024 Sadie Powell <sadie@witchery.services> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ /// $CompilerFlags: find_compiler_flags("re2") /// $LinkerFlags: find_linker_flags("re2") /// $PackageInfo: require_system("alpine") pkgconf re2-dev /// $PackageInfo: require_system("arch") pkgconf re2 /// $PackageInfo: require_system("darwin") pkg-config re2 /// $PackageInfo: require_system("debian~") libre2-dev pkg-config #include "inspircd.h" #include "modules/regex.h" #include <re2/re2.h> class RE2Pattern final : public Regex::Pattern { private: RE2 regex; static RE2::Options BuildOptions(uint8_t options) { RE2::Options re2options; re2options.set_case_sensitive(!(options & Regex::OPT_CASE_INSENSITIVE)); re2options.set_log_errors(false); return re2options; } public: RE2Pattern(const Module* mod, const std::string& pattern, uint8_t options) : Regex::Pattern(pattern, options) , regex(pattern, BuildOptions(options)) { if (!regex.ok()) throw Regex::Exception(mod, pattern, regex.error()); } bool IsMatch(const std::string& text) override { return RE2::FullMatch(text, regex); } std::optional<Regex::MatchCollection> Matches(const std::string& text) override { std::vector<re2::StringPiece> re2captures(regex.NumberOfCapturingGroups() + 1); bool result = regex.Match(text, 0, text.length(), RE2::ANCHOR_BOTH, re2captures.data(), static_cast<int>(re2captures.size())); if (!result) return std::nullopt; Regex::Captures captures; Regex::NamedCaptures namedcaptures; for (size_t idx = 0; idx < re2captures.size(); ++idx) { captures.emplace_back(re2captures[idx]); auto iter = regex.CapturingGroupNames().find(static_cast<int>(idx)); if (iter != regex.CapturingGroupNames().end()) namedcaptures.emplace(iter->second, re2captures[idx]); } return Regex::MatchCollection(captures, namedcaptures); } }; class ModuleRegexRE2 final : public Module { private: Regex::SimpleEngine<RE2Pattern> regex; public: ModuleRegexRE2() : Module(VF_VENDOR, "Provides the re2 regular expression engine which uses the RE2 library.") , regex(this, "re2") { } }; MODULE_INIT(ModuleRegexRE2) ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/src/modules/extra/m_sqlite3.cpp������������������������������������������������������0000664�0000000�0000000�00000014663�14771603147�0021347�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2015 Daniel Vassdal <shutter@canternet.org> * Copyright (C) 2014, 2016 Attila Molnar <attilamolnar@hush.com> * Copyright (C) 2013-2014, 2016-2017, 2019-2025 Sadie Powell <sadie@witchery.services> * Copyright (C) 2012 Robby <robby@chatbelgie.be> * Copyright (C) 2012 ChrisTX <xpipe@hotmail.de> * Copyright (C) 2012 Adam <Adam@anope.org> * Copyright (C) 2010 Daniel De Graaf <danieldg@inspircd.org> * Copyright (C) 2007, 2009 Craig Edwards <brain@inspircd.org> * Copyright (C) 2007 Dennis Friis <peavey@inspircd.org> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ /// $CompilerFlags: find_compiler_flags("sqlite3") /// $LinkerFlags: find_linker_flags("sqlite3") /// $PackageInfo: require_system("alpine") pkgconf sqlite-dev /// $PackageInfo: require_system("arch") pkgconf sqlite /// $PackageInfo: require_system("darwin") pkg-config sqlite /// $PackageInfo: require_system("debian~") libsqlite3-dev pkg-config /// $PackageInfo: require_system("rhel~") pkgconfig sqlite-devel #include "inspircd.h" #include "modules/sql.h" #include "utility/string.h" #include <sqlite3.h> #ifdef _WIN32 # pragma comment(lib, "sqlite3.lib") #endif class SQLConn; typedef insp::flat_map<std::string, SQLConn*> ConnMap; class SQLite3Result final : public SQL::Result { public: int currentrow = 0; int rows = 0; std::vector<std::string> columns; std::vector<SQL::Row> fieldlists; int Rows() override { return rows; } bool GetRow(SQL::Row& result) override { if (currentrow < rows) { result.assign(fieldlists[currentrow].begin(), fieldlists[currentrow].end()); currentrow++; return true; } else { result.clear(); return false; } } void GetCols(std::vector<std::string>& result) override { result.assign(columns.begin(), columns.end()); } bool HasColumn(const std::string& column, size_t& index) override { for (size_t i = 0; i < columns.size(); ++i) { if (columns[i] == column) { index = i; return true; } } return false; } }; class SQLConn final : public SQL::Provider { sqlite3* conn; std::shared_ptr<ConfigTag> config; public: SQLConn(Module* Parent, const std::shared_ptr<ConfigTag>& tag) : SQL::Provider(Parent, tag->getString("id")) , config(tag) { std::string host = tag->getString("hostname"); if (sqlite3_open_v2(host.c_str(), &conn, SQLITE_OPEN_READWRITE, nullptr) != SQLITE_OK) { // Even in case of an error conn must be closed sqlite3_close(conn); conn = nullptr; ServerInstance->Logs.Critical(MODNAME, "WARNING: Could not open DB with id: " + tag->getString("id")); } } ~SQLConn() override { if (conn) { sqlite3_interrupt(conn); sqlite3_close(conn); } } void Query(SQL::Query* query, const std::string& q) { SQLite3Result res; sqlite3_stmt* stmt; int err = sqlite3_prepare_v2(conn, q.c_str(), static_cast<int>(q.length()), &stmt, nullptr); if (err != SQLITE_OK) { SQL::Error error(SQL::QSEND_FAIL, sqlite3_errmsg(conn)); query->OnError(error); return; } int cols = sqlite3_column_count(stmt); res.columns.resize(cols); for(int i=0; i < cols; i++) { res.columns[i] = sqlite3_column_name(stmt, i); } while (true) { err = sqlite3_step(stmt); if (err == SQLITE_ROW) { // Add the row res.fieldlists.resize(res.rows + 1); res.fieldlists[res.rows].resize(cols); for(int i=0; i < cols; i++) { const char* txt = (const char*)sqlite3_column_text(stmt, i); if (txt) res.fieldlists[res.rows][i] = txt; } res.rows++; } else if (err == SQLITE_DONE) { query->OnResult(res); break; } else { SQL::Error error(SQL::QREPLY_FAIL, sqlite3_errmsg(conn)); query->OnError(error); break; } } sqlite3_finalize(stmt); } void Submit(SQL::Query* query, const std::string& q) override { ServerInstance->Logs.Debug(MODNAME, "Executing SQLite3 query: {}", q); Query(query, q); delete query; } void Submit(SQL::Query* query, const std::string& q, const SQL::ParamList& p) override { std::string res; unsigned int param = 0; for (const auto chr : q) { if (chr != '?') res.push_back(chr); else { if (param < p.size()) { char* escaped = sqlite3_mprintf("%q", p[param++].c_str()); res.append(escaped); sqlite3_free(escaped); } } } Submit(query, res); } void Submit(SQL::Query* query, const std::string& q, const SQL::ParamMap& p) override { std::string res; for(std::string::size_type i = 0; i < q.length(); i++) { if (q[i] != '$') res.push_back(q[i]); else { std::string field; i++; while (i < q.length() && isalnum(q[i])) field.push_back(q[i++]); i--; SQL::ParamMap::const_iterator it = p.find(field); if (it != p.end()) { char* escaped = sqlite3_mprintf("%q", it->second.c_str()); res.append(escaped); sqlite3_free(escaped); } } } Submit(query, res); } }; class ModuleSQLite3 final : public Module { private: ConnMap conns; public: ModuleSQLite3() : Module(VF_VENDOR, "Provides the ability for SQL modules to query a SQLite 3 database.") { } ~ModuleSQLite3() override { ClearConns(); } void init() override { ServerInstance->Logs.Normal(MODNAME, "Module was compiled against SQLite version {} and is running against version {}", SQLITE_VERSION, sqlite3_libversion()); } void ClearConns() { for (const auto& [_, conn] : conns) { ServerInstance->Modules.DelService(*conn); delete conn; } conns.clear(); } void ReadConfig(ConfigStatus& status) override { ClearConns(); for (const auto& [_, tag] : ServerInstance->Config->ConfTags("database")) { if (!insp::equalsci(tag->getString("module"), "sqlite")) continue; auto* conn = new SQLConn(this, tag); conns.emplace(tag->getString("id"), conn); ServerInstance->Modules.AddService(*conn); } } }; MODULE_INIT(ModuleSQLite3) �����������������������������������������������������������������������������inspircd-4.7.0/src/modules/extra/m_ssl_gnutls.cpp���������������������������������������������������0000664�0000000�0000000�00000105137�14771603147�0022155�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2021 Dominic Hamon * Copyright (C) 2020 Matt Schatz <genius3000@g3k.solutions> * Copyright (C) 2013-2014, 2016-2025 Sadie Powell <sadie@witchery.services> * Copyright (C) 2013 Daniel Vassdal <shutter@canternet.org> * Copyright (C) 2012-2017 Attila Molnar <attilamolnar@hush.com> * Copyright (C) 2012-2013, 2016 Adam <Adam@anope.org> * Copyright (C) 2012 Robby <robby@chatbelgie.be> * Copyright (C) 2012 ChrisTX <xpipe@hotmail.de> * Copyright (C) 2009-2010 Daniel De Graaf <danieldg@inspircd.org> * Copyright (C) 2008 Robin Burchell <robin+git@viroteck.net> * Copyright (C) 2008 John Brooks <john@jbrooks.io> * Copyright (C) 2007-2008 Craig Edwards <brain@inspircd.org> * Copyright (C) 2007 Dennis Friis <peavey@inspircd.org> * Copyright (C) 2006 Oliver Lupton <om@inspircd.org> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ /// $CompilerFlags: find_compiler_flags("gnutls") /// $LinkerFlags: find_linker_flags("gnutls") /// $PackageInfo: require_system("arch") gnutls pkgconf /// $PackageInfo: require_system("alpine") gnutls-dev gnutls-utils pkgconf /// $PackageInfo: require_system("darwin") gnutls pkg-config /// $PackageInfo: require_system("debian~") gnutls-bin libgnutls28-dev pkg-config /// $PackageInfo: require_system("rhel~") gnutls-devel pkgconfig #include "inspircd.h" #include "modules/ssl.h" #include "stringutils.h" #include "timeutils.h" #include "utility/string.h" #include <gnutls/gnutls.h> #include <gnutls/abstract.h> #include <gnutls/crypto.h> #include <gnutls/x509.h> // Check if the GnuTLS library is at least version major.minor.patch #define INSPIRCD_GNUTLS_HAS_VERSION(major, minor, patch) (GNUTLS_VERSION_NUMBER >= ((major << 16) | (minor << 8) | patch)) #if !INSPIRCD_GNUTLS_HAS_VERSION(3, 3, 5) # error GnuTLS 3.3.5 or newer is required by the ssl_openssl module. #elif INSPIRCD_GNUTLS_HAS_VERSION(3, 6, 0) # define GNUTLS_AUTO_DH #endif #ifdef _WIN32 # pragma comment(lib, "libgnutls-30.lib") #endif static Module* thismod; namespace GnuTLS { void GenRandom(char* buffer, size_t len) { gnutls_rnd(GNUTLS_RND_RANDOM, buffer, len); } class Init final { public: Init() { gnutls_global_init(); } ~Init() { gnutls_global_deinit(); } }; class Exception final : public ModuleException { public: Exception(const std::string& msg) : ModuleException(thismod, msg) { } }; void ThrowOnError(int errcode, const char* msg) { if (errcode < 0) { std::string reason = msg; reason.append(" :").append(gnutls_strerror(errcode)); throw Exception(reason); } } /** Used to create a gnutls_datum_t* from a std::string */ class Datum final { gnutls_datum_t datum; public: Datum(const std::string& dat) { datum.data = (unsigned char*)dat.data(); datum.size = static_cast<unsigned int>(dat.length()); } const gnutls_datum_t* get() const { return &datum; } }; class Hash final { std::vector<std::pair<gnutls_digest_algorithm_t, bool>> hashes; public: // Nothing to deallocate, constructor may throw freely Hash(const std::string& hashlist) { irc::spacesepstream hashstream(hashlist); for (std::string hashname; hashstream.GetToken(hashname); ) { bool spki = false; if (!hashname.compare(0, 5, "spki-", 5) && hashname.length() > 5) { spki = true; hashname.erase(0, 5); } auto hash = gnutls_digest_get_id(hashname.c_str()); if (hash == GNUTLS_DIG_UNKNOWN) throw Exception("Unknown hash type " + hashname); // Check if the user is giving us something that is a valid MAC but not digest gnutls_hash_hd_t is_digest; if (gnutls_hash_init(&is_digest, hash) < 0) throw Exception("Unknown hash type " + hashname); gnutls_hash_deinit(is_digest, nullptr); hashes.emplace_back(hash, spki); } } std::vector<std::pair<gnutls_digest_algorithm_t, bool>> get() const { return hashes; } }; #ifndef GNUTLS_AUTO_DH class DHParams final { gnutls_dh_params_t dh_params; DHParams() { ThrowOnError(gnutls_dh_params_init(&dh_params), "gnutls_dh_params_init() failed"); } public: /** Import */ static std::shared_ptr<DHParams> Import(const std::string& dhstr) { std::shared_ptr<DHParams> dh(new DHParams); int ret = gnutls_dh_params_import_pkcs3(dh->dh_params, Datum(dhstr).get(), GNUTLS_X509_FMT_PEM); ThrowOnError(ret, "Unable to import DH params"); return dh; } ~DHParams() { gnutls_dh_params_deinit(dh_params); } const gnutls_dh_params_t& get() const { return dh_params; } }; #endif class X509Key final { /** Ensure that the key is deinited in case the constructor of X509Key throws */ class RAIIKey final { public: gnutls_x509_privkey_t key; RAIIKey() { ThrowOnError(gnutls_x509_privkey_init(&key), "gnutls_x509_privkey_init() failed"); } ~RAIIKey() { gnutls_x509_privkey_deinit(key); } } key; public: /** Import */ X509Key(const std::string& keystr) { int ret = gnutls_x509_privkey_import(key.key, Datum(keystr).get(), GNUTLS_X509_FMT_PEM); ThrowOnError(ret, "Unable to import private key"); } gnutls_x509_privkey_t& get() { return key.key; } }; class X509CertList final { std::vector<gnutls_x509_crt_t> certs; public: /** Import */ X509CertList(const std::string& certstr) { unsigned int certcount = 3; certs.resize(certcount); Datum datum(certstr); int ret = gnutls_x509_crt_list_import(raw(), &certcount, datum.get(), GNUTLS_X509_FMT_PEM, GNUTLS_X509_CRT_LIST_IMPORT_FAIL_IF_EXCEED); if (ret == GNUTLS_E_SHORT_MEMORY_BUFFER) { // the buffer wasn't big enough to hold all certs but gnutls changed certcount to the number of available certs, // try again with a bigger buffer certs.resize(certcount); ret = gnutls_x509_crt_list_import(raw(), &certcount, datum.get(), GNUTLS_X509_FMT_PEM, GNUTLS_X509_CRT_LIST_IMPORT_FAIL_IF_EXCEED); } ThrowOnError(ret, "Unable to load certificates"); // Resize the vector to the actual number of certs because we rely on its size being correct // when deallocating the certs certs.resize(certcount); } ~X509CertList() { for (auto* cert : certs) gnutls_x509_crt_deinit(cert); } gnutls_x509_crt_t* raw() { return certs.data(); } size_t size() const { return certs.size(); } }; class X509CRL final { class RAIICRL final { public: gnutls_x509_crl_t crl; RAIICRL() { ThrowOnError(gnutls_x509_crl_init(&crl), "gnutls_x509_crl_init() failed"); } ~RAIICRL() { gnutls_x509_crl_deinit(crl); } } crl; public: /** Import */ X509CRL(const std::string& crlstr) { int ret = gnutls_x509_crl_import(get(), Datum(crlstr).get(), GNUTLS_X509_FMT_PEM); ThrowOnError(ret, "Unable to load certificate revocation list"); } gnutls_x509_crl_t& get() { return crl.crl; } }; class Priority final { gnutls_priority_t priority; public: Priority(const std::string& priorities) { // Try to set the priorities for ciphers, kex methods etc. to the user supplied string // If the user did not supply anything then the string is already set to "NORMAL" const char* priocstr = priorities.c_str(); const char* prioerror; int ret = gnutls_priority_init(&priority, priocstr, &prioerror); if (ret < 0) { // gnutls did not understand the user supplied string throw Exception(INSP_FORMAT("Unable to initialize priorities to \"{}\": {} Syntax error at position {}.", priorities, gnutls_strerror(ret), static_cast<size_t>(prioerror - priocstr))); } } ~Priority() { gnutls_priority_deinit(priority); } void SetupSession(gnutls_session_t sess) { gnutls_priority_set(sess, priority); } static const char* GetDefault() { return "NORMAL:%SERVER_PRECEDENCE:-VERS-SSL3.0"; } static std::string RemoveUnknownTokens(const std::string& prio) { std::string ret; irc::sepstream ss(prio, ':'); for (std::string token; ss.GetToken(token); ) { // Save current position so we can revert later if needed const std::string::size_type prevpos = ret.length(); // Append next token if (!ret.empty()) ret.push_back(':'); ret.append(token); gnutls_priority_t test; if (gnutls_priority_init(&test, ret.c_str(), nullptr) < 0) { // The new token broke the priority string, revert to the previously working one ServerInstance->Logs.Debug(MODNAME, "Priority string token not recognized: \"{}\"", token); ret.erase(prevpos); } else { // Worked gnutls_priority_deinit(test); } } return ret; } }; class CertCredentials { #ifndef GNUTLS_AUTO_DH /** DH parameters associated with these credentials */ std::shared_ptr<DHParams> dh; #endif protected: gnutls_certificate_credentials_t cred; public: CertCredentials() { ThrowOnError(gnutls_certificate_allocate_credentials(&cred), "Cannot allocate certificate credentials"); } ~CertCredentials() { gnutls_certificate_free_credentials(cred); } /** Associates these credentials with the session */ void SetupSession(gnutls_session_t sess) { gnutls_credentials_set(sess, GNUTLS_CRD_CERTIFICATE, cred); } #ifndef GNUTLS_AUTO_DH /** Set the given DH parameters to be used with these credentials */ void SetDH(const std::shared_ptr<DHParams>& DH) { dh = DH; gnutls_certificate_set_dh_params(cred, dh->get()); } #endif }; class X509Credentials final : public CertCredentials { /** Private key */ X509Key key; /** Certificate list, presented to the peer */ X509CertList certs; /** Trusted CA, may be NULL */ std::shared_ptr<X509CertList> trustedca; /** Certificate revocation list, may be NULL */ std::shared_ptr<X509CRL> crl; static int cert_callback(gnutls_session_t session, const gnutls_datum_t* req_ca_rdn, int nreqs, const gnutls_pk_algorithm_t* sign_algos, int sign_algos_length, gnutls_retr2_st* st); public: X509Credentials(const std::string& certstr, const std::string& keystr) : key(keystr) , certs(certstr) { // Throwing is ok here, the destructor of Credentials is called in that case int ret = gnutls_certificate_set_x509_key(cred, certs.raw(), static_cast<int>(certs.size()), key.get()); ThrowOnError(ret, "Unable to set cert/key pair"); gnutls_certificate_set_retrieve_function(cred, cert_callback); } /** Sets the trusted CA and the certificate revocation list * to use when verifying certificates */ void SetCA(const std::shared_ptr<X509CertList>& certlist, const std::shared_ptr<X509CRL>& CRL) { // Do nothing if certlist is NULL if (certlist.get()) { int ret = gnutls_certificate_set_x509_trust(cred, certlist->raw(), static_cast<int>(certlist->size())); ThrowOnError(ret, "gnutls_certificate_set_x509_trust() failed"); if (CRL.get()) { ret = gnutls_certificate_set_x509_crl(cred, &CRL->get(), 1); ThrowOnError(ret, "gnutls_certificate_set_x509_crl() failed"); } trustedca = certlist; crl = CRL; } } }; class DataReader final { ssize_t retval; gnutls_packet_t packet; public: DataReader(gnutls_session_t sess) { // Using the packet API avoids the final copy of the data which GnuTLS does if we supply // our own buffer. Instead, we get the buffer containing the data from GnuTLS and copy it // to the recvq directly from there in appendto(). retval = gnutls_record_recv_packet(sess, &packet); } void appendto(std::string& recvq) { // Copy data from GnuTLS buffers to recvq gnutls_datum_t datum; gnutls_packet_get(packet, &datum, nullptr); recvq.append(reinterpret_cast<const char*>(datum.data), datum.size); gnutls_packet_deinit(packet); } ssize_t ret() const { return retval; } }; class Profile final { /** Name of this profile */ const std::string name; /** X509 certificate(s) and key */ X509Credentials x509cred; /** The minimum length in bits for the DH prime to be accepted as a client */ unsigned int min_dh_bits; /** Hashing algorithm to use when generating certificate fingerprints */ Hash hash; /** Priorities for ciphers, compression methods, etc. */ Priority priority; /** Rough max size of records to send */ const unsigned int outrecsize; /** True to request a client certificate as a server */ const bool requestclientcert; static std::string ReadFile(const std::string& filename) { auto file = ServerInstance->Config->ReadFile(filename, ServerInstance->Time()); if (!file) throw Exception("Cannot read file " + filename + ": " + file.error); return file.contents; } static std::string GetPrioStr(const std::string& profilename, const std::shared_ptr<ConfigTag>& tag) { // Use default priority string if this tag does not specify one std::string priostr = GnuTLS::Priority::GetDefault(); bool found = tag->readString("priority", priostr); // If the prio string isn't set in the config don't be strict about the default one because it doesn't work on all versions of GnuTLS if (!tag->getBool("strictpriority", found)) { std::string stripped = GnuTLS::Priority::RemoveUnknownTokens(priostr); if (stripped.empty()) { // Stripping failed, act as if a prio string wasn't set stripped = GnuTLS::Priority::RemoveUnknownTokens(GnuTLS::Priority::GetDefault()); ServerInstance->Logs.Normal(MODNAME, "Priority string for profile \"{}\" contains unknown tokens and stripping it didn't yield a working one either, falling back to \"{}\"", profilename, stripped); } else if ((found) && (stripped != priostr)) { // Prio string was set in the config and we ended up with something that works but different ServerInstance->Logs.Warning(MODNAME, "Priority string for profile \"{}\" contains unknown tokens, stripped to \"{}\"", profilename, stripped); } priostr.swap(stripped); } return priostr; } public: struct Config final { std::string name; std::shared_ptr<X509CertList> ca; std::shared_ptr<X509CRL> crl; std::string certstr; std::string keystr; #ifndef GNUTLS_AUTO_DH std::shared_ptr<DHParams> dh; #endif std::string priostr; unsigned int mindh; std::string hashstr; unsigned int outrecsize; bool requestclientcert; Config(const std::string& profilename, const std::shared_ptr<ConfigTag>& tag) : name(profilename) , certstr(ReadFile(tag->getString("certfile", "cert.pem", 1))) , keystr(ReadFile(tag->getString("keyfile", "key.pem", 1))) #ifndef GNUTLS_AUTO_DH , dh(DHParams::Import(ReadFile(tag->getString("dhfile", "dhparams.pem", 1)))) #endif , priostr(GetPrioStr(profilename, tag)) , mindh(tag->getNum<unsigned int>("mindhbits", 1024)) , hashstr(tag->getString("hash", "sha256 md5", 1)) , requestclientcert(tag->getBool("requestclientcert", true)) { // Load trusted CA and revocation list, if set std::string filename = tag->getString("cafile"); if (!filename.empty()) { ca.reset(new X509CertList(ReadFile(filename))); filename = tag->getString("crlfile"); if (!filename.empty()) crl.reset(new X509CRL(ReadFile(filename))); } outrecsize = tag->getNum<unsigned int>("outrecsize", 2048, 512); } }; Profile(Config& config) : name(config.name) , x509cred(config.certstr, config.keystr) , min_dh_bits(config.mindh) , hash(config.hashstr) , priority(config.priostr) , outrecsize(config.outrecsize) , requestclientcert(config.requestclientcert) { #ifndef GNUTLS_AUTO_DH x509cred.SetDH(config.dh); #endif x509cred.SetCA(config.ca, config.crl); } /** Set up the given session with the settings in this profile */ void SetupSession(gnutls_session_t sess) { priority.SetupSession(sess); x509cred.SetupSession(sess); gnutls_dh_set_prime_bits(sess, min_dh_bits); // Request client certificate if enabled and we are a server, no-op if we're a client if (requestclientcert) gnutls_certificate_server_set_request(sess, GNUTLS_CERT_REQUEST); } const std::string& GetName() const { return name; } X509Credentials& GetX509Credentials() { return x509cred; } std::vector<std::pair<gnutls_digest_algorithm_t, bool>> GetHash() const { return hash.get(); } unsigned int GetOutgoingRecordSize() const { return outrecsize; } }; } class GnuTLSIOHook final : public SSLIOHook { private: gnutls_session_t sess = nullptr; size_t gbuffersize = 0; void CloseSession() { if (this->sess) { gnutls_bye(this->sess, GNUTLS_SHUT_WR); gnutls_deinit(this->sess); } sess = nullptr; certificate = nullptr; status = STATUS_NONE; } // Returns 1 if handshake succeeded, 0 if it is still in progress, -1 if it failed int Handshake(StreamSocket* user) { int ret = gnutls_handshake(this->sess); if (ret < 0) { if(ret == GNUTLS_E_AGAIN || ret == GNUTLS_E_INTERRUPTED) { // Handshake needs resuming later, read() or write() would have blocked. this->status = STATUS_HANDSHAKING; if (gnutls_record_get_direction(this->sess) == 0) { // gnutls_handshake() wants to read() again. SocketEngine::ChangeEventMask(user, FD_WANT_POLL_READ | FD_WANT_NO_WRITE); } else { // gnutls_handshake() wants to write() again. SocketEngine::ChangeEventMask(user, FD_WANT_NO_READ | FD_WANT_SINGLE_WRITE); } return 0; } else { user->SetError("Handshake Failed - " + std::string(gnutls_strerror(ret))); CloseSession(); return -1; } } else { // Change the session state this->status = STATUS_OPEN; VerifyCertificate(); // Finish writing, if any left SocketEngine::ChangeEventMask(user, FD_WANT_POLL_READ | FD_WANT_NO_WRITE | FD_ADD_TRIAL_WRITE); return 1; } } int GetCertFP(gnutls_x509_crt_t& cert, gnutls_digest_algorithm_t algo, char* buffer, size_t& buffer_size) { return gnutls_x509_crt_get_fingerprint(cert, algo, buffer, &buffer_size); } int GetSPKIFP(gnutls_x509_crt_t& cert, gnutls_digest_algorithm_t algo, char* buffer, size_t& buffer_size) { int ret; gnutls_pubkey_t pubkey; if ((ret = gnutls_pubkey_init(&pubkey)) != GNUTLS_E_SUCCESS) return ret; if ((ret = gnutls_pubkey_import_x509(pubkey, cert, 0)) != GNUTLS_E_SUCCESS) { gnutls_pubkey_deinit(pubkey); return ret; } // We need to do this twice in order to find the size of the public key. size_t derkey_size = 0; if (gnutls_pubkey_export(pubkey, GNUTLS_X509_FMT_DER, buffer, &derkey_size) != GNUTLS_E_SHORT_MEMORY_BUFFER) return GNUTLS_E_SHORT_MEMORY_BUFFER; std::vector<char> derkey(derkey_size); if ((ret = gnutls_pubkey_export(pubkey, GNUTLS_X509_FMT_DER, &derkey[0], &derkey_size)) != GNUTLS_E_SUCCESS) return ret; gnutls_pubkey_deinit(pubkey); if (gnutls_hash_fast(algo, &derkey[0], derkey_size, buffer) != GNUTLS_E_SUCCESS) return ret; buffer_size = gnutls_hash_get_len(algo); return GNUTLS_E_SUCCESS; } void VerifyCertificate() { auto* certinfo = new ssl_cert(); this->certificate = certinfo; unsigned int certstatus; int ret = gnutls_certificate_verify_peers2(this->sess, &certstatus); if (ret < 0) { certinfo->error = gnutls_strerror(ret); return; } certinfo->invalid = (certstatus & GNUTLS_CERT_INVALID); certinfo->unknownsigner = (certstatus & GNUTLS_CERT_SIGNER_NOT_FOUND); certinfo->revoked = (certstatus & GNUTLS_CERT_REVOKED); certinfo->trusted = !(certstatus & GNUTLS_CERT_SIGNER_NOT_CA); if (gnutls_certificate_type_get(this->sess) != GNUTLS_CRT_X509) { certinfo->error = "No X509 keys sent"; return; } gnutls_x509_crt_t cert; ret = gnutls_x509_crt_init(&cert); if (ret < 0) { certinfo->error = gnutls_strerror(ret); return; } char buffer[512]; size_t buffer_size = sizeof(buffer); unsigned int cert_list_size = 0; const gnutls_datum_t* cert_list = gnutls_certificate_get_peers(this->sess, &cert_list_size); if (!cert_list) { certinfo->error = "No certificate was found"; goto info_done_dealloc; } ret = gnutls_x509_crt_import(cert, &cert_list[0], GNUTLS_X509_FMT_DER); if (ret < 0) { certinfo->error = gnutls_strerror(ret); goto info_done_dealloc; } if (gnutls_x509_crt_get_dn(cert, buffer, &buffer_size) == 0) ProcessDNString(buffer, buffer_size, certinfo->dn); buffer_size = sizeof(buffer); if (gnutls_x509_crt_get_issuer_dn(cert, buffer, &buffer_size) == 0) ProcessDNString(buffer, buffer_size, certinfo->issuer); for (const auto& [hash, spki] : GetProfile().GetHash()) { buffer_size = sizeof(buffer); ret = spki ? GetSPKIFP(cert, hash, buffer, buffer_size) : GetCertFP(cert, hash, buffer, buffer_size); if (ret != GNUTLS_E_SUCCESS) { certinfo->error = gnutls_strerror(ret); } else { certinfo->fingerprints.push_back(Hex::Encode(buffer, buffer_size)); } } certinfo->activation = gnutls_x509_crt_get_activation_time(cert); if (certinfo->activation == -1) { certinfo->activation = 0; certinfo->error = "Unable to check certificate activation time"; } else if (certinfo->activation >= ServerInstance->Time()) { certinfo->error = INSP_FORMAT("Certificate not active for {} (on {})", Duration::ToLongString(certinfo->activation - ServerInstance->Time(), true), Time::ToString(certinfo->activation)); } certinfo->expiration = gnutls_x509_crt_get_expiration_time(cert); if (certinfo->expiration == -1) { certinfo->expiration = 0; certinfo->error = "Unable to check certificate expiration time"; } else if (certinfo->expiration <= ServerInstance->Time()) { certinfo->error = INSP_FORMAT("Certificate expired {} ago (on {})", Duration::ToLongString(ServerInstance->Time() - certinfo->expiration, true), Time::ToString(certinfo->expiration)); } info_done_dealloc: gnutls_x509_crt_deinit(cert); } static void ProcessDNString(const char* buffer, size_t buffer_size, std::string& out) { out.assign(buffer, buffer_size); for (size_t pos = 0; ((pos = out.find_first_of("\r\n", pos)) != std::string::npos); ) out[pos] = ' '; } // Returns 1 if application I/O should proceed, 0 if it must wait for the underlying protocol to progress, -1 on fatal error int PrepareIO(StreamSocket* sock) { if (status == STATUS_OPEN) return 1; else if (status == STATUS_HANDSHAKING) { // The handshake isn't finished, try to finish it return Handshake(sock); } CloseSession(); sock->SetError("No TLS session"); return -1; } int FlushBuffer(StreamSocket* sock) { // If GnuTLS has some data buffered, write it if (gbuffersize) return HandleWriteRet(sock, gnutls_record_uncork(this->sess, 0)); return 1; } int HandleWriteRet(StreamSocket* sock, int ret) { if (ret > 0) { gbuffersize -= ret; if (gbuffersize) { SocketEngine::ChangeEventMask(sock, FD_WANT_SINGLE_WRITE); return 0; } return ret; } else if (ret == GNUTLS_E_AGAIN || ret == GNUTLS_E_INTERRUPTED || ret == 0) { SocketEngine::ChangeEventMask(sock, FD_WANT_SINGLE_WRITE); return 0; } else // (ret < 0) { sock->SetError(gnutls_strerror(ret)); CloseSession(); return -1; } } static const char* UnknownIfNULL(const char* str) { return str ? str : "UNKNOWN"; } static ssize_t gnutls_pull_wrapper(gnutls_transport_ptr_t session_wrap, void* buffer, size_t size) { StreamSocket* sock = reinterpret_cast<StreamSocket*>(session_wrap); #ifdef _WIN32 GnuTLSIOHook* session = static_cast<GnuTLSIOHook*>(sock->GetModHook(thismod)); #endif if (sock->GetEventMask() & FD_READ_WILL_BLOCK) { #ifdef _WIN32 gnutls_transport_set_errno(session->sess, EAGAIN); #else errno = EAGAIN; #endif return -1; } ssize_t rv = SocketEngine::Recv(sock, reinterpret_cast<char *>(buffer), size, 0); #ifdef _WIN32 if (rv < 0) { /* Windows doesn't use errno, but gnutls does, so check SocketEngine::IgnoreError() * and then set errno appropriately. * The gnutls library may also have a different errno variable than us, see * gnutls_transport_set_errno(3). */ gnutls_transport_set_errno(session->sess, SocketEngine::IgnoreError() ? EAGAIN : errno); } #endif if (rv < 0 || size_t(rv) < size) SocketEngine::ChangeEventMask(sock, FD_READ_WILL_BLOCK); return rv; } static ssize_t VectorPush(gnutls_transport_ptr_t transportptr, const giovec_t* iov, int iovcnt) { StreamSocket* sock = reinterpret_cast<StreamSocket*>(transportptr); #ifdef _WIN32 GnuTLSIOHook* session = static_cast<GnuTLSIOHook*>(sock->GetModHook(thismod)); #endif if (sock->GetEventMask() & FD_WRITE_WILL_BLOCK) { #ifdef _WIN32 gnutls_transport_set_errno(session->sess, EAGAIN); #else errno = EAGAIN; #endif return -1; } // Cast the giovec_t to iovec not to IOVector so the correct function is called on Windows ssize_t ret = SocketEngine::WriteV(sock, reinterpret_cast<const iovec*>(iov), iovcnt); #ifdef _WIN32 // See the function above for more info about the usage of gnutls_transport_set_errno() on Windows if (ret < 0) gnutls_transport_set_errno(session->sess, SocketEngine::IgnoreError() ? EAGAIN : errno); #endif ssize_t size = 0; for (int i = 0; i < iovcnt; i++) size += iov[i].iov_len; if (ret < size) SocketEngine::ChangeEventMask(sock, FD_WRITE_WILL_BLOCK); return ret; } public: GnuTLSIOHook(const std::shared_ptr<IOHookProvider>& hookprov, StreamSocket* sock, unsigned int flags) : SSLIOHook(hookprov) { gnutls_init(&sess, flags); gnutls_transport_set_ptr(sess, reinterpret_cast<gnutls_transport_ptr_t>(sock)); gnutls_transport_set_vec_push_function(sess, VectorPush); gnutls_transport_set_pull_function(sess, gnutls_pull_wrapper); GetProfile().SetupSession(sess); sock->AddIOHook(this); Handshake(sock); } void OnStreamSocketClose(StreamSocket* user) override { CloseSession(); } ssize_t OnStreamSocketRead(StreamSocket* user, std::string& recvq) override { // Finish handshake if needed int prepret = PrepareIO(user); if (prepret <= 0) return prepret; // If we resumed the handshake then this->status will be STATUS_OPEN. { GnuTLS::DataReader reader(sess); ssize_t ret = reader.ret(); if (ret > 0) { reader.appendto(recvq); // Schedule a read if there is still data in the GnuTLS buffer if (gnutls_record_check_pending(sess) > 0) SocketEngine::ChangeEventMask(user, FD_ADD_TRIAL_READ); return 1; } else if (ret == GNUTLS_E_AGAIN || ret == GNUTLS_E_INTERRUPTED) { return 0; } else if (ret == 0) { user->SetError("Connection closed"); CloseSession(); return -1; } else { user->SetError(gnutls_strerror(int(ret))); CloseSession(); return -1; } } } ssize_t OnStreamSocketWrite(StreamSocket* user, StreamSocket::SendQueue& sendq) override { // Finish handshake if needed int prepret = PrepareIO(user); if (prepret <= 0) return prepret; // Session is ready for transferring application data while (true) { // If there is something in the GnuTLS buffer try to send() it ssize_t ret = FlushBuffer(user); if (ret <= 0) return ret; // Couldn't flush entire buffer, retry later (or close on error) // GnuTLS buffer is empty, if the sendq is empty as well then break to set FD_WANT_NO_WRITE if (sendq.empty()) break; // GnuTLS buffer is empty but sendq is not, begin sending data from the sendq gnutls_record_cork(this->sess); while ((!sendq.empty()) && (gbuffersize < GetProfile().GetOutgoingRecordSize())) { const StreamSocket::SendQueue::Element& elem = sendq.front(); gbuffersize += elem.length(); ret = gnutls_record_send(this->sess, elem.data(), elem.length()); if (ret < 0) { CloseSession(); return -1; } sendq.pop_front(); } } SocketEngine::ChangeEventMask(user, FD_WANT_NO_WRITE); return 1; } void GetCiphersuite(std::string& out) const override { if (!IsHookReady()) return; out.append(UnknownIfNULL(gnutls_protocol_get_name(gnutls_protocol_get_version(sess)))).push_back('-'); out.append(UnknownIfNULL(gnutls_kx_get_name(gnutls_kx_get(sess)))).push_back('-'); out.append(UnknownIfNULL(gnutls_cipher_get_name(gnutls_cipher_get(sess)))).push_back('-'); out.append(UnknownIfNULL(gnutls_mac_get_name(gnutls_mac_get(sess)))); } bool GetServerName(std::string& out) const override { std::vector<char> nameBuffer(1); size_t nameLength = 0; unsigned int nameType = GNUTLS_NAME_DNS; // First, determine the size of the hostname. if (gnutls_server_name_get(sess, nameBuffer.data(), &nameLength, &nameType, 0) != GNUTLS_E_SHORT_MEMORY_BUFFER) return false; // Then retrieve the hostname. nameBuffer.resize(nameLength); if (gnutls_server_name_get(sess, nameBuffer.data(), &nameLength, &nameType, 0) != GNUTLS_E_SUCCESS) return false; out.append(nameBuffer.data()); return true; } GnuTLS::Profile& GetProfile(); }; int GnuTLS::X509Credentials::cert_callback(gnutls_session_t sess, const gnutls_datum_t* req_ca_rdn, int nreqs, const gnutls_pk_algorithm_t* sign_algos, int sign_algos_length, gnutls_retr2_st* st) { st->cert_type = GNUTLS_CRT_X509; st->key_type = GNUTLS_PRIVKEY_X509; StreamSocket* sock = reinterpret_cast<StreamSocket*>(gnutls_transport_get_ptr(sess)); GnuTLS::X509Credentials& cred = static_cast<GnuTLSIOHook*>(sock->GetModHook(thismod))->GetProfile().GetX509Credentials(); st->ncerts = static_cast<unsigned int>(cred.certs.size()); st->cert.x509 = cred.certs.raw(); st->key.x509 = cred.key.get(); st->deinit_all = 0; return 0; } class GnuTLSIOHookProvider final : public SSLIOHookProvider { GnuTLS::Profile profile; public: GnuTLSIOHookProvider(Module* mod, GnuTLS::Profile::Config& config) : SSLIOHookProvider(mod, config.name) , profile(config) { ServerInstance->Modules.AddService(*this); } ~GnuTLSIOHookProvider() override { ServerInstance->Modules.DelService(*this); } void OnAccept(StreamSocket* sock, const irc::sockets::sockaddrs& client, const irc::sockets::sockaddrs& server) override { new GnuTLSIOHook(shared_from_this(), sock, GNUTLS_SERVER); } void OnConnect(StreamSocket* sock) override { new GnuTLSIOHook(shared_from_this(), sock, GNUTLS_CLIENT); } GnuTLS::Profile& GetProfile() { return profile; } }; GnuTLS::Profile& GnuTLSIOHook::GetProfile() { return std::static_pointer_cast<GnuTLSIOHookProvider>(prov)->GetProfile(); } class ModuleSSLGnuTLS final : public Module { typedef std::vector<std::shared_ptr<GnuTLSIOHookProvider>> ProfileList; // First member of the class, gets constructed first and destructed last GnuTLS::Init libinit; ProfileList profiles; std::function<void(char*, size_t)> rememberer; void ReadProfiles() { // First, store all profiles in a new, temporary container. If no problems occur, swap the two // containers; this way if something goes wrong we can go back and continue using the current profiles, // avoiding unpleasant situations where no new TLS connections are possible. ProfileList newprofiles; auto tags = ServerInstance->Config->ConfTags("sslprofile"); if (tags.empty()) throw ModuleException(this, "You have not specified any <sslprofile> tags that are usable by this module!"); for (const auto& [_, tag] : tags) { if (!insp::equalsci(tag->getString("provider", "gnutls", 1), "gnutls")) { ServerInstance->Logs.Debug(MODNAME, "Ignoring non-GnuTLS <sslprofile> tag at {}", tag->source.str()); continue; } const std::string name = tag->getString("name"); if (name.empty()) { ServerInstance->Logs.Warning(MODNAME, "Ignoring <sslprofile> tag without name at {}", tag->source.str()); continue; } std::shared_ptr<GnuTLSIOHookProvider> prov; try { GnuTLS::Profile::Config profileconfig(name, tag); prov = std::make_shared<GnuTLSIOHookProvider>(this, profileconfig); } catch (const CoreException& ex) { throw ModuleException(this, "Error while initializing TLS profile \"" + name + "\" at " + tag->source.str() + " - " + ex.GetReason()); } newprofiles.push_back(prov); } // New profiles are ok, begin using them // Old profiles are deleted when their refcount drops to zero for (const auto& profile : profiles) ServerInstance->Modules.DelService(*profile); profiles.swap(newprofiles); } public: ModuleSSLGnuTLS() : Module(VF_VENDOR, "Allows TLS encrypted connections using the GnuTLS library.") , rememberer(ServerInstance->GenRandom) { thismod = this; } void init() override { ServerInstance->Logs.Normal(MODNAME, "Module was compiled against GnuTLS version {} and is running against version {}", GNUTLS_VERSION, gnutls_check_version(nullptr)); ServerInstance->GenRandom = &GnuTLS::GenRandom; } void ReadConfig(ConfigStatus& status) override { const auto& tag = ServerInstance->Config->ConfValue("gnutls"); if (status.initial || tag->getBool("onrehash", true)) { // Try to help people who have outdated configs. for (const auto& field : {"cafile", "certfile", "crlfile", "dhfile", "hash", "keyfile", "mindhbits", "outrecsize", "priority", "requestclientcert", "strictpriority"}) { if (!tag->getString(field).empty()) throw ModuleException(this, "TLS settings have moved from <gnutls> to <sslprofile>. See " INSPIRCD_DOCS "modules/ssl_gnutls/#sslprofile for more information."); } ReadProfiles(); } } void OnModuleRehash(User* user, const std::string& param) override { if (!irc::equals(param, "tls") && !irc::equals(param, "ssl")) return; try { ReadProfiles(); ServerInstance->SNO.WriteToSnoMask('r', "GnuTLS TLS profiles have been reloaded."); } catch (const ModuleException& ex) { ServerInstance->SNO.WriteToSnoMask('r', "Failed to reload the GnuTLS TLS profiles. " + ex.GetReason()); } } ~ModuleSSLGnuTLS() override { ServerInstance->GenRandom = rememberer; } void OnCleanup(ExtensionType type, Extensible* item) override { if (type == ExtensionType::USER) { LocalUser* user = IS_LOCAL(static_cast<User*>(item)); if ((user) && (user->eh.GetModHook(this))) { // User is using TLS, they're a local user, and they're using one of *our* TLS ports. // Potentially there could be multiple TLS modules loaded at once on different ports. ServerInstance->Users.QuitUser(user, "GnuTLS module unloading"); } } } ModResult OnCheckReady(LocalUser* user) override { const GnuTLSIOHook* const iohook = static_cast<GnuTLSIOHook*>(user->eh.GetModHook(this)); if ((iohook) && (!iohook->IsHookReady())) return MOD_RES_DENY; return MOD_RES_PASSTHRU; } }; MODULE_INIT(ModuleSSLGnuTLS) ���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/src/modules/extra/m_ssl_openssl.cpp��������������������������������������������������0000664�0000000�0000000�00000073433�14771603147�0022327�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2021 Dominic Hamon * Copyright (C) 2020 Matt Schatz <genius3000@g3k.solutions> * Copyright (C) 2017, 2023 Wade Cline <wadecline@hotmail.com> * Copyright (C) 2014, 2016-2017, 2019-2025 Sadie Powell <sadie@witchery.services> * Copyright (C) 2014 Julien Vehent <julien@linuxwall.info> * Copyright (C) 2012-2017 Attila Molnar <attilamolnar@hush.com> * Copyright (C) 2012 Robby <robby@chatbelgie.be> * Copyright (C) 2012 ChrisTX <xpipe@hotmail.de> * Copyright (C) 2009-2010 Daniel De Graaf <danieldg@inspircd.org> * Copyright (C) 2008 Robin Burchell <robin+git@viroteck.net> * Copyright (C) 2007 Dennis Friis <peavey@inspircd.org> * Copyright (C) 2006-2008 Craig Edwards <brain@inspircd.org> * Copyright (C) 2006 Oliver Lupton <om@inspircd.org> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ /// $CompilerFlags: find_compiler_flags("openssl" "") /// $LinkerFlags: find_linker_flags("openssl" "-lssl -lcrypto") /// $PackageInfo: require_system("alpine") openssl-dev pkgconf /// $PackageInfo: require_system("arch") openssl pkgconf /// $PackageInfo: require_system("darwin") openssl pkg-config /// $PackageInfo: require_system("debian~") libssl-dev openssl pkg-config /// $PackageInfo: require_system("rhel~") openssl-devel pkgconfig #include "inspircd.h" #include "iohook.h" #include "modules/ssl.h" #include "stringutils.h" #include "timeutils.h" #include "utility/string.h" #include <openssl/ssl.h> #include <openssl/err.h> #include <openssl/dh.h> #ifdef _WIN32 # define timegm _mkgmtime # pragma comment(lib, "libcrypto.lib") # pragma comment(lib, "libssl.lib") #endif #if OPENSSL_VERSION_NUMBER < 0x10101000L # error OpenSSL 1.1.1 or newer is required by the ssl_openssl module. #elif OPENSSL_VERSION_NUMBER < 0x30000000L # define OPENSSL_VERSION_STR OPENSSL_VERSION_TEXT # define OPENSSL_VERSION_STRING OPENSSL_VERSION #else # define INSPIRCD_OPENSSL_AUTO_DH #endif static bool SelfSigned = false; static int exdataindex; static Module* thismod; char* get_error() { return ERR_error_string(ERR_get_error(), nullptr); } static int OnVerify(int preverify_ok, X509_STORE_CTX* ctx); static void StaticSSLInfoCallback(const SSL* ssl, int where, int rc); namespace OpenSSL { class Exception final : public ModuleException { public: Exception(const std::string& msg) : ModuleException(thismod, msg) { } }; #ifndef INSPIRCD_OPENSSL_AUTO_DH class DHParams final { DH* dh; public: DHParams(const std::string& filename) { BIO* dhpfile = BIO_new_file(filename.c_str(), "r"); if (!dhpfile) throw Exception("Couldn't open DH file " + filename); dh = PEM_read_bio_DHparams(dhpfile, nullptr, nullptr, nullptr); BIO_free(dhpfile); if (!dh) throw Exception("Couldn't read DH params from file " + filename); } ~DHParams() { DH_free(dh); } DH* get() { return dh; } }; #endif class Context final { SSL_CTX* const ctx; long ctx_options; public: Context(SSL_CTX* context) : ctx(context) { // Sane default options for OpenSSL see https://www.openssl.org/docs/ssl/SSL_CTX_set_options.html // and when choosing a cipher, use the server's preferences instead of the client preferences. long opts = SSL_OP_NO_SSLv2 | SSL_OP_NO_SSLv3 | SSL_OP_NO_TLSv1 | SSL_OP_NO_SESSION_RESUMPTION_ON_RENEGOTIATION | SSL_OP_CIPHER_SERVER_PREFERENCE | SSL_OP_SINGLE_DH_USE; // Only turn options on if they exist #ifdef SSL_OP_SINGLE_ECDH_USE opts |= SSL_OP_SINGLE_ECDH_USE; #endif #ifdef SSL_OP_NO_TICKET opts |= SSL_OP_NO_TICKET; #endif ctx_options = SSL_CTX_set_options(ctx, opts); long mode = SSL_MODE_ENABLE_PARTIAL_WRITE | SSL_MODE_ACCEPT_MOVING_WRITE_BUFFER; #ifdef SSL_MODE_RELEASE_BUFFERS mode |= SSL_MODE_RELEASE_BUFFERS; #endif SSL_CTX_set_mode(ctx, mode); SSL_CTX_set_verify(ctx, SSL_VERIFY_NONE, nullptr); SSL_CTX_set_session_cache_mode(ctx, SSL_SESS_CACHE_OFF); SSL_CTX_set_info_callback(ctx, StaticSSLInfoCallback); } ~Context() { SSL_CTX_free(ctx); } #ifndef INSPIRCD_OPENSSL_AUTO_DH bool SetDH(DHParams& dh) { ERR_clear_error(); return (SSL_CTX_set_tmp_dh(ctx, dh.get()) >= 0); } #endif #ifndef OPENSSL_NO_ECDH void SetECDH(const std::string& curvename) { int nid = OBJ_sn2nid(curvename.c_str()); if (nid == NID_undef) throw Exception("Unknown curve: " + curvename); ERR_clear_error(); if (!SSL_CTX_set1_groups(ctx, &nid, 1)) throw Exception("Couldn't set ECDH curve"); } #endif bool SetCiphers(const std::string& ciphers) { // TLSv1 to TLSv1.2 ciphers. ERR_clear_error(); return SSL_CTX_set_cipher_list(ctx, ciphers.c_str()); } bool SetCiphersuites(const std::string& ciphers) { // TLSv1.3+ ciphers. ERR_clear_error(); return SSL_CTX_set_ciphersuites(ctx, ciphers.c_str()); } bool SetCerts(const std::string& filename) { ERR_clear_error(); return SSL_CTX_use_certificate_chain_file(ctx, filename.c_str()); } bool SetPrivateKey(const std::string& filename) { ERR_clear_error(); return SSL_CTX_use_PrivateKey_file(ctx, filename.c_str(), SSL_FILETYPE_PEM); } bool SetCA(const std::string& filename) { ERR_clear_error(); return SSL_CTX_load_verify_locations(ctx, filename.c_str(), nullptr); } void SetCRL(const std::string& crlfile, const std::string& crlpath, const std::string& crlmode) { if (crlfile.empty() && crlpath.empty()) return; /* Set CRL mode */ unsigned long crlflags = X509_V_FLAG_CRL_CHECK; if (insp::equalsci(crlmode, "chain")) { crlflags |= X509_V_FLAG_CRL_CHECK_ALL; } else if (!insp::equalsci(crlmode, "leaf")) { throw ModuleException(thismod, "Unknown mode '" + crlmode + "'; expected either 'chain' (default) or 'leaf'"); } /* Load CRL files */ X509_STORE* store = SSL_CTX_get_cert_store(ctx); if (!store) { throw ModuleException(thismod, "Unable to get X509_STORE from TLS context; this should never happen"); } ERR_clear_error(); if (!X509_STORE_load_locations(store, crlfile.empty() ? nullptr : crlfile.c_str(), crlpath.empty() ? nullptr : crlpath.c_str())) { unsigned long err = ERR_get_error(); throw ModuleException(thismod, "Unable to load CRL file '" + crlfile + "' or CRL path '" + crlpath + "': '" + (err ? ERR_error_string(err, nullptr) : "unknown") + "'"); } /* Set CRL mode */ if (X509_STORE_set_flags(store, crlflags) != 1) { throw ModuleException(thismod, "Unable to set X509 CRL flags"); } } long GetDefaultContextOptions() const { return ctx_options; } long SetRawContextOptions(long setoptions, long clearoptions) { // Clear everything SSL_CTX_clear_options(ctx, SSL_CTX_get_options(ctx)); // Set the default options and what is in the conf SSL_CTX_set_options(ctx, ctx_options | setoptions); return SSL_CTX_clear_options(ctx, clearoptions); } void SetVerifyCert() { SSL_CTX_set_verify(ctx, SSL_VERIFY_PEER | SSL_VERIFY_CLIENT_ONCE, OnVerify); } SSL* CreateServerSession() { SSL* sess = SSL_new(ctx); SSL_set_accept_state(sess); // Act as server return sess; } SSL* CreateClientSession() { SSL* sess = SSL_new(ctx); SSL_set_connect_state(sess); // Act as client return sess; } }; class Profile final { /** Name of this profile */ const std::string name; #ifndef INSPIRCD_OPENSSL_AUTO_DH /** DH parameters in use */ DHParams dh; #endif /** OpenSSL makes us have two contexts, one for servers and one for clients */ Context ctx; Context clientctx; /** Digest to use when generating fingerprints */ std::vector<const EVP_MD*> digests; /** Last error, set by error_callback() */ std::string lasterr; /** True if renegotiations are allowed, false if not */ const bool allowrenego; /** Rough max size of records to send */ const unsigned int outrecsize; static int error_callback(const char* str, size_t len, void* u) { Profile* profile = reinterpret_cast<Profile*>(u); profile->lasterr = std::string(str, len - 1); return 0; } /** Set raw OpenSSL context (SSL_CTX) options from a config tag * @param ctxname Name of the context, client or server * @param tag Config tag defining this profile * @param context Context object to manipulate */ void SetContextOptions(const std::string& ctxname, const std::shared_ptr<ConfigTag>& tag, Context& context) { long setoptions = tag->getNum<long>(ctxname + "setoptions", 0); long clearoptions = tag->getNum<long>(ctxname + "clearoptions", 0); #ifdef SSL_OP_NO_COMPRESSION // Disable compression by default if (!tag->getBool("compression", false)) setoptions |= SSL_OP_NO_COMPRESSION; #endif #ifdef SSL_OP_NO_TLSv1_1 // Disable TLSv1.1 by default. if (!tag->getBool("tlsv11", false)) setoptions |= SSL_OP_NO_TLSv1_1; #endif #ifdef SSL_OP_NO_TLSv1_2 // Enable TLSv1.2 by default. if (!tag->getBool("tlsv12", true)) setoptions |= SSL_OP_NO_TLSv1_2; #endif #ifdef SSL_OP_NO_TLSv1_3 // Enable TLSv1.3 by default. if (!tag->getBool("tlsv13", true)) setoptions |= SSL_OP_NO_TLSv1_3; #endif if (!setoptions && !clearoptions) return; // Nothing to do ServerInstance->Logs.Debug(MODNAME, "Setting {} {} context options, default: {} set: {} clear: {}", name, ctxname, ctx.GetDefaultContextOptions(), setoptions, clearoptions); long final = context.SetRawContextOptions(setoptions, clearoptions); ServerInstance->Logs.Normal(MODNAME, "{} {} context options: {}", name, ctxname, final); } public: Profile(const std::string& profilename, const std::shared_ptr<ConfigTag>& tag) : name(profilename) #ifndef INSPIRCD_OPENSSL_AUTO_DH , dh(ServerInstance->Config->Paths.PrependConfig(tag->getString("dhfile", "dhparams.pem", 1))) #endif , ctx(SSL_CTX_new(TLS_server_method())) , clientctx(SSL_CTX_new(TLS_client_method())) , allowrenego(tag->getBool("renegotiation")) // Disallow by default , outrecsize(tag->getNum<unsigned int>("outrecsize", 2048, 512, 16384)) { #ifndef INSPIRCD_OPENSSL_AUTO_DH if ((!ctx.SetDH(dh)) || (!clientctx.SetDH(dh))) throw Exception("Couldn't set DH parameters"); #endif irc::spacesepstream hashstream(tag->getString("hash", "sha256 md5", 1)); for (std::string hash; hashstream.GetToken(hash); ) { const auto* digest = EVP_get_digestbyname(hash.c_str()); if (!digest) throw Exception("Unknown hash type " + hash); digests.push_back(digest); } const std::string ciphers = tag->getString("ciphers"); if (!ciphers.empty()) { if ((!ctx.SetCiphers(ciphers)) || (!clientctx.SetCiphers(ciphers))) { ERR_print_errors_cb(error_callback, this); throw Exception("Can't set cipher list to \"" + ciphers + "\" " + lasterr); } } const std::string ciphersuites = tag->getString("ciphersuites"); if (!ciphersuites.empty()) { if ((!ctx.SetCiphersuites(ciphersuites)) || (!clientctx.SetCiphersuites(ciphersuites))) { ERR_print_errors_cb(error_callback, this); throw Exception("Can't set ciphersuite list to \"" + ciphersuites + "\" " + lasterr); } } #ifndef OPENSSL_NO_ECDH const std::string curvename = tag->getString("ecdhcurve", "prime256v1"); if (!curvename.empty()) ctx.SetECDH(curvename); #endif SetContextOptions("server", tag, ctx); SetContextOptions("client", tag, clientctx); /* Load our keys and certificates * NOTE: OpenSSL's error logging API sucks, don't blame us for this clusterfuck. */ std::string filename = ServerInstance->Config->Paths.PrependConfig(tag->getString("certfile", "cert.pem", 1)); if ((!ctx.SetCerts(filename)) || (!clientctx.SetCerts(filename))) { ERR_print_errors_cb(error_callback, this); throw Exception("Can't read certificate file: " + lasterr); } filename = ServerInstance->Config->Paths.PrependConfig(tag->getString("keyfile", "key.pem", 1)); if ((!ctx.SetPrivateKey(filename)) || (!clientctx.SetPrivateKey(filename))) { ERR_print_errors_cb(error_callback, this); throw Exception("Can't read key file: " + lasterr); } // Load the CAs we trust filename = ServerInstance->Config->Paths.PrependConfig(tag->getString("cafile", "ca.pem", 1)); if ((!ctx.SetCA(filename)) || (!clientctx.SetCA(filename))) { ERR_print_errors_cb(error_callback, this); ServerInstance->Logs.Normal(MODNAME, "Can't read CA list from {}. This is only a problem if you want to verify client certificates, otherwise it's safe to ignore this message. Error: {}", filename, lasterr); } // Load the CRLs. const std::string crlfile = tag->getString("crlfile"); const std::string crlpath = tag->getString("crlpath"); const std::string crlmode = tag->getString("crlmode", "chain", 1); ctx.SetCRL(crlfile, crlpath, crlmode); clientctx.SetVerifyCert(); if (tag->getBool("requestclientcert", true)) ctx.SetVerifyCert(); } const std::string& GetName() const { return name; } SSL* CreateServerSession() { return ctx.CreateServerSession(); } SSL* CreateClientSession() { return clientctx.CreateClientSession(); } const std::vector<const EVP_MD*> GetDigests() { return digests; } bool AllowRenegotiation() const { return allowrenego; } unsigned int GetOutgoingRecordSize() const { return outrecsize; } }; namespace BIOMethod { static int create(BIO* bio) { BIO_set_init(bio, 1); return 1; } static int destroy(BIO* bio) { // XXX: Dummy function to avoid a memory leak in OpenSSL. // The memory leak happens in BIO_free() (bio_lib.c) when the destroy func of the BIO is NULL. // This is fixed in OpenSSL but some distros still ship the unpatched version hence we provide this workaround. return 1; } static long ctrl(BIO* bio, int cmd, long num, void* ptr) { if (cmd == BIO_CTRL_FLUSH) return 1; return 0; } // These signatures are required by the BIO_meth_set_write|read interface // even though they lead to shortening issues. static int read(BIO* bio, char* buf, int len); static int write(BIO* bio, const char* buf, int len); static BIO_METHOD* alloc() { BIO_METHOD* meth = BIO_meth_new(100 | BIO_TYPE_SOURCE_SINK, "inspircd"); BIO_meth_set_write(meth, OpenSSL::BIOMethod::write); BIO_meth_set_read(meth, OpenSSL::BIOMethod::read); BIO_meth_set_ctrl(meth, OpenSSL::BIOMethod::ctrl); BIO_meth_set_create(meth, OpenSSL::BIOMethod::create); BIO_meth_set_destroy(meth, OpenSSL::BIOMethod::destroy); return meth; } } } static BIO_METHOD* biomethods; static int OnVerify(int preverify_ok, X509_STORE_CTX* ctx) { /* XXX: This will allow self signed certificates. * In the future if we want an option to not allow this, * we can just return preverify_ok here, and openssl * will boot off self-signed and invalid peer certs. */ int ve = X509_STORE_CTX_get_error(ctx); SelfSigned = (ve == X509_V_ERR_DEPTH_ZERO_SELF_SIGNED_CERT); return 1; } class OpenSSLIOHook final : public SSLIOHook { private: SSL* sess; bool data_to_write = false; // Returns 1 if handshake succeeded, 0 if it is still in progress, -1 if it failed int Handshake(StreamSocket* user) { ERR_clear_error(); int ret = SSL_do_handshake(sess); if (ret < 0) { int err = SSL_get_error(sess, ret); if (err == SSL_ERROR_WANT_READ) { SocketEngine::ChangeEventMask(user, FD_WANT_POLL_READ | FD_WANT_NO_WRITE); this->status = STATUS_HANDSHAKING; return 0; } else if (err == SSL_ERROR_WANT_WRITE) { SocketEngine::ChangeEventMask(user, FD_WANT_NO_READ | FD_WANT_SINGLE_WRITE); this->status = STATUS_HANDSHAKING; return 0; } else { CloseSession(); return -1; } } else if (ret > 0) { // Handshake complete. VerifyCertificate(); status = STATUS_OPEN; SocketEngine::ChangeEventMask(user, FD_WANT_POLL_READ | FD_WANT_NO_WRITE | FD_ADD_TRIAL_WRITE); return 1; } else if (ret == 0) { CloseSession(); } return -1; } void CloseSession() { if (sess) { SSL_shutdown(sess); SSL_free(sess); } sess = nullptr; certificate = nullptr; status = STATUS_NONE; } void VerifyCertificate() { X509* cert; auto* certinfo = new ssl_cert(); this->certificate = certinfo; unsigned int n; unsigned char md[EVP_MAX_MD_SIZE]; cert = SSL_get_peer_certificate(sess); if (!cert) { certinfo->error = "Could not get peer certificate: "+std::string(get_error()); return; } certinfo->invalid = (SSL_get_verify_result(sess) != X509_V_OK); if (!SelfSigned) { certinfo->unknownsigner = false; certinfo->trusted = true; } else { certinfo->unknownsigner = true; certinfo->trusted = false; } GetDNString(X509_get_subject_name(cert), certinfo->dn); GetDNString(X509_get_issuer_name(cert), certinfo->issuer); for (const auto* digest : GetProfile().GetDigests()) { if (!X509_digest(cert, digest, md, &n)) { certinfo->error = "Out of memory generating fingerprint"; } else { certinfo->fingerprints.push_back(Hex::Encode(md, n)); } } certinfo->activation = GetTime(X509_getm_notBefore(cert)); certinfo->expiration = GetTime(X509_getm_notAfter(cert)); int activated = ASN1_TIME_cmp_time_t(X509_getm_notBefore(cert), ServerInstance->Time()); if (activated != -1 && activated != 0) { certinfo->error = INSP_FORMAT("Certificate not active for {} (on {})", Duration::ToLongString(certinfo->activation - ServerInstance->Time(), true), Time::ToString(certinfo->activation)); } int expired = ASN1_TIME_cmp_time_t(X509_getm_notAfter(cert), ServerInstance->Time()); if (expired != 0 && expired != 1) { certinfo->error = INSP_FORMAT("Certificate expired {} ago (on {})", Duration::ToLongString(ServerInstance->Time() - certinfo->expiration, true), Time::ToString(certinfo->expiration)); } X509_free(cert); } static void GetDNString(X509_NAME* x509name, std::string& out) { char buf[512]; X509_NAME_oneline(x509name, buf, sizeof(buf)); out.assign(buf); for (size_t pos = 0; ((pos = out.find_first_of("\r\n", pos)) != std::string::npos); ) out[pos] = ' '; } static time_t GetTime(ASN1_TIME* x509time) { if (!x509time) return 0; struct tm ts; if (!ASN1_TIME_to_tm(x509time, &ts)) return 0; return timegm(&ts); } void SSLInfoCallback(int where, int rc) { if ((where & SSL_CB_HANDSHAKE_START) && (status == STATUS_OPEN)) { if (GetProfile().AllowRenegotiation()) return; // The other side is trying to renegotiate, kill the connection and change status // to STATUS_NONE so CheckRenego() closes the session status = STATUS_NONE; BIO* bio = SSL_get_rbio(sess); EventHandler* eh = static_cast<StreamSocket*>(BIO_get_data(bio)); SocketEngine::Shutdown(eh, 2); } } bool CheckRenego(StreamSocket* sock) { if (status != STATUS_NONE) return true; ServerInstance->Logs.Debug(MODNAME, "Session {} killed, attempted to renegotiate", fmt::ptr(sess)); CloseSession(); sock->SetError("Renegotiation is not allowed"); return false; } // Returns 1 if application I/O should proceed, 0 if it must wait for the underlying protocol to progress, -1 on fatal error int PrepareIO(StreamSocket* sock) { if (status == STATUS_OPEN) return 1; else if (status == STATUS_HANDSHAKING) { // The handshake isn't finished, try to finish it return Handshake(sock); } CloseSession(); return -1; } // Calls our private SSLInfoCallback() friend void StaticSSLInfoCallback(const SSL* ssl, int where, int rc); public: OpenSSLIOHook(const std::shared_ptr<IOHookProvider>& hookprov, StreamSocket* sock, SSL* session) : SSLIOHook(hookprov) , sess(session) { // Create BIO instance and store a pointer to the socket in it which will be used by the read and write functions BIO* bio = BIO_new(biomethods); BIO_set_data(bio, sock); SSL_set_bio(sess, bio, bio); SSL_set_ex_data(sess, exdataindex, this); sock->AddIOHook(this); Handshake(sock); } void OnStreamSocketClose(StreamSocket* user) override { CloseSession(); } ssize_t OnStreamSocketRead(StreamSocket* user, std::string& recvq) override { // Finish handshake if needed int prepret = PrepareIO(user); if (prepret <= 0) return prepret; // If we resumed the handshake then this->status will be STATUS_OPEN { ERR_clear_error(); char* buffer = ServerInstance->GetReadBuffer(); int bufsiz = static_cast<int>(std::min<size_t>(ServerInstance->Config->NetBufferSize, INT_MAX)); int ret = SSL_read(sess, buffer, bufsiz); if (!CheckRenego(user)) return -1; if (ret > 0) { recvq.append(buffer, ret); int mask = 0; // Schedule a read if there is still data in the OpenSSL buffer if (SSL_pending(sess) > 0) mask |= FD_ADD_TRIAL_READ; if (data_to_write) mask |= FD_WANT_POLL_READ | FD_WANT_SINGLE_WRITE; if (mask != 0) SocketEngine::ChangeEventMask(user, mask); return 1; } else if (ret == 0) { // Client closed connection. CloseSession(); user->SetError("Connection closed"); return -1; } else // if (ret < 0) { int err = SSL_get_error(sess, ret); if (err == SSL_ERROR_WANT_READ) { SocketEngine::ChangeEventMask(user, FD_WANT_POLL_READ); return 0; } else if (err == SSL_ERROR_WANT_WRITE) { SocketEngine::ChangeEventMask(user, FD_WANT_NO_READ | FD_WANT_SINGLE_WRITE); return 0; } else { CloseSession(); return -1; } } } } ssize_t OnStreamSocketWrite(StreamSocket* user, StreamSocket::SendQueue& sendq) override { // Finish handshake if needed int prepret = PrepareIO(user); if (prepret <= 0) return prepret; data_to_write = true; // Session is ready for transferring application data while (!sendq.empty()) { ERR_clear_error(); FlattenSendQueue(sendq, GetProfile().GetOutgoingRecordSize()); const StreamSocket::SendQueue::Element& buffer = sendq.front(); int ret = SSL_write(sess, buffer.data(), static_cast<int>(buffer.size())); if (!CheckRenego(user)) return -1; if (ret == (int)buffer.length()) { // Wrote entire record, continue sending sendq.pop_front(); } else if (ret > 0) { sendq.erase_front(ret); SocketEngine::ChangeEventMask(user, FD_WANT_SINGLE_WRITE); return 0; } else if (ret == 0) { CloseSession(); return -1; } else // if (ret < 0) { int err = SSL_get_error(sess, ret); if (err == SSL_ERROR_WANT_WRITE) { SocketEngine::ChangeEventMask(user, FD_WANT_SINGLE_WRITE); return 0; } else if (err == SSL_ERROR_WANT_READ) { SocketEngine::ChangeEventMask(user, FD_WANT_POLL_READ); return 0; } else { CloseSession(); return -1; } } } data_to_write = false; SocketEngine::ChangeEventMask(user, FD_WANT_POLL_READ | FD_WANT_NO_WRITE); return 1; } void GetCiphersuite(std::string& out) const override { if (!IsHookReady()) return; out.append(SSL_get_version(sess)).push_back('-'); out.append(SSL_get_cipher(sess)); } bool GetServerName(std::string& out) const override { const char* name = SSL_get_servername(sess, TLSEXT_NAMETYPE_host_name); if (!name) return false; out.append(name); return true; } OpenSSL::Profile& GetProfile(); }; static void StaticSSLInfoCallback(const SSL* ssl, int where, int rc) { OpenSSLIOHook* hook = static_cast<OpenSSLIOHook*>(SSL_get_ex_data(ssl, exdataindex)); hook->SSLInfoCallback(where, rc); } static int OpenSSL::BIOMethod::write(BIO* bio, const char* buffer, int size) { BIO_clear_retry_flags(bio); StreamSocket* sock = static_cast<StreamSocket*>(BIO_get_data(bio)); if (sock->GetEventMask() & FD_WRITE_WILL_BLOCK) { // Writes blocked earlier, don't retry syscall BIO_set_retry_write(bio); return -1; } ssize_t ret = SocketEngine::Send(sock, buffer, size, 0); if ((ret < size) && ((ret > 0) || (SocketEngine::IgnoreError()))) { // Blocked, set retry flag for OpenSSL SocketEngine::ChangeEventMask(sock, FD_WRITE_WILL_BLOCK); BIO_set_retry_write(bio); } return static_cast<int>(ret); } static int OpenSSL::BIOMethod::read(BIO* bio, char* buffer, int size) { BIO_clear_retry_flags(bio); StreamSocket* sock = static_cast<StreamSocket*>(BIO_get_data(bio)); if (sock->GetEventMask() & FD_READ_WILL_BLOCK) { // Reads blocked earlier, don't retry syscall BIO_set_retry_read(bio); return -1; } ssize_t ret = SocketEngine::Recv(sock, buffer, size, 0); if ((ret < size) && ((ret > 0) || (SocketEngine::IgnoreError()))) { // Blocked, set retry flag for OpenSSL SocketEngine::ChangeEventMask(sock, FD_READ_WILL_BLOCK); BIO_set_retry_read(bio); } return static_cast<int>(ret); } class OpenSSLIOHookProvider final : public SSLIOHookProvider { OpenSSL::Profile profile; public: OpenSSLIOHookProvider(Module* mod, const std::string& profilename, const std::shared_ptr<ConfigTag>& tag) : SSLIOHookProvider(mod, profilename) , profile(profilename, tag) { ServerInstance->Modules.AddService(*this); } ~OpenSSLIOHookProvider() override { ServerInstance->Modules.DelService(*this); } void OnAccept(StreamSocket* sock, const irc::sockets::sockaddrs& client, const irc::sockets::sockaddrs& server) override { new OpenSSLIOHook(shared_from_this(), sock, profile.CreateServerSession()); } void OnConnect(StreamSocket* sock) override { new OpenSSLIOHook(shared_from_this(), sock, profile.CreateClientSession()); } OpenSSL::Profile& GetProfile() { return profile; } }; OpenSSL::Profile& OpenSSLIOHook::GetProfile() { return std::static_pointer_cast<OpenSSLIOHookProvider>(prov)->GetProfile(); } class ModuleSSLOpenSSL final : public Module { typedef std::vector<std::shared_ptr<OpenSSLIOHookProvider>> ProfileList; ProfileList profiles; void ReadProfiles() { ProfileList newprofiles; auto tags = ServerInstance->Config->ConfTags("sslprofile"); if (tags.empty()) throw ModuleException(this, "You have not specified any <sslprofile> tags that are usable by this module!"); for (const auto& [_, tag] : tags) { if (!insp::equalsci(tag->getString("provider", "openssl", 1), "openssl")) { ServerInstance->Logs.Debug(MODNAME, "Ignoring non-OpenSSL <sslprofile> tag at {}", tag->source.str()); continue; } const std::string name = tag->getString("name"); if (name.empty()) { ServerInstance->Logs.Warning(MODNAME, "Ignoring <sslprofile> tag without name at {}", tag->source.str()); continue; } std::shared_ptr<OpenSSLIOHookProvider> prov; try { prov = std::make_shared<OpenSSLIOHookProvider>(this, name, tag); } catch (const CoreException& ex) { throw ModuleException(this, "Error while initializing TLS profile \"" + name + "\" at " + tag->source.str() + " - " + ex.GetReason()); } newprofiles.push_back(prov); } for (const auto& profile : profiles) ServerInstance->Modules.DelService(*profile); profiles.swap(newprofiles); } public: ModuleSSLOpenSSL() : Module(VF_VENDOR, "Allows TLS encrypted connections using the OpenSSL library.") { // Initialize OpenSSL OPENSSL_init_ssl(0, nullptr); biomethods = OpenSSL::BIOMethod::alloc(); thismod = this; } ~ModuleSSLOpenSSL() override { BIO_meth_free(biomethods); } void init() override { ServerInstance->Logs.Normal(MODNAME, "Module was compiled against OpenSSL version {} and is running against version {}", OPENSSL_VERSION_STR, OpenSSL_version(OPENSSL_VERSION_STRING)); // Register application specific data char exdatastr[] = "inspircd"; exdataindex = SSL_get_ex_new_index(0, exdatastr, nullptr, nullptr, nullptr); if (exdataindex < 0) throw ModuleException(this, "Failed to register application specific data"); } void ReadConfig(ConfigStatus& status) override { const auto& tag = ServerInstance->Config->ConfValue("openssl"); if (status.initial || tag->getBool("onrehash", true)) { // Try to help people who have outdated configs. for (const auto& field : {"cafile", "certfile", "ciphers", "clientclearoptions", "clientsetoptions", "compression", "crlfile", "crlmode", "crlpath", "dhfile", "ecdhcurve", "hash", "keyfile", "renegotiation", "requestclientcert", "serverclearoptions", "serversetoptions", "tlsv1", "tlsv11", "tlsv12", "tlsv13"}) { if (!tag->getString(field).empty()) throw ModuleException(this, "TLS settings have moved from <openssl> to <sslprofile>. See " INSPIRCD_DOCS "modules/ssl_openssl/#sslprofile for more information."); } ReadProfiles(); } } void OnModuleRehash(User* user, const std::string& param) override { if (!irc::equals(param, "tls") && !irc::equals(param, "ssl")) return; try { ReadProfiles(); ServerInstance->SNO.WriteToSnoMask('r', "OpenSSL TLS profiles have been reloaded."); } catch (const ModuleException& ex) { ServerInstance->SNO.WriteToSnoMask('r', "Failed to reload the OpenSSL TLS profiles. " + ex.GetReason()); } } void OnCleanup(ExtensionType type, Extensible* item) override { if (type == ExtensionType::USER) { LocalUser* user = IS_LOCAL((User*)item); if ((user) && (user->eh.GetModHook(this))) { // User is using TLS, they're a local user, and they're using one of *our* TLS ports. // Potentially there could be multiple TLS modules loaded at once on different ports. ServerInstance->Users.QuitUser(user, "OpenSSL module unloading"); } } } ModResult OnCheckReady(LocalUser* user) override { const OpenSSLIOHook* const iohook = static_cast<OpenSSLIOHook*>(user->eh.GetModHook(this)); if ((iohook) && (!iohook->IsHookReady())) return MOD_RES_DENY; return MOD_RES_PASSTHRU; } }; MODULE_INIT(ModuleSSLOpenSSL) �������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/src/modules/extra/m_sslrehashsignal.cpp����������������������������������������������0000664�0000000�0000000�00000003165�14771603147�0023150�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2020 Matt Schatz <genius3000@g3k.solutions> * Copyright (C) 2018-2022 Sadie Powell <sadie@witchery.services> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include "inspircd.h" static volatile sig_atomic_t signaled; class ModuleSSLRehashSignal final : public Module { private: static void SignalHandler(int) { signaled = 1; } public: ModuleSSLRehashSignal() : Module(VF_VENDOR, "Allows the SIGUSR1 signal to be sent to the server to reload TLS certificates.") { } ~ModuleSSLRehashSignal() override { signal(SIGUSR1, SIG_IGN); } void init() override { signal(SIGUSR1, SignalHandler); } void OnBackgroundTimer(time_t) override { if (!signaled) return; const std::string feedbackmsg = "Got SIGUSR1, reloading TLS credentials"; ServerInstance->SNO.WriteGlobalSno('r', feedbackmsg); ServerInstance->Logs.Normal(MODNAME, feedbackmsg); const std::string str = "tls"; FOREACH_MOD(OnModuleRehash, (nullptr, str)); signaled = 0; } }; MODULE_INIT(ModuleSSLRehashSignal) �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/src/modules/m_abbreviation.cpp�������������������������������������������������������0000664�0000000�0000000�00000005255�14771603147�0021302�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2018-2023 Sadie Powell <sadie@witchery.services> * Copyright (C) 2014 Attila Molnar <attilamolnar@hush.com> * Copyright (C) 2012 Robby <robby@chatbelgie.be> * Copyright (C) 2009-2010 Daniel De Graaf <danieldg@inspircd.org> * Copyright (C) 2008 Craig Edwards <brain@inspircd.org> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include "inspircd.h" enum { // InspIRCd-specific. ERR_AMBIGUOUSCOMMAND = 420 }; class ModuleAbbreviation final : public Module { public: ModuleAbbreviation() : Module(VF_VENDOR, "Allows commands to be abbreviated by appending a full stop.") { } void Prioritize() override { ServerInstance->Modules.SetPriority(this, I_OnPreCommand, PRIORITY_FIRST); } ModResult OnPreCommand(std::string& command, CommandBase::Params& parameters, LocalUser* user, bool validated) override { /* Command is already validated, has a length of 0, or last character is not a . */ if (validated || command.empty() || command.back() != '.') return MOD_RES_PASSTHRU; /* Look for any command that starts with the same characters, if it does, replace the command string with it */ size_t clen = command.length() - 1; std::string foundcommand; std::string matchlist; bool foundmatch = false; for (const auto& [cmdname, _] : ServerInstance->Parser.GetCommands()) { if (!command.compare(0, clen, cmdname, 0, clen)) { if (matchlist.length() > 450) { user->WriteNumeric(ERR_AMBIGUOUSCOMMAND, "Ambiguous abbreviation and too many possible matches."); return MOD_RES_DENY; } if (!foundmatch) { /* Found the command */ foundcommand = cmdname; foundmatch = true; } else matchlist.append(" ").append(cmdname); } } /* Ambiguous command, list the matches */ if (!matchlist.empty()) { user->WriteNumeric(ERR_AMBIGUOUSCOMMAND, INSP_FORMAT("Ambiguous abbreviation, possible matches: {}{}", foundcommand, matchlist)); return MOD_RES_DENY; } if (!foundcommand.empty()) { command = foundcommand; } return MOD_RES_PASSTHRU; } }; MODULE_INIT(ModuleAbbreviation) ���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/src/modules/m_account.cpp������������������������������������������������������������0000664�0000000�0000000�00000024031�14771603147�0020262�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2019 linuxdaemon <linuxdaemon.irc@gmail.com> * Copyright (C) 2013-2015 Attila Molnar <attilamolnar@hush.com> * Copyright (C) 2013, 2017-2024 Sadie Powell <sadie@witchery.services> * Copyright (C) 2012 Robby <robby@chatbelgie.be> * Copyright (C) 2009-2010 Daniel De Graaf <danieldg@inspircd.org> * Copyright (C) 2007 Dennis Friis <peavey@inspircd.org> * Copyright (C) 2006, 2008 Robin Burchell <robin+git@viroteck.net> * Copyright (C) 2006, 2008 Craig Edwards <brain@inspircd.org> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include "inspircd.h" #include "modules/account.h" #include "modules/callerid.h" #include "modules/ctctags.h" #include "modules/extban.h" #include "modules/exemption.h" #include "modules/who.h" #include "modules/whois.h" enum { // From ircd-hybrid? ERR_NEEDREGGEDNICK = 477, // From IRCv3 sasl-3.1. RPL_LOGGEDIN = 900, RPL_LOGGEDOUT = 901 }; class AccountExtItemImpl final : public StringExtItem { Events::ModuleEventProvider eventprov; public: AccountExtItemImpl(Module* mod) : StringExtItem(mod, "accountname", ExtensionType::USER, true) , eventprov(mod, "event/account") { } void FromNetwork(Extensible* container, const std::string& value) noexcept override { if (container->extype != this->extype) return; StringExtItem::FromNetwork(container, value); User* user = static_cast<User*>(container); if (IS_LOCAL(user)) { if (value.empty()) { // Logged out. user->WriteNumeric(RPL_LOGGEDOUT, user->GetMask(), "You are now logged out"); } else { // Logged in. user->WriteNumeric(RPL_LOGGEDIN, user->GetMask(), value, INSP_FORMAT("You are now logged in as {}", value)); } } eventprov.Call(&Account::EventListener::OnAccountChange, user, value); } }; class AccountAPIImpl final : public Account::APIBase { private: AccountExtItemImpl accountext; StringExtItem accountidext; ListExtItem<Account::NickList> accountnicksext; UserModeReference identifiedmode; public: AccountAPIImpl(Module* mod) : Account::APIBase(mod) , accountext(mod) , accountidext(mod, "accountid", ExtensionType::USER, true) , accountnicksext(mod, "accountnicks", ExtensionType::USER, true) , identifiedmode(mod, "u_registered") { } std::string* GetAccountId(const User* user) const override { return accountidext.Get(user); } std::string* GetAccountName(const User* user) const override { return accountext.Get(user); } Account::NickList* GetAccountNicks(const User* user) const override { return accountnicksext.Get(user); } bool IsIdentifiedToNick(const User* user) override { if (user->IsModeSet(identifiedmode)) return true; // User has +r set. // Check whether their current nick is in their nick list. Account::NickList* nicks = accountnicksext.Get(user); return nicks && nicks->find(user->nick) != nicks->end(); } }; class AccountExtBan final : public ExtBan::MatchingBase { private: AccountAPIImpl& accountapi; public: AccountExtBan(Module* Creator, AccountAPIImpl& AccountAPI) : ExtBan::MatchingBase(Creator, "account", 'R') , accountapi(AccountAPI) { } bool IsMatch(User* user, Channel* channel, const std::string& text) override { const auto* nicks = accountapi.GetAccountNicks(user); if (nicks) { for (const auto& nick : *nicks) { if (InspIRCd::Match(nick, text)) return true; } } const auto* account = accountapi.GetAccountName(user); return account && InspIRCd::Match(*account, text); } }; class UnauthedExtBan final : public ExtBan::MatchingBase { private: AccountAPIImpl& accountapi; public: UnauthedExtBan(Module* Creator, AccountAPIImpl& AccountAPI) : ExtBan::MatchingBase(Creator, "unauthed", 'U') , accountapi(AccountAPI) { } bool IsMatch(User* user, Channel* channel, const std::string& text) override { const std::string* account = accountapi.GetAccountName(user); return !account && channel->CheckBan(user, text); } }; class ModuleAccount final : public Module , public CTCTags::EventListener , public Who::EventListener , public Whois::EventListener { private: CallerID::API calleridapi; CheckExemption::EventProvider exemptionprov; SimpleChannelMode reginvitemode; SimpleChannelMode regmoderatedmode; SimpleUserMode regdeafmode; AccountAPIImpl accountapi; AccountExtBan accountextban; UnauthedExtBan unauthedextban; public: ModuleAccount() : Module(VF_VENDOR | VF_OPTCOMMON, "Adds support for user accounts.") , CTCTags::EventListener(this) , Who::EventListener(this) , Whois::EventListener(this) , calleridapi(this) , exemptionprov(this) , reginvitemode(this, "reginvite", 'R') , regmoderatedmode(this, "regmoderated", 'M') , regdeafmode(this, "regdeaf", 'R') , accountapi(this) , accountextban(this, accountapi) , unauthedextban(this, accountapi) { } ModResult OnWhoLine(const Who::Request& request, LocalUser* source, User* user, Membership* memb, Numeric::Numeric& numeric) override { size_t flag_index; if (!request.GetFieldIndex('f', flag_index)) return MOD_RES_PASSTHRU; if (accountapi.IsIdentifiedToNick(user)) numeric.GetParams()[flag_index].push_back('r'); return MOD_RES_PASSTHRU; } void OnWhois(Whois::Context& whois) override { const std::string* account = accountapi.GetAccountName(whois.GetTarget()); if (account) whois.SendLine(RPL_WHOISACCOUNT, *account, "is logged in as"); if (accountapi.IsIdentifiedToNick(whois.GetTarget())) whois.SendLine(RPL_WHOISREGNICK, "is a registered nick"); } ModResult HandleMessage(User* user, const MessageTarget& target) { if (!IS_LOCAL(user)) return MOD_RES_PASSTHRU; const std::string* account = accountapi.GetAccountName(user); switch (target.type) { case MessageTarget::TYPE_CHANNEL: { auto* targetchan = target.Get<Channel>(); if (!targetchan->IsModeSet(regmoderatedmode) || account) return MOD_RES_PASSTHRU; if (exemptionprov.Check(user, targetchan, "regmoderated") == MOD_RES_ALLOW) return MOD_RES_PASSTHRU; // User is messaging a +M channel and is not registered or exempt. user->WriteNumeric(ERR_NEEDREGGEDNICK, targetchan->name, "You need to be identified to a registered account to message this channel"); return MOD_RES_DENY; } case MessageTarget::TYPE_USER: { auto* targetuser = target.Get<User>(); if (!targetuser->IsModeSet(regdeafmode) || account) return MOD_RES_PASSTHRU; if (calleridapi && calleridapi->IsOnAcceptList(user, targetuser)) return MOD_RES_PASSTHRU; // User is messaging a +R user and is not registered or on an accept list. user->WriteNumeric(ERR_NEEDREGGEDNICK, targetuser->nick, "You need to be identified to a registered account to message this user"); return MOD_RES_DENY; } case MessageTarget::TYPE_SERVER: break; } return MOD_RES_PASSTHRU; } ModResult OnUserPreMessage(User* user, MessageTarget& target, MessageDetails& details) override { return HandleMessage(user, target); } ModResult OnUserPreTagMessage(User* user, MessageTarget& target, CTCTags::TagMessageDetails& details) override { return HandleMessage(user, target); } ModResult OnUserPreJoin(LocalUser* user, Channel* chan, const std::string& cname, std::string& privs, const std::string& keygiven, bool override) override { if (override) return MOD_RES_PASSTHRU; const std::string* account = accountapi.GetAccountName(user); if (chan) { if (chan->IsModeSet(reginvitemode)) { if (!account) { // joining a +R channel and not identified user->WriteNumeric(ERR_NEEDREGGEDNICK, chan->name, "You need to be identified to a registered account to join this channel"); return MOD_RES_DENY; } } } return MOD_RES_PASSTHRU; } ModResult OnPreOperLogin(LocalUser* user, const std::shared_ptr<OperAccount>& oper, bool automatic) override { const std::string accountstr = oper->GetConfig()->getString("account"); if (accountstr.empty()) return MOD_RES_PASSTHRU; const std::string* accountid = accountapi.GetAccountId(user); const std::string* accountname = accountapi.GetAccountName(user); irc::spacesepstream accountstream(accountstr); for (std::string account; accountstream.GetToken(account); ) { if (accountid && irc::equals(account, *accountid)) return MOD_RES_PASSTHRU; // Matches on account id. if (accountname && irc::equals(account, *accountname)) return MOD_RES_PASSTHRU; // Matches on account name. } if (!automatic) { ServerInstance->SNO.WriteGlobalSno('o', "{} ({}) [{}] failed to log into the \x02{}\x02 oper account because they are not logged into the correct user account.", user->nick, user->GetRealUserHost(), user->GetAddress(), oper->GetName()); } return MOD_RES_DENY; // Account required but it does not match. } ModResult OnPreChangeConnectClass(LocalUser* user, const std::shared_ptr<ConnectClass>& klass, std::optional<Numeric::Numeric>& errnum) override { const char* error = nullptr; if (insp::equalsci(klass->config->getString("requireaccount"), "nick")) { if (!accountapi.GetAccountName(user) && !accountapi.IsIdentifiedToNick(user)) error = "an account matching their current nickname"; } else if (klass->config->getBool("requireaccount")) { if (!accountapi.GetAccountName(user)) error = "an account"; } if (error) { ServerInstance->Logs.Debug("CONNECTCLASS", "The {} connect class is not suitable as it requires the user to be logged into {}.", klass->GetName(), error); return MOD_RES_DENY; } return MOD_RES_PASSTHRU; } }; MODULE_INIT(ModuleAccount) �������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/src/modules/m_alias.cpp��������������������������������������������������������������0000664�0000000�0000000�00000026475�14771603147�0017735�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2018-2019 linuxdaemon <linuxdaemon.irc@gmail.com> * Copyright (C) 2013, 2015-2024 Sadie Powell <sadie@witchery.services> * Copyright (C) 2012-2015 Attila Molnar <attilamolnar@hush.com> * Copyright (C) 2012 Robby <robby@chatbelgie.be> * Copyright (C) 2009-2010 Daniel De Graaf <danieldg@inspircd.org> * Copyright (C) 2009 Matt Smith <dz@inspircd.org> * Copyright (C) 2008-2009 Robin Burchell <robin+git@viroteck.net> * Copyright (C) 2007-2008 Dennis Friis <peavey@inspircd.org> * Copyright (C) 2006-2009 Craig Edwards <brain@inspircd.org> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include "inspircd.h" /** An alias definition */ class Alias final { public: /** The text of the alias command */ std::string AliasedCommand; /** Text to replace with */ std::string ReplaceFormat; /** Nickname required to perform alias */ std::string RequiredNick; /** Alias requires the required nick to be on a services server */ bool ServiceOnly; /** Requires oper? */ bool OperOnly; /* whether or not it may be executed via fantasy (default OFF) */ bool ChannelCommand; /* whether or not it may be executed via /command (default ON) */ bool UserCommand; /** Format that must be matched for use */ std::string format; /** Strip color codes before match? */ bool StripColor; }; class ModuleAlias final : public Module { std::string fprefix; /* We cant use a map, there may be multiple aliases with the same name. * We can, however, use a fancy invention: the multimap. Maps a key to one or more values. * -- w00t */ typedef insp::flat_multimap<std::string, Alias, irc::insensitive_swo> AliasMap; AliasMap Aliases; /* whether or not +B users are allowed to use fantasy commands */ bool AllowBots; UserModeReference botmode; // Whether we are actively executing an alias. bool active = false; public: void ReadConfig(ConfigStatus& status) override { AliasMap newAliases; for (const auto& [_, tag] : ServerInstance->Config->ConfTags("alias")) { Alias a; a.AliasedCommand = tag->getString("text"); if (a.AliasedCommand.empty()) throw ModuleException(this, "<alias:text> is empty! at " + tag->source.str()); tag->readString("replace", a.ReplaceFormat, true); if (a.ReplaceFormat.empty()) throw ModuleException(this, "<alias:replace> is empty! at " + tag->source.str()); a.RequiredNick = tag->getString("requires"); a.ServiceOnly = tag->getBool("service", tag->getBool("uline")); a.ChannelCommand = tag->getBool("channelcommand", false); a.UserCommand = tag->getBool("usercommand", true); a.OperOnly = tag->getBool("operonly"); a.format = tag->getString("format"); a.StripColor = tag->getBool("stripcolor"); std::transform(a.AliasedCommand.begin(), a.AliasedCommand.end(), a.AliasedCommand.begin(), ::toupper); newAliases.emplace(a.AliasedCommand, a); } const auto& fantasy = ServerInstance->Config->ConfValue("fantasy"); AllowBots = fantasy->getBool("allowbots", false); fprefix = fantasy->getString("prefix", "!", 1, ServerInstance->Config->Limits.MaxLine); Aliases.swap(newAliases); } ModuleAlias() : Module(VF_VENDOR, "Allows the server administrator to define custom channel commands (e.g. !kick) and server commands (e.g. /OPERSERV).") , botmode(this, "bot") { } static std::string GetVar(std::string varname, const std::string& original_line) { irc::spacesepstream ss(original_line); varname.erase(varname.begin()); int index = *(varname.begin()) - 48; varname.erase(varname.begin()); bool everything_after = (varname == "-"); std::string word; for (int j = 0; j < index; j++) ss.GetToken(word); if (everything_after) { std::string more; while (ss.GetToken(more)) { word.append(" "); word.append(more); } } return word; } static std::string CreateRFCMessage(const std::string& command, CommandBase::Params& parameters) { std::string message(command); for (CommandBase::Params::const_iterator iter = parameters.begin(); iter != parameters.end();) { const std::string& parameter = *iter++; message.push_back(' '); if (iter == parameters.end() && (parameter.empty() || parameter.find(' ') != std::string::npos)) message.push_back(':'); message.append(parameter); } return message; } ModResult OnPreCommand(std::string& command, CommandBase::Params& parameters, LocalUser* user, bool validated) override { // If they're not fully connected yet, we dont want to know. if (!user->IsFullyConnected()) return MOD_RES_PASSTHRU; /* We dont have any commands looking like this? Stop processing. */ auto aliases = insp::equal_range(Aliases, command); if (aliases.empty()) return MOD_RES_PASSTHRU; /* The parameters for the command in their original form, with the command stripped off */ std::string original_line = CreateRFCMessage(command, parameters); std::string compare(original_line, command.length()); while (*(compare.c_str()) == ' ') compare.erase(compare.begin()); for (const auto& [_, alias] : aliases) { if (alias.UserCommand) { if (DoAlias(user, nullptr, alias, compare, original_line)) { return MOD_RES_DENY; } } } // If we made it here, no aliases actually matched. return MOD_RES_PASSTHRU; } ModResult OnUserPreMessage(User* user, MessageTarget& target, MessageDetails& details) override { // Don't echo anything which is caused by an alias. if (active) details.echo = false; return MOD_RES_PASSTHRU; } void OnUserPostMessage(User* user, const MessageTarget& target, const MessageDetails& details) override { // Don't allow aliases to trigger other aliases. if (active) return; if ((target.type != MessageTarget::TYPE_CHANNEL) || (details.type != MessageType::PRIVMSG)) { return; } // fcommands are only for local users. Spanningtree will send them back out as their original cmd. LocalUser* luser = IS_LOCAL(user); if (!luser) { return; } /* Stop here if the user is +B and allowbot is set to no. */ if (!AllowBots && user->IsModeSet(botmode)) { return; } auto* c = target.Get<Channel>(); std::string scommand; // text is like "!moo cows bite me", we want "!moo" first irc::spacesepstream ss(details.text); ss.GetToken(scommand); if (scommand.size() <= fprefix.size()) { return; // wtfbbq } // we don't want to touch non-fantasy stuff if (scommand.compare(0, fprefix.size(), fprefix) != 0) { return; } // nor do we give a shit about the prefix scommand.erase(0, fprefix.size()); auto aliases = insp::equal_range(Aliases, scommand); if (aliases.empty()) return; /* The parameters for the command in their original form, with the command stripped off */ std::string compare(details.text, scommand.length() + fprefix.size()); while (*(compare.c_str()) == ' ') compare.erase(compare.begin()); for (const auto& [_, alias] : aliases) { if (alias.ChannelCommand) { // We use substr here to remove the fantasy prefix if (DoAlias(luser, c, alias, compare, details.text.substr(fprefix.size()))) return; } } } int DoAlias(LocalUser* user, Channel* c, const Alias& a, const std::string& compare, const std::string& safe) { std::string stripped(compare); if (a.StripColor) InspIRCd::StripColor(stripped); /* Does it match the pattern? */ if (!a.format.empty()) { if (!InspIRCd::Match(stripped, a.format)) return 0; } if ((a.OperOnly) && (!user->IsOper())) return 0; if (!a.RequiredNick.empty()) { int numeric = a.ServiceOnly ? ERR_NOSUCHSERVICE : ERR_NOSUCHNICK; auto* u = ServerInstance->Users.FindNick(a.RequiredNick); if (!u) { user->WriteNumeric(numeric, a.RequiredNick, "is currently unavailable. Please try again later."); return 1; } if ((a.ServiceOnly) && (!u->server->IsService())) { ServerInstance->SNO.WriteToSnoMask('a', "NOTICE -- Service "+a.RequiredNick+" required by alias "+a.AliasedCommand+" is not on a services server, possibly underhanded antics detected!"); user->WriteNumeric(numeric, a.RequiredNick, "is not a network service! Please inform a server operator as soon as possible."); return 1; } } /* Now, search and replace in a copy of the original_line, replacing $1 through $9 and $1- etc */ std::string::size_type crlf = a.ReplaceFormat.find('\n'); if (crlf == std::string::npos) { DoCommand(a.ReplaceFormat, user, c, safe, a); return 1; } else { irc::sepstream commands(a.ReplaceFormat, '\n'); std::string scommand; while (commands.GetToken(scommand)) { DoCommand(scommand, user, c, safe, a); } return 1; } } void DoCommand(const std::string& newline, LocalUser* user, Channel* chan, const std::string& original_line, const Alias& a) { std::string result; result.reserve(newline.length()); for (unsigned int i = 0; i < newline.length(); i++) { char c = newline[i]; if ((c == '$') && (i + 1 < newline.length())) { if (isdigit(newline[i+1])) { size_t len = ((i + 2 < newline.length()) && (newline[i+2] == '-')) ? 3 : 2; std::string var = newline.substr(i, len); result.append(GetVar(var, original_line)); i += len - 1; } else if (!newline.compare(i, 5, "$nick", 5)) { result.append(user->nick); i += 4; } else if (!newline.compare(i, 5, "$host", 5)) { result.append(user->GetRealHost()); i += 4; } else if (!newline.compare(i, 5, "$chan", 5)) { if (chan) result.append(chan->name); i += 4; } else if (!newline.compare(i, 5, "$user", 5)) { result.append(user->GetRealUser()); i += 4; } else if (!newline.compare(i, 6, "$vhost", 6)) { result.append(user->GetDisplayedHost()); i += 5; } else if (!newline.compare(i, 12, "$requirement", 12)) { result.append(a.RequiredNick); i += 11; } else if (!newline.compare(i, 6, "$address", 8)) { result.append(user->GetAddress()); i += 7; } else if (!newline.compare(i, 6, "$ident", 6)) { // TODO: remove this in the next major release. result.append(user->GetRealUser()); i += 5; } else result.push_back(c); } else result.push_back(c); } irc::tokenstream ss(result); CommandBase::Params pars; std::string command; std::string token; ss.GetMiddle(command); while (ss.GetTrailing(token)) { pars.push_back(token); } active = true; ServerInstance->Parser.ProcessCommand(user, command, pars); active = false; } void Prioritize() override { // Prioritise after spanningtree so that channel aliases show the alias before the effects. Module* linkmod = ServerInstance->Modules.Find("spanningtree"); ServerInstance->Modules.SetPriority(this, I_OnUserPostMessage, PRIORITY_AFTER, linkmod); } }; MODULE_INIT(ModuleAlias) ���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/src/modules/m_allowinvite.cpp��������������������������������������������������������0000664�0000000�0000000�00000004040�14771603147�0021161�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2017, 2019-2022 Sadie Powell <sadie@witchery.services> * Copyright (C) 2012-2013 Attila Molnar <attilamolnar@hush.com> * Copyright (C) 2012 Robby <robby@chatbelgie.be> * Copyright (C) 2009-2010 Daniel De Graaf <danieldg@inspircd.org> * Copyright (C) 2009 Matt Smith <dz@inspircd.org> * Copyright (C) 2008 Robin Burchell <robin+git@viroteck.net> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include "inspircd.h" #include "modules/extban.h" class ModuleAllowInvite final : public Module { private: ExtBan::Acting extban; SimpleChannelMode ni; public: ModuleAllowInvite() : Module(VF_VENDOR, "Adds channel mode A (allowinvite) which allows unprivileged users to use the /INVITE command and extended ban A: (blockinvite) which bans specific masks from using the /INVITE command.") , extban(this, "blockinvite", 'A') , ni(this, "allowinvite", 'A') { } ModResult OnUserPreInvite(User* user, User* dest, Channel* channel, time_t timeout) override { if (IS_LOCAL(user)) { ModResult res = extban.GetStatus(user, channel); if (res == MOD_RES_DENY) { // Matching extban, explicitly deny /invite user->WriteNumeric(ERR_RESTRICTED, channel->name, "You are banned from using INVITE"); return res; } if (channel->IsModeSet(ni) || res == MOD_RES_ALLOW) { // Explicitly allow /invite return MOD_RES_ALLOW; } } return MOD_RES_PASSTHRU; } }; MODULE_INIT(ModuleAllowInvite) ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/src/modules/m_alltime.cpp������������������������������������������������������������0000664�0000000�0000000�00000003652�14771603147�0020263�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2019-2023, 2025 Sadie Powell <sadie@witchery.services> * Copyright (C) 2012 Robby <robby@chatbelgie.be> * Copyright (C) 2012 Attila Molnar <attilamolnar@hush.com> * Copyright (C) 2009-2010 Daniel De Graaf <danieldg@inspircd.org> * Copyright (C) 2007 Craig Edwards <brain@inspircd.org> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include "inspircd.h" #include "timeutils.h" class CommandAlltime final : public Command { public: CommandAlltime(Module* Creator) : Command(Creator, "ALLTIME", 0) { access_needed = CmdAccess::OPERATOR; } CmdResult Handle(User* user, const Params& parameters) override { auto timestr = Time::ToString(ServerInstance->Time(), Time::DEFAULT_LONG, true); timestr += INSP_FORMAT(" ({})", ServerInstance->Time()); user->WriteRemoteNumeric(RPL_TIME, ServerInstance->Config->ServerName, timestr); return CmdResult::SUCCESS; } RouteDescriptor GetRouting(User* user, const Params& parameters) override { return ROUTE_OPT_BCAST; } }; class Modulealltime final : public Module { private: CommandAlltime mycommand; public: Modulealltime() : Module(VF_VENDOR | VF_OPTCOMMON, "Adds the /ALLTIME command which allows server operators to see the current UTC time on all of the servers on the network.") , mycommand(this) { } }; MODULE_INIT(Modulealltime) ��������������������������������������������������������������������������������������inspircd-4.7.0/src/modules/m_anticaps.cpp�����������������������������������������������������������0000664�0000000�0000000�00000021021�14771603147�0020424�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2018-2024 Sadie Powell <sadie@witchery.services> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include <cmath> #include "inspircd.h" #include "extension.h" #include "modules/exemption.h" #include "numerichelper.h" enum class AntiCapsMethod : uint8_t { BAN, BLOCK, MUTE, KICK, KICK_BAN, }; class AntiCapsSettings final { public: const AntiCapsMethod method; const uint16_t minlen; const uint8_t percent; AntiCapsSettings(const AntiCapsMethod& m, uint16_t ml, uint8_t p) : method(m) , minlen(ml) , percent(p) { } static bool Parse(irc::sepstream& stream, AntiCapsMethod& method, uint16_t& minlen, uint8_t& percent) { return ParseMethod(stream, method) && ParseMinimumLength(stream, minlen) && ParsePercent(stream, percent); } static bool ParseMethod(irc::sepstream& stream, AntiCapsMethod& method) { std::string methodstr; if (!stream.GetToken(methodstr)) return false; if (irc::equals(methodstr, "ban")) method = AntiCapsMethod::BAN; else if (irc::equals(methodstr, "block")) method = AntiCapsMethod::BLOCK; else if (irc::equals(methodstr, "mute")) method = AntiCapsMethod::MUTE; else if (irc::equals(methodstr, "kick")) method = AntiCapsMethod::KICK; else if (irc::equals(methodstr, "kickban")) method = AntiCapsMethod::KICK_BAN; else return false; return true; } static bool ParseMinimumLength(irc::sepstream& stream, uint16_t& minlen) { std::string minlenstr; if (!stream.GetToken(minlenstr)) return false; uint16_t result = ConvToNum<uint16_t>(minlenstr); if (result < 1 || result > ServerInstance->Config->Limits.MaxLine) return false; minlen = result; return true; } static bool ParsePercent(irc::sepstream& stream, uint8_t& percent) { std::string percentstr; if (!stream.GetToken(percentstr)) return false; uint8_t result = ConvToNum<uint8_t>(percentstr); if (result < 1 || result > 100) return false; percent = result; return true; } }; class AntiCapsMode final : public ParamMode<AntiCapsMode, SimpleExtItem<AntiCapsSettings>> { public: AntiCapsMode(Module* Creator) : ParamMode<AntiCapsMode, SimpleExtItem<AntiCapsSettings>>(Creator, "anticaps", 'B') { syntax = "{ban|block|mute|kick|kickban}:<minlen>:<percent>"; } bool OnSet(User* source, Channel* channel, std::string& parameter) override { irc::sepstream stream(parameter, ':'); AntiCapsMethod method; uint16_t minlen; uint8_t percent; // Attempt to parse the settings. if (!AntiCapsSettings::Parse(stream, method, minlen, percent)) { source->WriteNumeric(Numerics::InvalidModeParameter(channel, this, parameter)); return false; } ext.SetFwd(channel, method, minlen, percent); return true; } void SerializeParam(Channel* chan, const AntiCapsSettings* acs, std::string& out) { switch (acs->method) { case AntiCapsMethod::BAN: out.append("ban"); break; case AntiCapsMethod::BLOCK: out.append("block"); break; case AntiCapsMethod::MUTE: out.append("mute"); break; case AntiCapsMethod::KICK: out.append("kick"); break; case AntiCapsMethod::KICK_BAN: out.append("kickban"); break; } out.push_back(':'); out.append(ConvToStr(acs->minlen)); out.push_back(':'); out.append(ConvToStr<uint16_t>(acs->percent)); } }; class ModuleAntiCaps final : public Module { private: ChanModeReference banmode; CheckExemption::EventProvider exemptionprov; CharState uppercase; CharState lowercase; AntiCapsMode mode; std::string message; void CreateBan(Channel* channel, User* user, bool mute) { std::string banmask(mute ? "m:*!" : "*!"); banmask.append(user->GetBanUser(false)); banmask.append("@"); banmask.append(user->GetDisplayedHost()); Modes::ChangeList changelist; changelist.push_add(*banmode, banmask); ServerInstance->Modes.Process(ServerInstance->FakeClient, channel, nullptr, changelist); } static void InformUser(Channel* channel, User* user, const std::string& msg) { user->WriteNumeric(Numerics::CannotSendTo(channel, msg)); } public: ModuleAntiCaps() : Module(VF_VENDOR | VF_COMMON, "Adds channel mode B (anticaps) which allows channels to block messages which are excessively capitalised.") , banmode(this, "ban") , exemptionprov(this) , mode(this) { } void ReadConfig(ConfigStatus&) override { const auto& tag = ServerInstance->Config->ConfValue("anticaps"); uppercase.reset(); for (const auto chr : tag->getString("uppercase", "ABCDEFGHIJKLMNOPQRSTUVWXYZ", 1)) uppercase.set(static_cast<unsigned char>(chr)); lowercase.reset(); for (const auto chr : tag->getString("lowercase", "abcdefghijklmnopqrstuvwxyz", 1)) lowercase.set(static_cast<unsigned char>(chr)); message = tag->getString("message", "Your message exceeded the %percent%%% upper case character threshold for %channel%", 1); } ModResult OnUserPreMessage(User* user, MessageTarget& target, MessageDetails& details) override { // We only want to operate on messages from local users. if (!IS_LOCAL(user)) return MOD_RES_PASSTHRU; // The mode can only be applied to channels. if (target.type != MessageTarget::TYPE_CHANNEL) return MOD_RES_PASSTHRU; // We only act if the channel has the mode set. auto* channel = target.Get<Channel>(); if (!channel->IsModeSet(&mode)) return MOD_RES_PASSTHRU; // If the user is exempt from anticaps then we don't need // to do anything else. ModResult result = exemptionprov.Check(user, channel, "anticaps"); if (result == MOD_RES_ALLOW) return MOD_RES_PASSTHRU; // If the message is a CTCP then we skip it unless it is // an ACTION in which case we just check against the body. std::string_view ctcpname; std::string_view msgbody(details.text); if (details.IsCTCP(ctcpname, msgbody)) { // If the CTCP is not an action then skip it. if (!irc::equals(ctcpname, "ACTION")) return MOD_RES_PASSTHRU; } // Retrieve the anticaps config. This should never be // null but its better to be safe than sorry. AntiCapsSettings* config = mode.ext.Get(channel); if (!config) return MOD_RES_PASSTHRU; // If the message is shorter than the minimum length then // we don't need to do anything else. size_t length = msgbody.length(); if (length < config->minlen) return MOD_RES_PASSTHRU; // Count the characters to see how many upper case and // ignored (non upper or lower) characters there are. size_t upper = 0; size_t lower = 0; for (const auto chr : msgbody) { if (uppercase.test(static_cast<unsigned char>(chr))) upper += 1; else if (lowercase.test(static_cast<unsigned char>(chr))) lower += 1; else length -= 1; } // If the message was entirely symbols then the message // can't contain any upper case letters. if (length == 0) return MOD_RES_PASSTHRU; // Calculate the percentage. double percent = round((upper * 100) / length); if (percent < config->percent) return MOD_RES_PASSTHRU; const auto msg = Template::Replace(message, { { "channel", channel->name }, { "lower", ConvToStr(lower) }, { "minlen", ConvToStr(config->minlen) }, { "percent", ConvToStr<uint16_t>(config->percent) }, { "punctuation", ConvToStr(msgbody.length() - upper - lower) }, { "upper", ConvToStr(upper) }, }); switch (config->method) { case AntiCapsMethod::BAN: InformUser(channel, user, msg); CreateBan(channel, user, false); break; case AntiCapsMethod::BLOCK: InformUser(channel, user, msg); break; case AntiCapsMethod::MUTE: InformUser(channel, user, msg); CreateBan(channel, user, true); break; case AntiCapsMethod::KICK: channel->KickUser(ServerInstance->FakeClient, user, msg); break; case AntiCapsMethod::KICK_BAN: CreateBan(channel, user, false); channel->KickUser(ServerInstance->FakeClient, user, msg); break; } return MOD_RES_DENY; } }; MODULE_INIT(ModuleAntiCaps) ���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/src/modules/m_auditorium.cpp���������������������������������������������������������0000664�0000000�0000000�00000014704�14771603147�0021016�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2017-2023 Sadie Powell <sadie@witchery.services> * Copyright (C) 2013-2014, 2016, 2018 Attila Molnar <attilamolnar@hush.com> * Copyright (C) 2012 Robby <robby@chatbelgie.be> * Copyright (C) 2009-2010 Daniel De Graaf <danieldg@inspircd.org> * Copyright (C) 2008 Robin Burchell <robin+git@viroteck.net> * Copyright (C) 2007-2008 Craig Edwards <brain@inspircd.org> * Copyright (C) 2007, 2009 Dennis Friis <peavey@inspircd.org> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include "inspircd.h" #include "clientprotocolevent.h" #include "modules/exemption.h" #include "modules/names.h" #include "modules/who.h" class AuditoriumMode final : public SimpleChannelMode { public: AuditoriumMode(Module* Creator) : SimpleChannelMode(Creator, "auditorium", 'u') { ranktoset = ranktounset = OP_VALUE; } }; class ModuleAuditorium; namespace { /** Hook handler for join client protocol events. * This allows us to block join protocol events completely, including all associated messages (e.g. MODE, away-notify AWAY). * This is not the same as OnUserJoin() because that runs only when a real join happens but this runs also when a module * such as delayjoin or hostcycle generates a join. */ class JoinHook final : public ClientProtocol::EventHook { ModuleAuditorium* const parentmod; bool active; public: JoinHook(ModuleAuditorium* mod); void OnEventInit(const ClientProtocol::Event& ev) override; ModResult OnPreEventSend(LocalUser* user, const ClientProtocol::Event& ev, ClientProtocol::MessageList& messagelist) override; }; } class ModuleAuditorium final : public Module , public Names::EventListener , public Who::EventListener , public Who::VisibleEventListener { CheckExemption::EventProvider exemptionprov; AuditoriumMode aum; bool OpsVisible; bool OpsCanSee; bool OperCanSee; JoinHook joinhook; public: ModuleAuditorium() : Module(VF_VENDOR, "Adds channel mode u (auditorium) which hides unprivileged users in a channel from each other.") , Names::EventListener(this) , Who::EventListener(this) , Who::VisibleEventListener(this) , exemptionprov(this) , aum(this) , joinhook(this) { } void ReadConfig(ConfigStatus& status) override { const auto& tag = ServerInstance->Config->ConfValue("auditorium"); OpsVisible = tag->getBool("opvisible"); OpsCanSee = tag->getBool("opcansee"); OperCanSee = tag->getBool("opercansee", true); } /* Can they be seen by everyone? */ bool IsVisible(Membership* memb) { if (!memb->chan->IsModeSet(&aum)) return true; ModResult res = exemptionprov.Check(memb->user, memb->chan, "auditorium-vis"); return res.check(OpsVisible && memb->GetRank() >= OP_VALUE); } /* Can they see this specific membership? */ bool CanSee(User* issuer, Membership* memb) { // If user is oper and operoverride is on, don't touch the list if (OperCanSee && issuer->HasPrivPermission("channels/auspex")) return true; // You can always see yourself if (issuer == memb->user) return true; // Can you see the list by permission? ModResult res = exemptionprov.Check(issuer, memb->chan, "auditorium-see"); return res.check(OpsCanSee && memb->chan->GetPrefixValue(issuer) >= OP_VALUE); } ModResult OnNamesListItem(LocalUser* issuer, Membership* memb, std::string& prefixes, std::string& nick) override { if (IsVisible(memb)) return MOD_RES_PASSTHRU; if (CanSee(issuer, memb)) return MOD_RES_PASSTHRU; // Don't display this user in the NAMES list return MOD_RES_DENY; } /** Build CUList for showing this join/part/kick */ void BuildExcept(Membership* memb, CUList& excepts) { if (IsVisible(memb)) return; for (const auto& [user, _] : memb->chan->GetUsers()) { if (IS_LOCAL(user) && !CanSee(user, memb)) excepts.insert(user); } } void OnUserPart(Membership* memb, std::string& partmessage, CUList& excepts) override { BuildExcept(memb, excepts); } void OnUserKick(User* source, Membership* memb, const std::string& reason, CUList& excepts) override { BuildExcept(memb, excepts); } void OnBuildNeighborList(User* source, User::NeighborList& include, User::NeighborExceptions& exception) override { for (User::NeighborList::iterator i = include.begin(); i != include.end(); ) { Membership* memb = *i; if (IsVisible(memb)) { ++i; continue; } // this channel should not be considered when listing my neighbors i = include.erase(i); // however, that might hide me from ops that can see me... for (const auto& [user, _] : memb->chan->GetUsers()) { if (IS_LOCAL(user) && CanSee(user, memb)) exception[user] = true; } } } ModResult OnWhoLine(const Who::Request& request, LocalUser* source, User* user, Membership* memb, Numeric::Numeric& numeric) override { if (!memb) return MOD_RES_PASSTHRU; if (IsVisible(memb)) return MOD_RES_PASSTHRU; if (CanSee(source, memb)) return MOD_RES_PASSTHRU; return MOD_RES_DENY; } ModResult OnWhoVisible(const Who::Request& request, LocalUser* source, Membership* memb) override { // Never pick a channel as the first visible one if the channel is in auditorium mode. return IsVisible(memb) || CanSee(source, memb) ? MOD_RES_PASSTHRU : MOD_RES_DENY; } }; JoinHook::JoinHook(ModuleAuditorium* mod) : ClientProtocol::EventHook(mod, "JOIN", 10) , parentmod(mod) { } void JoinHook::OnEventInit(const ClientProtocol::Event& ev) { const ClientProtocol::Events::Join& join = static_cast<const ClientProtocol::Events::Join&>(ev); active = !parentmod->IsVisible(join.GetMember()); } ModResult JoinHook::OnPreEventSend(LocalUser* user, const ClientProtocol::Event& ev, ClientProtocol::MessageList& messagelist) { if (!active) return MOD_RES_PASSTHRU; const ClientProtocol::Events::Join& join = static_cast<const ClientProtocol::Events::Join&>(ev); return ((parentmod->CanSee(user, join.GetMember())) ? MOD_RES_PASSTHRU : MOD_RES_DENY); } MODULE_INIT(ModuleAuditorium) ������������������������������������������������������������inspircd-4.7.0/src/modules/m_autoop.cpp�������������������������������������������������������������0000664�0000000�0000000�00000007373�14771603147�0020147�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2017-2023 Sadie Powell <sadie@witchery.services> * Copyright (C) 2012-2014 Attila Molnar <attilamolnar@hush.com> * Copyright (C) 2012 Robby <robby@chatbelgie.be> * Copyright (C) 2011 jackmcbarn <jackmcbarn@inspircd.org> * Copyright (C) 2010 Daniel De Graaf <danieldg@inspircd.org> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include "inspircd.h" #include "listmode.h" enum { // InspIRCd-specific. RPL_ACCESSLIST = 910, RPL_ENDOFACCESSLIST = 911 }; class AutoOpList final : public ListModeBase { public: AutoOpList(Module* Creator) : ListModeBase(Creator, "autoop", 'w', RPL_ACCESSLIST, RPL_ENDOFACCESSLIST) { ranktoset = ranktounset = OP_VALUE; syntax = "<prefix>:<mask>"; } static PrefixMode* FindMode(const std::string& mid) { if (mid.length() == 1) { PrefixMode* pm = ServerInstance->Modes.FindPrefixMode(mid[0]); if (!pm) pm = ServerInstance->Modes.FindPrefix(mid[0]); return pm; } ModeHandler* mh = ServerInstance->Modes.FindMode(mid, MODETYPE_CHANNEL); return mh ? mh->IsPrefixMode() : nullptr; } ModResult AccessCheck(User* source, Channel* channel, Modes::Change& change) override { std::string::size_type pos = change.param.find(':'); if (pos == 0 || pos == std::string::npos) return change.adding ? MOD_RES_DENY : MOD_RES_PASSTHRU; ModeHandler::Rank mylevel = channel->GetPrefixValue(source); std::string mid(change.param, 0, pos); PrefixMode* mh = FindMode(mid); if (change.adding && !mh) { source->WriteNumeric(ERR_UNKNOWNMODE, mid, INSP_FORMAT("Cannot find prefix mode '{}' for autoop", mid)); return MOD_RES_DENY; } else if (!mh) return MOD_RES_PASSTHRU; Modes::Change modechange(mh, true, ""); if (mh->AccessCheck(source, channel, change) == MOD_RES_DENY) return MOD_RES_DENY; if (mh->GetLevelRequired(change.adding) > mylevel) { source->WriteNumeric(ERR_CHANOPRIVSNEEDED, channel->name, INSP_FORMAT("You must be able to {} mode {} ({}) to {} an autoop containing it", change.adding ? "set" : "unset", mh->GetModeChar(), mh->name, change.adding ? "add" : "remove")); return MOD_RES_DENY; } return MOD_RES_PASSTHRU; } }; class ModuleAutoOp final : public Module { AutoOpList mh; public: ModuleAutoOp() : Module(VF_VENDOR, "Adds channel mode w (autoop) which allows channel operators to define an access list which gives status ranks to users on join.") , mh(this) { } void OnPostJoin(Membership* memb) override { if (!IS_LOCAL(memb->user)) return; ListModeBase::ModeList* list = mh.GetList(memb->chan); if (list) { Modes::ChangeList changelist; for (const auto& entry : *list) { std::string::size_type colon = entry.mask.find(':'); if (colon == std::string::npos) continue; if (memb->chan->CheckBan(memb->user, entry.mask.substr(colon + 1))) { PrefixMode* given = AutoOpList::FindMode(entry.mask.substr(0, colon)); if (given) changelist.push_add(given, memb->user->nick); } } ServerInstance->Modes.Process(ServerInstance->FakeClient, memb->chan, nullptr, changelist); } } void ReadConfig(ConfigStatus& status) override { mh.DoRehash(); } }; MODULE_INIT(ModuleAutoOp) ���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/src/modules/m_banexception.cpp�������������������������������������������������������0000664�0000000�0000000�00000007457�14771603147�0021322�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2017-2023 Sadie Powell <sadie@witchery.services> * Copyright (C) 2012-2013 Attila Molnar <attilamolnar@hush.com> * Copyright (C) 2012 Robby <robby@chatbelgie.be> * Copyright (C) 2009-2010 Daniel De Graaf <danieldg@inspircd.org> * Copyright (C) 2008 Robin Burchell <robin+git@viroteck.net> * Copyright (C) 2008 Dennis Friis <peavey@inspircd.org> * Copyright (C) 2007 Craig Edwards <brain@inspircd.org> * Copyright (C) 2006 Oliver Lupton <om@inspircd.org> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include "inspircd.h" #include "listmode.h" #include "modules/extban.h" #include "modules/isupport.h" enum { // From RFC 2812. RPL_EXCEPTLIST = 348, RPL_ENDOFEXCEPTLIST = 349 }; class BanException final : public ListModeBase { private: ExtBan::ManagerRef extbanmgr; public: BanException(Module* Creator) : ListModeBase(Creator, "banexception", 'e', RPL_EXCEPTLIST, RPL_ENDOFEXCEPTLIST) , extbanmgr(Creator) { syntax = "<mask>"; } bool CompareEntry(const std::string& entry, const std::string& value) const override { if (extbanmgr) { auto res = extbanmgr->CompareEntry(this, entry, value); if (res != ExtBan::Comparison::NOT_AN_EXTBAN) return res == ExtBan::Comparison::MATCH; } return irc::equals(entry, value); } bool ValidateParam(LocalUser* user, Channel* channel, std::string& parameter) override { if (!extbanmgr || !extbanmgr->Canonicalize(parameter)) ModeParser::CleanMask(parameter); return true; } }; class ModuleBanException final : public Module , public ExtBan::EventListener , public ISupport::EventListener { private: BanException be; public: ModuleBanException() : Module(VF_VENDOR, "Adds channel mode e (banexception) which allows channel operators to exempt user masks from channel mode b (ban).") , ExtBan::EventListener(this) , ISupport::EventListener(this) , be(this) { } void OnBuildISupport(ISupport::TokenMap& tokens) override { tokens["EXCEPTS"] = ConvToStr(be.GetModeChar()); } ModResult OnExtBanCheck(User* user, Channel* chan, ExtBan::Base* extban) override { ListModeBase::ModeList* list = be.GetList(chan); if (!list) return MOD_RES_PASSTHRU; for (const auto& ban : *list) { bool inverted; std::string name; std::string value; if (!ExtBan::Parse(ban.mask, name, value, inverted)) continue; if (name.size() == 1) { // It is an extban but not this extban. if (name[0] != extban->GetLetter()) continue; } else { // It is an extban but not this extban. if (!irc::equals(name, extban->GetName())) continue; } return extban->IsMatch(user, chan, value) != inverted ? MOD_RES_ALLOW : MOD_RES_PASSTHRU; } return MOD_RES_PASSTHRU; } ModResult OnCheckChannelBan(User* user, Channel* chan) override { ListModeBase::ModeList* list = be.GetList(chan); if (!list) { // No list, proceed normally return MOD_RES_PASSTHRU; } for (const auto& entry : *list) { if (chan->CheckBan(user, entry.mask)) { // They match an entry on the list, so let them in. return MOD_RES_ALLOW; } } return MOD_RES_PASSTHRU; } void ReadConfig(ConfigStatus& status) override { be.DoRehash(); } }; MODULE_INIT(ModuleBanException) �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/src/modules/m_banredirect.cpp��������������������������������������������������������0000664�0000000�0000000�00000025225�14771603147�0021116�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2021 Dominic Hamon * Copyright (C) 2020-2023 Sadie Powell <sadie@witchery.services> * Copyright (C) 2018 linuxdaemon <linuxdaemon.irc@gmail.com> * Copyright (C) 2014 Adam <Adam@anope.org> * Copyright (C) 2013-2014, 2016 Attila Molnar <attilamolnar@hush.com> * Copyright (C) 2013 Daniel Vassdal <shutter@canternet.org> * Copyright (C) 2012, 2019 Robby <robby@chatbelgie.be> * Copyright (C) 2009-2010 Daniel De Graaf <danieldg@inspircd.org> * Copyright (C) 2009 Matt Smith <dz@inspircd.org> * Copyright (C) 2008 Uli Schlachter <psychon@znc.in> * Copyright (C) 2008 Craig Edwards <brain@inspircd.org> * Copyright (C) 2007-2009 Robin Burchell <robin+git@viroteck.net> * Copyright (C) 2007 Oliver Lupton <om@inspircd.org> * Copyright (C) 2007 Dennis Friis <peavey@inspircd.org> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include "inspircd.h" #include "listmode.h" #include "modules/extban.h" /* Originally written by Om, January 2009 */ class BanRedirectEntry final { public: std::string targetchan; std::string banmask; BanRedirectEntry(const std::string& target = "", const std::string& mask = "") : targetchan(target) , banmask(mask) { } }; typedef std::vector<BanRedirectEntry> BanRedirectList; class BanRedirect final : public ModeWatcher { public: ChanModeReference banmode; ExtBan::ManagerRef extbanmgr; SimpleExtItem<BanRedirectList> redirectlist; BanRedirect(Module* parent) : ModeWatcher(parent, "ban", MODETYPE_CHANNEL) , banmode(parent, "ban") , extbanmgr(parent) , redirectlist(parent, "banredirect", ExtensionType::CHANNEL) { } bool BeforeMode(User* source, User* dest, Channel* channel, Modes::Change& change) override { /* nick!user@host -> nick!user@host * nick!user@host#chan -> nick!user@host#chan * nick@host#chan -> nick!*@host#chan * nick!user#chan -> nick!user@*#chan * nick#chan -> nick!*@*#chan */ if ((channel) && !change.param.empty()) { BanRedirectList* redirects; std::string mask[4]; enum { NICK, USER, HOST, CHAN } current = NICK; std::string::iterator start_pos = change.param.begin(); std::string unused = change.param; if (extbanmgr && extbanmgr->Canonicalize(unused)) return true; // Skip extbans. if (change.param.find('#') == std::string::npos) return true; ListModeBase* banlm = static_cast<ListModeBase*>(*banmode); unsigned long maxbans = banlm->GetLimit(channel); ListModeBase::ModeList* list = banlm->GetList(channel); if (list && change.adding && maxbans <= list->size()) { source->WriteNumeric(ERR_BANLISTFULL, channel->name, banlm->GetModeChar(), INSP_FORMAT("Channel ban list for {} is full (maximum entries for this channel is {})", channel->name, maxbans)); return false; } for(std::string::iterator curr = start_pos; curr != change.param.end(); curr++) { switch(*curr) { case '!': if (current != NICK) break; mask[current].assign(start_pos, curr); current = USER; start_pos = curr+1; break; case '@': if (current != USER) break; mask[current].assign(start_pos, curr); current = HOST; start_pos = curr+1; break; case '#': if (current == CHAN) break; mask[current].assign(start_pos, curr); current = CHAN; start_pos = curr; break; } } if(mask[current].empty()) { mask[current].assign(start_pos, change.param.end()); } /* nick@host wants to be changed to *!nick@host rather than nick!*@host... */ if(mask[NICK].length() && mask[HOST].length() && mask[USER].empty()) { /* std::string::swap() is fast - it runs in constant time */ mask[NICK].swap(mask[USER]); } if (!mask[NICK].empty() && mask[USER].empty() && mask[HOST].empty()) { if (mask[NICK].find('.') != std::string::npos || mask[NICK].find(':') != std::string::npos) { mask[NICK].swap(mask[HOST]); } } for(int i = 0; i < 3; i++) { if(mask[i].empty()) { mask[i].assign("*"); } } change.param.assign(mask[NICK]).append(1, '!').append(mask[USER]).append(1, '@').append(mask[HOST]); if(mask[CHAN].length()) { if (change.adding && IS_LOCAL(source)) { if (!ServerInstance->Channels.IsChannel(mask[CHAN])) { source->WriteNumeric(ERR_NOSUCHCHANNEL, channel->name, INSP_FORMAT("Invalid channel name in redirection ({})", mask[CHAN])); return false; } auto* c = ServerInstance->Channels.Find(mask[CHAN]); if (!c) { source->WriteNumeric(690, INSP_FORMAT("Target channel {} must exist to be set as a redirect.", mask[CHAN])); return false; } else if (change.adding && c->GetPrefixValue(source) < OP_VALUE) { source->WriteNumeric(690, INSP_FORMAT("You must be opped on {} to set it as a redirect.", mask[CHAN])); return false; } if (irc::equals(channel->name, mask[CHAN])) { source->WriteNumeric(690, channel->name, "You cannot set a ban redirection to the channel the ban is on"); return false; } } if (change.adding) { /* It's a properly valid redirecting ban, and we're adding it */ redirects = redirectlist.Get(channel); if (!redirects) { redirects = new BanRedirectList; redirectlist.Set(channel, redirects); } else { for (const auto& redirect : *redirects) { // Mimic the functionality used when removing the mode if (irc::equals(redirect.targetchan, mask[CHAN]) && irc::equals(redirect.banmask, change.param)) { // Make sure the +b handler will still set the right ban change.param.append(mask[CHAN]); // Silently ignore the duplicate and don't set metadata // This still allows channel ops to set/unset a redirect ban to clear "ghost" redirects return true; } } } /* Here 'param' doesn't have the channel on it yet */ redirects->emplace_back(mask[CHAN], change.param); /* Now it does */ change.param.append(mask[CHAN]); } else { /* Removing a ban, if there's no extensible there are no redirecting bans and we're fine. */ redirects = redirectlist.Get(channel); if (redirects) { /* But there were, so we need to remove the matching one if there is one */ for(BanRedirectList::iterator redir = redirects->begin(); redir != redirects->end(); redir++) { if ((irc::equals(redir->targetchan, mask[CHAN])) && (irc::equals(redir->banmask, change.param))) { redirects->erase(redir); if(redirects->empty()) { redirectlist.Unset(channel); } break; } } } /* Append the channel so the default +b handler can remove the entry too */ change.param.append(mask[CHAN]); } } } return true; } }; class ModuleBanRedirect final : public Module { private: BanRedirect banwatcher; bool nofollow = false; ChanModeReference limitmode; ChanModeReference redirectmode; public: ModuleBanRedirect() : Module(VF_VENDOR | VF_COMMON, "Allows specifying a channel to redirect a banned user to in the ban mask.") , banwatcher(this) , limitmode(this, "limit") , redirectmode(this, "redirect") { } void OnCleanup(ExtensionType type, Extensible* item) override { if (type == ExtensionType::CHANNEL) { Channel* chan = static_cast<Channel*>(item); BanRedirectList* redirects = banwatcher.redirectlist.Get(chan); if(redirects) { Modes::ChangeList changelist; for (auto& redirect : *redirects) changelist.push_remove(*banwatcher.banmode, redirect.targetchan.insert(0, redirect.banmask)); for (const auto& redirect : *redirects) changelist.push_add(*banwatcher.banmode, redirect.banmask); ServerInstance->Modes.Process(ServerInstance->FakeClient, chan, nullptr, changelist, ModeParser::MODE_LOCALONLY); } } } ModResult OnUserPreJoin(LocalUser* user, Channel* chan, const std::string& cname, std::string& privs, const std::string& keygiven, bool override) override { if (!override && chan) { BanRedirectList* redirects = banwatcher.redirectlist.Get(chan); if (redirects) { /* We actually had some ban redirects to check */ ModResult result; FIRST_MOD_RESULT(OnCheckChannelBan, result, (user, chan)); if (result == MOD_RES_ALLOW) { // they have a ban exception return MOD_RES_PASSTHRU; } std::string ipmask(user->nick); ipmask.append(1, '!').append(user->GetUserAddress()); for (const auto& redirect : *redirects) { if (InspIRCd::Match(user->GetRealMask(), redirect.banmask) || InspIRCd::Match(user->GetMask(), redirect.banmask) || InspIRCd::MatchCIDR(ipmask, redirect.banmask)) { /* This prevents recursion when a user sets multiple ban redirects in a chain * (thanks Potter) * * If we're here and nofollow is true then we're already redirecting this user * and there's a redirecting ban set on this channel that matches him, too. * Deny both joins. */ if (nofollow) return MOD_RES_DENY; /* tell them they're banned and are being transferred */ auto* destchan = ServerInstance->Channels.Find(redirect.targetchan); std::string destlimit; if (destchan) destlimit = destchan->GetModeParameter(limitmode); if(destchan && destchan->IsModeSet(redirectmode) && !destlimit.empty() && (destchan->GetUsers().size() >= ConvToNum<size_t>(destlimit))) { user->WriteNumeric(ERR_BANNEDFROMCHAN, chan->name, "Cannot join channel (you're banned)"); return MOD_RES_DENY; } else { user->WriteNumeric(ERR_BANNEDFROMCHAN, chan->name, "Cannot join channel (you're banned)"); user->WriteNumeric(470, chan->name, redirect.targetchan, "You are banned from this channel, so you are automatically being transferred to the redirected channel."); nofollow = true; Channel::JoinUser(user, redirect.targetchan); nofollow = false; return MOD_RES_DENY; } } } } } return MOD_RES_PASSTHRU; } }; MODULE_INIT(ModuleBanRedirect) ���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/src/modules/m_bcrypt.cpp�������������������������������������������������������������0000664�0000000�0000000�00000004460�14771603147�0020135�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2021 Dominic Hamon * Copyright (C) 2018-2024 Sadie Powell <sadie@witchery.services> * Copyright (C) 2014 Daniel Vassdal <shutter@canternet.org> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include "inspircd.h" #include "modules/hash.h" #include <bcrypt/crypt_blowfish.c> class BCryptProvider final : public HashProvider { private: std::string Salt() { char entropy[16]; ServerInstance->GenRandom(entropy, std::size(entropy)); char salt[32]; if (!_crypt_gensalt_blowfish_rn("$2a$", rounds, entropy, sizeof(entropy), salt, sizeof(salt))) throw ModuleException(creator, "Could not generate salt - this should never happen"); return salt; } public: unsigned long rounds = 10; static std::string Generate(const std::string& data, const std::string& salt) { char hash[64]; _crypt_blowfish_rn(data.c_str(), salt.c_str(), hash, sizeof(hash)); return hash; } std::string GenerateRaw(const std::string& data) override { return Generate(data, Salt()); } bool Compare(const std::string& input, const std::string& hash) override { return InspIRCd::TimingSafeCompare(Generate(input, hash), hash); } std::string ToPrintable(const std::string& raw) override { return raw; } BCryptProvider(Module* parent) : HashProvider(parent, "bcrypt", 60) { } }; class ModuleBCrypt final : public Module { private: BCryptProvider bcrypt; public: ModuleBCrypt() : Module(VF_VENDOR, "Allows other modules to generate bcrypt hashes.") , bcrypt(this) { } void ReadConfig(ConfigStatus& status) override { const auto& conf = ServerInstance->Config->ConfValue("bcrypt"); bcrypt.rounds = conf->getNum<unsigned long>("rounds", 10, 1); } }; MODULE_INIT(ModuleBCrypt) ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/src/modules/m_blockamsg.cpp����������������������������������������������������������0000664�0000000�0000000�00000012470�14771603147�0020574�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2021 Dominic Hamon * Copyright (C) 2018-2023 Sadie Powell <sadie@witchery.services> * Copyright (C) 2012, 2019 Robby <robby@chatbelgie.be> * Copyright (C) 2012, 2014-2016 Attila Molnar <attilamolnar@hush.com> * Copyright (C) 2009 Daniel De Graaf <danieldg@inspircd.org> * Copyright (C) 2008 Dennis Friis <peavey@inspircd.org> * Copyright (C) 2006 Oliver Lupton <om@inspircd.org> * Copyright (C) 2006 Craig Edwards <brain@inspircd.org> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include "inspircd.h" #include "extension.h" enum BlockAction { IBLOCK_KILL, IBLOCK_KILLOPERS, IBLOCK_NOTICE, IBLOCK_NOTICEOPERS, IBLOCK_SILENT }; /* IBLOCK_NOTICE - Send a notice to the user informing them of what happened. * IBLOCK_NOTICEOPERS - Send a notice to the user informing them and send an oper notice. * IBLOCK_SILENT - Generate no output, silently drop messages. * IBLOCK_KILL - Kill the user with the reason "Global message (/amsg or /ame) detected". * IBLOCK_KILLOPERS - As above, but send an oper notice as well. This is the default. */ /** Holds a blocked message's details */ class BlockedMessage final { public: std::string message; std::string target; time_t sent; BlockedMessage(const std::string& msg, const std::string& tgt, time_t when) : message(msg) , target(tgt) , sent(when) { } }; class ModuleBlockAmsg final : public Module { unsigned long ForgetDelay; BlockAction action; SimpleExtItem<BlockedMessage> blockamsg; public: ModuleBlockAmsg() : Module(VF_VENDOR, "Blocks mass messages sent using the /AME and /AMSG commands that exist in clients such as mIRC and HexChat.") , blockamsg(this, "blockamsg", ExtensionType::USER) { } void ReadConfig(ConfigStatus& status) override { const auto& tag = ServerInstance->Config->ConfValue("blockamsg"); action = tag->getEnum("action", IBLOCK_KILLOPERS, { { "kill", IBLOCK_KILL }, { "killopers", IBLOCK_KILLOPERS }, { "notice", IBLOCK_NOTICE }, { "noticeopers", IBLOCK_NOTICEOPERS }, { "silent", IBLOCK_SILENT } }); ForgetDelay = tag->getDuration("delay", 3); } ModResult OnPreCommand(std::string& command, CommandBase::Params& parameters, LocalUser* user, bool validated) override { // Don't do anything with partially connected users if (!user->IsFullyConnected()) return MOD_RES_PASSTHRU; if ((validated) && (parameters.size() >= 2) && ((command == "PRIVMSG") || (command == "NOTICE"))) { if (user->HasPrivPermission("servers/ignore-blockamsg")) return MOD_RES_PASSTHRU; // parameters[0] is the target list, count how many channels are there unsigned int targets = 0; // Is the first target a channel? if (ServerInstance->Channels.IsPrefix(parameters[0][0])) targets = 1; for (const char* c = parameters[0].c_str(); *c; c++) { if (*c == ',' && ServerInstance->Channels.IsPrefix(*(c + 1))) targets++; } /* targets should now contain the number of channel targets the msg/notice was pointed at. * If the msg/notice was a PM there should be no channel targets and 'targets' should = 0. * We don't want to block PMs so... */ if (targets == 0) return MOD_RES_PASSTHRU; // Check that this message wasn't already sent within a few seconds. BlockedMessage* m = blockamsg.Get(user); // If the message is identical and within the time. // We check the target is *not* identical, that'd straying into the realms of flood control. Which isn't what we're doing... // OR // The number of target channels is equal to the number of channels the sender is on..a little suspicious. // Check it's more than 1 too, or else users on one channel would have fun. if ((m && (m->message == parameters[1]) && (!irc::equals(m->target, parameters[0])) && ForgetDelay && (m->sent >= ServerInstance->Time()-(time_t)ForgetDelay)) || ((targets > 1) && (targets == user->chans.size()))) { // Block it... if (action == IBLOCK_KILLOPERS || action == IBLOCK_NOTICEOPERS) ServerInstance->SNO.WriteToSnoMask('a', "{} had an /amsg or /ame blocked", user->nick); if (action == IBLOCK_KILL || action == IBLOCK_KILLOPERS) ServerInstance->Users.QuitUser(user, "Attempted to global message (/amsg or /ame)"); else if (action == IBLOCK_NOTICE || action == IBLOCK_NOTICEOPERS) user->WriteNotice("Global message (/amsg or /ame) blocked"); return MOD_RES_DENY; } if (m) { // If there's already a BlockedMessage allocated, use it. m->message = parameters[1]; m->target = parameters[0]; m->sent = ServerInstance->Time(); } else { blockamsg.SetFwd(user, parameters[1], parameters[0], ServerInstance->Time()); } } return MOD_RES_PASSTHRU; } }; MODULE_INIT(ModuleBlockAmsg) ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/src/modules/m_blockcolor.cpp���������������������������������������������������������0000664�0000000�0000000�00000005675�14771603147�0020774�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2019 Matt Schatz <genius3000@g3k.solutions> * Copyright (C) 2017, 2020-2024 Sadie Powell <sadie@witchery.services> * Copyright (C) 2012 Robby <robby@chatbelgie.be> * Copyright (C) 2012 DjSlash <djslash@djslash.org> * Copyright (C) 2012 Attila Molnar <attilamolnar@hush.com> * Copyright (C) 2009 Daniel De Graaf <danieldg@inspircd.org> * Copyright (C) 2006 Craig Edwards <brain@inspircd.org> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include "inspircd.h" #include "modules/exemption.h" #include "modules/extban.h" #include "numerichelper.h" class ModuleBlockColor final : public Module { private: ExtBan::Acting extban; CheckExemption::EventProvider exemptionprov; SimpleChannelMode bc; public: ModuleBlockColor() : Module(VF_VENDOR, "Adds channel mode c (blockcolor) which allows channels to block messages which contain IRC formatting codes.") , extban(this, "blockcolor", 'c') , exemptionprov(this) , bc(this, "blockcolor", 'c') { } ModResult OnUserPreMessage(User* user, MessageTarget& target, MessageDetails& details) override { if ((target.type == MessageTarget::TYPE_CHANNEL) && (IS_LOCAL(user))) { auto* c = target.Get<Channel>(); ModResult res = exemptionprov.Check(user, c, "blockcolor"); if (res == MOD_RES_ALLOW) return MOD_RES_PASSTHRU; bool modeset = c->IsModeSet(bc); if (!extban.GetStatus(user, c).check(!modeset)) { std::string_view ctcpname; // Unused. std::string_view message; if (!details.IsCTCP(ctcpname, message)) message = details.text; auto it = std::find_if(message.begin(), message.end(), [](const char& chr) { switch (chr) { case '\x02': // Bold case '\x03': // Color case '\x04': // Hex Color case '\x1D': // Italic case '\x11': // Monospace case '\x16': // Reverse case '\x1E': // Strikethrough case '\x1F': // Underline case '\x0F': // Reset return true; } return false; }); if (it != message.end()) { if (modeset) user->WriteNumeric(Numerics::CannotSendTo(c, "messages containing formatting characters", &bc)); else user->WriteNumeric(Numerics::CannotSendTo(c, "messages containing formatting characters", extban)); return MOD_RES_DENY; } } } return MOD_RES_PASSTHRU; } }; MODULE_INIT(ModuleBlockColor) �������������������������������������������������������������������inspircd-4.7.0/src/modules/m_botmode.cpp������������������������������������������������������������0000664�0000000�0000000�00000006376�14771603147�0020273�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2017-2025 Sadie Powell <sadie@witchery.services> * Copyright (C) 2012, 2015 Attila Molnar <attilamolnar@hush.com> * Copyright (C) 2012 Robby <robby@chatbelgie.be> * Copyright (C) 2009-2010 Daniel De Graaf <danieldg@inspircd.org> * Copyright (C) 2004 Craig Edwards <brain@inspircd.org> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include "inspircd.h" #include "modules/ctctags.h" #include "modules/isupport.h" #include "modules/who.h" #include "modules/whois.h" class BotTag final : public CTCTags::TagProvider { private: SimpleUserMode& botmode; public: BotTag(Module* mod, SimpleUserMode& bm) : CTCTags::TagProvider(mod) , botmode(bm) { } void OnPopulateTags(ClientProtocol::Message& msg) override { User* const user = msg.GetSourceUser(); if (user && user->IsModeSet(botmode)) msg.AddTag("bot", this, ""); } }; class ModuleBotMode final : public Module , public ISupport::EventListener , public Who::EventListener , public Whois::EventListener { private: SimpleUserMode bm; BotTag tag; bool forcenotice; public: ModuleBotMode() : Module(VF_VENDOR, "Adds user mode B (bot) which marks users with it set as bots.") , ISupport::EventListener(this) , Who::EventListener(this) , Whois::EventListener(this) , bm(this, "bot", 'B') , tag(this, bm) { } void ReadConfig(ConfigStatus& status) override { forcenotice = ServerInstance->Config->ConfValue("botmode")->getBool("forcenotice"); } void OnBuildISupport(ISupport::TokenMap& tokens) override { tokens["BOT"] = ConvToStr(bm.GetModeChar()); } ModResult OnUserPreMessage(User* user, MessageTarget& target, MessageDetails& details) override { // Allow sending if forcenotice is off, the user is not a bot, or if the message is a notice. if (!forcenotice || !user->IsModeSet(bm) || details.type == MessageType::NOTICE) return MOD_RES_PASSTHRU; // Allow sending PRIVMSGs to services pseudoclients. if (target.type == MessageTarget::TYPE_USER && target.Get<User>()->server->IsService()) return MOD_RES_PASSTHRU; // Force the message to be broadcast as a NOTICE. details.type = MessageType::NOTICE; return MOD_RES_PASSTHRU; } ModResult OnWhoLine(const Who::Request& request, LocalUser* source, User* user, Membership* memb, Numeric::Numeric& numeric) override { size_t flag_index; if (!request.GetFieldIndex('f', flag_index)) return MOD_RES_PASSTHRU; if (user->IsModeSet(bm)) numeric.GetParams()[flag_index].push_back('B'); return MOD_RES_PASSTHRU; } void OnWhois(Whois::Context& whois) override { if (whois.GetTarget()->IsModeSet(bm)) { whois.SendLine(RPL_WHOISBOT, "is a bot"); } } }; MODULE_INIT(ModuleBotMode) ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/src/modules/m_callerid.cpp�����������������������������������������������������������0000664�0000000�0000000�00000032716�14771603147�0020416�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2021 Dominic Hamon * Copyright (C) 2013, 2017-2024 Sadie Powell <sadie@witchery.services> * Copyright (C) 2013 Adam <Adam@anope.org> * Copyright (C) 2012-2016 Attila Molnar <attilamolnar@hush.com> * Copyright (C) 2012, 2019 Robby <robby@chatbelgie.be> * Copyright (C) 2009-2010 Daniel De Graaf <danieldg@inspircd.org> * Copyright (C) 2009 John Brooks <john@jbrooks.io> * Copyright (C) 2008-2009 Robin Burchell <robin+git@viroteck.net> * Copyright (C) 2008 Thomas Stagner <aquanight@gmail.com> * Copyright (C) 2008 Craig Edwards <brain@inspircd.org> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include "inspircd.h" #include "modules/callerid.h" #include "modules/ctctags.h" #include "modules/isupport.h" #include "numerichelper.h" enum { RPL_ACCEPTLIST = 281, RPL_ENDOFACCEPT = 282, ERR_ACCEPTFULL = 456, ERR_ACCEPTEXIST = 457, ERR_ACCEPTNOT = 458, ERR_TARGUMODEG = 716, RPL_TARGNOTIFY = 717, RPL_UMODEGMSG = 718 }; class callerid_data final { public: typedef insp::flat_set<User*> UserSet; typedef std::vector<callerid_data*> CallerIdDataSet; time_t lastnotify = 0; /** Users I accept messages from */ UserSet accepting; /** Users who list me as accepted */ CallerIdDataSet wholistsme; std::string ToString(bool human) const { std::ostringstream oss; oss << lastnotify; for (const auto* u : accepting) { if (human) oss << ' ' << u->nick; else oss << ',' << u->uuid; } return oss.str(); } }; struct CallerIDExtInfo final : public ExtensionItem { CallerIDExtInfo(Module* parent) : ExtensionItem(parent, "callerid_data", ExtensionType::USER) { } std::string ToHuman(const Extensible* container, void* item) const noexcept override { callerid_data* dat = static_cast<callerid_data*>(item); return dat->ToString(true); } std::string ToInternal(const Extensible* container, void* item) const noexcept override { callerid_data* dat = static_cast<callerid_data*>(item); return dat->ToString(false); } void FromInternal(Extensible* container, const std::string& value) noexcept override { if (container->extype != this->extype) return; void* old = GetRaw(container); if (old) this->Delete(nullptr, old); auto* dat = new callerid_data(); SetRaw(container, dat); irc::commasepstream s(value); std::string tok; if (s.GetToken(tok)) dat->lastnotify = ConvToNum<time_t>(tok); while (s.GetToken(tok)) { auto* u = ServerInstance->Users.Find(tok, true); if (u && !u->quitting) { if (dat->accepting.insert(u).second) { callerid_data* other = this->Get(u, true); other->wholistsme.push_back(dat); } } } } callerid_data* Get(User* user, bool create) { callerid_data* dat = static_cast<callerid_data*>(GetRaw(user)); if (create && !dat) { dat = new callerid_data; SetRaw(user, dat); } return dat; } void Delete(Extensible* container, void* item) override { callerid_data* dat = static_cast<callerid_data*>(item); // We need to walk the list of users on our accept list, and remove ourselves from their wholistsme. for (auto* user : dat->accepting) { callerid_data* target = this->Get(user, false); if (!target) { ServerInstance->Logs.Debug(MODNAME, "BUG: Inconsistency detected in callerid state, please report (1)"); continue; // shouldn't happen, but oh well. } if (!stdalgo::vector::swaperase(target->wholistsme, dat)) ServerInstance->Logs.Debug(MODNAME, "BUG: Inconsistency detected in callerid state, please report (2)"); } delete dat; } }; class CommandAccept final : public Command { /** Pair: first is the target, second is true to add, false to remove */ typedef std::pair<User*, bool> ACCEPTAction; static ACCEPTAction GetTargetAndAction(std::string& tok, User* cmdfrom = nullptr) { bool remove = (tok[0] == '-'); if ((remove) || (tok[0] == '+')) tok.erase(tok.begin()); User* target; if (!cmdfrom || !IS_LOCAL(cmdfrom)) target = ServerInstance->Users.Find(tok, true); else target = ServerInstance->Users.FindNick(tok, true); if (target && target->quitting) target = nullptr; return std::make_pair(target, !remove); } public: CallerIDExtInfo extInfo; unsigned long maxaccepts; CommandAccept(Module* Creator) : Command(Creator, "ACCEPT", 1) , extInfo(Creator) { syntax = { "*|(+|-)<nick>[,(+|-)<nick>]+" }; translation = { TR_CUSTOM }; } void EncodeParameter(std::string& parameter, unsigned int index) override { // Send lists as-is (part of 2.0 compat) if (parameter.find(',') != std::string::npos) return; // Convert a (+|-)<nick> into a [-]<uuid> ACCEPTAction action = GetTargetAndAction(parameter); if (!action.first) return; parameter = (action.second ? "" : "-") + action.first->uuid; } /** Will take any number of nicks (up to MaxTargets), which can be separated by commas. * - in front of any nick removes, and an * lists. This effectively means you can do: * /accept nick1,nick2,nick3,* * to add 3 nicks and then show your list */ CmdResult Handle(User* user, const Params& parameters) override { if (CommandParser::LoopCall(user, this, parameters, 0)) return CmdResult::SUCCESS; /* Even if callerid mode is not set, we let them manage their ACCEPT list so that if they go +g they can * have a list already setup. */ if (parameters[0] == "*") { ListAccept(user); return CmdResult::SUCCESS; } std::string tok = parameters[0]; ACCEPTAction action = GetTargetAndAction(tok, user); if (!action.first) { user->WriteNumeric(Numerics::NoSuchNick(tok)); return CmdResult::FAILURE; } if ((!IS_LOCAL(user)) && (!IS_LOCAL(action.first))) // Neither source nor target is local, forward the command to the server of target return CmdResult::SUCCESS; // The second item in the pair is true if the first char is a '+' (or nothing), false if it's a '-' if (action.second) return (AddAccept(user, action.first) ? CmdResult::SUCCESS : CmdResult::FAILURE); else return (RemoveAccept(user, action.first) ? CmdResult::SUCCESS : CmdResult::FAILURE); } RouteDescriptor GetRouting(User* user, const Params& parameters) override { // There is a list in parameters[0] in two cases: // Either when the source is remote, this happens because 2.0 servers send comma separated uuid lists, // we don't split those but broadcast them, as before. // // Or if the source is local then LoopCall() runs OnPostCommand() after each entry in the list, // meaning the linking module has sent an ACCEPT already for each entry in the list to the // appropriate server and the ACCEPT with the list of nicks (this) doesn't need to be sent anywhere. if ((!IS_LOCAL(user)) && (parameters[0].find(',') != std::string::npos)) return ROUTE_BROADCAST; // Find the target std::string targetstring = parameters[0]; ACCEPTAction action = GetTargetAndAction(targetstring, user); if (!action.first) // Target is a "*" or source is local and the target is a list of nicks return ROUTE_LOCALONLY; // Route to the server of the target return ROUTE_UNICAST(action.first->server); } void ListAccept(User* user) { callerid_data* dat = extInfo.Get(user, false); if (dat) { for (const auto* accepted : dat->accepting) user->WriteNumeric(RPL_ACCEPTLIST, accepted->nick); } user->WriteNumeric(RPL_ENDOFACCEPT, "End of ACCEPT list"); } bool AddAccept(User* user, User* whotoadd) { // Add this user to my accept list first, so look me up.. callerid_data* dat = extInfo.Get(user, true); if (dat->accepting.size() >= maxaccepts) { user->WriteNumeric(ERR_ACCEPTFULL, INSP_FORMAT("Accept list is full (limit is {})", maxaccepts)); return false; } if (!dat->accepting.insert(whotoadd).second) { user->WriteNumeric(ERR_ACCEPTEXIST, whotoadd->nick, "is already on your accept list"); return false; } // Now, look them up, and add me to their list callerid_data* target = extInfo.Get(whotoadd, true); target->wholistsme.push_back(dat); user->WriteNotice(whotoadd->nick + " is now on your accept list"); return true; } bool RemoveAccept(User* user, User* whotoremove) { // Remove them from my list, so look up my list.. callerid_data* dat = extInfo.Get(user, false); if (!dat) { user->WriteNumeric(ERR_ACCEPTNOT, whotoremove->nick, "is not on your accept list"); return false; } if (!dat->accepting.erase(whotoremove)) { user->WriteNumeric(ERR_ACCEPTNOT, whotoremove->nick, "is not on your accept list"); return false; } // Look up their list to remove me. callerid_data* dat2 = extInfo.Get(whotoremove, false); if (!dat2) { // How the fuck is this possible. ServerInstance->Logs.Debug(MODNAME, "BUG: Inconsistency detected in callerid state, please report (3)"); return false; } if (!stdalgo::vector::swaperase(dat2->wholistsme, dat)) ServerInstance->Logs.Debug(MODNAME, "BUG: Inconsistency detected in callerid state, please report (4)"); user->WriteNotice(whotoremove->nick + " is no longer on your accept list"); return true; } }; class CallerIDAPIImpl final : public CallerID::APIBase { private: CallerIDExtInfo& ext; public: CallerIDAPIImpl(Module* Creator, CallerIDExtInfo& Ext) : CallerID::APIBase(Creator) , ext(Ext) { } bool IsOnAcceptList(User* source, User* target) override { callerid_data* dat = ext.Get(target, true); return dat->accepting.count(source); } }; class ModuleCallerID final : public Module , public CTCTags::EventListener , public ISupport::EventListener { private: CommandAccept cmd; CallerIDAPIImpl api; SimpleUserMode myumode; // Configuration variables: bool tracknick; // Allow ACCEPT entries to update with nick changes. unsigned long notify_cooldown; // Seconds between notifications. /** Removes a user from all accept lists * @param who The user to remove from accepts */ void RemoveFromAllAccepts(User* who) { // First, find the list of people who have me on accept callerid_data* userdata = cmd.extInfo.Get(who, false); if (!userdata) return; // Iterate over the list of people who accept me, and remove all entries for (auto* dat : userdata->wholistsme) { // Find me on their callerid list if (!dat->accepting.erase(who)) ServerInstance->Logs.Debug(MODNAME, "BUG: Inconsistency detected in callerid state, please report (5)"); } userdata->wholistsme.clear(); } public: ModuleCallerID() : Module(VF_VENDOR | VF_COMMON, "Provides user mode g (callerid) which allows users to require that other users are on their whitelist before messaging them.") , CTCTags::EventListener(this) , ISupport::EventListener(this) , cmd(this) , api(this, cmd.extInfo) , myumode(this, "callerid", 'g') { } void OnBuildISupport(ISupport::TokenMap& tokens) override { tokens["ACCEPT"] = ConvToStr(cmd.maxaccepts); tokens["CALLERID"] = ConvToStr(myumode.GetModeChar()); } ModResult HandleMessage(User* user, const MessageTarget& target) { if (!IS_LOCAL(user) || target.type != MessageTarget::TYPE_USER) return MOD_RES_PASSTHRU; auto* dest = target.Get<User>(); if (!dest->IsModeSet(myumode) || (user == dest)) return MOD_RES_PASSTHRU; if (user->HasPrivPermission("users/ignore-callerid")) return MOD_RES_PASSTHRU; callerid_data* dat = cmd.extInfo.Get(dest, true); if (!dat->accepting.count(user)) { time_t now = ServerInstance->Time(); /* +g and *not* accepted */ user->WriteNumeric(ERR_TARGUMODEG, dest->nick, INSP_FORMAT("is in +{} mode (server-side ignore).", myumode.GetModeChar())); if (now > (dat->lastnotify + long(notify_cooldown))) { user->WriteNumeric(RPL_TARGNOTIFY, dest->nick, "has been informed that you messaged them."); dest->WriteRemoteNumeric(RPL_UMODEGMSG, user->nick, user->GetUserHost(), INSP_FORMAT("is messaging you, and you have user mode +{} set. Use /ACCEPT +{} to allow.", myumode.GetModeChar(), user->nick) ); dat->lastnotify = now; } return MOD_RES_DENY; } return MOD_RES_PASSTHRU; } ModResult OnUserPreMessage(User* user, MessageTarget& target, MessageDetails& details) override { return HandleMessage(user, target); } ModResult OnUserPreTagMessage(User* user, MessageTarget& target, CTCTags::TagMessageDetails& details) override { return HandleMessage(user, target); } void OnUserPostNick(User* user, const std::string& oldnick) override { if (!tracknick) RemoveFromAllAccepts(user); } void OnUserQuit(User* user, const std::string& message, const std::string& oper_message) override { RemoveFromAllAccepts(user); } void ReadConfig(ConfigStatus& status) override { const auto& tag = ServerInstance->Config->ConfValue("callerid"); cmd.maxaccepts = tag->getNum<unsigned long>("maxaccepts", 30, 1); tracknick = tag->getBool("tracknick"); notify_cooldown = tag->getDuration("cooldown", 60); } void Prioritize() override { // Want to be after modules like account or silence ServerInstance->Modules.SetPriority(this, I_OnUserPreMessage, PRIORITY_LAST); } }; MODULE_INIT(ModuleCallerID) ��������������������������������������������������inspircd-4.7.0/src/modules/m_cap.cpp����������������������������������������������������������������0000664�0000000�0000000�00000030723�14771603147�0017376�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2018-2023 Sadie Powell <sadie@witchery.services> * Copyright (C) 2015-2016, 2018 Attila Molnar <attilamolnar@hush.com> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include "inspircd.h" #include "modules/reload.h" #include "modules/cap.h" #include "utility/string.h" enum { // From IRCv3 capability-negotiation-3.1. ERR_INVALIDCAPCMD = 410 }; namespace Cap { class ManagerImpl; } static Cap::ManagerImpl* managerimpl; class Cap::ManagerImpl final : public Cap::Manager , public ReloadModule::EventListener { /** Stores the cap state of a module being reloaded */ struct CapModData final { struct Data final { std::string name; std::vector<std::string> users; Data(Capability* cap) : name(cap->GetName()) { } }; std::vector<Data> caps; }; typedef insp::flat_map<std::string, Capability*, irc::insensitive_swo> CapMap; ExtItem capext; CapMap caps; Events::ModuleEventProvider& evprov; static bool CanRequest(LocalUser* user, Ext usercaps, Capability* cap, bool adding) { const bool hascap = ((usercaps & cap->GetMask()) != 0); if (hascap == adding) return true; return cap->OnRequest(user, adding); } Capability::Bit AllocateBit() const { Capability::Bit used = 0; for (const auto& [_, cap] : caps) used |= cap->GetMask(); for (size_t i = 0; i < MAX_CAPS; i++) { Capability::Bit bit = (static_cast<Capability::Bit>(1) << i); if (!(used & bit)) return bit; } throw ModuleException(creator, "Too many caps"); } void OnReloadModuleSave(Module* mod, ReloadModule::CustomData& cd) override { ServerInstance->Logs.Debug(MODNAME, "OnReloadModuleSave()"); if (mod == creator) return; auto* capmoddata = new CapModData(); cd.add(this, capmoddata); for (const auto& [_, cap] : caps) { // Only save users of caps that belong to the module being reloaded if (cap->creator != mod) continue; ServerInstance->Logs.Debug(MODNAME, "Module being reloaded implements cap {}, saving cap users", cap->GetName()); capmoddata->caps.emplace_back(cap); CapModData::Data& capdata = capmoddata->caps.back(); // Populate list with uuids of users who are using the cap for (auto* user : ServerInstance->Users.GetLocalUsers()) { if (cap->IsEnabled(user)) capdata.users.push_back(user->uuid); } } } void OnReloadModuleRestore(Module* mod, void* data) override { CapModData* capmoddata = static_cast<CapModData*>(data); for (const auto& capdata : capmoddata->caps) { Capability* cap = ManagerImpl::Find(capdata.name); if (!cap) { ServerInstance->Logs.Debug(MODNAME, "Cap {} is no longer available after reload", capdata.name); continue; } // Set back the cap for all users who were using it before the reload for (const auto& uuid : capdata.users) { auto* user = ServerInstance->Users.FindUUID(uuid); if (!user) { ServerInstance->Logs.Debug(MODNAME, "User {} is gone when trying to restore cap {}", uuid, capdata.name); continue; } cap->Set(user, true); } } delete capmoddata; } public: ManagerImpl(Module* mod, Events::ModuleEventProvider& evprovref) : Cap::Manager(mod) , ReloadModule::EventListener(mod) , capext(mod) , evprov(evprovref) { managerimpl = this; } ~ManagerImpl() override { for (const auto& [_, cap] : caps) cap->Unregister(); } void AddCap(Cap::Capability* cap) override { // No-op if the cap is already registered. // This allows modules to call SetActive() on a cap without checking if it's active first. if (cap->IsRegistered()) return; ServerInstance->Logs.Debug(MODNAME, "Registering cap {}", cap->GetName()); cap->bit = AllocateBit(); cap->extitem = &capext; caps.emplace(cap->GetName(), cap); ServerInstance->Modules.AddReferent("cap/" + cap->GetName(), cap); evprov.Call(&Cap::EventListener::OnCapAddDel, cap, true); } void DelCap(Cap::Capability* cap) override { // No-op if the cap is not registered, see AddCap() above if (!cap->IsRegistered()) return; ServerInstance->Logs.Debug(MODNAME, "Unregistering cap {}", cap->GetName()); // Fire the event first so modules can still see who is using the cap which is being unregistered evprov.Call(&Cap::EventListener::OnCapAddDel, cap, false); // Turn off the cap for all users for (auto* user : ServerInstance->Users.GetLocalUsers()) cap->Set(user, false); ServerInstance->Modules.DelReferent(cap); cap->Unregister(); caps.erase(cap->GetName()); } Capability* Find(const std::string& capname) const override { CapMap::const_iterator it = caps.find(capname); if (it != caps.end()) return it->second; return nullptr; } void NotifyValueChange(Capability* cap) override { ServerInstance->Logs.Debug(MODNAME, "Cap {} changed value", cap->GetName()); evprov.Call(&Cap::EventListener::OnCapValueChange, cap); } Protocol GetProtocol(LocalUser* user) const { return ((capext.Get(user) & CAP_302_BIT) ? CAP_302 : CAP_LEGACY); } void Set302Protocol(LocalUser* user) { capext.Set(user, capext.Get(user) | CAP_302_BIT); } bool HandleReq(LocalUser* user, const std::string& reqlist) { Ext usercaps = capext.Get(user); irc::spacesepstream ss(reqlist); for (std::string capname; ss.GetToken(capname); ) { bool remove = (capname[0] == '-'); if (remove) capname.erase(capname.begin()); Capability* cap = ManagerImpl::Find(capname); if ((!cap) || (!CanRequest(user, usercaps, cap, !remove))) return false; if (remove) usercaps = cap->DelFromMask(usercaps); else usercaps = cap->AddToMask(usercaps); } capext.Set(user, usercaps); return true; } void HandleList(std::vector<std::string>& out, LocalUser* user, bool show_all, bool show_values, bool minus_prefix = false) const { Ext show_caps = (show_all ? ~0 : capext.Get(user)); for (const auto& [_, cap] : caps) { if (!(show_caps & cap->GetMask())) continue; if ((show_all) && (!cap->OnList(user))) continue; std::string token; if (minus_prefix) token.push_back('-'); token.append(cap->GetName()); if (show_values) { const std::string* capvalue = cap->GetValue(user); if ((capvalue) && (!capvalue->empty()) && (capvalue->find(' ') == std::string::npos)) { token.push_back('='); token.append(*capvalue, 0, MAX_VALUE_LENGTH); } } out.push_back(token); } } void HandleClear(LocalUser* user, std::vector<std::string>& result) { HandleList(result, user, false, false, true); capext.Unset(user); } }; namespace { std::string SerializeCaps(const Extensible* container, bool human) { // XXX: Cast away the const because IS_LOCAL() doesn't handle it LocalUser* user = IS_LOCAL(const_cast<User*>(static_cast<const User*>(container))); if (!user) return {}; // List requested caps std::vector<std::string> result; managerimpl->HandleList(result, user, false, false); // Serialize cap protocol version. If building a human-readable string append a // new token, otherwise append only a single character indicating the version. std::string version; if (human) version.append("capversion=3."); switch (managerimpl->GetProtocol(user)) { case Cap::CAP_302: version.push_back('2'); break; default: version.push_back('1'); break; } result.push_back(version); return insp::join(result, ' '); } } Cap::ExtItem::ExtItem(Module* mod) : IntExtItem(mod, "caps", ExtensionType::USER) { } std::string Cap::ExtItem::ToHuman(const Extensible* container, void* item) const noexcept { return SerializeCaps(container, true); } std::string Cap::ExtItem::ToInternal(const Extensible* container, void* item) const noexcept { return SerializeCaps(container, false); } void Cap::ExtItem::FromInternal(Extensible* container, const std::string& value) noexcept { if (container->extype != this->extype) return; LocalUser* user = IS_LOCAL(static_cast<User*>(container)); if (!user) return; // Can't happen // Process the cap protocol version which is a single character at the end of the serialized string if (value.back() == '2') managerimpl->Set302Protocol(user); // Remove the version indicator from the string passed to HandleReq std::string caplist(value, 0, value.size()-1); managerimpl->HandleReq(user, caplist); } class CapMessage final : public Cap::MessageBase { public: CapMessage(LocalUser* user, const std::string& subcmd, const std::string& result, bool asterisk) : Cap::MessageBase(subcmd) { SetUser(user); if (asterisk) PushParam("*"); PushParamRef(result); } }; class CommandCap final : public SplitCommand { private: Events::ModuleEventProvider evprov; Cap::ManagerImpl manager; ClientProtocol::EventProvider protoevprov; void DisplayResult(LocalUser* user, const std::string& subcmd, const std::vector<std::string>& result, bool asterisk) { size_t maxline = ServerInstance->Config->Limits.MaxLine - ServerInstance->Config->ServerName.size() - user->nick.length() - subcmd.length() - 11; std::string line; for (const auto& cap : result) { if (line.length() + cap.length() < maxline) { line.append(cap); line.push_back(' '); } else { DisplaySingleResult(user, subcmd, line, asterisk); line.clear(); } } DisplaySingleResult(user, subcmd, line, false); } void DisplaySingleResult(LocalUser* user, const std::string& subcmd, const std::string& result, bool asterisk) { CapMessage msg(user, subcmd, result, asterisk); ClientProtocol::Event ev(protoevprov, msg); user->Send(ev); } public: BoolExtItem holdext; CommandCap(Module* mod) : SplitCommand(mod, "CAP", 1) , evprov(mod, "event/cap") , manager(mod, evprov) , protoevprov(mod, name) , holdext(mod, "cap-hold", ExtensionType::USER) { works_before_reg = true; } CmdResult HandleLocal(LocalUser* user, const Params& parameters) override { if (!user->IsFullyConnected()) holdext.Set(user); const std::string& subcommand = parameters[0]; if (irc::equals(subcommand, "REQ")) { if (parameters.size() < 2) return CmdResult::FAILURE; const std::string replysubcmd = (manager.HandleReq(user, parameters[1]) ? "ACK" : "NAK"); DisplaySingleResult(user, replysubcmd, parameters[1], false); } else if (irc::equals(subcommand, "END")) { holdext.Unset(user); } else if (irc::equals(subcommand, "LS") || irc::equals(subcommand, "LIST")) { Cap::Protocol capversion = Cap::CAP_LEGACY; const bool is_ls = (subcommand.length() == 2); if ((is_ls) && (parameters.size() > 1)) { unsigned int version = ConvToNum<unsigned int>(parameters[1]); if (version >= 302) { capversion = Cap::CAP_302; manager.Set302Protocol(user); } } std::vector<std::string> result; // Show values only if supports v3.2 and doing LS manager.HandleList(result, user, is_ls, ((is_ls) && (capversion != Cap::CAP_LEGACY))); DisplayResult(user, subcommand, result, (capversion != Cap::CAP_LEGACY)); } else if (irc::equals(subcommand, "CLEAR") && (manager.GetProtocol(user) == Cap::CAP_LEGACY)) { std::vector<std::string> result; manager.HandleClear(user, result); DisplayResult(user, "ACK", result, false); } else { user->WriteNumeric(ERR_INVALIDCAPCMD, subcommand.empty() ? "*" : subcommand, "Invalid CAP subcommand"); return CmdResult::FAILURE; } return CmdResult::SUCCESS; } }; class PoisonCap final : public Cap::Capability { public: PoisonCap(Module* mod) : Cap::Capability(mod, "inspircd.org/poison") { } bool OnRequest(LocalUser* user, bool adding) override { // Reject the attempt to enable this capability. return false; } }; class ModuleCap final : public Module { private: CommandCap cmd; PoisonCap poisoncap; public: ModuleCap() : Module(VF_VENDOR, "Provides support for the IRCv3 Client Capability Negotiation extension.") , cmd(this) , poisoncap(this) { } ModResult OnCheckReady(LocalUser* user) override { return (cmd.holdext.Get(user) ? MOD_RES_DENY : MOD_RES_PASSTHRU); } }; MODULE_INIT(ModuleCap) ���������������������������������������������inspircd-4.7.0/src/modules/m_cban.cpp���������������������������������������������������������������0000664�0000000�0000000�00000013420�14771603147�0017531�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2020 Michael <michaelhazell@hotmail.com> * Copyright (C) 2019 Matt Schatz <genius3000@g3k.solutions> * Copyright (C) 2018 linuxdaemon <linuxdaemon.irc@gmail.com> * Copyright (C) 2013, 2018-2023, 2025 Sadie Powell <sadie@witchery.services> * Copyright (C) 2012, 2019 Robby <robby@chatbelgie.be> * Copyright (C) 2012, 2016 Attila Molnar <attilamolnar@hush.com> * Copyright (C) 2009 Daniel De Graaf <danieldg@inspircd.org> * Copyright (C) 2008 Dennis Friis <peavey@inspircd.org> * Copyright (C) 2006 Craig Edwards <brain@inspircd.org> * Copyright (C) 2005, 2008 Robin Burchell <robin+git@viroteck.net> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include "inspircd.h" #include "modules/stats.h" #include "timeutils.h" #include "xline.h" enum { // InspIRCd-specific. ERR_BADCHANNEL = 926 }; /** Holds a CBAN item */ class CBan final : public XLine { private: std::string matchtext; public: CBan(time_t s_time, unsigned long d, const std::string& src, const std::string& re, const std::string& ch) : XLine(s_time, d, src, re, "CBAN") , matchtext(ch) { } // XXX I shouldn't have to define this bool Matches(User* u) const override { return false; } bool Matches(const std::string& s) const override { return InspIRCd::Match(s, matchtext); } const std::string& Displayable() const override { return matchtext; } }; /** An XLineFactory specialized to generate cban pointers */ class CBanFactory final : public XLineFactory { public: CBanFactory() : XLineFactory("CBAN") { } XLine* Generate(time_t set_time, unsigned long duration, const std::string& source, const std::string& reason, const std::string& xline_specific_mask) override { return new CBan(set_time, duration, source, reason, xline_specific_mask); } bool AutoApplyToUserList(XLine* x) override { return false; // No, we apply to channels. } }; class CommandCBan final : public Command { public: CommandCBan(Module* Creator) : Command(Creator, "CBAN", 1, 3) { access_needed = CmdAccess::OPERATOR; syntax = { "<channelmask> [[<duration>] :<reason>]" }; } CmdResult Handle(User* user, const Params& parameters) override { /* syntax: CBAN #channel time :reason goes here */ /* 'time' is a human-readable timestring, like 2d3h2s. */ if (parameters.size() == 1) { std::string reason; if (ServerInstance->XLines->DelLine(parameters[0], "CBAN", reason, user)) { ServerInstance->SNO.WriteToSnoMask('x', "{} removed CBan on {}: {}", user->nick, parameters[0], reason); } else { user->WriteNotice("*** CBan " + parameters[0] + " not found on the list."); return CmdResult::FAILURE; } } else { // Adding - XXX todo make this respect <insane> tag perhaps.. unsigned long duration = 0; if (parameters.size() > 2 && !Duration::TryFrom(parameters[1], duration)) { user->WriteNotice("*** Invalid duration for CBan."); return CmdResult::FAILURE; } auto* r = new CBan(ServerInstance->Time(), duration, user->nick, parameters.back(), parameters[0]); if (ServerInstance->XLines->AddLine(r, user)) { if (!duration) { ServerInstance->SNO.WriteToSnoMask('x', "{} added a permanent CBan on {}: {}", user->nick, parameters[0], r->reason); } else { ServerInstance->SNO.WriteToSnoMask('x', "{} added a timed CBan on {}, expires in {} (on {}): {}", user->nick, parameters[0], Duration::ToLongString(duration), Time::FromNow(duration), r->reason); } } else { delete r; user->WriteNotice("*** CBan for " + parameters[0] + " already exists"); return CmdResult::FAILURE; } } return CmdResult::SUCCESS; } }; class ModuleCBan final : public Module , public Stats::EventListener { CommandCBan mycommand; CBanFactory f; public: ModuleCBan() : Module(VF_VENDOR | VF_COMMON, "Adds the /CBAN command which allows server operators to prevent channels matching a glob from being created.") , Stats::EventListener(this) , mycommand(this) { } void init() override { ServerInstance->XLines->RegisterFactory(&f); } ~ModuleCBan() override { ServerInstance->XLines->DelAll("CBAN"); ServerInstance->XLines->UnregisterFactory(&f); } ModResult OnStats(Stats::Context& stats) override { if (stats.GetSymbol() != 'C') return MOD_RES_PASSTHRU; ServerInstance->XLines->InvokeStats("CBAN", stats); return MOD_RES_DENY; } ModResult OnUserPreJoin(LocalUser* user, Channel* chan, const std::string& cname, std::string& privs, const std::string& keygiven, bool override) override { if (override) return MOD_RES_PASSTHRU; XLine* rl = ServerInstance->XLines->MatchesLine("CBAN", cname); if (rl) { // Channel is banned. user->WriteNumeric(ERR_BADCHANNEL, cname, INSP_FORMAT("Channel {} is CBANed: {}", cname, rl->reason)); ServerInstance->SNO.WriteGlobalSno('a', "{} tried to join {} which is CBANed ({})", user->nick, cname, rl->reason); return MOD_RES_DENY; } return MOD_RES_PASSTHRU; } void GetLinkData(LinkData& data, std::string& compatdata) override { // It is assumed that if a server can speak the v4 protocol it can also // handle glob patterns for channel bans. compatdata.assign("glob"); } }; MODULE_INIT(ModuleCBan) ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/src/modules/m_chancreate.cpp���������������������������������������������������������0000664�0000000�0000000�00000003167�14771603147�0020732�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2019-2021, 2025 Sadie Powell <sadie@witchery.services> * Copyright (C) 2012 Robby <robby@chatbelgie.be> * Copyright (C) 2012 Attila Molnar <attilamolnar@hush.com> * Copyright (C) 2008 Robin Burchell <robin+git@viroteck.net> * Copyright (C) 2007 John Brooks <john@jbrooks.io> * Copyright (C) 2007 Dennis Friis <peavey@inspircd.org> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include "inspircd.h" class ModuleChanCreate final : public Module { public: ModuleChanCreate() : Module(VF_VENDOR, "Sends a notice to snomasks j (local) and J (remote) when a channel is created.") { } void init() override { ServerInstance->SNO.EnableSnomask('j', "CHANCREATE"); } void OnUserJoin(Membership* memb, bool sync, bool created, CUList& except) override { if ((created) && (IS_LOCAL(memb->user))) { ServerInstance->SNO.WriteGlobalSno('j', "Channel {} created by {} [{}]", memb->chan->name, memb->user->GetRealMask(), memb->user->GetAddress()); } } }; MODULE_INIT(ModuleChanCreate) ���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/src/modules/m_chanfilter.cpp���������������������������������������������������������0000664�0000000�0000000�00000012457�14771603147�0020756�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2019 linuxdaemon <linuxdaemon.irc@gmail.com> * Copyright (C) 2017-2024 Sadie Powell <sadie@witchery.services> * Copyright (C) 2012-2014 Attila Molnar <attilamolnar@hush.com> * Copyright (C) 2012, 2018 Robby <robby@chatbelgie.be> * Copyright (C) 2009 Daniel De Graaf <danieldg@inspircd.org> * Copyright (C) 2007 Dennis Friis <peavey@inspircd.org> * Copyright (C) 2006, 2008-2009 Craig Edwards <brain@inspircd.org> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include "inspircd.h" #include "clientprotocolmsg.h" #include "listmode.h" #include "modules/exemption.h" #include "numerichelper.h" enum { // InspIRCd-specific. RPL_ENDOFSPAMFILTER = 940, RPL_SPAMFILTER = 941 }; class ChanFilter final : public ListModeBase { public: unsigned long maxlen; ChanFilter(Module* Creator) : ListModeBase(Creator, "filter", 'g', RPL_SPAMFILTER, RPL_ENDOFSPAMFILTER) { syntax = "<pattern>"; } bool ValidateParam(LocalUser* user, Channel* chan, std::string& parameter) override { // We only enforce the length restriction against local users to avoid causing a desync. if (parameter.length() > maxlen) { user->WriteNumeric(Numerics::InvalidModeParameter(chan, this, parameter, "Entry is too long for the spamfilter list.")); return false; } return true; } }; class ModuleChanFilter final : public Module { CheckExemption::EventProvider exemptionprov; ChanFilter cf; bool hidemask; bool notifyuser; const ChanFilter::ListItem* Match(User* user, Channel* chan, const std::string& text) { if (!IS_LOCAL(user)) return nullptr; // We don't handle remote users. if (user->HasPrivPermission("channels/ignore-chanfilter")) return nullptr; // The source is an exempt server operator. if (exemptionprov.Check(user, chan, "filter") == MOD_RES_ALLOW) return nullptr; // The source matches an exemptchanops entry. ListModeBase::ModeList* list = cf.GetList(chan); if (!list) return nullptr; for (const auto& entry : *list) { if (InspIRCd::Match(text, entry.mask)) return &entry; } return nullptr; } public: ModuleChanFilter() : Module(VF_VENDOR, "Adds channel mode g (filter) which allows channel operators to define glob patterns for inappropriate phrases that are not allowed to be used in the channel.") , exemptionprov(this) , cf(this) { } void ReadConfig(ConfigStatus& status) override { const auto& tag = ServerInstance->Config->ConfValue("chanfilter"); hidemask = tag->getBool("hidemask"); cf.maxlen = tag->getNum<unsigned long>("maxlen", 35, 10, ModeParser::MODE_PARAM_MAX); notifyuser = tag->getBool("notifyuser", true); cf.DoRehash(); } void OnUserPart(Membership* memb, std::string& partmessage, CUList& except_list) override { if (!memb) return; User* user = memb->user; Channel* chan = memb->chan; const ChanFilter::ListItem* match = Match(user, chan, partmessage); if (!match) return; // Match() checks the user is local, we can assume from here LocalUser* luser = IS_LOCAL(user); std::string oldreason(partmessage); partmessage = "Reason filtered"; if (!notifyuser) { // Send fake part ClientProtocol::Messages::Part partmsg(memb, oldreason); ClientProtocol::Event ev(ServerInstance->GetRFCEvents().part, partmsg); luser->Send(ev); // Don't send the user the changed message except_list.insert(user); return; } if (hidemask) user->WriteNumeric(Numerics::CannotSendTo(chan, "Your part message contained a banned phrase and was blocked.")); else { user->WriteNumeric(Numerics::CannotSendTo(chan, INSP_FORMAT("Your part message contained a banned phrase ({}) and was blocked.", match->mask))); } } ModResult OnUserPreMessage(User* user, MessageTarget& target, MessageDetails& details) override { if (target.type != MessageTarget::TYPE_CHANNEL) return MOD_RES_PASSTHRU; auto* chan = target.Get<Channel>(); const ChanFilter::ListItem* match = Match(user, chan, details.text); if (match) { if (!notifyuser) { details.echo_original = true; return MOD_RES_DENY; } if (hidemask) user->WriteNumeric(Numerics::CannotSendTo(chan, "Your message to this channel contained a banned phrase and was blocked.")); else { user->WriteNumeric(Numerics::CannotSendTo(chan, INSP_FORMAT("Your message to this channel contained a banned phrase ({}) and was blocked.", match->mask))); } return MOD_RES_DENY; } return MOD_RES_PASSTHRU; } void GetLinkData(LinkData& data, std::string& compatdata) override { data["max-length"] = ConvToStr(cf.maxlen); // We don't send any link data if the length is 35 for compatibility with v3 and earlier.. if (cf.maxlen != 35) compatdata = ConvToStr(cf.maxlen); } }; MODULE_INIT(ModuleChanFilter) �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/src/modules/m_chanhistory.cpp��������������������������������������������������������0000664�0000000�0000000�00000017710�14771603147�0021167�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2021 Dominic Hamon * Copyright (C) 2017-2025 Sadie Powell <sadie@witchery.services> * Copyright (C) 2013 Daniel Vassdal <shutter@canternet.org> * Copyright (C) 2012, 2014, 2018 Attila Molnar <attilamolnar@hush.com> * Copyright (C) 2012 Robby <robby@chatbelgie.be> * Copyright (C) 2009-2010 Daniel De Graaf <danieldg@inspircd.org> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include "inspircd.h" #include "clientprotocolmsg.h" #include "modules/ircv3_batch.h" #include "modules/ircv3_servertime.h" #include "modules/server.h" #include "numerichelper.h" typedef insp::flat_map<std::string, std::string> HistoryTagMap; struct HistoryItem final { time_t ts; std::string text; MessageType type; HistoryTagMap tags; std::string sourcemask; HistoryItem(User* source, const MessageDetails& details) : ts(ServerInstance->Time()) , text(details.text) , type(details.type) , sourcemask(source->GetMask()) { tags.reserve(details.tags_out.size()); for (const auto& [tagname, tagvalue] : details.tags_out) tags[tagname] = tagvalue.value; } }; struct HistoryList final { std::deque<HistoryItem> lines; unsigned long maxlen; unsigned long maxtime; HistoryList(unsigned long len, unsigned long time) : maxlen(len) , maxtime(time) { } size_t Prune() { // Prune expired entries from the list. if (maxtime) { time_t mintime = ServerInstance->Time() - maxtime; while (!lines.empty() && lines.front().ts < mintime) lines.pop_front(); } return lines.size(); } }; class HistoryMode final : public ParamMode<HistoryMode, SimpleExtItem<HistoryList>> { private: bool ParseDuration(User* user, irc::sepstream& stream, unsigned long& duration) { std::string durationstr; if (!stream.GetToken(durationstr)) return false; if (!Duration::TryFrom(durationstr, duration) || duration == 0) return false; if (IS_LOCAL(user) && maxduration && duration > maxduration) duration = maxduration; // Clamp for local users. return true; } bool ParseLines(User* user, irc::sepstream& stream, unsigned long& lines) { std::string linesstr; if (!stream.GetToken(linesstr)) return false; lines = ConvToNum<unsigned long>(linesstr); if (lines == 0) return false; if (IS_LOCAL(user) && maxlines && lines > maxlines) lines = maxlines; // Clamp for local users. return true; } public: unsigned long maxduration; unsigned long maxlines; HistoryMode(Module* Creator) : ParamMode<HistoryMode, SimpleExtItem<HistoryList>>(Creator, "history", 'H') { syntax = "<max-messages>:<max-duration>"; } bool OnSet(User* source, Channel* channel, std::string& parameter) override { irc::sepstream stream(parameter, ':'); unsigned long lines; unsigned long duration; if (!ParseLines(source, stream, lines) || !ParseDuration(source, stream, duration)) { source->WriteNumeric(Numerics::InvalidModeParameter(channel, this, parameter)); return false; } HistoryList* history = ext.Get(channel); if (history) { // Shrink the list if the new line number limit is lower than the old one if (lines < history->lines.size()) history->lines.erase(history->lines.begin(), history->lines.begin() + (history->lines.size() - lines)); history->maxlen = lines; history->maxtime = duration; history->Prune(); } else { ext.SetFwd(channel, lines, duration); } return true; } void SerializeParam(Channel* chan, const HistoryList* history, std::string& out) { out.append(ConvToStr(history->maxlen)); out.append(":"); out.append(Duration::ToString(history->maxtime)); } }; class ModuleChanHistory final : public Module , public ServerProtocol::RouteEventListener { private: HistoryMode historymode; SimpleUserMode nohistorymode; UserModeReference botmode; IRCv3::Batch::CapReference batchcap; IRCv3::Batch::API batchmanager; IRCv3::Batch::Batch batch; IRCv3::ServerTime::API servertimemanager; ClientProtocol::MessageTagEvent tagevent; bool prefixmsg; bool savefrombots; bool sendtobots; void AddTag(ClientProtocol::Message& msg, const std::string& tagkey, std::string& tagval) { for (auto* subscriber : tagevent.GetSubscribers()) { ClientProtocol::MessageTagProvider* const tagprov = static_cast<ClientProtocol::MessageTagProvider*>(subscriber); const ModResult res = tagprov->OnProcessTag(ServerInstance->FakeClient, tagkey, tagval); if (res == MOD_RES_ALLOW) msg.AddTag(tagkey, tagprov, tagval); else if (res == MOD_RES_DENY) break; } } void SendHistory(LocalUser* user, Channel* channel, HistoryList* list) { if (batchmanager) { batchmanager->Start(batch); batch.GetBatchStartMessage().PushParamRef(channel->name); } for (auto& item : list->lines) { ClientProtocol::Messages::Privmsg msg(ClientProtocol::Messages::Privmsg::nocopy, item.sourcemask, channel, item.text, item.type); for (auto& [tagname, tagvalue] : item.tags) AddTag(msg, tagname, tagvalue); if (servertimemanager) servertimemanager->Set(msg, item.ts); batch.AddToBatch(msg); user->Send(ServerInstance->GetRFCEvents().privmsg, msg); } if (batchmanager) batchmanager->End(batch); } public: ModuleChanHistory() : Module(VF_VENDOR, "Adds channel mode H (history) which allows message history to be viewed on joining the channel.") , ServerProtocol::RouteEventListener(this) , historymode(this) , nohistorymode(this, "nohistory", 'N') , botmode(this, "bot") , batchcap(this) , batchmanager(this) , batch("chathistory") , servertimemanager(this) , tagevent(this) { } void ReadConfig(ConfigStatus& status) override { const auto& tag = ServerInstance->Config->ConfValue("chanhistory"); historymode.maxduration = tag->getDuration("maxduration", 60*60*24*28); historymode.maxlines = tag->getNum<unsigned long>("maxlines", 50); prefixmsg = tag->getBool("prefixmsg", true); savefrombots = tag->getBool("savefrombots", true); sendtobots = tag->getBool("sendtobots", tag->getBool("bots", true)); } ModResult OnRouteMessage(const Channel* channel, const Server* server) override { return channel->IsModeSet(historymode) && !server->IsService() ? MOD_RES_ALLOW : MOD_RES_PASSTHRU; } void OnUserPostMessage(User* user, const MessageTarget& target, const MessageDetails& details) override { if (target.type != MessageTarget::TYPE_CHANNEL || target.status) return; if (user->IsModeSet(botmode) && !savefrombots) return; std::string_view ctcpname; if (details.IsCTCP(ctcpname) && !irc::equals(ctcpname, "ACTION")) return; HistoryList* list = historymode.ext.Get(target.Get<Channel>()); if (!list) return; list->lines.emplace_back(user, details); if (list->lines.size() > list->maxlen) list->lines.pop_front(); } void OnPostJoin(Membership* memb) override { LocalUser* localuser = IS_LOCAL(memb->user); if (!localuser) return; if (memb->user->IsModeSet(botmode) && !sendtobots) return; if (memb->user->IsModeSet(nohistorymode)) return; HistoryList* list = historymode.ext.Get(memb->chan); if (!list || !list->Prune()) return; if ((prefixmsg) && (!batchcap.IsEnabled(localuser))) { auto message = INSP_FORMAT("Replaying up to {} lines of pre-join history", list->maxlen); if (list->maxtime > 0) message += INSP_FORMAT(" from the last {}", Duration::ToLongString(list->maxtime)); memb->WriteNotice(message); } SendHistory(localuser, memb->chan, list); } }; MODULE_INIT(ModuleChanHistory) ��������������������������������������������������������inspircd-4.7.0/src/modules/m_chanlog.cpp������������������������������������������������������������0000664�0000000�0000000�00000005622�14771603147�0020246�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2018-2024 Sadie Powell <sadie@witchery.services> * Copyright (C) 2018 linuxdaemon <linuxdaemon.irc@gmail.com> * Copyright (C) 2012-2014, 2018 Attila Molnar <attilamolnar@hush.com> * Copyright (C) 2012, 2019 Robby <robby@chatbelgie.be> * Copyright (C) 2009 Daniel De Graaf <danieldg@inspircd.org> * Copyright (C) 2008 Thomas Stagner <aquanight@gmail.com> * Copyright (C) 2008 Robin Burchell <robin+git@viroteck.net> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include "inspircd.h" #include "clientprotocolmsg.h" class ModuleChanLog final : public Module { /* * Multimap so people can redirect a snomask to multiple channels. */ typedef insp::flat_multimap<char, std::string> ChanLogTargets; ChanLogTargets logstreams; public: ModuleChanLog() : Module(VF_VENDOR, "Allows messages sent to snomasks to be logged to a channel.") { } void ReadConfig(ConfigStatus& status) override { ChanLogTargets newlogs; for (const auto& [_, tag] : ServerInstance->Config->ConfTags("chanlog")) { const std::string channel = tag->getString("channel"); if (!ServerInstance->Channels.IsChannel(channel)) throw ModuleException(this, "<chanlog:channel> must be set to a channel name, at " + tag->source.str()); const std::string snomasks = tag->getString("snomasks"); if (snomasks.empty()) throw ModuleException(this, "<chanlog:snomasks> must not be empty, at " + tag->source.str()); for (const auto snomask : snomasks) { newlogs.emplace(snomask, channel); ServerInstance->Logs.Normal(MODNAME, "Logging {} to {}", snomask, channel); } } logstreams.swap(newlogs); } ModResult OnSendSnotice(char& sno, std::string& desc, const std::string& msg) override { auto channels = insp::equal_range(logstreams, sno); if (channels.empty()) return MOD_RES_PASSTHRU; const std::string snotice = "\002" + desc + "\002: " + msg; for (const auto& [_, channel] : channels) { auto* c = ServerInstance->Channels.Find(channel); if (c) { ClientProtocol::Messages::Privmsg privmsg(ClientProtocol::Messages::Privmsg::nocopy, ServerInstance->FakeClient, c, snotice); c->Write(ServerInstance->GetRFCEvents().privmsg, privmsg); ServerInstance->PI->SendMessage(c, 0, snotice); } } return MOD_RES_PASSTHRU; } }; MODULE_INIT(ModuleChanLog) ��������������������������������������������������������������������������������������������������������������inspircd-4.7.0/src/modules/m_channames.cpp����������������������������������������������������������0000664�0000000�0000000�00000010301�14771603147�0020556�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2021 Dominic Hamon * Copyright (C) 2019-2023 Sadie Powell <sadie@witchery.services> * Copyright (C) 2013 Daniel Vassdal <shutter@canternet.org> * Copyright (C) 2012-2014 Attila Molnar <attilamolnar@hush.com> * Copyright (C) 2012 Robby <robby@chatbelgie.be> * Copyright (C) 2009-2010 Daniel De Graaf <danieldg@inspircd.org> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include "inspircd.h" static CharState allowedmap; class NewIsChannelHandler final { public: static bool Call(const std::string_view&); }; bool NewIsChannelHandler::Call(const std::string_view& channame) { if (channame.empty() || channame.length() > ServerInstance->Config->Limits.MaxChannel || !ServerInstance->Channels.IsPrefix(channame[0])) return false; for (const auto chr : channame) { if (!allowedmap[static_cast<unsigned char>(chr)]) return false; } return true; } class ModuleChannelNames final : public Module { std::function<bool(const std::string_view&)> rememberer; bool badchan = false; ChanModeReference permchannelmode; public: ModuleChannelNames() : Module(VF_VENDOR, "Allows the server administrator to define what characters are allowed in channel names.") , rememberer(ServerInstance->Channels.IsChannel) , permchannelmode(this, "permanent") { } void ValidateChans() { Modes::ChangeList removepermchan; badchan = true; const ChannelMap& chans = ServerInstance->Channels.GetChans(); for (ChannelMap::const_iterator i = chans.begin(); i != chans.end(); ) { Channel* c = i->second; // Move iterator before we begin kicking ++i; if (ServerInstance->Channels.IsChannel(c->name)) continue; // The name of this channel is still valid if (c->IsModeSet(permchannelmode) && !c->GetUsers().empty()) { removepermchan.clear(); removepermchan.push_remove(*permchannelmode); ServerInstance->Modes.Process(ServerInstance->FakeClient, c, nullptr, removepermchan); } Channel::MemberMap& users = c->userlist; for (Channel::MemberMap::iterator j = users.begin(); j != users.end(); ) { if (IS_LOCAL(j->first)) { // KickUser invalidates the iterator Channel::MemberMap::iterator it = j++; c->KickUser(ServerInstance->FakeClient, it, "Channel name no longer valid"); } else ++j; } } badchan = false; } void ReadConfig(ConfigStatus& status) override { const auto& tag = ServerInstance->Config->ConfValue("channames"); std::string denyToken = tag->getString("denyrange"); std::string allowToken = tag->getString("allowrange"); if (!denyToken.compare(0, 2, "0-")) denyToken[0] = '1'; if (!allowToken.compare(0, 2, "0-")) allowToken[0] = '1'; allowedmap.set(); irc::portparser denyrange(denyToken, false); long denyno = -1; while (0 != (denyno = denyrange.GetToken())) allowedmap[denyno & UCHAR_MAX] = false; irc::portparser allowrange(allowToken, false); long allowno = -1; while (0 != (allowno = allowrange.GetToken())) allowedmap[allowno & UCHAR_MAX] = true; allowedmap[0x07] = false; // BEL allowedmap[0x20] = false; // ' ' allowedmap[0x2C] = false; // ',' ServerInstance->Channels.IsChannel = NewIsChannelHandler::Call; ValidateChans(); } void OnUserKick(User* source, Membership* memb, const std::string& reason, CUList& except_list) override { if (badchan) { for (const auto& [user, _] : memb->chan->GetUsers()) { if (user != memb->user) except_list.insert(user); } } } Cullable::Result Cull() override { ServerInstance->Channels.IsChannel = rememberer; ValidateChans(); return Module::Cull(); } }; MODULE_INIT(ModuleChannelNames) �������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/src/modules/m_channelban.cpp���������������������������������������������������������0000664�0000000�0000000�00000003720�14771603147�0020721�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2020-2022 Sadie Powell <sadie@witchery.services> * Copyright (C) 2012 Robby <robby@chatbelgie.be> * Copyright (C) 2009 Uli Schlachter <psychon@znc.in> * Copyright (C) 2009 Daniel De Graaf <danieldg@inspircd.org> * Copyright (C) 2008 Robin Burchell <robin+git@viroteck.net> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include "inspircd.h" #include "modules/extban.h" class ChannelExtBan final : public ExtBan::MatchingBase { public: ChannelExtBan(Module* Creator) : ExtBan::MatchingBase(Creator, "channel", 'j') { } bool IsMatch(User* user, Channel* channel, const std::string& text) override { unsigned char status = 0; const char* target = text.c_str(); const PrefixMode* const mh = ServerInstance->Modes.FindPrefix(text[0]); if (mh) { status = mh->GetModeChar(); target++; } for (auto* memb : user->chans) { if (!InspIRCd::Match(memb->chan->name, target)) continue; if (!status || memb->GetRank() >= mh->GetPrefixRank()) return true; } return false; } }; class ModuleBadChannelExtban final : public Module { private: ChannelExtBan extban; public: ModuleBadChannelExtban() : Module(VF_VENDOR | VF_OPTCOMMON, "Adds extended ban j: (channel) which checks whether users are in a channel matching the specified glob pattern.") , extban(this) { } }; MODULE_INIT(ModuleBadChannelExtban) ������������������������������������������������inspircd-4.7.0/src/modules/m_check.cpp��������������������������������������������������������������0000664�0000000�0000000�00000022613�14771603147�0017707�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2020 Matt Schatz <genius3000@g3k.solutions> * Copyright (C) 2018-2023, 2025 Sadie Powell <sadie@witchery.services> * Copyright (C) 2013, 2016 Attila Molnar <attilamolnar@hush.com> * Copyright (C) 2012 Robby <robby@chatbelgie.be> * Copyright (C) 2009-2010 Daniel De Graaf <danieldg@inspircd.org> * Copyright (C) 2007 Dennis Friis <peavey@inspircd.org> * Copyright (C) 2006 Robin Burchell <robin+git@viroteck.net> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include "inspircd.h" #include "listmode.h" #include "numericbuilder.h" #include "timeutils.h" #include "utility/string.h" enum { RPL_CHECK = 802 }; class CheckContext final { private: User* const user; const std::string& target; static std::string FormatTime(time_t ts) { auto timestr = Time::ToString(ts, Time::DEFAULT_LONG, true); timestr += INSP_FORMAT(" ({})", ServerInstance->Time()); return timestr; } public: CheckContext(User* u, const std::string& targetstr) : user(u) , target(targetstr) { Write("START", target); } ~CheckContext() { Write("END", target); } void Write(const std::string& type, const std::string& text) { user->WriteRemoteNumeric(RPL_CHECK, type, text); } void Write(const std::string& type, time_t ts) { user->WriteRemoteNumeric(RPL_CHECK, type, FormatTime(ts)); } User* GetUser() const { return user; } void DumpListMode(ListModeBase* mode, Channel* chan) { const ListModeBase::ModeList* list = mode->GetList(chan); if (!list) return; for (const auto& entry : *list) { CheckContext::List listmode(*this, "listmode"); listmode.Add(ConvToStr(mode->GetModeChar())); listmode.Add(entry.mask); listmode.Add(entry.setter); listmode.Add(FormatTime(entry.time)); listmode.Flush(); } } void DumpExt(Extensible* ext) { CheckContext::List extlist(*this, "metadata"); for (const auto& [item, obj] : ext->GetExtList()) { const std::string value = item->ToHuman(ext, obj); if (!value.empty()) Write("meta:" + item->name, value); else if (!item->name.empty()) extlist.Add(item->name); } extlist.Flush(); } class List final : public Numeric::GenericBuilder<' ', false, Numeric::WriteRemoteNumericSink> { public: List(CheckContext& context, const char* checktype) : Numeric::GenericBuilder<' ', false, Numeric::WriteRemoteNumericSink>(Numeric::WriteRemoteNumericSink(context.GetUser()), RPL_CHECK, false, (IS_LOCAL(context.GetUser()) ? context.GetUser()->nick.length() : ServerInstance->Config->Limits.MaxNick) + strlen(checktype) + 1) { GetNumeric().push(checktype).push(std::string()); } }; }; class CommandCheck final : public Command { UserModeReference snomaskmode; std::string GetSnomasks(User* user) { std::string ret; if (snomaskmode) ret = snomaskmode->GetUserParameter(user); if (ret.empty()) ret = "+"; return ret; } public: CommandCheck(Module* parent) : Command(parent, "CHECK", 1) , snomaskmode(parent, "snomask") { access_needed = CmdAccess::OPERATOR; syntax = { "<nick>|<channel> [<servername>]", "<nickmask>|<usermask>|<hostmask>|<ipmask>|<realnamemask> [<servername>]", }; } CmdResult Handle(User* user, const Params& parameters) override { if (parameters.size() > 1 && !irc::equals(parameters[1], ServerInstance->Config->ServerName)) return CmdResult::SUCCESS; auto* targetuser = ServerInstance->Users.FindNick(parameters[0]); auto* targetchan = ServerInstance->Channels.Find(parameters[0]); /* * Syntax of a /check reply: * :server.name 802 target START <target> * :server.name 802 target <field> :<value> * :server.name 802 target END <target> */ // Constructor sends START, destructor sends END CheckContext context(user, parameters[0]); if (targetuser) { LocalUser* localtarget = IS_LOCAL(targetuser); /* /check on a user */ context.Write("nuh", targetuser->GetMask()); context.Write("realnuh", targetuser->GetRealMask()); context.Write("realname", targetuser->GetRealName()); context.Write("modes", targetuser->GetModeLetters()); context.Write("snomasks", GetSnomasks(targetuser)); context.Write("server", targetuser->server->GetName()); context.Write("uid", targetuser->uuid); context.Write("signon", targetuser->signon); context.Write("nickchanged", targetuser->nickchanged); if (localtarget) context.Write("lastmsg", localtarget->idle_lastmsg); if (targetuser->IsAway()) { /* user is away */ context.Write("awaytime", targetuser->away->time); context.Write("awaymsg", targetuser->away->message); } if (targetuser->IsOper()) { context.Write("oper", targetuser->oper->GetName()); context.Write("opertype", targetuser->oper->GetType()); if (localtarget) { context.Write("chanmodeperms", localtarget->oper->GetModes(MODETYPE_CHANNEL)); context.Write("usermodeperms", localtarget->oper->GetModes(MODETYPE_USER)); context.Write("snomaskperms", localtarget->oper->GetSnomasks()); context.Write("commandperms", localtarget->oper->GetCommands()); context.Write("permissions", localtarget->oper->GetPrivileges()); } } if (localtarget) { context.Write("clientaddr", localtarget->client_sa.str()); context.Write("serveraddr", localtarget->server_sa.str()); std::string classname = localtarget->GetClass()->name; if (!classname.empty()) context.Write("connectclass", classname); context.Write("exempt", localtarget->exempt ? "yes" : "no"); context.Write("serializer", localtarget->serializer->name.substr(11)); } else context.Write("onip", targetuser->GetAddress()); CheckContext::List chanlist(context, "onchans"); for (const auto* memb : targetuser->chans) chanlist.Add(memb->GetAllPrefixChars() + memb->chan->name); chanlist.Flush(); context.DumpExt(targetuser); } else if (targetchan) { /* /check on a channel */ context.Write("createdat", targetchan->age); if (!targetchan->topic.empty()) { /* there is a topic, assume topic related information exists */ context.Write("topic", targetchan->topic); context.Write("topic_setby", targetchan->setby); context.Write("topic_setat", targetchan->topicset); } context.Write("modes", targetchan->ChanModes(true)); context.Write("membercount", ConvToStr(targetchan->GetUsers().size())); for (const auto& [u, memb] : targetchan->GetUsers()) { /* * Unlike Asuka, I define a clone as coming from the same host. --w00t */ const UserManager::CloneCounts& clonecount = ServerInstance->Users.GetCloneCounts(u); context.Write("member", INSP_FORMAT("{} {}{} ({}\x0F)", clonecount.global, memb->GetAllPrefixChars(), u->GetMask(), u->GetRealName())); } for (auto* lm : ServerInstance->Modes.GetListModes()) context.DumpListMode(lm, targetchan); context.DumpExt(targetchan); } else { /* /check on an IP address, or something that doesn't exist */ size_t x = 0; std::vector<const char*> matches; matches.reserve(6); /* hostname or other */ for (const auto& [_, u] : ServerInstance->Users.GetUsers()) { if (InspIRCd::Match(u->nick, parameters[0], ascii_case_insensitive_map)) matches.push_back("nick"); if (InspIRCd::Match(u->GetRealUser(), parameters[0], ascii_case_insensitive_map)) matches.push_back("ruser"); if (InspIRCd::Match(u->GetDisplayedUser(), parameters[0], ascii_case_insensitive_map)) matches.push_back("duser"); if (InspIRCd::Match(u->GetRealHost(), parameters[0], ascii_case_insensitive_map)) matches.push_back("rhost"); if (InspIRCd::Match(u->GetDisplayedHost(), parameters[0], ascii_case_insensitive_map)) matches.push_back("dhost"); if (InspIRCd::MatchCIDR(u->GetAddress(), parameters[0])) matches.push_back("ipaddr"); if (InspIRCd::MatchCIDR(u->GetRealName(), parameters[0])) matches.push_back("realname"); if (!matches.empty()) { const std::string whatmatch = insp::join(matches, ','); context.Write("match", INSP_FORMAT("{} {} {} {} {} {} {} {} :{}", ++x, whatmatch, u->nick, u->GetRealUser(), u->GetDisplayedUser(), u->GetRealHost(), u->GetDisplayedHost(), u->GetAddress(), u->GetRealName())); matches.clear(); } } context.Write("matches", ConvToStr(x)); } // END is sent by the CheckContext destructor return CmdResult::SUCCESS; } RouteDescriptor GetRouting(User* user, const Params& parameters) override { if ((parameters.size() > 1) && (parameters[1].find('.') != std::string::npos)) return ROUTE_OPT_UCAST(parameters[1]); return ROUTE_LOCALONLY; } }; class ModuleCheck final : public Module { private: CommandCheck cmd; public: ModuleCheck() : Module(VF_VENDOR | VF_OPTCOMMON, "Adds the /CHECK command which allows server operators to look up details about a channel, user, IP address, or hostname.") , cmd(this) { } }; MODULE_INIT(ModuleCheck) ���������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/src/modules/m_chghost.cpp������������������������������������������������������������0000664�0000000�0000000�00000007261�14771603147�0020273�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2013-2014, 2017, 2019-2023, 2025 Sadie Powell <sadie@witchery.services> * Copyright (C) 2012-2013, 2016 Attila Molnar <attilamolnar@hush.com> * Copyright (C) 2012 Robby <robby@chatbelgie.be> * Copyright (C) 2009, 2012 Daniel De Graaf <danieldg@inspircd.org> * Copyright (C) 2008 Robin Burchell <robin+git@viroteck.net> * Copyright (C) 2007 Dennis Friis <peavey@inspircd.org> * Copyright (C) 2006 Craig Edwards <brain@inspircd.org> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include "inspircd.h" #include "numerichelper.h" class CommandChghost final : public Command { public: CharState hostmap; CommandChghost(Module* Creator) : Command(Creator, "CHGHOST", 2) { access_needed = CmdAccess::OPERATOR; syntax = { "<nick> <host>" }; translation = { TR_NICK, TR_TEXT }; } CmdResult Handle(User* user, const Params& parameters) override { if (parameters[1].length() > ServerInstance->Config->Limits.MaxHost) { user->WriteNotice("*** CHGHOST: Host too long"); return CmdResult::FAILURE; } for (const auto chr : parameters[1]) { if (!hostmap.test(static_cast<unsigned char>(chr))) { user->WriteNotice("*** CHGHOST: Invalid characters in hostname"); return CmdResult::FAILURE; } } auto* dest = ServerInstance->Users.Find(parameters[0]); // Allow services to change the host of partially connected users. if (!dest || (!dest->IsFullyConnected() && !user->server->IsService())) { user->WriteNumeric(Numerics::NoSuchNick(parameters[0])); return CmdResult::FAILURE; } if (IS_LOCAL(dest)) { dest->ChangeDisplayedHost(parameters[1]); if (!user->server->IsService()) { ServerInstance->SNO.WriteGlobalSno('a', user->nick+" used CHGHOST to make the displayed host of "+dest->nick+" become "+dest->GetDisplayedHost()); } } return CmdResult::SUCCESS; } RouteDescriptor GetRouting(User* user, const Params& parameters) override { return ROUTE_OPT_UCAST(parameters[0]); } }; class ModuleChgHost final : public Module { private: CommandChghost cmd; public: ModuleChgHost() : Module(VF_VENDOR | VF_OPTCOMMON, "Adds the /CHGHOST command which allows server operators to change the displayed hostname of a user.") , cmd(this) { } void ReadConfig(ConfigStatus& status) override { const auto& tag = ServerInstance->Config->ConfValue("hostname"); const std::string hmap = tag->getString("charmap", "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz.-_/0123456789", 1); CharState newhostmap; for (const auto chr : hmap) { // A hostname can not contain NUL, LF, CR, or SPACE. if (chr == 0x00 || chr == 0x0A || chr == 0x0D || chr == 0x20) throw ModuleException(this, "<hostname:charmap> can not contain character 0x{:02X} ({})", chr, chr); newhostmap.set(static_cast<unsigned char>(chr)); } std::swap(newhostmap, cmd.hostmap); } void GetLinkData(Module::LinkData& data, std::string& compatdata) override { for (size_t i = 0; i < cmd.hostmap.size(); ++i) if (cmd.hostmap[i]) data["hostchars"].push_back(static_cast<unsigned char>(i)); } }; MODULE_INIT(ModuleChgHost) �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/src/modules/m_chgident.cpp�����������������������������������������������������������0000664�0000000�0000000�00000005071�14771603147�0020416�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2019-2023 Sadie Powell <sadie@witchery.services> * Copyright (C) 2012, 2016 Attila Molnar <attilamolnar@hush.com> * Copyright (C) 2012 Robby <robby@chatbelgie.be> * Copyright (C) 2009 Daniel De Graaf <danieldg@inspircd.org> * Copyright (C) 2008 Craig Edwards <brain@inspircd.org> * Copyright (C) 2007 John Brooks <john@jbrooks.io> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include "inspircd.h" #include "numerichelper.h" class CommandChgident final : public Command { public: CommandChgident(Module* Creator) : Command(Creator, "CHGIDENT", 2) { access_needed = CmdAccess::OPERATOR; syntax = { "<nick> <username>" }; translation = { TR_NICK, TR_TEXT }; } CmdResult Handle(User* user, const Params& parameters) override { auto* dest = ServerInstance->Users.Find(parameters[0], true); if (!dest) { user->WriteNumeric(Numerics::NoSuchNick(parameters[0])); return CmdResult::FAILURE; } if (parameters[1].length() > ServerInstance->Config->Limits.MaxUser) { user->WriteNotice("*** CHGIDENT: Username is too long"); return CmdResult::FAILURE; } if (!ServerInstance->IsUser(parameters[1])) { user->WriteNotice("*** CHGIDENT: Invalid characters in username"); return CmdResult::FAILURE; } if (IS_LOCAL(dest)) { dest->ChangeDisplayedUser(parameters[1]); if (!user->server->IsService()) { ServerInstance->SNO.WriteGlobalSno('a', "{} used CHGIDENT to change {}'s username to '{}'", user->nick, dest->nick, dest->GetDisplayedUser()); } } return CmdResult::SUCCESS; } RouteDescriptor GetRouting(User* user, const Params& parameters) override { return ROUTE_OPT_UCAST(parameters[0]); } }; class ModuleChgIdent final : public Module { private: CommandChgident cmd; public: ModuleChgIdent() : Module(VF_VENDOR | VF_OPTCOMMON, "Adds the /CHGIDENT command which allows server operators to change the username of a user.") , cmd(this) { } }; MODULE_INIT(ModuleChgIdent) �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/src/modules/m_chgname.cpp������������������������������������������������������������0000664�0000000�0000000�00000004765�14771603147�0020244�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2018-2023 Sadie Powell <sadie@witchery.services> * Copyright (C) 2018 Matt Schatz <genius3000@g3k.solutions> * Copyright (C) 2012, 2016 Attila Molnar <attilamolnar@hush.com> * Copyright (C) 2012 Robby <robby@chatbelgie.be> * Copyright (C) 2009 Daniel De Graaf <danieldg@inspircd.org> * Copyright (C) 2007 Robin Burchell <robin+git@viroteck.net> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include "inspircd.h" #include "numerichelper.h" class CommandChgname final : public Command { public: CommandChgname(Module* Creator) : Command(Creator, "CHGNAME", 2, 2) { access_needed = CmdAccess::OPERATOR; syntax = { "<nick> :<realname>" }; translation = { TR_NICK, TR_TEXT }; } CmdResult Handle(User* user, const Params& parameters) override { auto* dest = ServerInstance->Users.Find(parameters[0], true); if (!dest) { user->WriteNumeric(Numerics::NoSuchNick(parameters[0])); return CmdResult::FAILURE; } if (parameters[1].empty()) { user->WriteNotice("*** CHGNAME: Real name must be specified"); return CmdResult::FAILURE; } if (parameters[1].length() > ServerInstance->Config->Limits.MaxReal) { user->WriteNotice("*** CHGNAME: Real name is too long"); return CmdResult::FAILURE; } if (IS_LOCAL(dest)) { dest->ChangeRealName(parameters[1]); ServerInstance->SNO.WriteGlobalSno('a', "{} used CHGNAME to change {}'s real name to '{}\x0F'", user->nick, dest->nick, dest->GetRealName()); } return CmdResult::SUCCESS; } RouteDescriptor GetRouting(User* user, const Params& parameters) override { return ROUTE_OPT_UCAST(parameters[0]); } }; class ModuleChgName final : public Module { private: CommandChgname cmd; public: ModuleChgName() : Module(VF_VENDOR | VF_OPTCOMMON, "Adds the /CHGNAME command which allows server operators to change the real name of a user.") , cmd(this) { } }; MODULE_INIT(ModuleChgName) �����������inspircd-4.7.0/src/modules/m_classban.cpp�����������������������������������������������������������0000664�0000000�0000000�00000003220�14771603147�0020411�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2020-2021, 2023 Sadie Powell <sadie@witchery.services> * Copyright (C) 2016 Johanna A * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include "inspircd.h" #include "modules/extban.h" class ClassExtBan final : public ExtBan::MatchingBase { public: ClassExtBan(Module* Creator) : ExtBan::MatchingBase(Creator, "class", 'n') { } bool IsMatch(User* user, Channel* channel, const std::string& text) override { LocalUser* luser = IS_LOCAL(user); if (!luser) return false; // Replace spaces with underscores as they're prohibited in mode parameters. std::string classname(luser->GetClass()->name); std::replace(classname.begin(), classname.end(), ' ', '_'); return InspIRCd::Match(classname, text); } }; class ModuleClassBan final : public Module { private: ClassExtBan extban; public: ModuleClassBan() : Module(VF_VENDOR | VF_OPTCOMMON, "Adds extended ban n: (class) which check whether users are in a connect class matching the specified glob pattern.") , extban(this) { } }; MODULE_INIT(ModuleClassBan) ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/src/modules/m_clearchan.cpp����������������������������������������������������������0000664�0000000�0000000�00000014600�14771603147�0020547�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2018-2023 Sadie Powell <sadie@witchery.services> * Copyright (C) 2014 Attila Molnar <attilamolnar@hush.com> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include "inspircd.h" #include "xline.h" class CommandClearChan final : public Command { public: Channel* activechan; CommandClearChan(Module* Creator) : Command(Creator, "CLEARCHAN", 1, 3) { syntax = { "<channel> [KILL|KICK|G|Z] [:<reason>]" }; access_needed = CmdAccess::OPERATOR; // Stop the linking mod from forwarding ENCAP'd CLEARCHAN commands, see below why force_manual_route = true; } CmdResult Handle(User* user, const Params& parameters) override { Channel* chan = activechan = ServerInstance->Channels.Find(parameters[0]); if (!chan) { user->WriteNotice("The channel " + parameters[0] + " does not exist."); return CmdResult::FAILURE; } // See what method the oper wants to use, default to KILL std::string method("KILL"); if (parameters.size() > 1) { method = parameters[1]; std::transform(method.begin(), method.end(), method.begin(), ::toupper); } XLineFactory* xlf = nullptr; bool kick = (method == "KICK"); if ((!kick) && (method != "KILL")) { if ((method != "Z") && (method != "G")) { user->WriteNotice("Invalid method for clearing " + chan->name); return CmdResult::FAILURE; } xlf = ServerInstance->XLines->GetFactory(method); if (!xlf) return CmdResult::FAILURE; } const std::string reason = parameters.size() > 2 ? parameters.back() : "Clearing " + chan->name; if (!user->server->IsSilentService()) ServerInstance->SNO.WriteToSnoMask((IS_LOCAL(user) ? 'a' : 'A'), user->nick + " has cleared \002" + chan->name + "\002 (" + method + "): " + reason); user->WriteNotice("Clearing \002" + chan->name + "\002 (" + method + "): " + reason); { // Route this command manually so it is sent before the QUITs we are about to generate. // The idea is that by the time our QUITs reach the next hop, it has already removed all their // clients from the channel, meaning victims on other servers won't see the victims on this // server quitting. CommandBase::Params eparams; eparams.push_back(chan->name); eparams.push_back(method); eparams.push_back(":"); eparams.back().append(reason); ServerInstance->PI->BroadcastEncap(this->name, eparams, user, user); } // Attach to the appropriate hook so we're able to hide the QUIT/KICK messages Implementation hook = (kick ? I_OnUserKick : I_OnBuildNeighborList); ServerInstance->Modules.Attach(hook, creator); std::string mask; // Now remove all local non-opers from the channel Channel::MemberMap& users = chan->userlist; for (Channel::MemberMap::iterator i = users.begin(); i != users.end(); ) { User* curr = i->first; const Channel::MemberMap::iterator currit = i; ++i; if (!IS_LOCAL(curr) || curr->IsOper()) continue; // If kicking users, remove them and skip the QuitUser() if (kick) { chan->KickUser(ServerInstance->FakeClient, currit, reason); continue; } // If we are banning users then create the XLine and add it if (xlf) { XLine* xline; try { mask = (method[0] == 'Z') ? curr->GetAddress() : (curr->GetBanUser(true) + "@" + curr->GetRealHost()); xline = xlf->Generate(ServerInstance->Time(), 60*60, user->nick, reason, mask); } catch (const ModuleException&) { // Nothing, move on to the next user continue; } if (!ServerInstance->XLines->AddLine(xline, user)) delete xline; } ServerInstance->Users.QuitUser(curr, reason); } ServerInstance->Modules.Detach(hook, creator); if (xlf) ServerInstance->XLines->ApplyLines(); return CmdResult::SUCCESS; } }; class ModuleClearChan final : public Module { private: CommandClearChan cmd; public: ModuleClearChan() : Module(VF_VENDOR | VF_OPTCOMMON, "Adds the /CLEARCHAN command which allows server operators to mass-punish the members of a channel.") , cmd(this) { } void init() override { // Only attached while we are working; don't react to events otherwise Implementation events[] = { I_OnBuildNeighborList, I_OnUserKick }; ServerInstance->Modules.Detach(events, this, sizeof(events)/sizeof(Implementation)); } void OnBuildNeighborList(User* source, User::NeighborList& include, User::NeighborExceptions& exception) override { bool found = false; for (User::NeighborList::iterator i = include.begin(); i != include.end(); ++i) { if ((*i)->chan == cmd.activechan) { // Don't show the QUIT to anyone in the channel by default include.erase(i); found = true; break; } } for (const auto& [member, _] : cmd.activechan->GetUsers()) { LocalUser* curr = IS_LOCAL(member); if (!curr) continue; if (curr->IsOper()) { // If another module has removed the channel we're working on from the list of channels // to consider for sending the QUIT to then don't add exceptions for opers, because the // module before us doesn't want them to see it or added the exceptions already. // If there is a value for this oper in excepts already, this won't overwrite it. if (found) exception.emplace(curr, true); continue; } else if (!include.empty() && curr->chans.size() > 1) { // This is a victim and potentially has another common channel with the user quitting, // add a negative exception overwriting the previous value, if any. exception[curr] = false; } } } void OnUserKick(User* source, Membership* memb, const std::string& reason, CUList& excepts) override { // Hide the KICK from all non-opers User* leaving = memb->user; for (const auto& [curr, _] : memb->chan->GetUsers()) { if ((IS_LOCAL(curr)) && (!curr->IsOper()) && (curr != leaving)) excepts.insert(curr); } } }; MODULE_INIT(ModuleClearChan) ��������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/src/modules/m_cloak.cpp��������������������������������������������������������������0000664�0000000�0000000�00000030716�14771603147�0017726�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2023-2024 Sadie Powell <sadie@witchery.services> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include "inspircd.h" #include "clientprotocolevent.h" #include "modules/cloak.h" #include "modules/ircv3_replies.h" #include "utility/map.h" typedef std::vector<Cloak::MethodPtr> CloakMethodList; class CommandCloak final : public SplitCommand { private: // The cloak engines from the config. CloakMethodList& cloakmethods; // API for sending a FAIL message. IRCv3::Replies::Note failrpl; // API for sending a NOTE message. IRCv3::Replies::Note noterpl; // Reference to the standard-replies cap. IRCv3::Replies::CapReference stdrplcap; public: CommandCloak(Module* Creator, CloakMethodList& ce) : SplitCommand(Creator, "CLOAK", 1) , cloakmethods(ce) , failrpl(Creator) , noterpl(Creator) , stdrplcap(Creator) { access_needed = CmdAccess::OPERATOR; syntax = { "<host>" }; } CmdResult HandleLocal(LocalUser* user, const Params& parameters) override { size_t count = 0; for (const auto& cloakmethod : cloakmethods) { const std::string cloak = cloakmethod->Generate(parameters[0]); if (cloak.empty()) continue; noterpl.SendIfCap(user, stdrplcap, this, "CLOAK_RESULT", parameters[0], cloak, INSP_FORMAT("Cloak #{} for {} is {} (method: {})", ++count, parameters[0], cloak, cloakmethod->GetName())); } if (!count) { failrpl.SendIfCap(user, stdrplcap, this, "UNABLE_TO_CLOAK", parameters[0], INSP_FORMAT("There are no methods available for cloaking {}", parameters[0])); } return CmdResult::SUCCESS; } }; class CloakAPI final : public Cloak::APIBase { private: // The cloak providers from the config. CloakMethodList& cloakmethods; // The mode which marks a user as being cloaked. ModeHandler* cloakmode; // Holds the list of cloaks for a user. ListExtItem<Cloak::List> ext; std::string GetFrontCloak(LocalUser* user) { auto* cloaks = GetCloaks(user); return cloaks ? cloaks->front() : ""; } public: bool recloaking = false; CloakAPI(Module* Creator, CloakMethodList& cm, ModeHandler* mh) : Cloak::APIBase(Creator) , cloakmethods(cm) , cloakmode(mh) , ext(Creator, "cloaks", ExtensionType::USER) { } Cloak::List* GetCloaks(LocalUser* user) override { if (user->quitting || !(user->connected & User::CONN_NICKUSER)) return nullptr; // This user isn't at a point where they can change their cloak. if (!user->GetClass()->config->getBool("usecloak", true)) return nullptr; auto* cloaks = ext.Get(user); if (!cloaks) { // The list doesn't exist so try to create it. cloaks = new Cloak::List(); for (const auto& cloakmethod : cloakmethods) { const std::string cloak = cloakmethod->Generate(user); if (!cloak.empty()) { cloaks->push_back(cloak); ServerInstance->Logs.Debug(MODNAME, "Cloaked {} ({}) [{}] as {} using the {} method.", user->uuid, user->GetAddress(), user->GetRealHost(), cloak, cloakmethod->GetName()); } else { ServerInstance->Logs.Debug(MODNAME, "Unable to cloak {} ({}) [{}] using the {} method.", user->uuid, user->GetAddress(), user->GetRealHost(), cloakmethod->GetName()); } } ext.Set(user, cloaks); } return cloaks->empty() ? nullptr : cloaks; } bool IsActiveCloak(const Cloak::Engine& engine) override { for (const auto& cloakmethod : cloakmethods) { if (cloakmethod->IsProvidedBy(engine)) return true; } return false; } void ResetCloaks(LocalUser* user, bool resetdisplay) override { if (user->quitting || !(user->connected & User::CONN_NICKUSER)) return; // This user isn't at a point where they can change their cloak. const std::string oldcloak = GetFrontCloak(user); ext.Unset(user); if (!resetdisplay || !user->IsModeSet(cloakmode)) return; // Not resetting the display or not cloaked. const std::string newcloak = GetFrontCloak(user); if (oldcloak == newcloak) return; // New front cloak is the same. Modes::ChangeList changelist; changelist.push_remove(cloakmode); if (!newcloak.empty()) { recloaking = true; changelist.push_add(cloakmode); } ServerInstance->Modes.Process(ServerInstance->FakeClient, nullptr, user, changelist); recloaking = false; } }; class CloakMode final : public ModeHandler { private: // The public API for the cloak system. CloakAPI& cloakapi; // The number of times the last user has set/unset this mode at once. size_t prevcount = 0; // The time at which the last user set/unset this mode. time_t prevtime = 0; // The UUID of the last user to set/unset this mode. std::string prevuuid; bool CheckSpam(User* user) { if (cloakapi.recloaking) return false; // Recloaking is always allowed. if (user->uuid == prevuuid && prevtime == ServerInstance->Time()) { // The user has changed this mode already recently. Have they done // it too much? return ++prevcount > 2; } // This is the first time the user has executed the mode recently so its fine. prevcount = 0; prevtime = ServerInstance->Time(); prevuuid = user->uuid; return false; } public: // Whether the mode has recently been changed. bool active = false; CloakMode(Module* Creator, CloakAPI& api) : ModeHandler(Creator, "cloak", 'x', PARAM_NONE, MODETYPE_USER) , cloakapi(api) { } bool OnModeChange(User* source, User* dest, Channel* channel, Modes::Change& change) override { // For remote users blindly allow this LocalUser* user = IS_LOCAL(dest); if (!user) { // Remote setters broadcast mode before host while local setters do the opposite. active = IS_LOCAL(source) ? change.adding : !change.adding; dest->SetMode(this, change.adding); return true; } // Don't allow the mode change if its a no-op or a spam change. if (change.adding == user->IsModeSet(this) || CheckSpam(user)) return false; // Penalise changing the mode to avoid spam. if (source == dest && !cloakapi.recloaking) user->CommandFloodPenalty += 5'000; if (!change.adding) { // Remove the mode and restore their real host. user->SetMode(this, false); if (!cloakapi.recloaking) user->ChangeDisplayedHost(user->GetRealHost()); return true; } // If a user is not fully connected and their displayed hostname is // different to their real hostname they probably had a vhost set on // them by services. We should avoid automatically setting cloak on // them in this case. if (!user->IsFullyConnected() && user->GetRealHost() != user->GetDisplayedHost()) return false; auto* cloaks = cloakapi.GetCloaks(user); if (cloaks) { // We were able to generate cloaks for this user. user->ChangeDisplayedHost(cloaks->front()); user->SetMode(this, true); return true; } return false; } }; class ModuleCloak final : public Module { private: CloakAPI cloakapi; CloakMethodList cloakmethods; CommandCloak cloakcmd; CloakMode cloakmode; void DisableMode(User* user) { user->SetMode(cloakmode, false); auto* luser = IS_LOCAL(user); if (luser) { Modes::ChangeList changelist; changelist.push_remove(&cloakmode); ClientProtocol::Events::Mode modeevent(ServerInstance->FakeClient, nullptr, luser, changelist); luser->Send(modeevent); } } public: ModuleCloak() : Module(VF_VENDOR | VF_COMMON, "Adds user mode x (cloak) which allows user hostnames to be hidden.") , cloakapi(this, cloakmethods, &cloakmode) , cloakcmd(this, cloakmethods) , cloakmode(this, cloakapi) { } void ReadConfig(ConfigStatus& status) override { auto tags = ServerInstance->Config->ConfTags("cloak"); if (tags.empty()) throw ModuleException(this, "You have loaded the cloak module but not configured any <cloak> tags!"); bool primary = true; CloakMethodList newcloakmethods; for (const auto& [_, tag] : tags) { const std::string method = tag->getString("method", tag->getString("mode")); if (method.empty()) throw ModuleException(this, "<cloak:method> must be set to the name of a cloak engine, at " + tag->source.str()); auto* service = ServerInstance->Modules.FindDataService<Cloak::Engine>("cloak/" + method); if (!service) throw ModuleException(this, "<cloak> tag was set to non-existent cloak method \"" + method + "\", at " + tag->source.str()); newcloakmethods.push_back(service->Create(tag, primary)); primary = false; } // The cloak configuration was valid so we can apply it. cloakmethods.swap(newcloakmethods); } void CompareLinkData(const LinkData& otherdata, LinkDataDiff& diffs) override { std::string unused; LinkData data; this->GetLinkData(data, unused); // If the only difference is the method then just include that. insp::map::difference(data, otherdata, diffs); auto it = diffs.find("method"); if (it != diffs.end()) diffs = { *it }; } void GetLinkData(LinkData& data, std::string& compatdata) override { if (cloakmethods.empty()) return; Cloak::MethodPtr cloakmethod; for (const auto& method : cloakmethods) { if (method->IsLinkSensitive()) { // This cloak method really wants to be the link method so prefer it. cloakmethod = method; break; } } // If no methods are link sensitive we just use the first. if (!cloakmethod) cloakmethod = cloakmethods.front(); cloakmethod->GetLinkData(data, compatdata); data["method"] = cloakmethod->GetName(); if (compatdata.empty()) compatdata.assign(cloakmethod->GetName()); } void Prioritize() override { ServerInstance->Modules.SetPriority(this, I_OnCheckBan, PRIORITY_LAST); } void OnChangeHost(User* user, const std::string& host) override { if (user->IsModeSet(cloakmode) && !cloakmode.active) DisableMode(user); cloakmode.active = false; } void OnChangeRemoteAddress(LocalUser* user) override { // Remove the cloaks so we can generate new ones. cloakapi.ResetCloaks(user, false); // If a user is using a cloak then update it. auto* cloaks = cloakapi.GetCloaks(user); if (user->IsModeSet(cloakmode)) { if (cloaks) { // The user has a new cloak list; pick the first. user->ChangeDisplayedHost(cloaks->front()); } else { // The user has no cloak list; unset mode and revert to the real host. DisableMode(user); user->ChangeDisplayedHost(user->GetRealHost()); } } } ModResult OnCheckBan(User* user, Channel* chan, const std::string& mask) override { LocalUser* lu = IS_LOCAL(user); if (!lu) return MOD_RES_PASSTHRU; // We don't have cloaks for remote users. auto* cloaks = cloakapi.GetCloaks(lu); if (!cloaks) return MOD_RES_PASSTHRU; // No cloaks, nothing to check. // Check if they have a cloaked host but are not using it. for (const auto& cloak : *cloaks) { if (cloak == user->GetDisplayedHost()) continue; // This is checked by the core. std::string cloakmask = user->nick + "!" + user->GetRealUser() + "@" + cloak; if (InspIRCd::Match(cloakmask, mask)) return MOD_RES_DENY; cloakmask = user->nick + "!" + user->GetDisplayedUser() + "@" + cloak; if (InspIRCd::Match(cloakmask, mask)) return MOD_RES_DENY; } return MOD_RES_PASSTHRU; } void OnServiceDel(ServiceProvider& service) override { size_t methods = 0; for (auto it = cloakmethods.begin(); it != cloakmethods.end(); ) { auto cloakmethod = *it; if (cloakmethod->IsProvidedBy(service)) { it = cloakmethods.erase(it); methods++; continue; } it++; } if (methods) { ServerInstance->SNO.WriteGlobalSno('a', "The {} hash provider was unloaded; removing {} cloak methods until the next rehash.", service.name.substr(6), methods); } } void OnUserConnect(LocalUser* user) override { // Generate cloaks now if they do not already exist so opers can /CHECK // this user if need be. cloakapi.GetCloaks(user); } void OnPostChangeConnectClass(LocalUser* user, bool force) override { // Reset the cloaks so if the user is moving into a class with <connect usecloak="no"> they // will be decloaked. cloakapi.ResetCloaks(user, true); } }; MODULE_INIT(ModuleCloak) ��������������������������������������������������inspircd-4.7.0/src/modules/m_cloak_md5.cpp����������������������������������������������������������0000664�0000000�0000000�00000023022�14771603147�0020463�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2019 B00mX0r <b00mx0r@aureus.pw> * Copyright (C) 2017 Sheogorath <sheogorath@shivering-isles.com> * Copyright (C) 2016 Adam <Adam@anope.org> * Copyright (C) 2013, 2017-2019, 2021-2025 Sadie Powell <sadie@witchery.services> * Copyright (C) 2012 Robby <robby@chatbelgie.be> * Copyright (C) 2009-2010 Daniel De Graaf <danieldg@inspircd.org> * Copyright (C) 2008 Robin Burchell <robin+git@viroteck.net> * Copyright (C) 2007-2008 Craig Edwards <brain@inspircd.org> * Copyright (C) 2007 John Brooks <john@jbrooks.io> * Copyright (C) 2006 Oliver Lupton <om@inspircd.org> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include "inspircd.h" #include "modules/cloak.h" #include "modules/hash.h" enum CloakMode { /** 2.0 cloak of "half" of the hostname plus the full IP hash */ MODE_HALF_CLOAK, /** 2.0 cloak of IP hash, split at 2 common CIDR range points */ MODE_OPAQUE }; // lowercase-only encoding similar to base64, used for hash output static constexpr char base32[] = "0123456789abcdefghijklmnopqrstuv"; // The minimum length of a cloak key. static constexpr size_t minkeylen = 30; struct CloakInfo final : public Cloak::Method { // The method used for cloaking users. CloakMode mode; // The number of parts of the hostname shown when using half cloaking. unsigned int domainparts; // Whether to ignore the case of a hostname when cloaking it. bool ignorecase; // The secret used for generating cloaks. std::string key; // Dynamic reference to the md5 implementation. dynamic_reference_nocheck<HashProvider> md5; // The prefix for cloaks (e.g. MyNet-). std::string prefix; // The suffix for IP cloaks (e.g. .IP). std::string suffix; CloakInfo(const Cloak::Engine* engine, const std::shared_ptr<ConfigTag>& tag, CloakMode Mode, const std::string& Key) : Cloak::Method(engine, tag) , mode(Mode) , domainparts(tag->getNum<unsigned int>("domainparts", 3, 1, 10)) , ignorecase(tag->getBool("ignorecase")) , key(Key) , md5(engine->creator, "hash/md5") , prefix(tag->getString("prefix")) , suffix(tag->getString("suffix", ".IP")) { } /* * 2.0-style cloaking function * @param item The item to cloak (part of an IP or hostname) * @param id A unique ID for this type of item (to make it unique if the item matches) * @param len The length of the output. Maximum for MD5 is 16 characters. */ std::string SegmentCloak(const std::string& item, char id, size_t len) { std::string input; input.reserve(key.length() + 3 + item.length()); input.append(1, id); input.append(key); input.append(1, '\0'); // null does not terminate a C++ string if (ignorecase) std::transform(item.begin(), item.end(), std::back_inserter(input), ::tolower); else input.append(item); std::string rv = md5->GenerateRaw(input).substr(0, len); for(size_t i = 0; i < len; i++) { // this discards 3 bits per byte. We have an // overabundance of bits in the hash output, doesn't // matter which ones we are discarding. rv[i] = base32[rv[i] & 0x1F]; } return rv; } std::string SegmentIP(const irc::sockets::sockaddrs& ip, bool full) { std::string bindata; size_t hop1; size_t hop2; size_t hop3; size_t len1; size_t len2; std::string rv; if (ip.family() == AF_INET6) { bindata = std::string((const char*)ip.in6.sin6_addr.s6_addr, 16); hop1 = 8; hop2 = 6; hop3 = 4; len1 = 6; len2 = 4; // pfx s1.s2.s3. (xxxx.xxxx or s4) sfx // 6 4 4 9/6 rv.reserve(prefix.length() + 26 + suffix.length()); } else { bindata = std::string((const char*)&ip.in4.sin_addr, 4); hop1 = 3; hop2 = 0; hop3 = 2; len1 = len2 = 3; // pfx s1.s2. (xxx.xxx or s3) sfx rv.reserve(prefix.length() + 15 + suffix.length()); } rv.append(prefix); rv.append(SegmentCloak(bindata, 10, len1)); rv.append(1, '.'); bindata.erase(hop1); rv.append(SegmentCloak(bindata, 11, len2)); if (hop2) { rv.append(1, '.'); bindata.erase(hop2); rv.append(SegmentCloak(bindata, 12, len2)); } if (full) { rv.append(1, '.'); bindata.erase(hop3); rv.append(SegmentCloak(bindata, 13, 6)); rv.append(suffix); } else { if (ip.family() == AF_INET6) { rv.append(INSP_FORMAT(".{:02x}{:02x}.{:02x}{:02x}{}", ip.in6.sin6_addr.s6_addr[2], ip.in6.sin6_addr.s6_addr[3], ip.in6.sin6_addr.s6_addr[0], ip.in6.sin6_addr.s6_addr[1], suffix)); } else { const unsigned char* ip4 = (const unsigned char*)&ip.in4.sin_addr; rv.append(INSP_FORMAT(".{}.{}{}", ip4[1], ip4[0], suffix)); } } return rv; } std::string GetCompatLinkData() { std::string data = "broken"; if (md5) { switch (mode) { case MODE_HALF_CLOAK: // Use old cloaking verification to stay compatible with 2.0 // But verify domainparts and ignorecase when use 3.0-only features if (domainparts == 3 && !ignorecase) data = prefix + SegmentCloak("*", 3, 8) + suffix; else { irc::sockets::sockaddrs sa; data = GenCloak(sa, "", data + ConvToStr(domainparts)) + (ignorecase ? "-ci" : ""); } break; case MODE_OPAQUE: data = prefix + SegmentCloak("*", 4, 8) + suffix + (ignorecase ? "-ci" : ""); } } return data; } void GetLinkData(Module::LinkData& data, std::string& compatdata) override { data["domain-parts"] = ConvToStr(domainparts); data["ignore-case"] = ignorecase ? "yes" : "no"; data["prefix"] = prefix; data["suffix"] = suffix; // IMPORTANT: link data is sent over unauthenticated server links so we // can't directly send the key here. Instead we use dummy cloaks that // allow verification of or less the same thing. const std::string broken = "missing-md5-module"; data["cloak-v4"] = md5 ? Generate("123.123.123.123") : broken; data["cloak-v6"] = md5 ? Generate("dead:beef:cafe::") : broken; data["cloak-host"] = md5 ? Generate("extremely.long.inspircd.cloak.example") : broken; compatdata = GetCompatLinkData(); } bool IsLinkSensitive() const override { // This method always wants to be at the front. return true; } std::string GenCloak(const irc::sockets::sockaddrs& ip, const std::string& ipstr, const std::string& host) { std::string chost; irc::sockets::sockaddrs hostip(false); bool host_is_ip = hostip.from_ip_port(host, ip.port()) && hostip == ip; switch (mode) { case MODE_HALF_CLOAK: { if (!host_is_ip) chost = prefix + SegmentCloak(host, 1, 6) + "." + Cloak::VisiblePart(host, domainparts, '.'); if (chost.empty() || chost.length() > 50) chost = SegmentIP(ip, false); break; } case MODE_OPAQUE: chost = SegmentIP(ip, true); break; } return chost; } std::string Generate(LocalUser* user) override ATTR_NOT_NULL(2) { if (!md5 || !user->client_sa.is_ip() || !MatchesUser(user)) return {}; return GenCloak(user->client_sa, user->GetAddress(), user->GetRealHost()); } std::string Generate(const std::string& hostip) override { if (!md5) return {}; irc::sockets::sockaddrs sa; const char* ipaddr = sa.from_ip(hostip) ? hostip.c_str() : ""; return GenCloak(sa, ipaddr, hostip); } }; class MD5Engine final : public Cloak::Engine { private: // Dynamic reference to the md5 implementation. dynamic_reference_nocheck<HashProvider> md5; // The method used for cloaking users. CloakMode mode; public: MD5Engine(Module* Creator, const std::string& Name, CloakMode cm) : Cloak::Engine(Creator, Name) , md5(Creator, "hash/md5") , mode(cm) { } Cloak::MethodPtr Create(const std::shared_ptr<ConfigTag>& tag, bool primary) override { // Check any dependent modules are loaded. if (!md5) throw ModuleException(creator, "Unable to create a " + name.substr(6) + " cloak without the md5 module, at" + tag->source.str()); // Ensure that we have the <cloak:key> parameter. const std::string key = tag->getString("key"); if (key.empty()) throw ModuleException(creator, "You have not defined a cloaking key. Define <cloak:key> as a {}+ character network-wide secret, at {}", minkeylen, tag->source.str()); // If we are the first cloak method then mandate a strong key. if (primary) { if (key.length() < minkeylen) throw ModuleException(creator, "Your cloaking key is not secure. It should be at least {} characters long, at {}", minkeylen, tag->source.str()); ServerInstance->Logs.Normal(MODNAME, "The {} cloak method is deprecated and will be removed in the next major version of InspIRCd. Consider migrating to cloak_sha256 instead. See " INSPIRCD_DOCS "modules/cloak_md5 for more information.", name.c_str() + 6); } return std::make_shared<CloakInfo>(this, tag, mode, key); } }; class ModuleCloakMD5 final : public Module { private: MD5Engine halfcloak; MD5Engine fullcloak; public: ModuleCloakMD5() : Module(VF_VENDOR, "Adds the half and full cloaking methods for use with the cloak module.") , halfcloak(this, "half", MODE_HALF_CLOAK) , fullcloak(this, "full", MODE_OPAQUE) { } }; MODULE_INIT(ModuleCloakMD5) ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/src/modules/m_cloak_sha256.cpp�������������������������������������������������������0000664�0000000�0000000�00000025717�14771603147�0021023�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2023-2025 Sadie Powell <sadie@witchery.services> * Copyright (C) 2017 Adam <Adam@anope.org> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ /// $CompilerFlags: require_library("libpsl") find_compiler_flags("libpsl") -DHAS_LIBPSL /// $LinkerFlags: require_library("libpsl") find_linker_flags("libpsl") /// $PackageInfo: require_system("alpine") libpsl-dev pkgconf /// $PackageInfo: require_system("arch") libpsl pkgconf /// $PackageInfo: require_system("darwin") libpsl pkg-config /// $PackageInfo: require_system("debian~") libpsl-dev pkg-config /// $PackageInfo: require_system("rhel~") libpsl-devel pkg-config #ifdef _WIN32 # if __has_include(<libpsl.h>) # define HAS_LIBPSL # pragma comment(lib, "psl.lib") # endif #endif #ifdef HAS_LIBPSL # include <libpsl.h> #else typedef void psl_ctx_t; #endif #include "inspircd.h" #include "modules/cloak.h" #include "modules/hash.h" #include "utility/string.h" class SHA256Method final : public Cloak::Method { private: // The base32 table used for upper-case cloaks. static constexpr unsigned char base32upper[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZ234567"; // The base32 table used for lower-case cloaks. static constexpr unsigned char base32lower[] = "abcdefghijklmnopqrstuvwxyz234567"; // The number of bytes of the hash to use when downsampling. static constexpr size_t segmentlen = 8; // Whether to cloak the hostname if available. const bool cloakhost; // The number of parts of the hostname shown. const unsigned long hostparts; // The secret used for generating cloaks. const std::string key; // The number of parts of the UNIX socket path shown. const unsigned long pathparts; // The prefix for cloaks (e.g. MyNet). const std::string prefix; #ifdef HAS_LIBPSL // Handle to the Public Suffix List library. psl_ctx_t* psl; #endif // Dynamic reference to the sha256 implementation. dynamic_reference_nocheck<HashProvider> sha256; // The base32 table used when encoding. const unsigned char* table; // The suffix for IP cloaks (e.g. IP). const std::string suffix; std::string CloakAddress(const irc::sockets::sockaddrs& sa) { switch (sa.family()) { case AF_INET: return CloakIPv4(sa.in4.sin_addr.s_addr); case AF_INET6: return CloakIPv6(sa.in6.sin6_addr.s6_addr); case AF_UNIX: return CloakHost(sa.un.sun_path, '/', pathparts); } // Should never be reached. return {}; } std::string CloakIPv4(unsigned long address) { // IPv4 addresses are cloaked in the form ALPHA.BETA.GAMMA // // ALPHA is unique for a.b.c.d // BETA is unique for a.b.c // GAMMA is unique for a.b unsigned int a = (unsigned int)(address) & 0xFF; unsigned int b = (unsigned int)(address >> 8) & 0xFF; unsigned int c = (unsigned int)(address >> 16) & 0xFF; unsigned int d = (unsigned int)(address >> 24) & 0xFF; const std::string alpha = Hash(INSP_FORMAT("{}.{}.{}.{}", a, b, c, d)); const std::string beta = Hash(INSP_FORMAT("{}.{}.{}", a, b, c)); const std::string gamma = Hash(INSP_FORMAT("{}.{}", a, b)); return Wrap(INSP_FORMAT("{}.{}.{}", alpha, beta, gamma), suffix, '.'); } std::string CloakIPv6(const unsigned char* address) { // IPv6 addresses are cloaked in the form ALPHA.BETA.GAMMA.IP // // ALPHA is unique for a:b:c:d:e:f:g:h // BETA is unique for a:b:c:d:e:f:g // GAMMA is unique for a:b:c:d const uint16_t* address16 = reinterpret_cast<const uint16_t*>(address); unsigned int a = ntohs(address16[0]); unsigned int b = ntohs(address16[1]); unsigned int c = ntohs(address16[2]); unsigned int d = ntohs(address16[3]); unsigned int e = ntohs(address16[4]); unsigned int f = ntohs(address16[5]); unsigned int g = ntohs(address16[6]); unsigned int h = ntohs(address16[7]); const std::string alpha = Hash(INSP_FORMAT("{:x}:{:x}:{:x}:{:x}:{:x}:{:x}:{:x}:{:x}", a, b, c, d, e, f, g, h)); const std::string beta = Hash(INSP_FORMAT("{:x}:{:x}:{:x}:{:x}:{:x}:{:x}:{:x}", a, b, c, d, e, f, g)); const std::string gamma = Hash(INSP_FORMAT("{:x}:{:x}:{:x}:{:x}", a, b, c, d)); return Wrap(INSP_FORMAT("{}:{}:{}", alpha, beta, gamma), suffix, ':'); } std::string CloakHost(const std::string& host, char separator, unsigned long parts) { // Attempt to divine the public part of the hostname. std::string visiblepart; #ifdef HAS_LIBPSL if (psl && separator == '.') { // Attempt to look up the suffix with libpsl. const char* publicsuffix = psl_registrable_domain(psl, host.c_str()); if (!publicsuffix || publicsuffix == host) publicsuffix = psl_unregistrable_domain(psl, host.c_str()); if (publicsuffix && publicsuffix != host) visiblepart = publicsuffix; } #endif // If libpsl failed to find a suffix or wasn't available fall back. if (visiblepart.empty() && parts) visiblepart = Cloak::VisiblePart(host, parts, separator); // Convert the host to lowercase to avoid ban evasion. std::string lowerhost(host.length(), '\0'); std::transform(host.begin(), host.end(), lowerhost.begin(), ::tolower); return Wrap(Hash(lowerhost), visiblepart, separator); } std::string Hash(const std::string& str) { std::string out; for (const auto chr : sha256->hmac(key, str).substr(0, segmentlen)) out.push_back(table[chr & 0x1F]); return out; } std::string Wrap(const std::string& cloak, const std::string& cloaksuffix, char separator) { std::string fullcloak; if (!prefix.empty()) fullcloak.append(prefix).append(1, separator); fullcloak.append(cloak); if (!cloaksuffix.empty()) fullcloak.append(1, separator).append(cloaksuffix); return fullcloak; } public: SHA256Method(const Cloak::Engine* engine, const std::shared_ptr<ConfigTag>& tag, const std::string& k, psl_ctx_t* p, bool ch) ATTR_NOT_NULL(2) : Cloak::Method(engine, tag) , cloakhost(ch) , hostparts(cloakhost ? tag->getNum<unsigned long>("hostparts", 3, 0, ServerInstance->Config->Limits.MaxHost / 2) : 0) , key(k) , pathparts(tag->getNum<unsigned long>("pathparts", 1, 0, ServerInstance->Config->Limits.MaxHost / 2)) , prefix(tag->getString("prefix")) #ifdef HAS_LIBPSL , psl(p) #endif , sha256(engine->creator, "hash/sha256") , suffix(tag->getString("suffix", "ip")) { table = tag->getEnum("case", base32lower, { { "upper", base32upper }, { "lower", base32lower } }); } #ifdef HAS_PSL ~SHA256Method() override { if (psl) psl_free(psl); } #endif std::string Generate(LocalUser* user) override ATTR_NOT_NULL(2) { if (!sha256 || !MatchesUser(user)) return {}; irc::sockets::sockaddrs sa(false); if (!cloakhost || (sa.from(user->GetRealHost()) && sa.addr() == user->client_sa.addr())) return CloakAddress(user->client_sa); return CloakHost(user->GetRealHost(), '.', hostparts); } std::string Generate(const std::string& hostip) override { if (!sha256) return {}; irc::sockets::sockaddrs sa(false); if (sa.from(hostip)) return CloakAddress(sa); if (cloakhost) return CloakHost(hostip, '.', hostparts); return {}; // Only reachable on hmac-sha256-ip. } void GetLinkData(Module::LinkData& data, std::string& compatdata) override { // The value we use for cloaks when the sha2 module is missing. const std::string broken = "missing-sha2-module"; // IMPORTANT: link data is sent over unauthenticated server links so we // can't directly send the key here. Instead we use dummy cloaks that // allow verification of or less the same thing. data["cloak-v4"] = sha256 ? Generate("123.123.123.123") : broken; data["cloak-v6"] = sha256 ? Generate("dead:beef:cafe::") : broken; data["cloak-unix"] = sha256 ? Generate("/extremely/long/inspircd/cloak.example") : broken; data["path-parts"] = ConvToStr(pathparts); data["prefix"] = prefix; data["suffix"] = suffix; if (!cloakhost) return; data["cloak-host"] = sha256 ? Generate("extremely.long.inspircd.cloak.example") : broken; data["host-parts"] = ConvToStr(hostparts); #ifdef HAS_PSL data["using-psl"] = psl ? "yes" : "no"; #else data["using-psl"] = "no"; #endif } bool IsLinkSensitive() const override { // This method always wants to be at the front. return true; } }; class SHA256Engine final : public Cloak::Engine { private: // The minimum length of a cloak key. static constexpr size_t minkeylen = 30; // Whether to cloak the hostname if available. const bool cloakhost; // Dynamic reference to the sha256 implementation. dynamic_reference_nocheck<HashProvider> sha256; public: SHA256Engine(Module* Creator, const std::string& Name, bool ch) : Cloak::Engine(Creator, Name) , cloakhost(ch) , sha256(Creator, "hash/sha256") { } Cloak::MethodPtr Create(const std::shared_ptr<ConfigTag>& tag, bool primary) override { if (!sha256) throw ModuleException(creator, "Unable to create a " + name.substr(6) + " cloak without the sha2 module, at" + tag->source.str()); // Ensure that we have the <cloak:key> parameter. const std::string key = tag->getString("key"); if (key.length() < minkeylen) throw ModuleException(creator, "Your cloak key should be at least {} characters long, at {}", minkeylen, tag->source.str()); psl_ctx_t* psl = nullptr; std::string psldb = tag->getString("psl"); if (cloakhost && !psldb.empty()) { #ifdef HAS_LIBPSL if (insp::equalsci(psldb, "system")) { psldb = psl_dist_filename(); if (psldb.empty()) throw ModuleException(creator, "You specified \"system\" in <cloak:psl> but libpsl was built without a system copy, at " + tag->source.str()); } psl = psl_load_file(psldb.c_str()); if (!psl) throw ModuleException(creator, "The database specified in <cloak:psl> (" + psldb + ") does not exist, at " + tag->source.str()); #else throw ModuleException(creator, "You specified <cloak:psl> but InspIRCd was built without libpsl, at " + tag->source.str()); #endif } return std::make_shared<SHA256Method>(this, tag, key, psl, cloakhost); } }; class ModuleCloakSHA256 final : public Module { private: SHA256Engine addrcloak; SHA256Engine hostcloak; public: ModuleCloakSHA256() : Module(VF_VENDOR, "Adds the hmac-sha256 and hmac-sha256-addr cloaking methods for use with the cloak module.") , addrcloak(this, "hmac-sha256-addr", false) , hostcloak(this, "hmac-sha256", true) { } #ifdef HAS_LIBPSL void init() override { ServerInstance->Logs.Normal(MODNAME, "Module was compiled against libpsl version {} and is running against version {}", PSL_VERSION, psl_get_version()); } #endif }; MODULE_INIT(ModuleCloakSHA256) �������������������������������������������������inspircd-4.7.0/src/modules/m_cloak_static.cpp�������������������������������������������������������0000664�0000000�0000000�00000004364�14771603147�0021275�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2023, 2025 Sadie Powell <sadie@witchery.services> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include "inspircd.h" #include "modules/cloak.h" class StaticMethod final : public Cloak::Method { private: // The cloak to set on users. std::string cloak; public: StaticMethod(const Cloak::Engine* engine, const std::shared_ptr<ConfigTag>& tag, const std::string& c) ATTR_NOT_NULL(2) : Cloak::Method(engine, tag) , cloak(c) { } std::string Generate(LocalUser* user) override ATTR_NOT_NULL(2) { if (!MatchesUser(user)) return {}; // We shouldn't cloak this user. return cloak; } std::string Generate(const std::string& hostip) override { return cloak; } void GetLinkData(Module::LinkData& data, std::string& compatdata) override { data["cloak"] = cloak; } }; class StaticEngine final : public Cloak::Engine { public: StaticEngine(Module* Creator) : Cloak::Engine(Creator, "static") { } Cloak::MethodPtr Create(const std::shared_ptr<ConfigTag>& tag, bool primary) override { const std::string cloak = tag->getString("cloak"); if (cloak.empty() || cloak.length() > ServerInstance->Config->Limits.MaxHost) { throw ModuleException(creator, "Your static cloak must be between 1 and {} characters long, at {}", ServerInstance->Config->Limits.MaxHost, tag->source.str()); } return std::make_shared<StaticMethod>(this, tag, cloak); } }; class ModuleCloakStatic final : public Module { private: StaticEngine nickcloak; public: ModuleCloakStatic() : Module(VF_VENDOR, "Adds the static cloaking method for use with the cloak module.") , nickcloak(this) { } }; MODULE_INIT(ModuleCloakStatic) ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/src/modules/m_cloak_user.cpp���������������������������������������������������������0000664�0000000�0000000�00000023326�14771603147�0020763�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2023-2025 Sadie Powell <sadie@witchery.services> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include "inspircd.h" #include "modules/account.h" #include "modules/cloak.h" #include "modules/ssl.h" class UserMethodBase : public Cloak::Method { protected: // The action to take when an invalid character is encountered. enum class InvalidChar : uint8_t { // Reject the value as a valid cloak, REJECT, // Strip the invalid character from the value. STRIP, // Truncate the value at the missing character. TRUNCATE, }; // The action to perform to the cloak value. enum class TransformCase : uint8_t { // Preserve the case of the cloak. PRESERVE, // Convert the cloak to upper case. UPPER, // Convert the cloak to lower case. LOWER, }; // The characters which are valid in a hostname. const CharState& hostmap; // The action to take when an invalid character is encountered. InvalidChar invalidchar; // The prefix for cloaks (e.g. users.). const std::string prefix; // The suffix for IP cloaks (e.g. .example.org). const std::string suffix; // The case to transform cloaks to. TransformCase transformcase; // Retrieves the middle segment of the cloak. virtual std::string GetMiddle(LocalUser* user) = 0; UserMethodBase(const Cloak::Engine* engine, const std::shared_ptr<ConfigTag>& tag, const CharState& hm) ATTR_NOT_NULL(2) : Cloak::Method(engine, tag) , hostmap(hm) , prefix(tag->getString("prefix")) , suffix(tag->getString("suffix")) { invalidchar = tag->getEnum("invalidchar", InvalidChar::STRIP, { { "reject", InvalidChar::REJECT }, { "strip", InvalidChar::STRIP }, { "truncate", InvalidChar::TRUNCATE }, }); transformcase = tag->getEnum("case", TransformCase::PRESERVE, { { "lower", TransformCase::LOWER }, { "preserve", TransformCase::PRESERVE }, { "upper", TransformCase::UPPER }, }); } public: std::string Generate(LocalUser* user) override ATTR_NOT_NULL(2) { if (!MatchesUser(user)) return {}; // We shouldn't cloak this user. const std::string middle = GetMiddle(user); if (middle.empty()) return {}; // No middle cloak. std::string safemiddle; safemiddle.reserve(middle.length()); for (auto chr : middle) { switch (transformcase) { case TransformCase::LOWER: chr = tolower(chr); break; case TransformCase::PRESERVE: break; // We don't need to do anything here. case TransformCase::UPPER: chr = toupper(chr); break; } if (hostmap.test(static_cast<unsigned char>(chr))) { safemiddle.push_back(chr); continue; // Character is valid. } // Character is invalid. What should we do? bool done = false; switch (invalidchar) { case InvalidChar::REJECT: safemiddle.clear(); done = true; break; case InvalidChar::STRIP: continue; case InvalidChar::TRUNCATE: done = true; break; } if (done) break; } ServerInstance->Logs.Debug(MODNAME, "Cleaned {} for cloak: {} => {}", GetName(), middle, safemiddle); if (safemiddle.empty()) return {}; // No cloak. return prefix + safemiddle + suffix; } std::string Generate(const std::string& hostip) override { // We can't generate user cloaks without a user. return {}; } void GetLinkData(Module::LinkData& data, std::string& compatdata) override { switch (invalidchar) { case InvalidChar::REJECT: data["invalidchar"] = "reject"; break; case InvalidChar::STRIP: data["invalidchar"] = "strip"; break; case InvalidChar::TRUNCATE: data["invalidchar"] = "truncate"; break; } data["prefix"] = prefix; data["suffix"] = suffix; } }; class AccountMethod final : public UserMethodBase { private: // Dynamic reference to the account api. Account::API accountapi; // Retrieves the middle segment of the cloak. std::string GetMiddle(LocalUser* user) override { const std::string* accountname = accountapi ? accountapi->GetAccountName(user) : nullptr; return accountname ? *accountname : ""; } public: AccountMethod(const Cloak::Engine* engine, const std::shared_ptr<ConfigTag>& tag, const CharState& hm) ATTR_NOT_NULL(2) : UserMethodBase(engine, tag, hm) , accountapi(engine->creator) { } }; class AccountIdMethod final : public UserMethodBase { private: // Dynamic reference to the account api. Account::API accountapi; // Retrieves the middle segment of the cloak. std::string GetMiddle(LocalUser* user) override { const std::string* accountid = accountapi ? accountapi->GetAccountId(user) : nullptr; return accountid ? *accountid : ""; } public: AccountIdMethod(const Cloak::Engine* engine, const std::shared_ptr<ConfigTag>& tag, const CharState& hm) ATTR_NOT_NULL(2) : UserMethodBase(engine, tag, hm) , accountapi(engine->creator) { } }; class FingerprintMethod final : public UserMethodBase { private: // Dynamic reference to the certificate api. UserCertificateAPI sslapi; // The number of octets of the fingerprint to use. size_t length; // Retrieves the middle segment of the cloak. std::string GetMiddle(LocalUser* user) override { const ssl_cert* cert = sslapi ? sslapi->GetCertificate(user) : nullptr; if (!cert || !cert->IsUsable()) return {}; return cert->GetFingerprint().substr(0, length); } // Calculates the longest valid fingerprint length. inline size_t GetMaxLength() { return ServerInstance->Config->Limits.MaxHost - prefix.length() - suffix.length(); } public: FingerprintMethod(const Cloak::Engine* engine, const std::shared_ptr<ConfigTag>& tag, const CharState& hm) ATTR_NOT_NULL(2) : UserMethodBase(engine, tag, hm) , sslapi(engine->creator) , length(tag->getNum<size_t>("length", GetMaxLength(), 1, GetMaxLength())) { } void GetLinkData(Module::LinkData& data, std::string& compatdata) override { UserMethodBase::GetLinkData(data, compatdata); data["length"] = ConvToStr(length); } }; class NickMethod final : public UserMethodBase { private: // Retrieves the middle segment of the cloak. std::string GetMiddle(LocalUser* user) override { return user->nick; } public: NickMethod(const Cloak::Engine* engine, const std::shared_ptr<ConfigTag>& tag, const CharState& hm) ATTR_NOT_NULL(2) : UserMethodBase(engine, tag, hm) { } }; class UserMethod final : public UserMethodBase { private: // Retrieves the middle segment of the cloak. std::string GetMiddle(LocalUser* user) override { return user->GetRealUser(); } public: UserMethod(const Cloak::Engine* engine, const std::shared_ptr<ConfigTag>& tag, const CharState& hm) ATTR_NOT_NULL(2) : UserMethodBase(engine, tag, hm) { } }; template <typename Method> class UserEngine final : public Cloak::Engine { private: // The characters which are valid in a hostname. const CharState& hostmap; public: UserEngine(Module* Creator, const std::string& Name, const CharState& hm) : Cloak::Engine(Creator, Name) , hostmap(hm) { } Cloak::MethodPtr Create(const std::shared_ptr<ConfigTag>& tag, bool primary) override { return std::make_shared<Method>(this, tag, hostmap); } }; class ModuleCloakUser final : public Module , public Account::EventListener { private: UserEngine<AccountMethod> accountcloak; UserEngine<AccountIdMethod> accountidcloak; UserEngine<FingerprintMethod> fingerprintcloak; UserEngine<NickMethod> nicknamecloak; UserEngine<UserMethod> usernamecloak; Cloak::API cloakapi; CharState hostmap; public: ModuleCloakUser() : Module(VF_VENDOR, "Adds the account, account-id, fingerprint, nickname, and username cloaking methods for use with the cloak module.") , Account::EventListener(this) , accountcloak(this, "account", hostmap) , accountidcloak(this, "account-id", hostmap) , fingerprintcloak(this, "fingerprint", hostmap) , nicknamecloak(this, "nickname", hostmap) , usernamecloak(this, "username", hostmap) , cloakapi(this) { } void ReadConfig(ConfigStatus& status) override { CharState newhostmap; const auto& tag = ServerInstance->Config->ConfValue("hostname"); for (const auto chr : tag->getString("charmap", "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz.-_/0123456789", 1)) { // A hostname can not contain NUL, LF, CR, or SPACE. if (chr == 0x00 || chr == 0x0A || chr == 0x0D || chr == 0x20) throw ModuleException(this, "<hostname:charmap> can not contain character 0x{:02X} ({})", chr, chr); newhostmap.set(static_cast<unsigned char>(chr)); } std::swap(newhostmap, hostmap); } void OnAccountChange(User* user, const std::string& newaccount) override { LocalUser* luser = IS_LOCAL(user); if (!luser || !cloakapi) return; if (cloakapi->IsActiveCloak(accountcloak) || cloakapi->IsActiveCloak(accountidcloak)) cloakapi->ResetCloaks(luser, true); } void OnChangeRealUser(User* user, const std::string& newuser) override { LocalUser* luser = IS_LOCAL(user); if (luser && cloakapi && cloakapi->IsActiveCloak(usernamecloak)) cloakapi->ResetCloaks(luser, true); } void OnUserPostNick(User* user, const std::string& oldnick) override { LocalUser* luser = IS_LOCAL(user); if (luser && cloakapi && cloakapi->IsActiveCloak(nicknamecloak)) cloakapi->ResetCloaks(luser, true); } }; MODULE_INIT(ModuleCloakUser) ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/src/modules/m_codepage.cpp�����������������������������������������������������������0000664�0000000�0000000�00000032202�14771603147�0020374�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2020-2023, 2025 Sadie Powell <sadie@witchery.services> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include "inspircd.h" #include "modules/isupport.h" class Codepage { public: enum class AllowCharacterResult : uint8_t { // The character is allowed in a nick. OKAY, // The character is never valid in a nick. NOT_VALID, // The character is not valid at the front of a nick. NOT_VALID_AT_FRONT, }; // The mapping of lower case characters to upper case characters. unsigned char casemap[UCHAR_MAX + 1]; // Initialises the Codepage class. Codepage() { for (size_t i = 0; i <= UCHAR_MAX; ++i) casemap[i] = i; } // Destroys the Codepage class. virtual ~Codepage() = default; // Specifies that a character is allowed. virtual AllowCharacterResult AllowCharacter(uint32_t character, bool front) { if (front) { // Nicknames can not begin with a number as that would collide with // a user identifier. if (character >= '0' && character <= '9') return AllowCharacterResult::NOT_VALID_AT_FRONT; // Nicknames can not begin with a : or a $ as they have a special // meaning within the IRC message format. if (character == '$' || character == ':') return AllowCharacterResult::NOT_VALID_AT_FRONT; // Nicknames can not begin with a channel prefix character (e.g. #) // as they are used to differentiate users from channels in message // targets. if (ServerInstance->Channels.IsPrefix(character)) return AllowCharacterResult::NOT_VALID_AT_FRONT; // Nicknames can not begin with a prefix mode character (e.g. @) // as they are used as a nick prefix when sending a STATUSMSG. if (ServerInstance->Modes.FindPrefix(character)) return AllowCharacterResult::NOT_VALID_AT_FRONT; } // Nicknames can never contain NUL, CR, LF, SPACE, COMMA, PERIOD, // ASTERISK, QUESTION MARK, EXCLAMATION MARK, or AT SIGN as they are // either banned within an IRC message or have special meaning within // the IRC message format. switch (character) { case '\0': case '\n': case '\r': case ' ': case '!': case '*': case ',': case '.': case '?': case '@': return AllowCharacterResult::NOT_VALID; } // The character is probably okay? return AllowCharacterResult::OKAY; } // Determines whether a nickname is valid. virtual bool IsValidNick(const std::string_view& nick) = 0; // Retrieves the link data for this codepage. virtual void GetLinkData(Module::LinkData& data, std::string& compatdata) const = 0; // Maps an upper case character to a lower case character. virtual bool Map(uint32_t upper, uint32_t lower) = 0; }; class SingleByteCodepage final : public Codepage { private: // The characters which are allowed in nicknames. CharState allowedchars; // The characters which are allowed at the front of a nickname. CharState allowedfrontchars; public: AllowCharacterResult AllowCharacter(uint32_t character, bool front) override { // Single byte codepage can, as their name suggests, only be one byte in size. if (character > UCHAR_MAX) return AllowCharacterResult::NOT_VALID; // Check the common allowed character rules. AllowCharacterResult result = Codepage::AllowCharacter(character, front); if (result != AllowCharacterResult::OKAY) return result; // The character is okay. allowedchars.set(character); allowedfrontchars.set(character, front); return AllowCharacterResult::OKAY; } bool IsValidNick(const std::string_view& nick) override { if (nick.empty() || nick.length() > ServerInstance->Config->Limits.MaxNick) return false; for (std::string_view::const_iterator iter = nick.begin(); iter != nick.end(); ++iter) { unsigned char chr = static_cast<unsigned char>(*iter); // Check that the character is allowed at the front of the nick. if (iter == nick.begin() && !allowedfrontchars[chr]) return false; // Check that the character is allowed in the nick. if (!allowedchars[chr]) return false; } return true; } void GetLinkData(Module::LinkData& data, std::string& compatdata) const override { for (size_t i = 0; i < allowedfrontchars.size(); ++i) if (allowedfrontchars[i]) data["front"].push_back(static_cast<unsigned char>(i)); for (size_t i = 0; i < allowedchars.size(); ++i) if (allowedchars[i]) data["middle"].push_back(static_cast<unsigned char>(i)); for (size_t i = 0; i < sizeof(casemap); ++i) { if (casemap[i] == i) continue; data["map"].push_back(static_cast<unsigned char>(i)); data["map"].push_back(casemap[i]); data["map"].push_back(','); } compatdata = INSP_FORMAT("front={}&middle={}&map={}", data["front"], data["middle"], data["map"]); } bool Map(uint32_t upper, uint32_t lower) override { if (upper > UCHAR_MAX || lower > UCHAR_MAX) return false; casemap[upper] = lower; return true; } }; class ModuleCodepage final : public Module , public ISupport::EventListener { private: // The currently active codepage. std::unique_ptr<Codepage> codepage = nullptr; // The character map which was set before this module was loaded. const unsigned char* origcasemap; // The name of the character map which was set before this module was loaded. const std::string origcasemapname; // The IsNick handler which was set before this module was loaded. const std::function<bool(const std::string_view&)> origisnick; // The character set used for the codepage. std::string charset; template <typename T> static void RehashHashmap(T& hashmap) { T newhash(hashmap.bucket_count()); for (const auto& [key, value] : hashmap) newhash.emplace(key, value); hashmap.swap(newhash); } static void DestroyChannel(Channel* chan) { // Remove all of the users from the channel. Using KICK here will mean // the user's client will probably attempt to rejoin and will enter the // succeeding channel. Unfortunately this is the best we can do for now. while (!chan->userlist.empty()) chan->KickUser(ServerInstance->FakeClient, chan->userlist.begin(), "This channel does not exist anymore."); // Remove all modes from the channel just in case one of them keeps the channel open. Modes::ChangeList changelist; for (const auto& [_, mh] : ServerInstance->Modes.GetModes(MODETYPE_CHANNEL)) mh->RemoveMode(chan, changelist); ServerInstance->Modes.Process(ServerInstance->FakeClient, chan, nullptr, changelist, ModeParser::MODE_LOCALONLY); // The channel will be destroyed automatically by CheckDestroy. } static void ChangeNick(User* user, const std::string& message) { user->WriteNumeric(RPL_SAVENICK, user->uuid, message); user->ChangeNick(user->uuid); } static void CheckDuplicateChan() { ChannelMap duplicates; for (auto &[_, chan] : ServerInstance->Channels.GetChans()) { auto check = duplicates.insert(std::make_pair(chan->name, chan)); if (check.second) continue; // No duplicate. Channel* otherchan = check.first->second; if (otherchan->age < chan->age) { // The other channel was created first. DestroyChannel(chan); } else if (otherchan->age > chan->age) { // The other channel was created last. DestroyChannel(otherchan); check.first->second = chan; } else { // Both created at the same time. DestroyChannel(chan); DestroyChannel(otherchan); duplicates.erase(check.first); } } } static void CheckDuplicateNick() { UserMap duplicates; for (auto* user : ServerInstance->Users.GetLocalUsers()) { if (user->nick == user->uuid) continue; // UUID users are always unique. auto check = duplicates.insert(std::make_pair(user->nick, user)); if (check.second) continue; // No duplicate. User* otheruser = check.first->second; if (otheruser->nickchanged < user->nickchanged) { // The other user connected first. ChangeNick(user, "Your nickname is no longer available."); } else if (otheruser->nickchanged > user->nickchanged) { // The other user connected last. ChangeNick(otheruser, "Your nickname is no longer available."); check.first->second = user; } else { // Both connected at the same time. ChangeNick(user, "Your nickname is no longer available."); ChangeNick(otheruser, "Your nickname is no longer available."); duplicates.erase(check.first); } } } static void CheckInvalidNick() { for (auto* user : ServerInstance->Users.GetLocalUsers()) { if (user->nick != user->uuid && !ServerInstance->IsNick(user->nick)) ChangeNick(user, "Your nickname is no longer valid."); } } static void CheckRehash(unsigned char* prevmap) { if (!memcmp(prevmap, national_case_insensitive_map, UCHAR_MAX)) return; RehashHashmap(ServerInstance->Users.clientlist); RehashHashmap(ServerInstance->Users.uuidlist); RehashHashmap(ServerInstance->Channels.GetChans()); } static std::string GetPrintable(uint32_t chr) { if (isprint(chr)) return INSP_FORMAT("{} ({})", reinterpret_cast<const char*>(&chr), chr); else return INSP_FORMAT("{}", chr); } public: ModuleCodepage() : Module(VF_VENDOR | VF_COMMON, "Allows the server administrator to define what characters are allowed in nicknames and how characters should be compared in a case insensitive way.") , ISupport::EventListener(this) , origcasemap(national_case_insensitive_map) , origcasemapname(ServerInstance->Config->CaseMapping) , origisnick(ServerInstance->IsNick) { } ~ModuleCodepage() override { ServerInstance->IsNick = origisnick; CheckInvalidNick(); ServerInstance->Config->CaseMapping = origcasemapname; national_case_insensitive_map = origcasemap; CheckDuplicateChan(); CheckDuplicateNick(); if (codepage) // nullptr if ReadConfig throws on load. CheckRehash(codepage->casemap); } void ReadConfig(ConfigStatus& status) override { const auto& codepagetag = ServerInstance->Config->ConfValue("codepage"); const std::string name = codepagetag->getString("name"); if (name.empty()) throw ModuleException(this, "<codepage:name> is a required field!"); std::unique_ptr<Codepage> newcodepage = std::make_unique<SingleByteCodepage>(); for (const auto& [_, tag] : ServerInstance->Config->ConfTags("cpchars")) { uint32_t begin = tag->getNum<uint32_t>("begin", tag->getNum<uint32_t>("index", 0)); if (!begin) throw ModuleException(this, "<cpchars> tag without index or begin specified at " + tag->source.str()); uint32_t end = tag->getNum<uint32_t>("end", begin); if (begin > end) throw ModuleException(this, "<cpchars:begin> must be lower than <cpchars:end> at " + tag->source.str()); bool front = tag->getBool("front", false); for (uint32_t pos = begin; pos <= end; ++pos) { switch (newcodepage->AllowCharacter(pos, front)) { case Codepage::AllowCharacterResult::OKAY: ServerInstance->Logs.Debug(MODNAME, "Marked {} as allowed (front: {})", GetPrintable(pos), front ? "yes" : "no"); break; case Codepage::AllowCharacterResult::NOT_VALID: throw ModuleException(this, "<cpchars> tag contains a forbidden character: {} at {}", GetPrintable(pos), tag->source.str()); case Codepage::AllowCharacterResult::NOT_VALID_AT_FRONT: throw ModuleException(this, "<cpchars> tag contains a forbidden front character: {} at {}", GetPrintable(pos), tag->source.str()); } } } for (const auto& [_, tag] : ServerInstance->Config->ConfTags("cpcase")) { uint32_t lower = tag->getNum<uint32_t>("lower", 0); if (!lower) throw ModuleException(this, "<cpcase:lower> is required at " + tag->source.str()); uint32_t upper = tag->getNum<uint32_t>("upper", 0); if (!upper) throw ModuleException(this, "<cpcase:upper> is required at " + tag->source.str()); if (!newcodepage->Map(upper, lower)) throw ModuleException(this, "Malformed <cpcase> tag at " + tag->source.str()); ServerInstance->Logs.Debug(MODNAME, "Marked {} as the lower case version of {}", GetPrintable(lower), GetPrintable(upper)); } charset = codepagetag->getString("charset"); std::swap(codepage, newcodepage); ServerInstance->IsNick = [this](const std::string_view& nick) { return codepage->IsValidNick(nick); }; CheckInvalidNick(); ServerInstance->Config->CaseMapping = name; national_case_insensitive_map = codepage->casemap; if (newcodepage) // nullptr on first read. { CheckDuplicateChan(); CheckDuplicateNick(); CheckRehash(newcodepage->casemap); } } void OnBuildISupport(ISupport::TokenMap& tokens) override { if (!charset.empty()) tokens["CHARSET"] = charset; } void GetLinkData(LinkData& data, std::string& compatdata) override { codepage->GetLinkData(data, compatdata); } }; MODULE_INIT(ModuleCodepage) ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/src/modules/m_commonchans.cpp��������������������������������������������������������0000664�0000000�0000000�00000005565�14771603147�0021146�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2019-2024 Sadie Powell <sadie@witchery.services> * Copyright (C) 2012 Robby <robby@chatbelgie.be> * Copyright (C) 2012 Attila Molnar <attilamolnar@hush.com> * Copyright (C) 2009-2010 Daniel De Graaf <danieldg@inspircd.org> * Copyright (C) 2007 Craig Edwards <brain@inspircd.org> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include "inspircd.h" #include "modules/callerid.h" #include "modules/ctctags.h" #include "numerichelper.h" class ModuleCommonChans final : public Module , public CTCTags::EventListener { private: CallerID::API calleridapi; SimpleUserMode mode; bool IsExempt(User* source, User* target) { if (!target->IsModeSet(mode) || source->SharesChannelWith(target)) return true; // Target doesn't have mode set or shares a common channel. if (source->HasPrivPermission("users/ignore-commonchans") || source->server->IsService()) return true; // Source is an oper or a service. if (calleridapi && calleridapi->IsOnAcceptList(source, target)) return true; // Source is on the callerid accept list return false; } ModResult HandleMessage(User* user, const MessageTarget& target) { if (target.type != MessageTarget::TYPE_USER) return MOD_RES_PASSTHRU; auto* targetuser = target.Get<User>(); if (IsExempt(user, targetuser)) return MOD_RES_PASSTHRU; user->WriteNumeric(Numerics::CannotSendTo(targetuser, "messages", &mode)); return MOD_RES_DENY; } public: ModuleCommonChans() : Module(VF_VENDOR, "Adds user mode c (deaf_commonchan) which requires users to have a common channel before they can privately message each other.") , CTCTags::EventListener(this) , calleridapi(this) , mode(this, "deaf_commonchan", 'c') { } ModResult OnUserPreInvite(User* source, User* dest, Channel* channel, time_t timeout) override { if (IsExempt(source, dest)) return MOD_RES_PASSTHRU; source->WriteNumeric(Numerics::CannotSendTo(dest, "invites", &mode)); return MOD_RES_DENY; } ModResult OnUserPreMessage(User* user, MessageTarget& target, MessageDetails& details) override { return HandleMessage(user, target); } ModResult OnUserPreTagMessage(User* user, MessageTarget& target, CTCTags::TagMessageDetails& details) override { return HandleMessage(user, target); } }; MODULE_INIT(ModuleCommonChans) �������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/src/modules/m_conn_join.cpp����������������������������������������������������������0000664�0000000�0000000�00000006215�14771603147�0020606�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2021 Dominic Hamon * Copyright (C) 2019-2023 Sadie Powell <sadie@witchery.services> * Copyright (C) 2014 Daniel Vassdal <shutter@canternet.org> * Copyright (C) 2013-2015 Attila Molnar <attilamolnar@hush.com> * Copyright (C) 2012 Robby <robby@chatbelgie.be> * Copyright (C) 2009-2010 Daniel De Graaf <danieldg@inspircd.org> * Copyright (C) 2009 Robin Burchell <robin+git@viroteck.net> * Copyright (C) 2007 Craig Edwards <brain@inspircd.org> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include "inspircd.h" #include "extension.h" static void JoinChannels(LocalUser* u, const std::string& chanlist) { irc::commasepstream chans(chanlist); std::string chan; while (chans.GetToken(chan)) { if (ServerInstance->Channels.IsChannel(chan)) Channel::JoinUser(u, chan); } } class JoinTimer final : public Timer { private: LocalUser* const user; const std::string channels; SimpleExtItem<JoinTimer>& ext; public: JoinTimer(LocalUser* u, SimpleExtItem<JoinTimer>& ex, const std::string& chans, unsigned int delay) : Timer(delay, false) , user(u) , channels(chans) , ext(ex) { ServerInstance->Timers.AddTimer(this); } bool Tick() override { if (user->chans.empty()) JoinChannels(user, channels); ext.Unset(user); return false; } }; class ModuleConnJoin final : public Module { private: SimpleExtItem<JoinTimer> ext; std::string defchans; unsigned int defdelay; public: ModuleConnJoin() : Module(VF_VENDOR, "Allows the server administrator to force users to join one or more channels on connect.") , ext(this, "join-timer", ExtensionType::USER) { } void ReadConfig(ConfigStatus& status) override { const auto& tag = ServerInstance->Config->ConfValue("autojoin"); defchans = tag->getString("channel"); defdelay = static_cast<unsigned int>(tag->getDuration("delay", 0, 0, 60*15)); } void Prioritize() override { ServerInstance->Modules.SetPriority(this, I_OnPostConnect, PRIORITY_LAST); } void OnPostConnect(User* user) override { LocalUser* localuser = IS_LOCAL(user); if (!localuser) return; std::string chanlist = localuser->GetClass()->config->getString("autojoin"); unsigned int chandelay = static_cast<unsigned int>(localuser->GetClass()->config->getDuration("autojoindelay", 0, 0, 60*15)); if (chanlist.empty()) { if (defchans.empty()) return; chanlist = defchans; chandelay = defdelay; } if (!chandelay) JoinChannels(localuser, chanlist); else ext.SetFwd(localuser, localuser, ext, chanlist, chandelay); } }; MODULE_INIT(ModuleConnJoin) �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/src/modules/m_conn_umodes.cpp��������������������������������������������������������0000664�0000000�0000000�00000003153�14771603147�0021141�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2019-2021 Sadie Powell <sadie@witchery.services> * Copyright (C) 2012 Robby <robby@chatbelgie.be> * Copyright (C) 2009 Daniel De Graaf <danieldg@inspircd.org> * Copyright (C) 2007 Dennis Friis <peavey@inspircd.org> * Copyright (C) 2006 Craig Edwards <brain@inspircd.org> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include "inspircd.h" class ModuleModesOnConnect final : public Module { public: ModuleModesOnConnect() : Module(VF_VENDOR, "Allows the server administrator to set user modes on connecting users.") { } void OnUserConnect(LocalUser* user) override { const std::string modestr = user->GetClass()->config->getString("modes"); if (modestr.empty()) return; CommandBase::Params params; params.push_back(user->nick); irc::spacesepstream modestream(modestr); for (std::string modetoken; modestream.GetToken(modetoken); ) params.push_back(modetoken); ServerInstance->Parser.CallHandler("MODE", params, user); } }; MODULE_INIT(ModuleModesOnConnect) ���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/src/modules/m_conn_waitpong.cpp������������������������������������������������������0000664�0000000�0000000�00000005262�14771603147�0021500�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2018-2023 Sadie Powell <sadie@witchery.services> * Copyright (C) 2012, 2018 Attila Molnar <attilamolnar@hush.com> * Copyright (C) 2012 Robby <robby@chatbelgie.be> * Copyright (C) 2009-2010 Daniel De Graaf <danieldg@inspircd.org> * Copyright (C) 2006 Craig Edwards <brain@inspircd.org> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include "inspircd.h" #include "clientprotocolmsg.h" #include "extension.h" class ModuleWaitPong final : public Module { bool sendsnotice; bool killonbadreply; StringExtItem ext; public: ModuleWaitPong() : Module(VF_VENDOR, "Requires all clients to respond to a PING request before they can fully connect.") , ext(this, "waitpong-cookie", ExtensionType::USER) { } void ReadConfig(ConfigStatus& status) override { const auto& tag = ServerInstance->Config->ConfValue("waitpong"); sendsnotice = tag->getBool("sendsnotice", false); killonbadreply = tag->getBool("killonbadreply", true); } ModResult OnUserRegister(LocalUser* user) override { std::string pingrpl = ServerInstance->GenRandomStr(10); { ClientProtocol::Messages::Ping pingmsg(pingrpl); user->Send(ServerInstance->GetRFCEvents().ping, pingmsg); } if(sendsnotice) user->WriteNotice("*** If you are having problems connecting due to connection timeouts type /quote PONG " + pingrpl + " or /raw PONG " + pingrpl + " now."); ext.Set(user, pingrpl); return MOD_RES_PASSTHRU; } ModResult OnPreCommand(std::string& command, CommandBase::Params& parameters, LocalUser* user, bool validated) override { if (command == "PONG") { std::string* pingrpl = ext.Get(user); if (pingrpl) { if (!parameters.empty() && *pingrpl == parameters[0]) { ext.Unset(user); return MOD_RES_DENY; } else { if(killonbadreply) ServerInstance->Users.QuitUser(user, "Incorrect ping reply for connection"); return MOD_RES_DENY; } } } return MOD_RES_PASSTHRU; } ModResult OnCheckReady(LocalUser* user) override { return ext.Get(user) ? MOD_RES_DENY : MOD_RES_PASSTHRU; } }; MODULE_INIT(ModuleWaitPong) ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/src/modules/m_connectban.cpp���������������������������������������������������������0000664�0000000�0000000�00000013501�14771603147�0020740�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2021 Dominic Hamon * Copyright (C) 2019 Matt Schatz <genius3000@g3k.solutions> * Copyright (C) 2014 Googolplexed <googol@googolplexed.net> * Copyright (C) 2013, 2019-2025 Sadie Powell <sadie@witchery.services> * Copyright (C) 2012-2014 Attila Molnar <attilamolnar@hush.com> * Copyright (C) 2012, 2019 Robby <robby@chatbelgie.be> * Copyright (C) 2009-2010 Daniel De Graaf <danieldg@inspircd.org> * Copyright (C) 2008 Robin Burchell <robin+git@viroteck.net> * Copyright (C) 2008 Craig Edwards <brain@inspircd.org> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include "inspircd.h" #include "modules/server.h" #include "modules/webirc.h" #include "timeutils.h" #include "xline.h" class ModuleConnectBan final : public Module , public ServerProtocol::LinkEventListener , public WebIRC::EventListener { private: typedef std::map<irc::sockets::cidr_mask, unsigned int> ConnectMap; ConnectMap connects; unsigned long threshold; unsigned long banduration; unsigned int ipv4_cidr; unsigned int ipv6_cidr; unsigned long bootwait; unsigned long splitwait; time_t ignoreuntil = 0; std::string banmessage; unsigned char GetRange(LocalUser* user) const { sa_family_t family = user->client_sa.family(); switch (family) { case AF_INET: return ipv4_cidr; case AF_INET6: return ipv6_cidr; case AF_UNIX: // Ranges for UNIX sockets are ignored entirely. return 0; } // If we have reached this point then we have encountered a bug. ServerInstance->Logs.Debug(MODNAME, "BUG: ModuleConnectBan::GetRange(): socket type {} is unknown!", family); return 0; } static bool IsExempt(LocalUser* user) { // E-lined and already banned users shouldn't be hit. if (user->exempt || user->quitting) return true; // Users in an exempt class shouldn't be hit. return user->GetClass() && !user->GetClass()->config->getBool("useconnectban", true); } public: // Stop GCC warnings about the deprecated OnServerSplit event. using ServerProtocol::LinkEventListener::OnServerSplit; ModuleConnectBan() : Module(VF_VENDOR, "Z-lines IP addresses which make excessive connections to the server.") , ServerProtocol::LinkEventListener(this) , WebIRC::EventListener(this) { } void Prioritize() override { Module* corexline = ServerInstance->Modules.Find("core_xline"); ServerInstance->Modules.SetPriority(this, I_OnChangeRemoteAddress, PRIORITY_AFTER, corexline); } void ReadConfig(ConfigStatus& status) override { const auto& tag = ServerInstance->Config->ConfValue("connectban"); ipv4_cidr = tag->getNum<unsigned int>("ipv4cidr", ServerInstance->Config->IPv4Range, 1, 32); ipv6_cidr = tag->getNum<unsigned int>("ipv6cidr", ServerInstance->Config->IPv6Range, 1, 128); threshold = tag->getNum<unsigned long>("threshold", 10, 2); bootwait = tag->getDuration("bootwait", 60*2); splitwait = tag->getDuration("splitwait", 60*2); banduration = tag->getDuration("banduration", 6*60*60, 1); banmessage = tag->getString("banmessage", "Your IP range has been attempting to connect too many times in too short a duration. Wait a while, and you will be able to connect."); if (status.initial) ignoreuntil = ServerInstance->Time() + bootwait; } void OnWebIRCAuth(LocalUser* user, const WebIRC::FlagMap* flags) override { if (IsExempt(user)) return; // HACK: Lower the connection attempts for the gateway IP address. The user // will be rechecked for connect spamming shortly after when their IP address // is changed and OnChangeRemoteAddress is called. irc::sockets::cidr_mask mask(user->client_sa, GetRange(user)); ConnectMap::iterator iter = connects.find(mask); if (iter != connects.end() && iter->second) iter->second--; } void OnServerSplit(const Server* server, bool error) override { if (splitwait) ignoreuntil = std::max<time_t>(ignoreuntil, ServerInstance->Time() + splitwait); } void OnChangeRemoteAddress(LocalUser* u) override { if (IsExempt(u) || ignoreuntil > ServerInstance->Time()) return; irc::sockets::cidr_mask mask(u->client_sa, GetRange(u)); ConnectMap::iterator i = connects.find(mask); if (i != connects.end()) { i->second++; if (i->second >= threshold) { // If an IPv6 address begins with a colon then expand it // slightly to avoid breaking the server protocol. std::string maskstr = mask.str(); if (maskstr[0] == ':') maskstr.insert(maskstr.begin(), 1, '0'); // Create Z-line for set duration. auto* zl = new ZLine(ServerInstance->Time(), banduration, MODNAME "@" + ServerInstance->Config->ServerName, banmessage, maskstr); if (!ServerInstance->XLines->AddLine(zl, nullptr)) { delete zl; return; } ServerInstance->SNO.WriteToSnoMask('x', "{} added a timed Z-line on {}, expires in {} (on {}): {}", zl->source, maskstr, Duration::ToLongString(zl->duration), Time::ToString(zl->expiry), zl->reason); ServerInstance->SNO.WriteGlobalSno('a', "Connect flooding from IP range {} ({})", maskstr, threshold); connects.erase(i); ServerInstance->XLines->ApplyLines(); } } else { connects[mask] = 1; } } void OnGarbageCollect() override { ServerInstance->Logs.Debug(MODNAME, "Clearing map."); connects.clear(); } }; MODULE_INIT(ModuleConnectBan) �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/src/modules/m_connflood.cpp����������������������������������������������������������0000664�0000000�0000000�00000006444�14771603147�0020617�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2021 Dominic Hamon * Copyright (C) 2018-2023 Sadie Powell <sadie@witchery.services> * Copyright (C) 2012-2013 Attila Molnar <attilamolnar@hush.com> * Copyright (C) 2012 Robby <robby@chatbelgie.be> * Copyright (C) 2009 Daniel De Graaf <danieldg@inspircd.org> * Copyright (C) 2008 Robin Burchell <robin+git@viroteck.net> * Copyright (C) 2007 Dennis Friis <peavey@inspircd.org> * Copyright (C) 2006-2007 Craig Edwards <brain@inspircd.org> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include "inspircd.h" class ModuleConnFlood final : public Module { private: unsigned long seconds; unsigned long timeout; unsigned long boot_wait; unsigned long conns = 0; unsigned long maxconns; bool throttled = false; time_t first; std::string quitmsg; static bool IsExempt(LocalUser* user) { // E-lined and already banned users shouldn't be hit. if (user->exempt || user->quitting) return true; // Users in an exempt class shouldn't be hit. return user->GetClass() && !user->GetClass()->config->getBool("useconnflood", true); } public: ModuleConnFlood() : Module(VF_VENDOR, "Throttles excessive connections to the server.") { } void ReadConfig(ConfigStatus& status) override { /* read configuration variables */ const auto& tag = ServerInstance->Config->ConfValue("connflood"); /* throttle configuration */ seconds = tag->getDuration("period", 30); maxconns = tag->getNum<unsigned long>("maxconns", 3); timeout = tag->getDuration("timeout", 30); quitmsg = tag->getString("quitmsg"); /* seconds to wait when the server just booted */ boot_wait = tag->getDuration("bootwait", 60*2); first = ServerInstance->Time(); } ModResult OnUserRegister(LocalUser* user) override { if (IsExempt(user)) return MOD_RES_PASSTHRU; time_t next = ServerInstance->Time(); if ((time_t)(ServerInstance->startup_time + boot_wait) > next) return MOD_RES_PASSTHRU; /* time difference between first and latest connection */ unsigned long tdiff = next - first; /* increase connection count */ conns++; if (throttled) { if (tdiff > (seconds + timeout)) { /* expire throttle */ throttled = false; ServerInstance->SNO.WriteGlobalSno('a', "Connection throttle deactivated"); return MOD_RES_PASSTHRU; } ServerInstance->Users.QuitUser(user, quitmsg); return MOD_RES_DENY; } if (tdiff <= seconds) { if (conns >= maxconns) { throttled = true; ServerInstance->SNO.WriteGlobalSno('a', "Connection throttle activated"); ServerInstance->Users.QuitUser(user, quitmsg); return MOD_RES_DENY; } } else { conns = 1; first = next; } return MOD_RES_PASSTHRU; } }; MODULE_INIT(ModuleConnFlood) ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/src/modules/m_customprefix.cpp�������������������������������������������������������0000664�0000000�0000000�00000010646�14771603147�0021365�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2017-2023 Sadie Powell <sadie@witchery.services> * Copyright (C) 2013-2014 Attila Molnar <attilamolnar@hush.com> * Copyright (C) 2012 Robby <robby@chatbelgie.be> * Copyright (C) 2010 Daniel De Graaf <danieldg@inspircd.org> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include "inspircd.h" class CustomPrefixMode final : public PrefixMode { public: std::shared_ptr<ConfigTag> tag; CustomPrefixMode(Module* parent, const std::string& Name, char Letter, char Prefix, const std::shared_ptr<ConfigTag>& Tag) : PrefixMode(parent, Name, Letter, 0, Prefix) , tag(Tag) { ModeHandler::Rank rank = tag->getNum<ModeHandler::Rank>("rank", 1, 1); ModeHandler::Rank setrank = tag->getNum<ModeHandler::Rank>("ranktoset", prefixrank, rank); ModeHandler::Rank unsetrank = tag->getNum<ModeHandler::Rank>("ranktounset", setrank, setrank); bool depriv = tag->getBool("depriv", true); this->Update(rank, setrank, unsetrank, depriv); ServerInstance->Logs.Debug(MODNAME, "Created the {} prefix: letter={} prefix={} rank={} ranktoset={} ranktounset={} depriv={}", name, GetModeChar(), GetPrefix(), GetPrefixRank(), GetLevelRequired(true), GetLevelRequired(false), CanSelfRemove() ? "yes" : "no"); } }; class ModuleCustomPrefix final : public Module { private: std::vector<CustomPrefixMode*> modes; public: ModuleCustomPrefix() : Module(VF_VENDOR, "Allows the server administrator to configure custom channel prefix modes.") { } void init() override { for (const auto& [_, tag] : ServerInstance->Config->ConfTags("customprefix")) { const std::string name = tag->getString("name"); if (name.empty()) throw ModuleException(this, "<customprefix:name> must be specified at " + tag->source.str()); if (name.find(' ') != std::string::npos) throw ModuleException(this, "<customprefix:name> must not contain spaces at " + tag->source.str()); if (tag->getBool("change")) { ModeHandler* mh = ServerInstance->Modes.FindMode(name, MODETYPE_CHANNEL); if (!mh) throw ModuleException(this, "<customprefix:change> specified for a nonexistent mode at " + tag->source.str()); PrefixMode* pm = mh->IsPrefixMode(); if (!pm) throw ModuleException(this, "<customprefix:change> specified for a non-prefix mode at " + tag->source.str()); ModeHandler::Rank rank = tag->getNum<ModeHandler::Rank>("rank", pm->GetPrefixRank(), 1); ModeHandler::Rank setrank = tag->getNum<ModeHandler::Rank>("ranktoset", pm->GetLevelRequired(true), rank); ModeHandler::Rank unsetrank = tag->getNum<ModeHandler::Rank>("ranktounset", pm->GetLevelRequired(false), setrank); bool depriv = tag->getBool("depriv", pm->CanSelfRemove()); pm->Update(rank, setrank, unsetrank, depriv); ServerInstance->Logs.Debug(MODNAME, "Changed the {} prefix: letter={} prefix={} rank={} ranktoset={} ranktounset={} depriv={}", name, pm->GetModeChar(), pm->GetPrefix(), pm->GetPrefixRank(), pm->GetLevelRequired(true), pm->GetLevelRequired(false), pm->CanSelfRemove() ? "yes" : "no"); continue; } const std::string letter = tag->getString("letter"); if (letter.length() != 1) throw ModuleException(this, "<customprefix:letter> must be set to a mode character at " + tag->source.str()); const std::string prefix = tag->getString("prefix"); if (prefix.length() != 1) throw ModuleException(this, "<customprefix:prefix> must be set to a mode prefix at " + tag->source.str()); try { auto* mh = new CustomPrefixMode(this, name, letter[0], prefix[0], tag); modes.push_back(mh); ServerInstance->Modules.AddService(*mh); } catch (const ModuleException& e) { throw ModuleException(this, e.GetReason() + " (while creating mode from " + tag->source.str() + ")"); } } } ~ModuleCustomPrefix() override { stdalgo::delete_all(modes); } }; MODULE_INIT(ModuleCustomPrefix) ������������������������������������������������������������������������������������������inspircd-4.7.0/src/modules/m_customtitle.cpp��������������������������������������������������������0000664�0000000�0000000�00000010776�14771603147�0021215�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2018 linuxdaemon <linuxdaemon.irc@gmail.com> * Copyright (C) 2013, 2018-2023 Sadie Powell <sadie@witchery.services> * Copyright (C) 2012, 2015 Attila Molnar <attilamolnar@hush.com> * Copyright (C) 2012 Robby <robby@chatbelgie.be> * Copyright (C) 2009 Daniel De Graaf <danieldg@inspircd.org> * Copyright (C) 2007 Dennis Friis <peavey@inspircd.org> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include "inspircd.h" #include "extension.h" #include "modules/whois.h" struct CustomTitle final { const std::string name; const std::string password; const std::string hash; const std::string host; const std::string title; const std::string vhost; CustomTitle(const std::string& n, const std::string& p, const std::string& h, const std::string& hst, const std::string& t, const std::string& v) : name(n) , password(p) , hash(h) , host(hst) , title(t) , vhost(v) { } bool MatchUser(User* user) const { return InspIRCd::MatchMask(host, user->GetRealUserHost(), user->GetUserAddress()); } bool CheckPass(const std::string& pass) const { return InspIRCd::CheckPassword(password, hash, pass); } }; typedef std::multimap<std::string, CustomTitle> CustomVhostMap; class CommandTitle final : public Command { public: StringExtItem ctitle; CustomVhostMap configs; CommandTitle(Module* Creator) : Command(Creator, "TITLE", 2) , ctitle(Creator, "ctitle", ExtensionType::USER, true) { syntax = { "<username> <password>" }; } CmdResult Handle(User* user, const Params& parameters) override { for (const auto& [_, config] : insp::equal_range(configs, parameters[0])) { if (config.MatchUser(user) && config.CheckPass(parameters[1])) { ctitle.Set(user, config.title); if (!config.vhost.empty()) user->ChangeDisplayedHost(config.vhost); user->WriteNotice("Custom title set to '" + config.title + "'"); return CmdResult::SUCCESS; } } user->WriteNotice("Invalid title credentials"); return CmdResult::SUCCESS; } }; class ModuleCustomTitle final : public Module , public Whois::LineEventListener { private: CommandTitle cmd; public: ModuleCustomTitle() : Module(VF_VENDOR | VF_OPTCOMMON, "Allows the server administrator to define accounts which can grant a custom title in /WHOIS and an optional virtual host.") , Whois::LineEventListener(this) , cmd(this) { } void ReadConfig(ConfigStatus& status) override { CustomVhostMap newtitles; for (const auto& [_, tag] : ServerInstance->Config->ConfTags("title")) { std::string name = tag->getString("name", "", 1); if (name.empty()) throw ModuleException(this, "<title:name> is empty at " + tag->source.str()); std::string pass = tag->getString("password"); if (pass.empty()) throw ModuleException(this, "<title:password> is empty at " + tag->source.str()); const std::string hash = tag->getString("hash", "plaintext", 1); if (insp::equalsci(hash, "plaintext")) { ServerInstance->Logs.Normal(MODNAME, "<title> tag for {} at {} contains an plain text password, this is insecure!", name, tag->source.str()); } std::string host = tag->getString("host", "*@*", 1); std::string title = tag->getString("title"); std::string vhost = tag->getString("vhost"); CustomTitle config(name, pass, hash, host, title, vhost); newtitles.emplace(name, config); } cmd.configs.swap(newtitles); } // :kenny.chatspike.net 320 Brain Azhrarn :is getting paid to play games. ModResult OnWhoisLine(Whois::Context& whois, Numeric::Numeric& numeric) override { /* We use this and not OnWhois because this triggers for remote, too */ if (numeric.GetNumeric() == RPL_WHOISSERVER) { /* Insert our numeric before 312 */ const std::string* ctitle = cmd.ctitle.Get(whois.GetTarget()); if (ctitle && !ctitle->empty()) whois.SendLine(RPL_WHOISSPECIAL, *ctitle); } /* Don't block anything */ return MOD_RES_PASSTHRU; } }; MODULE_INIT(ModuleCustomTitle) ��inspircd-4.7.0/src/modules/m_cycle.cpp��������������������������������������������������������������0000664�0000000�0000000�00000005426�14771603147�0017734�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2019-2023 Sadie Powell <sadie@witchery.services> * Copyright (C) 2017 B00mX0r <b00mx0r@aureus.pw> * Copyright (C) 2012-2014, 2016 Attila Molnar <attilamolnar@hush.com> * Copyright (C) 2012 Robby <robby@chatbelgie.be> * Copyright (C) 2010 Craig Edwards <brain@inspircd.org> * Copyright (C) 2009 Uli Schlachter <psychon@znc.in> * Copyright (C) 2009 Daniel De Graaf <danieldg@inspircd.org> * Copyright (C) 2008 Dennis Friis <peavey@inspircd.org> * Copyright (C) 2007 Robin Burchell <robin+git@viroteck.net> * Copyright (C) 2007 John Brooks <john@jbrooks.io> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include "inspircd.h" #include "numerichelper.h" class CommandCycle final : public SplitCommand { public: CommandCycle(Module* Creator) : SplitCommand(Creator, "CYCLE", 1) { penalty = 3000; syntax = { "<channel> [:<reason>]" }; } CmdResult HandleLocal(LocalUser* user, const Params& parameters) override { auto* channel = ServerInstance->Channels.Find(parameters[0]); std::string reason = "Cycling"; if (parameters.size() > 1) { /* reason provided, use it */ reason = reason + ": " + parameters[1]; } if (!channel) { user->WriteNumeric(Numerics::NoSuchChannel(parameters[0])); return CmdResult::FAILURE; } if (channel->HasUser(user)) { if (channel->GetPrefixValue(user) < VOICE_VALUE && channel->IsBanned(user)) { // User is banned, send an error and don't cycle them user->WriteNumeric(ERR_BANNEDFROMCHAN, channel->name, "You may not cycle, as you are banned on channel " + channel->name); return CmdResult::FAILURE; } channel->PartUser(user, reason); Channel::JoinUser(user, parameters[0], true); return CmdResult::SUCCESS; } else { user->WriteNumeric(ERR_NOTONCHANNEL, channel->name, "You're not on that channel"); } return CmdResult::FAILURE; } }; class ModuleCycle final : public Module { private: CommandCycle cmd; public: ModuleCycle() : Module(VF_VENDOR, "Allows channel members to part and rejoin a channel without needing to worry about channel modes such as +i (inviteonly) which might prevent rejoining.") , cmd(this) { } }; MODULE_INIT(ModuleCycle) ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/src/modules/m_dccallow.cpp�����������������������������������������������������������0000664�0000000�0000000�00000040350�14771603147�0020420�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2021 Dominic Hamon * Copyright (C) 2018 linuxdaemon <linuxdaemon.irc@gmail.com> * Copyright (C) 2016 Adam <Adam@anope.org> * Copyright (C) 2013, 2017-2025 Sadie Powell <sadie@witchery.services> * Copyright (C) 2012-2016 Attila Molnar <attilamolnar@hush.com> * Copyright (C) 2012, 2019 Robby <robby@chatbelgie.be> * Copyright (C) 2009 Matt Smith <dz@inspircd.org> * Copyright (C) 2009 Daniel De Graaf <danieldg@inspircd.org> * Copyright (C) 2008 John Brooks <john@jbrooks.io> * Copyright (C) 2008 Craig Edwards <brain@inspircd.org> * Copyright (C) 2007-2008 Robin Burchell <robin+git@viroteck.net> * Copyright (C) 2007-2008 Dennis Friis <peavey@inspircd.org> * Copyright (C) 2006 jamie * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include "inspircd.h" #include "extension.h" #include "numerichelper.h" #include "timeutils.h" enum { // From ircd-ratbox. RPL_HELPSTART = 704, RPL_HELPTXT = 705, RPL_ENDOFHELP = 706, // InspIRCd-specific? RPL_DCCALLOWSTART = 990, RPL_DCCALLOWLIST = 991, RPL_DCCALLOWEND = 992, RPL_DCCALLOWTIMED = 993, RPL_DCCALLOWPERMANENT = 994, RPL_DCCALLOWREMOVED = 995, ERR_DCCALLOWINVALID = 996, RPL_DCCALLOWEXPIRED = 997, ERR_UNKNOWNDCCALLOWCMD = 998 }; static const char* const helptext[] = { "You may allow DCCs from specific users by specifying a", "DCC allow for the user you want to receive DCCs from.", "For example, to allow the user Brain to send you inspircd.exe", "you would type:", "/DCCALLOW +Brain", "Brain would then be able to send you files. They would have to", "resend the file again if the server gave them an error message", "before you added them to your DCCALLOW list.", "DCCALLOW entries will be temporary. If you want to add", "them to your DCCALLOW list until you leave IRC, type:", "/DCCALLOW +Brain 0", "To remove the user from your DCCALLOW list, type:", "/DCCALLOW -Brain", "To see the users in your DCCALLOW list, type:", "/DCCALLOW LIST", "NOTE: If the user leaves IRC or changes their nickname", " they will be removed from your DCCALLOW list.", " Your DCCALLOW list will be deleted when you leave IRC." }; class BannedFileList final { public: std::string filemask; std::string action; }; class DCCAllow final { public: std::string nickname; std::string hostmask; time_t set_on; unsigned long length; DCCAllow() = default; DCCAllow(const std::string& nick, const std::string& hm, time_t so, unsigned long ln) : nickname(nick) , hostmask(hm) , set_on(so) , length(ln) { } }; typedef std::vector<User *> userlist; userlist ul; typedef std::vector<DCCAllow> dccallowlist; dccallowlist* dl; typedef std::vector<BannedFileList> bannedfilelist; bannedfilelist bfl; class DCCAllowExt final : public SimpleExtItem<dccallowlist> { public: unsigned long maxentries; DCCAllowExt(Module* Creator) : SimpleExtItem<dccallowlist>(Creator, "dccallow", ExtensionType::USER) { } void FromInternal(Extensible* container, const std::string& value) noexcept override { if (container->extype != this->extype) return; LocalUser* user = IS_LOCAL(static_cast<User*>(container)); if (!user) return; // Remove the old list and create a new one. Unset(user, false); auto* list = new dccallowlist(); irc::spacesepstream ts(value); while (!ts.StreamEnd()) { // Check we have space for another entry. if (list->size() >= maxentries) { ServerInstance->Logs.Debug(MODNAME, "Oversized DCC allow list received for {}: {}", user->uuid, value); delete list; return; } // Extract the fields. DCCAllow dccallow; if (!ts.GetToken(dccallow.nickname) || !ts.GetToken(dccallow.hostmask) || !ts.GetNumericToken(dccallow.set_on) || !ts.GetNumericToken(dccallow.length)) { ServerInstance->Logs.Debug(MODNAME, "Malformed DCC allow list received for {}: {}", user->uuid, value); delete list; return; } // Store the DCC allow entry. list->push_back(dccallow); } // If we have an empty list then don't store it. if (list->empty()) { delete list; return; } // The value was well formed. Set(user, list); } std::string ToInternal(const Extensible* container, void* item) const noexcept override { dccallowlist* list = static_cast<dccallowlist*>(item); std::string buf; for (dccallowlist::const_iterator iter = list->begin(); iter != list->end(); ++iter) { if (iter != list->begin()) buf.push_back(' '); buf.append(iter->nickname); buf.push_back(' '); buf.append(iter->hostmask); buf.push_back(' '); buf.append(ConvToStr(iter->set_on)); buf.push_back(' '); buf.append(ConvToStr(iter->length)); } return buf; } }; class CommandDccallow final : public Command { public: DCCAllowExt& ext; unsigned long defaultlength; CommandDccallow(Module* parent, DCCAllowExt& Ext) : Command(parent, "DCCALLOW", 0) , ext(Ext) { syntax = { "[(+|-)<nick> [<time>]]", "LIST", "HELP" }; /* XXX we need to fix this so it can work with translation stuff (i.e. move +- into a separate param */ } CmdResult Handle(User* user, const Params& parameters) override { /* syntax: DCCALLOW [(+|-)<nick> [<time>]]|[LIST|HELP] */ if (parameters.empty()) { // display current DCCALLOW list DisplayDCCAllowList(user); return CmdResult::FAILURE; } else { char action = parameters[0][0]; // if they didn't specify an action, this is probably a command if (action != '+' && action != '-') { if (irc::equals(parameters[0], "LIST")) { // list current DCCALLOW list DisplayDCCAllowList(user); return CmdResult::FAILURE; } else if (irc::equals(parameters[0], "HELP")) { // display help DisplayHelp(user); return CmdResult::FAILURE; } else { user->WriteNumeric(ERR_UNKNOWNDCCALLOWCMD, "DCCALLOW command not understood. For help on DCCALLOW, type /DCCALLOW HELP"); return CmdResult::FAILURE; } } std::string nick(parameters[0], 1); auto* target = ServerInstance->Users.FindNick(nick, true); if (target && !target->quitting) { if (action == '-') { // check if it contains any entries dl = ext.Get(user); if (dl) { for (dccallowlist::iterator i = dl->begin(); i != dl->end(); ++i) { // search through list if (i->nickname == target->nick) { dl->erase(i); user->WriteNumeric(RPL_DCCALLOWREMOVED, user->nick, INSP_FORMAT("Removed {} from your DCCALLOW list", target->nick)); break; } } } } else if (action == '+') { if (target == user) { user->WriteNumeric(ERR_DCCALLOWINVALID, user->nick, "You cannot add yourself to your own DCCALLOW list!"); return CmdResult::FAILURE; } dl = ext.Get(user); if (!dl) { dl = new dccallowlist; ext.Set(user, dl); // add this user to the userlist ul.push_back(user); } if (dl->size() >= ext.maxentries) { user->WriteNumeric(ERR_DCCALLOWINVALID, user->nick, "Too many nicks on DCCALLOW list"); return CmdResult::FAILURE; } for (const auto& dccallow : *dl) { if (dccallow.nickname == target->nick) { user->WriteNumeric(ERR_DCCALLOWINVALID, user->nick, INSP_FORMAT("{} is already on your DCCALLOW list", target->nick)); return CmdResult::FAILURE; } } std::string mask = target->GetMask(); unsigned long length; if (parameters.size() < 2) { length = defaultlength; } else if (!Duration::IsValid(parameters[1])) { user->WriteNumeric(ERR_DCCALLOWINVALID, user->nick, INSP_FORMAT("{} is not a valid DCCALLOW duration", parameters[1])); return CmdResult::FAILURE; } else { if (!Duration::TryFrom(parameters[1], length)) { user->WriteNotice("*** Invalid duration for DCC allow"); return CmdResult::FAILURE; } } if (!InspIRCd::IsValidMask(mask)) { return CmdResult::FAILURE; } dl->emplace_back(target->nick, mask, ServerInstance->Time(), length); if (length > 0) { user->WriteNumeric(RPL_DCCALLOWTIMED, user->nick, INSP_FORMAT("Added {} to DCCALLOW list for {}", target->nick, Duration::ToLongString(length))); } else { user->WriteNumeric(RPL_DCCALLOWPERMANENT, user->nick, INSP_FORMAT("Added {} to DCCALLOW list for this session", target->nick)); } /* route it. */ return CmdResult::SUCCESS; } } else { // nick doesn't exist user->WriteNumeric(Numerics::NoSuchNick(nick)); return CmdResult::FAILURE; } } return CmdResult::FAILURE; } RouteDescriptor GetRouting(User* user, const Params& parameters) override { return ROUTE_BROADCAST; } static void DisplayHelp(User* user) { user->WriteNumeric(RPL_HELPSTART, "*", "DCCALLOW [(+|-)<nick> [<time>]]|[LIST|HELP]"); for (const auto& helpline : helptext) user->WriteNumeric(RPL_HELPTXT, "*", helpline); user->WriteNumeric(RPL_ENDOFHELP, "*", "End of DCCALLOW HELP"); LocalUser* localuser = IS_LOCAL(user); if (localuser) localuser->CommandFloodPenalty += 4000; } void DisplayDCCAllowList(User* user) { // display current DCCALLOW list user->WriteNumeric(RPL_DCCALLOWSTART, "Users on your DCCALLOW list:"); dl = ext.Get(user); if (dl) { for (const auto& dccallow : *dl) { user->WriteNumeric(RPL_DCCALLOWLIST, user->nick, INSP_FORMAT("{} ({})", dccallow.nickname, dccallow.hostmask)); } } user->WriteNumeric(RPL_DCCALLOWEND, "End of DCCALLOW list"); } }; class ModuleDCCAllow final : public Module { private: DCCAllowExt ext; CommandDccallow cmd; bool blockchat = false; std::string defaultaction; public: ModuleDCCAllow() : Module(VF_VENDOR | VF_COMMON, "Allows the server administrator to configure what files are allowed to be sent via DCC SEND and allows users to configure who can send them DCC CHAT and DCC SEND requests.") , ext(this) , cmd(this, ext) { } void OnUserQuit(User* user, const std::string& reason, const std::string& oper_message) override { dccallowlist* udl = ext.Get(user); // remove their DCCALLOW list if they have one if (udl) stdalgo::erase(ul, user); // remove them from any DCCALLOW lists // they are currently on RemoveNick(user); } void OnUserPostNick(User* user, const std::string& oldnick) override { RemoveNick(user); } ModResult OnUserPreMessage(User* user, MessageTarget& target, MessageDetails& details) override { if (!IS_LOCAL(user)) return MOD_RES_PASSTHRU; if (target.type == MessageTarget::TYPE_USER) { auto* u = target.Get<User>(); /* Always allow a user to dcc themselves (although... why?) */ if (user == u) return MOD_RES_PASSTHRU; std::string_view ctcpname; std::string_view ctcpbody; if (details.IsCTCP(ctcpname, ctcpbody)) { Expire(); // :jamie!jamie@test-D4457903BA652E0F.silverdream.org PRIVMSG eimaj :DCC SEND m_dnsbl.cpp 3232235786 52650 9676 // :jamie!jamie@test-D4457903BA652E0F.silverdream.org PRIVMSG eimaj :VERSION if (irc::equals(ctcpname, "DCC") && !ctcpbody.empty()) { dl = ext.Get(u); if (dl && !dl->empty()) { for (const auto& dccallow : *dl) { if (InspIRCd::Match(user->GetMask(), dccallow.hostmask)) return MOD_RES_PASSTHRU; } } size_t s = ctcpbody.find(' '); if (s == std::string::npos) return MOD_RES_PASSTHRU; const std::string type = std::string(ctcpbody).substr(0, s); if (irc::equals(type, "SEND")) { size_t first; std::string buf = std::string(ctcpbody).substr(s + 1); if (!buf.empty() && buf[0] == '"') { s = buf.find('"', 1); if (s == std::string::npos || s <= 1) return MOD_RES_PASSTHRU; --s; first = 1; } else { s = buf.find(' '); first = 0; } if (s == std::string::npos) return MOD_RES_PASSTHRU; std::string filename = buf.substr(first, s); bool found = false; for (const auto& bf : bfl) { if (InspIRCd::Match(filename, bf.filemask, ascii_case_insensitive_map)) { /* We have a matching badfile entry, override whatever the default action is */ if (insp::equalsci(bf.action, "allow")) return MOD_RES_PASSTHRU; else { found = true; break; } } } /* only follow the default action if no badfile matches were found above */ if ((!found) && (defaultaction == "allow")) return MOD_RES_PASSTHRU; user->WriteNotice("The user " + u->nick + " is not accepting DCC SENDs from you. Your file " + filename + " was not sent."); u->WriteNotice(user->nick + " (" + user->GetUserHost() + ") attempted to send you a file named " + filename + ", which was blocked."); u->WriteNotice("If you trust " + user->nick + " and were expecting this, you can type /DCCALLOW HELP for information on the DCCALLOW system."); return MOD_RES_DENY; } else if (blockchat && irc::equals(type, "CHAT")) { user->WriteNotice("The user " + u->nick + " is not accepting DCC CHAT requests from you."); u->WriteNotice(user->nick + " (" + user->GetUserHost() + ") attempted to initiate a DCC CHAT session, which was blocked."); u->WriteNotice("If you trust " + user->nick + " and were expecting this, you can type /DCCALLOW HELP for information on the DCCALLOW system."); return MOD_RES_DENY; } } } } return MOD_RES_PASSTHRU; } void Expire() { for (userlist::iterator iter = ul.begin(); iter != ul.end();) { User* u = (User*)(*iter); dl = ext.Get(u); if (dl) { if (!dl->empty()) { dccallowlist::iterator iter2 = dl->begin(); while (iter2 != dl->end()) { time_t expires = iter2->set_on + iter2->length; if (iter2->length != 0 && expires <= ServerInstance->Time()) { u->WriteNumeric(RPL_DCCALLOWEXPIRED, u->nick, INSP_FORMAT("DCCALLOW entry for {} has expired", iter2->nickname)); iter2 = dl->erase(iter2); } else { ++iter2; } } } ++iter; } else { iter = ul.erase(iter); } } } void RemoveNick(User* user) { /* Iterate through all DCCALLOW lists and remove user */ for (userlist::iterator iter = ul.begin(); iter != ul.end();) { User* u = (User*)(*iter); dl = ext.Get(u); if (dl) { if (!dl->empty()) { for (dccallowlist::iterator i = dl->begin(); i != dl->end(); ++i) { if (i->nickname == user->nick) { u->WriteNotice(i->nickname + " left the network or changed their nickname and has been removed from your DCCALLOW list"); u->WriteNumeric(RPL_DCCALLOWREMOVED, u->nick, INSP_FORMAT("Removed {} from your DCCALLOW list", i->nickname)); dl->erase(i); break; } } } ++iter; } else { iter = ul.erase(iter); } } } static void RemoveFromUserlist(User* user) { // remove user from userlist for (userlist::iterator j = ul.begin(); j != ul.end(); ++j) { User* u = (User*)(*j); if (u == user) { ul.erase(j); break; } } } void ReadConfig(ConfigStatus& status) override { bannedfilelist newbfl; for (const auto& [_, tag] : ServerInstance->Config->ConfTags("banfile")) { BannedFileList bf; bf.filemask = tag->getString("pattern"); bf.action = tag->getString("action"); newbfl.push_back(bf); } bfl.swap(newbfl); const auto& tag = ServerInstance->Config->ConfValue("dccallow"); cmd.ext.maxentries = tag->getNum<unsigned long>("maxentries", 20, 1); cmd.defaultlength = tag->getDuration("length", 0); blockchat = tag->getBool("blockchat"); defaultaction = tag->getString("action"); } }; MODULE_INIT(ModuleDCCAllow) ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/src/modules/m_deaf.cpp���������������������������������������������������������������0000664�0000000�0000000�00000013756�14771603147�0017541�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2019 linuxdaemon <linuxdaemon.irc@gmail.com> * Copyright (C) 2019 Matt Schatz <genius3000@g3k.solutions> * Copyright (C) 2013, 2017, 2019-2023 Sadie Powell <sadie@witchery.services> * Copyright (C) 2012 Robby <robby@chatbelgie.be> * Copyright (C) 2012 Attila Molnar <attilamolnar@hush.com> * Copyright (C) 2009 Daniel De Graaf <danieldg@inspircd.org> * Copyright (C) 2008 Craig Edwards <brain@inspircd.org> * Copyright (C) 2007 Robin Burchell <robin+git@viroteck.net> * Copyright (C) 2006 Dennis Friis <peavey@inspircd.org> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include "inspircd.h" #include "modules/ctctags.h" // User mode +d - filter out channel messages and channel notices class DeafMode final : public SimpleUserMode { public: DeafMode(Module* Creator) : SimpleUserMode(Creator, "deaf", 'd') { } bool OnModeChange(User* source, User* dest, Channel* channel, Modes::Change& change) override { if (!SimpleUserMode::OnModeChange(source, dest, channel, change)) return false; if (change.adding) dest->WriteNotice("*** You have enabled user mode +d, deaf mode. This mode means you WILL NOT receive any messages from any channels you are in. If you did NOT mean to do this, use /mode " + dest->nick + " -d."); return true; } }; // User mode +D - filter out user messages and user notices class PrivDeafMode final : public SimpleUserMode { public: PrivDeafMode(Module* Creator) : SimpleUserMode(Creator, "privdeaf", 'D') { } bool OnModeChange(User* source, User* dest, Channel* channel, Modes::Change& change) override { if (!SimpleUserMode::OnModeChange(source, dest, channel, change)) return false; if (change.adding) dest->WriteNotice("*** You have enabled user mode +D, private deaf mode. This mode means you WILL NOT receive any messages and notices from any nicks. If you did NOT mean to do this, use /mode " + dest->nick + " -D."); return true; } }; class ModuleDeaf final : public Module , public CTCTags::EventListener { private: DeafMode deafmode; PrivDeafMode privdeafmode; std::string deaf_bypasschars; std::string deaf_bypasschars_service; bool privdeafservice; ModResult HandleChannel(User* source, Channel* target, CUList& exemptions, bool is_bypasschar, bool is_bypasschar_service) { for (const auto& [member, _] : target->GetUsers()) { // Allow if the user doesn't have the mode set. if (!member->IsModeSet(deafmode)) continue; // Allow if the message begins with a service char and the // user is on a services server. if (is_bypasschar_service && member->server->IsService()) continue; // Allow if the prefix begins with a normal char and the // user is not on a services server. if (is_bypasschar && !member->server->IsService()) continue; exemptions.insert(member); } return MOD_RES_PASSTHRU; } ModResult HandleUser(User* source, User* target) { // Allow if the mode is not set. if (!target->IsModeSet(privdeafmode)) return MOD_RES_PASSTHRU; // Reject if the source is a service and privdeafservice is disabled. if (!privdeafservice && source->server->IsService()) return MOD_RES_DENY; // Reject if the source doesn't have the right priv. if (!source->HasPrivPermission("users/ignore-privdeaf")) return MOD_RES_DENY; return MOD_RES_PASSTHRU; } public: ModuleDeaf() : Module(VF_VENDOR, "Adds user modes d (deaf) and D (privdeaf) which prevents users from receiving channel (deaf) or private (privdeaf) messages.") , CTCTags::EventListener(this) , deafmode(this) , privdeafmode(this) { } void ReadConfig(ConfigStatus& status) override { const auto& tag = ServerInstance->Config->ConfValue("deaf"); deaf_bypasschars = tag->getString("bypasschars"); deaf_bypasschars_service = tag->getString("servicebypasschars", tag->getString("bypasscharsuline")); privdeafservice = tag->getBool("privdeafservice", tag->getBool("privdeafuline", true)); } ModResult OnUserPreTagMessage(User* user, MessageTarget& target, CTCTags::TagMessageDetails& details) override { switch (target.type) { case MessageTarget::TYPE_CHANNEL: return HandleChannel(user, target.Get<Channel>(), details.exemptions, false, false); case MessageTarget::TYPE_USER: return HandleUser(user, target.Get<User>()); case MessageTarget::TYPE_SERVER: break; } return MOD_RES_PASSTHRU; } ModResult OnUserPreMessage(User* user, MessageTarget& target, MessageDetails& details) override { switch (target.type) { case MessageTarget::TYPE_CHANNEL: { // If we have no bypasschars_service in config, and this is a bypasschar (regular) // Then it is obviously going to get through +d, no exemption list required bool is_bypasschar = (deaf_bypasschars.find(details.text[0]) != std::string::npos); if (deaf_bypasschars_service.empty() && is_bypasschar) return MOD_RES_PASSTHRU; // If it matches both bypasschar and bypasschar_service, it will get through. bool is_bypasschar_service = (deaf_bypasschars_service.find(details.text[0]) != std::string::npos); if (is_bypasschar && is_bypasschar_service) return MOD_RES_PASSTHRU; return HandleChannel(user, target.Get<Channel>(), details.exemptions, is_bypasschar, is_bypasschar_service); } case MessageTarget::TYPE_USER: return HandleUser(user, target.Get<User>()); case MessageTarget::TYPE_SERVER: break; } return MOD_RES_PASSTHRU; } }; MODULE_INIT(ModuleDeaf) ������������������inspircd-4.7.0/src/modules/m_delayjoin.cpp����������������������������������������������������������0000664�0000000�0000000�00000021164�14771603147�0020610�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2017-2024 Sadie Powell <sadie@witchery.services> * Copyright (C) 2012-2015, 2018 Attila Molnar <attilamolnar@hush.com> * Copyright (C) 2012 Robby <robby@chatbelgie.be> * Copyright (C) 2010 Jens Voss <DukePyrolator@anope.org> * Copyright (C) 2009 Matt Smith <dz@inspircd.org> * Copyright (C) 2009 Daniel De Graaf <danieldg@inspircd.org> * Copyright (C) 2008 Robin Burchell <robin+git@viroteck.net> * Copyright (C) 2007-2008 Craig Edwards <brain@inspircd.org> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include "inspircd.h" #include "clientprotocolevent.h" #include "modules/ctctags.h" #include "modules/ircv3_servertime.h" #include "modules/names.h" #include "modules/who.h" class DelayJoinMode final : public SimpleChannelMode { private: IntExtItem& unjoined; IRCv3::ServerTime::API servertime; public: DelayJoinMode(Module* Parent, IntExtItem& ext) : SimpleChannelMode(Parent, "delayjoin", 'D') , unjoined(ext) , servertime(Parent) { ranktoset = ranktounset = OP_VALUE; } bool OnModeChange(User* source, User* dest, Channel* channel, Modes::Change& change) override { if (SimpleChannelMode::OnModeChange(source, dest, channel, change)) { /* * Make all users visible, as +D is being removed. If we don't do this, * they remain permanently invisible on this channel! */ for (const auto& [member, _] : channel->GetUsers()) RevealUser(member, channel); return true; } return false; } void RevealUser(User* user, Channel* chan); }; namespace { /** Hook handler for join client protocol events. * This allows us to block join protocol events completely, including all associated messages (e.g. MODE, away-notify AWAY). * This is not the same as OnUserJoin() because that runs only when a real join happens but this runs also when a module * such as hostcycle generates a join. */ class JoinHook final : public ClientProtocol::EventHook { private: const IntExtItem& unjoined; public: JoinHook(Module* mod, const IntExtItem& unjoinedref) : ClientProtocol::EventHook(mod, "JOIN", 10) , unjoined(unjoinedref) { } ModResult OnPreEventSend(LocalUser* user, const ClientProtocol::Event& ev, ClientProtocol::MessageList& messagelist) override { const ClientProtocol::Events::Join& join = static_cast<const ClientProtocol::Events::Join&>(ev); const Membership* const memb = join.GetMember(); const User* const u = memb->user; if ((unjoined.Get(memb)) && (u != user)) return MOD_RES_DENY; return MOD_RES_PASSTHRU; } }; } class ModuleDelayJoin final : public Module , public CTCTags::EventListener , public Names::EventListener , public Who::EventListener , public Who::VisibleEventListener { private: IntExtItem unjoined; JoinHook joinhook; DelayJoinMode djm; void PopulateExcepts(CUList& except, Membership* memb) { if (!unjoined.Get(memb)) return; unjoined.Unset(memb); for (const auto& [member, _] : memb->chan->GetUsers()) { if (member != memb->user && IS_LOCAL(member)) except.insert(member); } } public: ModuleDelayJoin() : Module(VF_VENDOR, "Adds channel mode D (delayjoin) which hides JOIN messages from users until they speak.") , CTCTags::EventListener(this) , Names::EventListener(this) , Who::EventListener(this) , Who::VisibleEventListener(this) , unjoined(this, "delayjoin", ExtensionType::MEMBERSHIP) , joinhook(this, unjoined) , djm(this, unjoined) { } ModResult OnNamesListItem(LocalUser* issuer, Membership*, std::string& prefixes, std::string& nick) override; ModResult OnWhoLine(const Who::Request& request, LocalUser* source, User* user, Membership* memb, Numeric::Numeric& numeric) override; ModResult OnWhoVisible(const Who::Request& request, LocalUser* source, Membership* memb) override; void OnUserJoin(Membership*, bool, bool, CUList&) override; void CleanUser(User* user); void OnUserPart(Membership*, std::string& partmessage, CUList&) override; void OnUserKick(User* source, Membership*, const std::string& reason, CUList&) override; void OnBuildNeighborList(User* source, User::NeighborList& include, User::NeighborExceptions& exception) override; void OnUserMessage(User* user, const MessageTarget& target, const MessageDetails& details) override; void OnUserTagMessage(User* user, const MessageTarget& target, const CTCTags::TagMessageDetails& details) override; ModResult OnRawMode(User* user, Channel* channel, const Modes::Change& change) override; }; ModResult ModuleDelayJoin::OnNamesListItem(LocalUser* issuer, Membership* memb, std::string& prefixes, std::string& nick) { /* don't prevent the user from seeing themself */ if (issuer == memb->user) return MOD_RES_PASSTHRU; /* If the user is hidden by delayed join, hide them from the NAMES list */ if (unjoined.Get(memb)) return MOD_RES_DENY; return MOD_RES_PASSTHRU; } ModResult ModuleDelayJoin::OnWhoLine(const Who::Request& request, LocalUser* source, User* user, Membership* memb, Numeric::Numeric& numeric) { // We don't need to do anything if they're not delayjoined. if (!memb || !unjoined.Get(memb)) return MOD_RES_PASSTHRU; // Only show delayjoined users to others if the d flag has been specified. if (source != user && !request.flags['d']) return MOD_RES_DENY; // Add the < flag to mark the user as delayjoined. size_t flag_index; if (request.GetFieldIndex('f', flag_index)) numeric.GetParams()[flag_index].push_back('<'); return MOD_RES_PASSTHRU; } ModResult ModuleDelayJoin::OnWhoVisible(const Who::Request& request, LocalUser* source, Membership* memb) { // A WHO request is visible if: // 1. The source is the user. // 2. The user specified the delayjoin `d` flag. // 3. The user is not delayjoined. return source == memb->user || request.flags['d'] || !unjoined.Get(memb) ? MOD_RES_PASSTHRU : MOD_RES_DENY; } void ModuleDelayJoin::OnUserJoin(Membership* memb, bool sync, bool created, CUList& except) { if (memb->chan->IsModeSet(djm)) unjoined.Set(memb, ServerInstance->Time()); } void ModuleDelayJoin::OnUserPart(Membership* memb, std::string& partmessage, CUList& except) { PopulateExcepts(except, memb); } void ModuleDelayJoin::OnUserKick(User* source, Membership* memb, const std::string& reason, CUList& except) { PopulateExcepts(except, memb); } void ModuleDelayJoin::OnBuildNeighborList(User* source, User::NeighborList& include, User::NeighborExceptions& exception) { for (User::NeighborList::iterator i = include.begin(); i != include.end(); ) { Membership* memb = *i; if (unjoined.Get(memb)) i = include.erase(i); else ++i; } } void ModuleDelayJoin::OnUserTagMessage(User* user, const MessageTarget& target, const CTCTags::TagMessageDetails& details) { if (target.type != MessageTarget::TYPE_CHANNEL) return; auto* channel = target.Get<Channel>(); djm.RevealUser(user, channel); } void ModuleDelayJoin::OnUserMessage(User* user, const MessageTarget& target, const MessageDetails& details) { if (target.type != MessageTarget::TYPE_CHANNEL) return; auto* channel = target.Get<Channel>(); djm.RevealUser(user, channel); } void DelayJoinMode::RevealUser(User* user, Channel* chan) { Membership* memb = chan->GetUser(user); if (!memb) return; time_t jointime = unjoined.Get(memb); if (!jointime) return; /* Display the join to everyone else (the user who joined got it earlier) */ unjoined.Unset(memb); CUList except_list; except_list.insert(user); ClientProtocol::Events::Join joinevent(memb); if (servertime) servertime->Set(joinevent, jointime); chan->Write(joinevent, 0, except_list); } /* make the user visible if they receive any mode change */ ModResult ModuleDelayJoin::OnRawMode(User* user, Channel* channel, const Modes::Change& change) { if (!channel || change.param.empty()) return MOD_RES_PASSTHRU; // If not a prefix mode then we got nothing to do here if (!change.mh->IsPrefixMode()) return MOD_RES_PASSTHRU; User* dest; if (IS_LOCAL(user)) dest = ServerInstance->Users.FindNick(change.param); else dest = ServerInstance->Users.Find(change.param); if (!dest) return MOD_RES_PASSTHRU; djm.RevealUser(dest, channel); return MOD_RES_PASSTHRU; } MODULE_INIT(ModuleDelayJoin) ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/src/modules/m_delaymsg.cpp�����������������������������������������������������������0000664�0000000�0000000�00000011026�14771603147�0020433�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2022 iwalkalone <iwalkalone69@gmail.com> * Copyright (C) 2021 Dominic Hamon * Copyright (C) 2017-2025 Sadie Powell <sadie@witchery.services> * Copyright (C) 2012-2014 Attila Molnar <attilamolnar@hush.com> * Copyright (C) 2012 Robby <robby@chatbelgie.be> * Copyright (C) 2009-2010 Daniel De Graaf <danieldg@inspircd.org> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include "inspircd.h" #include "modules/ctctags.h" #include "modules/exemption.h" #include "timeutils.h" #include "numerichelper.h" class DelayMsgMode final : public ParamMode<DelayMsgMode, IntExtItem> { public: IntExtItem jointime; DelayMsgMode(Module* Parent) : ParamMode<DelayMsgMode, IntExtItem>(Parent, "delaymsg", 'd') , jointime(Parent, "delaymsg", ExtensionType::MEMBERSHIP) { ranktoset = ranktounset = OP_VALUE; syntax = "<seconds>"; } bool ResolveModeConflict(const std::string& their_param, const std::string& our_param, Channel*) override { return ConvToNum<intptr_t>(their_param) < ConvToNum<intptr_t>(our_param); } bool OnSet(User* source, Channel* chan, std::string& parameter) override; void OnUnset(User* source, Channel* chan) override; void SerializeParam(Channel* chan, intptr_t n, std::string& out) { out += ConvToStr(n); } }; class ModuleDelayMsg final : public Module , public CTCTags::EventListener { private: DelayMsgMode djm; CheckExemption::EventProvider exemptionprov; ModResult HandleMessage(User* user, const MessageTarget& target); public: ModuleDelayMsg() : Module(VF_VENDOR, "Adds channel mode d (delaymsg) which prevents newly joined users from speaking until the specified number of seconds have passed.") , CTCTags::EventListener(this) , djm(this) , exemptionprov(this) { } void OnUserJoin(Membership* memb, bool sync, bool created, CUList&) override; ModResult OnUserPreMessage(User* user, MessageTarget& target, MessageDetails& details) override; ModResult OnUserPreTagMessage(User* user, MessageTarget& target, CTCTags::TagMessageDetails& details) override; }; bool DelayMsgMode::OnSet(User* source, Channel* chan, std::string& parameter) { // Setting a new limit, sanity check intptr_t limit = ConvToNum<intptr_t>(parameter); if (limit <= 0) limit = 1; ext.Set(chan, limit); return true; } void DelayMsgMode::OnUnset(User* source, Channel* chan) { for (const auto& [_, memb] : chan->GetUsers()) jointime.Unset(memb); } void ModuleDelayMsg::OnUserJoin(Membership* memb, bool sync, bool created, CUList&) { if ((IS_LOCAL(memb->user)) && (memb->chan->IsModeSet(djm))) { djm.jointime.Set(memb, ServerInstance->Time()); } } ModResult ModuleDelayMsg::OnUserPreMessage(User* user, MessageTarget& target, MessageDetails& details) { return HandleMessage(user, target); } ModResult ModuleDelayMsg::OnUserPreTagMessage(User* user, MessageTarget& target, CTCTags::TagMessageDetails& details) { return HandleMessage(user, target); } ModResult ModuleDelayMsg::HandleMessage(User* user, const MessageTarget& target) { if (!IS_LOCAL(user) || target.type != MessageTarget::TYPE_CHANNEL) return MOD_RES_PASSTHRU; auto* channel = target.Get<Channel>(); Membership* memb = channel->GetUser(user); if (!memb) return MOD_RES_PASSTHRU; time_t ts = djm.jointime.Get(memb); if (ts == 0) return MOD_RES_PASSTHRU; intptr_t len = djm.ext.Get(channel); if ((ts + len) > ServerInstance->Time()) { ModResult res = exemptionprov.Check(user, channel, "delaymsg"); if (res == MOD_RES_ALLOW) return MOD_RES_PASSTHRU; if (user->HasPrivPermission("channels/ignore-delaymsg")) return MOD_RES_PASSTHRU; const std::string message = INSP_FORMAT("You cannot send messages to this channel until you have been a member for {}.", Duration::ToLongString(len)); user->WriteNumeric(Numerics::CannotSendTo(channel, message)); return MOD_RES_DENY; } else { /* Timer has expired, we can stop checking now */ djm.jointime.Unset(memb); } return MOD_RES_PASSTHRU; } MODULE_INIT(ModuleDelayMsg) ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/src/modules/m_denychans.cpp����������������������������������������������������������0000664�0000000�0000000�00000014066�14771603147�0020611�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2019 Matt Schatz <genius3000@g3k.solutions> * Copyright (C) 2018-2024 Sadie Powell <sadie@witchery.services> * Copyright (C) 2013 Attila Molnar <attilamolnar@hush.com> * Copyright (C) 2012 Robby <robby@chatbelgie.be> * Copyright (C) 2009 Daniel De Graaf <danieldg@inspircd.org> * Copyright (C) 2008 Robin Burchell <robin+git@viroteck.net> * Copyright (C) 2007 Dennis Friis <peavey@inspircd.org> * Copyright (C) 2007 Craig Edwards <brain@inspircd.org> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include "inspircd.h" enum { // InspIRCd-specific. ERR_BADCHANNEL = 926 }; struct BadChannel final { bool allowopers; std::string name; std::string reason; std::string redirect; BadChannel(const std::string& Name, const std::string& Redirect, const std::string& Reason, bool AllowOpers) : allowopers(AllowOpers) , name(Name) , reason(Reason) , redirect(Redirect) { } }; typedef std::vector<BadChannel> BadChannels; typedef std::vector<std::string> GoodChannels; class ModuleDenyChannels final : public Module { private: BadChannels badchannels; GoodChannels goodchannels; UserModeReference antiredirectmode; ChanModeReference redirectmode; public: ModuleDenyChannels() : Module(VF_VENDOR, "Allows the server administrator to prevent users from joining channels matching a glob.") , antiredirectmode(this, "antiredirect") , redirectmode(this, "redirect") { } void ReadConfig(ConfigStatus& status) override { GoodChannels goodchans; for (const auto& [_, tag] : ServerInstance->Config->ConfTags("goodchan")) { // Ensure that we have the <goodchan:name> parameter. const std::string name = tag->getString("name"); if (name.empty()) throw ModuleException(this, "<goodchan:name> is a mandatory field, at " + tag->source.str()); goodchans.push_back(name); } BadChannels badchans; for (const auto& [_, tag] : ServerInstance->Config->ConfTags("badchan")) { // Ensure that we have the <badchan:name> parameter. const std::string name = tag->getString("name"); if (name.empty()) throw ModuleException(this, "<badchan:name> is a mandatory field, at " + tag->source.str()); // Ensure that we have the <badchan:reason> parameter. const std::string reason = tag->getString("reason"); if (reason.empty()) throw ModuleException(this, "<badchan:reason> is a mandatory field, at " + tag->source.str()); const std::string redirect = tag->getString("redirect"); if (!redirect.empty()) { // Ensure that <badchan:redirect> contains a channel name. if (!ServerInstance->Channels.IsChannel(redirect)) throw ModuleException(this, "<badchan:redirect> is not a valid channel name, at " + tag->source.str()); // We defer the rest of the validation of the redirect channel until we have // finished parsing all of the badchans. } badchans.emplace_back(name, redirect, reason, tag->getBool("allowopers")); } // Now we have all of the badchan information recorded we can check that all redirect // channels can actually be redirected to. for (const auto& badchan : badchans) { // If there is no redirect channel we have nothing to do. if (badchan.redirect.empty()) continue; // If the redirect channel is whitelisted then it is okay. bool whitelisted = false; for (const auto& goodchan : goodchans) { if (InspIRCd::Match(badchan.redirect, goodchan)) { whitelisted = true; break; } } if (whitelisted) continue; // If the redirect channel is not blacklisted then it is okay. for (const auto& badchanredir : badchans) { if (InspIRCd::Match(badchan.redirect, badchanredir.name)) throw ModuleException(this, "<badchan:redirect> cannot be a blacklisted channel name"); } } // The config file contained no errors so we can apply the new configuration. badchannels.swap(badchans); goodchannels.swap(goodchans); } ModResult OnUserPreJoin(LocalUser* user, Channel* chan, const std::string& cname, std::string& privs, const std::string& keygiven, bool override) override { if (override) return MOD_RES_PASSTHRU; for (const auto& badchan : badchannels) { // If the channel does not match the current entry we have nothing else to do. if (!InspIRCd::Match(cname, badchan.name)) continue; // If the user is an oper and opers are allowed to enter this blacklisted channel // then allow the join. if (user->IsOper() && badchan.allowopers) return MOD_RES_PASSTHRU; // If the channel matches a whitelist then allow the join. for (const auto& goodchan : goodchannels) if (InspIRCd::Match(cname, goodchan)) return MOD_RES_PASSTHRU; // If there is no redirect chan, the user has enabled the antiredirect mode, or // the target channel redirects elsewhere we just tell the user and deny the join. Channel* target = nullptr; if (badchan.redirect.empty() || user->IsModeSet(antiredirectmode) || ((target = ServerInstance->Channels.Find(badchan.redirect)) && target->IsModeSet(redirectmode))) { user->WriteNumeric(ERR_BADCHANNEL, cname, INSP_FORMAT("Channel {} is forbidden: {}", cname, badchan.reason)); return MOD_RES_DENY; } // Redirect the user to the target channel. user->WriteNumeric(ERR_BADCHANNEL, cname, INSP_FORMAT("Channel {} is forbidden, redirecting to {}: {}", cname, badchan.redirect, badchan.reason)); Channel::JoinUser(user, badchan.redirect); return MOD_RES_DENY; } return MOD_RES_PASSTHRU; } }; MODULE_INIT(ModuleDenyChannels) ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/src/modules/m_disable.cpp������������������������������������������������������������0000664�0000000�0000000�00000016371�14771603147�0020241�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2019-2023, 2025 Sadie Powell <sadie@witchery.services> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include "inspircd.h" enum { // From ircu. ERR_DISABLED = 517, // InspIRCd-specific. RPL_COMMANDS = 700 }; // Holds a list of disabled commands. typedef std::vector<std::string> CommandList; class ModuleDisable final : public Module { private: CommandList commands; ModeParser::ModeStatus chanmodes; bool fakenonexistent; bool notifyopers; ModeParser::ModeStatus usermodes; void ReadModes(const std::shared_ptr<ConfigTag>& tag, const std::string& field, ModeType type, ModeParser::ModeStatus& status) { for (const auto chr : tag->getString(field)) { // Check that the character is a valid mode letter. if (!ModeParser::IsModeChar(chr)) throw ModuleException(this, "Invalid mode '{}' was specified in <disabled:{}> at {}", chr, field, tag->source.str()); // Check that the mode actually exists. ModeHandler* mh = ServerInstance->Modes.FindMode(chr, type); if (!mh) throw ModuleException(this, "Nonexistent mode '{}' was specified in <disabled:{}> at {}", chr, field, tag->source.str()); // Disable the mode. ServerInstance->Logs.Debug(MODNAME, "The {} ({}) {} mode has been disabled", mh->GetModeChar(), mh->name, type == MODETYPE_CHANNEL ? "channel" : "user"); status.set(ModeParser::GetModeIndex(chr)); } } template <typename... Args> void WriteLog(const char* message, Args&&... args) const { if (notifyopers) ServerInstance->SNO.WriteToSnoMask('a', message, std::forward<Args>(args)...); else ServerInstance->Logs.Normal(MODNAME, message, std::forward<Args>(args)...); } public: ModuleDisable() : Module(VF_VENDOR, "Allows commands, channel modes, and user modes to be disabled.") { } void ReadConfig(ConfigStatus& status) override { const auto& tag = ServerInstance->Config->ConfValue("disabled"); // Parse the disabled commands. CommandList newcommands; irc::spacesepstream commandlist(tag->getString("commands")); for (std::string command; commandlist.GetToken(command); ) { // Check that the command actually exists. Command* handler = ServerInstance->Parser.GetHandler(command); if (!handler) throw ModuleException(this, "Nonexistent command '{}' was specified in <disabled:commands> at {}", command, tag->source.str()); // Prevent admins from disabling MODULES for transparency reasons. if (handler->name == "MODULES") continue; // Disable the command. ServerInstance->Logs.Debug(MODNAME, "The {} command has been disabled", handler->name); newcommands.push_back(handler->name); } // Parse the disabled channel modes. ModeParser::ModeStatus newchanmodes; ReadModes(tag, "chanmodes", MODETYPE_CHANNEL, newchanmodes); // Parse the disabled user modes. ModeParser::ModeStatus newusermodes; ReadModes(tag, "usermodes", MODETYPE_USER, newusermodes); // The server config was valid so we can use these now. chanmodes = newchanmodes; usermodes = newusermodes; commands.swap(newcommands); // Whether we should fake the non-existence of disabled things. fakenonexistent = tag->getBool("fakenonexistent"); // Whether to notify server operators via snomask `a` about the attempted use of disabled commands/modes. notifyopers = tag->getBool("notifyopers"); } ModResult OnNumeric(User* user, const Numeric::Numeric& numeric) override { if (numeric.GetNumeric() != RPL_COMMANDS || numeric.GetParams().empty()) return MOD_RES_PASSTHRU; // The numeric isn't the one we care about. if (!fakenonexistent || !IS_LOCAL(user)) return MOD_RES_PASSTHRU; // We're not hiding the numeric OR the user is remote. if (!stdalgo::isin(commands, numeric.GetParams()[0]) || user->HasPrivPermission("servers/use-disabled-commands")) return MOD_RES_PASSTHRU; // Wrong command or the user is is an exempt oper. return MOD_RES_DENY; } ModResult OnPreCommand(std::string& command, CommandBase::Params& parameters, LocalUser* user, bool validated) override { // If a command is unvalidated or the source is not fully connected we do nothing. if (!validated || !user->IsFullyConnected()) return MOD_RES_PASSTHRU; // If the command is not disabled or the user has the servers/use-disabled-commands priv we do nothing. if (!stdalgo::isin(commands, command) || user->HasPrivPermission("servers/use-disabled-commands")) return MOD_RES_PASSTHRU; // The user has tried to execute a disabled command! user->CommandFloodPenalty += 2000; WriteLog("{} was blocked from executing the disabled {} command", user->GetRealMask(), command); if (fakenonexistent) { // The server administrator has specified that disabled commands should be // treated as if they do not exist. user->WriteNumeric(ERR_UNKNOWNCOMMAND, command, "Unknown command"); ServerInstance->Stats.Unknown++; return MOD_RES_DENY; } // Inform the user that the command they executed has been disabled. user->WriteNumeric(ERR_DISABLED, command, "Command disabled"); return MOD_RES_DENY; } ModResult OnRawMode(User* user, Channel* chan, const Modes::Change& change) override { // If a mode change is remote or the source is not fully connected we do nothing. if (!IS_LOCAL(user) || !user->IsFullyConnected()) return MOD_RES_PASSTHRU; // If the mode is not disabled or the user has the servers/use-disabled-modes priv we do nothing. const ModeParser::ModeStatus& disabled = (change.mh->GetModeType() == MODETYPE_CHANNEL) ? chanmodes : usermodes; if (!disabled.test(ModeParser::GetModeIndex(change.mh->GetModeChar())) || user->HasPrivPermission("servers/use-disabled-modes")) return MOD_RES_PASSTHRU; // The user has tried to change a disabled mode! const char* what = change.mh->GetModeType() == MODETYPE_CHANNEL ? "channel" : "user"; WriteLog("{} was blocked from {}setting the disabled {} mode {} ({})", user->GetRealMask(), change.adding ? "" : "un", what, change.mh->GetModeChar(), change.mh->name); if (fakenonexistent) { // The server administrator has specified that disabled modes should be // treated as if they do not exist. int numeric = (change.mh->GetModeType() == MODETYPE_CHANNEL ? ERR_UNKNOWNMODE : ERR_UNKNOWNSNOMASK); const char* typestr = (change.mh->GetModeType() == MODETYPE_CHANNEL ? "channel" : "user"); user->WriteNumeric(numeric, change.mh->GetModeChar(), INSP_FORMAT("is not a recognised {} mode.", typestr)); return MOD_RES_DENY; } // Inform the user that the mode they changed has been disabled. user->WriteNumeric(ERR_NOPRIVILEGES, INSP_FORMAT("Permission Denied - {} mode {} ({}) is disabled", what, change.mh->GetModeChar(), change.mh->name)); return MOD_RES_DENY; } }; MODULE_INIT(ModuleDisable) �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/src/modules/m_dnsbl.cpp��������������������������������������������������������������0000664�0000000�0000000�00000051234�14771603147�0017735�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2021 Dominic Hamon * Copyright (C) 2020 Matt Schatz <genius3000@g3k.solutions> * Copyright (C) 2018-2019 linuxdaemon <linuxdaemon.irc@gmail.com> * Copyright (C) 2017-2025 Sadie Powell <sadie@witchery.services> * Copyright (C) 2013, 2016 Adam <Adam@anope.org> * Copyright (C) 2013, 2015-2016 Attila Molnar <attilamolnar@hush.com> * Copyright (C) 2012 Robby <robby@chatbelgie.be> * Copyright (C) 2009-2010 Daniel De Graaf <danieldg@inspircd.org> * Copyright (C) 2007 Dennis Friis <peavey@inspircd.org> * Copyright (C) 2007 Craig Edwards <brain@inspircd.org> * Copyright (C) 2006-2007, 2009 Robin Burchell <robin+git@viroteck.net> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #ifndef _WIN32 # include <arpa/inet.h> #endif #include "inspircd.h" #include "extension.h" #include "modules/dns.h" #include "modules/shun.h" #include "modules/stats.h" #include "numerichelper.h" #include "timeutils.h" #include "xline.h" class DNSBLEntry final { public: enum class Action : uint8_t { // G-line users who's IP address is in the DNSBL. GLINE, // Kill users who's IP address is in the DNSBL. KILL, // K-line users who's IP address is in the DNSBL. KLINE, // Mark users who's IP address is in the DNSBL. MARK, // Shun users who's IP address is in the DNSBL. SHUN, // Z-line users who's IP address is in the DNSBL. ZLINE, }; enum class Type : uint8_t { // DNSBL results will be compared against the specified bit mask. BITMASK, // DNSBL results will be compared against a numeric range of values. RECORD, }; // The action to take against users who's IP address is in this DNSBL. Action action; // A bitmask of DNSBL result types to match against. unsigned int bitmask; // The domain name of this DNSBL. std::string domain; // If action is set to mark then a new hostname to set on users who's IP address is in this DNSBL. std::string markhost; // If action is set to mark then a new username to set on users who's IP address is in this DNSBL. std::string markuser; // The human readable name of this DNSBL. std::string name; // A range of DNSBL result types to match against. CharState records; // A map of DNSBL replies to their descriptions. insp::flat_map<uint32_t, std::string> replies; // The message to send to users who's IP address is in a DNSBL. std::string reason; // The number of seconds to wait for a DNSBL request before assuming it has failed. unsigned int timeout; // The type of result that this DNSBL will provide. Type type; // The number of errors which have occurred when querying this DNSBL. unsigned long stats_errors = 0; // The number of hits which have occurred when querying this DNSBL. unsigned long stats_hits = 0; // The number of misses which have occurred when querying this DNSBL. unsigned long stats_misses = 0; // If action is set to gline, kline, or zline then the duration for an X-line to last for. unsigned long xlineduration; DNSBLEntry(const Module* mod, const std::shared_ptr<ConfigTag>& tag) { name = tag->getString("name"); if (name.empty()) throw ModuleException(mod, "<dnsbl:name> can not be empty at " + tag->source.str()); domain = tag->getString("domain"); if (domain.empty()) throw ModuleException(mod, "<dnsbl:domain> can not be empty at " + tag->source.str()); action = tag->getEnum("action", Action::KILL, { { "gline", Action::GLINE }, { "kill", Action::KILL }, { "kline", Action::KLINE }, { "mark", Action::MARK }, { "shun", Action::SHUN }, { "zline", Action::ZLINE }, }); const std::string typestr = tag->getString("type", "record", 1); if (insp::equalsci(typestr, "bitmask")) { type = Type::BITMASK; bitmask = tag->getNum<unsigned int>("bitmask", 0); records = 0; ServerInstance->Logs.Normal(MODNAME, "<dnsbl> tag at {} specifies a bitmask. This is deprecated and will be removed in the next major version of InspIRCd, consider migrating to records instead.", tag->source.str()); } else if (insp::equalsci(typestr, "record")) { type = Type::RECORD; irc::portparser recordrange(tag->getString("records"), false); for (long record = 0; (record = recordrange.GetToken()); ) { if (record < 0 || record > UCHAR_MAX) throw ModuleException(mod, "<dnsbl:records> can only hold records between 0 and 255 at " + tag->source.str()); records.set(record); } if (records.none()) throw ModuleException(mod, "<dnsbl:records> can not be empty at " + tag->source.str()); } else { throw ModuleException(mod, typestr + " is an invalid value for <dnsbl:type>; acceptable values are 'bitmask' or 'records' at " + tag->source.str()); } reason = tag->getString("reason", "Your IP (%ip%) has been blacklisted by the %dnsbl% DNSBL.", 1, ServerInstance->Config->Limits.MaxLine); timeout = static_cast<unsigned int>(tag->getDuration("timeout", 0, 1, 60)); markuser = tag->getString("user", tag->getString("ident")); markhost = tag->getString("host"); xlineduration = tag->getDuration("duration", 60*60, 1); } }; class DNSBLMask final { public: // The username to give a user because they were in a DNSBL (<dnsbl:user>). std::string user; // The hostname to give a user because they were in a DNSBL (<dnsbl:host>). std::string host; // The reason why the user was given this user@host (<dnsbl:reason>). std::string reason; DNSBLMask(const std::shared_ptr<DNSBLEntry>& cfg, const std::string& msg) : user(cfg->markuser) , host(cfg->markhost) , reason(msg) { } }; typedef std::vector<std::shared_ptr<DNSBLEntry>> DNSBLEntries; typedef SimpleExtItem<DNSBLMask> MaskExtItem; typedef ListExtItem<std::vector<std::string>> MarkExtItem; // Data which is shared with DNS lookup classes. class SharedData final { private: std::string ReverseIP(const irc::sockets::sockaddrs& sa) { switch (sa.family()) { case AF_INET: { auto a = (unsigned int) sa.in4.sin_addr.s_addr & 0xFF; auto b = (unsigned int) (sa.in4.sin_addr.s_addr >> 8) & 0xFF; auto c = (unsigned int) (sa.in4.sin_addr.s_addr >> 16) & 0xFF; auto d = (unsigned int) (sa.in4.sin_addr.s_addr >> 24) & 0xFF; return INSP_FORMAT("{}.{}.{}.{}", d, c, b, a); } case AF_INET6: { const std::string hexaddr = Hex::Encode(sa.in6.sin6_addr.s6_addr, 16); std::string reversedip; reversedip.reserve(hexaddr.length() * 2); for (const auto hexchr : insp::reverse_range(hexaddr)) { reversedip.push_back(hexchr); reversedip.push_back('.'); } reversedip.pop_back(); return reversedip; } default: break; } // Clients can't be in a DNSBL if they aren't connected via IPv4 or IPv6. return {}; } public: // Counts the number of DNSBL lookups waiting for this user. IntExtItem countext; // Reference to the DNS manager. DNS::ManagerRef dns; // The DNSBL entries from the config. DNSBLEntries dnsbls; // The DNSBL marks which are set on a user. MarkExtItem markext; // The user@host to set on a marked user when they are connected. MaskExtItem maskext; SharedData(Module* mod) : countext(mod, "dnsbl-pending", ExtensionType::USER) , dns(mod) , markext(mod, "dnsbl-match", ExtensionType::USER) , maskext(mod, "dnsbl-mask", ExtensionType::USER) { } // Performs one or more DNSBL lookups on the specified user. void Lookup(LocalUser* user); }; class DNSBLResolver final : public DNS::Request { private: std::shared_ptr<DNSBLEntry> config; SharedData& data; const irc::sockets::sockaddrs sa; const std::string uuid; template <typename Line, typename... Extra> void AddLine(const char* type, const std::string& reason, unsigned long duration, LocalUser* user, Extra&&... extra) { if (user->exempt) return; // This user shouldn't be banned. auto line = new Line(ServerInstance->Time(), duration, MODNAME "@" + ServerInstance->Config->ServerName, reason, std::forward<Extra>(extra)...); if (!ServerInstance->XLines->AddLine(line, nullptr)) { ServerInstance->Users.QuitUser(user, "Killed (" + reason + ")"); delete line; return; } ServerInstance->SNO.WriteToSnoMask('x', "{} added a timed {} on {}, expires in {} (on {}): {}", line->source, type, line->Displayable(), Duration::ToLongString(line->duration), Time::ToString(line->expiry), line->reason); ServerInstance->XLines->ApplyLines(); } public: DNSBLResolver(Module* mod, SharedData& sd, const std::string& hostname, LocalUser* u, const std::shared_ptr<DNSBLEntry>& cfg) : DNS::Request(*sd.dns, mod, hostname, DNS::QUERY_A, true, cfg->timeout) , config(cfg) , data(sd) , sa(u->client_sa) , uuid(u->uuid) { } /* Note: This may be called multiple times for multiple A record results */ void OnLookupComplete(const DNS::Query* r) override { /* Check the user still exists */ LocalUser* them = ServerInstance->Users.FindUUID<LocalUser>(uuid); if (!them || them->client_sa != sa) { config->stats_misses++; return; } intptr_t i = data.countext.Get(them); if (i) data.countext.Set(them, i - 1); // The DNSBL reply must contain an A result. const DNS::ResourceRecord* const ans_record = r->FindAnswerOfType(DNS::QUERY_A); if (!ans_record) { config->stats_errors++; ServerInstance->SNO.WriteGlobalSno('d', "{} returned an result with no IPv4 address.", config->name); return; } // The DNSBL reply must be a valid IPv4 address. in_addr resultip; if (inet_pton(AF_INET, ans_record->rdata.c_str(), &resultip) != 1) { config->stats_errors++; ServerInstance->SNO.WriteGlobalSno('d', "{} returned an invalid IPv4 address: {}", config->name, ans_record->rdata); return; } // The DNSBL reply should be in the 127.0.0.0/8 range. if ((resultip.s_addr & 0xFF) != 127) { config->stats_errors++; ServerInstance->SNO.WriteGlobalSno('d', "{} returned an IPv4 address which is outside of the 127.0.0.0/8 subnet: {}", config->name, ans_record->rdata); return; } bool match = false; unsigned int result = 0; switch (config->type) { case DNSBLEntry::Type::BITMASK: { result = (resultip.s_addr >> 24) & config->bitmask; match = (result != 0); break; } case DNSBLEntry::Type::RECORD: { result = resultip.s_addr >> 24; match = (config->records[result] == 1); break; } } if (match) { const auto it = config->replies.find(result); const auto reasonstr = it == config->replies.end() ? INSP_FORMAT("Result {}", result) : it->second; const std::string reason = Template::Replace(config->reason, { { "dnsbl", config->name }, { "dnsbl.url", Percent::Encode(config->name) }, { "ip", them->GetAddress() }, { "network", ServerInstance->Config->Network }, { "network.url", Percent::Encode(ServerInstance->Config->Network) }, { "reason", reasonstr }, { "result", ConvToStr(result) }, }); config->stats_hits++; switch (config->action) { case DNSBLEntry::Action::KILL: { if (!them->exempt) ServerInstance->Users.QuitUser(them, "Killed (" + reason + ")"); break; } case DNSBLEntry::Action::MARK: { if (!config->markuser.empty() || !config->markhost.empty()) { // Store the u@h mask for later to avoid being overwritten by username/hostname lookups. data.maskext.SetFwd(them, config, reason); // If the user is already connected we should just do this now. if (them->IsFullyConnected()) creator->OnUserConnect(them); } data.markext.GetRef(them).push_back(config->name); break; } case DNSBLEntry::Action::KLINE: { AddLine<KLine>("K-line", reason, config->xlineduration, them, them->GetBanUser(true), them->GetAddress()); break; } case DNSBLEntry::Action::GLINE: { AddLine<GLine>("G-line", reason, config->xlineduration, them, them->GetBanUser(true), them->GetAddress()); break; } case DNSBLEntry::Action::ZLINE: { AddLine<ZLine>("Z-line", reason, config->xlineduration, them, them->GetAddress()); break; } case DNSBLEntry::Action::SHUN: { AddLine<Shun>("Shun", reason, config->xlineduration, them, them->GetAddress()); break; } } ServerInstance->SNO.WriteGlobalSno('d', "{} {} ({}) detected as being on the '{}' DNSBL: {}{}", them->IsFullyConnected() ? "User" : "Connecting user", them->GetRealMask(), them->GetAddress(), config->name, reasonstr, them->exempt ? " -- exempt" : ""); } else config->stats_misses++; } void OnError(const DNS::Query* q) override { bool is_miss = true; switch (q->error) { case DNS::ERROR_NO_RECORDS: case DNS::ERROR_DOMAIN_NOT_FOUND: config->stats_misses++; break; default: config->stats_errors++; is_miss = false; break; } LocalUser* them = ServerInstance->Users.FindUUID<LocalUser>(uuid); if (!them || them->client_sa != sa) return; intptr_t i = data.countext.Get(them); if (i) data.countext.Set(them, i - 1); if (is_miss) return; ServerInstance->SNO.WriteGlobalSno('d', "An error occurred whilst checking whether {} ({}) is on the '{}' DNSBL: {}", them->GetRealMask(), them->GetAddress(), config->name, data.dns->GetErrorStr(q->error)); } }; class CommandDNSBL final : public Command { private: SharedData& data; public: CommandDNSBL(Module* mod, SharedData& sd) : Command(mod, "DNSBL", 1, 2) , data(sd) { access_needed = CmdAccess::OPERATOR; syntax = { "[<nick> [<reason>]]" }; translation = { TR_NICK, TR_TEXT }; } CmdResult Handle(User* user, const Params& parameters) override { User* target; if (IS_LOCAL(user)) target = ServerInstance->Users.FindNick(parameters[0], true); else target = ServerInstance->Users.FindUUID(parameters[0], true); // We couldn't find the user so just give up. if (!target) { user->WriteNumeric(Numerics::NoSuchNick(parameters[0])); return CmdResult::FAILURE; } auto* ltarget = IS_LOCAL(target); if (!ltarget) return CmdResult::SUCCESS; // The user is on another server so just let it forward. intptr_t count = data.countext.Get(ltarget); if (count) { // TODO: replace this with a FAIL stdrpl when we can network those. user->WriteRemoteNotice("*** DNSBL: Unable to recheck {}: still waiting on {} DNSBLs from the previous check.", ltarget->nick, count); return CmdResult::FAILURE; } // TODO: replace this with a NOTE stdrpl when we can network those. user->WriteRemoteNotice("*** DNSBL: Rechecking {} against {} DNSBLs.", ltarget->nick, data.dnsbls.size()); const bool has_reason = parameters.size() > 1; ServerInstance->SNO.WriteGlobalSno('d', "{} is rechecking whether {} ({}) is in a DNSBL{}{}", user->nick, ltarget->nick, ltarget->GetAddress(), has_reason ? ": " : "", has_reason ? parameters[1] : "."); data.Lookup(ltarget); return CmdResult::SUCCESS; } RouteDescriptor GetRouting(User* user, const Params& parameters) override { return ROUTE_OPT_UCAST(parameters[0]); } }; void SharedData::Lookup(LocalUser* user) { if (!dns) return; // The core_dns module is not loaded. if (!user->GetClass()->config->getBool("usednsbl", true)) return; // The user's class is exempt from DNSBL lookups. const std::string reversedip = ReverseIP(user->client_sa); ServerInstance->Logs.Debug(MODNAME, "Reversed IP {} => {}", user->GetAddress(), reversedip); countext.Set(user, dnsbls.size()); // For each DNSBL, we will run through this lookup for (const auto& dnsbl : dnsbls) { // Fill hostname with a dnsbl style host (d.c.b.a.domain.tld) const std::string hostname = reversedip + "." + dnsbl->domain; // Try to do the DNSBL lookup. auto* r = new DNSBLResolver(dns->creator, *this, hostname, user, dnsbl); try { dns->Process(r); } catch (const DNS::Exception& ex) { delete r; ServerInstance->Logs.Debug(MODNAME, "DNSBL lookup error: {}", ex.GetReason()); } if (user->quitting) break; // DNS resolver found a cached hit. } } class ModuleDNSBL final : public Module , public Stats::EventListener { private: SharedData data; CommandDNSBL cmd; public: ModuleDNSBL() : Module(VF_VENDOR, "Allows the server administrator to check the IP address of connecting users against a DNSBL.") , Stats::EventListener(this) , data(this) , cmd(this, data) { } void init() override { ServerInstance->SNO.EnableSnomask('d', "DNSBL"); } void Prioritize() override { Module* corexline = ServerInstance->Modules.Find("core_xline"); ServerInstance->Modules.SetPriority(this, I_OnChangeRemoteAddress, PRIORITY_AFTER, corexline); } void ReadConfig(ConfigStatus& status) override { DNSBLEntries newdnsbls; for (const auto& [_, tag] : ServerInstance->Config->ConfTags("dnsbl")) { auto entry = std::make_shared<DNSBLEntry>(this, tag); newdnsbls.push_back(entry); } for (const auto& [_, tag] : ServerInstance->Config->ConfTags("dnsblreply")) { const auto dnsblname = tag->getString("name"); auto dnsbl = std::find_if(newdnsbls.begin(), newdnsbls.end(), [&dnsblname](const auto& d) { return insp::equalsci(d->name, dnsblname); }); if (dnsbl == newdnsbls.end()) throw ModuleException(this, "<dnsblreply:name> must be set to the name of a DNSBL at " + tag->source.str()); const auto dnsbldesc = tag->getString("description"); if (dnsbldesc.empty()) throw ModuleException(this, "<dnsblreply:description> must not be empty at " + tag->source.str()); const auto dnsblreply = tag->getNum<uint32_t>("reply", std::numeric_limits<uint32_t>::max()); if (dnsblreply > 16'777'215) { throw ModuleException(this, "<dnsblreply:reply> ({}) is not a valid DNSBL reply at {}", dnsblreply, tag->source.str()); } (*dnsbl)->replies[dnsblreply] = dnsbldesc; } data.dnsbls.swap(newdnsbls); } void OnChangeRemoteAddress(LocalUser* user) override { if (!user->quitting && user->GetClass()) data.Lookup(user); } ModResult OnPreChangeConnectClass(LocalUser* user, const std::shared_ptr<ConnectClass>& klass, std::optional<Numeric::Numeric>& errnum) override { const std::string dnsbl = klass->config->getString("dnsbl"); if (dnsbl.empty()) return MOD_RES_PASSTHRU; MarkExtItem::List* match = data.markext.Get(user); if (!match) { ServerInstance->Logs.Debug("CONNECTCLASS", "The {} connect class is not suitable as it requires a DNSBL mark.", klass->GetName()); return MOD_RES_DENY; } for (const auto& mark : *match) { if (InspIRCd::Match(mark, dnsbl)) return MOD_RES_PASSTHRU; } ServerInstance->Logs.Debug("CONNECTCLASS", "The {} connect class is not suitable as the DNSBL marks ({}) do not match {}.", klass->GetName(), insp::join(*match, ", "), dnsbl); return MOD_RES_DENY; } ModResult OnCheckReady(LocalUser* user) override { // Block until all of the DNSBL lookups are complete. return data.countext.Get(user) ? MOD_RES_DENY : MOD_RES_PASSTHRU; } void OnUserConnect(LocalUser* user) override { DNSBLMask* ih = data.maskext.Get(user); if (ih) { if (!ih->user.empty()) { user->ChangeDisplayedUser(ih->user); user->WriteNotice("Your username has been set to " + ih->user + ": " + ih->reason); } if (!ih->host.empty()) { user->ChangeDisplayedHost(ih->host); user->WriteNotice("Your hostname has been set to " + ih->host + ": " + ih->reason); } data.maskext.Unset(user); } } ModResult OnStats(Stats::Context& stats) override { if (stats.GetSymbol() != 'd') return MOD_RES_PASSTHRU; unsigned long total_hits = 0; unsigned long total_misses = 0; unsigned long total_errors = 0; for (const auto& dnsbl : data.dnsbls) { total_hits += dnsbl->stats_hits; total_misses += dnsbl->stats_misses; total_errors += dnsbl->stats_errors; stats.AddGenericRow(INSP_FORMAT("The \"{}\" DNSBL had {} hits, {} misses, and {} errors", dnsbl->name, dnsbl->stats_hits, dnsbl->stats_misses, dnsbl->stats_errors)); } stats.AddGenericRow(INSP_FORMAT("Total DNSBL hits: {}", total_hits)); stats.AddGenericRow(INSP_FORMAT("Total DNSBL misses: {}", total_misses)); stats.AddGenericRow(INSP_FORMAT("Total DNSBL errors: {}", total_errors)); return MOD_RES_DENY; } }; MODULE_INIT(ModuleDNSBL) ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/src/modules/m_exemptchanops.cpp������������������������������������������������������0000664�0000000�0000000�00000011756�14771603147�0021516�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2017-2023 Sadie Powell <sadie@witchery.services> * Copyright (C) 2013-2014 Attila Molnar <attilamolnar@hush.com> * Copyright (C) 2012 Robby <robby@chatbelgie.be> * Copyright (C) 2009-2010 Daniel De Graaf <danieldg@inspircd.org> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include "inspircd.h" #include "listmode.h" #include "modules/exemption.h" #include "numerichelper.h" enum { RPL_ENDOFEXEMPTIONLIST = 953, RPL_EXEMPTIONLIST = 954 }; class ExemptChanOps final : public ListModeBase { public: ExemptChanOps(Module* Creator) : ListModeBase(Creator, "exemptchanops", 'X', RPL_EXEMPTIONLIST, RPL_ENDOFEXEMPTIONLIST) { syntax = "<restriction>:<prefix>"; } static PrefixMode* FindMode(const std::string& pmode) { if (pmode.length() == 1) { PrefixMode* pm = ServerInstance->Modes.FindPrefixMode(pmode[0]); if (!pm) pm = ServerInstance->Modes.FindPrefix(pmode[0]); return pm; } ModeHandler* mh = ServerInstance->Modes.FindMode(pmode, MODETYPE_CHANNEL); return mh ? mh->IsPrefixMode() : nullptr; } static bool ParseEntry(const std::string& entry, std::string& restriction, std::string& prefix) { // The entry must be in the format <restriction>:<prefix>. std::string::size_type colon = entry.find(':'); if (colon == std::string::npos || colon == entry.length()-1) return false; restriction.assign(entry, 0, colon); prefix.assign(entry, colon + 1, std::string::npos); return true; } ModResult AccessCheck(User* source, Channel* channel, Modes::Change& change) override { std::string restriction; std::string prefix; if (!ParseEntry(change.param, restriction, prefix)) return MOD_RES_PASSTHRU; PrefixMode* pm = FindMode(prefix); if (!pm) return MOD_RES_PASSTHRU; if (channel->GetPrefixValue(source) >= pm->GetLevelRequired(change.adding)) return MOD_RES_PASSTHRU; source->WriteNumeric(ERR_CHANOPRIVSNEEDED, channel->name, INSP_FORMAT("You must be able to {} mode {} ({}) to {} a restriction containing it", change.adding ? "set" : "unset", pm->GetModeChar(), pm->name, change.adding ? "add" : "remove")); return MOD_RES_DENY; } bool ValidateParam(LocalUser* user, Channel* chan, std::string& parameter) override { // We only enforce the format restriction against local users to avoid causing a desync. std::string restriction; std::string prefix; if (!ParseEntry(parameter, restriction, prefix)) { user->WriteNumeric(Numerics::InvalidModeParameter(chan, this, parameter)); return false; } // If there is a '-' in the restriction string ignore it and everything after it // to support "auditorium-vis" and "auditorium-see" in m_auditorium std::string::size_type dash = restriction.find('-'); if (dash != std::string::npos) restriction.erase(dash); if (!ServerInstance->Modes.FindMode(restriction, MODETYPE_CHANNEL)) { user->WriteNumeric(Numerics::InvalidModeParameter(chan, this, parameter, "Unknown restriction.")); return false; } if (prefix != "*" && !FindMode(prefix)) { user->WriteNumeric(Numerics::InvalidModeParameter(chan, this, parameter, "Unknown prefix mode.")); return false; } return true; } }; class ExemptHandler final : public CheckExemption::EventListener { public: ExemptChanOps ec; ExemptHandler(Module* me) : CheckExemption::EventListener(me) , ec(me) { } ModResult OnCheckExemption(User* user, Channel* chan, const std::string& restriction) override { ModeHandler::Rank mypfx = chan->GetPrefixValue(user); std::string minmode; ListModeBase::ModeList* list = ec.GetList(chan); if (list) { for (const auto& entry : *list) { std::string::size_type pos = entry.mask.find(':'); if (pos == std::string::npos) continue; if (!entry.mask.compare(0, pos, restriction)) minmode.assign(entry.mask, pos + 1, std::string::npos); } } PrefixMode* mh = ExemptChanOps::FindMode(minmode); if (mh && mypfx >= mh->GetPrefixRank()) return MOD_RES_ALLOW; if (mh || minmode == "*") return MOD_RES_DENY; return MOD_RES_PASSTHRU; } }; class ModuleExemptChanOps final : public Module { private: ExemptHandler eh; public: ModuleExemptChanOps() : Module(VF_VENDOR, "Adds channel mode X (exemptchanops) which allows channel operators to grant exemptions to various channel-level restrictions.") , eh(this) { } void ReadConfig(ConfigStatus& status) override { eh.ec.DoRehash(); } }; MODULE_INIT(ModuleExemptChanOps) ������������������inspircd-4.7.0/src/modules/m_filter.cpp�������������������������������������������������������������0000664�0000000�0000000�00000075266�14771603147�0020133�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2021 Herman <GermanAizek@yandex.ru> * Copyright (C) 2019 Matt Schatz <genius3000@g3k.solutions> * Copyright (C) 2019 Filippo Cortigiani <simos@simosnap.org> * Copyright (C) 2018-2019 linuxdaemon <linuxdaemon.irc@gmail.com> * Copyright (C) 2018 Michael Hazell <michaelhazell@hotmail.com> * Copyright (C) 2017 B00mX0r <b00mx0r@aureus.pw> * Copyright (C) 2012-2014, 2016 Attila Molnar <attilamolnar@hush.com> * Copyright (C) 2012-2013, 2017-2025 Sadie Powell <sadie@witchery.services> * Copyright (C) 2012, 2018-2019 Robby <robby@chatbelgie.be> * Copyright (C) 2011 Adam <Adam@anope.org> * Copyright (C) 2009-2010 Daniel De Graaf <danieldg@inspircd.org> * Copyright (C) 2009 Robin Burchell <robin+git@viroteck.net> * Copyright (C) 2009 Matt Smith <dz@inspircd.org> * Copyright (C) 2009 John Brooks <john@jbrooks.io> * Copyright (C) 2007 Dennis Friis <peavey@inspircd.org> * Copyright (C) 2006-2009 Craig Edwards <brain@inspircd.org> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include "inspircd.h" #include "modules/account.h" #include "modules/regex.h" #include "modules/server.h" #include "modules/shun.h" #include "modules/stats.h" #include "numerichelper.h" #include "timeutils.h" #include "utility/string.h" #include "xline.h" #include <fstream> enum FilterFlags { FLAG_PART = 2, FLAG_QUIT = 4, FLAG_PRIVMSG = 8, FLAG_NOTICE = 16 }; enum FilterAction { FA_GLINE, FA_ZLINE, FA_WARN, FA_BLOCK, FA_SILENT, FA_KILL, FA_SHUN, FA_NONE }; static Module* thismod; class FilterResult final { public: Regex::PatternPtr regex; std::string freeform; std::string reason; FilterAction action; unsigned long duration; bool from_config; bool flag_no_opers; bool flag_part_message; bool flag_quit_message; bool flag_privmsg; bool flag_notice; bool flag_strip_color; bool flag_no_registered; FilterResult(Regex::EngineReference& RegexEngine, const std::string& free, const std::string& rea, FilterAction act, unsigned long gt, const std::string& fla, bool cfg, bool ef) : freeform(free) , reason(rea) , action(act) , duration(gt) , from_config(cfg) { if (!RegexEngine) throw ModuleException(thismod, "Regex module implementing '"+RegexEngine.GetProvider()+"' is not loaded!"); regex = ef ? RegexEngine->CreateHuman(free) : RegexEngine->Create(free); this->FillFlags(fla); } char FillFlags(const std::string& flags) { flag_no_opers = flag_part_message = flag_quit_message = flag_privmsg = flag_notice = flag_strip_color = flag_no_registered = false; for (const auto flag : flags) { switch (flag) { case 'o': flag_no_opers = true; break; case 'P': flag_part_message = true; break; case 'q': flag_quit_message = true; break; case 'p': flag_privmsg = true; break; case 'n': flag_notice = true; break; case 'c': flag_strip_color = true; break; case 'r': flag_no_registered = true; break; case '*': flag_no_opers = flag_part_message = flag_quit_message = flag_privmsg = flag_notice = flag_strip_color = true; break; default: return flag; } } return 0; } std::string GetFlags() const { std::string flags; if (flag_no_opers) flags.push_back('o'); if (flag_part_message) flags.push_back('P'); if (flag_quit_message) flags.push_back('q'); if (flag_privmsg) flags.push_back('p'); if (flag_notice) flags.push_back('n'); /* Order is important here, as the logic in FillFlags() stops parsing when it encounters * an unknown character. So the following characters must be last in the string. * 'c' is unsupported on < 2.0.10 * 'r' is unsupported on < 3.2.0 */ if (flag_strip_color) flags.push_back('c'); if (flag_no_registered) flags.push_back('r'); if (flags.empty()) flags.push_back('-'); return flags; } FilterResult() = default; }; class CommandFilter final : public Command { public: CommandFilter(Module* f) : Command(f, "FILTER", 1, 5) { access_needed = CmdAccess::OPERATOR; this->syntax = { "<pattern> [<action> <flags> [<duration>] :<reason>]" }; } CmdResult Handle(User* user, const Params& parameters) override; RouteDescriptor GetRouting(User* user, const Params& parameters) override { return ROUTE_BROADCAST; } }; class ModuleFilter final : public Module , public ServerProtocol::SyncEventListener , public Stats::EventListener , public Timer { private: typedef insp::flat_set<std::string, irc::insensitive_swo> ExemptTargetSet; Account::API accountapi; bool initing = true; bool enableflags; bool notifyuser; bool warnonselfmsg; bool dirty = false; std::string filterconf; Regex::Engine* factory; unsigned long saveperiod; unsigned long maxbackoff; unsigned char backoff; void FreeFilters(); public: CommandFilter filtcommand; Regex::EngineReference RegexEngine; std::vector<FilterResult> filters; int flags; // List of channel names excluded from filtering. ExemptTargetSet exemptedchans; // List of target nicknames excluded from filtering. ExemptTargetSet exemptednicks; ModuleFilter(); void init() override; Cullable::Result Cull() override; ModResult OnUserPreMessage(User* user, MessageTarget& target, MessageDetails& details) override; const FilterResult* FilterMatch(User* user, const std::string& text, int flags); bool DeleteFilter(const std::string& freeform, std::string& reason); std::pair<bool, std::string> AddFilter(const std::string& freeform, FilterAction type, const std::string& reason, unsigned long duration, const std::string& flags, bool config = false); void ReadConfig(ConfigStatus& status) override; void CompareLinkData(const LinkData& otherdata, LinkDataDiff& diffs) override; void GetLinkData(LinkData& data, std::string& compatdata) override; static std::string EncodeFilter(const FilterResult& filter); FilterResult DecodeFilter(const std::string& data); void OnSyncNetwork(Server& server) override; void OnDecodeMetadata(Extensible* target, const std::string& extname, const std::string& extdata) override; ModResult OnStats(Stats::Context& stats) override; ModResult OnPreCommand(std::string& command, CommandBase::Params& parameters, LocalUser* user, bool validated) override; void OnUnloadModule(Module* mod) override; bool Tick() override; bool WriteDatabase(); bool AppliesToMe(User* user, const FilterResult& filter, int flags); void ReadFilters(); static bool StringToFilterAction(const std::string& str, FilterAction& fa); static std::string FilterActionToString(FilterAction fa); }; CmdResult CommandFilter::Handle(User* user, const Params& parameters) { if (parameters.size() == 1) { /* Deleting a filter */ Module* me = creator; std::string reason; if (static_cast<ModuleFilter*>(me)->DeleteFilter(parameters[0], reason)) { user->WriteNotice("*** Removed filter '" + parameters[0] + "': " + reason); ServerInstance->SNO.WriteToSnoMask(IS_LOCAL(user) ? 'f' : 'F', "{} removed filter '{}': {}", user->nick, parameters[0], reason); return CmdResult::SUCCESS; } else { user->WriteNotice("*** Filter '" + parameters[0] + "' not found on the list."); return CmdResult::FAILURE; } } else { /* Adding a filter */ if (parameters.size() >= 4) { const std::string& freeform = parameters[0]; FilterAction type; const std::string& flags = parameters[2]; unsigned int reasonindex; unsigned long duration = 0; if (!ModuleFilter::StringToFilterAction(parameters[1], type)) { if (ServerInstance->XLines->GetFactory("SHUN")) user->WriteNotice("*** Invalid filter type '" + parameters[1] + "'. Supported types are 'gline', 'zline', 'none', 'warn', 'block', 'silent', 'kill', and 'shun'."); else user->WriteNotice("*** Invalid filter type '" + parameters[1] + "'. Supported types are 'gline', 'zline', 'none', 'warn', 'block', 'silent', and 'kill'."); return CmdResult::FAILURE; } if (type == FA_GLINE || type == FA_ZLINE || type == FA_SHUN) { if (parameters.size() >= 5) { if (!Duration::TryFrom(parameters[3], duration)) { user->WriteNotice("*** Invalid duration for filter"); return CmdResult::FAILURE; } reasonindex = 4; } else { user->WriteNotice("*** Not enough parameters: When setting a '" + parameters[1] + "' type filter, a duration must be specified as the third parameter."); return CmdResult::FAILURE; } } else { reasonindex = 3; } Module* me = creator; std::pair<bool, std::string> result = static_cast<ModuleFilter*>(me)->AddFilter(freeform, type, parameters[reasonindex], duration, flags); if (result.first) { const std::string message = INSP_FORMAT("'{}', type '{}'{}, flags '{}', reason: {}", freeform, parameters[1], (duration ? INSP_FORMAT(", duration '{}'", Duration::ToLongString(duration)) : ""), flags, parameters[reasonindex]); user->WriteNotice("*** Added filter " + message); ServerInstance->SNO.WriteToSnoMask(IS_LOCAL(user) ? 'f' : 'F', "{} added filter {}", user->nick, message); return CmdResult::SUCCESS; } else { user->WriteNotice("*** Filter '" + freeform + "' could not be added: " + result.second); return CmdResult::FAILURE; } } else { user->WriteNotice("*** Not enough parameters."); return CmdResult::FAILURE; } } } bool ModuleFilter::AppliesToMe(User* user, const FilterResult& filter, int iflags) { if ((filter.flag_no_opers) && user->IsOper()) return false; if ((filter.flag_no_registered) && accountapi && accountapi->GetAccountName(user)) return false; if ((iflags & FLAG_PRIVMSG) && (!filter.flag_privmsg)) return false; if ((iflags & FLAG_NOTICE) && (!filter.flag_notice)) return false; if ((iflags & FLAG_QUIT) && (!filter.flag_quit_message)) return false; if ((iflags & FLAG_PART) && (!filter.flag_part_message)) return false; return true; } ModuleFilter::ModuleFilter() : Module(VF_VENDOR | VF_COMMON, "Adds the /FILTER command which allows server operators to define regex matches for inappropriate phrases that are not allowed to be used in channel messages, private messages, part messages, or quit messages.") , ServerProtocol::SyncEventListener(this) , Stats::EventListener(this) , Timer(0, true) , accountapi(this) , filtcommand(this) , RegexEngine(this) { thismod = this; } void ModuleFilter::init() { ServerInstance->SNO.EnableSnomask('f', "FILTER"); } Cullable::Result ModuleFilter::Cull() { FreeFilters(); return Module::Cull(); } void ModuleFilter::FreeFilters() { filters.clear(); dirty = true; } ModResult ModuleFilter::OnUserPreMessage(User* user, MessageTarget& msgtarget, MessageDetails& details) { // Leave remote users and servers alone if (!IS_LOCAL(user)) return MOD_RES_PASSTHRU; flags = (details.type == MessageType::PRIVMSG) ? FLAG_PRIVMSG : FLAG_NOTICE; const FilterResult* f = this->FilterMatch(user, details.text, flags); if (f) { bool is_selfmsg = false; switch (msgtarget.type) { case MessageTarget::TYPE_USER: { const auto* t = msgtarget.Get<User>(); // Check if the target nick is exempted, if yes, ignore this message if (exemptednicks.count(t->nick)) return MOD_RES_PASSTHRU; if (user == t) is_selfmsg = true; break; } case MessageTarget::TYPE_CHANNEL: { const auto* t = msgtarget.Get<Channel>(); if (exemptedchans.count(t->name)) return MOD_RES_PASSTHRU; break; } case MessageTarget::TYPE_SERVER: return MOD_RES_PASSTHRU; } if (is_selfmsg && warnonselfmsg) { ServerInstance->SNO.WriteGlobalSno('f', "WARNING: {}'s self message matched {} ({})", user->nick, f->freeform, f->reason); return MOD_RES_PASSTHRU; } else if (f->action == FA_WARN) { ServerInstance->SNO.WriteGlobalSno('f', "WARNING: {}'s message to {} matched {} ({})", user->nick, msgtarget.GetName(), f->freeform, f->reason); return MOD_RES_PASSTHRU; } else if (f->action == FA_BLOCK) { ServerInstance->SNO.WriteGlobalSno('f', "{} had their message to {} filtered as it matched {} ({})", user->nick, msgtarget.GetName(), f->freeform, f->reason); if (notifyuser) { if (msgtarget.type == MessageTarget::TYPE_CHANNEL) user->WriteNumeric(Numerics::CannotSendTo(msgtarget.Get<Channel>(), INSP_FORMAT("Your message to this channel was blocked: {}.", f->reason))); else user->WriteNumeric(Numerics::CannotSendTo(msgtarget.Get<User>(), INSP_FORMAT("Your message to this user was blocked: {}.", f->reason))); } else details.echo_original = true; } else if (f->action == FA_SILENT) { if (notifyuser) { if (msgtarget.type == MessageTarget::TYPE_CHANNEL) user->WriteNumeric(Numerics::CannotSendTo(msgtarget.Get<Channel>(), INSP_FORMAT("Your message to this channel was blocked: {}.", f->reason))); else user->WriteNumeric(Numerics::CannotSendTo(msgtarget.Get<User>(), INSP_FORMAT("Your message to this user was blocked: {}.", f->reason))); } else details.echo_original = true; } else if (f->action == FA_KILL) { ServerInstance->SNO.WriteGlobalSno('f', "{} was killed because their message to {} matched {} ({})", user->nick, msgtarget.GetName(), f->freeform, f->reason); ServerInstance->Users.QuitUser(user, "Filtered: " + f->reason); } else if (f->action == FA_SHUN && (ServerInstance->XLines->GetFactory("SHUN"))) { auto* sh = new Shun(ServerInstance->Time(), f->duration, MODNAME "@" + ServerInstance->Config->ServerName, f->reason, user->GetAddress()); ServerInstance->SNO.WriteGlobalSno('f', "{} ({}) was shunned for {} (expires on {}) because their message to {} matched {} ({})", user->nick, sh->Displayable(), Duration::ToLongString(f->duration), Time::FromNow(f->duration), msgtarget.GetName(), f->freeform, f->reason); if (ServerInstance->XLines->AddLine(sh, nullptr)) { ServerInstance->XLines->ApplyLines(); } else delete sh; } else if (f->action == FA_GLINE) { auto* gl = new GLine(ServerInstance->Time(), f->duration, MODNAME "@" + ServerInstance->Config->ServerName, f->reason, "*", user->GetAddress()); ServerInstance->SNO.WriteGlobalSno('f', "{} ({}) was G-lined for {} (expires on {}) because their message to {} matched {} ({})", user->nick, gl->Displayable(), Duration::ToLongString(f->duration), Time::FromNow(f->duration), msgtarget.GetName(), f->freeform, f->reason); if (ServerInstance->XLines->AddLine(gl, nullptr)) { ServerInstance->XLines->ApplyLines(); } else delete gl; } else if (f->action == FA_ZLINE) { auto* zl = new ZLine(ServerInstance->Time(), f->duration, MODNAME "@" + ServerInstance->Config->ServerName, f->reason, user->GetAddress()); ServerInstance->SNO.WriteGlobalSno('f', "{} ({}) was Z-lined for {} (expires on {}) because their message to {} matched {} ({})", user->nick, zl->Displayable(), Duration::ToLongString(f->duration), Time::FromNow(f->duration), msgtarget.GetName(), f->freeform, f->reason); if (ServerInstance->XLines->AddLine(zl, nullptr)) { ServerInstance->XLines->ApplyLines(); } else delete zl; } ServerInstance->Logs.Normal(MODNAME, user->nick + " had their message filtered, target was " + msgtarget.GetName() + ": " + f->reason + " Action: " + ModuleFilter::FilterActionToString(f->action)); return MOD_RES_DENY; } return MOD_RES_PASSTHRU; } ModResult ModuleFilter::OnPreCommand(std::string& command, CommandBase::Params& parameters, LocalUser* user, bool validated) { if (validated) { flags = 0; bool parting; if (command == "QUIT") { /* QUIT with no reason: nothing to do */ if (parameters.empty()) return MOD_RES_PASSTHRU; parting = false; flags = FLAG_QUIT; } else if (command == "PART") { /* PART with no reason: nothing to do */ if (parameters.size() < 2) return MOD_RES_PASSTHRU; if (exemptedchans.count(parameters[0])) return MOD_RES_PASSTHRU; parting = true; flags = FLAG_PART; } else /* We're only messing with PART and QUIT */ return MOD_RES_PASSTHRU; const FilterResult* f = this->FilterMatch(user, parameters[parting ? 1 : 0], flags); if (!f) /* PART or QUIT reason doesnt match a filter */ return MOD_RES_PASSTHRU; /* We cant block a part or quit, so instead we change the reason to 'Reason filtered' */ parameters[parting ? 1 : 0] = "Reason filtered"; /* We're warning or blocking, OR they're quitting and its a KILL action * (we cant kill someone who's already quitting, so filter them anyway) */ if ((f->action == FA_WARN) || (f->action == FA_BLOCK) || (((!parting) && (f->action == FA_KILL))) || (f->action == FA_SILENT)) { return MOD_RES_PASSTHRU; } else { /* Are they parting, if so, kill is applicable */ if ((parting) && (f->action == FA_KILL)) { user->WriteNotice("*** Your PART message was filtered: " + f->reason); ServerInstance->Users.QuitUser(user, "Filtered: " + f->reason); } if (f->action == FA_GLINE) { /* Note: We G-line *@IP so that if their host doesn't resolve the G-line still applies. */ auto* gl = new GLine(ServerInstance->Time(), f->duration, MODNAME "@" + ServerInstance->Config->ServerName, f->reason, "*", user->GetAddress()); ServerInstance->SNO.WriteGlobalSno('f', "{} ({}) was G-lined for {} (expires on {}) because their {} message matched {} ({})", user->nick, gl->Displayable(), Duration::ToLongString(f->duration), Time::FromNow(f->duration), command, f->freeform, f->reason); if (ServerInstance->XLines->AddLine(gl, nullptr)) { ServerInstance->XLines->ApplyLines(); } else delete gl; } if (f->action == FA_ZLINE) { auto* zl = new ZLine(ServerInstance->Time(), f->duration, MODNAME "@" + ServerInstance->Config->ServerName, f->reason, user->GetAddress()); ServerInstance->SNO.WriteGlobalSno('f', "{} ({}) was Z-lined for {} (expires on {}) because their {} message matched {} ({})", user->nick, zl->Displayable(), Duration::ToLongString(f->duration), Time::FromNow(f->duration), command, f->freeform, f->reason); if (ServerInstance->XLines->AddLine(zl, nullptr)) { ServerInstance->XLines->ApplyLines(); } else delete zl; } else if (f->action == FA_SHUN && (ServerInstance->XLines->GetFactory("SHUN"))) { /* Note: We shun *!*@IP so that if their host doesnt resolve the shun still applies. */ auto* sh = new Shun(ServerInstance->Time(), f->duration, MODNAME "@" + ServerInstance->Config->ServerName, f->reason, user->GetAddress()); ServerInstance->SNO.WriteGlobalSno('f', "{} ({}) was shunned for {} (expires on {}) because their {} message matched {} ({})", user->nick, sh->Displayable(), Duration::ToLongString(f->duration), Time::FromNow(f->duration), command, f->freeform, f->reason); if (ServerInstance->XLines->AddLine(sh, nullptr)) { ServerInstance->XLines->ApplyLines(); } else delete sh; } return MOD_RES_DENY; } } return MOD_RES_PASSTHRU; } void ModuleFilter::ReadConfig(ConfigStatus& status) { exemptedchans.clear(); exemptednicks.clear(); for (const auto& [_, tag] : ServerInstance->Config->ConfTags("exemptfromfilter")) { const std::string target = tag->getString("target"); if (!target.empty()) { if (ServerInstance->Channels.IsPrefix(target[0])) exemptedchans.insert(target); else exemptednicks.insert(target); } } const auto& tag = ServerInstance->Config->ConfValue("filteropts"); std::string newrxengine = tag->getString("engine"); enableflags = tag->getBool("enableflags"); notifyuser = tag->getBool("notifyuser", true); warnonselfmsg = tag->getBool("warnonselfmsg"); filterconf = tag->getString("filename"); if (!filterconf.empty()) filterconf = ServerInstance->Config->Paths.PrependConfig(filterconf); saveperiod = tag->getDuration("saveperiod", 5); backoff = tag->getNum<uint8_t>("backoff", 0); maxbackoff = tag->getDuration("maxbackoff", saveperiod * 120, saveperiod); SetInterval(saveperiod); factory = RegexEngine ? (RegexEngine.operator->()) : nullptr; RegexEngine.SetEngine(newrxengine); if (!RegexEngine) { if (newrxengine.empty()) ServerInstance->SNO.WriteGlobalSno('f', "WARNING: No regex engine loaded - Filter functionality disabled until this is corrected."); else ServerInstance->SNO.WriteGlobalSno('f', "WARNING: Regex engine '{}' is not loaded - Filter functionality disabled until this is corrected.", newrxengine); initing = false; FreeFilters(); return; } if ((!initing) && (RegexEngine.operator->() != factory)) { ServerInstance->SNO.WriteGlobalSno('f', "Dumping all filters due to regex engine change"); FreeFilters(); } initing = false; ReadFilters(); } void ModuleFilter::CompareLinkData(const LinkData& otherdata, LinkDataDiff& diffs) { Module::CompareLinkData(otherdata, diffs); auto it = diffs.find("flags"); if (it == diffs.end()) return; // Should never happen. if (!it->second.first) it->second.first = "no"; if (!it->second.second) it->second.second = "no"; } void ModuleFilter::GetLinkData(LinkData& data, std::string& compatdata) { if (RegexEngine) { compatdata = RegexEngine->name; // e.g. regex/pcre data["regex"] = RegexEngine->GetName(); // e.g. pcre } else data["regex"] = "broken"; if (enableflags) data["flags"] = "yes"; } std::string ModuleFilter::EncodeFilter(const FilterResult& filter) { std::ostringstream stream; /* Hax to allow spaces in the freeform without changing the design of the irc protocol */ std::string freeform = filter.freeform; for (auto& chr : freeform) { if (chr == ' ') chr = '\7'; } stream << freeform << " " << FilterActionToString(filter.action) << " " << filter.GetFlags() << " " << filter.duration << " :" << filter.reason; return stream.str(); } FilterResult ModuleFilter::DecodeFilter(const std::string& data) { std::string filteraction; FilterResult res; irc::tokenstream tokens(data); tokens.GetMiddle(res.freeform); tokens.GetMiddle(filteraction); if (!StringToFilterAction(filteraction, res.action)) throw ModuleException(this, "Invalid action: " + filteraction); std::string filterflags; tokens.GetMiddle(filterflags); char c = res.FillFlags(filterflags); if (c != 0) throw ModuleException(this, "Invalid flag: '" + std::string(1, c) + "'"); std::string duration; tokens.GetMiddle(duration); res.duration = ConvToNum<unsigned long>(duration); tokens.GetTrailing(res.reason); /* Hax to allow spaces in the freeform without changing the design of the irc protocol */ for (auto& chr : res.freeform) { if (chr == '\7') chr = ' '; } return res; } void ModuleFilter::OnSyncNetwork(Server& server) { for (const auto& filter : filters) { if (filter.from_config) continue; server.SendMetadata("filter", EncodeFilter(filter)); } } void ModuleFilter::OnDecodeMetadata(Extensible* target, const std::string& extname, const std::string& extdata) { if (!target && irc::equals(extname, "filter")) { try { FilterResult data = DecodeFilter(extdata); this->AddFilter(data.freeform, data.action, data.reason, data.duration, data.GetFlags()); } catch (const ModuleException& e) { ServerInstance->Logs.Debug(MODNAME, "Error when unserializing filter: {}", e.GetReason()); } } } const FilterResult* ModuleFilter::FilterMatch(User* user, const std::string& text, int flgs) { static std::string stripped_text; stripped_text.clear(); for (const auto& filter : filters) { /* Skip ones that dont apply to us */ if (!AppliesToMe(user, filter, flgs)) continue; if ((filter.flag_strip_color) && (stripped_text.empty())) { stripped_text = text; InspIRCd::StripColor(stripped_text); } if (filter.regex->IsMatch(filter.flag_strip_color ? stripped_text : text)) return &filter; } return nullptr; } bool ModuleFilter::DeleteFilter(const std::string& freeform, std::string& reason) { for (std::vector<FilterResult>::iterator i = filters.begin(); i != filters.end(); i++) { if (i->freeform == freeform) { reason.assign(i->reason); filters.erase(i); dirty = true; return true; } } return false; } std::pair<bool, std::string> ModuleFilter::AddFilter(const std::string& freeform, FilterAction type, const std::string& reason, unsigned long duration, const std::string& flgs, bool config) { for (const auto& filter : filters) { if (filter.freeform == freeform) { return std::make_pair(false, "Filter already exists"); } } try { filters.emplace_back(RegexEngine, freeform, reason, type, duration, flgs, config, enableflags); dirty = true; } catch (const ModuleException& e) { ServerInstance->Logs.Normal(MODNAME, "Error in regular expression '{}': {}", freeform, e.GetReason()); return std::make_pair(false, e.GetReason()); } return std::make_pair(true, ""); } bool ModuleFilter::StringToFilterAction(const std::string& str, FilterAction& fa) { if (insp::equalsci(str, "gline")) fa = FA_GLINE; else if (insp::equalsci(str, "zline")) fa = FA_ZLINE; else if (insp::equalsci(str, "warn")) fa = FA_WARN; else if (insp::equalsci(str, "block")) fa = FA_BLOCK; else if (insp::equalsci(str, "silent")) fa = FA_SILENT; else if (insp::equalsci(str, "kill")) fa = FA_KILL; else if (insp::equalsci(str, "shun") && (ServerInstance->XLines->GetFactory("SHUN"))) fa = FA_SHUN; else if (insp::equalsci(str, "none")) fa = FA_NONE; else return false; return true; } std::string ModuleFilter::FilterActionToString(FilterAction fa) { switch (fa) { case FA_GLINE: return "gline"; case FA_ZLINE: return "zline"; case FA_WARN: return "warn"; case FA_BLOCK: return "block"; case FA_SILENT: return "silent"; case FA_KILL: return "kill"; case FA_SHUN: return "shun"; default: return "none"; } } void ModuleFilter::ReadFilters() { insp::flat_set<std::string> removedfilters; for (std::vector<FilterResult>::iterator filter = filters.begin(); filter != filters.end(); ) { if (filter->from_config) { removedfilters.insert(filter->freeform); filter = filters.erase(filter); continue; } // The filter is not from the config. filter++; } for (const auto& [_, tag] : ServerInstance->Config->ConfTags("keyword")) { std::string pattern = tag->getString("pattern"); std::string reason = tag->getString("reason"); std::string action = tag->getString("action"); std::string flgs = tag->getString("flags", "*", 1); bool generated = tag->getBool("generated"); unsigned long duration = tag->getDuration("duration", 10*60, 1); FilterAction fa; if (!StringToFilterAction(action, fa)) fa = FA_NONE; std::pair<bool, std::string> result = static_cast<ModuleFilter*>(this)->AddFilter(pattern, fa, reason, duration, flgs, !generated); if (result.first) removedfilters.erase(pattern); else ServerInstance->Logs.Warning(MODNAME, "Filter '{}' could not be added: {}", pattern, result.second); } if (!removedfilters.empty()) { for (const auto& removedfilter : removedfilters) ServerInstance->SNO.WriteGlobalSno('f', "Removing filter '" + removedfilter + "' due to config rehash."); } } ModResult ModuleFilter::OnStats(Stats::Context& stats) { if (stats.GetSymbol() == 's') { for (const auto& filter : filters) { stats.AddRow(223, RegexEngine.GetProvider(), filter.freeform, filter.GetFlags(), FilterActionToString(filter.action), filter.duration, filter.reason); } for (const auto& exemptedchan : exemptedchans) { stats.AddRow(223, "EXEMPT " + exemptedchan); } for (const auto& exemptednick : exemptednicks) { stats.AddRow(223, "EXEMPT " + exemptednick); } return MOD_RES_DENY; } return MOD_RES_PASSTHRU; } void ModuleFilter::OnUnloadModule(Module* mod) { // If the regex engine became unavailable or has changed, remove all filters if (!RegexEngine) { FreeFilters(); } else if (RegexEngine.operator->() != factory) { factory = RegexEngine.operator->(); FreeFilters(); } } bool ModuleFilter::Tick() { if (dirty) { if (WriteDatabase()) { // If we were previously unable to write but now can then reset the time interval. if (GetInterval() != saveperiod) SetInterval(saveperiod, false); dirty = false; } else { // Back off a bit to avoid spamming opers. if (backoff > 1) SetInterval(std::min(GetInterval() * backoff, maxbackoff), false); ServerInstance->Logs.Debug(MODNAME, "Trying again in {}", Duration::ToLongString(GetInterval())); } } return true; }; bool ModuleFilter::WriteDatabase() { if (filterconf.empty()) // Nothing to write to. { dirty = false; return true; } const auto newfilterconf = INSP_FORMAT("{}.new.{}", filterconf, ServerInstance->Time()); std::ofstream stream(newfilterconf.c_str()); if (!stream.is_open()) // Filesystem probably not writable. { ServerInstance->SNO.WriteToSnoMask('f', "Unable to save filters to \"{}\": {} ({})", newfilterconf, strerror(errno), errno); return false; } stream << "# This file was automatically generated by the " << INSPIRCD_VERSION << " filter module on " << Time::ToString(ServerInstance->Time()) << "." << std::endl << "# Any changes to this file will be automatically overwritten." << std::endl << "# If you want to convert this to a normal config file you *MUST* remove the generated=\"yes\" keys!" << std::endl << std::endl; for (const auto& filter : filters) { if (filter.from_config) continue; stream << "<keyword generated=\"yes" << "\" pattern=\"" << ServerConfig::Escape(filter.freeform) << "\" reason=\"" << ServerConfig::Escape(filter.reason) << "\" action=\"" << FilterActionToString(filter.action) << "\" flags=\"" << filter.GetFlags(); if (filter.duration) stream << "\" duration=\"" << Duration::ToString(filter.duration); stream << "\">" << std::endl; } if (stream.fail()) // Filesystem probably not writable. { ServerInstance->SNO.WriteToSnoMask('f', "Unable to save filters to \"{}\": {} ({})", newfilterconf, strerror(errno), errno); return false; } stream.close(); #ifdef _WIN32 remove(filterconf.c_str()); #endif // Use rename to move temporary to new db - this is guaranteed not to fuck up, even in case of a crash. if (rename(newfilterconf.c_str(), filterconf.c_str()) < 0) { ServerInstance->SNO.WriteToSnoMask('f', "Unable to replace old filter config \"{}\" with \"{}\": {} ({})", filterconf, newfilterconf, strerror(errno), errno); return false; } dirty = false; return true; } MODULE_INIT(ModuleFilter) ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/src/modules/m_gateway.cpp������������������������������������������������������������0000664�0000000�0000000�00000041634�14771603147�0020277�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2021 Dominic Hamon * Copyright (C) 2017-2024 Sadie Powell <sadie@witchery.services> * Copyright (C) 2014 md_5 <git@md-5.net> * Copyright (C) 2014 Googolplexed <googol@googolplexed.net> * Copyright (C) 2012 Robby <robby@chatbelgie.be> * Copyright (C) 2012 Attila Molnar <attilamolnar@hush.com> * Copyright (C) 2009-2010 Daniel De Graaf <danieldg@inspircd.org> * Copyright (C) 2009 Uli Schlachter <psychon@znc.in> * Copyright (C) 2008 Robin Burchell <robin+git@viroteck.net> * Copyright (C) 2006-2007, 2010 Craig Edwards <brain@inspircd.org> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include "inspircd.h" #include "extension.h" #include "modules/extban.h" #include "modules/ssl.h" #include "modules/webirc.h" #include "modules/whois.h" // One or more hostmask globs or CIDR ranges. typedef std::vector<std::string> MaskList; // Encapsulates information about a username gateway. class UserHost final { private: MaskList hostmasks; std::string newuser; public: UserHost(const MaskList& masks, const std::string& user) : hostmasks(masks) , newuser(user) { } const std::string& GetUser() const { return newuser; } bool Matches(LocalUser* user) const { for (const auto& mask : hostmasks) { // Does the user's hostname match this hostmask? if (InspIRCd::Match(user->GetRealHost(), mask, ascii_case_insensitive_map)) return true; // Does the user's IP address match this hostmask? if (InspIRCd::MatchCIDR(user->GetAddress(), mask, ascii_case_insensitive_map)) return true; } // The user didn't match any hostmasks. return false; } }; // Encapsulates information about a WebIRC gateway. class WebIRCHost final { private: MaskList hostmasks; std::string fingerprint; std::string password; std::string passhash; TokenList trustedflags; public: WebIRCHost(const MaskList& masks, const std::string& fp, const std::string& pass, const std::string& hash, const std::string& flags) : hostmasks(masks) , fingerprint(fp) , password(pass) , passhash(hash) , trustedflags(flags) { } bool IsFlagTrusted(const std::string& flag) const { return trustedflags.Contains(flag); } bool Matches(LocalUser* user, const std::string& pass, UserCertificateAPI& sslapi) const { // Did the user send a valid password? if (!password.empty() && !InspIRCd::CheckPassword(password, passhash, pass)) return false; // Does the user have a valid fingerprint? if (!fingerprint.empty()) { if (!sslapi) return false; bool okay = false; for (const auto& fp : sslapi->GetFingerprints(user)) { if (InspIRCd::TimingSafeCompare(fp, fingerprint)) { okay = true; break; } } if (!okay) return false; } for (const auto& mask : hostmasks) { // Does the user's hostname match this hostmask? if (InspIRCd::Match(user->GetRealHost(), mask, ascii_case_insensitive_map)) return true; // Does the user's IP address match this hostmask? if (InspIRCd::MatchCIDR(user->GetAddress(), mask, ascii_case_insensitive_map)) return true; } // The user didn't match any hostmasks. return false; } }; class CommandHexIP final : public SplitCommand { public: CommandHexIP(Module* Creator) : SplitCommand(Creator, "HEXIP", 1) { penalty = 2000; syntax = { "<hex-ip|raw-ip>" }; } CmdResult HandleLocal(LocalUser* user, const Params& parameters) override { irc::sockets::sockaddrs sa(false); if (sa.from_ip(parameters[0])) { if (sa.family() != AF_INET) { user->WriteNotice("*** HEXIP: You can only hex encode an IPv4 address!"); return CmdResult::FAILURE; } uint32_t addr = sa.in4.sin_addr.s_addr; user->WriteNotice("*** HEXIP: {} encodes to {:02x}{:02x}{:02x}{:02x}.", sa.addr(), (addr & 0xFF), ((addr >> 8) & 0xFF), ((addr >> 16) & 0xFF), ((addr >> 24) & 0xFF)); return CmdResult::SUCCESS; } if (ParseIP(parameters[0], sa)) { user->WriteNotice("*** HEXIP: {} decodes to {}.", parameters[0], sa.addr()); return CmdResult::SUCCESS; } user->WriteNotice("*** HEXIP: {} is not a valid raw or hex encoded IPv4 address.", parameters[0]); return CmdResult::FAILURE; } static bool ParseIP(const std::string& in, irc::sockets::sockaddrs& out) { const char* username = nullptr; if (in.length() == 8) { // The username is an IPv4 address encoded in hexadecimal with two characters // per address segment. username = in.c_str(); } else if (in.length() == 9 && in[0] == '~') { // The same as above but m_ident got to this user before we did. Strip the // username prefix and continue as normal. username = in.c_str() + 1; } else { // The user either does not have an IPv4 in their username or the gateway server // is also running an identd. In the latter case there isn't really a lot we // can do so we just assume that the client in question is not connecting via // a username gateway. return false; } // Try to convert the IP address to a string. If this fails then the user // does not have an IPv4 address in their username. errno = 0; unsigned long address = strtoul(username, nullptr, 16); if (errno) return false; // If the converted IP address is > 32 bits then it's not valid so bail. if (address > UINT32_MAX) return false; out.in4.sin_family = AF_INET; out.in4.sin_addr.s_addr = htonl(uint32_t(address)); return true; } }; class GatewayExtBan final : public ExtBan::MatchingBase { public: StringExtItem gateway; GatewayExtBan(Module* Creator) : ExtBan::MatchingBase(Creator, "gateway", 'w') , gateway(Creator, "webirc-gateway", ExtensionType::USER, true) { } bool IsMatch(User* user, Channel* channel, const std::string& text) override { const std::string* gatewayname = gateway.Get(user); return gatewayname ? InspIRCd::Match(*gatewayname, text) : false; } }; class CommandWebIRC final : public SplitCommand { public: std::vector<WebIRCHost> hosts; GatewayExtBan extban; StringExtItem realhost; StringExtItem realip; UserCertificateAPI sslapi; Events::ModuleEventProvider webircevprov; CommandWebIRC(Module* Creator) : SplitCommand(Creator, "WEBIRC", 4) , extban(Creator) , realhost(Creator, "gateway-realhost", ExtensionType::USER, true) , realip(Creator, "gateway-realip", ExtensionType::USER, true) , sslapi(Creator) , webircevprov(Creator, "event/webirc") { works_before_reg = true; syntax = { "<password> <gateway> <hostname> <ip> [<flags>]" }; } CmdResult HandleLocal(LocalUser* user, const Params& parameters) override { if (user->IsFullyConnected() || realhost.Get(user)) return CmdResult::FAILURE; for (const auto& host : hosts) { // If we don't match the host then skip to the next host. if (!host.Matches(user, parameters[0], sslapi)) continue; irc::sockets::sockaddrs ipaddr(false); if (!ipaddr.from_ip_port(parameters[3], user->client_sa.port())) { ServerInstance->SNO.WriteGlobalSno('w', "Connecting user {} ({}) tried to use WEBIRC but gave an invalid IP address.", user->uuid, user->GetAddress()); ServerInstance->Users.QuitUser(user, "WEBIRC: IP address is invalid: " + parameters[3]); return CmdResult::FAILURE; } // The user matched a WebIRC block! extban.gateway.Set(user, parameters[1]); realhost.Set(user, user->GetRealHost()); realip.Set(user, user->GetAddress()); ServerInstance->SNO.WriteGlobalSno('w', "Connecting user {} is using the {} WebIRC gateway; changing their IP from {} to {}.", user->uuid, parameters[1], user->GetAddress(), parameters[3]); // If we have custom flags then deal with them. WebIRC::FlagMap flags; const bool hasflags = (parameters.size() > 4); if (hasflags) { std::string flagname; std::string flagvalue; // Parse the flags. irc::spacesepstream flagstream(parameters[4]); for (std::string flag; flagstream.GetToken(flag); ) { // Does this flag have a value? const size_t separator = flag.find('='); if (separator == std::string::npos) { // It does not; just use the flag. flagname = flag; flagvalue.clear(); } else { // It does; extract the value. flagname = flag.substr(0, separator); flagvalue = flag.substr(separator + 1); } if (host.IsFlagTrusted(flagname)) flags[flagname] = flagvalue; } } // Inform modules about the WebIRC attempt. webircevprov.Call(&WebIRC::EventListener::OnWebIRCAuth, user, (hasflags ? &flags : nullptr)); // Set the IP address sent via WEBIRC. We ignore the hostname and lookup // instead do our own DNS lookups because of unreliable gateways. user->ChangeRemoteAddress(ipaddr); return CmdResult::SUCCESS; } ServerInstance->SNO.WriteGlobalSno('w', "Connecting user {} ({}) tried to use WEBIRC but didn't match any configured WebIRC hosts.", user->uuid, user->GetAddress()); ServerInstance->Users.QuitUser(user, "WEBIRC: you don't match any configured WebIRC hosts."); return CmdResult::FAILURE; } }; class ModuleGateway final : public Module , public WebIRC::EventListener , public Whois::EventListener { private: CommandHexIP cmdhexip; CommandWebIRC cmdwebirc; std::vector<UserHost> hosts; public: ModuleGateway() : Module(VF_VENDOR, "Adds the ability for IRC gateways to forward the real IP address of users connecting through them.") , WebIRC::EventListener(this) , Whois::EventListener(this) , cmdhexip(this) , cmdwebirc(this) { } void init() override { ServerInstance->SNO.EnableSnomask('w', "GATEWAY"); } void ReadConfig(ConfigStatus& status) override { std::vector<UserHost> userhosts; std::vector<WebIRCHost> webirchosts; for (const auto& [_, tag] : ServerInstance->Config->ConfTags("gateway", ServerInstance->Config->ConfTags("cgihost"))) { MaskList masks; irc::spacesepstream maskstream(tag->getString("mask")); for (std::string mask; maskstream.GetToken(mask); ) masks.push_back(mask); // Ensure that we have the <gateway:mask> parameter. if (masks.empty()) throw ModuleException(this, "<" + tag->name + ":mask> is a mandatory field, at " + tag->source.str()); // Determine what lookup type this host uses. const std::string type = tag->getString("type"); if (insp::equalsci(type, "username") || insp::equalsci(type, "ident")) { // The IP address should be looked up from the hex IP address. const std::string newuser = tag->getString("newusername", tag->getString("newident", "gateway", ServerInstance->IsUser), ServerInstance->IsUser); userhosts.emplace_back(masks, newuser); } else if (insp::equalsci(type, "webirc")) { // The IP address will be received via the WEBIRC command. const std::string fingerprint = tag->getString("fingerprint"); const std::string password = tag->getString("password"); const std::string passwordhash = tag->getString("hash", "plaintext", 1); const std::string trustedflags = tag->getString("trustedflags", "*", 1); // WebIRC blocks require a password. if (fingerprint.empty() && password.empty()) throw ModuleException(this, "When using <" + tag->name + " type=\"webirc\"> either the fingerprint or password field is required, at " + tag->source.str()); if (!password.empty() && insp::equalsci(passwordhash, "plaintext")) { ServerInstance->Logs.Normal(MODNAME, "<{}> tag at {} contains an plain text password, this is insecure!", tag->name, tag->source.str()); } webirchosts.emplace_back(masks, fingerprint, password, passwordhash, trustedflags); } else { throw ModuleException(this, type + " is an invalid <" + tag->name + ":mask> type, at " + tag->source.str()); } } // The host configuration was valid so we can apply it. hosts.swap(userhosts); cmdwebirc.hosts.swap(webirchosts); } ModResult OnPreChangeConnectClass(LocalUser* user, const std::shared_ptr<ConnectClass>& klass, std::optional<Numeric::Numeric>& errnum) override { // If <connect:webirc> is not set then we have nothing to do. const std::string webirc = klass->config->getString("webirc"); if (webirc.empty()) return MOD_RES_PASSTHRU; // If the user is not connecting via a WebIRC gateway then they // cannot match this connect class. const std::string* gateway = cmdwebirc.extban.gateway.Get(user); if (!gateway) { ServerInstance->Logs.Debug("CONNECTCLASS", "The {} connect class is not suitable as it requires a connection via a WebIRC gateway.", klass->GetName()); return MOD_RES_DENY; } // If the gateway matches the <connect:webirc> constraint then // allow the check to continue. Otherwise, reject it. if (!InspIRCd::Match(*gateway, webirc)) { ServerInstance->Logs.Debug("CONNECTCLASS", "The {} connect class is not suitable as the WebIRC gateway name ({}) does not match {}.", klass->GetName(), *gateway, webirc); return MOD_RES_DENY; } return MOD_RES_PASSTHRU; } ModResult OnUserRegister(LocalUser* user) override { // There is no need to check for gateways if one is already being used. if (cmdwebirc.realhost.Get(user)) return MOD_RES_PASSTHRU; for (const auto& host : hosts) { // If we don't match the host then skip to the next host. if (!host.Matches(user)) continue; // We have matched an gateway block! Try to parse the encoded IPv4 address // out of the user. irc::sockets::sockaddrs address(user->client_sa); if (!CommandHexIP::ParseIP(user->GetRealUser(), address)) return MOD_RES_PASSTHRU; // Store the hostname and IP of the gateway for later use. cmdwebirc.realhost.Set(user, user->GetRealHost()); cmdwebirc.realip.Set(user, user->GetAddress()); const std::string& newuser = host.GetUser(); ServerInstance->SNO.WriteGlobalSno('w', "Connecting user {} is using a username gateway; changing their IP from {} to {} and their real username from {} to {}.", user->uuid, user->GetAddress(), address.addr(), user->GetRealUser(), newuser); user->ChangeRealUser(newuser, user->GetDisplayedUser() == user->GetRealUser()); user->ChangeRemoteAddress(address); break; } return MOD_RES_PASSTHRU; } void OnWebIRCAuth(LocalUser* user, const WebIRC::FlagMap* flags) override { // We are only interested in connection flags. If none have been // given then we have nothing to do. if (!flags) return; WebIRC::FlagMap::const_iterator cport = flags->find("remote-port"); if (cport != flags->end()) { // If we can't parse the port then just give up. in_port_t port = ConvToNum<in_port_t>(cport->second); if (port) { switch (user->client_sa.family()) { case AF_INET: user->client_sa.in4.sin_port = htons(port); break; case AF_INET6: user->client_sa.in6.sin6_port = htons(port); break; default: // If we have reached this point then we have encountered a bug. ServerInstance->Logs.Debug(MODNAME, "BUG: OnWebIRCAuth({}): socket type {} is unknown!", user->uuid, user->client_sa.family()); return; } } } WebIRC::FlagMap::const_iterator sport = flags->find("local-port"); if (sport != flags->end()) { // If we can't parse the port then just give up. in_port_t port = ConvToNum<in_port_t>(sport->second); if (port) { switch (user->server_sa.family()) { case AF_INET: user->server_sa.in4.sin_port = htons(port); break; case AF_INET6: user->server_sa.in6.sin6_port = htons(port); break; default: // If we have reached this point then we have encountered a bug. ServerInstance->Logs.Debug(MODNAME, "BUG: OnWebIRCAuth({}): socket type {} is unknown!", user->uuid, user->server_sa.family()); return; } } } } void OnWhois(Whois::Context& whois) override { // If these fields are not set then the client is not using a gateway. std::string* realhost = cmdwebirc.realhost.Get(whois.GetTarget()); std::string* realip = cmdwebirc.realip.Get(whois.GetTarget()); if (!realhost || !realip) return; // If the source doesn't have the right privs then only show the gateway name. std::string hidden = "*"; if (!whois.GetSource()->HasPrivPermission("users/auspex")) realhost = realip = &hidden; const std::string* gateway = cmdwebirc.extban.gateway.Get(whois.GetTarget()); if (gateway) whois.SendLine(RPL_WHOISGATEWAY, *realhost, *realip, "is connected via the " + *gateway + " WebIRC gateway"); else whois.SendLine(RPL_WHOISGATEWAY, *realhost, *realip, "is connected via a username gateway"); } }; MODULE_INIT(ModuleGateway) ����������������������������������������������������������������������������������������������������inspircd-4.7.0/src/modules/m_geoban.cpp�������������������������������������������������������������0000664�0000000�0000000�00000005315�14771603147�0020065�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2020 Matt Schatz <genius3000@g3k.solutions> * Copyright (C) 2019-2022 Sadie Powell <sadie@witchery.services> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include "inspircd.h" #include "modules/extban.h" #include "modules/geolocation.h" #include "modules/who.h" #include "modules/whois.h" class CountryExtBan final : public ExtBan::MatchingBase { private: Geolocation::API& geoapi; public: CountryExtBan(Module* Creator, Geolocation::API& api) : ExtBan::MatchingBase(Creator, "country", 'G') , geoapi(api) { } bool IsMatch(User* user, Channel* channel, const std::string& text) override { Geolocation::Location* location = geoapi ? geoapi->GetLocation(user) : nullptr; const std::string code = location ? location->GetCode() : "XX"; // Does this user match against the ban? return InspIRCd::Match(code, text); } }; class ModuleGeoBan final : public Module , public Who::MatchEventListener , public Whois::EventListener { private: Geolocation::API geoapi; CountryExtBan extban; public: ModuleGeoBan() : Module(VF_VENDOR | VF_OPTCOMMON, "Adds extended ban G: (country) which matches against two letter country codes.") , Who::MatchEventListener(this) , Whois::EventListener(this) , geoapi(this) , extban(this, geoapi) { } ModResult OnWhoMatch(const Who::Request& request, LocalUser* source, User* user) override { if (!request.flags['G']) return MOD_RES_PASSTHRU; Geolocation::Location* location = geoapi ? geoapi->GetLocation(user) : nullptr; const std::string code = location ? location->GetCode() : "XX"; return InspIRCd::Match(code, request.matchtext, ascii_case_insensitive_map) ? MOD_RES_ALLOW : MOD_RES_DENY; } void OnWhois(Whois::Context& whois) override { if (whois.GetTarget()->server->IsService()) return; Geolocation::Location* location = geoapi ? geoapi->GetLocation(whois.GetTarget()) : nullptr; if (location) whois.SendLine(RPL_WHOISCOUNTRY, location->GetCode(), "is connecting from " + location->GetName()); else whois.SendLine(RPL_WHOISCOUNTRY, "*", "is connecting from an unknown country"); } }; MODULE_INIT(ModuleGeoBan) �������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/src/modules/m_geoclass.cpp�����������������������������������������������������������0000664�0000000�0000000�00000006275�14771603147�0020440�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2019-2021, 2023 Sadie Powell <sadie@witchery.services> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include "inspircd.h" #include "modules/geolocation.h" #include "modules/stats.h" #include "utility/string.h" class ModuleGeoClass final : public Module , public Stats::EventListener { private: Geolocation::API geoapi; public: ModuleGeoClass() : Module(VF_VENDOR, "Allows the server administrator to assign users to connect classes by the country they are connecting from.") , Stats::EventListener(this) , geoapi(this) { } ModResult OnPreChangeConnectClass(LocalUser* user, const std::shared_ptr<ConnectClass>& klass, std::optional<Numeric::Numeric>& errnum) override { const std::string country = klass->config->getString("country"); if (country.empty()) return MOD_RES_PASSTHRU; // If we can't find the location of this user then we can't assign // them to a location-specific connect class. Geolocation::Location* location = geoapi ? geoapi->GetLocation(user) : nullptr; const std::string code = location ? location->GetCode() : "XX"; irc::spacesepstream codes(country); for (std::string token; codes.GetToken(token); ) { if (token.length() != 2) { ServerInstance->Logs.Debug("CONNECTCLASS", "The {} connect class contains an invalid country code: {}", klass->GetName(), token); continue; } // If the user matches this country code then they can use this // connect class. if (insp::equalsci(token, code)) return MOD_RES_PASSTHRU; } // A list of country codes were specified but the user didn't match // any of them. ServerInstance->Logs.Debug("CONNECTCLASS", "The {} connect class is not suitable as the origin country ({}) is not any of {}.", klass->GetName(), code, country); return MOD_RES_DENY; } ModResult OnStats(Stats::Context& stats) override { if (stats.GetSymbol() != 'G') return MOD_RES_PASSTHRU; // Counter for the number of users in each country. std::map<Geolocation::Location*, size_t> counts; // Counter for the number of users in an unknown country. size_t unknown = 0; for (auto* user : ServerInstance->Users.GetLocalUsers()) { Geolocation::Location* location = geoapi ? geoapi->GetLocation(user) : nullptr; if (location) counts[location]++; else unknown++; } for (const auto& [location, count] : counts) { stats.AddGenericRow(INSP_FORMAT("{} ({}): {}", location->GetName(), location->GetCode(), count)); } if (unknown) stats.AddGenericRow(INSP_FORMAT("Unknown Country: {}", unknown)); return MOD_RES_DENY; } }; MODULE_INIT(ModuleGeoClass) �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/src/modules/m_globalload.cpp���������������������������������������������������������0000664�0000000�0000000�00000012612�14771603147�0020730�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2013, 2017, 2019-2023 Sadie Powell <sadie@witchery.services> * Copyright (C) 2012, 2014-2016 Attila Molnar <attilamolnar@hush.com> * Copyright (C) 2012 Robby <robby@chatbelgie.be> * Copyright (C) 2009-2010 Daniel De Graaf <danieldg@inspircd.org> * Copyright (C) 2009 Robin Burchell <robin+git@viroteck.net> * Copyright (C) 2007-2008 Dennis Friis <peavey@inspircd.org> * Copyright (C) 2007-2008 Craig Edwards <brain@inspircd.org> * Copyright (C) 2007 John Brooks <john@jbrooks.io> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include "inspircd.h" class CommandGLoadModule final : public Command { public: CommandGLoadModule(Module* Creator) : Command(Creator, "GLOADMODULE", 1) { access_needed = CmdAccess::OPERATOR; syntax = { "<modulename> [<servermask>]" }; } CmdResult Handle(User* user, const Params& parameters) override { std::string servername = parameters.size() > 1 ? parameters[1] : "*"; if (InspIRCd::Match(ServerInstance->Config->ServerName, servername)) { if (ServerInstance->Modules.Load(parameters[0])) { ServerInstance->SNO.WriteToSnoMask('a', "NEW MODULE '{}' GLOBALLY LOADED BY '{}'", parameters[0], user->nick); user->WriteRemoteNumeric(RPL_LOADEDMODULE, parameters[0], "Module successfully loaded."); } else { user->WriteRemoteNumeric(ERR_CANTLOADMODULE, parameters[0], ServerInstance->Modules.LastError()); } } else ServerInstance->SNO.WriteToSnoMask('a', "MODULE '{}' GLOBAL LOAD BY '{}' (not loaded here)", parameters[0], user->nick); return CmdResult::SUCCESS; } RouteDescriptor GetRouting(User* user, const Params& parameters) override { return ROUTE_BROADCAST; } }; class CommandGUnloadModule final : public Command { public: CommandGUnloadModule(Module* Creator) : Command(Creator, "GUNLOADMODULE", 1) { access_needed = CmdAccess::OPERATOR; syntax = { "<modulename> [<servermask>]" }; } CmdResult Handle(User* user, const Params& parameters) override { if (InspIRCd::Match(parameters[0], "core_*", ascii_case_insensitive_map)) { user->WriteRemoteNumeric(ERR_CANTUNLOADMODULE, parameters[0], "You cannot unload core commands!"); return CmdResult::FAILURE; } std::string servername = parameters.size() > 1 ? parameters[1] : "*"; if (InspIRCd::Match(ServerInstance->Config->ServerName, servername)) { Module* m = ServerInstance->Modules.Find(parameters[0]); if (m) { if (ServerInstance->Modules.Unload(m)) { ServerInstance->SNO.WriteToSnoMask('a', "MODULE '{}' GLOBALLY UNLOADED BY '{}'", parameters[0], user->nick); user->WriteRemoteNumeric(RPL_UNLOADEDMODULE, parameters[0], "Module successfully unloaded."); } else { user->WriteRemoteNumeric(ERR_CANTUNLOADMODULE, parameters[0], ServerInstance->Modules.LastError()); } } else user->WriteRemoteNumeric(ERR_CANTUNLOADMODULE, parameters[0], "No such module"); } else ServerInstance->SNO.WriteToSnoMask('a', "MODULE '{}' GLOBAL UNLOAD BY '{}' (not unloaded here)", parameters[0], user->nick); return CmdResult::SUCCESS; } RouteDescriptor GetRouting(User* user, const Params& parameters) override { return ROUTE_BROADCAST; } }; class CommandGReloadModule final : public Command { public: CommandGReloadModule(Module* Creator) : Command(Creator, "GRELOADMODULE", 1) { access_needed = CmdAccess::OPERATOR; syntax = { "<modulename> [<servermask>]" }; } CmdResult Handle(User* user, const Params& parameters) override { std::string servername = parameters.size() > 1 ? parameters[1] : "*"; if (InspIRCd::Match(ServerInstance->Config->ServerName, servername)) { Module* m = ServerInstance->Modules.Find(parameters[0]); if (m) { ServerInstance->SNO.WriteToSnoMask('a', "MODULE '{}' GLOBALLY RELOADED BY '{}'", parameters[0], user->nick); ServerInstance->Parser.CallHandler("RELOADMODULE", parameters, user); } else { user->WriteRemoteNumeric(ERR_CANTUNLOADMODULE, parameters[0], "Could not find a loaded module by that name"); return CmdResult::FAILURE; } } else ServerInstance->SNO.WriteToSnoMask('a', "MODULE '{}' GLOBAL RELOAD BY '{}' (not reloaded here)", parameters[0], user->nick); return CmdResult::SUCCESS; } RouteDescriptor GetRouting(User* user, const Params& parameters) override { return ROUTE_BROADCAST; } }; class ModuleGlobalLoad final : public Module { private: CommandGLoadModule cmdgloadmodule; CommandGUnloadModule cmdgunloadmodule; CommandGReloadModule cmdgreloadmodule; public: ModuleGlobalLoad() : Module(VF_VENDOR | VF_COMMON, "Adds the /GLOADMODULE, /GRELOADMODULE, and /GUNLOADMODULE commands which allows server operators to load, reload, and unload modules on remote servers.") , cmdgloadmodule(this) , cmdgunloadmodule(this) , cmdgreloadmodule(this) { } }; MODULE_INIT(ModuleGlobalLoad) ����������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/src/modules/m_globops.cpp������������������������������������������������������������0000664�0000000�0000000�00000004017�14771603147�0020275�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2019-2023 Sadie Powell <sadie@witchery.services> * Copyright (C) 2012 Robby <robby@chatbelgie.be> * Copyright (C) 2009-2010 Daniel De Graaf <danieldg@inspircd.org> * Copyright (C) 2009 Uli Schlachter <psychon@znc.in> * Copyright (C) 2007-2008 Dennis Friis <peavey@inspircd.org> * Copyright (C) 2006 Craig Edwards <brain@inspircd.org> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ // Globops and snomask +g module by C.J.Edwards #include "inspircd.h" class CommandGlobops final : public Command { public: CommandGlobops(Module* Creator) : Command(Creator, "GLOBOPS", 1, 1) { access_needed = CmdAccess::OPERATOR; allow_empty_last_param = true; syntax = { ":<message>" }; } CmdResult Handle(User* user, const Params& parameters) override { if (parameters[0].empty()) { user->WriteNumeric(ERR_NOTEXTTOSEND, "No text to send"); return CmdResult::FAILURE; } ServerInstance->SNO.WriteGlobalSno('g', "From " + user->nick + ": " + parameters[0]); return CmdResult::SUCCESS; } }; class ModuleGlobops final : public Module { private: CommandGlobops cmd; public: ModuleGlobops() : Module(VF_VENDOR | VF_OPTCOMMON, "Adds the /GLOBOPS command which allows server operators to send messages to all server operators with the g (globops) snomask.") , cmd(this) { } void init() override { ServerInstance->SNO.EnableSnomask('g', "GLOBOPS"); } }; MODULE_INIT(ModuleGlobops) �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/src/modules/m_haproxy.cpp������������������������������������������������������������0000664�0000000�0000000�00000026343�14771603147�0020330�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2021 Dominic Hamon * Copyright (C) 2019 linuxdaemon <linuxdaemon.irc@gmail.com> * Copyright (C) 2018-2019, 2021-2023 Sadie Powell <sadie@witchery.services> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include "inspircd.h" #include "iohook.h" #include "modules/ssl.h" enum { // The TLV flag for a client being connected over TLS. PP2_CLIENT_SSL = 0x01, // The family for TCP over IPv4. PP2_FAMILY_IPV4 = 0x11, // The length of the PP2_FAMILY_IPV4 endpoints. PP2_FAMILY_IPV4_LENGTH = 12, // The family for TCP over IPv6. PP2_FAMILY_IPV6 = 0x21, // The length of the PP2_FAMILY_IPV6 endpoints. PP2_FAMILY_IPV6_LENGTH = 36, // The family for UNIX sockets. PP2_FAMILY_UNIX = 0x31, // The length of the PP2_FAMILY_UNIX endpoints. PP2_FAMILY_UNIX_LENGTH = 216, // The bitmask we apply to extract the command. PP2_COMMAND_MASK = 0x0F, // The length of the PROXY protocol header. PP2_HEADER_LENGTH = 16, // The minimum length of a Type-Length-Value entry. PP2_TLV_LENGTH = 3, // The identifier for a TLS TLV entry. PP2_TYPE_SSL = 0x20, // The minimum length of a PP2_TYPE_SSL TLV entry. PP2_TYPE_SSL_LENGTH = 5, // The length of the PROXY protocol signature. PP2_SIGNATURE_LENGTH = 12, // The PROXY protocol version we support. PP2_VERSION = 0x20, // The bitmask we apply to extract the protocol version. PP2_VERSION_MASK = 0xF0 }; enum HAProxyState { // We are waiting for the PROXY header section. HPS_WAITING_FOR_HEADER, // We are waiting for the PROXY address section. HPS_WAITING_FOR_ADDRESS, // The client is fully connected. HPS_CONNECTED }; enum HAProxyCommand { // LOCAL command. HPC_LOCAL = 0x00, // PROXY command. HPC_PROXY = 0x01 }; struct HAProxyHeader final { // The signature used to identify the HAProxy protocol. uint8_t signature[PP2_SIGNATURE_LENGTH]; // The version of the PROXY protocol and command being sent. uint8_t version_command; // The family for the address. uint8_t family; // The length of the address section. uint16_t length; }; class HAProxyHookProvider final : public IOHookProvider { private: UserCertificateAPI sslapi; public: HAProxyHookProvider(Module* mod) : IOHookProvider(mod, "haproxy", IOHookProvider::IOH_UNKNOWN, true) , sslapi(mod) { } void OnAccept(StreamSocket* sock, const irc::sockets::sockaddrs& client, const irc::sockets::sockaddrs& server) override; void OnConnect(StreamSocket* sock) override { // We don't need to implement this. } }; // The signature for a HAProxy PROXY protocol header. static constexpr char proxy_signature[13] = "\x0D\x0A\x0D\x0A\x00\x0D\x0A\x51\x55\x49\x54\x0A"; class HAProxyHook final : public IOHookMiddle { private: // The length of the address section. uint16_t address_length = 0; // The endpoint the client is connecting from. irc::sockets::sockaddrs client; // The command sent by the proxy server. HAProxyCommand command; // The endpoint the client is connected to. irc::sockets::sockaddrs server; // The API for interacting with user TLS internals. UserCertificateAPI& sslapi; // The current state of the PROXY parser. HAProxyState state = HPS_WAITING_FOR_HEADER; size_t ReadProxyTLV(StreamSocket* sock, size_t start_index, uint16_t buffer_length) { // A TLV must at least consist of a type (uint8_t) and a length (uint16_t). if (buffer_length < PP2_TLV_LENGTH) { sock->SetError("Truncated HAProxy PROXY TLV type and/or length"); return 0; } // Check that the length can actually contain the TLV value. std::string& recvq = GetRecvQ(); uint16_t length = ntohs(recvq[start_index + 1] | (recvq[start_index + 2] << 8)); if (buffer_length < PP2_TLV_LENGTH + length) { sock->SetError("Truncated HAProxy PROXY TLV value"); return 0; } // What type of TLV are we parsing? switch (recvq[start_index]) { case PP2_TYPE_SSL: if (!ReadProxyTLVSSL(sock, start_index + PP2_TLV_LENGTH, length)) return 0; break; } return PP2_TLV_LENGTH + length; } bool ReadProxyTLVSSL(StreamSocket* sock, size_t start_index, uint16_t buffer_length) { // A TLS TLV must at least consist of client info (uint8_t) and verification info (uint32_t). if (buffer_length < PP2_TYPE_SSL_LENGTH) { sock->SetError("Truncated HAProxy PROXY TLS TLV"); return false; } // If the socket is not a user socket we don't have to do // anything with this TLVs information. if (sock->type != StreamSocket::SS_USER) return true; // If the sslinfo module is not loaded we can't // do anything with this TLV. if (!sslapi) return true; // If the client is not connecting via TLS the rest of this TLV is irrelevant. std::string& recvq = GetRecvQ(); if ((recvq[start_index] & PP2_CLIENT_SSL) == 0) return true; // Create a fake ssl_cert for the user. Ideally we should use the user's // TLS client certificate here but as of 2018-10-16 this is not forwarded // by HAProxy. auto* cert = new ssl_cert(); cert->error = "HAProxy does not forward client TLS certificates"; cert->invalid = true; cert->revoked = true; cert->trusted = false; cert->unknownsigner = true; // Extract the user for this socket and set their certificate. LocalUser* luser = static_cast<UserIOHandler*>(sock)->user; sslapi->SetCertificate(luser, cert); return true; } int ReadData(std::string& destrecvq) { // Once connected we handle no special data. std::string& recvq = GetRecvQ(); destrecvq.append(recvq); recvq.clear(); return 1; } int ReadProxyAddress(StreamSocket* sock, std::string& destrecvq) { // Block until we have the entire address. std::string& recvq = GetRecvQ(); if (recvq.length() < address_length) return 0; switch (command) { case HPC_LOCAL: // Skip the address completely. recvq.erase(0, address_length); break; case HPC_PROXY: // Store the endpoint information. size_t tlv_index = 0; switch (client.family()) { case AF_INET: memcpy(&client.in4.sin_addr.s_addr, &recvq[0], 4); memcpy(&server.in4.sin_addr.s_addr, &recvq[4], 4); memcpy(&client.in4.sin_port, &recvq[8], 2); memcpy(&server.in4.sin_port, &recvq[10], 2); tlv_index = 12; break; case AF_INET6: memcpy(client.in6.sin6_addr.s6_addr, &recvq[0], 16); memcpy(server.in6.sin6_addr.s6_addr, &recvq[16], 16); memcpy(&client.in6.sin6_port, &recvq[32], 2); memcpy(&server.in6.sin6_port, &recvq[34], 2); tlv_index = 36; break; case AF_UNIX: memcpy(client.un.sun_path, &recvq[0], 108); memcpy(server.un.sun_path, &recvq[108], 108); tlv_index = 216; break; } if (!sock->OnChangeLocalSocketAddress(server) || !sock->OnChangeRemoteSocketAddress(client)) return -1; // Parse any available TLVs. while (tlv_index < address_length) { size_t length = ReadProxyTLV(sock, tlv_index, address_length - tlv_index); if (!length) return -1; tlv_index += length; } // Erase the processed proxy information from the receive queue. recvq.erase(0, address_length); break; } // We're done! state = HPS_CONNECTED; return ReadData(destrecvq); } int ReadProxyHeader(StreamSocket* sock, std::string& destrecvq) { // Block until we have a header. std::string& recvq = GetRecvQ(); if (recvq.length() < PP2_HEADER_LENGTH) return 0; // Read the header. HAProxyHeader header; memcpy(&header, recvq.c_str(), PP2_HEADER_LENGTH); recvq.erase(0, PP2_HEADER_LENGTH); // Check we are actually parsing a HAProxy header. if (memcmp(&header.signature, proxy_signature, PP2_SIGNATURE_LENGTH) != 0) { // If we've reached this point the proxy server did not send a proxy information. sock->SetError("Invalid HAProxy PROXY signature"); return -1; } // We only support this version of the protocol. const uint8_t version = (header.version_command & PP2_VERSION_MASK); if (version != PP2_VERSION) { sock->SetError("Unsupported HAProxy PROXY protocol version"); return -1; } // We only support the LOCAL and PROXY commands. command = static_cast<HAProxyCommand>(header.version_command & PP2_COMMAND_MASK); switch (command) { case HPC_LOCAL: // Intentionally left blank. break; case HPC_PROXY: // Check the protocol support and initialise the sockaddrs. uint16_t shortest_length; switch (header.family) { case PP2_FAMILY_IPV4: // TCP over IPv4. client.sa.sa_family = server.sa.sa_family = AF_INET; shortest_length = PP2_FAMILY_IPV4_LENGTH; break; case PP2_FAMILY_IPV6: // TCP over IPv6. client.sa.sa_family = server.sa.sa_family = AF_INET6; shortest_length = PP2_FAMILY_IPV6_LENGTH; break; case PP2_FAMILY_UNIX: // UNIX stream. client.sa.sa_family = server.sa.sa_family = AF_UNIX; shortest_length = PP2_FAMILY_UNIX_LENGTH; break; default: // Unknown protocol. sock->SetError("Invalid HAProxy PROXY protocol type"); return -1; } // Check that the length can actually contain the addresses. address_length = ntohs(header.length); if (address_length < shortest_length) { sock->SetError("Truncated HAProxy PROXY address section"); return -1; } break; default: sock->SetError("Unsupported HAProxy PROXY command"); return -1; } state = HPS_WAITING_FOR_ADDRESS; return ReadProxyAddress(sock, destrecvq); } public: HAProxyHook(const std::shared_ptr<IOHookProvider>& Prov, StreamSocket* sock, UserCertificateAPI& api) : IOHookMiddle(Prov) , sslapi(api) { sock->AddIOHook(this); } bool IsHookReady() const override { return state == HPS_CONNECTED; } ssize_t OnStreamSocketWrite(StreamSocket* sock, StreamSocket::SendQueue& uppersendq) override { // We don't need to implement this. GetSendQ().moveall(uppersendq); return 1; } ssize_t OnStreamSocketRead(StreamSocket* sock, std::string& destrecvq) override { switch (state) { case HPS_WAITING_FOR_HEADER: return ReadProxyHeader(sock, destrecvq); case HPS_WAITING_FOR_ADDRESS: return ReadProxyAddress(sock, destrecvq); case HPS_CONNECTED: return ReadData(destrecvq); } // We should never reach this point. return -1; } }; void HAProxyHookProvider::OnAccept(StreamSocket* sock, const irc::sockets::sockaddrs& client, const irc::sockets::sockaddrs& server) { new HAProxyHook(shared_from_this(), sock, sslapi); } class ModuleHAProxy final : public Module { private: std::shared_ptr<HAProxyHookProvider> hookprov; public: ModuleHAProxy() : Module(VF_VENDOR, "Allows IRC connections to be made using reverse proxies that implement version 2 of the HAProxy PROXY protocol.") , hookprov(std::make_shared<HAProxyHookProvider>(this)) { } }; MODULE_INIT(ModuleHAProxy) ���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/src/modules/m_help.cpp���������������������������������������������������������������0000664�0000000�0000000�00000011746�14771603147�0017567�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2017-2021, 2023, 2025 Sadie Powell <sadie@witchery.services> * Copyright (C) 2013, 2015 Attila Molnar <attilamolnar@hush.com> * Copyright (C) 2012 Robby <robby@chatbelgie.be> * Copyright (C) 2009-2010 Daniel De Graaf <danieldg@inspircd.org> * Copyright (C) 2007 Dennis Friis <peavey@inspircd.org> * Copyright (C) 2006 Craig Edwards <brain@inspircd.org> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include "inspircd.h" enum { // From ircd-ratbox. ERR_HELPNOTFOUND = 524, RPL_HELPSTART = 704, RPL_HELPTXT = 705, RPL_ENDOFHELP = 706 }; typedef std::vector<std::string> HelpMessage; struct HelpTopic final { // The body of the help topic. const HelpMessage body; // The title of the help topic. const std::string title; HelpTopic(const HelpMessage& Body, const std::string& Title) : body(Body) , title(Title) { } }; typedef std::map<std::string, HelpTopic, irc::insensitive_swo> HelpMap; class CommandHelp final : public Command { private: const std::string startkey; public: HelpMap help; std::string nohelp; CommandHelp(Module* Creator) : Command(Creator, "HELP") , startkey("start") { syntax = { "<any-text>" }; } CmdResult Handle(User* user, const Params& parameters) override { const std::string& topic = parameters.empty() ? startkey : parameters[0]; HelpMap::const_iterator titer = help.find(topic); if (titer == help.end()) { user->WriteNumeric(ERR_HELPNOTFOUND, topic, nohelp); return CmdResult::FAILURE; } const HelpTopic& entry = titer->second; user->WriteNumeric(RPL_HELPSTART, topic, entry.title); for (const auto& line : entry.body) user->WriteNumeric(RPL_HELPTXT, topic, line); user->WriteNumeric(RPL_ENDOFHELP, topic, "End of /HELP."); return CmdResult::SUCCESS; } }; class ModuleHelp final : public Module { private: CommandHelp cmd; public: ModuleHelp() : Module(VF_VENDOR, "Adds the /HELP command which allows users to view help on various topics.") , cmd(this) { } void ReadConfig(ConfigStatus& status) override { size_t longestkey = 0; HelpMap newhelp; auto tags = ServerInstance->Config->ConfTags("helptopic", ServerInstance->Config->ConfTags("helpop")); if (tags.empty()) throw ModuleException(this, "You have loaded the help module but not configured any help topics!"); for (const auto& [_, tag] : tags) { // Attempt to read the help key. const std::string key = tag->getString("key"); if (key.empty()) throw ModuleException(this, "<{}:key> is empty at {}", tag->name, tag->source.str()); else if (irc::equals(key, "index")) throw ModuleException(this, "<{}:key> is set to \"index\" which is reserved at {}", tag->name, tag->source.str()); else if (key.length() > longestkey) longestkey = key.length(); // Attempt to read the help value. std::string value; if (!tag->readString("value", value, true) || value.empty()) throw ModuleException(this, "<{}:value> is empty at {}", tag->name, tag->source.str()); // Parse the help body. Empty lines are replaced with a single // space because some clients are unable to show blank lines. HelpMessage helpmsg; irc::sepstream linestream(value, '\n', true); for (std::string line; linestream.GetToken(line); ) helpmsg.push_back(line.empty() ? " " : line); // Read the help title and store the topic. const std::string title = tag->getString("title", INSP_FORMAT("*** Help for {}", key), 1); if (!newhelp.emplace(key, HelpTopic(helpmsg, title)).second) { throw ModuleException(this, "<{}> tag with duplicate key '{}' at {}", tag->name, key, tag->source.str()); } } // The number of items we can fit on a page. HelpMessage indexmsg; size_t maxcolumns = 80 / (longestkey + 2); for (HelpMap::iterator iter = newhelp.begin(); iter != newhelp.end(); ) { std::string indexline; for (size_t column = 0; column != maxcolumns; ) { if (iter == newhelp.end()) break; indexline.append(iter->first); if (++column != maxcolumns) indexline.append(longestkey - iter->first.length() + 2, ' '); iter++; } indexmsg.push_back(indexline); } newhelp.emplace("index", HelpTopic(indexmsg, "List of help topics")); cmd.help.swap(newhelp); const auto& tag = ServerInstance->Config->ConfValue("helpmsg"); cmd.nohelp = tag->getString("nohelp", "There is no help for the topic you searched for. Please try again.", 1); } }; MODULE_INIT(ModuleHelp) ��������������������������inspircd-4.7.0/src/modules/m_helpmode.cpp�����������������������������������������������������������0000664�0000000�0000000�00000010411�14771603147�0020420�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2023-2025 Sadie Powell <sadie@witchery.services> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include "inspircd.h" #include "modules/stats.h" #include "modules/whois.h" #include "timeutils.h" class HelpOp final : public SimpleUserMode { public: std::vector<User*> helpers; HelpOp(Module* mod) : SimpleUserMode(mod, "helpop", 'h', true) { } bool OnModeChange(User* source, User* dest, Channel* channel, Modes::Change& change) override { if (!SimpleUserMode::OnModeChange(source, dest, channel, change)) return false; if (change.adding) helpers.push_back(dest); else stdalgo::erase(helpers, dest); return true; } }; class ModuleHelpMode final : public Module , public Stats::EventListener , public Whois::EventListener { private: bool ignorehideoper; HelpOp helpop; UserModeReference hideoper; bool markhelpers; std::string helpchanmodes; insp::flat_map<std::string, std::string> helpchans; public: ModuleHelpMode() : Module(VF_VENDOR, "Adds user mode h (helpop) which marks a user as being available for help.") , Stats::EventListener(this, 50) , Whois::EventListener(this) , helpop(this) , hideoper(this, "hideoper") { } void ReadConfig(ConfigStatus& status) override { for (const auto& [_, tag] : ServerInstance->Config->ConfTags("helpchan")) { const auto name = tag->getString("name"); if (name.empty()) throw ModuleException(this, "<helpchan:name> must not be empty at " + tag->source.str()); helpchans[name] = tag->getString("prefix", "o", 1); } const auto& tag = ServerInstance->Config->ConfValue("helpmode"); ignorehideoper = tag->getBool("ignorehideoper"); markhelpers = tag->getBool("markhelpers", true); } ModResult OnStats(Stats::Context& stats) override { if (stats.GetSymbol() != 'P') return MOD_RES_PASSTHRU; for (auto* helper : helpop.helpers) { if (helper->server->IsService()) continue; // Ignore services. if (helper->IsOper() && (!ignorehideoper || !helper->IsModeSet(hideoper))) continue; // Ignore opers. std::string extra; if (helper->IsAway()) { const std::string awayperiod = Duration::ToLongString(ServerInstance->Time() - helper->away->time, true); const std::string awaytime = Time::ToString(helper->away->time); extra = INSP_FORMAT(": away for {} [since {}] ({})", awayperiod, awaytime, helper->away->message); } auto* lhelper = IS_LOCAL(helper); if (lhelper) { const std::string idleperiod = Duration::ToLongString(ServerInstance->Time() - lhelper->idle_lastmsg, true); const std::string idletime = Time::ToString(lhelper->idle_lastmsg); extra += INSP_FORMAT("{} idle for {} [since {}]", extra.empty() ? ':' : ',', idleperiod, idletime); } stats.AddGenericRow(INSP_FORMAT("\x02{}\x02{} ({}){}", helper->nick, markhelpers ? " [helper]" : "", helper->GetUserHost(), extra)); } // Allow the core to add normal opers. return MOD_RES_PASSTHRU; } ModResult OnUserPreJoin(LocalUser* user, Channel* chan, const std::string& cname, std::string& privs, const std::string& keygiven, bool override) override { if (!user->IsModeSet(helpop)) return MOD_RES_PASSTHRU; for (const auto& [helpchan, prefix] : helpchans) { if (InspIRCd::Match(cname, helpchan)) { privs.append(prefix); break; } } return MOD_RES_PASSTHRU; } void OnUserQuit(User* user, const std::string& message, const std::string& opermessage) override { if (user->IsModeSet(helpop)) stdalgo::erase(helpop.helpers, user); } void OnWhois(Whois::Context& whois) override { if (whois.GetTarget()->IsModeSet(helpop)) whois.SendLine(RPL_WHOISHELPOP, "is available for help."); } }; MODULE_INIT(ModuleHelpMode) �������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/src/modules/m_hidechans.cpp����������������������������������������������������������0000664�0000000�0000000�00000005537�14771603147�0020566�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2018-2022, 2024 Sadie Powell <sadie@witchery.services> * Copyright (C) 2012, 2015 Attila Molnar <attilamolnar@hush.com> * Copyright (C) 2012 Robby <robby@chatbelgie.be> * Copyright (C) 2009-2010 Daniel De Graaf <danieldg@inspircd.org> * Copyright (C) 2006, 2008 Robin Burchell <robin+git@viroteck.net> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include "inspircd.h" #include "modules/who.h" #include "modules/whois.h" /** Handles user mode +I */ class HideChans final : public SimpleUserMode { public: HideChans(Module* Creator) : SimpleUserMode(Creator, "hidechans", 'I') { } }; class ModuleHideChans final : public Module , public Who::VisibleEventListener , public Whois::LineEventListener { private: bool affectsopers; bool hideservices; HideChans hm; ModResult ShouldHideChans(LocalUser* source, User* target) { if (source == target) return MOD_RES_PASSTHRU; // User is targeting themself. if (!target->IsModeSet(hm)) return MOD_RES_PASSTHRU; // Mode not set on the target. if (hideservices && target->server->IsService()) return MOD_RES_DENY; // Nobody is allowed to see services not even opers. if (!affectsopers && source->HasPrivPermission("users/auspex")) return MOD_RES_PASSTHRU; // Opers aren't exempt or the oper doesn't have the right priv. return MOD_RES_DENY; } public: ModuleHideChans() : Module(VF_VENDOR, "Adds user mode I (hidechans) which hides the channels users with it set are in from their /WHOIS response.") , Who::VisibleEventListener(this) , Whois::LineEventListener(this) , hm(this) { } void ReadConfig(ConfigStatus& status) override { const auto& tag = ServerInstance->Config->ConfValue("hidechans"); affectsopers = tag->getBool("affectsopers"); hideservices = tag->getBool("hideservices", true); } ModResult OnWhoVisible(const Who::Request& request, LocalUser* source, Membership* memb) override { return ShouldHideChans(source, memb->user); } ModResult OnWhoisLine(Whois::Context& whois, Numeric::Numeric& numeric) override { if (numeric.GetNumeric() != RPL_WHOISCHANNELS && numeric.GetNumeric() != RPL_CHANNELSMSG) return MOD_RES_PASSTHRU; return ShouldHideChans(whois.GetSource(), whois.GetTarget()); } }; MODULE_INIT(ModuleHideChans) �����������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/src/modules/m_hidelist.cpp�����������������������������������������������������������0000664�0000000�0000000�00000005561�14771603147�0020442�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2019-2023 Sadie Powell <sadie@witchery.services> * Copyright (C) 2018 linuxdaemon <linuxdaemon.irc@gmail.com> * Copyright (C) 2014 Attila Molnar <attilamolnar@hush.com> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include "inspircd.h" #include "numerichelper.h" class ListWatcher final : public ModeWatcher { // Minimum rank required to view the list const ModeHandler::Rank minrank; public: ListWatcher(Module* mod, const std::string& modename, ModeHandler::Rank rank) : ModeWatcher(mod, modename, MODETYPE_CHANNEL) , minrank(rank) { } bool BeforeMode(User* user, User* destuser, Channel* chan, Modes::Change& change) override { // Only handle listmode list requests if (!change.param.empty()) return true; // If the user requesting the list is a member of the channel see if they have the // rank required to view the list Membership* memb = chan->GetUser(user); if ((memb) && (memb->GetRank() >= minrank)) return true; if (user->HasPrivPermission("channels/auspex")) return true; user->WriteNumeric(Numerics::ChannelPrivilegesNeeded(chan, minrank, INSP_FORMAT("view the channel {} list", GetModeName()))); return false; } }; class ModuleHideList final : public Module { std::vector<ListWatcher*> watchers; public: void ReadConfig(ConfigStatus& status) override { std::vector<std::pair<std::string, unsigned int>> newconfigs; for (const auto& [_, tag] : ServerInstance->Config->ConfTags("hidelist")) { std::string modename = tag->getString("mode"); if (modename.empty()) throw ModuleException(this, "Empty <hidelist:mode> at " + tag->source.str()); // If rank is set to 0 everyone inside the channel can view the list, // but non-members may not ModeHandler::Rank rank = tag->getNum<ModeHandler::Rank>("rank", HALFOP_VALUE); newconfigs.emplace_back(modename, rank); } stdalgo::delete_all(watchers); watchers.clear(); for (const auto& [mode, rank] : newconfigs) watchers.push_back(new ListWatcher(this, mode, rank)); } ModuleHideList() : Module(VF_VENDOR, "Allows list mode lists to be hidden from users without a prefix mode ranked equal to or higher than a defined level.") { } ~ModuleHideList() override { stdalgo::delete_all(watchers); } }; MODULE_INIT(ModuleHideList) �����������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/src/modules/m_hidemode.cpp�����������������������������������������������������������0000664�0000000�0000000�00000014615�14771603147�0020413�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2019 Matt Schatz <genius3000@g3k.solutions> * Copyright (C) 2018-2023 Sadie Powell <sadie@witchery.services> * Copyright (C) 2018 linuxdaemon <linuxdaemon.irc@gmail.com> * Copyright (C) 2018 Attila Molnar <attilamolnar@hush.com> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include "inspircd.h" #include "clientprotocolevent.h" namespace { class Settings final { typedef insp::flat_map<std::string, ModeHandler::Rank> RanksToSeeMap; RanksToSeeMap rankstosee; public: ModeHandler::Rank GetRequiredRank(const ModeHandler& mh) const { RanksToSeeMap::const_iterator it = rankstosee.find(mh.name); if (it != rankstosee.end()) return it->second; return 0; } void Load(const Module* mod) { RanksToSeeMap newranks; for (const auto& [_, tag] : ServerInstance->Config->ConfTags("hidemode")) { const std::string modename = tag->getString("mode"); if (modename.empty()) throw ModuleException(mod, "<hidemode:mode> is empty at " + tag->source.str()); ModeHandler::Rank rank = tag->getNum<ModeHandler::Rank>("rank", 0); if (!rank) throw ModuleException(mod, "<hidemode:rank> must be greater than 0 at " + tag->source.str()); ServerInstance->Logs.Debug(MODNAME, "Hiding the {} mode from users below rank {}", modename, rank); newranks.emplace(modename, rank); } rankstosee.swap(newranks); } }; class ModeHook final : public ClientProtocol::EventHook { typedef insp::flat_map<ModeHandler::Rank, const ClientProtocol::MessageList*> FilteredModeMap; std::vector<Modes::ChangeList> modechangelists; std::list<ClientProtocol::Messages::Mode> filteredmodelist; std::list<ClientProtocol::MessageList> filteredmsgplists; FilteredModeMap cache; static ModResult HandleResult(const ClientProtocol::MessageList* filteredmessagelist, ClientProtocol::MessageList& messagelist) { // Deny if member isn't allowed to see even a single mode change from this mode event if (!filteredmessagelist) return MOD_RES_DENY; // Member is allowed to see at least one mode change, replace list if (filteredmessagelist != &messagelist) messagelist = *filteredmessagelist; return MOD_RES_PASSTHRU; } Modes::ChangeList* FilterModeChangeList(const ClientProtocol::Events::Mode& mode, ModeHandler::Rank rank) { Modes::ChangeList* modechangelist = nullptr; for (Modes::ChangeList::List::const_iterator i = mode.GetChangeList().getlist().begin(); i != mode.GetChangeList().getlist().end(); ++i) { const Modes::Change& curr = *i; if (settings.GetRequiredRank(*curr.mh) <= rank) { // No restriction on who can see this mode or there is one but the member's rank is sufficient if (modechangelist) modechangelist->push(curr); continue; } // Member cannot see the current mode change if (!modechangelist) { // Create new mode change list or reuse the last one if it's empty if ((modechangelists.empty()) || (!modechangelists.back().empty())) modechangelists.emplace_back(); // Add all modes to it which we've accepted so far modechangelists.back().push(mode.GetChangeList().getlist().begin(), i); modechangelist = &modechangelists.back(); } } return modechangelist; } void OnEventInit(const ClientProtocol::Event& ev) override { cache.clear(); filteredmsgplists.clear(); filteredmodelist.clear(); modechangelists.clear(); // Ensure no reallocations will happen const size_t numprefixmodes = ServerInstance->Modes.GetPrefixModes().size(); modechangelists.reserve(numprefixmodes); } ModResult OnPreEventSend(LocalUser* user, const ClientProtocol::Event& ev, ClientProtocol::MessageList& messagelist) override { const ClientProtocol::Events::Mode& mode = static_cast<const ClientProtocol::Events::Mode&>(ev); Channel* const chan = mode.GetMessages().front().GetChanTarget(); if (!chan) return MOD_RES_PASSTHRU; if (user->HasPrivPermission("channels/auspex")) return MOD_RES_PASSTHRU; Membership* const memb = chan->GetUser(user); if (!memb) return MOD_RES_PASSTHRU; // Check cache first const FilteredModeMap::const_iterator it = cache.find(memb->GetRank()); if (it != cache.end()) return HandleResult(it->second, messagelist); // Message for this rank isn't cached, generate it now const Modes::ChangeList* const filteredchangelist = FilterModeChangeList(mode, memb->GetRank()); // If no new change list was generated (above method returned NULL) it means the member and everyone else // with the same rank can see everything in the original change list. ClientProtocol::MessageList* finalmsgplist = &messagelist; if (filteredchangelist) { if (filteredchangelist->empty()) { // This rank cannot see any mode changes in the original change list finalmsgplist = nullptr; } else { // This rank can see some of the mode changes in the filtered mode change list. // Create and store a new protocol message from it. filteredmsgplists.emplace_back(); ClientProtocol::Events::Mode::BuildMessages(mode.GetMessages().front().GetSourceUser(), chan, nullptr, *filteredchangelist, filteredmodelist, filteredmsgplists.back()); finalmsgplist = &filteredmsgplists.back(); } } // Cache the result in all cases so it can be reused for further members with the same rank cache.emplace(memb->GetRank(), finalmsgplist); return HandleResult(finalmsgplist, messagelist); } public: Settings settings; ModeHook(Module* mod) : ClientProtocol::EventHook(mod, "MODE", 10) { } }; } class ModuleHideMode final : public Module { private: ModeHook modehook; public: ModuleHideMode() : Module(VF_VENDOR, "Allows mode changes to be hidden from users without a prefix mode ranked equal to or higher than a defined level.") , modehook(this) { } void ReadConfig(ConfigStatus& status) override { modehook.settings.Load(this); } }; MODULE_INIT(ModuleHideMode) �������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/src/modules/m_hideoper.cpp�����������������������������������������������������������0000664�0000000�0000000�00000013047�14771603147�0020432�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2019 linuxdaemon <linuxdaemon.irc@gmail.com> * Copyright (C) 2015, 2017-2023, 2025 Sadie Powell <sadie@witchery.services> * Copyright (C) 2014 Adam <Adam@anope.org> * Copyright (C) 2012-2013, 2015-2016 Attila Molnar <attilamolnar@hush.com> * Copyright (C) 2012 Robby <robby@chatbelgie.be> * Copyright (C) 2009-2010 Daniel De Graaf <danieldg@inspircd.org> * Copyright (C) 2008 Geoff Bricker <geoff.bricker@gmail.com> * Copyright (C) 2006 Craig Edwards <brain@inspircd.org> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include "inspircd.h" #include "modules/stats.h" #include "modules/who.h" #include "modules/whois.h" #include "timeutils.h" /** Handles user mode +H */ class HideOper final : public SimpleUserMode { public: size_t opercount = 0; HideOper(Module* Creator) : SimpleUserMode(Creator, "hideoper", 'H', true) { } bool OnModeChange(User* source, User* dest, Channel* channel, Modes::Change& change) override { if (!SimpleUserMode::OnModeChange(source, dest, channel, change)) return false; if (change.adding) opercount++; else opercount--; return true; } }; class ModuleHideOper final : public Module , public Stats::EventListener , public Who::EventListener , public Whois::LineEventListener { private: HideOper hm; bool active = false; public: ModuleHideOper() : Module(VF_VENDOR, "Adds user mode H (hideoper) which hides the server operator status of a user from unprivileged users.") , Stats::EventListener(this) , Who::EventListener(this) , Whois::LineEventListener(this) , hm(this) { } void OnUserQuit(User* user, const std::string&, const std::string&) override { if (user->IsModeSet(hm)) hm.opercount--; } ModResult OnNumeric(User* user, const Numeric::Numeric& numeric) override { if (numeric.GetNumeric() != RPL_LUSEROP || active || user->HasPrivPermission("users/auspex")) return MOD_RES_PASSTHRU; // If there are no visible operators then we shouldn't send the numeric. size_t opercount = ServerInstance->Users.all_opers.size() - hm.opercount; if (opercount) { active = true; user->WriteNumeric(RPL_LUSEROP, opercount, "operator(s) online"); active = false; } return MOD_RES_DENY; } ModResult OnWhoisLine(Whois::Context& whois, Numeric::Numeric& numeric) override { /* Dont display numeric 313 (RPL_WHOISOPER) if they have +H set and the * person doing the WHOIS is not an oper */ if (numeric.GetNumeric() != RPL_WHOISOPERATOR) return MOD_RES_PASSTHRU; if (!whois.GetTarget()->IsModeSet(hm)) return MOD_RES_PASSTHRU; if (!whois.GetSource()->HasPrivPermission("users/auspex")) return MOD_RES_DENY; return MOD_RES_PASSTHRU; } ModResult OnWhoLine(const Who::Request& request, LocalUser* source, User* user, Membership* memb, Numeric::Numeric& numeric) override { if (user->IsModeSet(hm) && !source->HasPrivPermission("users/auspex")) { // Hide the line completely if doing a "/who * o" query if (request.flags['o']) return MOD_RES_DENY; size_t flag_index; if (!request.GetFieldIndex('f', flag_index)) return MOD_RES_PASSTHRU; // hide the "*" that marks the user as an oper from the /WHO line // #chan ident localhost insp22.test nick H@ :0 Attila if (numeric.GetParams().size() <= flag_index) return MOD_RES_PASSTHRU; std::string& param = numeric.GetParams()[flag_index]; const std::string::size_type pos = param.find('*'); if (pos != std::string::npos) param.erase(pos, 1); } return MOD_RES_PASSTHRU; } ModResult OnStats(Stats::Context& stats) override { if (stats.GetSymbol() != 'P') return MOD_RES_PASSTHRU; bool source_has_priv = stats.GetSource()->HasPrivPermission("users/auspex"); for (auto* oper : ServerInstance->Users.all_opers) { if (oper->server->IsService() || (oper->IsModeSet(hm) && !source_has_priv)) continue; std::string extra; if (oper->IsAway()) { const std::string awayperiod = Duration::ToLongString(ServerInstance->Time() - oper->away->time, true); const std::string awaytime = Time::ToString(oper->away->time); extra = INSP_FORMAT(": away for {} [since {}] ({})", awayperiod, awaytime, oper->away->message); } auto* loper = IS_LOCAL(oper); if (loper) { const std::string idleperiod = Duration::ToLongString(ServerInstance->Time() - loper->idle_lastmsg, true); const std::string idletime = Time::ToString(loper->idle_lastmsg); extra += INSP_FORMAT("{} idle for {} [since {}]", extra.empty() ? ':' : ',', idleperiod, idletime); } stats.AddGenericRow(INSP_FORMAT("\x02{}\x02 ({}){}", oper->nick, oper->GetUserHost(), extra)); } // Sort opers alphabetically. std::sort(stats.GetRows().begin(), stats.GetRows().end(), [](const auto& lhs, const auto& rhs) { return lhs.GetParams()[1] < rhs.GetParams()[1]; }); stats.AddGenericRow(INSP_FORMAT("{} server operator{} total", stats.GetRows().size(), stats.GetRows().size() ? "s" : "")); return MOD_RES_DENY; } }; MODULE_INIT(ModuleHideOper) �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/src/modules/m_hostcycle.cpp����������������������������������������������������������0000664�0000000�0000000�00000006452�14771603147�0020632�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2017-2023 Sadie Powell <sadie@witchery.services> * Copyright (C) 2013-2015, 2018 Attila Molnar <attilamolnar@hush.com> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include "inspircd.h" #include "clientprotocolevent.h" #include "modules/cap.h" class ModuleHostCycle final : public Module { Cap::Reference chghostcap; const std::string quitmsghost; const std::string quitmsguser; // Sends a fake quit/join/mode messages for hostame or username cycle. void DoHostCycle(User* user, const std::string& newuser, const std::string& newhost, const std::string& reason) { // The user has the original username/hostname at the time this function is called ClientProtocol::Messages::Quit quitmsg(user, reason); ClientProtocol::Event quitevent(ServerInstance->GetRFCEvents().quit, quitmsg); uint64_t silent_id = ServerInstance->Users.NextAlreadySentId(); uint64_t seen_id = ServerInstance->Users.NextAlreadySentId(); User::NeighborList include_chans(user->chans.begin(), user->chans.end()); User::NeighborExceptions exceptions; FOREACH_MOD(OnBuildNeighborList, (user, include_chans, exceptions)); // Users shouldn't see themselves quitting when host cycling exceptions.erase(user); for (const auto& [exception, sendto] : exceptions) { LocalUser* u = IS_LOCAL(exception); if ((u) && (!u->quitting) && (!chghostcap.IsEnabled(u))) { if (sendto) { u->already_sent = seen_id; u->Send(quitevent); } else { u->already_sent = silent_id; } } } const std::string newfullhost = user->nick + "!" + newuser + "@" + newhost; for (auto* memb : include_chans) { Channel* c = memb->chan; ClientProtocol::Events::Join joinevent(memb, newfullhost); for (const auto& [chanuser, _] : c->GetUsers()) { LocalUser* u = IS_LOCAL(chanuser); if (!u || u == user) continue; if (u->already_sent == silent_id) continue; if (chghostcap.IsEnabled(u)) continue; if (u->already_sent != seen_id) { u->Send(quitevent); u->already_sent = seen_id; } u->Send(joinevent); } } } public: ModuleHostCycle() : Module(VF_VENDOR, "Sends a fake disconnection and reconnection when a user's username or hostname changes to allow clients to update their internal caches.") , chghostcap(this, "chghost") , quitmsghost("Changing hostname") , quitmsguser("Changing username") { } void OnChangeUser(User* user, const std::string& newuser) override { DoHostCycle(user, newuser, user->GetDisplayedHost(), quitmsguser); } void OnChangeHost(User* user, const std::string& newhost) override { DoHostCycle(user, user->GetDisplayedUser(), newhost, quitmsghost); } }; MODULE_INIT(ModuleHostCycle) ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/src/modules/m_httpd.cpp��������������������������������������������������������������0000664�0000000�0000000�00000030214�14771603147�0017751�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2021 Dominic Hamon * Copyright (C) 2019 linuxdaemon <linuxdaemon.irc@gmail.com> * Copyright (C) 2018 edef <edef@edef.eu> * Copyright (C) 2013-2014, 2017, 2019-2023, 2025 Sadie Powell <sadie@witchery.services> * Copyright (C) 2012-2016 Attila Molnar <attilamolnar@hush.com> * Copyright (C) 2012 Robby <robby@chatbelgie.be> * Copyright (C) 2009 Daniel De Graaf <danieldg@inspircd.org> * Copyright (C) 2008 Robin Burchell <robin+git@viroteck.net> * Copyright (C) 2007 John Brooks <john@jbrooks.io> * Copyright (C) 2007 Dennis Friis <peavey@inspircd.org> * Copyright (C) 2006, 2008 Craig Edwards <brain@inspircd.org> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include "inspircd.h" #include "iohook.h" #include "modules/httpd.h" #include "utility/string.h" #ifdef __GNUC__ # pragma GCC diagnostic push #endif // Fix warnings about shadowing in http_parser. #ifdef __GNUC__ # pragma GCC diagnostic ignored "-Wshadow" #endif #include <http_parser/http_parser.c> #ifdef __GNUC__ # pragma GCC diagnostic pop #endif class ModuleHttpServer; static ModuleHttpServer* HttpModule; static insp::intrusive_list<HttpServerSocket> sockets; static Events::ModuleEventProvider* aclevprov; static Events::ModuleEventProvider* reqevprov; static http_parser_settings parser_settings; /** A socket used for HTTP transport */ class HttpServerSocket final : public BufferedSocket , public Timer , public insp::intrusive_list_node<HttpServerSocket> { private: friend class ModuleHttpServer; http_parser parser; http_parser_url url; std::string ip; std::string uri; HTTPHeaders headers; std::string body; size_t total_buffers; int status_code = 0; /** True if this object is in the cull list */ bool waitingcull = false; bool messagecomplete = false; bool Tick() override { if (!messagecomplete) { ServerInstance->Logs.Debug(MODNAME, "HTTP socket {} timed out", GetFd()); Close(); return false; } return true; } template<int (HttpServerSocket::*f)()> static int Callback(http_parser* p) { HttpServerSocket* sock = static_cast<HttpServerSocket*>(p->data); return (sock->*f)(); } template<int (HttpServerSocket::*f)(const char*, size_t)> static int DataCallback(http_parser* p, const char* buf, size_t len) { HttpServerSocket* sock = static_cast<HttpServerSocket*>(p->data); return (sock->*f)(buf, len); } static void ConfigureParser() { http_parser_settings_init(&parser_settings); parser_settings.on_message_begin = Callback<&HttpServerSocket::OnMessageBegin>; parser_settings.on_url = DataCallback<&HttpServerSocket::OnUrl>; parser_settings.on_header_field = DataCallback<&HttpServerSocket::OnHeaderField>; parser_settings.on_header_value = DataCallback<&HttpServerSocket::OnHeaderValue>; parser_settings.on_headers_complete = Callback<&HttpServerSocket::OnHeadersComplete>; parser_settings.on_body = DataCallback<&HttpServerSocket::OnBody>; parser_settings.on_message_complete = Callback<&HttpServerSocket::OnMessageComplete>; } int OnMessageBegin() { uri.clear(); header_state = HEADER_NONE; body.clear(); total_buffers = 0; return 0; } bool AcceptData(size_t len) { total_buffers += len; return total_buffers < 8192; } int OnUrl(const char* buf, size_t len) { if (!AcceptData(len)) { status_code = HTTP_STATUS_URI_TOO_LONG; return -1; } uri.append(buf, len); return 0; } enum { HEADER_NONE, HEADER_FIELD, HEADER_VALUE } header_state; std::string header_field; std::string header_value; void OnHeaderComplete() { headers.SetHeader(header_field, header_value); header_field.clear(); header_value.clear(); } int OnHeaderField(const char* buf, size_t len) { if (header_state == HEADER_VALUE) OnHeaderComplete(); header_state = HEADER_FIELD; if (!AcceptData(len)) { status_code = HTTP_STATUS_REQUEST_HEADER_FIELDS_TOO_LARGE; return -1; } header_field.append(buf, len); return 0; } int OnHeaderValue(const char* buf, size_t len) { header_state = HEADER_VALUE; if (!AcceptData(len)) { status_code = HTTP_STATUS_REQUEST_HEADER_FIELDS_TOO_LARGE; return -1; } header_value.append(buf, len); return 0; } int OnHeadersComplete() { if (header_state != HEADER_NONE) OnHeaderComplete(); return 0; } int OnBody(const char* buf, size_t len) { if (!AcceptData(len)) { status_code = HTTP_STATUS_PAYLOAD_TOO_LARGE; return -1; } body.append(buf, len); return 0; } int OnMessageComplete() { messagecomplete = true; ServeData(); return 0; } public: HttpServerSocket(int newfd, const std::string& IP, ListenSocket* via, const irc::sockets::sockaddrs& client, const irc::sockets::sockaddrs& server, unsigned long timeoutsec) : BufferedSocket(newfd) , Timer(timeoutsec, false) , ip(IP) { if ((!via->iohookprovs.empty()) && (via->iohookprovs.back())) { via->iohookprovs.back()->OnAccept(this, client, server); // IOHook may have errored if (!GetError().empty()) { ServerInstance->Logs.Debug(MODNAME, "HTTP socket {} encountered a hook error: {}", GetFd(), GetError()); Close(); return; } } parser.data = this; http_parser_init(&parser, HTTP_REQUEST); ServerInstance->Timers.AddTimer(this); } ~HttpServerSocket() override { sockets.erase(this); } void Close() override { if (waitingcull || !HasFd()) return; waitingcull = true; BufferedSocket::Close(); ServerInstance->GlobalCulls.AddItem(this); } void OnError(BufferedSocketError err) override { ServerInstance->Logs.Debug(MODNAME, "HTTP socket {} encountered an error: {} - {}", GetFd(), (int)err, GetError()); Close(); } void SendHTTPError(unsigned int response, const char* errstr = nullptr) { if (!errstr) errstr = http_status_str((http_status)response); ServerInstance->Logs.Debug(MODNAME, "Sending HTTP error {}: {}", response, errstr); static HTTPHeaders empty; std::string data = INSP_FORMAT( "<html><head></head><body style='font-family: sans-serif; text-align: center'>" "<h1 style='font-size: 48pt'>Error {}</h1><h2 style='font-size: 24pt'>{}</h2><hr>" "<small>Powered by <a href='https://www.inspircd.org'>InspIRCd</a></small></body></html>", response, errstr); Page(data, response, &empty); } void SendHeaders(unsigned long size, unsigned int response, HTTPHeaders& rheaders) { WriteData(INSP_FORMAT("HTTP/{}.{} {} {}\r\n", parser.http_major ? parser.http_major : 1, parser.http_major ? parser.http_minor : 1, response, http_status_str((http_status)response))); rheaders.CreateHeader("Date", Time::ToString(ServerInstance->Time(), Time::RFC_1123, true)); rheaders.CreateHeader("Server", INSPIRCD_BRANCH); rheaders.SetHeader("Content-Length", ConvToStr(size)); if (size) rheaders.CreateHeader("Content-Type", "text/html"); else rheaders.RemoveHeader("Content-Type"); /* Supporting Connection: keep-alive causes a whole world of hurt synchronizing timeouts, * so remove it, its not essential for what we need. */ rheaders.SetHeader("Connection", "Close"); WriteData(rheaders.GetFormattedHeaders()); WriteData("\r\n"); } void OnDataReady() override { if (parser.upgrade || HTTP_PARSER_ERRNO(&parser)) return; http_parser_execute(&parser, &parser_settings, recvq.data(), recvq.size()); if (parser.upgrade) SendHTTPError(status_code ? status_code : 400); else if (HTTP_PARSER_ERRNO(&parser)) SendHTTPError(status_code ? status_code : 400, http_errno_description((http_errno)parser.http_errno)); } void ServeData() { std::string method = http_method_str(static_cast<http_method>(parser.method)); HTTPRequestURI parsed; ParseURI(uri, parsed); HTTPRequest acl(method, parsed, &headers, this, ip, body); ModResult res = aclevprov->FirstResult(&HTTPACLEventListener::OnHTTPACLCheck, acl); if (res != MOD_RES_DENY) { HTTPRequest request(method, parsed, &headers, this, ip, body); res = reqevprov->FirstResult(&HTTPRequestEventListener::OnHTTPRequest, request); if (res == MOD_RES_PASSTHRU) { SendHTTPError(404); } } } void Page(const std::string& s, unsigned int response, HTTPHeaders* hheaders) { SendHeaders(s.length(), response, *hheaders); WriteData(s); BufferedSocket::Close(true); } void Page(std::stringstream* n, unsigned int response, HTTPHeaders* hheaders) { Page(n->str(), response, hheaders); } bool ParseURI(const std::string& uristr, HTTPRequestURI& out) { http_parser_url_init(&url); if (http_parser_parse_url(uristr.c_str(), uristr.size(), 0, &url) != 0) return false; if (url.field_set & (1 << UF_PATH)) { // Normalise the path. std::vector<std::string> pathsegments; irc::sepstream pathstream(uri.substr(url.field_data[UF_PATH].off, url.field_data[UF_PATH].len), '/'); for (std::string pathsegment; pathstream.GetToken(pathsegment); ) { if (pathsegment == ".") { // Stay at the current level. continue; } if (pathsegment == "..") { // Traverse up to the previous level. if (!pathsegments.empty()) pathsegments.pop_back(); continue; } pathsegments.push_back(pathsegment); } out.path.reserve(url.field_data[UF_PATH].len); out.path.append("/").append(insp::join(pathsegments, '/')); } if (url.field_set & (1 << UF_FRAGMENT)) out.fragment = uri.substr(url.field_data[UF_FRAGMENT].off, url.field_data[UF_FRAGMENT].len); std::string param_str; if (url.field_set & (1 << UF_QUERY)) param_str = uri.substr(url.field_data[UF_QUERY].off, url.field_data[UF_QUERY].len); irc::sepstream param_stream(param_str, '&'); std::string token; std::string::size_type eq_pos; while (param_stream.GetToken(token)) { eq_pos = token.find('='); if (eq_pos == std::string::npos) { out.query_params.emplace(token, ""); } else { out.query_params.emplace(token.substr(0, eq_pos), token.substr(eq_pos + 1)); } } return true; } }; class HTTPdAPIImpl final : public HTTPdAPIBase { public: HTTPdAPIImpl(Module* parent) : HTTPdAPIBase(parent) { } void SendResponse(HTTPDocumentResponse& resp) override { resp.src.sock->Page(resp.document, resp.responsecode, &resp.headers); } }; class ModuleHttpServer final : public Module { private: HTTPdAPIImpl APIImpl; unsigned long timeoutsec; Events::ModuleEventProvider acleventprov; Events::ModuleEventProvider reqeventprov; public: ModuleHttpServer() : Module(VF_VENDOR, "Allows the server administrator to serve various useful resources over HTTP.") , APIImpl(this) , acleventprov(this, "event/http-acl") , reqeventprov(this, "event/http-request") { aclevprov = &acleventprov; reqevprov = &reqeventprov; HttpServerSocket::ConfigureParser(); } void init() override { HttpModule = this; } void ReadConfig(ConfigStatus& status) override { const auto& tag = ServerInstance->Config->ConfValue("httpd"); timeoutsec = tag->getDuration("timeout", 10, 1); } ModResult OnAcceptConnection(int nfd, ListenSocket* from, const irc::sockets::sockaddrs& client, const irc::sockets::sockaddrs& server) override { if (!insp::equalsci(from->bind_tag->getString("type"), "httpd")) return MOD_RES_PASSTHRU; sockets.push_front(new HttpServerSocket(nfd, client.addr(), from, client, server, timeoutsec)); return MOD_RES_ALLOW; } void OnUnloadModule(Module* mod) override { for (insp::intrusive_list<HttpServerSocket>::const_iterator i = sockets.begin(); i != sockets.end(); ) { HttpServerSocket* sock = *i; ++i; if (sock->GetModHook(mod)) { sock->Cull(); delete sock; } } } Cullable::Result Cull() override { for (auto* sock : sockets) sock->Close(); return Module::Cull(); } }; MODULE_INIT(ModuleHttpServer) ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/src/modules/m_httpd_acl.cpp����������������������������������������������������������0000664�0000000�0000000�00000020254�14771603147�0020573�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2018 linuxdaemon <linuxdaemon.irc@gmail.com> * Copyright (C) 2013, 2017, 2019-2023 Sadie Powell <sadie@witchery.services> * Copyright (C) 2013, 2015 Attila Molnar <attilamolnar@hush.com> * Copyright (C) 2012 Robby <robby@chatbelgie.be> * Copyright (C) 2009-2010 Daniel De Graaf <danieldg@inspircd.org> * Copyright (C) 2008 Robin Burchell <robin+git@viroteck.net> * Copyright (C) 2008 Craig Edwards <brain@inspircd.org> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include "inspircd.h" #include "modules/httpd.h" #include "stringutils.h" #include "utility/string.h" class HTTPACL final { public: std::string path; std::string username; std::string password; std::string whitelist; std::string blacklist; HTTPACL(const std::string& set_path, const std::string& set_username, const std::string& set_password, const std::string& set_whitelist, const std::string& set_blacklist) : path(set_path) , username(set_username) , password(set_password) , whitelist(set_whitelist) , blacklist(set_blacklist) { } }; class ModuleHTTPAccessList final : public Module , public HTTPACLEventListener { private: std::vector<HTTPACL> acl_list; HTTPdAPI API; public: ModuleHTTPAccessList() : Module(VF_VENDOR, "Allows the server administrator to control who can access resources served over HTTP with the httpd module.") , HTTPACLEventListener(this) , API(this) { } void ReadConfig(ConfigStatus& status) override { std::vector<HTTPACL> new_acls; for (const auto& [_, c] : ServerInstance->Config->ConfTags("httpdacl")) { std::string path = c->getString("path"); std::string types = c->getString("types"); irc::commasepstream sep(types); std::string type; std::string username; std::string password; std::string whitelist; std::string blacklist; while (sep.GetToken(type)) { if (insp::equalsci(type, "password")) { username = c->getString("username"); password = c->getString("password"); } else if (insp::equalsci(type, "whitelist")) { whitelist = c->getString("whitelist"); } else if (insp::equalsci(type, "blacklist")) { blacklist = c->getString("blacklist"); } else { throw ModuleException(this, "Invalid HTTP ACL type '" + type + "'"); } } ServerInstance->Logs.Debug(MODNAME, "Read ACL: path={} pass={} whitelist={} blacklist={}", path, password, whitelist, blacklist); new_acls.emplace_back(path, username, password, whitelist, blacklist); } acl_list.swap(new_acls); } void BlockAccess(HTTPRequest* http, unsigned int returnval, const std::string& extraheaderkey = "", const std::string& extraheaderval="") { ServerInstance->Logs.Debug(MODNAME, "BlockAccess ({})", returnval); std::stringstream data; data << "<html><head></head><body style='font-family: sans-serif; text-align: center'>" << "<h1 style='font-size: 48pt'>Error " << returnval << "</h1>" << "<h2 style='font-size: 24pt'>Access to this resource is denied by an access control list.</h2>" << "<h2 style='font-size: 24pt'>Please contact your IRC administrator.</h2><hr>" << "<small>Powered by <a href='https://www.inspircd.org'>InspIRCd</a></small></body></html>"; HTTPDocumentResponse response(this, *http, &data, returnval); response.headers.SetHeader("X-Powered-By", MODNAME); if (!extraheaderkey.empty()) response.headers.SetHeader(extraheaderkey, extraheaderval); API->SendResponse(response); } bool IsAccessAllowed(HTTPRequest* http) { { ServerInstance->Logs.Debug(MODNAME, "Handling httpd acl event"); for (const auto& acl : acl_list) { if (InspIRCd::Match(http->GetPath(), acl.path, ascii_case_insensitive_map)) { if (!acl.blacklist.empty()) { /* Blacklist */ irc::commasepstream sep(acl.blacklist); std::string entry; while (sep.GetToken(entry)) { if (InspIRCd::Match(http->GetIP(), entry, ascii_case_insensitive_map)) { ServerInstance->Logs.Debug(MODNAME, "Denying access to blacklisted resource {} (matched by pattern {}) from ip {} (matched by entry {})", http->GetPath(), acl.path, http->GetIP(), entry); BlockAccess(http, 403); return false; } } } if (!acl.whitelist.empty()) { /* Whitelist */ irc::commasepstream sep(acl.whitelist); std::string entry; bool allow_access = false; while (sep.GetToken(entry)) { if (InspIRCd::Match(http->GetIP(), entry, ascii_case_insensitive_map)) allow_access = true; } if (!allow_access) { ServerInstance->Logs.Debug(MODNAME, "Denying access to whitelisted resource {} (matched by pattern {}) from ip {} (Not in whitelist)", http->GetPath(), acl.path, http->GetIP()); BlockAccess(http, 403); return false; } } if (!acl.password.empty() && !acl.username.empty()) { /* Password auth, first look to see if we have a basic authentication header */ ServerInstance->Logs.Debug(MODNAME, "Checking HTTP auth password for resource {} (matched by pattern {}) from ip {}, against username {}", http->GetPath(), acl.path, http->GetIP(), acl.username); if (http->headers->IsSet("Authorization")) { /* Password has been given, validate it */ std::string authorization = http->headers->GetHeader("Authorization"); irc::spacesepstream sep(authorization); std::string authtype; std::string base64; sep.GetToken(authtype); if (authtype == "Basic") { std::string user; std::string pass; sep.GetToken(base64); std::string userpass = Base64::Decode(base64); ServerInstance->Logs.Debug(MODNAME, "HTTP authorization: {} ({})", userpass, base64); irc::sepstream userpasspair(userpass, ':'); if (userpasspair.GetToken(user)) { userpasspair.GetToken(pass); /* Access granted if username and password are correct */ if (InspIRCd::TimingSafeCompare(user, acl.username) && InspIRCd::TimingSafeCompare(pass, acl.password)) { ServerInstance->Logs.Debug(MODNAME, "HTTP authorization: password and username match"); return true; } else { /* Invalid password */ ServerInstance->Logs.Debug(MODNAME, "HTTP authorization: password and username do not match"); BlockAccess(http, 401, "WWW-Authenticate", "Basic realm=\"Restricted Object\""); } } else { /* Malformed user:pass pair */ ServerInstance->Logs.Debug(MODNAME, "HTTP authorization: password and username malformed"); BlockAccess(http, 401, "WWW-Authenticate", "Basic realm=\"Restricted Object\""); } } else { /* Unsupported authentication type */ ServerInstance->Logs.Debug(MODNAME, "HTTP authorization: unsupported auth type: {}", authtype); BlockAccess(http, 401, "WWW-Authenticate", "Basic realm=\"Restricted Object\""); } } else { /* No password given at all, access denied */ ServerInstance->Logs.Debug(MODNAME, "HTTP authorization: password and username not sent"); BlockAccess(http, 401, "WWW-Authenticate", "Basic realm=\"Restricted Object\""); } return false; } /* A path may only match one ACL (the first it finds in the config file) */ break; } } } return true; } ModResult OnHTTPACLCheck(HTTPRequest& req) override { if (IsAccessAllowed(&req)) return MOD_RES_PASSTHRU; return MOD_RES_DENY; } }; MODULE_INIT(ModuleHTTPAccessList) ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/src/modules/m_httpd_config.cpp�������������������������������������������������������0000664�0000000�0000000�00000004704�14771603147�0021303�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2013, 2018-2021, 2023 Sadie Powell <sadie@witchery.services> * Copyright (C) 2013, 2015 Attila Molnar <attilamolnar@hush.com> * Copyright (C) 2012 Robby <robby@chatbelgie.be> * Copyright (C) 2009-2010 Daniel De Graaf <danieldg@inspircd.org> * Copyright (C) 2009 Uli Schlachter <psychon@znc.in> * Copyright (C) 2008 Craig Edwards <brain@inspircd.org> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include "inspircd.h" #include "modules/httpd.h" class ModuleHttpConfig final : public Module , public HTTPRequestEventListener { private: HTTPdAPI API; public: ModuleHttpConfig() : Module(VF_VENDOR, "Allows the server configuration to be viewed over HTTP via the /config path.") , HTTPRequestEventListener(this) , API(this) { } ModResult OnHTTPRequest(HTTPRequest& request) override { if (request.GetPath() != "/config") return MOD_RES_PASSTHRU; ServerInstance->Logs.Debug(MODNAME, "Handling HTTP request for {}", request.GetPath()); std::stringstream buffer; for (const auto& [_, tag] : ServerInstance->Config->GetConfig()) { // Show the location of the tag in a comment. buffer << "# " << tag->source.str() << std::endl << '<' << tag->name << ' '; // Print out the tag with all keys aligned vertically. const std::string indent(tag->name.length() + 2, ' '); bool first = true; for (const auto& [key, value] : tag->GetItems()) { if (!first) buffer << std::endl << indent; buffer << key << "=\"" << ServerConfig::Escape(value) << '"'; first = false; } buffer << '>' << std::endl << std::endl; } HTTPDocumentResponse response(this, request, &buffer, 200); response.headers.SetHeader("X-Powered-By", MODNAME); response.headers.SetHeader("Content-Type", "text/plain"); API->SendResponse(response); return MOD_RES_DENY; } }; MODULE_INIT(ModuleHttpConfig) ������������������������������������������������������������inspircd-4.7.0/src/modules/m_httpd_stats.cpp��������������������������������������������������������0000664�0000000�0000000�00000032017�14771603147�0021172�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2019 linuxdaemon <linuxdaemon.irc@gmail.com> * Copyright (C) 2016 Johanna A * Copyright (C) 2013, 2020-2023, 2025 Sadie Powell <sadie@witchery.services> * Copyright (C) 2013, 2015 Attila Molnar <attilamolnar@hush.com> * Copyright (C) 2012 Robby <robby@chatbelgie.be> * Copyright (C) 2009 Daniel De Graaf <danieldg@inspircd.org> * Copyright (C) 2008 Robin Burchell <robin+git@viroteck.net> * Copyright (C) 2008 Pippijn van Steenhoven <pip88nl@gmail.com> * Copyright (C) 2007 John Brooks <john@jbrooks.io> * Copyright (C) 2007 Dennis Friis <peavey@inspircd.org> * Copyright (C) 2006-2008 Craig Edwards <brain@inspircd.org> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include "inspircd.h" #include "extension.h" #include "modules/isupport.h" #include "modules/httpd.h" #include "xline.h" #include <stack> static ISupport::EventProvider* isevprov; namespace Stats { static const insp::flat_map<char, char const*> xmlentities = { { '<', "lt" }, { '>', "gt" }, { '&', "amp" }, { '"', "quot" }, }; std::string Sanitize(const std::string& str) { std::string ret; ret.reserve(str.length() * 2); for (const auto chr : str) { insp::flat_map<char, char const*>::const_iterator it = xmlentities.find(chr); if (it != xmlentities.end()) { ret += '&'; ret += it->second; ret += ';'; } else if (chr == 0x09 || chr == 0x0A || chr == 0x0D || ((chr >= 0x20) && (chr <= 0x7e))) { // The XML specification defines the following characters as valid inside an XML document: // Char ::= #x9 | #xA | #xD | [#x20-#xD7FF] | [#xE000-#xFFFD] | [#x10000-#x10FFFF] ret += chr; } else { // If we reached this point then the string contains characters which can // not be represented in XML, even using a numeric escape. Therefore, we // Base64 encode the entire string and wrap it in a CDATA. ret.clear(); ret += "<![CDATA["; ret += Base64::Encode(str, nullptr, '='); ret += "]]>"; break; } } return ret; } class XMLSerializer final { private: std::stack<const char*> blocks; std::stringstream data; public: XMLSerializer& Attribute(const char* name, const std::string& value) { if (value.empty()) data << '<' << name << "/>"; else data << '<' << name << '>' << Sanitize(value) << "</" << name << '>'; return *this; } template<typename Numeric> std::enable_if_t<std::is_arithmetic_v<Numeric>, XMLSerializer&> Attribute(const char* name, const Numeric& value) { return Attribute(name, ConvToStr(value)); } std::stringstream* GetData() { return &data; } XMLSerializer& BeginBlock(const char* name) { blocks.push(name); data << '<' << name << '>'; return *this; } XMLSerializer& EndBlock() { const char* name = blocks.top(); data << "</" << name << '>'; blocks.pop(); return *this; } }; void DumpMeta(XMLSerializer& serializer, Extensible* ext) { serializer.BeginBlock("metadata"); for (const auto& [item, obj] : ext->GetExtList()) { serializer.BeginBlock("meta") .Attribute("name", item->name); const std::string value = item->ToHuman(ext, obj); serializer.Attribute("value", value) .EndBlock(); } serializer.EndBlock(); } void ServerInfo(XMLSerializer& serializer) { serializer.BeginBlock("server") .Attribute("id", ServerInstance->Config->ServerId) .Attribute("name", ServerInstance->Config->ServerName) .Attribute("description", ServerInstance->Config->ServerDesc) .Attribute("customversion", ServerInstance->Config->CustomVersion) .Attribute("version", INSPIRCD_VERSION) .EndBlock(); } void ISupport(XMLSerializer& serializer) { ISupport::TokenMap tokens; isevprov->Call(&ISupport::EventListener::OnBuildISupport, tokens); serializer.BeginBlock("isupport"); for (const auto& [key, value] : tokens) { serializer.BeginBlock("token") .Attribute("name", key) .Attribute("value", value) .EndBlock(); } serializer.EndBlock(); } void General(XMLSerializer& serializer) { serializer.BeginBlock("general") .Attribute("usercount", ServerInstance->Users.GetUsers().size()) .Attribute("localusercount", ServerInstance->Users.GetLocalUsers().size()) .Attribute("channelcount", ServerInstance->Channels.GetChans().size()) .Attribute("opercount", ServerInstance->Users.all_opers.size()) .Attribute("socketcount", SocketEngine::GetUsedFds()) .Attribute("socketmax", SocketEngine::GetMaxFds()) .Attribute("boottime", ServerInstance->startup_time) .Attribute("currenttime", ServerInstance->Time()); ISupport(serializer); serializer.EndBlock(); } void XLines(XMLSerializer& serializer) { serializer.BeginBlock("xlines"); for (const auto& xltype : ServerInstance->XLines->GetAllTypes()) { XLineLookup* lookup = ServerInstance->XLines->GetAll(xltype); if (!lookup) continue; for (const auto& [_, xline] : *lookup) { serializer.BeginBlock("xline") .Attribute("type", xltype) .Attribute("mask", xline->Displayable()) .Attribute("settime", xline->set_time) .Attribute("duration", xline->duration) .Attribute("reason", xline->reason) .EndBlock(); } } serializer.EndBlock(); } void Modules(XMLSerializer& serializer) { serializer.BeginBlock("modulelist"); for (const auto& [modname, mod] : ServerInstance->Modules.GetModules()) { serializer.BeginBlock("module") .Attribute("name", modname) .Attribute("description", mod->description) .EndBlock(); } serializer.EndBlock(); } void Channels(XMLSerializer& serializer) { serializer.BeginBlock("channellist"); for (const auto& [_, c] : ServerInstance->Channels.GetChans()) { serializer.BeginBlock("channel") .Attribute("channelname", c->name) .Attribute("usercount", c->GetUsers().size()) .Attribute("channelmodes", c->ChanModes(true)); if (!c->topic.empty()) { serializer.BeginBlock("channeltopic") .Attribute("topictext", c->topic) .Attribute("setby", c->setby) .Attribute("settime", c->topicset) .EndBlock(); } for (const auto& [__, memb] : c->GetUsers()) { serializer.BeginBlock("channelmember") .Attribute("uid", memb->user->uuid) .Attribute("privs", memb->GetAllPrefixChars()) .Attribute("modes", memb->GetAllPrefixModes()); DumpMeta(serializer, memb); serializer.EndBlock(); } DumpMeta(serializer, c); serializer.EndBlock(); } serializer.EndBlock(); } void DumpUser(XMLSerializer& serializer, User* u) { serializer.BeginBlock("user") .Attribute("nickname", u->nick) .Attribute("uuid", u->uuid) .Attribute("realhost", u->GetRealHost()) .Attribute("displayhost", u->GetDisplayedHost()) .Attribute("realname", u->GetRealName()) .Attribute("server", u->server->GetName()) .Attribute("signon", u->signon) .Attribute("nickchanged", u->nickchanged) .Attribute("modes", u->GetModeLetters().substr(1)) .Attribute("realuser", u->GetRealUser()) .Attribute("displayuser", u->GetDisplayedUser()) .Attribute("ipaddress", u->GetAddress()); if (u->IsAway()) { serializer.Attribute("away", u->away->message) .Attribute("awaytime", u->away->time); } if (u->IsOper()) serializer.Attribute("opertype", u->oper->GetType()); LocalUser* lu = IS_LOCAL(u); if (lu) { serializer.Attribute("port", lu->server_sa.port()) .Attribute("servaddr", lu->server_sa.addr()) .Attribute("connectclass", lu->GetClass()->GetName()) .Attribute("lastmsg", lu->idle_lastmsg); } DumpMeta(serializer, u); serializer.EndBlock(); } void Users(XMLSerializer& serializer) { serializer.BeginBlock("userlist"); for (const auto& [_, u] : ServerInstance->Users.GetUsers()) { if (!u->IsFullyConnected()) continue; DumpUser(serializer, u); } serializer.EndBlock(); } void Servers(XMLSerializer& serializer) { ProtocolInterface::ServerList sl; ServerInstance->PI->GetServerList(sl); serializer.BeginBlock("serverlist"); for (const auto& server : sl) { serializer.BeginBlock("server") .Attribute("servername", server.servername) .Attribute("parentname", server.parentname) .Attribute("description", server.description) .Attribute("usercount", server.usercount) .Attribute("opercount", server.opercount) .Attribute("lagmillisecs", server.latencyms) .EndBlock(); } serializer.EndBlock(); } void Commands(XMLSerializer& serializer) { serializer.BeginBlock("commandlist"); for (const auto& [cmdname, cmd] : ServerInstance->Parser.GetCommands()) { serializer.BeginBlock("command") .Attribute("name", cmdname) .Attribute("usecount", cmd->use_count) .EndBlock(); } serializer.EndBlock(); } enum OrderBy { OB_NICK, OB_LASTMSG, OB_NONE }; struct UserSorter final { OrderBy order; bool desc; UserSorter(OrderBy Order, bool Desc = false) : order(Order) , desc(Desc) { } template <typename T> inline bool Compare(const T& a, const T& b) { return desc ? a > b : a < b; } bool operator()(User* u1, User* u2) { switch (order) { case OB_LASTMSG: return Compare(IS_LOCAL(u1)->idle_lastmsg, IS_LOCAL(u2)->idle_lastmsg); case OB_NICK: return Compare(u1->nick, u2->nick); default: return false; } } }; void ListUsers(XMLSerializer& serializer, const HTTPQueryParameters& params) { if (params.empty()) { Users(serializer); return; } serializer.BeginBlock("userlist"); // Filters size_t limit = params.getNum<size_t>("limit"); bool showunreg = params.getBool("showunreg"); bool localonly = params.getBool("localonly"); // Minimum time since a user's last message unsigned long min_idle = params.getDuration("minidle"); time_t maxlastmsg = ServerInstance->Time() - min_idle; if (min_idle) // We can only check idle times on local users localonly = true; // Sorting const std::string& sortmethod = params.getString("sortby"); bool desc = params.getBool("desc", false); OrderBy orderby; if (insp::equalsci(sortmethod, "nick")) orderby = OB_NICK; else if (insp::equalsci(sortmethod, "lastmsg")) { orderby = OB_LASTMSG; // We can only check idle times on local users localonly = true; } else orderby = OB_NONE; typedef std::list<User*> NewUserList; NewUserList user_list; for (const auto& [_, u] : ServerInstance->Users.GetUsers()) { if (!showunreg && !u->IsFullyConnected()) continue; LocalUser* lu = IS_LOCAL(u); if (localonly && !lu) continue; if (min_idle && lu->idle_lastmsg > maxlastmsg) continue; user_list.push_back(u); } UserSorter sorter(orderby, desc); if (sorter.order != OB_NONE && !(!localonly && sorter.order == OB_LASTMSG)) user_list.sort(sorter); size_t count = 0; for (NewUserList::const_iterator i = user_list.begin(); i != user_list.end() && (!limit || count < limit); ++i, ++count) DumpUser(serializer, *i); serializer.EndBlock(); } } class ModuleHttpStats final : public Module , public HTTPRequestEventListener { private: HTTPdAPI API; ISupport::EventProvider isupportevprov; public: ModuleHttpStats() : Module(VF_VENDOR, "Provides XML-serialised statistics about the server, channels, and users over HTTP via the /stats path.") , HTTPRequestEventListener(this) , API(this) , isupportevprov(this) { isevprov = &isupportevprov; } ModResult OnHTTPRequest(HTTPRequest& request) override { if (request.GetPath().compare(0, 6, "/stats")) return MOD_RES_PASSTHRU; ServerInstance->Logs.Debug(MODNAME, "Handling HTTP request for {}", request.GetPath()); Stats::XMLSerializer serializer; serializer.BeginBlock("inspircdstats"); if (request.GetPath() == "/stats") { Stats::ServerInfo(serializer); Stats::General(serializer); Stats::XLines(serializer); Stats::Modules(serializer); Stats::Channels(serializer); Stats::Users(serializer); Stats::Servers(serializer); Stats::Commands(serializer); } else if (request.GetPath() == "/stats/general") { Stats::General(serializer); } else if (request.GetPath() == "/stats/users") { Stats::ListUsers(serializer, request.GetParsedURI().query_params); } else { return MOD_RES_PASSTHRU; } serializer.EndBlock(); /* Send the document back to m_httpd */ HTTPDocumentResponse response(this, request, serializer.GetData(), 200); response.headers.SetHeader("X-Powered-By", MODNAME); response.headers.SetHeader("Content-Type", "text/xml"); API->SendResponse(response); return MOD_RES_DENY; // Handled } }; MODULE_INIT(ModuleHttpStats) �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/src/modules/m_ident.cpp��������������������������������������������������������������0000664�0000000�0000000�00000031271�14771603147�0017735�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2021 Dominic Hamon * Copyright (C) 2013, 2018-2023, 2025 Sadie Powell <sadie@witchery.services> * Copyright (C) 2012-2013 Robby <robby@chatbelgie.be> * Copyright (C) 2012, 2014-2015 Attila Molnar <attilamolnar@hush.com> * Copyright (C) 2009-2010 Daniel De Graaf <danieldg@inspircd.org> * Copyright (C) 2008 Robin Burchell <robin+git@viroteck.net> * Copyright (C) 2007 John Brooks <john@jbrooks.io> * Copyright (C) 2007 Dennis Friis <peavey@inspircd.org> * Copyright (C) 2007 Craig Edwards <brain@inspircd.org> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include "inspircd.h" #include "extension.h" enum { // Either the ident lookup has not started yet or the user is fully connected. IDENT_UNKNOWN = 0, // Ident lookups are not enabled and a user has been marked as being skipped. IDENT_SKIPPED, // Ident lookups are not enabled and a user has been an insecure ident prefix. IDENT_PREFIXED, // An ident lookup was done and an ident was found. IDENT_FOUND, // An ident lookup was done but no ident was found IDENT_MISSING }; /* -------------------------------------------------------------- * Note that this is the third incarnation of m_ident. The first * two attempts were pretty crashy, mainly due to the fact we tried * to use InspSocket/BufferedSocket to make them work. This class * is ok for more heavyweight tasks, it does a lot of things behind * the scenes that are not good for ident sockets and it has a huge * memory footprint! * * To fix all the issues that we had in the old ident modules (many * nasty race conditions that would cause segfaults etc) we have * rewritten this module to use a simplified socket object based * directly off EventHandler. As EventHandler only has low level * readability, writability and error events tied directly to the * socket engine, this makes our lives easier as nothing happens to * our ident lookup class that is outside of this module, or out- * side of the control of the class. There are no timers, internal * events, or such, which will cause the socket to be deleted, * queued for deletion, etc. In fact, there's not even any queueing! * * Using this framework we have a much more stable module. * * A few things to note: * * O The only place that may *delete* an active or inactive * ident socket is OnUserDisconnect in the module class. * Because this is out of scope of the socket class there is * no possibility that the socket may ever try to delete * itself. * * O Closure of the ident socket with the Close() method will * not cause removal of the socket from memory or detachment * from its 'parent' User class. It will only flag it as an * inactive socket in the socket engine. * * O Timeouts are handled in OnCheckReady at the same time as * checking if the ident socket has a result. This is done * by checking if the age the of the class (its instantiation * time) plus the timeout value is greater than the current time. * * O The ident socket is able to but should not modify its * 'parent' user directly. Instead the ident socket class sets * a completion flag and during the next call to OnCheckReady, * the completion flag will be checked and any result copied to * that user's class. This again ensures a single point of socket * deletion for safer, neater code. * * O The code in the constructor of the ident socket is taken from * BufferedSocket but majorly thinned down. It works for both * IPv4 and IPv6. * * O In the event that the ident socket throws a ModuleException, * nothing is done. This is counted as total and complete * failure to create a connection. * -------------------------------------------------------------- */ class IdentRequestSocket final : public EventHandler { public: LocalUser* user; /* User we are attached to */ std::string result; /* Holds the ident string if done */ time_t age; bool done; /* True if lookup is finished */ IdentRequestSocket(const Module* mod, LocalUser* luser) : user(luser) { age = ServerInstance->Time(); SetFd(socket(user->server_sa.family(), SOCK_STREAM, 0)); if (!HasFd()) throw ModuleException(mod, "Could not create socket"); done = false; irc::sockets::sockaddrs bindaddr(user->server_sa); irc::sockets::sockaddrs connaddr(user->client_sa); if (connaddr.family() == AF_INET6) { bindaddr.in6.sin6_port = 0; connaddr.in6.sin6_port = htons(113); } else { bindaddr.in4.sin_port = 0; connaddr.in4.sin_port = htons(113); } /* Attempt to bind (ident requests must come from the ip the query is referring to */ if (SocketEngine::Bind(this, bindaddr) < 0) { this->Close(); throw ModuleException(mod, "failed to bind()"); } SocketEngine::NonBlocking(GetFd()); /* Attempt connection (nonblocking) */ if (SocketEngine::Connect(this, connaddr) == -1 && errno != EINPROGRESS) { this->Close(); throw ModuleException(mod, "connect() failed"); } /* Add fd to socket engine */ if (!SocketEngine::AddFd(this, FD_WANT_NO_READ | FD_WANT_POLL_WRITE)) { this->Close(); throw ModuleException(mod, "out of fds"); } } void OnEventHandlerWrite() override { SocketEngine::ChangeEventMask(this, FD_WANT_POLL_READ | FD_WANT_NO_WRITE); char req[32]; /* Build request in the form 'localport,remoteport\r\n' */ int req_size; if (user->client_sa.family() == AF_INET6) req_size = snprintf(req, sizeof(req), "%d,%d\r\n", ntohs(user->client_sa.in6.sin6_port), ntohs(user->server_sa.in6.sin6_port)); else req_size = snprintf(req, sizeof(req), "%d,%d\r\n", ntohs(user->client_sa.in4.sin_port), ntohs(user->server_sa.in4.sin_port)); /* Send failed if we didnt write the whole ident request -- * might as well give up if this happens! */ if (SocketEngine::Send(this, req, req_size, 0) < req_size) done = true; } void Close() { /* Remove ident socket from engine, and close it, but dont detach it * from its parent user class, or attempt to delete its memory. */ if (HasFd()) { ServerInstance->Logs.Debug(MODNAME, "Close ident socket {}", GetFd()); SocketEngine::Close(this); } } bool HasResult() const { return done; } void OnEventHandlerRead() override { /* We don't really need to buffer for incomplete replies here, since IDENT replies are * extremely short - there is *no* sane reason it'd be in more than one packet */ char ibuf[256]; ssize_t recvresult = SocketEngine::Recv(this, ibuf, sizeof(ibuf)-1, 0); /* Close (but don't delete from memory) our socket * and flag as done since the ident lookup has finished */ Close(); done = true; /* Cant possibly be a valid response shorter than 3 chars, * because the shortest possible response would look like: '1,1' */ if (recvresult < 3) return; ServerInstance->Logs.Debug(MODNAME, "ReadResponse()"); /* Truncate at the first null character, but first make sure * there is at least one null char (at the end of the buffer). */ ibuf[recvresult] = '\0'; std::string buf(ibuf); /* <2 colons: invalid * 2 colons: reply is an error * >3 colons: there is a colon in the ident */ if (std::count(buf.begin(), buf.end(), ':') != 3) return; std::string::size_type lastcolon = buf.rfind(':'); /* Truncate the ident at any characters we don't like, skip leading spaces */ for (const auto chr : insp::iterator_range(buf.begin() + lastcolon + 1, buf.end())) { if (result.size() == ServerInstance->Config->Limits.MaxUser) /* Ident is getting too long */ break; if (chr == ' ') continue; /* Add the next char to the result and see if it's still a valid ident, * according to IsUser(). If it isn't, then erase what we just added and * we're done. */ result += chr; if (!ServerInstance->IsUser(result)) { result.pop_back(); break; } } } void OnEventHandlerError(int errornum) override { Close(); done = true; } Cullable::Result Cull() override { Close(); return EventHandler::Cull(); } }; class ModuleIdent final : public Module { private: unsigned long timeout; bool prefixunqueried; SimpleExtItem<IdentRequestSocket, Cullable::Deleter> socket; IntExtItem state; static void PrefixUser(LocalUser* user) { // Check that they haven't been prefixed already. if (user->GetRealUser().front() == '~') return; // All invalid usernames are prefixed with a tilde. std::string newuser(user->GetRealUser()); newuser.insert(newuser.begin(), '~'); // If the username is too long then truncate it. if (newuser.length() > ServerInstance->Config->Limits.MaxUser) newuser.erase(ServerInstance->Config->Limits.MaxUser); // Apply the new username. user->ChangeRealUser(newuser, user->GetDisplayedUser() == user->GetRealUser()); } public: ModuleIdent() : Module(VF_VENDOR, "Allows the usernames of users to be looked up using the RFC 1413 Identification Protocol.") , socket(this, "ident-socket", ExtensionType::USER) , state(this, "ident-state", ExtensionType::USER) { } void ReadConfig(ConfigStatus& status) override { const auto& tag = ServerInstance->Config->ConfValue("ident"); timeout = tag->getDuration("timeout", 5, 1, 60); prefixunqueried = tag->getBool("prefixunqueried"); } void OnChangeRemoteAddress(LocalUser* user) override { IdentRequestSocket* isock = socket.Get(user); if (isock) { // If an ident lookup request was in progress then cancel it. isock->Close(); socket.Unset(user); } // The ident protocol requires that clients are connecting over a protocol with ports. if (!user->client_sa.is_ip()) return; // We don't want to look this up once the user has connected. if (user->IsFullyConnected() || user->quitting) return; if (!user->GetClass()->config->getBool("useident", true)) { state.Set(user, IDENT_SKIPPED); return; } user->WriteNotice("*** Looking up your username..."); try { isock = new IdentRequestSocket(this, user); socket.Set(user, isock); } catch (const ModuleException& e) { ServerInstance->Logs.Debug(MODNAME, "Ident exception: {}", e.GetReason()); } } /* This triggers pretty regularly, we can use it in preference to * creating a Timer object and especially better than creating a * Timer per ident lookup! */ ModResult OnCheckReady(LocalUser* user) override { /* Does user have an ident socket attached at all? */ IdentRequestSocket* isock = socket.Get(user); if (!isock) { if (prefixunqueried && state.Get(user) == IDENT_SKIPPED) { PrefixUser(user); state.Set(user, IDENT_PREFIXED); } return MOD_RES_PASSTHRU; } time_t compare = isock->age + timeout; /* Check for timeout of the socket */ if (ServerInstance->Time() >= compare) { /* Ident timeout */ state.Set(user, IDENT_MISSING); PrefixUser(user); user->WriteNotice("*** Ident lookup timed out, using " + user->GetRealUser() + " instead."); } else if (!isock->HasResult()) { // time still good, no result yet... hold the connection return MOD_RES_DENY; } /* wooo, got a result (it will be good, or bad) */ else if (isock->result.empty()) { state.Set(user, IDENT_MISSING); PrefixUser(user); user->WriteNotice("*** Could not find your username, using " + user->GetRealUser() + " instead."); } else { state.Set(user, IDENT_FOUND); user->ChangeRealUser(isock->result, user->GetDisplayedUser() == user->GetRealUser()); user->WriteNotice("*** Found your username (" + user->GetRealUser() + ")"); } isock->Close(); socket.Unset(user); return MOD_RES_PASSTHRU; } ModResult OnPreChangeConnectClass(LocalUser* user, const std::shared_ptr<ConnectClass>& klass, std::optional<Numeric::Numeric>& errnum) override { if (klass->config->getBool("requireident") && state.Get(user) != IDENT_FOUND) { ServerInstance->Logs.Debug("CONNECTCLASS", "The {} connect class is not suitable as it requires an identd response.", klass->GetName()); return MOD_RES_DENY; } return MOD_RES_PASSTHRU; } void OnUserConnect(LocalUser* user) override { // Clear this as it is no longer necessary. state.Unset(user); } }; MODULE_INIT(ModuleIdent) ���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/src/modules/m_inviteexception.cpp����������������������������������������������������0000664�0000000�0000000�00000006044�14771603147�0022047�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2017-2023 Sadie Powell <sadie@witchery.services> * Copyright (C) 2012-2013 Attila Molnar <attilamolnar@hush.com> * Copyright (C) 2012 Robby <robby@chatbelgie.be> * Copyright (C) 2009-2010 Daniel De Graaf <danieldg@inspircd.org> * Copyright (C) 2006 Craig Edwards <brain@inspircd.org> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include "inspircd.h" #include "listmode.h" #include "modules/extban.h" #include "modules/isupport.h" enum { // From RFC 2812. RPL_INVEXLIST = 346, RPL_ENDOFINVEXLIST = 347 }; class InviteException final : public ListModeBase { private: ExtBan::ManagerRef extbanmgr; public: InviteException(Module* Creator) : ListModeBase(Creator, "invex", 'I', RPL_INVEXLIST, RPL_ENDOFINVEXLIST) , extbanmgr(Creator) { syntax = "<mask>"; } bool CompareEntry(const std::string& entry, const std::string& value) const override { if (extbanmgr) { auto res = extbanmgr->CompareEntry(this, entry, value); if (res != ExtBan::Comparison::NOT_AN_EXTBAN) return res == ExtBan::Comparison::MATCH; } return irc::equals(entry, value); } bool ValidateParam(LocalUser* user, Channel* channel, std::string& parameter) override { if (!extbanmgr || !extbanmgr->Canonicalize(parameter)) ModeParser::CleanMask(parameter); return true; } }; class ModuleInviteException final : public Module , public ISupport::EventListener { private: bool invite_bypass_key; InviteException ie; public: ModuleInviteException() : Module(VF_VENDOR, "Adds channel mode I (invex) which allows channel operators to exempt user masks from channel mode i (inviteonly).") , ISupport::EventListener(this) , ie(this) { } void OnBuildISupport(ISupport::TokenMap& tokens) override { tokens["INVEX"] = ConvToStr(ie.GetModeChar()); } ModResult OnCheckInvite(User* user, Channel* chan) override { ListModeBase::ModeList* list = ie.GetList(chan); if (list) { for (const auto& entry : *list) { if (chan->CheckBan(user, entry.mask)) { return MOD_RES_ALLOW; } } } return MOD_RES_PASSTHRU; } ModResult OnCheckKey(User* user, Channel* chan, const std::string& key) override { if (invite_bypass_key) return OnCheckInvite(user, chan); return MOD_RES_PASSTHRU; } void ReadConfig(ConfigStatus& status) override { ie.DoRehash(); invite_bypass_key = ServerInstance->Config->ConfValue("inviteexception")->getBool("bypasskey", true); } }; MODULE_INIT(ModuleInviteException) ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/src/modules/m_ircv3.cpp��������������������������������������������������������������0000664�0000000�0000000�00000013025�14771603147�0017655�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2022 delthas * Copyright (C) 2013, 2018-2023 Sadie Powell <sadie@witchery.services> * Copyright (C) 2012, 2015, 2018 Attila Molnar <attilamolnar@hush.com> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include "inspircd.h" #include "clientprotocolevent.h" #include "modules/account.h" #include "modules/away.h" #include "modules/cap.h" #include "modules/ircv3.h" #include "modules/monitor.h" class AwayMessage final : public ClientProtocol::Message { public: AwayMessage(User* user) : ClientProtocol::Message("AWAY", user) { SetParams(user, user->away); } AwayMessage() : ClientProtocol::Message("AWAY") { } void SetParams(User* user, const std::optional<AwayState>& awaystate) { // Going away: 1 parameter which is the away reason // Back from away: no parameter if (awaystate) PushParam(awaystate->message); } }; class JoinHook final : public ClientProtocol::EventHook { private: Account::API accountapi; ClientProtocol::Events::Join extendedjoinmsg; public: const std::string asterisk = "*"; ClientProtocol::EventProvider awayprotoev; AwayMessage awaymsg; Cap::Capability extendedjoincap; Cap::Capability awaycap; JoinHook(Module* mod) : ClientProtocol::EventHook(mod, "JOIN") , accountapi(mod) , awayprotoev(mod, "AWAY") , extendedjoincap(mod, "extended-join") , awaycap(mod, "away-notify") { } void OnEventInit(const ClientProtocol::Event& ev) override { const ClientProtocol::Events::Join& join = static_cast<const ClientProtocol::Events::Join&>(ev); // An extended join has two extra parameters: // First the account name of the joining user or an asterisk if the user is not logged in. // The second parameter is the realname of the joining user. Membership* const memb = join.GetMember(); const std::string* account = &asterisk; if (accountapi) { const std::string* accountname = accountapi->GetAccountName(memb->user); if (accountname) account = accountname; } extendedjoinmsg.ClearParams(); extendedjoinmsg.SetSource(join); extendedjoinmsg.PushParamRef(memb->chan->name); extendedjoinmsg.PushParamRef(*account); extendedjoinmsg.PushParamRef(memb->user->GetRealName()); awaymsg.ClearParams(); if ((memb->user->IsAway()) && (awaycap.IsActive())) { awaymsg.SetSource(join); awaymsg.SetParams(memb->user, memb->user->away); } } ModResult OnPreEventSend(LocalUser* user, const ClientProtocol::Event& ev, ClientProtocol::MessageList& messagelist) override { if (extendedjoincap.IsEnabled(user)) messagelist.front() = &extendedjoinmsg; if ((!awaymsg.GetParams().empty()) && (awaycap.IsEnabled(user))) messagelist.push_back(&awaymsg); return MOD_RES_PASSTHRU; } }; class ModuleIRCv3 final : public Module , public Account::EventListener , public Away::EventListener { private: Cap::Capability cap_accountnotify; JoinHook joinhook; ClientProtocol::EventProvider accountprotoev; Monitor::API monitorapi; Cap::Capability stdrplcap; public: ModuleIRCv3() : Module(VF_VENDOR, "Provides the IRCv3 account-notify, away-notify, extended-join, and standard-replies client capabilities.") , Account::EventListener(this) , Away::EventListener(this) , cap_accountnotify(this, "account-notify") , joinhook(this) , accountprotoev(this, "ACCOUNT") , monitorapi(this) , stdrplcap(this, "standard-replies") { } void ReadConfig(ConfigStatus& status) override { const auto& conf = ServerInstance->Config->ConfValue("ircv3"); cap_accountnotify.SetActive(conf->getBool("accountnotify", true)); joinhook.awaycap.SetActive(conf->getBool("awaynotify", true)); joinhook.extendedjoincap.SetActive(conf->getBool("extendedjoin", true)); stdrplcap.SetActive(conf->getBool("standardreplies", true)); } void OnAccountChange(User* user, const std::string& newaccount) override { if (!(user->connected & User::CONN_NICKUSER)) return; // Logged in: 1 parameter which is the account name // Logged out: 1 parameter which is a "*" ClientProtocol::Message msg("ACCOUNT", user); const std::string& param = (newaccount.empty() ? joinhook.asterisk : newaccount); msg.PushParamRef(param); ClientProtocol::Event accountevent(accountprotoev, msg); IRCv3::WriteNeighborsWithCap res(user, accountevent, cap_accountnotify, true); Monitor::WriteWatchersWithCap(monitorapi, user, accountevent, cap_accountnotify, res.GetAlreadySentId()); } void OnUserAway(User* user, const std::optional<AwayState>& prevstate) override { if (!joinhook.awaycap.IsActive()) return; // Going away: n!u@h AWAY :reason AwayMessage msg(user); ClientProtocol::Event awayevent(joinhook.awayprotoev, msg); IRCv3::WriteNeighborsWithCap res(user, awayevent, joinhook.awaycap); Monitor::WriteWatchersWithCap(monitorapi, user, awayevent, joinhook.awaycap, res.GetAlreadySentId()); } void OnUserBack(User* user, const std::optional<AwayState>& prevstate) override { // Back from away: n!u@h AWAY OnUserAway(user, prevstate); } }; MODULE_INIT(ModuleIRCv3) �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/src/modules/m_ircv3_accounttag.cpp���������������������������������������������������0000664�0000000�0000000�00000004741�14771603147�0022072�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2018, 2020-2022 Sadie Powell <sadie@witchery.services> * Copyright (C) 2018 Attila Molnar <attilamolnar@hush.com> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include "inspircd.h" #include "modules/ctctags.h" #include "modules/ircv3.h" #include "modules/account.h" class AccountTag final : public IRCv3::CapTag<AccountTag> { private: Account::API& accountapi; public: const std::string* GetValue(const ClientProtocol::Message& msg) const { User* const user = msg.GetSourceUser(); if (!user || !accountapi) return nullptr; return accountapi->GetAccountName(user); } AccountTag(Module* mod, Account::API& api) : IRCv3::CapTag<AccountTag>(mod, "account-tag", "account") , accountapi(api) { } }; class AccountIdTag final : public ClientProtocol::MessageTagProvider { private: Account::API& accountapi; AccountTag& acctag; CTCTags::CapReference ctctagcap; public: AccountIdTag(Module* mod, AccountTag& tag, Account::API& api) : ClientProtocol::MessageTagProvider(mod) , accountapi(api) , acctag(tag) , ctctagcap(mod) { } void OnPopulateTags(ClientProtocol::Message& msg) override { const User* user = msg.GetSourceUser(); if (!user || !accountapi) return; const std::string* accountid = accountapi->GetAccountId(user); if (accountid) msg.AddTag("inspircd.org/account-id", this, *accountid); } bool ShouldSendTag(LocalUser* user, const ClientProtocol::MessageTagData& tagdata) override { return acctag.GetCap().IsEnabled(user) && ctctagcap.IsEnabled(user); } }; class ModuleIRCv3AccountTag final : public Module { private: Account::API accountapi; AccountTag tag; AccountIdTag idtag; public: ModuleIRCv3AccountTag() : Module(VF_VENDOR, "Provides the IRCv3 account-tag client capability.") , accountapi(this) , tag(this, accountapi) , idtag(this, tag, accountapi) { } }; MODULE_INIT(ModuleIRCv3AccountTag) �������������������������������inspircd-4.7.0/src/modules/m_ircv3_batch.cpp��������������������������������������������������������0000664�0000000�0000000�00000013141�14771603147�0021015�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2021 Dominic Hamon * Copyright (C) 2018-2022 Sadie Powell <sadie@witchery.services> * Copyright (C) 2018 Attila Molnar <attilamolnar@hush.com> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include "inspircd.h" #include "modules/cap.h" #include "modules/ircv3_batch.h" class BatchMessage final : public ClientProtocol::Message { public: BatchMessage(const IRCv3::Batch::Batch& batch, bool start) : ClientProtocol::Message("BATCH", ServerInstance->Config->GetServerName()) { char c = (start ? '+' : '-'); PushParam(std::string(1, c) + batch.GetRefTagStr()); if ((start) && (!batch.GetType().empty())) PushParamRef(batch.GetType()); } }; /** Extra structure allocated only for running batches, containing objects only relevant for * that specific run of the batch. */ struct IRCv3::Batch::BatchInfo final { /** List of users that have received the batch start message */ std::vector<LocalUser*> users; BatchMessage startmsg; ClientProtocol::Event startevent; BatchMessage endmsg; ClientProtocol::Event endevent; BatchInfo(ClientProtocol::EventProvider& protoevprov, IRCv3::Batch::Batch& b) : startmsg(b, true) , startevent(protoevprov, startmsg) , endmsg(b, false) , endevent(protoevprov, endmsg) { } }; class IRCv3::Batch::ManagerImpl final : public Manager { typedef std::vector<Batch*> BatchList; Cap::Capability cap; ClientProtocol::EventProvider protoevprov; IntExtItem batchbits; BatchList active_batches; bool unloading = false; bool ShouldSendTag(LocalUser* user, const ClientProtocol::MessageTagData& tagdata) override { if (!cap.IsEnabled(user)) return false; Batch& batch = *static_cast<Batch*>(tagdata.provdata); // Check if this is the first message the user is getting that is part of the batch const intptr_t bits = batchbits.Get(user); if (!(bits & batch.GetBit())) { // Send the start batch command ("BATCH +reftag TYPE"), remember the user so we can send them a // "BATCH -reftag" message later when the batch ends and set the flag we just checked so this is // only done once per user per batch. batchbits.Set(user, (bits | batch.GetBit())); batch.batchinfo->users.push_back(user); user->Send(batch.batchinfo->startevent); } return true; } unsigned int NextFreeId() const { if (active_batches.empty()) return 0; return active_batches.back()->GetId()+1; } public: ManagerImpl(Module* mod) : Manager(mod) , cap(mod, "batch") , protoevprov(mod, "BATCH") , batchbits(mod, "batchbits", ExtensionType::USER) { } void Init() { // Set batchbits to 0 for all users in case we were reloaded and the previous, now meaningless, // batchbits are set on users for (auto* user : ServerInstance->Users.GetLocalUsers()) batchbits.Unset(user); } void Shutdown() { unloading = true; while (!active_batches.empty()) ManagerImpl::End(*active_batches.back()); } void RemoveFromAll(LocalUser* user) { const intptr_t bits = batchbits.Get(user); // User is quitting, remove them from all lists for (const auto& batch : active_batches) { // Check the bit first to avoid list scan in case they're not on the list if ((bits & batch->GetBit()) != 0) stdalgo::vector::swaperase(batch->batchinfo->users, user); } } void Start(Batch& batch) override { if (unloading) return; if (batch.IsRunning()) return; // Already started, don't start again const size_t id = NextFreeId(); if (id >= MAX_BATCHES) return; // This cast is safe thanks to the clamping above. batch.Setup(static_cast<unsigned int>(id)); // Set the manager field which Batch::IsRunning() checks and is also used by AddToBatch() // to set the message tag batch.manager = this; batch.batchinfo = new IRCv3::Batch::BatchInfo(protoevprov, batch); batch.batchstartmsg = &batch.batchinfo->startmsg; batch.batchendmsg = &batch.batchinfo->endmsg; active_batches.push_back(&batch); } void End(Batch& batch) override { if (!batch.IsRunning()) return; // Mark batch as stopped batch.manager = nullptr; BatchInfo& batchinfo = *batch.batchinfo; // Send end batch message to all users who got the batch start message and unset bit so it can be reused for (const auto& user : batchinfo.users) { user->Send(batchinfo.endevent); batchbits.Set(user, batchbits.Get(user) & ~batch.GetBit()); } // erase() not swaperase because the reftag generation logic depends on the order of the elements stdalgo::erase(active_batches, &batch); delete batch.batchinfo; batch.batchinfo = nullptr; } }; class ModuleIRCv3Batch final : public Module { private: IRCv3::Batch::ManagerImpl manager; public: ModuleIRCv3Batch() : Module(VF_VENDOR, "Provides the IRCv3 batch client capability.") , manager(this) { } void init() override { manager.Init(); } void OnUnloadModule(Module* mod) override { if (mod == this) manager.Shutdown(); } void OnUserDisconnect(LocalUser* user) override { // Remove the user from all internal lists manager.RemoveFromAll(user); } }; MODULE_INIT(ModuleIRCv3Batch) �������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/src/modules/m_ircv3_capnotify.cpp����������������������������������������������������0000664�0000000�0000000�00000011244�14771603147�0021732�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2018-2022, 2024 Sadie Powell <sadie@witchery.services> * Copyright (C) 2015, 2018 Attila Molnar <attilamolnar@hush.com> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include "inspircd.h" #include "modules/cap.h" #include "modules/reload.h" class CapNotify final : public Cap::Capability { bool OnRequest(LocalUser* user, bool add) override { // Users using the negotiation protocol v3.2 or newer may not turn off cap-notify return add || GetProtocol(user) == Cap::CAP_LEGACY; } bool OnList(LocalUser* user) override { // If the client supports 3.2 enable cap-notify for them if (GetProtocol(user) != Cap::CAP_LEGACY) Set(user, true); return true; } public: CapNotify(Module* mod) : Cap::Capability(mod, "cap-notify") { } }; class CapNotifyMessage final : public Cap::MessageBase { public: CapNotifyMessage(bool add, const std::string& capname) : Cap::MessageBase((add ? "NEW" : "DEL")) { PushParamRef(capname); } }; class CapNotifyValueMessage final : public Cap::MessageBase { std::string s; const std::string::size_type pos; public: CapNotifyValueMessage(const std::string& capname) : Cap::MessageBase("NEW") , s(capname) , pos(s.size()+1) { s.push_back('='); PushParamRef(s); } void SetCapValue(const std::string& capvalue) { s.erase(pos); s.append(capvalue); InvalidateCache(); } }; class ModuleIRCv3CapNotify final : public Module , public Cap::EventListener , public ReloadModule::EventListener { CapNotify capnotify; std::string reloadedmod; std::vector<std::string> reloadedcaps; ClientProtocol::EventProvider protoev; void Send(const std::string& capname, Cap::Capability* cap, bool add) { CapNotifyMessage msg(add, capname); CapNotifyValueMessage msgwithval(capname); ClientProtocol::Event event(protoev, msg); ClientProtocol::Event eventwithval(protoev, msgwithval); for (auto* user : ServerInstance->Users.GetLocalUsers()) { if (!capnotify.IsEnabled(user)) continue; // Check that this user can actually see the cap. if (add && (!cap || !cap->OnList(user))) continue; // If the cap is being added and the client supports cap values then show the value, if any if ((add) && (capnotify.GetProtocol(user) != Cap::CAP_LEGACY)) { const std::string* capvalue = cap->GetValue(user); if ((capvalue) && (!capvalue->empty())) { msgwithval.SetUser(user); msgwithval.SetCapValue(*capvalue); user->Send(eventwithval); continue; } } msg.SetUser(user); user->Send(event); } } public: ModuleIRCv3CapNotify() : Module(VF_VENDOR, "Provides the IRCv3 cap-notify client capability.") , Cap::EventListener(this) , ReloadModule::EventListener(this) , capnotify(this) , protoev(this, "CAP_NOTIFY") { } void OnCapAddDel(Cap::Capability* cap, bool add) override { if (cap->creator == this) return; if (cap->creator->ModuleFile == reloadedmod) { if (!add) reloadedcaps.push_back(cap->GetName()); return; } Send(cap->GetName(), cap, add); } void OnCapValueChange(Cap::Capability* cap) override { // The value of a cap has changed, send CAP DEL and CAP NEW with the new value Send(cap->GetName(), cap, false); Send(cap->GetName(), cap, true); } void OnReloadModuleSave(Module* mod, ReloadModule::CustomData& cd) override { if (mod == this) return; reloadedmod = mod->ModuleFile; // Request callback when reload is complete cd.add(this, nullptr); } void OnReloadModuleRestore(Module* mod, void* data) override { // Reloading can change the set of caps provided by a module so assuming that if the reload succeeded all // caps that the module previously provided are available or all were lost if the reload failed is wrong. // Instead, we verify the availability of each cap individually. dynamic_reference_nocheck<Cap::Manager> capmanager(this, "capmanager"); if (capmanager) { for (const auto& capname : reloadedcaps) { if (!capmanager->Find(capname)) Send(capname, nullptr, false); } } reloadedmod.clear(); reloadedcaps.clear(); } }; MODULE_INIT(ModuleIRCv3CapNotify) ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/src/modules/m_ircv3_chghost.cpp������������������������������������������������������0000664�0000000�0000000�00000003751�14771603147�0021401�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2022 delthas * Copyright (C) 2018-2023 Sadie Powell <sadie@witchery.services> * Copyright (C) 2015, 2018 Attila Molnar <attilamolnar@hush.com> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include "inspircd.h" #include "modules/cap.h" #include "modules/ircv3.h" #include "modules/monitor.h" class ModuleIRCv3ChgHost final : public Module { Cap::Capability cap; ClientProtocol::EventProvider protoevprov; Monitor::API monitorapi; void DoChgHost(User* user, const std::string& username, const std::string& hostname) { if (!(user->connected & User::CONN_NICKUSER)) return; ClientProtocol::Message msg("CHGHOST", user); msg.PushParamRef(username); msg.PushParamRef(hostname); ClientProtocol::Event protoev(protoevprov, msg); IRCv3::WriteNeighborsWithCap res(user, protoev, cap, true); Monitor::WriteWatchersWithCap(monitorapi, user, protoev, cap, res.GetAlreadySentId()); } public: ModuleIRCv3ChgHost() : Module(VF_VENDOR, "Provides the IRCv3 chghost client capability.") , cap(this, "chghost") , protoevprov(this, "CHGHOST") , monitorapi(this) { } void OnChangeUser(User* user, const std::string& newuser) override { DoChgHost(user, newuser, user->GetDisplayedHost()); } void OnChangeHost(User* user, const std::string& newhost) override { DoChgHost(user, user->GetDisplayedUser(), newhost); } }; MODULE_INIT(ModuleIRCv3ChgHost) �����������������������inspircd-4.7.0/src/modules/m_ircv3_ctctags.cpp������������������������������������������������������0000664�0000000�0000000�00000031455�14771603147�0021374�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2019 linuxdaemon <linuxdaemon.irc@gmail.com> * Copyright (C) 2018-2024 Sadie Powell <sadie@witchery.services> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include "inspircd.h" #include "modules/cap.h" #include "modules/ctctags.h" #include "modules/isupport.h" #include "numerichelper.h" class CommandTagMsg final : public Command { private: Cap::Capability& cap; Events::ModuleEventProvider tagevprov; ClientProtocol::EventProvider msgevprov; bool FirePreEvents(User* source, MessageTarget& msgtarget, CTCTags::TagMessageDetails& msgdetails) { // Inform modules that a TAGMSG wants to be sent. ModResult modres = tagevprov.FirstResult(&CTCTags::EventListener::OnUserPreTagMessage, source, msgtarget, msgdetails); if (modres == MOD_RES_DENY) { // Inform modules that a module blocked the TAGMSG. tagevprov.Call(&CTCTags::EventListener::OnUserTagMessageBlocked, source, msgtarget, msgdetails); return false; } // Check whether a module zapped the message tags. if (msgdetails.tags_out.empty()) return false; // Inform modules that a TAGMSG is about to be sent. tagevprov.Call(&CTCTags::EventListener::OnUserTagMessage, source, msgtarget, msgdetails); return true; } CmdResult FirePostEvent(User* source, const MessageTarget& msgtarget, const CTCTags::TagMessageDetails& msgdetails) { // If the source is local then update its idle time. LocalUser* lsource = IS_LOCAL(source); if (lsource && msgdetails.update_idle) lsource->idle_lastmsg = ServerInstance->Time(); // Inform modules that a TAGMSG was sent. tagevprov.Call(&CTCTags::EventListener::OnUserPostTagMessage, source, msgtarget, msgdetails); return CmdResult::SUCCESS; } CmdResult HandleChannelTarget(User* source, const Params& parameters, const char* target, PrefixMode* pm) { auto* chan = ServerInstance->Channels.Find(target); if (!chan) { // The target channel does not exist. source->WriteNumeric(Numerics::NoSuchChannel(parameters[0])); return CmdResult::FAILURE; } // Fire the pre-message events. MessageTarget msgtarget(chan, pm ? pm->GetPrefix() : 0); CTCTags::TagMessageDetails msgdetails(parameters.GetTags()); if (!FirePreEvents(source, msgtarget, msgdetails)) return CmdResult::FAILURE; ModeHandler::Rank minrank = pm ? pm->GetPrefixRank() : 0; CTCTags::TagMessage message(source, chan, msgdetails.tags_out, msgtarget.status); message.SetSideEffect(true); for (const auto& [user, memb] : chan->GetUsers()) { LocalUser* luser = IS_LOCAL(user); // Don't send to remote users or the user who is the source. if (!luser || luser == source) continue; // Don't send to unprivileged or exempt users. if (memb->GetRank() < minrank || msgdetails.exemptions.count(luser)) continue; // Send to users if they have the capability. if (cap.IsEnabled(luser)) luser->Send(msgevprov, message); } return FirePostEvent(source, msgtarget, msgdetails); } CmdResult HandleServerTarget(User* source, const Params& parameters) { // If the source isn't allowed to mass message users then reject // the attempt to mass-message users. if (!source->HasPrivPermission("users/mass-message")) { source->WriteNumeric(ERR_NOPRIVILEGES, "Permission Denied - You do not have the required operator privileges"); return CmdResult::FAILURE; } // Extract the server glob match from the target parameter. std::string servername(parameters[0], 1); // Fire the pre-message events. MessageTarget msgtarget(&servername); CTCTags::TagMessageDetails msgdetails(parameters.GetTags()); if (!FirePreEvents(source, msgtarget, msgdetails)) return CmdResult::FAILURE; // If the current server name matches the server name glob then send // the message out to the local users. if (InspIRCd::Match(ServerInstance->Config->ServerName, servername)) { CTCTags::TagMessage message(source, "$*", msgdetails.tags_out); message.SetSideEffect(true); for (auto* luser : ServerInstance->Users.GetLocalUsers()) { // Don't send to partially connected users or the user who is the source. if (!luser->IsFullyConnected() || luser == source) continue; // Don't send to exempt users. if (msgdetails.exemptions.count(luser)) continue; // Send to users if they have the capability. if (cap.IsEnabled(luser)) luser->Send(msgevprov, message); } } // Fire the post-message event. return FirePostEvent(source, msgtarget, msgdetails); } CmdResult HandleUserTarget(User* source, const Params& parameters) { User* target; if (IS_LOCAL(source)) { // Local sources can specify either a nick or a nick@server mask as the target. const char* targetserver = strchr(parameters[0].c_str(), '@'); if (targetserver) { // The target is a user on a specific server (e.g. jto@tolsun.oulu.fi). target = ServerInstance->Users.FindNick(parameters[0].substr(0, targetserver - parameters[0].c_str()), true); if (target && strcasecmp(target->server->GetPublicName().c_str(), targetserver + 1) != 0) target = nullptr; } else { // If the source is a local user then we only look up the target by nick. target = ServerInstance->Users.FindNick(parameters[0], true); // Drop attempts to send a tag message to a server. This usually happens when the // server is started in debug mode and a client tries to send a typing notification // to a query window created by the debug message. if (!target && irc::equals(parameters[0], ServerInstance->FakeClient->GetMask())) return CmdResult::FAILURE; } } else { // Remote users can only specify a nick or UUID as the target. target = ServerInstance->Users.Find(parameters[0], true); } if (!target) { // The target user does not exist or is not fully connected. source->WriteNumeric(Numerics::NoSuchNick(parameters[0])); return CmdResult::FAILURE; } // Fire the pre-message events. MessageTarget msgtarget(target); CTCTags::TagMessageDetails msgdetails(parameters.GetTags()); if (!FirePreEvents(source, msgtarget, msgdetails)) return CmdResult::FAILURE; LocalUser* const localtarget = IS_LOCAL(target); if (localtarget && cap.IsEnabled(localtarget)) { // Servers can fake the target of a message when it is sent to an individual user. auto context_tag = parameters.GetTags().find("~context"); const std::string& msgcontext = context_tag == parameters.GetTags().end() ? localtarget->nick : context_tag->second.value; // Send to the target if they have the capability and are a local user. CTCTags::TagMessage message(source, msgcontext.c_str(), msgdetails.tags_out); message.SetSideEffect(true); localtarget->Send(msgevprov, message); } // Fire the post-message event. return FirePostEvent(source, msgtarget, msgdetails); } public: CommandTagMsg(Module* Creator, Cap::Capability& Cap) : Command(Creator, "TAGMSG", 1) , cap(Cap) , tagevprov(Creator, "event/tagmsg") , msgevprov(Creator, "TAGMSG") { } CmdResult Handle(User* user, const Params& parameters) override { if (CommandParser::LoopCall(user, this, parameters, 0)) return CmdResult::SUCCESS; // Check that the source has the message tags capability. if (IS_LOCAL(user) && !cap.IsEnabled(user)) return CmdResult::FAILURE; // The specified message tags were empty. if (parameters.GetTags().empty()) { user->WriteNumeric(ERR_NOTEXTTOSEND, "No tags to send"); return CmdResult::FAILURE; } // The target is a server glob. if (parameters[0][0] == '$') return HandleServerTarget(user, parameters); // If the message begins with one or more status characters then look them up. const char* target = parameters[0].c_str(); PrefixMode* targetpfx = nullptr; for (PrefixMode* pfx; (pfx = ServerInstance->Modes.FindPrefix(target[0])); ++target) { // We want the lowest ranked prefix specified. if (!targetpfx || pfx->GetPrefixRank() < targetpfx->GetPrefixRank()) targetpfx = pfx; } if (!target[0]) { // The target consisted solely of prefix modes. user->WriteNumeric(ERR_NORECIPIENT, "No recipient given"); return CmdResult::FAILURE; } // The target is a channel name. if (ServerInstance->Channels.IsPrefix(*target)) return HandleChannelTarget(user, parameters, target, targetpfx); // The target is a nickname. return HandleUserTarget(user, parameters); } RouteDescriptor GetRouting(User* user, const Params& parameters) override { if (IS_LOCAL(user)) // This is handled by the OnUserPostTagMessage hook to split the LoopCall pieces return ROUTE_LOCALONLY; else return ROUTE_MESSAGE(parameters[0]); } }; class C2CTags final : public ClientProtocol::MessageTagProvider { private: Cap::Capability& cap; public: bool allowclientonlytags; C2CTags(Module* Creator, Cap::Capability& Cap) : ClientProtocol::MessageTagProvider(Creator) , cap(Cap) { } ModResult OnProcessTag(User* user, const std::string& tagname, std::string& tagvalue) override { // A client-only tag is prefixed with a plus sign (+) and otherwise conforms // to the format specified in IRCv3.2 tags. if (tagname[0] != '+' || tagname.length() < 2 || !allowclientonlytags) return MOD_RES_PASSTHRU; // If the user is local then we check whether they have the message-tags cap // enabled. If not then we reject all client-only tags originating from them. LocalUser* lu = IS_LOCAL(user); if (lu && !cap.IsEnabled(lu)) return MOD_RES_DENY; // Remote users have their client-only tags checked by their local server. return MOD_RES_ALLOW; } bool ShouldSendTag(LocalUser* user, const ClientProtocol::MessageTagData& tagdata) override { return cap.IsEnabled(user); } }; class ModuleIRCv3CTCTags final : public Module , public CTCTags::EventListener , public ISupport::EventListener { private: Cap::Capability cap; CommandTagMsg cmd; C2CTags c2ctags; ChanModeReference moderatedmode; ChanModeReference noextmsgmode; ModResult CopyClientTags(const ClientProtocol::TagMap& tags_in, ClientProtocol::TagMap& tags_out) { for (const auto& tag_in : tags_in) { const ClientProtocol::MessageTagData& tagdata = tag_in.second; if (tagdata.tagprov == &c2ctags) tags_out.insert(tag_in); } return MOD_RES_PASSTHRU; } public: ModuleIRCv3CTCTags() : Module(VF_VENDOR | VF_COMMON, "Provides the IRCv3 message-tags client capability.") , CTCTags::EventListener(this) , ISupport::EventListener(this) , cap(this, "message-tags") , cmd(this, cap) , c2ctags(this, cap) , moderatedmode(this, "moderated") , noextmsgmode(this, "noextmsg") { } void ReadConfig(ConfigStatus& status) override { c2ctags.allowclientonlytags = ServerInstance->Config->ConfValue("ctctags")->getBool("allowclientonlytags", true); } void OnBuildISupport(ISupport::TokenMap& tokens) override { if (!c2ctags.allowclientonlytags) tokens["CLIENTTAGDENY"] = "*"; } ModResult OnUserPreMessage(User* user, MessageTarget& target, MessageDetails& details) override { return CopyClientTags(details.tags_in, details.tags_out); } ModResult OnUserPreTagMessage(User* user, MessageTarget& target, CTCTags::TagMessageDetails& details) override { if (IS_LOCAL(user) && target.type == MessageTarget::TYPE_CHANNEL) { auto* chan = target.Get<Channel>(); if (chan->IsModeSet(noextmsgmode) && !chan->HasUser(user)) { // The noextmsg mode is set and the user is not in the channel. user->WriteNumeric(Numerics::CannotSendTo(chan, "external messages", *noextmsgmode)); return MOD_RES_DENY; } bool no_chan_priv = chan->GetPrefixValue(user) < VOICE_VALUE; if (no_chan_priv && chan->IsModeSet(moderatedmode)) { // The moderated mode is set and the user has no status rank. user->WriteNumeric(Numerics::CannotSendTo(chan, "messages", *noextmsgmode)); return MOD_RES_DENY; } if (no_chan_priv && ServerInstance->Config->RestrictBannedUsers != ServerConfig::BUT_NORMAL && chan->IsBanned(user)) { // The user is banned in the channel and restrictbannedusers is enabled. if (ServerInstance->Config->RestrictBannedUsers == ServerConfig::BUT_RESTRICT_NOTIFY) user->WriteNumeric(Numerics::CannotSendTo(chan, "You cannot send messages to this channel whilst banned.")); return MOD_RES_DENY; } } return CopyClientTags(details.tags_in, details.tags_out); } }; MODULE_INIT(ModuleIRCv3CTCTags) �������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/src/modules/m_ircv3_echomessage.cpp��������������������������������������������������0000664�0000000�0000000�00000012332�14771603147�0022220�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2019 linuxdaemon <linuxdaemon.irc@gmail.com> * Copyright (C) 2018-2024 Sadie Powell <sadie@witchery.services> * Copyright (C) 2015, 2018 Attila Molnar <attilamolnar@hush.com> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include "inspircd.h" #include "clientprotocolmsg.h" #include "modules/cap.h" #include "modules/ctctags.h" class EchoTag final : public ClientProtocol::MessageTagProvider { private: CTCTags::CapReference stdrplcap; public: Cap::Capability echomsgcap; EchoTag(Module* Creator) : ClientProtocol::MessageTagProvider(Creator) , stdrplcap(Creator) , echomsgcap(Creator, "echo-message") { } bool ShouldSendTag(LocalUser* user, const ClientProtocol::MessageTagData& tagdata) final { return stdrplcap.IsEnabled(user) && echomsgcap.IsEnabled(user); } }; class ModuleIRCv3EchoMessage final : public Module , public CTCTags::EventListener { private: EchoTag echotag; ClientProtocol::EventProvider tagmsgprov; void AddEchoTag(ClientProtocol::Message& msg) { msg.AddTag("inspircd.org/echo", &echotag, ""); } public: ModuleIRCv3EchoMessage() : Module(VF_VENDOR, "Provides the IRCv3 echo-message client capability.") , CTCTags::EventListener(this) , echotag(this) , tagmsgprov(this, "TAGMSG") { } void OnUserPostMessage(User* user, const MessageTarget& target, const MessageDetails& details) override { if (!echotag.echomsgcap.IsEnabled(user) || !details.echo) return; // Caps are only set on local users LocalUser* const localuser = static_cast<LocalUser*>(user); const std::string& text = details.echo_original ? details.original_text : details.text; const ClientProtocol::TagMap& tags = details.echo_original ? details.tags_in : details.tags_out; switch (target.type) { case MessageTarget::TYPE_USER: { const auto* destuser = target.Get<User>(); ClientProtocol::Messages::Privmsg privmsg(ClientProtocol::Messages::Privmsg::nocopy, user, destuser, text, details.type); privmsg.AddTags(tags); AddEchoTag(privmsg); localuser->Send(ServerInstance->GetRFCEvents().privmsg, privmsg); break; } case MessageTarget::TYPE_CHANNEL: { const auto* chan = target.Get<Channel>(); const char status = details.echo_original ? target.original_status : target.status; ClientProtocol::Messages::Privmsg privmsg(ClientProtocol::Messages::Privmsg::nocopy, user, chan, text, details.type, status); privmsg.AddTags(tags); AddEchoTag(privmsg); localuser->Send(ServerInstance->GetRFCEvents().privmsg, privmsg); break; } case MessageTarget::TYPE_SERVER: { const auto* servername = target.Get<std::string>(); ClientProtocol::Messages::Privmsg privmsg(ClientProtocol::Messages::Privmsg::nocopy, user, *servername, text, details.type); privmsg.AddTags(tags); AddEchoTag(privmsg); localuser->Send(ServerInstance->GetRFCEvents().privmsg, privmsg); break; } } } void OnUserPostTagMessage(User* user, const MessageTarget& target, const CTCTags::TagMessageDetails& details) override { if (!echotag.echomsgcap.IsEnabled(user) || !details.echo) return; // Caps are only set on local users LocalUser* const localuser = static_cast<LocalUser*>(user); const ClientProtocol::TagMap& tags = details.echo_original ? details.tags_in : details.tags_out; switch (target.type) { case MessageTarget::TYPE_USER: { const auto* destuser = target.Get<User>(); CTCTags::TagMessage message(user, destuser, tags); AddEchoTag(message); localuser->Send(tagmsgprov, message); break; } case MessageTarget::TYPE_CHANNEL: { const auto* chan = target.Get<Channel>(); const char status = details.echo_original ? target.original_status : target.status; CTCTags::TagMessage message(user, chan, tags, status); AddEchoTag(message); localuser->Send(tagmsgprov, message); break; } case MessageTarget::TYPE_SERVER: { const auto* servername = target.Get<std::string>(); CTCTags::TagMessage message(user, servername->c_str(), tags); AddEchoTag(message); localuser->Send(tagmsgprov, message); break; } } } void OnUserMessageBlocked(User* user, const MessageTarget& target, const MessageDetails& details) override { // Prevent spammers from knowing that their spam was blocked. if (details.echo_original) OnUserPostMessage(user, target, details); } void OnUserTagMessageBlocked(User* user, const MessageTarget& target, const CTCTags::TagMessageDetails& details) override { // Prevent spammers from knowing that their spam was blocked. if (details.echo_original) OnUserPostTagMessage(user, target, details); } }; MODULE_INIT(ModuleIRCv3EchoMessage) ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/src/modules/m_ircv3_invitenotify.cpp�������������������������������������������������0000664�0000000�0000000�00000004274�14771603147�0022472�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2018-2022 Sadie Powell <sadie@witchery.services> * Copyright (C) 2015, 2018 Attila Molnar <attilamolnar@hush.com> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include "inspircd.h" #include "clientprotocolmsg.h" #include "modules/cap.h" class ModuleIRCv3InviteNotify final : public Module { Cap::Capability cap; public: ModuleIRCv3InviteNotify() : Module(VF_VENDOR, "Provides the IRCv3 invite-notify client capability.") , cap(this, "invite-notify") { } void OnUserInvite(User* source, User* dest, Channel* chan, time_t expiry, ModeHandler::Rank notifyrank, CUList& notifyexcepts) override { ClientProtocol::Messages::Invite invitemsg(source, dest, chan); ClientProtocol::Event inviteevent(ServerInstance->GetRFCEvents().invite, invitemsg); for (const auto& [user, memb] : chan->GetUsers()) { // Skip members who don't use this extension or were excluded by other modules if ((!cap.IsEnabled(user)) || (notifyexcepts.count(user))) continue; // Check whether the member has a high enough rank to see the notification if (memb->GetRank() < notifyrank) continue; // Caps are only set on local users LocalUser* const localuser = static_cast<LocalUser*>(user); // Send and add the user to the exceptions so they won't get the NOTICE invite announcement message localuser->Send(inviteevent); notifyexcepts.insert(user); } } void Prioritize() override { // Prioritize after all modules to see all excepted users ServerInstance->Modules.SetPriority(this, I_OnUserInvite, PRIORITY_LAST); } }; MODULE_INIT(ModuleIRCv3InviteNotify) ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/src/modules/m_ircv3_labeledresponse.cpp����������������������������������������������0000664�0000000�0000000�00000015555�14771603147�0023116�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2020-2022 Sadie Powell <sadie@witchery.services> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include "inspircd.h" #include "modules/cap.h" #include "modules/ircv3_batch.h" class LabeledResponseTag final : public ClientProtocol::MessageTagProvider { private: const Cap::Capability& cap; public: LocalUser* labeluser = nullptr; std::string label; const std::string labeltag; LabeledResponseTag(Module* mod, const Cap::Capability& capref) : ClientProtocol::MessageTagProvider(mod) , cap(capref) , labeltag("label") { } ModResult OnProcessTag(User* user, const std::string& tagname, std::string& tagvalue) override { if (!irc::equals(tagname, labeltag)) return MOD_RES_PASSTHRU; // If the tag is empty or too long then we can't accept it. if (tagvalue.empty() || tagvalue.size() > 64) return MOD_RES_DENY; // If the user is local then we check whether they have the labeled-response // cap enabled. If not then we reject the label tag originating from them. LocalUser* lu = IS_LOCAL(user); if (lu && !cap.IsEnabled(lu)) return MOD_RES_DENY; // Remote users have their label tag checked by their local server. return MOD_RES_ALLOW; } bool ShouldSendTag(LocalUser* user, const ClientProtocol::MessageTagData& tagdata) override { // Messages only have a label when being sent to a user that sent one. return user == labeluser && tagdata.value == label; } }; class ModuleIRCv3LabeledResponse final : public Module { private: Cap::Capability cap; LabeledResponseTag tag; IRCv3::Batch::API batchmanager; IRCv3::Batch::Batch batch; IRCv3::Batch::CapReference batchcap; ClientProtocol::EventProvider ackmsgprov; ClientProtocol::EventProvider labelmsgprov; insp::aligned_storage<ClientProtocol::Message> firstmsg; size_t msgcount = 0; void FlushFirstMsg(LocalUser* user) { // This isn't a side effect but we treat it like one to avoid the logic in OnUserWrite. firstmsg->SetSideEffect(true); user->Send(labelmsgprov, *firstmsg); firstmsg->~Message(); } public: ModuleIRCv3LabeledResponse() : Module(VF_VENDOR, "Provides support for the IRCv3 Labeled Response specification.") , cap(this, "labeled-response") , tag(this, cap) , batchmanager(this) , batch("labeled-response") , batchcap(this) , ackmsgprov(this, "ACK") , labelmsgprov(this, "labeled") { } ModResult OnPreCommand(std::string& command, CommandBase::Params& parameters, LocalUser* user, bool validated) override { // We only care about the initial unvalidated OnPreCommand call. if (validated || tag.labeluser) return MOD_RES_PASSTHRU; // We only care about registered users with the labeled-response and batch caps. if (!user->IsFullyConnected() || !cap.IsEnabled(user) || !batchcap.IsEnabled(user)) return MOD_RES_PASSTHRU; const ClientProtocol::TagMap& tagmap = parameters.GetTags(); const ClientProtocol::TagMap::const_iterator labeltag = tagmap.find(tag.labeltag); if (labeltag == tagmap.end()) return MOD_RES_PASSTHRU; tag.label = labeltag->second.value; tag.labeluser = user; return MOD_RES_PASSTHRU; } void OnPostCommand(Command* command, const CommandBase::Params& parameters, LocalUser* user, CmdResult result, bool loop) override { // Do nothing if this isn't the last OnPostCommand() run for the command. // // If a parameter for the command was originally a list and the command handler chose to be executed // for each element on the list with synthesized parameters (CommandHandler::LoopCall) then this hook // too will run for each element on the list plus once after the whole list has been processed. // loop will only be false for the last run. if (!loop) OnCommandBlocked(command->name, parameters, user); } void OnCommandBlocked(const std::string& command, const CommandBase::Params& parameters, LocalUser* user) override { // If no label was sent we don't have to do anything. if (!tag.labeluser) return; switch (msgcount) { case 0: { // There was no response so we send an ACK instead. ClientProtocol::Message ackmsg("ACK", ServerInstance->FakeClient); ackmsg.AddTag(tag.labeltag, &tag, tag.label); ackmsg.SetSideEffect(true); tag.labeluser->Send(ackmsgprov, ackmsg); break; } case 1: { // There was one response which was cached; send it now. firstmsg->AddTag(tag.labeltag, &tag, tag.label); FlushFirstMsg(user); break; } default: { // There was two or more responses; send an end-of-batch. if (batchmanager) { // Set end start as side effect so we'll ignore it otherwise it'd end up added into the batch. batch.GetBatchEndMessage().SetSideEffect(true); batchmanager->End(batch); } break; } } tag.labeluser = nullptr; msgcount = 0; } ModResult OnUserWrite(LocalUser* user, ClientProtocol::Message& msg) override { // The label user is writing a message to another user. if (user != tag.labeluser) return MOD_RES_PASSTHRU; // The message is a side effect (e.g. a self-PRIVMSG). if (msg.IsSideEffect()) return MOD_RES_PASSTHRU; switch (++msgcount) { case 1: { // First reply message. We can' send it yet because we don't know if there will be more. new(firstmsg) ClientProtocol::Message(msg); firstmsg->CopyAll(); return MOD_RES_DENY; } case 2: { // Second reply message. This and all subsequent messages need to go into a batch. if (batchmanager) { batchmanager->Start(batch); // Set batch start as side effect so we'll ignore it otherwise it'd end up added into the batch. ClientProtocol::Message& batchstartmsg = batch.GetBatchStartMessage(); batchstartmsg.SetSideEffect(true); batchstartmsg.AddTag(tag.labeltag, &tag, tag.label); batch.AddToBatch(*firstmsg); batch.AddToBatch(msg); } // Flush first message which triggers the batch start message FlushFirstMsg(user); return MOD_RES_PASSTHRU; } default: { // Third or later message. Put it in the batch and send directly. if (batchmanager) batch.AddToBatch(msg); return MOD_RES_PASSTHRU; } } } void Prioritize() override { Module* alias = ServerInstance->Modules.Find("alias"); ServerInstance->Modules.SetPriority(this, I_OnPreCommand, PRIORITY_BEFORE, alias); } }; MODULE_INIT(ModuleIRCv3LabeledResponse) ���������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/src/modules/m_ircv3_msgid.cpp��������������������������������������������������������0000664�0000000�0000000�00000005434�14771603147�0021045�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2019-2023 Sadie Powell <sadie@witchery.services> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include "inspircd.h" #include "modules/ctctags.h" class MsgIdTag final : public CTCTags::TagProvider { public: MsgIdTag(Module* mod) : CTCTags::TagProvider(mod) { } ModResult OnProcessTag(User* user, const std::string& tagname, std::string& tagvalue) override { if (!irc::equals(tagname, "msgid")) return MOD_RES_PASSTHRU; // We should only allow this tag if it is added by a remote server. return IS_LOCAL(user) ? MOD_RES_DENY : MOD_RES_ALLOW; } }; class MsgIdGenerator final { uint64_t counter = 0; std::string strid; const std::string::size_type baselen; public: MsgIdGenerator() : strid(INSP_FORMAT("{}~{}~", ServerInstance->Config->ServerId, ServerInstance->startup_time)) , baselen(strid.length()) { } const std::string& GetNext() { strid.erase(baselen); strid.append(ConvToStr(counter++)); return strid; } }; class ModuleMsgId final : public Module , public CTCTags::EventListener { private: MsgIdTag tag; MsgIdGenerator generator; ModResult CopyMessageId(const ClientProtocol::TagMap& tags_in, ClientProtocol::TagMap& tags_out) { ClientProtocol::TagMap::const_iterator iter = tags_in.find("msgid"); if (iter != tags_in.end()) { // If the remote server has sent a message identifier we should use that as // identifiers need to be the same on all sides of the network. tags_out.insert(*iter); return MOD_RES_PASSTHRU; } // Otherwise, we can just create a new message identifier. tags_out.emplace("msgid", ClientProtocol::MessageTagData(&tag, generator.GetNext())); return MOD_RES_PASSTHRU; } public: ModuleMsgId() : Module(VF_VENDOR, "Provides support for the IRCv3 Message IDs specification.") , CTCTags::EventListener(this) , tag(this) { } ModResult OnUserPreMessage(User* user, MessageTarget& target, MessageDetails& details) override { return CopyMessageId(details.tags_in, details.tags_out); } ModResult OnUserPreTagMessage(User* user, MessageTarget& target, CTCTags::TagMessageDetails& details) override { return CopyMessageId(details.tags_in, details.tags_out); } }; MODULE_INIT(ModuleMsgId) ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/src/modules/m_ircv3_servertime.cpp���������������������������������������������������0000664�0000000�0000000�00000004545�14771603147�0022131�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2018-2022 Sadie Powell <sadie@witchery.services> * Copyright (C) 2018 Attila Molnar <attilamolnar@hush.com> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include "inspircd.h" #include "modules/ircv3.h" #include "modules/ircv3_servertime.h" #include "modules/server.h" class ServerTimeTag final : public IRCv3::ServerTime::Manager , public IRCv3::CapTag<ServerTimeTag> , public ServerProtocol::MessageEventListener { time_t lasttime = 0; long lasttimens = 0; std::string lasttimestring; void RefreshTimeString() { const time_t currtime = ServerInstance->Time(); const long currtimens = ServerInstance->Time_ns(); if (currtime != lasttime || currtimens != lasttimens) { lasttime = currtime; lasttimens = currtimens; // Cache the string so it's not recreated every time a message is sent. lasttimestring = IRCv3::ServerTime::FormatTime(currtime, (currtimens ? currtimens / 1000000 : 0)); } } public: ServerTimeTag(Module* mod) : IRCv3::ServerTime::Manager(mod) , IRCv3::CapTag<ServerTimeTag>(mod, "server-time", "time") , ServerProtocol::MessageEventListener(mod) { tagprov = this; } const std::string* GetValue(const ClientProtocol::Message& msg) { // Client protocol. RefreshTimeString(); return &lasttimestring; } void OnBuildUserMessage(const User* source, const char* command, ClientProtocol::TagMap& tags) override { // Server protocol. RefreshTimeString(); tags.emplace(tagname, ClientProtocol::MessageTagData(this, lasttimestring)); } }; class ModuleIRCv3ServerTime final : public Module { private: ServerTimeTag tag; public: ModuleIRCv3ServerTime() : Module(VF_VENDOR, "Provides the IRCv3 server-time client capability.") , tag(this) { } }; MODULE_INIT(ModuleIRCv3ServerTime) �����������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/src/modules/m_ircv3_sts.cpp����������������������������������������������������������0000664�0000000�0000000�00000013755�14771603147�0020560�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2017, 2019-2023 Sadie Powell <sadie@witchery.services> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include "inspircd.h" #include "modules/cap.h" #include "modules/ssl.h" class STSCap final : public Cap::Capability { private: std::string host; std::string plaintextpolicy; std::string securepolicy; mutable UserCertificateAPI sslapi; bool OnList(LocalUser* user) override { // Don't send the cap to clients that only support cap-3.1. if (GetProtocol(user) == Cap::CAP_LEGACY) return false; // Don't send the cap to clients in a class which has STS disabled. if (!user->GetClass()->config->getBool("usests", true)) return false; // Plaintext listeners have their own policy. SSLIOHook* sslhook = SSLIOHook::IsSSL(&user->eh); if (!sslhook) return true; // If no hostname has been provided for the connection, an STS persistence policy SHOULD NOT be advertised. std::string snihost; if (!sslhook->GetServerName(snihost)) return false; // Before advertising an STS persistence policy over a secure connection, servers SHOULD verify whether the // hostname provided by clients, for example, via TLS Server Name Indication (SNI), has been whitelisted by // administrators in the server configuration. return InspIRCd::Match(snihost, host, ascii_case_insensitive_map); } bool OnRequest(LocalUser* user, bool adding) override { // Clients MUST NOT request this capability with CAP REQ. Servers MAY reply with a CAP NAK message if a // client requests this capability. return false; } const std::string* GetValue(LocalUser* user) const override { if (SSLIOHook::IsSSL(&user->eh)) return &securepolicy; // Normal SSL connection. if (sslapi && sslapi->GetCertificate(user)) return &securepolicy; // Proxied SSL connection. return &plaintextpolicy; // Plain text connection. } public: STSCap(Module* mod) : Cap::Capability(mod, "sts") , sslapi(mod) { DisableAutoRegister(); } ~STSCap() override { // TODO: Send duration=0 when STS vanishes. } void SetPolicy(const std::string& newhost, unsigned long duration, in_port_t port, bool preload) { // To enforce an STS upgrade policy, servers MUST send this key to insecurely connected clients. Servers // MAY send this key to securely connected clients, but it will be ignored. std::string newplaintextpolicy("port="); newplaintextpolicy.append(ConvToStr(port)); // To enforce an STS persistence policy, servers MUST send this key to securely connected clients. Servers // MAY send this key to all clients, but insecurely connected clients MUST ignore it. std::string newsecurepolicy("duration="); newsecurepolicy.append(ConvToStr(duration)); // Servers MAY send this key to all clients, but insecurely connected clients MUST ignore it. if (preload) newsecurepolicy.append(",preload"); // Apply the new policy. bool changed = false; if (!irc::equals(host, newhost)) { ServerInstance->Logs.Debug(MODNAME, "Changing STS SNI hostname from \"{}\" to \"{}\"", host, newhost); host = newhost; changed = true; } if (plaintextpolicy != newplaintextpolicy) { ServerInstance->Logs.Debug(MODNAME, "Changing plaintext STS policy from \"{}\" to \"{}\"", plaintextpolicy, newplaintextpolicy); plaintextpolicy.swap(newplaintextpolicy); changed = true; } if (securepolicy != newsecurepolicy) { ServerInstance->Logs.Debug(MODNAME, "Changing secure STS policy from \"{}\" to \"{}\"", securepolicy, newsecurepolicy); securepolicy.swap(newsecurepolicy); changed = true; } // If the policy has changed then notify all clients via cap-notify. if (changed) NotifyValueChange(); } }; class ModuleIRCv3STS final : public Module { private: STSCap cap; // The IRCv3 STS specification requires that the server is listening using TLS using a valid certificate. static bool HasValidSSLPort(in_port_t port) { for (const auto* ls : ServerInstance->ports) { // Is this listener marked as providing SSL over HAProxy? if (!ls->bind_tag->getString("hook").empty() && ls->bind_tag->getBool("sslhook")) return true; // Is this listener on the right port? in_port_t saport = ls->bind_sa.port(); if (saport != port) continue; // Is this listener using TLS? if (ls->bind_tag->getString("sslprofile").empty()) continue; // TODO: Add a way to check if a listener's TLS cert is CA-verified. return true; } return false; } public: ModuleIRCv3STS() : Module(VF_VENDOR | VF_OPTCOMMON, "Adds support for the IRCv3 Strict Transport Security specification.") , cap(this) { } void ReadConfig(ConfigStatus& status) override { // TODO: Multiple SNI profiles const auto& tag = ServerInstance->Config->ConfValue("sts"); if (tag == ServerInstance->Config->EmptyTag) throw ModuleException(this, "You must define a STS policy!"); const std::string host = tag->getString("host"); if (host.empty()) throw ModuleException(this, "<sts:host> must contain a hostname, at " + tag->source.str()); in_port_t port = tag->getNum<in_port_t>("port", 6697, 1); if (!HasValidSSLPort(port)) throw ModuleException(this, "<sts:port> must be a TLS port, at " + tag->source.str()); unsigned long duration = tag->getDuration("duration", 5*60, 60); bool preload = tag->getBool("preload"); cap.SetPolicy(host, duration, port, preload); if (!cap.IsRegistered()) ServerInstance->Modules.AddService(cap); } }; MODULE_INIT(ModuleIRCv3STS) �������������������inspircd-4.7.0/src/modules/m_joinflood.cpp����������������������������������������������������������0000664�0000000�0000000�00000013264�14771603147�0020617�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2021 Dominic Hamon * Copyright (C) 2016, 2018-2023, 2025 Sadie Powell <sadie@witchery.services> * Copyright (C) 2012-2014 Attila Molnar <attilamolnar@hush.com> * Copyright (C) 2012 Robby <robby@chatbelgie.be> * Copyright (C) 2009 Daniel De Graaf <danieldg@inspircd.org> * Copyright (C) 2008 Robin Burchell <robin+git@viroteck.net> * Copyright (C) 2007 Dennis Friis <peavey@inspircd.org> * Copyright (C) 2006-2007 Craig Edwards <brain@inspircd.org> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include "inspircd.h" #include "extension.h" #include "modules/server.h" #include "numerichelper.h" #include "timeutils.h" // The number of seconds the channel will be closed for. static unsigned int duration; /** Holds settings and state associated with channel mode +j */ class joinfloodsettings final { public: unsigned int secs; unsigned int joins; time_t reset; time_t unlocktime = 0; unsigned int counter = 0; joinfloodsettings(unsigned int b, unsigned int c) : secs(b) , joins(c) { reset = ServerInstance->Time() + secs; } void addjoin() { if (ServerInstance->Time() > reset) { counter = 1; reset = ServerInstance->Time() + secs; } else counter++; } bool shouldlock() const { return (counter >= this->joins); } void clear() { counter = 0; } bool islocked() { if (ServerInstance->Time() > unlocktime) unlocktime = 0; return (unlocktime != 0); } void lock() { unlocktime = ServerInstance->Time() + duration; } bool operator==(const joinfloodsettings& other) const { return ((this->secs == other.secs) && (this->joins == other.joins)); } }; /** Handles channel mode +j */ class JoinFlood final : public ParamMode<JoinFlood, SimpleExtItem<joinfloodsettings>> { public: JoinFlood(Module* Creator) : ParamMode<JoinFlood, SimpleExtItem<joinfloodsettings>>(Creator, "joinflood", 'j') { syntax = "<joins>:<seconds>"; } bool OnSet(User* source, Channel* channel, std::string& parameter) override { std::string::size_type colon = parameter.find(':'); if ((colon == std::string::npos) || (parameter.find('-') != std::string::npos)) { source->WriteNumeric(Numerics::InvalidModeParameter(channel, this, parameter)); return false; } /* Set up the flood parameters for this channel */ unsigned int njoins = ConvToNum<unsigned int>(parameter.substr(0, colon)); unsigned int nsecs = ConvToNum<unsigned int>(parameter.substr(colon+1)); if ((njoins<1) || (nsecs<1)) { source->WriteNumeric(Numerics::InvalidModeParameter(channel, this, parameter)); return false; } ext.SetFwd(channel, nsecs, njoins); return true; } void SerializeParam(Channel* chan, const joinfloodsettings* jfs, std::string& out) { out.append(ConvToStr(jfs->joins)).push_back(':'); out.append(ConvToStr(jfs->secs)); } }; class ModuleJoinFlood final : public Module , public ServerProtocol::LinkEventListener { private: JoinFlood jf; time_t ignoreuntil = 0; unsigned long bootwait; unsigned long splitwait; ModeHandler::Rank notifyrank; public: ModuleJoinFlood() : Module(VF_VENDOR, "Adds channel mode j (joinflood) which helps protect against spammers which mass-join channels.") , ServerProtocol::LinkEventListener(this) , jf(this) { } void ReadConfig(ConfigStatus& status) override { const auto& tag = ServerInstance->Config->ConfValue("joinflood"); duration = static_cast<unsigned int>(tag->getDuration("duration", 60, 10, 600)); bootwait = tag->getDuration("bootwait", 30); splitwait = tag->getDuration("splitwait", 30); notifyrank = tag->getNum<ModeHandler::Rank>("notifyrank", 0); if (status.initial) ignoreuntil = ServerInstance->startup_time + bootwait; } void OnServerSplit(const Server* server, bool error) override { if (splitwait) ignoreuntil = std::max<time_t>(ignoreuntil, ServerInstance->Time() + splitwait); } ModResult OnUserPreJoin(LocalUser* user, Channel* chan, const std::string& cname, std::string& privs, const std::string& keygiven, bool override) override { if (!override && chan) { joinfloodsettings* f = jf.ext.Get(chan); if (f && f->islocked()) { user->WriteNumeric(ERR_UNAVAILRESOURCE, chan->name, INSP_FORMAT("This channel is temporarily unavailable (+{} is set). Please try again later.", jf.GetModeChar())); return MOD_RES_DENY; } } return MOD_RES_PASSTHRU; } void OnUserJoin(Membership* memb, bool sync, bool created, CUList& excepts) override { /* We arent interested in JOIN events caused by a network burst */ if (sync || ignoreuntil > ServerInstance->Time()) return; joinfloodsettings* f = jf.ext.Get(memb->chan); /* But all others are OK */ if ((f) && (!f->islocked())) { f->addjoin(); if (f->shouldlock()) { f->clear(); f->lock(); PrefixMode* pm = ServerInstance->Modes.FindNearestPrefixMode(notifyrank); memb->chan->WriteNotice(INSP_FORMAT("This channel has been closed to new users for {} because there have been more than {} joins in {}.", Duration::ToLongString(duration), f->joins, Duration::ToLongString(f->secs)), pm ? pm->GetPrefix() : 0); } } } }; MODULE_INIT(ModuleJoinFlood) ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/src/modules/m_kicknorejoin.cpp�������������������������������������������������������0000664�0000000�0000000�00000010504�14771603147�0021313�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2018-2023, 2025 Sadie Powell <sadie@witchery.services> * Copyright (C) 2018 A_D * Copyright (C) 2012-2015 Attila Molnar <attilamolnar@hush.com> * Copyright (C) 2012 Robby <robby@chatbelgie.be> * Copyright (C) 2009 Uli Schlachter <psychon@znc.in> * Copyright (C) 2009 Daniel De Graaf <danieldg@inspircd.org> * Copyright (C) 2007 Dennis Friis <peavey@inspircd.org> * Copyright (C) 2006 Craig Edwards <brain@inspircd.org> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include "inspircd.h" #include "extension.h" #include "modules/invite.h" #include "numerichelper.h" #include "timeutils.h" class KickRejoinData final { struct KickedUser final { std::string uuid; time_t expire; KickedUser(User* user, unsigned int Delay) : uuid(user->uuid) , expire(ServerInstance->Time() + Delay) { } }; typedef std::vector<KickedUser> KickedList; mutable KickedList kicked; public: const unsigned int delay; KickRejoinData(unsigned int Delay) : delay(Delay) { } bool canjoin(LocalUser* user) const { for (KickedList::iterator i = kicked.begin(); i != kicked.end(); ) { KickedUser& rec = *i; if (rec.expire > ServerInstance->Time()) { if (rec.uuid == user->uuid) return false; ++i; } else { // Expired record, remove. stdalgo::vector::swaperase(kicked, i); if (kicked.empty()) break; } } return true; } void add(User* user) { // One user can be in the list multiple times if the user gets kicked, force joins // (skipping OnUserPreJoin) and gets kicked again, but that's okay because canjoin() // works correctly in this case as well kicked.emplace_back(user, delay); } }; /** Handles channel mode +J */ class KickRejoin final : public ParamMode<KickRejoin, SimpleExtItem<KickRejoinData>> { public: const unsigned int max = 60; KickRejoin(Module* Creator) : ParamMode<KickRejoin, SimpleExtItem<KickRejoinData>>(Creator, "kicknorejoin", 'J') { syntax = "<seconds>"; } bool OnSet(User* source, Channel* channel, std::string& parameter) override { unsigned int v = ConvToNum<unsigned int>(parameter); if (v <= 0) { source->WriteNumeric(Numerics::InvalidModeParameter(channel, this, parameter)); return false; } if (IS_LOCAL(source) && v > max) v = max; ext.Set(channel, v); return true; } void SerializeParam(Channel* chan, const KickRejoinData* krd, std::string& out) { out.append(ConvToStr(krd->delay)); } }; class ModuleKickNoRejoin final : public Module { KickRejoin kr; Invite::API invapi; public: ModuleKickNoRejoin() : Module(VF_VENDOR | VF_COMMON, "Adds channel mode J (kicknorejoin) which prevents users from rejoining after being kicked from a channel.") , kr(this) , invapi(this) { } ModResult OnUserPreJoin(LocalUser* user, Channel* chan, const std::string& cname, std::string& privs, const std::string& keygiven, bool override) override { if (!override && chan) { const KickRejoinData* data = kr.ext.Get(chan); if ((data) && !invapi->IsInvited(user, chan) && (!data->canjoin(user))) { user->WriteNumeric(ERR_UNAVAILRESOURCE, chan->name, INSP_FORMAT("You must wait for {} after being kicked to rejoin (+{} is set)", Duration::ToLongString(data->delay), kr.GetModeChar())); return MOD_RES_DENY; } } return MOD_RES_PASSTHRU; } void OnUserKick(User* source, Membership* memb, const std::string& reason, CUList& excepts) override { if ((!IS_LOCAL(memb->user)) || (source == memb->user)) return; KickRejoinData* data = kr.ext.Get(memb->chan); if (data) { data->add(memb->user); } } void GetLinkData(LinkData& data, std::string& compatdata) override { data["max-time"] = compatdata = ConvToStr(kr.max); } }; MODULE_INIT(ModuleKickNoRejoin) ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/src/modules/m_knock.cpp��������������������������������������������������������������0000664�0000000�0000000�00000011414�14771603147�0017734�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2017 B00mX0r <b00mx0r@aureus.pw> * Copyright (C) 2013, 2018-2024 Sadie Powell <sadie@witchery.services> * Copyright (C) 2012-2013, 2018 Attila Molnar <attilamolnar@hush.com> * Copyright (C) 2012 Robby <robby@chatbelgie.be> * Copyright (C) 2009-2010 Daniel De Graaf <danieldg@inspircd.org> * Copyright (C) 2007 Robin Burchell <robin+git@viroteck.net> * Copyright (C) 2006, 2008 Craig Edwards <brain@inspircd.org> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include "inspircd.h" #include "clientprotocolmsg.h" #include "modules/invite.h" #include "numerichelper.h" enum { // From UnrealIRCd. ERR_CANNOTKNOCK = 480, // From ircd-ratbox. RPL_KNOCK = 710, RPL_KNOCKDLVR = 711, ERR_CHANOPEN = 713, ERR_KNOCKONCHAN = 714 }; // Actions which can be taken when a user knocks on a channel. enum KnockNotify : uint8_t { // Send a notice when a user knocks on a channel. KN_SEND_NOTICE = 1, // Send a numeric when a user knocks on a channel. KN_SEND_NUMERIC = 2, // Send a notice and a numeric when a user knocks on a channel. KN_SEND_BOTH = KN_SEND_NOTICE | KN_SEND_NUMERIC, }; /** Handles the /KNOCK command */ class CommandKnock final : public Command { private: SimpleChannelMode& noknockmode; ChanModeReference inviteonlymode; Invite::API inviteapi; public: int notify; CommandKnock(Module* Creator, SimpleChannelMode& Noknockmode) : Command(Creator, "KNOCK", 2, 2) , noknockmode(Noknockmode) , inviteonlymode(Creator, "inviteonly") , inviteapi(Creator) { penalty = 5000; syntax = { "<channel> :<reason>" }; } CmdResult Handle(User* user, const Params& parameters) override { auto* c = ServerInstance->Channels.Find(parameters[0]); if (!c) { user->WriteNumeric(Numerics::NoSuchChannel(parameters[0])); return CmdResult::FAILURE; } if (c->HasUser(user)) { user->WriteNumeric(ERR_KNOCKONCHAN, c->name, INSP_FORMAT("Can't KNOCK on {}, you are already on that channel.", c->name)); return CmdResult::FAILURE; } if (c->IsModeSet(noknockmode)) { user->WriteNumeric(ERR_CANNOTKNOCK, INSP_FORMAT("Can't KNOCK on {}, +{} is set.", c->name, noknockmode.GetModeChar())); return CmdResult::FAILURE; } if (!c->IsModeSet(inviteonlymode)) { user->WriteNumeric(ERR_CHANOPEN, c->name, INSP_FORMAT("Can't KNOCK on {}, channel is not invite only so knocking is pointless!", c->name)); return CmdResult::FAILURE; } // Work out who we should send the knock to. char status; switch (inviteapi->GetAnnounceState()) { case Invite::ANNOUNCE_ALL: { status = 0; break; } case Invite::ANNOUNCE_DYNAMIC: { PrefixMode* mh = ServerInstance->Modes.FindNearestPrefixMode(HALFOP_VALUE); status = mh->GetPrefix() ? mh->GetPrefix() : '@'; break; } default: { status = '@'; break; } } if (notify & KN_SEND_NOTICE) { c->WriteNotice(INSP_FORMAT("User {} is KNOCKing on {} ({})", user->nick, c->name, parameters[1]), status); user->WriteNotice("KNOCKing on " + c->name); } if (notify & KN_SEND_NUMERIC) { Numeric::Numeric numeric(RPL_KNOCK); numeric.push(c->name).push(user->GetMask()).push("is KNOCKing: " + parameters[1]); ClientProtocol::Messages::Numeric numericmsg(numeric, c->name); c->Write(ServerInstance->GetRFCEvents().numeric, numericmsg, status); user->WriteNumeric(RPL_KNOCKDLVR, c->name, "KNOCKing on channel"); } return CmdResult::SUCCESS; } RouteDescriptor GetRouting(User* user, const Params& parameters) override { return ROUTE_OPT_BCAST; } }; class ModuleKnock final : public Module { SimpleChannelMode kn; CommandKnock cmd; public: ModuleKnock() : Module(VF_VENDOR | VF_OPTCOMMON, "Adds the /KNOCK command which allows users to request access to an invite-only channel and channel mode K (noknock) which allows channels to disable usage of this command.") , kn(this, "noknock", 'K') , cmd(this, kn) { } void ReadConfig(ConfigStatus& status) override { const auto& tag = ServerInstance->Config->ConfValue("knock"); cmd.notify = tag->getEnum("notify", KN_SEND_NOTICE, { { "both", KN_SEND_BOTH }, { "notice", KN_SEND_NOTICE }, { "numeric", KN_SEND_NUMERIC }, }); } }; MODULE_INIT(ModuleKnock) ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/src/modules/m_ldapauth.cpp�����������������������������������������������������������0000664�0000000�0000000�00000026651�14771603147�0020442�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2020 Joel Sing <joel@sing.id.au> * Copyright (C) 2019-2023 Sadie Powell <sadie@witchery.services> * Copyright (C) 2014-2015 Attila Molnar <attilamolnar@hush.com> * Copyright (C) 2014 Thiago Crepaldi <thiago@thiagocrepaldi.com> * Copyright (C) 2013-2014, 2017 Adam <Adam@anope.org> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include "inspircd.h" #include "extension.h" #include "modules/ldap.h" namespace { Module* me; std::string killreason; BoolExtItem* authed; bool verbose; std::string vhost; StringExtItem* vhosts; std::vector<std::pair<std::string, std::string>> requiredattributes; } class BindInterface final : public LDAPInterface { const std::string provider; const std::string uid; std::string DN; bool checkingAttributes = false; bool passed = false; int attrCount = 0; static std::string SafeReplace(const std::string& text, std::map<std::string, std::string>& replacements) { std::string result; result.reserve(text.length()); for (unsigned int i = 0; i < text.length(); ++i) { char c = text[i]; if (c == '$') { // find the first nonalpha i++; unsigned int start = i; while (i < text.length() - 1 && isalpha(text[i + 1])) ++i; std::string key(text, start, (i - start) + 1); result.append(replacements[key]); } else result.push_back(c); } return result; } static void SetVHost(User* user, const std::string& DN) { if (!vhost.empty()) { irc::commasepstream stream(DN); // mashed map of key:value parts of the DN std::map<std::string, std::string> dnParts; std::string dnPart; while (stream.GetToken(dnPart)) { std::string::size_type pos = dnPart.find('='); if (pos == std::string::npos) // malformed continue; std::string key(dnPart, 0, pos); std::string value(dnPart, pos + 1, dnPart.length() - pos + 1); // +1s to skip the = itself dnParts[key] = value; } // change host according to config key vhosts->Set(user, SafeReplace(vhost, dnParts)); } } public: BindInterface(Module* c, const std::string& p, const std::string& u, const std::string& dn) : LDAPInterface(c) , provider(p) , uid(u) , DN(dn) { } void OnResult(const LDAPResult& r) override { auto* user = ServerInstance->Users.FindUUID(uid); dynamic_reference<LDAPProvider> LDAP(me, provider); if (!user || !LDAP) { if (!checkingAttributes || !--attrCount) delete this; return; } if (!checkingAttributes && requiredattributes.empty()) { if (verbose) ServerInstance->SNO.WriteToSnoMask('c', "Successful connection from {} (dn={})", user->GetRealMask(), DN); // We're done, there are no attributes to check SetVHost(user, DN); authed->Set(user); delete this; return; } // Already checked attributes? if (checkingAttributes) { if (!passed) { // Only one has to pass passed = true; if (verbose) ServerInstance->SNO.WriteToSnoMask('c', "Successful connection from {} (dn={})", user->GetRealMask(), DN); SetVHost(user, DN); authed->Set(user); } // Delete this if this is the last ref if (!--attrCount) delete this; return; } // check required attributes checkingAttributes = true; for (const auto& [attr, val] : requiredattributes) { // Note that only one of these has to match for it to be success ServerInstance->Logs.Debug(MODNAME, "LDAP compare: {}={}", attr, val); try { LDAP->Compare(this, DN, attr, val); ++attrCount; } catch (const LDAPException& ex) { if (verbose) ServerInstance->SNO.WriteToSnoMask('c', "Unable to compare attributes {}={}: {}", attr, val, ex.GetReason()); } } // Nothing done if (!attrCount) { if (verbose) { ServerInstance->SNO.WriteToSnoMask('c', "Forbidden connection from {} (dn={}) (unable to validate attributes)", user->GetRealMask(), DN); } ServerInstance->Users.QuitUser(user, killreason); delete this; } } void OnError(const LDAPResult& err) override { if (checkingAttributes && --attrCount) return; if (passed) { delete this; return; } auto* user = ServerInstance->Users.FindUUID(uid); if (user) { if (verbose) { ServerInstance->SNO.WriteToSnoMask('c', "Forbidden connection from {} ({})", user->GetRealMask(), err.getError()); } ServerInstance->Users.QuitUser(user, killreason); } delete this; } }; class SearchInterface final : public LDAPInterface { const std::string provider; const std::string uid; public: SearchInterface(Module* c, const std::string& p, const std::string& u) : LDAPInterface(c) , provider(p) , uid(u) { } void OnResult(const LDAPResult& r) override { LocalUser* user = ServerInstance->Users.FindUUID<LocalUser>(uid); dynamic_reference<LDAPProvider> LDAP(me, provider); if (!LDAP || r.empty() || !user) { if (user) ServerInstance->Users.QuitUser(user, killreason); delete this; return; } try { const LDAPAttributes& a = r.get(0); std::string bindDn = a.get("dn"); if (bindDn.empty()) { ServerInstance->Users.QuitUser(user, killreason); delete this; return; } LDAP->Bind(new BindInterface(this->creator, provider, uid, bindDn), bindDn, user->password); } catch (const LDAPException& ex) { ServerInstance->SNO.WriteToSnoMask('a', "Error searching LDAP server: " + ex.GetReason()); } delete this; } void OnError(const LDAPResult& err) override { ServerInstance->SNO.WriteToSnoMask('a', "Error searching LDAP server: {}", err.getError()); auto* user = ServerInstance->Users.FindUUID(uid); if (user) ServerInstance->Users.QuitUser(user, killreason); delete this; } }; class AdminBindInterface final : public LDAPInterface { const std::string provider; const std::string uuid; const std::string base; const std::string what; public: AdminBindInterface(Module* c, const std::string& p, const std::string& u, const std::string& b, const std::string& w) : LDAPInterface(c) , provider(p) , uuid(u) , base(b) , what(w) { } void OnResult(const LDAPResult& r) override { dynamic_reference<LDAPProvider> LDAP(me, provider); if (LDAP) { try { LDAP->Search(new SearchInterface(this->creator, provider, uuid), base, what); } catch (const LDAPException& ex) { ServerInstance->SNO.WriteToSnoMask('a', "Error searching LDAP server: " + ex.GetReason()); } } delete this; } void OnError(const LDAPResult& err) override { ServerInstance->SNO.WriteToSnoMask('a', "Error binding as manager to LDAP server: " + err.getError()); delete this; } }; enum class AuthField : uint8_t { NICKNAME, USERNAME, PASSWORD, }; class ModuleLDAPAuth final : public Module { dynamic_reference<LDAPProvider> LDAP; BoolExtItem ldapAuthed; StringExtItem ldapVhost; std::string base; std::string attribute; std::vector<std::string> exemptions; AuthField field; public: ModuleLDAPAuth() : Module(VF_VENDOR, "Allows connecting users to be authenticated against an LDAP database.") , LDAP(this, "LDAP") , ldapAuthed(this, "ldapauth", ExtensionType::USER) , ldapVhost(this, "ldapauth-vhost", ExtensionType::USER) { me = this; authed = &ldapAuthed; vhosts = &ldapVhost; } void ReadConfig(ConfigStatus& status) override { const auto& tag = ServerInstance->Config->ConfValue("ldapauth"); base = tag->getString("baserdn"); attribute = tag->getString("attribute"); killreason = tag->getString("killreason"); vhost = tag->getString("host"); // Set to true if failed connects should be reported to operators verbose = tag->getBool("verbose"); field = tag->getEnum("field", tag->getBool("useusername") ? AuthField::USERNAME : AuthField::NICKNAME, { { "nickname", AuthField::USERNAME }, { "password", AuthField::PASSWORD }, { "username", AuthField::NICKNAME }, }); LDAP.SetProvider("LDAP/" + tag->getString("dbid")); requiredattributes.clear(); for (const auto& [_, rtag] : ServerInstance->Config->ConfTags("ldaprequire")) { const std::string attr = rtag->getString("attribute"); const std::string val = rtag->getString("value"); if (!attr.empty() && !val.empty()) requiredattributes.emplace_back(attr, val); } exemptions.clear(); for (const auto& [_, etag] : ServerInstance->Config->ConfTags("ldapexemption")) { const std::string mask = etag->getString("mask"); if (!mask.empty()) exemptions.push_back(mask); } // Begin v3 config compatibility. for (const auto& [_, wtag] : ServerInstance->Config->ConfTags("ldapwhitelist")) { const std::string cidr = wtag->getString("cidr"); if (!cidr.empty()) exemptions.push_back("*!*@" + cidr); } irc::spacesepstream nickstream(tag->getString("allowpattern")); for (std::string nick; nickstream.GetToken(nick); ) exemptions.push_back(nick + "!*@*"); // End v3 config compatibility. } void OnUserConnect(LocalUser* user) override { std::string* cc = ldapVhost.Get(user); if (cc) { user->ChangeDisplayedHost(*cc); ldapVhost.Unset(user); } } ModResult OnUserRegister(LocalUser* user) override { for (const auto& exemption : exemptions) { if (InspIRCd::MatchCIDR(user->GetRealMask(), exemption) || InspIRCd::MatchCIDR(user->GetMask(), exemption)) { ldapAuthed.Set(user, true); return MOD_RES_PASSTHRU; } } if (user->password.empty()) { if (verbose) ServerInstance->SNO.WriteToSnoMask('c', "Forbidden connection from {} (no password provided)", user->GetRealMask()); ServerInstance->Users.QuitUser(user, killreason); return MOD_RES_DENY; } if (!LDAP) { if (verbose) ServerInstance->SNO.WriteToSnoMask('c', "Forbidden connection from {} (unable to find LDAP provider)", user->GetRealMask()); ServerInstance->Users.QuitUser(user, killreason); return MOD_RES_DENY; } std::string what = attribute + "="; switch (field) { case AuthField::NICKNAME: what += user->nick; break; case AuthField::USERNAME: what += user->GetRealUser(); break; case AuthField::PASSWORD: { auto pos = user->password.find(':'); if (pos == std::string::npos) { if (verbose) ServerInstance->SNO.WriteToSnoMask('c', "Forbidden connection from {} (no username provided)", user->GetRealMask()); ServerInstance->Users.QuitUser(user, killreason); return MOD_RES_DENY; } what += user->password.substr(0, pos); user->password.erase(0, pos + 1); user->password.shrink_to_fit(); break; } } try { LDAP->BindAsManager(new AdminBindInterface(this, LDAP.GetProvider(), user->uuid, base, what)); } catch (const LDAPException& ex) { ServerInstance->SNO.WriteToSnoMask('a', "LDAP exception: " + ex.GetReason()); ServerInstance->Users.QuitUser(user, killreason); } return MOD_RES_DENY; } ModResult OnCheckReady(LocalUser* user) override { return ldapAuthed.Get(user) ? MOD_RES_PASSTHRU : MOD_RES_DENY; } }; MODULE_INIT(ModuleLDAPAuth) ���������������������������������������������������������������������������������������inspircd-4.7.0/src/modules/m_ldapoper.cpp�����������������������������������������������������������0000664�0000000�0000000�00000013724�14771603147�0020443�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2018-2023 Sadie Powell <sadie@witchery.services> * Copyright (C) 2014, 2018 Attila Molnar <attilamolnar@hush.com> * Copyright (C) 2013-2014 Adam <Adam@anope.org> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include "inspircd.h" #include "modules/ldap.h" namespace { Module* me; } class LDAPOperBase : public LDAPInterface { protected: const std::string uid; const std::string opername; const std::string password; void Fallback(User* user) { if (!user) return; Command* oper_command = ServerInstance->Parser.GetHandler("OPER"); if (!oper_command) return; CommandBase::Params params; params.push_back(opername); params.push_back(password); ClientProtocol::TagMap tags; oper_command->Handle(user, CommandBase::Params(params, tags)); } void Fallback() { auto* user = ServerInstance->Users.FindUUID(uid); Fallback(user); } public: LDAPOperBase(Module* mod, const std::string& uuid, const std::string& oper, const std::string& pass) : LDAPInterface(mod) , uid(uuid) , opername(oper) , password(pass) { } void OnError(const LDAPResult& err) override { ServerInstance->SNO.WriteToSnoMask('a', "Error searching LDAP server: {}", err.getError()); Fallback(); delete this; } }; class BindInterface final : public LDAPOperBase { public: BindInterface(Module* mod, const std::string& uuid, const std::string& oper, const std::string& pass) : LDAPOperBase(mod, uuid, oper, pass) { } void OnResult(const LDAPResult& r) override { auto* user = ServerInstance->Users.FindUUID(uid); auto iter = ServerInstance->Config->OperAccounts.find(opername); if (!user || iter == ServerInstance->Config->OperAccounts.end()) { Fallback(); delete this; return; } user->OperLogin(iter->second); delete this; } }; class SearchInterface final : public LDAPOperBase { const std::string provider; bool HandleResult(const LDAPResult& result) { dynamic_reference<LDAPProvider> LDAP(me, provider); if (!LDAP || result.empty()) return false; try { const LDAPAttributes& attr = result.get(0); std::string bindDn = attr.get("dn"); if (bindDn.empty()) return false; LDAP->Bind(new BindInterface(this->creator, uid, opername, password), bindDn, password); } catch (const LDAPException& ex) { ServerInstance->SNO.WriteToSnoMask('a', "Error searching LDAP server: " + ex.GetReason()); } return true; } public: SearchInterface(Module* mod, const std::string& prov, const std::string& uuid, const std::string& oper, const std::string& pass) : LDAPOperBase(mod, uuid, oper, pass) , provider(prov) { } void OnResult(const LDAPResult& result) override { if (!HandleResult(result)) Fallback(); delete this; } }; class AdminBindInterface final : public LDAPInterface { const std::string provider; const std::string user; const std::string opername; const std::string password; const std::string base; const std::string what; public: AdminBindInterface(Module* c, const std::string& p, const std::string& u, const std::string& o, const std::string& pa, const std::string& b, const std::string& w) : LDAPInterface(c) , provider(p) , user(u) , opername(o) , password(pa) , base(b) , what(w) { } void OnResult(const LDAPResult& r) override { dynamic_reference<LDAPProvider> LDAP(me, provider); if (LDAP) { try { LDAP->Search(new SearchInterface(this->creator, provider, user, opername, password), base, what); } catch (const LDAPException& ex) { ServerInstance->SNO.WriteToSnoMask('a', "Error searching LDAP server: " + ex.GetReason()); } } delete this; } void OnError(const LDAPResult& err) override { ServerInstance->SNO.WriteToSnoMask('a', "Error binding as manager to LDAP server: " + err.getError()); delete this; } }; class ModuleLDAPOper final : public Module { dynamic_reference<LDAPProvider> LDAP; std::string base; std::string attribute; public: ModuleLDAPOper() : Module(VF_VENDOR, "Allows server operators to be authenticated against an LDAP database.") , LDAP(this, "LDAP") { me = this; } void ReadConfig(ConfigStatus& status) override { const auto& tag = ServerInstance->Config->ConfValue("ldapoper"); LDAP.SetProvider("LDAP/" + tag->getString("dbid")); base = tag->getString("baserdn"); attribute = tag->getString("attribute"); } ModResult OnPreCommand(std::string& command, CommandBase::Params& parameters, LocalUser* user, bool validated) override { if (validated && command == "OPER" && parameters.size() >= 2) { const std::string& opername = parameters[0]; const std::string& password = parameters[1]; auto it = ServerInstance->Config->OperAccounts.find(opername); if (it == ServerInstance->Config->OperAccounts.end()) return MOD_RES_PASSTHRU; std::string acceptedhosts = it->second->GetConfig()->getString("host"); if (!InspIRCd::MatchMask(acceptedhosts, user->GetRealUserHost(), user->GetUserAddress())) return MOD_RES_PASSTHRU; if (!LDAP) return MOD_RES_PASSTHRU; try { std::string what = attribute + "=" + opername; LDAP->BindAsManager(new AdminBindInterface(this, LDAP.GetProvider(), user->uuid, opername, password, base, what)); return MOD_RES_DENY; } catch (const LDAPException& ex) { ServerInstance->SNO.WriteToSnoMask('a', "LDAP exception: " + ex.GetReason()); } } return MOD_RES_PASSTHRU; } }; MODULE_INIT(ModuleLDAPOper) ��������������������������������������������inspircd-4.7.0/src/modules/m_log_sql.cpp������������������������������������������������������������0000664�0000000�0000000�00000005775�14771603147�0020304�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2022-2023 Sadie Powell <sadie@witchery.services> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include "inspircd.h" #include "modules/sql.h" namespace { Module* thismod; } class SQLQuery final : public SQL::Query { public: SQLQuery(Module* mod) ATTR_NOT_NULL(2) : SQL::Query(mod) { } void OnResult(SQL::Result& res) override { // Nothing to do here. } void OnError(const SQL::Error& error) override { ServerInstance->SNO.WriteGlobalSno('a', "Unable to write to SQL log (query error: {}).", error.ToString()); } }; class SQLMethod final : public Log::Method { private: std::string query; dynamic_reference<SQL::Provider> sql; time_t lastwarning = 0; public: SQLMethod(const dynamic_reference<SQL::Provider>& s, const std::string& q) : query(q) , sql(s) { } void OnLog(time_t time, Log::Level level, const std::string& type, const std::string& message) override { if (!sql) { // Only give a warning every 5 minutes to avoid log spam. if (ServerInstance->Time() - lastwarning > 300) { lastwarning = ServerInstance->Time(); ServerInstance->SNO.WriteGlobalSno('a', "Unable to write to SQL log (database {} not available).", sql->GetId()); } return; } SQL::ParamMap params = { { "level", ConvToStr(static_cast<uint8_t>(level)) }, { "levelstr", Log::LevelToString(level) }, { "message", message }, { "time", ConvToStr(time) }, { "type", type }, }; sql->Submit(new SQLQuery(thismod), query, params); } }; class SQLEngine final : public Log::Engine { public: SQLEngine(Module* Creator) ATTR_NOT_NULL(2) : Log::Engine(Creator, "sql") { } Log::MethodPtr Create(const std::shared_ptr<ConfigTag>& tag) override { dynamic_reference<SQL::Provider> sql(creator, "SQL"); const std::string dbid = tag->getString("dbid"); if (!dbid.empty()) sql.SetProvider("SQL/" + dbid); const std::string query = tag->getString("query", "INSERT INTO ircd_log (time, type, message) VALUES (FROM_UNIXTIME($time), '$type', '$message');", 1); return std::make_shared<SQLMethod>(sql, query); } }; class ModuleLogSQL final : public Module { private: SQLEngine engine; public: ModuleLogSQL() : Module(VF_VENDOR, "Provides the ability to log to a SQL database.") , engine(this) { thismod = this; } }; MODULE_INIT(ModuleLogSQL) ���inspircd-4.7.0/src/modules/m_maphide.cpp������������������������������������������������������������0000664�0000000�0000000�00000003424�14771603147�0020240�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2013, 2019-2021 Sadie Powell <sadie@witchery.services> * Copyright (C) 2012-2013 Attila Molnar <attilamolnar@hush.com> * Copyright (C) 2012 Robby <robby@chatbelgie.be> * Copyright (C) 2009-2010 Daniel De Graaf <danieldg@inspircd.org> * Copyright (C) 2009 Uli Schlachter <psychon@znc.in> * Copyright (C) 2008 Craig Edwards <brain@inspircd.org> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include "inspircd.h" class ModuleMapHide final : public Module { private: std::string url; public: ModuleMapHide() : Module(VF_VENDOR, "Allows the server administrator to replace the output of a /MAP and /LINKS with an URL.") { } void ReadConfig(ConfigStatus& status) override { url = ServerInstance->Config->ConfValue("security")->getString("maphide"); } ModResult OnPreCommand(std::string& command, CommandBase::Params& parameters, LocalUser* user, bool validated) override { if (validated && !user->IsOper() && !url.empty() && (command == "MAP" || command == "LINKS")) { user->WriteNotice("/" + command + " has been disabled; visit " + url); return MOD_RES_DENY; } else return MOD_RES_PASSTHRU; } }; MODULE_INIT(ModuleMapHide) ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/src/modules/m_md5.cpp����������������������������������������������������������������0000664�0000000�0000000�00000003302�14771603147�0017311�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2013, 2019-2023 Sadie Powell <sadie@witchery.services> * Copyright (C) 2012 Robby <robby@chatbelgie.be> * Copyright (C) 2009 Daniel De Graaf <danieldg@inspircd.org> * Copyright (C) 2006 Craig Edwards <brain@inspircd.org> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include <md5/md5.c> #undef F #ifdef _WIN32 # undef OUT #endif #include "inspircd.h" #include "modules/hash.h" class MD5Provider final : public HashProvider { public: std::string GenerateRaw(const std::string& data) override { MD5_CTX context; MD5_Init(&context); MD5_Update(&context, reinterpret_cast<const unsigned char*>(data.data()), data.length()); std::vector<unsigned char> bytes(16); MD5_Final(bytes.data(), &context); return std::string(reinterpret_cast<const char*>(bytes.data()), bytes.size()); } MD5Provider(Module* parent) : HashProvider(parent, "md5", 16, 64) { } }; class ModuleMD5 final : public Module { private: MD5Provider md5; public: ModuleMD5() : Module(VF_VENDOR, "Allows other modules to generate MD5 hashes.") , md5(this) { } }; MODULE_INIT(ModuleMD5) ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/src/modules/m_messageflood.cpp�������������������������������������������������������0000664�0000000�0000000�00000021644�14771603147�0021305�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2017-2024 Sadie Powell <sadie@witchery.services> * Copyright (C) 2012-2014 Attila Molnar <attilamolnar@hush.com> * Copyright (C) 2012 Robby <robby@chatbelgie.be> * Copyright (C) 2009 Daniel De Graaf <danieldg@inspircd.org> * Copyright (C) 2008 Robin Burchell <robin+git@viroteck.net> * Copyright (C) 2006, 2008 Craig Edwards <brain@inspircd.org> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include "inspircd.h" #include "modules/ctctags.h" #include "modules/exemption.h" #include "numerichelper.h" #include "timeutils.h" enum class MsgFloodAction : uint8_t { BAN, BLOCK, MUTE, KICK, KICK_BAN, }; class MsgFloodSettings final { private: insp::flat_map<User*, double> counters; time_t reset; public: MsgFloodAction action; unsigned int messages; unsigned long period; MsgFloodSettings(MsgFloodAction a, unsigned int m, unsigned long p) : reset(ServerInstance->Time() + p) , action(a) , messages(m) , period(p) { } bool Add(User* who, double weight) { if (ServerInstance->Time() > reset) { counters.clear(); reset = ServerInstance->Time() + period; } counters[who] += weight; return (counters[who] >= this->messages); } void Clear(User* who) { counters.erase(who); } }; class MsgFlood final : public ParamMode<MsgFlood, SimpleExtItem<MsgFloodSettings>> { private: static bool ParseAction(irc::sepstream& stream, MsgFloodAction& action) { std::string actionstr; if (!stream.GetToken(actionstr)) return false; if (irc::equals(actionstr, "ban")) action = MsgFloodAction::BAN; else if (irc::equals(actionstr, "block")) action = MsgFloodAction::BLOCK; else if (irc::equals(actionstr, "mute")) action = MsgFloodAction::MUTE; else if (irc::equals(actionstr, "kick")) action = MsgFloodAction::KICK; else if (irc::equals(actionstr, "kickban")) action = MsgFloodAction::KICK_BAN; else return false; return true; } static bool ParseMessages(irc::sepstream& stream, unsigned int& messages) { std::string messagestr; if (!stream.GetToken(messagestr)) return false; messages = ConvToNum<unsigned int>(messagestr); return true; } static bool ParsePeriod(irc::sepstream& stream, unsigned long& period) { std::string periodstr; if (!stream.GetToken(periodstr)) return false; return Duration::TryFrom(periodstr, period); } public: bool extended; MsgFlood(Module* Creator) : ParamMode<MsgFlood, SimpleExtItem<MsgFloodSettings>>(Creator, "flood", 'f') { } bool OnSet(User* source, Channel* channel, std::string& parameter) override { MsgFloodAction action; unsigned int messages; unsigned long period; if (extended) { irc::sepstream stream(parameter, ':'); if (!ParseAction(stream, action) || !ParseMessages(stream, messages) || !ParsePeriod(stream, period)) { source->WriteNumeric(Numerics::InvalidModeParameter(channel, this, parameter)); return false; } } else { std::string::size_type colon = parameter.find(':'); if (colon == std::string::npos || parameter.find('-') != std::string::npos) { source->WriteNumeric(Numerics::InvalidModeParameter(channel, this, parameter)); return false; } bool kickban = parameter[0] == '*'; action = kickban ? MsgFloodAction::KICK_BAN : MsgFloodAction::BLOCK; messages = ConvToNum<unsigned int>(parameter.substr(kickban ? 1 : 0, kickban ? colon - 1 : colon)); period = ConvToNum<unsigned int>(parameter.substr(colon + 1)); } if (messages < 2 || period < 1) { source->WriteNumeric(Numerics::InvalidModeParameter(channel, this, parameter)); return false; } ext.SetFwd(channel, action, messages, period); return true; } void SerializeParam(Channel* chan, const MsgFloodSettings* fs, std::string& out) { if (extended) { switch (fs->action) { case MsgFloodAction::BAN: out.append("ban"); break; case MsgFloodAction::BLOCK: out.append("block"); break; case MsgFloodAction::MUTE: out.append("mute"); break; case MsgFloodAction::KICK: out.append("kick"); break; case MsgFloodAction::KICK_BAN: out.append("kickban"); break; } out.push_back(':'); out.append(ConvToStr(fs->messages)); out.push_back(':'); out.append(Duration::ToString(fs->period)); } else { if (fs->action == MsgFloodAction::KICK_BAN) out.push_back('*'); out.append(ConvToStr(fs->messages)).push_back(':'); out.append(ConvToStr(fs->period)); } } void SetSyntax() { if (extended) syntax = "{ban|block|mute|kick|kickban}:<messages>:<period>"; else syntax = "[*]<messages>:<period>"; } }; class ModuleMsgFlood final : public Module , public CTCTags::EventListener { private: ChanModeReference banmode; CheckExemption::EventProvider exemptionprov; MsgFlood mf; double notice; double privmsg; double tagmsg; std::string message; void CreateBan(Channel* channel, User* user, bool mute) { std::string banmask(mute ? "m:*!" : "*!"); banmask.append(user->GetBanUser(false)); banmask.append("@"); banmask.append(user->GetDisplayedHost()); Modes::ChangeList changelist; changelist.push_add(*banmode, banmask); ServerInstance->Modes.Process(ServerInstance->FakeClient, channel, nullptr, changelist); } static void InformUser(Channel* chan, User* user, const std::string& message) { Membership* memb = chan->GetUser(user); if (memb) memb->WriteNotice(message); else user->WriteNotice("[{}] {}", chan->name, message); } public: ModuleMsgFlood() : Module(VF_VENDOR, "Adds channel mode f (flood) which helps protect against spammers which mass-message channels.") , CTCTags::EventListener(this) , banmode(this, "ban") , exemptionprov(this) , mf(this) { } void ReadConfig(ConfigStatus&) override { const auto& tag = ServerInstance->Config->ConfValue("messageflood"); notice = tag->getNum<double>("notice", 1.0); privmsg = tag->getNum<double>("privmsg", 1.0); tagmsg = tag->getNum<double>("tagmsg", 0.2); message = tag->getString("message", "Message flood detected (trigger is %messages% messages in %duration%)", 1); mf.extended = tag->getBool("extended"); mf.SetSyntax(); } void GetLinkData(LinkData& data, std::string& compatdata) override { data["actions"] = mf.extended ? "ban block kick kickban mute" : "block kickban"; compatdata = mf.extended ? "extended" : ""; } ModResult HandleMessage(User* user, const MessageTarget& target, double weight) { if (target.type != MessageTarget::TYPE_CHANNEL) return MOD_RES_PASSTHRU; auto* dest = target.Get<Channel>(); if ((!IS_LOCAL(user)) || !dest->IsModeSet(mf)) return MOD_RES_PASSTHRU; ModResult res = exemptionprov.Check(user, dest, "flood"); if (res == MOD_RES_ALLOW) return MOD_RES_PASSTHRU; auto* f = mf.ext.Get(dest); if (f) { if (f->Add(user, weight)) { /* You're outttta here! */ f->Clear(user); const std::string msg = Template::Replace(message, { { "channel", dest->name }, { "duration", Duration::ToString(f->period) }, { "messages", ConvToStr(f->messages) }, { "seconds", ConvToStr(f->period) }, }); switch (f->action) { case MsgFloodAction::BAN: InformUser(dest, user, msg); CreateBan(dest, user, false); break; case MsgFloodAction::BLOCK: InformUser(dest, user, msg); break; case MsgFloodAction::KICK: dest->KickUser(ServerInstance->FakeClient, user, msg); break; case MsgFloodAction::KICK_BAN: CreateBan(dest, user, false); dest->KickUser(ServerInstance->FakeClient, user, msg); break; case MsgFloodAction::MUTE: InformUser(dest, user, msg); CreateBan(dest, user, true); break; } return MOD_RES_DENY; } } return MOD_RES_PASSTHRU; } ModResult OnUserPreMessage(User* user, MessageTarget& target, MessageDetails& details) override { return HandleMessage(user, target, (details.type == MessageType::PRIVMSG ? privmsg : notice)); } ModResult OnUserPreTagMessage(User* user, MessageTarget& target, CTCTags::TagMessageDetails& details) override { return HandleMessage(user, target, tagmsg); } void Prioritize() override { // we want to be after all modules that might deny the message (e.g. m_muteban, m_noctcp, m_blockcolor, etc.) ServerInstance->Modules.SetPriority(this, I_OnUserPreMessage, PRIORITY_LAST); } }; MODULE_INIT(ModuleMsgFlood) ��������������������������������������������������������������������������������������������inspircd-4.7.0/src/modules/m_monitor.cpp������������������������������������������������������������0000664�0000000�0000000�00000025342�14771603147�0020323�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2022 delthas * Copyright (C) 2021 Dominic Hamon * Copyright (C) 2018-2023 Sadie Powell <sadie@witchery.services> * Copyright (C) 2016 Attila Molnar <attilamolnar@hush.com> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include "inspircd.h" #include "modules/cap.h" #include "modules/isupport.h" #include "modules/monitor.h" #include "numericbuilder.h" namespace IRCv3::Monitor { class ExtItem; struct Entry; class Manager; class ManagerInternal; typedef std::vector<Entry*> WatchedList; typedef std::vector<LocalUser*> WatcherList; } struct IRCv3::Monitor::Entry final { WatcherList watchers; std::string nick; void SetNick(const std::string& Nick) { nick.clear(); // We may show this string to other users so do not leak the casing std::transform(Nick.begin(), Nick.end(), std::back_inserter(nick), ::tolower); } const std::string& GetNick() const { return nick; } }; class IRCv3::Monitor::Manager final { struct ExtData final { WatchedList list; }; class ExtItem final : public ExtensionItem { Manager& manager; public: ExtItem(Module* mod, const std::string& extname, Manager& managerref) : ExtensionItem(mod, extname, ExtensionType::USER) , manager(managerref) { } ExtData* Get(User* user, bool create = false) { ExtData* extdata = static_cast<ExtData*>(GetRaw(user)); if ((!extdata) && (create)) { extdata = new ExtData; SetRaw(user, extdata); } return extdata; } void Unset(User* user) { Delete(user, UnsetRaw(user)); } std::string ToInternal(const Extensible* container, void* item) const noexcept override { std::string ret; const ExtData* extdata = static_cast<ExtData*>(item); for (const auto* entry : extdata->list) ret.append(entry->GetNick()).push_back(' '); if (!ret.empty()) ret.pop_back(); return ret; } void FromInternal(Extensible* container, const std::string& value) noexcept override; void Delete(Extensible* container, void* item) override { delete static_cast<ExtData*>(item); } }; public: Manager(Module* mod, const std::string& extname) : ext(mod, extname, *this) { } enum WatchResult { WR_OK, WR_TOOMANY, WR_ALREADYWATCHING, WR_INVALIDNICK }; WatchResult Watch(LocalUser* user, const std::string& nick, unsigned long maxwatch) { if (!ServerInstance->IsNick(nick)) return WR_INVALIDNICK; WatchedList* watched = GetWatchedPriv(user, true); if (watched->size() >= maxwatch) return WR_TOOMANY; Entry* entry = AddWatcher(nick, user); if (stdalgo::isin(*watched, entry)) return WR_ALREADYWATCHING; entry->watchers.push_back(user); watched->push_back(entry); return WR_OK; } bool Unwatch(LocalUser* user, const std::string& nick) { WatchedList* list = GetWatchedPriv(user); if (!list) return false; bool ret = RemoveWatcher(nick, user, *list); // If no longer watching any nick unset ext if (list->empty()) ext.Unset(user); return ret; } const WatchedList& GetWatched(LocalUser* user) { WatchedList* list = GetWatchedPriv(user); if (list) return *list; return emptywatchedlist; } void UnwatchAll(LocalUser* user) { WatchedList* list = GetWatchedPriv(user); if (!list) return; while (!list->empty()) { Entry* entry = list->front(); RemoveWatcher(entry->GetNick(), user, *list); } ext.Unset(user); } WatcherList* GetWatcherList(const std::string& nick) { Entry* entry = Find(nick); if (entry) return &entry->watchers; return nullptr; } private: typedef std::unordered_map<std::string, Entry, irc::insensitive, irc::StrHashComp> NickHash; Entry* Find(const std::string& nick) { NickHash::iterator it = nicks.find(nick); if (it != nicks.end()) return &it->second; return nullptr; } Entry* AddWatcher(const std::string& nick, LocalUser* user) { std::pair<NickHash::iterator, bool> ret = nicks.emplace(nick, Entry()); Entry& entry = ret.first->second; if (ret.second) entry.SetNick(nick); return &entry; } bool RemoveWatcher(const std::string& nick, LocalUser* user, WatchedList& watchedlist) { NickHash::iterator it = nicks.find(nick); // If nobody is watching this nick the user trying to remove it isn't watching it for sure if (it == nicks.end()) return false; Entry& entry = it->second; // Erase from the user's list of watched nicks if (!stdalgo::vector::swaperase(watchedlist, &entry)) return false; // User is not watching this nick // Erase from the nick's list of watching users stdalgo::vector::swaperase(entry.watchers, user); // If nobody else is watching the nick remove map entry if (entry.watchers.empty()) nicks.erase(it); return true; } WatchedList* GetWatchedPriv(LocalUser* user, bool create = false) { ExtData* extdata = ext.Get(user, create); if (!extdata) return nullptr; return &extdata->list; } NickHash nicks; ExtItem ext; WatchedList emptywatchedlist; }; void IRCv3::Monitor::Manager::ExtItem::FromInternal(Extensible* container, const std::string& value) noexcept { if (container->extype != this->extype) return; irc::spacesepstream ss(value); for (std::string nick; ss.GetToken(nick); ) manager.Watch(static_cast<LocalUser*>(container), nick, ULONG_MAX); } #ifndef INSPIRCD_MONITOR_MANAGER_ONLY enum { RPL_MONONLINE = 730, RPL_MONOFFLINE = 731, RPL_MONLIST = 732, RPL_ENDOFMONLIST = 733, ERR_MONLISTFULL = 734 }; class CommandMonitor final : public SplitCommand { typedef Numeric::Builder<> ReplyBuilder; // Additional penalty for the /MONITOR L and /MONITOR S commands that request a list from the server static constexpr unsigned int ListPenalty = 3000; IRCv3::Monitor::Manager& manager; void HandlePlus(LocalUser* user, const std::string& input) { ReplyBuilder online(user, RPL_MONONLINE); ReplyBuilder offline(user, RPL_MONOFFLINE); irc::commasepstream ss(input); for (std::string nick; ss.GetToken(nick); ) { IRCv3::Monitor::Manager::WatchResult result = manager.Watch(user, nick, maxmonitor); if (result == IRCv3::Monitor::Manager::WR_TOOMANY) { // List is full, send error which includes the remaining nicks that were not processed user->WriteNumeric(ERR_MONLISTFULL, maxmonitor, INSP_FORMAT("{}{}{}", nick, (ss.StreamEnd() ? "" : ","), ss.GetRemaining()), "Monitor list is full"); break; } else if (result != IRCv3::Monitor::Manager::WR_OK) continue; // Already added or invalid nick ReplyBuilder& out = (ServerInstance->Users.FindNick(nick, true) ? online : offline); out.Add(nick); } online.Flush(); offline.Flush(); } void HandleMinus(LocalUser* user, const std::string& input) { irc::commasepstream ss(input); for (std::string nick; ss.GetToken(nick); ) manager.Unwatch(user, nick); } public: unsigned long maxmonitor; CommandMonitor(Module* mod, IRCv3::Monitor::Manager& managerref) : SplitCommand(mod, "MONITOR", 1) , manager(managerref) { penalty = 2000; syntax = { "C", "L", "S", "(+|-) <nick>[,<nick>]+" }; } CmdResult HandleLocal(LocalUser* user, const Params& parameters) override { char subcmd = toupper(parameters[0][0]); if (subcmd == '+') { if (parameters.size() > 1) HandlePlus(user, parameters[1]); } else if (subcmd == '-') { if (parameters.size() > 1) HandleMinus(user, parameters[1]); } else if (subcmd == 'C') { manager.UnwatchAll(user); } else if (subcmd == 'L') { user->CommandFloodPenalty += ListPenalty; const IRCv3::Monitor::WatchedList& list = manager.GetWatched(user); ReplyBuilder out(user, RPL_MONLIST); for (const auto* entry : list) out.Add(entry->GetNick()); out.Flush(); user->WriteNumeric(RPL_ENDOFMONLIST, "End of MONITOR list"); } else if (subcmd == 'S') { user->CommandFloodPenalty += ListPenalty; ReplyBuilder online(user, RPL_MONONLINE); ReplyBuilder offline(user, RPL_MONOFFLINE); for (const auto* entry : manager.GetWatched(user)) { ReplyBuilder& out = (ServerInstance->Users.FindNick(entry->GetNick(), true) ? online : offline); out.Add(entry->GetNick()); } online.Flush(); offline.Flush(); } else return CmdResult::FAILURE; return CmdResult::SUCCESS; } }; class ModuleMonitor final : public Module , public ISupport::EventListener , public Monitor::APIBase { private: IRCv3::Monitor::Manager manager; CommandMonitor cmd; Cap::Capability extendedcap; void SendAlert(unsigned int numeric, const std::string& nick) { const IRCv3::Monitor::WatcherList* list = manager.GetWatcherList(nick); if (!list) return; for (const auto& curr : *list) curr->WriteNumeric(numeric, nick); } public: ModuleMonitor() : Module(VF_VENDOR, "Adds the /MONITOR command which allows users to find out when their friends are connected to the server.") , ISupport::EventListener(this) , Monitor::APIBase(this) , manager(this, "monitor") , cmd(this, manager) , extendedcap(this, "extended-monitor") { } void ReadConfig(ConfigStatus& status) override { const auto& tag = ServerInstance->Config->ConfValue("monitor"); cmd.maxmonitor = tag->getNum<unsigned long>("maxentries", 30, 1); } void OnPostConnect(User* user) override { SendAlert(RPL_MONONLINE, user->nick); } void OnUserPostNick(User* user, const std::string& oldnick) override { // Detect and ignore nickname case change if (ServerInstance->Users.FindNick(oldnick) == user) return; SendAlert(RPL_MONOFFLINE, oldnick); SendAlert(RPL_MONONLINE, user->nick); } void OnUserQuit(User* user, const std::string& message, const std::string& oper_message) override { LocalUser* localuser = IS_LOCAL(user); if (localuser) manager.UnwatchAll(localuser); SendAlert(RPL_MONOFFLINE, user->nick); } void OnBuildISupport(ISupport::TokenMap& tokens) override { tokens["MONITOR"] = ConvToStr(cmd.maxmonitor); } void ForEachWatcher(User* user, Monitor::ForEachHandler& handler, bool extended_only) override { const IRCv3::Monitor::WatcherList* list = manager.GetWatcherList(user->nick); if (!list) return; for (IRCv3::Monitor::WatcherList::const_iterator i = list->begin(); i != list->end(); ++i) { LocalUser* curr = *i; if (!extended_only || extendedcap.IsEnabled(curr)) handler.Execute(curr); } } }; MODULE_INIT(ModuleMonitor) #endif ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/src/modules/m_multiprefix.cpp��������������������������������������������������������0000664�0000000�0000000�00000007145�14771603147�0021205�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2019 linuxdaemon <linuxdaemon.irc@gmail.com> * Copyright (C) 2013, 2018-2023 Sadie Powell <sadie@witchery.services> * Copyright (C) 2012-2015 Attila Molnar <attilamolnar@hush.com> * Copyright (C) 2012 Robby <robby@chatbelgie.be> * Copyright (C) 2009-2010 Daniel De Graaf <danieldg@inspircd.org> * Copyright (C) 2006 Craig Edwards <brain@inspircd.org> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include "inspircd.h" #include "modules/cap.h" #include "modules/names.h" #include "modules/who.h" #include "modules/whois.h" class ModuleMultiPrefix final : public Module , public Names::EventListener , public Who::EventListener , public Whois::LineEventListener { private: Cap::Capability cap; public: ModuleMultiPrefix() : Module(VF_VENDOR, "Provides the IRCv3 multi-prefix client capability.") , Names::EventListener(this) , Who::EventListener(this) , Whois::LineEventListener(this) , cap(this, "multi-prefix") { } ModResult OnNamesListItem(LocalUser* issuer, Membership* memb, std::string& prefixes, std::string& nick) override { if (cap.IsEnabled(issuer)) prefixes = memb->GetAllPrefixChars(); return MOD_RES_PASSTHRU; } ModResult OnWhoLine(const Who::Request& request, LocalUser* source, User* user, Membership* memb, Numeric::Numeric& numeric) override { if ((!memb) || (!cap.IsEnabled(source))) return MOD_RES_PASSTHRU; // Don't do anything if the user has only one prefix if (memb->modes.size() <= 1) return MOD_RES_PASSTHRU; size_t flag_index; if (!request.GetFieldIndex('f', flag_index)) return MOD_RES_PASSTHRU; if (numeric.GetParams().size() <= flag_index) return MOD_RES_PASSTHRU; numeric.GetParams()[flag_index].append(memb->GetAllPrefixChars(), 1, std::string::npos); return MOD_RES_PASSTHRU; } ModResult OnWhoisLine(Whois::Context& whois, Numeric::Numeric& numeric) override { if (numeric.GetNumeric() != RPL_WHOISCHANNELS || !cap.IsEnabled(whois.GetSource())) return MOD_RES_PASSTHRU; // :testnet.inspircd.org 319 test Sadie :#test ~#inspircd if (numeric.GetParams().size() < 2 || numeric.GetParams().back().empty()) return MOD_RES_PASSTHRU; std::stringstream newchannels; irc::spacesepstream channelstream(numeric.GetParams().back()); for (std::string channel; channelstream.GetToken(channel); ) { size_t hashpos = channel.find('#'); if (!hashpos || hashpos == std::string::npos) { // The entry is malformed or the user has no privs. newchannels << channel << ' '; continue; } auto* chan = ServerInstance->Channels.Find(channel.substr(hashpos)); if (!chan) { // Should never happen. newchannels << channel << ' '; continue; } Membership* memb = chan->GetUser(whois.GetTarget()); if (!memb) { // Should never happen. newchannels << channel << ' '; continue; } newchannels << memb->GetAllPrefixChars() << chan->name << ' '; } numeric.GetParams().back() = newchannels.str(); return MOD_RES_PASSTHRU; } }; MODULE_INIT(ModuleMultiPrefix) ���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/src/modules/m_muteban.cpp������������������������������������������������������������0000664�0000000�0000000�00000006042�14771603147�0020263�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2017, 2019-2024 Sadie Powell <sadie@witchery.services> * Copyright (C) 2012, 2018 Robby <robby@chatbelgie.be> * Copyright (C) 2009 Daniel De Graaf <danieldg@inspircd.org> * Copyright (C) 2008 Robin Burchell <robin+git@viroteck.net> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include "inspircd.h" #include "clientprotocolevent.h" #include "modules/ctctags.h" #include "modules/extban.h" #include "numerichelper.h" class ModuleQuietBan final : public Module , public CTCTags::EventListener { private: ExtBan::Acting extban; bool notifyuser; public: ModuleQuietBan() : Module(VF_VENDOR | VF_OPTCOMMON, "Adds extended ban m: (mute) which bans specific masks from speaking in a channel.") , CTCTags::EventListener(this) , extban(this, "mute", 'm') { } void ReadConfig(ConfigStatus& status) override { const auto& tag = ServerInstance->Config->ConfValue("muteban"); notifyuser = tag->getBool("notifyuser", true); } ModResult HandleMessage(User* user, const MessageTarget& target, bool& echo_original) { if (!IS_LOCAL(user) || target.type != MessageTarget::TYPE_CHANNEL) return MOD_RES_PASSTHRU; auto* chan = target.Get<Channel>(); if (extban.GetStatus(user, chan) == MOD_RES_DENY && chan->GetPrefixValue(user) < VOICE_VALUE) { if (!notifyuser) { echo_original = true; return MOD_RES_DENY; } user->WriteNumeric(Numerics::CannotSendTo(chan, "messages", extban)); return MOD_RES_DENY; } return MOD_RES_PASSTHRU; } ModResult OnUserPreMessage(User* user, MessageTarget& target, MessageDetails& details) override { return HandleMessage(user, target, details.echo_original); } ModResult OnUserPreTagMessage(User* user, MessageTarget& target, CTCTags::TagMessageDetails& details) override { return HandleMessage(user, target, details.echo_original); } void OnUserPart(Membership* memb, std::string& partmessage, CUList& except_list) override { LocalUser* luser = IS_LOCAL(memb->user); if (!luser) return; if (extban.GetStatus(memb->user, memb->chan) != MOD_RES_DENY) return; if (!notifyuser) { // Send fake part const std::string oldreason = partmessage; ClientProtocol::Messages::Part partmsg(memb, oldreason); ClientProtocol::Event ev(ServerInstance->GetRFCEvents().part, partmsg); luser->Send(ev); // Don't send the user the changed message except_list.insert(luser); return; } partmessage.clear(); } }; MODULE_INIT(ModuleQuietBan) ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/src/modules/m_namedmodes.cpp���������������������������������������������������������0000664�0000000�0000000�00000012030�14771603147�0020736�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2021 Herman <GermanAizek@yandex.ru> * Copyright (C) 2018-2023 Sadie Powell <sadie@witchery.services> * Copyright (C) 2017 B00mX0r <b00mx0r@aureus.pw> * Copyright (C) 2013-2016 Attila Molnar <attilamolnar@hush.com> * Copyright (C) 2012 Robby <robby@chatbelgie.be> * Copyright (C) 2009-2010 Daniel De Graaf <danieldg@inspircd.org> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include "inspircd.h" #include "numericbuilder.h" #include "numerichelper.h" enum { // InspIRCd-specific. RPL_ENDOFPROPLIST = 960, RPL_PROPLIST = 961 }; static void DisplayList(LocalUser* user, Channel* channel) { Numeric::ParamBuilder<1> numeric(user, RPL_PROPLIST); numeric.AddStatic(channel->name); for (const auto& [_, mh] : ServerInstance->Modes.GetModes(MODETYPE_CHANNEL)) { if (!channel->IsModeSet(mh)) continue; numeric.Add("+" + mh->name); ParamModeBase* pm = mh->IsParameterMode(); if (pm) { if ((pm->IsParameterSecret()) && (!channel->HasUser(user)) && (!user->HasPrivPermission("channels/auspex"))) numeric.Add("<" + mh->name + ">"); else numeric.Add(channel->GetModeParameter(mh)); } } numeric.Flush(); user->WriteNumeric(RPL_ENDOFPROPLIST, channel->name, "End of mode list"); } class CommandProp final : public SplitCommand { public: CommandProp(Module* parent) : SplitCommand(parent, "PROP", 1) { syntax = { "<channel> [[(+|-)]<mode> [<value>]]" }; } CmdResult HandleLocal(LocalUser* src, const Params& parameters) override { Channel* const chan = ServerInstance->Channels.Find(parameters[0]); if (!chan) { src->WriteNumeric(Numerics::NoSuchChannel(parameters[0])); return CmdResult::FAILURE; } if (parameters.size() == 1) { DisplayList(src, chan); return CmdResult::SUCCESS; } unsigned int i = 1; Modes::ChangeList modes; while (i < parameters.size()) { std::string prop = parameters[i++]; if (prop.empty()) continue; bool plus = prop[0] != '-'; if (prop[0] == '+' || prop[0] == '-') prop.erase(prop.begin()); ModeHandler* mh = ServerInstance->Modes.FindMode(prop, MODETYPE_CHANNEL); if (mh) { if (mh->NeedsParam(plus)) { if (i != parameters.size()) modes.push(mh, plus, parameters[i++]); } else modes.push(mh, plus); } } ServerInstance->Modes.ProcessSingle(src, chan, nullptr, modes, ModeParser::MODE_CHECKACCESS); return CmdResult::SUCCESS; } }; class DummyZ final : public ModeHandler { public: DummyZ(Module* parent) : ModeHandler(parent, "namebase", 'Z', PARAM_ALWAYS, MODETYPE_CHANNEL) { list = true; } // Handle /MODE #chan Z void DisplayList(User* user, Channel* chan) override { LocalUser* luser = IS_LOCAL(user); if (luser) ::DisplayList(luser, chan); } }; class ModuleNamedModes final : public Module { private: CommandProp cmd; DummyZ dummyZ; public: ModuleNamedModes() : Module(VF_VENDOR, "Provides support for adding and removing modes via their long names.") , cmd(this) , dummyZ(this) { } void Prioritize() override { ServerInstance->Modules.SetPriority(this, I_OnPreMode, PRIORITY_FIRST); } ModResult OnPreMode(User* source, User* dest, Channel* channel, Modes::ChangeList& modes) override { if (!channel) return MOD_RES_PASSTHRU; Modes::ChangeList::List& list = modes.getlist(); for (Modes::ChangeList::List::iterator i = list.begin(); i != list.end(); ) { Modes::Change& curr = *i; // Replace all namebase (dummyZ) modes being changed with the actual // mode handler and parameter. The parameter format of the namebase mode is // <modename>[=<parameter>]. if (curr.mh == &dummyZ) { std::string name = curr.param; std::string value; std::string::size_type eq = name.find('='); if (eq != std::string::npos) { value.assign(name, eq + 1, std::string::npos); name.erase(eq); } ModeHandler* mh = ServerInstance->Modes.FindMode(name, MODETYPE_CHANNEL); if (!mh) { // Mode handler not found i = list.erase(i); continue; } curr.param.clear(); if (mh->NeedsParam(curr.adding)) { if (value.empty()) { // Mode needs a parameter but there wasn't one i = list.erase(i); continue; } // Change parameter to the text after the '=' curr.param = std::move(value); } // Put the actual ModeHandler in place of the namebase handler curr.mh = mh; } ++i; } return MOD_RES_PASSTHRU; } }; MODULE_INIT(ModuleNamedModes) ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/src/modules/m_nickflood.cpp����������������������������������������������������������0000664�0000000�0000000�00000012645�14771603147�0020606�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2021 Dominic Hamon * Copyright (C) 2016-2023, 2025 Sadie Powell <sadie@witchery.services> * Copyright (C) 2012, 2014 Attila Molnar <attilamolnar@hush.com> * Copyright (C) 2012 Robby <robby@chatbelgie.be> * Copyright (C) 2009 Daniel De Graaf <danieldg@inspircd.org> * Copyright (C) 2007-2009 Robin Burchell <robin+git@viroteck.net> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include "inspircd.h" #include "extension.h" #include "modules/exemption.h" #include "numerichelper.h" #include "timeutils.h" // The number of seconds nickname changing will be blocked for. static unsigned int duration; /** Holds settings and state associated with channel mode +F */ class nickfloodsettings final { public: unsigned int secs; unsigned int nicks; time_t reset; time_t unlocktime = 0; unsigned int counter = 0; nickfloodsettings(unsigned int b, unsigned int c) : secs(b) , nicks(c) { reset = ServerInstance->Time() + secs; } void addnick() { if (ServerInstance->Time() > reset) { counter = 1; reset = ServerInstance->Time() + secs; } else counter++; } bool shouldlock() const { return ((ServerInstance->Time() <= reset) && (counter == this->nicks)); } void clear() { counter = 0; } bool islocked() { if (ServerInstance->Time() > unlocktime) unlocktime = 0; return (unlocktime != 0); } void lock() { unlocktime = ServerInstance->Time() + duration; } }; /** Handles channel mode +F */ class NickFlood final : public ParamMode<NickFlood, SimpleExtItem<nickfloodsettings>> { public: NickFlood(Module* Creator) : ParamMode<NickFlood, SimpleExtItem<nickfloodsettings>>(Creator, "nickflood", 'F') { syntax = "<nick-changes>:<seconds>"; } bool OnSet(User* source, Channel* channel, std::string& parameter) override { std::string::size_type colon = parameter.find(':'); if ((colon == std::string::npos) || (parameter.find('-') != std::string::npos)) { source->WriteNumeric(Numerics::InvalidModeParameter(channel, this, parameter)); return false; } /* Set up the flood parameters for this channel */ unsigned int nnicks = ConvToNum<unsigned int>(parameter.substr(0, colon)); unsigned int nsecs = ConvToNum<unsigned int>(parameter.substr(colon+1)); if ((nnicks<1) || (nsecs<1)) { source->WriteNumeric(Numerics::InvalidModeParameter(channel, this, parameter)); return false; } ext.SetFwd(channel, nsecs, nnicks); return true; } void SerializeParam(Channel* chan, const nickfloodsettings* nfs, std::string& out) { out.append(ConvToStr(nfs->nicks)).push_back(':'); out.append(ConvToStr(nfs->secs)); } }; class ModuleNickFlood final : public Module { private: CheckExemption::EventProvider exemptionprov; NickFlood nf; public: ModuleNickFlood() : Module(VF_VENDOR, "Adds channel mode F (nickflood) which helps protect against spammers which mass-change nicknames.") , exemptionprov(this) , nf(this) { } void ReadConfig(ConfigStatus&) override { const auto& tag = ServerInstance->Config->ConfValue("nickflood"); duration = static_cast<unsigned int>(tag->getDuration("duration", 60, 10, 600)); } ModResult OnUserPreNick(LocalUser* user, const std::string& newnick) override { for (const auto* memb : user->chans) { nickfloodsettings* f = nf.ext.Get(memb->chan); if (f) { ModResult res = exemptionprov.Check(user, memb->chan, "nickflood"); if (res == MOD_RES_ALLOW) continue; if (f->islocked()) { user->WriteNumeric(ERR_CANTCHANGENICK, INSP_FORMAT("{} has been locked for nick changes for {} because there have been more than {} nick changes in {}", memb->chan->name, Duration::ToLongString(duration), f->nicks, Duration::ToLongString(f->secs))); return MOD_RES_DENY; } if (f->shouldlock()) { f->clear(); f->lock(); memb->chan->WriteNotice(INSP_FORMAT("No nick changes are allowed for {} because there have been more than {} nick changes in {}.", Duration::ToLongString(duration), f->nicks, Duration::ToLongString(f->secs))); return MOD_RES_DENY; } } } return MOD_RES_PASSTHRU; } /* * XXX: HACK: We do the increment on the *POST* event here (instead of all together) because we have no way of knowing whether other modules would block a nickchange. */ void OnUserPostNick(User* user, const std::string& oldnick) override { if (isdigit(user->nick[0])) /* allow switches to UID */ return; for (const auto* memb : user->chans) { nickfloodsettings* f = nf.ext.Get(memb->chan); if (f) { ModResult res = exemptionprov.Check(user, memb->chan, "nickflood"); if (res == MOD_RES_ALLOW) return; /* moved this here to avoid incrementing the counter for nick * changes that are denied for some other reason (bans, +N, etc.) * per bug #874. */ f->addnick(); } } } }; MODULE_INIT(ModuleNickFlood) �������������������������������������������������������������������������������������������inspircd-4.7.0/src/modules/m_nicklock.cpp�����������������������������������������������������������0000664�0000000�0000000�00000011456�14771603147�0020432�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2013, 2017, 2019-2023 Sadie Powell <sadie@witchery.services> * Copyright (C) 2012, 2014-2016 Attila Molnar <attilamolnar@hush.com> * Copyright (C) 2012 Robby <robby@chatbelgie.be> * Copyright (C) 2009-2010 Daniel De Graaf <danieldg@inspircd.org> * Copyright (C) 2009 Robin Burchell <robin+git@viroteck.net> * Copyright (C) 2009 Dennis Friis <peavey@inspircd.org> * Copyright (C) 2006, 2008 Craig Edwards <brain@inspircd.org> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include "inspircd.h" #include "extension.h" #include "numerichelper.h" enum { // InspIRCd-specific. ERR_NICKNOTLOCKED = 946, RPL_NICKLOCKON = 947, RPL_NICKLOCKOFF = 945 }; class CommandNicklock final : public Command { public: BoolExtItem& locked; CommandNicklock (Module* Creator, BoolExtItem& ext) : Command(Creator, "NICKLOCK", 2) , locked(ext) { access_needed = CmdAccess::OPERATOR; syntax = { "<nick> <newnick>" }; translation = { TR_NICK, TR_TEXT }; } CmdResult Handle(User* user, const Params& parameters) override { auto* target = ServerInstance->Users.Find(parameters[0], true); if (!target) { user->WriteNumeric(Numerics::NoSuchNick(parameters[0])); return CmdResult::FAILURE; } /* Do local sanity checks and bails */ if (IS_LOCAL(user)) { if (!ServerInstance->IsNick(parameters[1])) { user->WriteNotice("*** Invalid nickname '" + parameters[1] + "'"); return CmdResult::FAILURE; } user->WriteNumeric(RPL_NICKLOCKON, parameters[1], "Nickname now locked."); } /* If we made it this far, extend the user */ if (IS_LOCAL(target)) { locked.Set(target); std::string oldnick = target->nick; if (target->ChangeNick(parameters[1])) ServerInstance->SNO.WriteGlobalSno('a', user->nick+" used NICKLOCK to change and hold "+oldnick+" to "+parameters[1]); else { std::string newnick = target->nick; ServerInstance->SNO.WriteGlobalSno('a', user->nick+" used NICKLOCK, but "+oldnick+" failed nick change to "+parameters[1]+" and was locked to "+newnick+" instead"); } } return CmdResult::SUCCESS; } RouteDescriptor GetRouting(User* user, const Params& parameters) override { return ROUTE_OPT_UCAST(parameters[0]); } }; class CommandNickunlock final : public Command { public: BoolExtItem& locked; CommandNickunlock (Module* Creator, BoolExtItem& ext) : Command(Creator, "NICKUNLOCK", 1) , locked(ext) { access_needed = CmdAccess::OPERATOR; syntax = { "<nick>" }; translation = { TR_NICK }; } CmdResult Handle(User* user, const Params& parameters) override { auto* target = ServerInstance->Users.Find(parameters[0]); if (!target) { user->WriteNumeric(Numerics::NoSuchNick(parameters[0])); return CmdResult::FAILURE; } if (IS_LOCAL(target)) { if (locked.Get(target)) { locked.Unset(target); ServerInstance->SNO.WriteGlobalSno('a', user->nick+" used NICKUNLOCK on "+target->nick); user->WriteRemoteNumeric(RPL_NICKLOCKOFF, target->nick, "Nickname now unlocked."); } else { user->WriteRemoteNumeric(ERR_NICKNOTLOCKED, target->nick, "This user's nickname is not locked."); return CmdResult::FAILURE; } } return CmdResult::SUCCESS; } RouteDescriptor GetRouting(User* user, const Params& parameters) override { return ROUTE_OPT_UCAST(parameters[0]); } }; class ModuleNickLock final : public Module { private: BoolExtItem locked; CommandNicklock cmd1; CommandNickunlock cmd2; public: ModuleNickLock() : Module(VF_VENDOR | VF_OPTCOMMON, "Adds the /NICKLOCK command which allows server operators to change a user's nickname and prevent them from changing it again until they disconnect.") , locked(this, "nick-locked", ExtensionType::USER) , cmd1(this, locked) , cmd2(this, locked) { } ModResult OnUserPreNick(LocalUser* user, const std::string& newnick) override { if (locked.Get(user)) { user->WriteNumeric(ERR_CANTCHANGENICK, "You cannot change your nickname (your nick is locked)"); return MOD_RES_DENY; } return MOD_RES_PASSTHRU; } void Prioritize() override { Module* nflood = ServerInstance->Modules.Find("nickflood"); ServerInstance->Modules.SetPriority(this, I_OnUserPreNick, PRIORITY_BEFORE, nflood); } }; MODULE_INIT(ModuleNickLock) ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/src/modules/m_noctcp.cpp�������������������������������������������������������������0000664�0000000�0000000�00000007234�14771603147�0020122�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2019 linuxdaemon <linuxdaemon.irc@gmail.com> * Copyright (C) 2019 Matt Schatz <genius3000@g3k.solutions> * Copyright (C) 2017-2024 Sadie Powell <sadie@witchery.services> * Copyright (C) 2012, 2019 Robby <robby@chatbelgie.be> * Copyright (C) 2012 Attila Molnar <attilamolnar@hush.com> * Copyright (C) 2009 Daniel De Graaf <danieldg@inspircd.org> * Copyright (C) 2006 Craig Edwards <brain@inspircd.org> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include "inspircd.h" #include "modules/callerid.h" #include "modules/exemption.h" #include "modules/extban.h" #include "numerichelper.h" class ModuleNoCTCP final : public Module { private: CallerID::API calleridapi; CheckExemption::EventProvider exemptionprov; ExtBan::Acting extban; SimpleChannelMode nc; SimpleUserMode ncu; public: ModuleNoCTCP() : Module(VF_VENDOR, "Adds channel mode C (noctcp) which allows channels to block messages which contain CTCPs and user mode T (u_noctcp) which allows users to block private messages that contain CTCPs.") , calleridapi(this) , exemptionprov(this) , extban(this, "noctcp", 'C') , nc(this, "noctcp", 'C') , ncu(this, "u_noctcp", 'T') { } ModResult OnUserPreMessage(User* user, MessageTarget& target, MessageDetails& details) override { if (!IS_LOCAL(user)) return MOD_RES_PASSTHRU; std::string_view ctcpname; if (!details.IsCTCP(ctcpname) || irc::equals(ctcpname, "ACTION")) return MOD_RES_PASSTHRU; switch (target.type) { case MessageTarget::TYPE_CHANNEL: { if (user->HasPrivPermission("channels/ignore-noctcp")) return MOD_RES_PASSTHRU; auto* c = target.Get<Channel>(); for (const auto& [u, _] : c->GetUsers()) { if (u->IsModeSet(ncu)) details.exemptions.insert(u); } ModResult res = exemptionprov.Check(user, c, "noctcp"); if (res == MOD_RES_ALLOW) return MOD_RES_PASSTHRU; if (c->IsModeSet(nc)) { user->WriteNumeric(Numerics::CannotSendTo(c, "CTCPs", &nc)); return MOD_RES_DENY; } if (extban.GetStatus(user, c) == MOD_RES_DENY) { user->WriteNumeric(Numerics::CannotSendTo(c, "CTCPs", extban)); return MOD_RES_DENY; } break; } case MessageTarget::TYPE_USER: { auto* targetuser = target.Get<User>(); if (user->HasPrivPermission("users/ignore-noctcp")) return MOD_RES_PASSTHRU; if (calleridapi && calleridapi->IsOnAcceptList(user, targetuser)) return MOD_RES_PASSTHRU; if (targetuser->IsModeSet(ncu)) { // Don't send an error message if we're blocking an automatic CTCP reply. if (details.type == MessageType::NOTICE) user->WriteNumeric(Numerics::CannotSendTo(targetuser, "CTCPs", &ncu)); return MOD_RES_DENY; } break; } case MessageTarget::TYPE_SERVER: { if (user->HasPrivPermission("users/ignore-noctcp")) return MOD_RES_PASSTHRU; for (auto* u : ServerInstance->Users.GetLocalUsers()) { if (u->IsModeSet(ncu)) details.exemptions.insert(u); } break; } } return MOD_RES_PASSTHRU; } }; MODULE_INIT(ModuleNoCTCP) ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/src/modules/m_nokicks.cpp������������������������������������������������������������0000664�0000000�0000000�00000004001�14771603147�0020262�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2019-2021, 2023-2024 Sadie Powell <sadie@witchery.services> * Copyright (C) 2019 Matt Schatz <genius3000@g3k.solutions> * Copyright (C) 2012 Robby <robby@chatbelgie.be> * Copyright (C) 2012 Attila Molnar <attilamolnar@hush.com> * Copyright (C) 2009-2010 Daniel De Graaf <danieldg@inspircd.org> * Copyright (C) 2009 Uli Schlachter <psychon@znc.in> * Copyright (C) 2006 Craig Edwards <brain@inspircd.org> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include "inspircd.h" #include "modules/extban.h" class ModuleNoKicks final : public Module { private: ExtBan::Acting extban; SimpleChannelMode nk; public: ModuleNoKicks() : Module(VF_VENDOR, "Adds channel mode Q (nokick) which prevents privileged users from using the /KICK command.") , extban(this, "nokick", 'Q') , nk(this, "nokick", 'Q') { } ModResult OnUserPreKick(User* source, Membership* memb, const std::string& reason) override { bool modeset = memb->chan->IsModeSet(nk); if (!extban.GetStatus(source, memb->chan).check(!modeset)) { // Can't kick with Q in place, not even opers with override, and founders source->WriteNumeric(ERR_RESTRICTED, memb->chan->name, INSP_FORMAT("Can't kick user {} from channel ({})", memb->user->nick, modeset ? INSP_FORMAT("+{} is set", nk.GetModeChar()) : "you're extbanned")); return MOD_RES_DENY; } return MOD_RES_PASSTHRU; } }; MODULE_INIT(ModuleNoKicks) �������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/src/modules/m_nonicks.cpp������������������������������������������������������������0000664�0000000�0000000�00000004320�14771603147�0020271�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2017-2021, 2023, 2025 Sadie Powell <sadie@witchery.services> * Copyright (C) 2012 Robby <robby@chatbelgie.be> * Copyright (C) 2012 Attila Molnar <attilamolnar@hush.com> * Copyright (C) 2009-2010 Daniel De Graaf <danieldg@inspircd.org> * Copyright (C) 2008 Robin Burchell <robin+git@viroteck.net> * Copyright (C) 2004 Craig Edwards <brain@inspircd.org> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include "inspircd.h" #include "modules/exemption.h" #include "modules/extban.h" class ModuleNoNickChange final : public Module { private: CheckExemption::EventProvider exemptionprov; ExtBan::Acting extban; SimpleChannelMode nn; public: ModuleNoNickChange() : Module(VF_VENDOR, "Adds channel mode N (nonick) which prevents users from changing their nickname whilst in the channel.") , exemptionprov(this) , extban(this, "nonick", 'N') , nn(this, "nonick", 'N') { } ModResult OnUserPreNick(LocalUser* user, const std::string& newnick) override { for (const auto* memb : user->chans) { ModResult res = exemptionprov.Check(user, memb->chan, "nonick"); if (res == MOD_RES_ALLOW) continue; if (user->HasPrivPermission("channels/ignore-nonicks")) continue; bool modeset = memb->chan->IsModeSet(nn); if (!extban.GetStatus(user, memb->chan).check(!modeset)) { user->WriteNumeric(ERR_CANTCHANGENICK, INSP_FORMAT("Can't change nickname while on {} ({})", memb->chan->name, modeset ? INSP_FORMAT("+{} is set", nn.GetModeChar()) : "you're extbanned")); return MOD_RES_DENY; } } return MOD_RES_PASSTHRU; } }; MODULE_INIT(ModuleNoNickChange) ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/src/modules/m_nonotice.cpp�����������������������������������������������������������0000664�0000000�0000000�00000004237�14771603147�0020452�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2017, 2020-2024 Sadie Powell <sadie@witchery.services> * Copyright (C) 2012 Robby <robby@chatbelgie.be> * Copyright (C) 2012 Attila Molnar <attilamolnar@hush.com> * Copyright (C) 2009 Daniel De Graaf <danieldg@inspircd.org> * Copyright (C) 2006 Craig Edwards <brain@inspircd.org> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include "inspircd.h" #include "modules/exemption.h" #include "modules/extban.h" #include "numerichelper.h" class ModuleNoNotice final : public Module { private: ExtBan::Acting extban; CheckExemption::EventProvider exemptionprov; SimpleChannelMode nt; public: ModuleNoNotice() : Module(VF_VENDOR, "Adds channel mode T (nonotice) which allows channels to block messages sent with the /NOTICE command.") , extban(this, "nonotice", 'T') , exemptionprov(this) , nt(this, "nonotice", 'T') { } ModResult OnUserPreMessage(User* user, MessageTarget& target, MessageDetails& details) override { if ((details.type == MessageType::NOTICE) && (target.type == MessageTarget::TYPE_CHANNEL) && (IS_LOCAL(user))) { auto* c = target.Get<Channel>(); ModResult res = exemptionprov.Check(user, c, "nonotice"); if (res == MOD_RES_ALLOW) return MOD_RES_PASSTHRU; if (c->IsModeSet(nt)) { user->WriteNumeric(Numerics::CannotSendTo(c, "notices", &nt)); return MOD_RES_DENY; } if (extban.GetStatus(user, c) == MOD_RES_DENY) { user->WriteNumeric(Numerics::CannotSendTo(c, "notices", extban)); return MOD_RES_DENY; } } return MOD_RES_PASSTHRU; } }; MODULE_INIT(ModuleNoNotice) �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/src/modules/m_ojoin.cpp��������������������������������������������������������������0000664�0000000�0000000�00000011174�14771603147�0017750�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2019-2024 Sadie Powell <sadie@witchery.services> * Copyright (C) 2013-2014, 2016 Attila Molnar <attilamolnar@hush.com> * Copyright (C) 2010 Craig Edwards <brain@inspircd.org> * Copyright (C) 2009-2010 Daniel De Graaf <danieldg@inspircd.org> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include "inspircd.h" #define NETWORK_VALUE 9000000 class CommandOjoin final : public SplitCommand { public: bool active; bool notice; bool op; ModeHandler* npmh; ChanModeReference opmode; CommandOjoin(Module* parent, ModeHandler& mode) : SplitCommand(parent, "OJOIN", 1) , npmh(&mode) , opmode(parent, "op") { access_needed = CmdAccess::OPERATOR; syntax = { "<channel>" }; active = false; } CmdResult HandleLocal(LocalUser* user, const Params& parameters) override { // Make sure the channel name is allowable. if (!ServerInstance->Channels.IsChannel(parameters[0])) { user->WriteNumeric(ERR_BADCHANMASK, parameters[0], "Invalid channel name"); return CmdResult::FAILURE; } active = true; // override is false because we want OnUserPreJoin to run Membership* memb = Channel::JoinUser(user, parameters[0], false); active = false; if (memb) { ServerInstance->SNO.WriteGlobalSno('a', user->nick+" used OJOIN to join "+memb->chan->name); if (notice) memb->chan->WriteRemoteNotice(user->nick + " joined on official network business."); } else { Channel* channel = ServerInstance->Channels.Find(parameters[0]); if (!channel) return CmdResult::FAILURE; ServerInstance->SNO.WriteGlobalSno('a', user->nick+" used OJOIN in "+parameters[0]); // they're already in the channel Modes::ChangeList changelist; changelist.push_add(npmh, user->nick); if (op && opmode) changelist.push_add(*opmode, user->nick); ServerInstance->Modes.Process(ServerInstance->FakeClient, channel, nullptr, changelist); } return CmdResult::SUCCESS; } }; /** channel mode +Y */ class NetworkPrefix final : public PrefixMode { public: NetworkPrefix(Module* parent, char NPrefix) : PrefixMode(parent, "official-join", 'Y', NETWORK_VALUE, NPrefix) { ranktoset = ranktounset = std::numeric_limits<ModeHandler::Rank>::max(); } ModResult AccessCheck(User* source, Channel* channel, Modes::Change& change) override { auto* theuser = ServerInstance->Users.Find(change.param); // remove own privs? if (source == theuser && !change.adding) return MOD_RES_ALLOW; return MOD_RES_PASSTHRU; } }; class ModuleOjoin final : public Module { private: NetworkPrefix np; CommandOjoin mycommand; public: ModuleOjoin() : Module(VF_VENDOR, "Adds the /OJOIN command which allows server operators to join a channel and receive the server operator-only Y (official-join) channel prefix mode.") , np(this, ServerInstance->Config->ConfValue("ojoin")->getCharacter("prefix", '\0', true)) , mycommand(this, np) { } ModResult OnUserPreJoin(LocalUser* user, Channel* chan, const std::string& cname, std::string& privs, const std::string& keygiven, bool override) override { if (mycommand.active) { privs += np.GetModeChar(); if (mycommand.op && mycommand.opmode) privs += mycommand.opmode->IsPrefixMode()->GetPrefix(); return MOD_RES_ALLOW; } return MOD_RES_PASSTHRU; } void ReadConfig(ConfigStatus& status) override { const auto& Conf = ServerInstance->Config->ConfValue("ojoin"); mycommand.notice = Conf->getBool("notice", true); mycommand.op = Conf->getBool("op", true); } ModResult OnUserPreKick(User* source, Membership* memb, const std::string& reason) override { // Don't do anything if they're not +Y if (!memb->HasMode(&np)) return MOD_RES_PASSTHRU; // Let them do whatever they want to themselves. if (source == memb->user) return MOD_RES_PASSTHRU; source->WriteNumeric(ERR_RESTRICTED, memb->chan->name, "Can't kick "+memb->user->nick+" as they're on official network business."); return MOD_RES_DENY; } void Prioritize() override { ServerInstance->Modules.SetPriority(this, I_OnUserPreJoin, PRIORITY_FIRST); } }; MODULE_INIT(ModuleOjoin) ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/src/modules/m_operchans.cpp����������������������������������������������������������0000664�0000000�0000000�00000006074�14771603147�0020617�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2018-2023 Sadie Powell <sadie@witchery.services> * Copyright (C) 2012 Robby <robby@chatbelgie.be> * Copyright (C) 2012 Attila Molnar <attilamolnar@hush.com> * Copyright (C) 2009-2010 Daniel De Graaf <danieldg@inspircd.org> * Copyright (C) 2009 Uli Schlachter <psychon@znc.in> * Copyright (C) 2006 Craig Edwards <brain@inspircd.org> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include "inspircd.h" #include "modules/extban.h" enum { // From UnrealIRCd. ERR_CANTJOINOPERSONLY = 520 }; class OperAccountExtBan final : public ExtBan::MatchingBase { public: OperAccountExtBan(Module* Creator) : ExtBan::MatchingBase(Creator, "oper", 'o') { } bool IsMatch(User* user, Channel* channel, const std::string& text) override { // If the user is not an oper they can't match this. if (!user->IsOper()) return false; // Replace spaces with underscores as they're prohibited in mode parameters. std::string opername(user->oper->GetName()); std::replace(opername.begin(), opername.end(), ' ', '_'); return InspIRCd::Match(opername, text); } }; class OperTypeExtBan final : public ExtBan::MatchingBase { public: OperTypeExtBan(Module* Creator) : ExtBan::MatchingBase(Creator, "opertype", 'O') { } bool IsMatch(User* user, Channel* channel, const std::string& text) override { // If the user is not an oper they can't match this. if (!user->IsOper()) return false; // Replace spaces with underscores as they're prohibited in mode parameters. std::string opername(user->oper->GetType()); std::replace(opername.begin(), opername.end(), ' ', '_'); return InspIRCd::Match(opername, text); } }; class ModuleOperChans final : public Module { private: SimpleChannelMode oc; OperAccountExtBan operaccount; OperTypeExtBan opertype; public: ModuleOperChans() : Module(VF_VENDOR, "Adds channel mode O (operonly) which prevents non-server operators from joining the channel.") , oc(this, "operonly", 'O', true) , operaccount(this) , opertype(this) { } ModResult OnUserPreJoin(LocalUser* user, Channel* chan, const std::string& cname, std::string& privs, const std::string& keygiven, bool override) override { if (!override && chan && chan->IsModeSet(oc) && !user->IsOper()) { user->WriteNumeric(ERR_CANTJOINOPERSONLY, chan->name, INSP_FORMAT("Only server operators may join {} (+{} is set)", chan->name, oc.GetModeChar())); return MOD_RES_DENY; } return MOD_RES_PASSTHRU; } }; MODULE_INIT(ModuleOperChans) ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/src/modules/m_operjoin.cpp�����������������������������������������������������������0000664�0000000�0000000�00000004442�14771603147�0020457�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2019-2023 Sadie Powell <sadie@witchery.services> * Copyright (C) 2012-2014 Attila Molnar <attilamolnar@hush.com> * Copyright (C) 2012 Robby <robby@chatbelgie.be> * Copyright (C) 2009 Daniel De Graaf <danieldg@inspircd.org> * Copyright (C) 2008 Thomas Stagner <aquanight@gmail.com> * Copyright (C) 2007-2008 Dennis Friis <peavey@inspircd.org> * Copyright (C) 2006-2007 Craig Edwards <brain@inspircd.org> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include "inspircd.h" class ModuleOperjoin final : public Module { private: std::vector<std::string> operChans; bool override; public: ModuleOperjoin() : Module(VF_VENDOR, "Allows the server administrator to force server operators to join one or more channels when logging into their server operator account.") { } void ReadConfig(ConfigStatus& status) override { const auto& tag = ServerInstance->Config->ConfValue("operjoin"); override = tag->getBool("override", false); irc::commasepstream ss(tag->getString("channel")); operChans.clear(); for (std::string channame; ss.GetToken(channame); ) operChans.push_back(channame); } void OnPostOperLogin(User* user, bool automatic) override { LocalUser* localuser = IS_LOCAL(user); if (!localuser) return; for (const auto& operchan : operChans) { if (ServerInstance->Channels.IsChannel(operchan)) Channel::JoinUser(localuser, operchan, override); } irc::commasepstream ss(localuser->oper->GetConfig()->getString("autojoin")); for (std::string channame; ss.GetToken(channame); ) { if (ServerInstance->Channels.IsChannel(channame)) Channel::JoinUser(localuser, channame, override); } } }; MODULE_INIT(ModuleOperjoin) ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/src/modules/m_operlevels.cpp���������������������������������������������������������0000664�0000000�0000000�00000004542�14771603147�0021013�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2018-2021, 2023 Sadie Powell <sadie@witchery.services> * Copyright (C) 2012-2013 Attila Molnar <attilamolnar@hush.com> * Copyright (C) 2012, 2019 Robby <robby@chatbelgie.be> * Copyright (C) 2009 Thomas Stagner <aquanight@gmail.com> * Copyright (C) 2009 Daniel De Graaf <danieldg@inspircd.org> * Copyright (C) 2007-2008 Robin Burchell <robin+git@viroteck.net> * Copyright (C) 2007 Dennis Friis <peavey@inspircd.org> * Copyright (C) 2005-2006 Craig Edwards <brain@inspircd.org> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include "inspircd.h" class ModuleOperLevels final : public Module { public: ModuleOperLevels() : Module(VF_VENDOR, "Allows the server administrator to define ranks for server operators which prevent lower ranked server operators from using /KILL on higher ranked server operators.") { } ModResult OnKill(User* source, User* dest, const std::string &reason) override { // oper killing an oper? if (dest->IsOper() && source->IsOper()) { unsigned long dest_level = dest->oper->GetConfig()->getNum<unsigned long>("level", 0); unsigned long source_level = source->oper->GetConfig()->getNum<unsigned long>("level", 0); if (dest_level > source_level) { if (IS_LOCAL(source)) { ServerInstance->SNO.WriteGlobalSno('a', "Oper {} (level {}) attempted to /KILL a higher level oper: {} (level {}), reason: {}", source->nick, source_level, dest->nick, dest_level, reason); } dest->WriteNotice("*** Oper " + source->nick + " attempted to /KILL you!"); source->WriteNumeric(ERR_NOPRIVILEGES, INSP_FORMAT("Permission Denied - Oper {} is a higher level than you", dest->nick)); return MOD_RES_DENY; } } return MOD_RES_PASSTHRU; } }; MODULE_INIT(ModuleOperLevels) ��������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/src/modules/m_operlog.cpp������������������������������������������������������������0000664�0000000�0000000�00000004240�14771603147�0020275�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2019-2023 Sadie Powell <sadie@witchery.services> * Copyright (C) 2012, 2014 Attila Molnar <attilamolnar@hush.com> * Copyright (C) 2012 Robby <robby@chatbelgie.be> * Copyright (C) 2009-2010 Daniel De Graaf <danieldg@inspircd.org> * Copyright (C) 2006 Craig Edwards <brain@inspircd.org> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include "inspircd.h" #include "modules/isupport.h" #include "utility/string.h" class ModuleOperLog final : public Module { private: bool tosnomask; public: ModuleOperLog() : Module(VF_VENDOR, "Allows the server administrator to make the server log when a server operator-only command is executed.") { } void ReadConfig(ConfigStatus& status) override { tosnomask = ServerInstance->Config->ConfValue("operlog")->getBool("tosnomask", false); } ModResult OnPreCommand(std::string& command, CommandBase::Params& parameters, LocalUser* user, bool validated) override { /* If the command doesnt appear to be valid, we dont want to mess with it. */ if (!validated) return MOD_RES_PASSTHRU; if ((user->IsOper()) && (user->HasCommandPermission(command))) { Command* thiscommand = ServerInstance->Parser.GetHandler(command); if ((thiscommand) && (thiscommand->access_needed == CmdAccess::OPERATOR)) { std::string msg = "[" + user->GetRealMask() + "] " + command + " " + insp::join(parameters); if (tosnomask) ServerInstance->SNO.WriteGlobalSno('o', msg); else ServerInstance->Logs.Normal(MODNAME, msg); } } return MOD_RES_PASSTHRU; } }; MODULE_INIT(ModuleOperLog) ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/src/modules/m_opermodes.cpp����������������������������������������������������������0000664�0000000�0000000�00000003462�14771603147�0020630�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2020-2022 Sadie Powell <sadie@witchery.services> * Copyright (C) 2012 Robby <robby@chatbelgie.be> * Copyright (C) 2012 Attila Molnar <attilamolnar@hush.com> * Copyright (C) 2007 Dennis Friis <peavey@inspircd.org> * Copyright (C) 2005 Craig Edwards <brain@inspircd.org> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include "inspircd.h" class ModuleOperModes final : public Module { public: ModuleOperModes() : Module(VF_VENDOR, "Allows the server administrator to set user modes on server operators when they log into their server operator account.") { } void OnPostOperLogin(User* user, bool automatic) override { if (!IS_LOCAL(user)) return; // We don't handle remote users. const std::string opermodes = user->oper->GetConfig()->getString("modes"); if (opermodes.empty()) return; // We don't have any modes to set. CommandBase::Params modeparams; modeparams.push_back(user->nick); irc::spacesepstream modestream(opermodes); for (std::string modeparam; modestream.GetToken(modeparam); ) modeparams.push_back(modeparam); if (modeparams.size() > 1) ServerInstance->Parser.CallHandler("MODE", modeparams, user); } }; MODULE_INIT(ModuleOperModes) ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/src/modules/m_opermotd.cpp�����������������������������������������������������������0000664�0000000�0000000�00000011107�14771603147�0020457�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2013, 2019-2024 Sadie Powell <sadie@witchery.services> * Copyright (C) 2012, 2016 Attila Molnar <attilamolnar@hush.com> * Copyright (C) 2012 Robby <robby@chatbelgie.be> * Copyright (C) 2009 Uli Schlachter <psychon@znc.in> * Copyright (C) 2007, 2009 Dennis Friis <peavey@inspircd.org> * Copyright (C) 2006 Craig Edwards <brain@inspircd.org> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include "inspircd.h" enum { // From UnrealIRCd. ERR_NOOPERMOTD = 425, // From ircd-ratbox. RPL_OMOTDSTART = 720, RPL_OMOTD = 721, RPL_ENDOFOMOTD = 722 }; typedef insp::flat_map<std::string, std::vector<std::string>> MOTDCache; class CommandOperMOTD final : public Command { public: std::string file; MOTDCache motds; CommandOperMOTD(Module* Creator) : Command(Creator, "OPERMOTD") { access_needed = CmdAccess::OPERATOR; syntax = { "[<servername>]" }; } CmdResult Handle(User* user, const Params& parameters) override { if (parameters.empty() || irc::equals(parameters[0], ServerInstance->Config->ServerName)) return ShowOperMOTD(user, true); return CmdResult::SUCCESS; } RouteDescriptor GetRouting(User* user, const Params& parameters) override { if ((!parameters.empty()) && (parameters[0].find('.') != std::string::npos)) return ROUTE_OPT_UCAST(parameters[0]); return ROUTE_LOCALONLY; } CmdResult ShowOperMOTD(User* user, bool showmissing) { if (!user->IsOper()) return CmdResult::SUCCESS; // WTF? auto motd = motds.find(user->oper->GetConfig()->getString("motd", file, 1)); if (motd == motds.end()) { if (showmissing) user->WriteRemoteNumeric(ERR_NOOPERMOTD, "There is no server operator MOTD."); return CmdResult::SUCCESS; } user->WriteRemoteNumeric(RPL_OMOTDSTART, "Server operator MOTD:"); for (const auto& line : motd->second) user->WriteRemoteNumeric(RPL_OMOTD, line); user->WriteRemoteNumeric(RPL_ENDOFOMOTD, "End of server operator MOTD."); return CmdResult::SUCCESS; } }; class ModuleOperMOTD final : public Module { private: CommandOperMOTD cmd; bool onoper; void ProcessMOTD(MOTDCache& newmotds, const std::shared_ptr<OperType>& oper, const char* type) const { // Don't process the file if it has already been processed. const std::string motd = oper->GetConfig()->getString("motd", cmd.file); if (motd.empty() || newmotds.find(motd) != newmotds.end()) return; auto file = ServerInstance->Config->ReadFile(motd); if (!file) { // We can't process the file if it doesn't exist. ServerInstance->Logs.Normal(MODNAME, "Unable to read server operator motd for oper {} \"{}\" at {}: {}", type, oper->GetName(), oper->GetConfig()->source.str(), file.error); return; } // Process the MOTD entry. auto& newmotd = newmotds[motd]; irc::sepstream linestream(file.contents, '\n', true); for (std::string line; linestream.GetToken(line); ) { // Some clients can not handle receiving RPL_OMOTD with an empty // trailing parameter so if a line is empty we replace it with // a single space. InspIRCd::ProcessColors(line); newmotd.push_back(line.empty() ? " " : line); } } public: ModuleOperMOTD() : Module(VF_VENDOR | VF_OPTCOMMON, "Adds the /OPERMOTD command which adds a special message of the day for server operators.") , cmd(this) { } void OnPostOperLogin(User* user, bool automatic) override { if (IS_LOCAL(user) && user->oper->GetConfig()->getBool("automotd", onoper)) cmd.ShowOperMOTD(user, false); } void ReadConfig(ConfigStatus& status) override { // Compatibility with the v3 config. const auto& tag = ServerInstance->Config->ConfValue("opermotd"); cmd.file = tag->getString("file", "opermotd", 1); onoper = tag->getBool("onoper", true); MOTDCache newmotds; for (const auto& [_, account] : ServerInstance->Config->OperAccounts) ProcessMOTD(newmotds, account, "account"); for (const auto& [_, type] : ServerInstance->Config->OperTypes) ProcessMOTD(newmotds, type, "type"); cmd.motds.swap(newmotds); } }; MODULE_INIT(ModuleOperMOTD) ���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/src/modules/m_operprefix.cpp���������������������������������������������������������0000664�0000000�0000000�00000010430�14771603147�0021007�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2019-2022, 2024 Sadie Powell <sadie@witchery.services> * Copyright (C) 2012-2016 Attila Molnar <attilamolnar@hush.com> * Copyright (C) 2012 Robby <robby@chatbelgie.be> * Copyright (C) 2009-2010 Craig Edwards <brain@inspircd.org> * Copyright (C) 2009 Uli Schlachter <psychon@znc.in> * Copyright (C) 2009 Daniel De Graaf <danieldg@inspircd.org> * Copyright (C) 2008 Robin Burchell <robin+git@viroteck.net> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ /* * Originally by Chernov-Phoenix Alexey (Phoenix@RusNet) mailto:phoenix /email address separator/ pravmail.ru */ #include "inspircd.h" #define OPERPREFIX_VALUE 1000000 class OperPrefixMode final : public PrefixMode { public: OperPrefixMode(Module* Creator) : PrefixMode(Creator, "operprefix", 'y', OPERPREFIX_VALUE) { prefix = ServerInstance->Config->ConfValue("operprefix")->getCharacter("prefix", '!', true); ranktoset = ranktounset = std::numeric_limits<ModeHandler::Rank>::max(); } }; class ModuleOperPrefixMode; class HideOperWatcher final : public ModeWatcher { ModuleOperPrefixMode* parentmod; public: HideOperWatcher(ModuleOperPrefixMode* parent); void AfterMode(User* source, User* dest, Channel* channel, const Modes::Change& change) override; }; class ModuleOperPrefixMode final : public Module { private: OperPrefixMode opm; HideOperWatcher hideoperwatcher; UserModeReference hideopermode; public: ModuleOperPrefixMode() : Module(VF_VENDOR, "Adds the server operator-only y (operprefix) channel prefix mode.") , opm(this) , hideoperwatcher(this) , hideopermode(this, "hideoper") { /* To give clients a chance to learn about the new prefix we don't give +y to opers * right now. That means if the module was loaded after opers have joined channels * they need to rejoin them in order to get the oper prefix. */ } ModResult OnUserPreJoin(LocalUser* user, Channel* chan, const std::string& cname, std::string& privs, const std::string& keygiven, bool override) override { if ((user->IsOper()) && (!user->IsModeSet(hideopermode))) privs.push_back('y'); return MOD_RES_PASSTHRU; } void OnPostJoin(Membership* memb) override { if ((!IS_LOCAL(memb->user)) || (!memb->user->IsOper()) || (memb->user->IsModeSet(hideopermode))) return; if (memb->HasMode(&opm)) return; // The user was force joined and OnUserPreJoin() did not run. Set the operprefix now. Modes::ChangeList changelist; changelist.push_add(&opm, memb->user->nick); ServerInstance->Modes.Process(ServerInstance->FakeClient, memb->chan, nullptr, changelist); } void SetOperPrefix(User* user, bool add) { Modes::ChangeList changelist; changelist.push(&opm, add, user->nick); for (const auto* memb : user->chans) ServerInstance->Modes.Process(ServerInstance->FakeClient, memb->chan, nullptr, changelist); } void OnPostOperLogin(User* user, bool automatic) override { if (IS_LOCAL(user) && (!user->IsModeSet(hideopermode))) SetOperPrefix(user, true); } void Prioritize() override { // m_opermodes may set +H on the oper to hide him, we don't want to set the oper prefix in that case Module* opermodes = ServerInstance->Modules.Find("opermodes"); ServerInstance->Modules.SetPriority(this, I_OnPostOperLogin, PRIORITY_AFTER, opermodes); } }; HideOperWatcher::HideOperWatcher(ModuleOperPrefixMode* parent) : ModeWatcher(parent, "hideoper", MODETYPE_USER) , parentmod(parent) { } void HideOperWatcher::AfterMode(User* source, User* dest, Channel* channel, const Modes::Change& change) { // If hideoper is being unset because the user is deopering, don't set +y if (IS_LOCAL(dest) && dest->IsOper()) parentmod->SetOperPrefix(dest, !change.adding); } MODULE_INIT(ModuleOperPrefixMode) ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/src/modules/m_opmoderated.cpp��������������������������������������������������������0000664�0000000�0000000�00000005270�14771603147�0021135�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2021-2024 Sadie Powell <sadie@witchery.services> * Copyright (C) 2021 Daniel De Graaf <danieldg@inspircd.org> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include "inspircd.h" #include "modules/ctctags.h" #include "modules/exemption.h" #include "modules/extban.h" class ModuleOpModerated final : public Module , public CTCTags::EventListener { private: CheckExemption::EventProvider exemptionprov; ExtBan::Acting extban; SimpleChannelMode mode; ModResult HandleMessage(User* user, MessageTarget& target, CUList& exemptions) { // We only handle messages from local users. if (!IS_LOCAL(user)) return MOD_RES_PASSTHRU; // We only handle messages non-statusmsg messages sent to channels. if (target.type != MessageTarget::TYPE_CHANNEL || target.status) return MOD_RES_PASSTHRU; // Exempt opers who have the appropriate privileges. if (user->HasPrivPermission("channels/ignore-opmoderated")) return MOD_RES_PASSTHRU; // Exempt channel members who have the appropriate privileges. auto* chan = target.Get<Channel>(); if (chan->GetPrefixValue(user) > VOICE_VALUE) return MOD_RES_PASSTHRU; // Check for channel members who are exempted by a module. if (exemptionprov.Check(user, chan, "opmoderated") == MOD_RES_ALLOW) return MOD_RES_PASSTHRU; if (!extban.GetStatus(user, chan).check(!chan->IsModeSet(mode))) target.status = '@'; return MOD_RES_PASSTHRU; } public: ModuleOpModerated() : Module(VF_VENDOR | VF_OPTCOMMON, "Adds channel mode U (opmoderated) which hides the messages of unprivileged users from other unprivileged users.") , CTCTags::EventListener(this) , exemptionprov(this) , extban(this, "opmoderated", 'u') , mode(this, "opmoderated", 'U') { } ModResult OnUserPreMessage(User* user, MessageTarget& target, MessageDetails& details) override { return HandleMessage(user, target, details.exemptions); } ModResult OnUserPreTagMessage(User* user, MessageTarget& target, CTCTags::TagMessageDetails& details) override { return HandleMessage(user, target, details.exemptions); } }; MODULE_INIT(ModuleOpModerated) ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/src/modules/m_override.cpp�����������������������������������������������������������0000664�0000000�0000000�00000017660�14771603147�0020457�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2020 satmd <satmd@satmd.de> * Copyright (C) 2017 B00mX0r <b00mx0r@aureus.pw> * Copyright (C) 2013-2015 Attila Molnar <attilamolnar@hush.com> * Copyright (C) 2013, 2019-2024 Sadie Powell <sadie@witchery.services> * Copyright (C) 2013 Daniel Vassdal <shutter@canternet.org> * Copyright (C) 2012 Robby <robby@chatbelgie.be> * Copyright (C) 2009 Daniel De Graaf <danieldg@inspircd.org> * Copyright (C) 2008 Robin Burchell <robin+git@viroteck.net> * Copyright (C) 2008 Dennis Friis <peavey@inspircd.org> * Copyright (C) 2006, 2008 Craig Edwards <brain@inspircd.org> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include "inspircd.h" #include "extension.h" #include "modules/invite.h" #include "modules/isupport.h" class UnsetTimer final : public Timer { private: ModeHandler& overridemode; LocalUser* user; public: UnsetTimer(LocalUser* u, unsigned long timeout, ModeHandler& om) : Timer(timeout, false) , overridemode(om) , user(u) { ServerInstance->Timers.AddTimer(this); } bool Tick() override { if (!user->quitting && user->IsModeSet(overridemode)) { Modes::ChangeList changelist; changelist.push_remove(&overridemode); ServerInstance->Modes.Process(ServerInstance->FakeClient, nullptr, user, changelist); } return false; } }; class Override final : public SimpleUserMode { public: SimpleExtItem<UnsetTimer> ext; unsigned long timeout; Override(Module* Creator) : SimpleUserMode(Creator, "override", 'O', true) , ext(Creator, "override-timer", ExtensionType::USER) { } bool OnModeChange(User* source, User* dest, Channel* channel, Modes::Change& change) override { bool res = SimpleUserMode::OnModeChange(source, dest, channel, change); if (change.adding && res && IS_LOCAL(dest) && timeout) ext.Set(dest, new UnsetTimer(IS_LOCAL(dest), timeout, *this)); return res; } }; class ModuleOverride final : public Module , public ISupport::EventListener { private: bool requirekey; bool noisyoverride; Override ou; ChanModeReference topiclock; ChanModeReference inviteonly; ChanModeReference key; ChanModeReference limit; Invite::API invapi; static bool IsOverride(ModeHandler::Rank userlevel, const Modes::ChangeList::List& list) { for (const auto& change : list) { if (change.mh->GetLevelRequired(change.adding) > userlevel) return true; } return false; } ModResult HandleJoinOverride(LocalUser* user, Channel* chan, const std::string& keygiven, const char* bypasswhat, const char* mode) const { if (requirekey && keygiven != "override") { // Can't join normally -- must use a special key to bypass restrictions user->WriteNotice("*** You may not join normally. You must join with a key of 'override' to oper override."); return MOD_RES_PASSTHRU; } if (noisyoverride) chan->WriteRemoteNotice(INSP_FORMAT("{} used oper override to bypass {}", user->nick, bypasswhat)); ServerInstance->SNO.WriteGlobalSno('v', user->nick+" used oper override to bypass " + mode + " on " + chan->name); return MOD_RES_ALLOW; } public: ModuleOverride() : Module(VF_VENDOR, "Allows server operators to be given privileges that allow them to ignore various channel-level restrictions.") , ISupport::EventListener(this) , ou(this) , topiclock(this, "topiclock") , inviteonly(this, "inviteonly") , key(this, "key") , limit(this, "limit") , invapi(this) { } void init() override { ServerInstance->SNO.EnableSnomask('v', "OVERRIDE"); } void ReadConfig(ConfigStatus& status) override { // re-read our config options const auto& tag = ServerInstance->Config->ConfValue("override"); noisyoverride = tag->getBool("noisy"); requirekey = tag->getBool("requirekey"); ou.timeout = tag->getDuration("timeout", 0); } void OnBuildISupport(ISupport::TokenMap& tokens) override { tokens["OVERRIDE"] = ConvToStr(ou.GetModeChar()); } bool CanOverride(User* source, const char* token) { // The oper override umode (+O) is not set if (!source->IsModeSet(ou)) return false; return TokenList(source->oper->GetConfig()->getString("override")).Contains(token); } ModResult OnPreTopicChange(User* source, Channel* channel, const std::string& topic) override { if (IS_LOCAL(source) && source->IsOper() && CanOverride(source, "TOPIC")) { if (!channel->HasUser(source) || (channel->IsModeSet(topiclock) && channel->GetPrefixValue(source) < HALFOP_VALUE)) { ServerInstance->SNO.WriteGlobalSno('v', source->nick + " used oper override to change a topic on " + channel->name); } // Explicit allow return MOD_RES_ALLOW; } return MOD_RES_PASSTHRU; } ModResult OnUserPreKick(User* source, Membership* memb, const std::string& reason) override { if (source->IsOper() && CanOverride(source, "KICK")) { // If the kicker's status is less than the target's, or the kicker's status is less than or equal to voice if ((memb->chan->GetPrefixValue(source) < memb->GetRank()) || (memb->chan->GetPrefixValue(source) <= VOICE_VALUE) || (memb->chan->GetPrefixValue(source) == HALFOP_VALUE && memb->GetRank() == HALFOP_VALUE)) { ServerInstance->SNO.WriteGlobalSno('v', source->nick + " used oper override to kick " + memb->user->nick + " on " + memb->chan->name + " (" + reason + ")"); return MOD_RES_ALLOW; } } return MOD_RES_PASSTHRU; } ModResult OnPreMode(User* source, User* dest, Channel* channel, Modes::ChangeList& modes) override { if (!channel) return MOD_RES_PASSTHRU; if (!source->IsOper() || !IS_LOCAL(source)) return MOD_RES_PASSTHRU; const Modes::ChangeList::List& list = modes.getlist(); ModeHandler::Rank mode = channel->GetPrefixValue(source); if (!IsOverride(mode, list)) return MOD_RES_PASSTHRU; if (CanOverride(source, "MODE")) { std::string msg = source->nick + " used oper override to set modes on " + channel->name + ": "; // Construct a MODE string in the old format for sending it as a snotice std::string params; char pm = 0; for (const auto& item : list) { if (!item.param.empty()) params.append(1, ' ').append(item.param); char wanted_pm = (item.adding ? '+' : '-'); if (wanted_pm != pm) { pm = wanted_pm; msg += pm; } msg += item.mh->GetModeChar(); } msg += params; ServerInstance->SNO.WriteGlobalSno('v', msg); return MOD_RES_ALLOW; } return MOD_RES_PASSTHRU; } ModResult OnUserPreJoin(LocalUser* user, Channel* chan, const std::string& cname, std::string& privs, const std::string& keygiven, bool override) override { if (user->IsOper() && !override) { if (chan) { if (chan->IsModeSet(inviteonly) && (CanOverride(user, "INVITE"))) { if (!invapi->IsInvited(user, chan)) return HandleJoinOverride(user, chan, keygiven, "invite-only", "+i"); return MOD_RES_ALLOW; } if (chan->IsModeSet(key) && (CanOverride(user, "KEY")) && keygiven != chan->GetModeParameter(key)) return HandleJoinOverride(user, chan, keygiven, "the channel key", "+k"); if (chan->IsModeSet(limit) && (chan->GetUsers().size() >= ConvToNum<size_t>(chan->GetModeParameter(limit))) && (CanOverride(user, "LIMIT"))) return HandleJoinOverride(user, chan, keygiven, "the channel limit", "+l"); if (chan->IsBanned(user) && CanOverride(user, "BANWALK")) return HandleJoinOverride(user, chan, keygiven, "channel ban", "channel ban"); } } return MOD_RES_PASSTHRU; } }; MODULE_INIT(ModuleOverride) ��������������������������������������������������������������������������������inspircd-4.7.0/src/modules/m_passforward.cpp��������������������������������������������������������0000664�0000000�0000000�00000006340�14771603147�0021164�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2019-2024 Sadie Powell <sadie@witchery.services> * Copyright (C) 2019 linuxdaemon <linuxdaemon.irc@gmail.com> * Copyright (C) 2014 Googolplexed <googol@googolplexed.net> * Copyright (C) 2012 Robby <robby@chatbelgie.be> * Copyright (C) 2012 Attila Molnar <attilamolnar@hush.com> * Copyright (C) 2010 Daniel De Graaf <danieldg@inspircd.org> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include "inspircd.h" #include "modules/account.h" #include "stringutils.h" class ModulePassForward final : public Module { private: Account::API accountapi; std::string nickrequired, forwardmsg, forwardcmd; public: ModulePassForward() : Module(VF_VENDOR, "Allows an account password to be forwarded to a services pseudoclient such as NickServ.") , accountapi(this) { } void ReadConfig(ConfigStatus& status) override { const auto& tag = ServerInstance->Config->ConfValue("passforward"); nickrequired = tag->getString("nick", "NickServ"); forwardmsg = tag->getString("forwardmsg", "NOTICE %nick% :*** Forwarding password to %nickrequired%"); forwardcmd = tag->getString("cmd", "SQUERY %nickrequired% :IDENTIFY %nick% %pass%", 1); } std::string FormatStr(const LocalUser* user, const std::string& format, const std::string& pass) { return Template::Replace(format, { { "nick", user->nick, }, { "nickrequired", nickrequired, }, { "pass", pass, }, { "user", user->GetRealUser(), }, }); } void OnPostConnect(User* ruser) override { LocalUser* user = IS_LOCAL(ruser); if (!user || user->password.empty()) return; // If the connect class requires a password, don't forward it if (!user->GetClass()->password.empty()) return; if (accountapi && accountapi->GetAccountName(user)) { // User is logged in already (probably via SASL) don't forward the password return; } ForwardPass(user, user->password); } void OnPostCommand(Command* command, const CommandBase::Params& parameters, LocalUser* user, CmdResult result, bool loop) override { if (command->name == "NICK" && parameters.size() > 1) ForwardPass(user, parameters[1]); } void ForwardPass(LocalUser* user, const std::string& pass) { if (!nickrequired.empty()) { /* Check if nick exists and is on a services server. */ auto* u = ServerInstance->Users.Find(nickrequired); if (!u || !u->server->IsService()) return; } if (!forwardmsg.empty()) ServerInstance->Parser.ProcessBuffer(user, FormatStr(user, forwardmsg, pass)); ServerInstance->Parser.ProcessBuffer(user, FormatStr(user, forwardcmd, pass)); } }; MODULE_INIT(ModulePassForward) ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/src/modules/m_password_hash.cpp������������������������������������������������������0000664�0000000�0000000�00000011072�14771603147�0021474�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2014 Daniel Vassdal <shutter@canternet.org> * Copyright (C) 2013, 2017, 2019-2024 Sadie Powell <sadie@witchery.services> * Copyright (C) 2012, 2014 Attila Molnar <attilamolnar@hush.com> * Copyright (C) 2012 Robby <robby@chatbelgie.be> * Copyright (C) 2009-2010 Daniel De Graaf <danieldg@inspircd.org> * Copyright (C) 2008 Robin Burchell <robin+git@viroteck.net> * Copyright (C) 2007 Dennis Friis <peavey@inspircd.org> * Copyright (C) 2006 Craig Edwards <brain@inspircd.org> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include "inspircd.h" #include "modules/hash.h" class CommandMkpasswd final : public Command { public: CommandMkpasswd(Module* Creator) : Command(Creator, "MKPASSWD", 2) { penalty = 5000; syntax = { "<hashtype> <plaintext>" }; } CmdResult Handle(User* user, const Params& parameters) override { if (!parameters[0].compare(0, 5, "hmac-", 5)) { std::string type(parameters[0], 5); HashProvider* hp = ServerInstance->Modules.FindDataService<HashProvider>("hash/" + type); if (!hp) { user->WriteNotice("Unknown hash type"); return CmdResult::FAILURE; } if (hp->IsKDF()) { user->WriteNotice(type + " does not support HMAC"); return CmdResult::FAILURE; } std::string salt(hp->out_size, '\0'); ServerInstance->GenRandom(salt.data(), salt.length()); std::string target = hp->hmac(salt, parameters[1]); std::string str = Base64::Encode(salt) + "$" + Base64::Encode(target, nullptr, 0); user->WriteNotice(parameters[0] + " hashed password for " + parameters[1] + " is " + str); return CmdResult::SUCCESS; } HashProvider* hp = ServerInstance->Modules.FindDataService<HashProvider>("hash/" + parameters[0]); if (!hp) { user->WriteNotice("Unknown hash type"); return CmdResult::FAILURE; } try { std::string hexsum = hp->Generate(parameters[1]); user->WriteNotice(parameters[0] + " hashed password for " + parameters[1] + " is " + hexsum); return CmdResult::SUCCESS; } catch (const ModuleException& error) { user->WriteNotice("*** " + name + ": " + error.GetReason()); return CmdResult::FAILURE; } } }; class ModulePasswordHash final : public Module { private: CommandMkpasswd cmd; public: ModulePasswordHash() : Module(VF_VENDOR, "Allows passwords to be hashed and adds the /MKPASSWD command which allows the generation of hashed passwords for use in the server configuration.") , cmd(this) { } void ReadConfig(ConfigStatus& status) override { const auto& tag = ServerInstance->Config->ConfValue("mkpasswd"); cmd.access_needed = tag->getBool("operonly") ? CmdAccess::OPERATOR : CmdAccess::NORMAL; } ModResult OnCheckPassword(const std::string& password, const std::string& passwordhash, const std::string& value) override { if (!passwordhash.compare(0, 5, "hmac-", 5)) { std::string type(passwordhash, 5); HashProvider* hp = ServerInstance->Modules.FindDataService<HashProvider>("hash/" + type); if (!hp) return MOD_RES_PASSTHRU; if (hp->IsKDF()) { ServerInstance->Logs.Normal(MODNAME, "Tried to use HMAC with {}, which does not support HMAC", type); return MOD_RES_DENY; } // this is a valid hash, from here on we either accept or deny std::string::size_type sep = password.find('$'); if (sep == std::string::npos) return MOD_RES_DENY; std::string salt = Base64::Decode(password.substr(0, sep)); std::string target = Base64::Decode(password.substr(sep + 1)); if (target == hp->hmac(salt, value)) return MOD_RES_ALLOW; else return MOD_RES_DENY; } HashProvider* hp = ServerInstance->Modules.FindDataService<HashProvider>("hash/" + passwordhash); /* Is this a valid hash name? */ if (hp) { if (hp->Compare(value, password)) return MOD_RES_ALLOW; else /* No match, and must be hashed, forbid */ return MOD_RES_DENY; } // We don't handle this type, let other mods or the core decide return MOD_RES_PASSTHRU; } }; MODULE_INIT(ModulePasswordHash) ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/src/modules/m_pbkdf2.cpp�������������������������������������������������������������0000664�0000000�0000000�00000015055�14771603147�0020004�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2021 Dominic Hamon * Copyright (C) 2018-2025 Sadie Powell <sadie@witchery.services> * Copyright (C) 2018 linuxdaemon <linuxdaemon.irc@gmail.com> * Copyright (C) 2014, 2020 Daniel Vassdal <shutter@canternet.org> * Copyright (C) 2014, 2016 Attila Molnar <attilamolnar@hush.com> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include <cmath> #include "inspircd.h" #include "modules/hash.h" // Format: // Iterations:B64(Hash):B64(Salt) // E.g. // 10200:AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA:BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB class PBKDF2Hash final { public: unsigned long iterations; size_t length; std::string salt; std::string hash; PBKDF2Hash(unsigned long itr, size_t dkl, const std::string& slt, const std::string& hsh = "") : iterations(itr) , length(dkl) , salt(slt) , hash(hsh) { } PBKDF2Hash(const std::string& data) { irc::sepstream ss(data, ':'); std::string tok; ss.GetToken(tok); this->iterations = ConvToNum<unsigned int>(tok); ss.GetToken(tok); this->hash = Base64::Decode(tok); ss.GetToken(tok); this->salt = Base64::Decode(tok); this->length = this->hash.length(); } std::string ToString() const { if (!IsValid()) return ""; return INSP_FORMAT("{}:{}:{}", this->iterations, Base64::Encode(this->hash), Base64::Encode(this->salt)); } bool IsValid() const { return this->iterations && this->length && !this->salt.empty() && !this->hash.empty(); } }; class PBKDF2Provider final : public HashProvider { public: HashProvider* provider; unsigned long iterations; size_t dkey_length; std::string PBKDF2(const std::string& pass, const std::string& salt, unsigned long itr = 0, size_t dkl = 0) const { size_t blocks = std::ceil((double)dkl / provider->out_size); std::string output; std::string tmphash; std::string salt_block = salt; for (size_t block = 1; block <= blocks; block++) { char salt_data[4]; for (size_t i = 0; i < sizeof(salt_data); i++) salt_data[i] = block >> (24 - i * 8) & 0x0F; salt_block.erase(salt.length()); salt_block.append(salt_data, sizeof(salt_data)); std::string blockdata = provider->hmac(pass, salt_block); std::string lasthash = blockdata; for (size_t iter = 1; iter < itr; iter++) { tmphash = provider->hmac(pass, lasthash); for (size_t i = 0; i < provider->out_size; i++) blockdata[i] ^= tmphash[i]; lasthash.swap(tmphash); } output += blockdata; } output.erase(dkl); return output; } std::string GenerateRaw(const std::string& data) override { std::string salt(dkey_length, '\0'); ServerInstance->GenRandom(salt.data(), salt.length()); PBKDF2Hash hs(this->iterations, this->dkey_length, salt); hs.hash = PBKDF2(data, hs.salt, this->iterations, this->dkey_length); return hs.ToString(); } bool Compare(const std::string& input, const std::string& hash) override { PBKDF2Hash hs(hash); if (!hs.IsValid()) return false; std::string cmp = PBKDF2(input, hs.salt, hs.iterations, hs.length); return InspIRCd::TimingSafeCompare(cmp, hs.hash); } std::string ToPrintable(const std::string& raw) override { return raw; } PBKDF2Provider(Module* mod, HashProvider* hp) : HashProvider(mod, "pbkdf2-hmac-" + hp->name.substr(hp->name.find('/') + 1)) , provider(hp) { DisableAutoRegister(); } }; struct ProviderConfig final { unsigned long dkey_length; unsigned long iterations; }; typedef std::map<std::string, ProviderConfig> ProviderConfigMap; class ModulePBKDF2 final : public Module { std::vector<PBKDF2Provider*> providers; ProviderConfig globalconfig; ProviderConfigMap providerconfigs; ProviderConfig GetConfigForProvider(const std::string& name) const { ProviderConfigMap::const_iterator it = providerconfigs.find(name); if (it == providerconfigs.end()) return globalconfig; return it->second; } void ConfigureProviders() { for (auto* pi : providers) { ProviderConfig config = GetConfigForProvider(pi->name); pi->iterations = config.iterations; pi->dkey_length = config.dkey_length; } } void ReadConfig(ConfigStatus& status) override { // First set the common values const auto& tag = ServerInstance->Config->ConfValue("pbkdf2"); ProviderConfig newglobal; newglobal.iterations = tag->getNum<unsigned long>("iterations", 12288, 1); newglobal.dkey_length = tag->getNum<size_t>("length", 32, 1, 1024); // Then the specific values ProviderConfigMap newconfigs; for (const auto& [_, ptag] : ServerInstance->Config->ConfTags("pbkdf2prov")) { std::string hash_name = "hash/" + ptag->getString("hash"); ProviderConfig& config = newconfigs[hash_name]; config.iterations = ptag->getNum<unsigned long>("iterations", newglobal.iterations, 1); config.dkey_length = ptag->getNum<size_t>("length", newglobal.dkey_length, 1, 1024); } // Config is valid, apply it providerconfigs.swap(newconfigs); std::swap(globalconfig, newglobal); ConfigureProviders(); } public: ModulePBKDF2() : Module(VF_VENDOR, "Allows other modules to generate PBKDF2 hashes.") { } ~ModulePBKDF2() override { stdalgo::delete_all(providers); } void init() override { // Let ourself know about any existing services. for (const auto& [_, service] : ServerInstance->Modules.DataProviders) OnServiceAdd(*service); } void OnServiceAdd(ServiceProvider& provider) override { // Check if it's a hash provider if (provider.name.compare(0, 5, "hash/")) return; HashProvider* hp = static_cast<HashProvider*>(&provider); if (hp->IsKDF()) return; auto* prov = new PBKDF2Provider(this, hp); providers.push_back(prov); ServerInstance->Modules.AddService(*prov); ConfigureProviders(); } void OnServiceDel(ServiceProvider& prov) override { for (std::vector<PBKDF2Provider*>::iterator i = providers.begin(); i != providers.end(); ++i) { PBKDF2Provider* item = *i; if (item->provider != &prov) continue; ServerInstance->Modules.DelService(*item); delete item; providers.erase(i); break; } } }; MODULE_INIT(ModulePBKDF2) �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/src/modules/m_permchannels.cpp�������������������������������������������������������0000664�0000000�0000000�00000027161�14771603147�0021314�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2013-2014, 2017, 2019-2025 Sadie Powell <sadie@witchery.services> * Copyright (C) 2013, 2016 Attila Molnar <attilamolnar@hush.com> * Copyright (C) 2012, 2014 Adam <Adam@anope.org> * Copyright (C) 2012 Robby <robby@chatbelgie.be> * Copyright (C) 2010 Craig Edwards <brain@inspircd.org> * Copyright (C) 2009-2010 Daniel De Graaf <danieldg@inspircd.org> * Copyright (C) 2009 Uli Schlachter <psychon@znc.in> * Copyright (C) 2008-2009 Robin Burchell <robin+git@viroteck.net> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include "inspircd.h" #include "listmode.h" #include "timeutils.h" #include <fstream> /** Handles the +P channel mode */ class PermChannel final : public SimpleChannelMode { public: PermChannel(Module* Creator) : SimpleChannelMode(Creator, "permanent", 'P', true) { } bool OnModeChange(User* source, User* dest, Channel* channel, Modes::Change& change) override { if (SimpleChannelMode::OnModeChange(source, dest, channel, change)) { if (!change.adding) channel->CheckDestroy(); return true; } return false; } void SetOperOnly(bool value) { oper = value; } }; // Not in a class due to circular dependency hell. static std::string permchannelsconf; static bool WriteDatabase(PermChannel& permchanmode, bool save_listmodes, unsigned char writeversion) { /* * We need to perform an atomic write so as not to fuck things up. * So, let's write to a temporary file, flush it, then rename the file.. * -- w00t */ // If the user has not specified a configuration file then we don't write one. if (permchannelsconf.empty()) return true; const auto permchannelsnewconf = INSP_FORMAT("{}.new.{}", permchannelsconf, ServerInstance->Time()); std::ofstream stream(permchannelsnewconf); if (!stream.is_open()) { ServerInstance->Logs.Critical(MODNAME, "Cannot create database \"{}\"! {} ({})", permchannelsnewconf, strerror(errno), errno); ServerInstance->SNO.WriteToSnoMask('a', "database: cannot create new permchan db \"{}\": {} ({})", permchannelsnewconf, strerror(errno), errno); return false; } stream << "# This file was automatically generated by the " << INSPIRCD_VERSION << " permchannels module on " << Time::ToString(ServerInstance->Time()) << "." << std::endl << "# Any changes to this file will be automatically overwritten." << std::endl << std::endl; const static std::string indent(14, ' '); for (const auto& [_, chan] : ServerInstance->Channels.GetChans()) { if (!chan->IsModeSet(permchanmode)) continue; std::string chanmodes = chan->ChanModes(true); if (save_listmodes && writeversion == 1) { std::string modes; std::string params; for (auto* lm : ServerInstance->Modes.GetListModes()) { ListModeBase::ModeList* list = lm->GetList(chan); if (!list || list->empty()) continue; // Append the parameters for (const auto& entry : *list) { params += entry.mask; params += ' '; } // Append the mode letters (for example "IIII", "gg") modes.append(list->size(), lm->GetModeChar()); } if (!params.empty()) { // Remove the last space params.pop_back(); // If there is at least a space in chanmodes (that is, a non-listmode has a parameter) // insert the listmode mode letters before the space. Otherwise just append them. std::string::size_type p = chanmodes.find(' '); if (p == std::string::npos) chanmodes += modes; else chanmodes.insert(p, modes); // Append the listmode parameters (the masks themselves) chanmodes += ' '; chanmodes += params; } } stream << "<permchannels channel=\"" << ServerConfig::Escape(chan->name) << "\"" << std::endl << indent << "ts=\"" << chan->age << "\"" << std::endl; if (!chan->topic.empty()) { // Only store the topic if one is set. stream << indent << "topic=\"" << ServerConfig::Escape(chan->topic) << "\"" << std::endl << indent << "topicts=\"" << chan->topicset << "\"" << std::endl << indent << "topicsetby=\"" << ServerConfig::Escape(chan->setby) << "\"" << std::endl; } if (save_listmodes && writeversion >= 2) { for (auto* lm : ServerInstance->Modes.GetListModes()) { ListModeBase::ModeList* list = lm->GetList(chan); if (!list || list->empty()) continue; stream << indent << lm->name << "list=\""; for (auto entry = list->begin(); entry != list->end(); ++entry) { if (entry != list->begin()) stream << ' '; stream << ServerConfig::Escape(entry->mask) << ' ' << ServerConfig::Escape(entry->setter) << ' ' << entry->time; } stream << "\"" << std::endl; } } stream << indent << "modes=\"" << ServerConfig::Escape(chanmodes) << "\">" << std::endl; } if (stream.fail()) { ServerInstance->Logs.Critical(MODNAME, "Cannot write to new database \"{}\"! {} ({})", permchannelsnewconf, strerror(errno), errno); ServerInstance->SNO.WriteToSnoMask('a', "database: cannot write to new permchan db \"{}\": {} ({})", permchannelsnewconf, strerror(errno), errno); return false; } stream.close(); #ifdef _WIN32 remove(permchannelsconf.c_str()); #endif // Use rename to move temporary to new db - this is guaranteed not to fuck up, even in case of a crash. if (rename(permchannelsnewconf.c_str(), permchannelsconf.c_str()) < 0) { ServerInstance->Logs.Critical(MODNAME, "Cannot replace old database \"{}\" with new database \"{}\"! {} ({})", permchannelsconf, permchannelsnewconf, strerror(errno), errno); ServerInstance->SNO.WriteToSnoMask('a', "database: cannot replace old permchan db \"{}\" with new db \"{}\": {} ({})", permchannelsconf, permchannelsnewconf, strerror(errno), errno); return false; } return true; } class ModulePermanentChannels final : public Module , public Timer { private: PermChannel p; bool dirty = false; bool loaded = false; bool save_listmodes; unsigned long saveperiod; unsigned long maxbackoff; unsigned char backoff; unsigned char writeversion; public: ModulePermanentChannels() : Module(VF_VENDOR, "Adds channel mode P (permanent) which prevents the channel from being deleted when the last user leaves.") , Timer(0, true) , p(this) { } void ReadConfig(ConfigStatus& status) override { const auto& tag = ServerInstance->Config->ConfValue("permchanneldb"); permchannelsconf = tag->getString("filename"); save_listmodes = tag->getBool("listmodes", true); p.SetOperOnly(tag->getBool("operonly", true)); saveperiod = tag->getDuration("saveperiod", 5); backoff = tag->getNum<uint8_t>("backoff", 0); maxbackoff = tag->getDuration("maxbackoff", saveperiod * 120, saveperiod); writeversion = tag->getNum<unsigned char>("writeversion", 2, 1, 2); SetInterval(saveperiod); if (!permchannelsconf.empty()) permchannelsconf = ServerInstance->Config->Paths.PrependConfig(permchannelsconf); } void LoadDatabase() { /* * Process config-defined list of permanent channels. * -- w00t */ for (const auto& [_, tag] : ServerInstance->Config->ConfTags("permchannels")) { std::string channel = tag->getString("channel"); if (!ServerInstance->Channels.IsChannel(channel)) { ServerInstance->Logs.Warning(MODNAME, "Ignoring permchannels tag with invalid channel name (\"" + channel + "\")"); continue; } auto* c = ServerInstance->Channels.Find(channel); if (!c) { time_t TS = tag->getNum<time_t>("ts", ServerInstance->Time(), 1); c = new Channel(channel, TS); time_t topicset = tag->getNum<time_t>("topicts", 0); std::string topic = tag->getString("topic"); if ((topicset != 0) || (!topic.empty())) { if (topicset == 0) topicset = ServerInstance->Time(); std::string topicsetby = tag->getString("topicsetby"); if (topicsetby.empty()) topicsetby = ServerInstance->Config->GetServerName(); c->SetTopic(ServerInstance->FakeClient, topic, topicset, &topicsetby); } ServerInstance->Logs.Debug(MODNAME, "Added {} with topic {}", channel, c->topic); irc::spacesepstream modes(tag->getString("modes")); std::string modechars; modes.GetToken(modechars); for (const auto modechr : modechars) { auto* mode = ServerInstance->Modes.FindMode(modechr, MODETYPE_CHANNEL); if (mode) { std::string param; if (mode->NeedsParam(true)) modes.GetToken(param); Modes::Change modechange(mode, true, param); mode->OnModeChange(ServerInstance->FakeClient, ServerInstance->FakeClient, c, modechange); } } for (auto* lm : ServerInstance->Modes.GetListModes()) { irc::spacesepstream listmodes(tag->getString(lm->name + "list")); std::string mask; std::string set_by; time_t set_at; while (listmodes.GetToken(mask) && listmodes.GetToken(set_by) && listmodes.GetNumericToken(set_at)) { Modes::Change modechange(lm, true, mask, set_by, set_at); lm->OnModeChange(ServerInstance->FakeClient, ServerInstance->FakeClient, c, modechange); } } // We always apply the permchannels mode to permanent channels. Modes::Change modechange(&p, true); p.OnModeChange(ServerInstance->FakeClient, ServerInstance->FakeClient, c, modechange); } } } ModResult OnRawMode(User* user, Channel* chan, const Modes::Change& change) override { if (chan && (chan->IsModeSet(p) || change.mh == &p)) dirty = true; return MOD_RES_PASSTHRU; } void OnPostTopicChange(User*, Channel* c, const std::string&) override { if (c->IsModeSet(p)) dirty = true; } bool Tick() override { if (dirty) { if (WriteDatabase(p, save_listmodes, writeversion)) { // If we were previously unable to write but now can then reset the time interval. if (GetInterval() != saveperiod) SetInterval(saveperiod, false); dirty = false; } else { // Back off a bit to avoid spamming opers. if (backoff > 1) SetInterval(std::min(GetInterval() * backoff, maxbackoff), false); ServerInstance->Logs.Debug(MODNAME, "Trying again in {}", Duration::ToLongString(GetInterval())); } } return true; } void Prioritize() override { // XXX: Load the DB here because the order in which modules are init()ed at boot is // alphabetical, this means we must wait until all modules have done their init() // to be able to set the modes they provide (e.g.: m_stripcolor is inited after us) // Prioritize() is called after all module initialization is complete, consequently // all modes are available now if (loaded) return; loaded = true; // Load only when there are no linked servers - we set the TS of the channels we // create to the current time, this can lead to desync because spanningtree has // no way of knowing what we do ProtocolInterface::ServerList serverlist; ServerInstance->PI->GetServerList(serverlist); if (serverlist.size() < 2) { try { LoadDatabase(); } catch (const CoreException& e) { ServerInstance->Logs.Critical(MODNAME, "Error loading permchannels database: {}", e.what()); } } } ModResult OnChannelPreDelete(Channel* c) override { if (c->IsModeSet(p)) return MOD_RES_DENY; return MOD_RES_PASSTHRU; } }; MODULE_INIT(ModulePermanentChannels) ���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/src/modules/m_randquote.cpp����������������������������������������������������������0000664�0000000�0000000�00000004121�14771603147�0020626�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2013, 2019-2021, 2023 Sadie Powell <sadie@witchery.services> * Copyright (C) 2012 Robby <robby@chatbelgie.be> * Copyright (C) 2010 Daniel De Graaf <danieldg@inspircd.org> * Copyright (C) 2007 Dennis Friis <peavey@inspircd.org> * Copyright (C) 2006-2008 Craig Edwards <brain@inspircd.org> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include "inspircd.h" class ModuleRandQuote final : public Module { private: std::string prefix; std::string suffix; std::vector<std::string> quotes; public: ModuleRandQuote() : Module(VF_VENDOR, "Allows random quotes to be sent to users when they connect to the server.") { } void init() override { const auto& conf = ServerInstance->Config->ConfValue("randquote"); prefix = conf->getString("prefix"); suffix = conf->getString("suffix"); const std::string filestr = conf->getString("file", "quotes", 1); auto file = ServerInstance->Config->ReadFile(filestr); if (!file) throw ModuleException(this, "Unable to read quotes from " + filestr + ": " + file.error); std::vector<std::string> newquotes; irc::sepstream linestream(file.contents, '\n'); for (std::string line; linestream.GetToken(line); ) newquotes.push_back(line); std::swap(quotes, newquotes); } void OnUserConnect(LocalUser* user) override { if (!quotes.empty()) { unsigned long random = ServerInstance->GenRandomInt(quotes.size()); user->WriteNotice(prefix + quotes[random] + suffix); } } }; MODULE_INIT(ModuleRandQuote) �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/src/modules/m_realnameban.cpp��������������������������������������������������������0000664�0000000�0000000�00000004573�14771603147�0021104�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2020-2021 Sadie Powell <sadie@witchery.services> * Copyright (C) 2015 Renegade334 <contact.caaeed4f@renegade334.me.uk> * Copyright (C) 2012 Robby <robby@chatbelgie.be> * Copyright (C) 2009 Uli Schlachter <psychon@znc.in> * Copyright (C) 2009 Daniel De Graaf <danieldg@inspircd.org> * Copyright (C) 2008 Robin Burchell <robin+git@viroteck.net> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include "inspircd.h" #include "modules/extban.h" class RealMaskExtBan final : public ExtBan::MatchingBase { public: RealMaskExtBan(Module* Creator) : ExtBan::MatchingBase(Creator, "realmask", 'a') { } bool IsMatch(User* user, Channel* channel, const std::string& text) override { // Check that the user actually specified a real name. const size_t divider = text.find('+', 1); if (divider == std::string::npos) return false; // Check whether the user's mask matches. if (!channel->CheckBan(user, text.substr(0, divider))) return false; // Check whether the user's real name matches. return InspIRCd::Match(user->GetRealName(), text.substr(divider + 1)); } }; class RealNameExtBan final : public ExtBan::MatchingBase { public: RealNameExtBan(Module* Creator) : ExtBan::MatchingBase(Creator, "realname", 'r') { } bool IsMatch(User* user, Channel* channel, const std::string& text) override { return InspIRCd::Match(user->GetRealName(), text); } }; class ModuleGecosBan final : public Module { private: RealMaskExtBan maskextban; RealNameExtBan realextban; public: ModuleGecosBan() : Module(VF_VENDOR | VF_OPTCOMMON, "Adds extended bans a: (realmask) and r:(realname) which checks whether users have a real name matching the specified glob pattern.") , maskextban(this) , realextban(this) { } }; MODULE_INIT(ModuleGecosBan) �������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/src/modules/m_redirect.cpp�����������������������������������������������������������0000664�0000000�0000000�00000010151�14771603147�0020425�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2019-2023 Sadie Powell <sadie@witchery.services> * Copyright (C) 2017 B00mX0r <b00mx0r@aureus.pw> * Copyright (C) 2012-2014, 2016 Attila Molnar <attilamolnar@hush.com> * Copyright (C) 2012, 2019 Robby <robby@chatbelgie.be> * Copyright (C) 2012, 2014 Shawn Smith <ShawnSmith0828@gmail.com> * Copyright (C) 2009 Daniel De Graaf <danieldg@inspircd.org> * Copyright (C) 2008 Robin Burchell <robin+git@viroteck.net> * Copyright (C) 2006 Craig Edwards <brain@inspircd.org> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include "inspircd.h" #include "extension.h" #include "numerichelper.h" /** Handle channel mode +L */ class Redirect final : public ParamMode<Redirect, StringExtItem> { public: Redirect(Module* Creator) : ParamMode<Redirect, StringExtItem>(Creator, "redirect", 'L') { syntax = "<target>"; } bool OnSet(User* source, Channel* channel, std::string& parameter) override { if (IS_LOCAL(source)) { if (!ServerInstance->Channels.IsChannel(parameter)) { source->WriteNumeric(Numerics::NoSuchChannel(parameter)); return false; } } if (IS_LOCAL(source) && !source->IsOper()) { auto* c = ServerInstance->Channels.Find(parameter); if (!c) { source->WriteNumeric(690, INSP_FORMAT("Target channel {} must exist to be set as a redirect.", parameter)); return false; } else if (c->GetPrefixValue(source) < OP_VALUE) { source->WriteNumeric(690, INSP_FORMAT("You must be opped on {} to set it as a redirect.", parameter)); return false; } } /* * We used to do some checking for circular +L here, but there is no real need for this any more especially as we * now catch +L looping in PreJoin. Remove it, since O(n) logic makes me sad, and we catch it anyway. :) -- w00t */ ext.Set(channel, parameter); return true; } void SerializeParam(Channel* chan, const std::string* str, std::string& out) { out += *str; } }; class ModuleRedirect final : public Module { private: Redirect re; SimpleUserMode antiredirectmode; ChanModeReference limitmode; public: ModuleRedirect() : Module(VF_VENDOR, "Allows users to be redirected to another channel when the user limit is reached.") , re(this) , antiredirectmode(this, "antiredirect", 'L') , limitmode(this, "limit") { } ModResult OnUserPreJoin(LocalUser* user, Channel* chan, const std::string& cname, std::string& privs, const std::string& keygiven, bool override) override { if (!override && chan) { if (chan->IsModeSet(re) && chan->IsModeSet(limitmode)) { if (chan->GetUsers().size() >= ConvToNum<size_t>(chan->GetModeParameter(limitmode))) { const std::string& channel = *re.ext.Get(chan); /* sometimes broken services can make circular or chained +L, avoid this */ auto* destchan = ServerInstance->Channels.Find(channel); if (destchan && destchan->IsModeSet(re)) { user->WriteNumeric(470, cname, '*', "You may not join this channel. A redirect is set, but you may not be redirected as it is a circular loop."); return MOD_RES_DENY; } if (user->IsModeSet(antiredirectmode)) { user->WriteNumeric(470, cname, channel, "Force redirection stopped."); return MOD_RES_DENY; } else { user->WriteNumeric(470, cname, channel, "You may not join this channel, so you are automatically being transferred to the redirected channel."); Channel::JoinUser(user, channel); return MOD_RES_DENY; } } } } return MOD_RES_PASSTHRU; } }; MODULE_INIT(ModuleRedirect) �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/src/modules/m_regex_glob.cpp���������������������������������������������������������0000664�0000000�0000000�00000003671�14771603147�0020752�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2013, 2020-2022 Sadie Powell <sadie@witchery.services> * Copyright (C) 2013 Attila Molnar <attilamolnar@hush.com> * Copyright (C) 2012 Robby <robby@chatbelgie.be> * Copyright (C) 2009-2010 Daniel De Graaf <danieldg@inspircd.org> * Copyright (C) 2008 Thomas Stagner <aquanight@gmail.com> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include "inspircd.h" #include "modules/regex.h" class GlobPattern final : public Regex::Pattern { public: GlobPattern(const Module* mod, const std::string& pattern, uint8_t options) : Regex::Pattern(pattern, options) { } bool IsMatch(const std::string& text) override { return InspIRCd::Match(text, GetPattern()); } std::optional<Regex::MatchCollection> Matches(const std::string& text) override { if (!InspIRCd::Match(text, GetPattern())) return std::nullopt; // The glob engine does not support any kind of capture. static const Regex::Captures unusedc; static const Regex::NamedCaptures unusednc; return Regex::MatchCollection(unusedc, unusednc); } }; class ModuleRegexGlob final : public Module { private: Regex::SimpleEngine<GlobPattern> regex; public: ModuleRegexGlob() : Module(VF_VENDOR, "Provides the glob regular expression engine which uses the built-in glob matching system.") , regex(this, "glob") { } }; MODULE_INIT(ModuleRegexGlob) �����������������������������������������������������������������������inspircd-4.7.0/src/modules/m_regex_stdlib.cpp�������������������������������������������������������0000664�0000000�0000000�00000006157�14771603147�0021312�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2013, 2019-2023 Sadie Powell <sadie@witchery.services> * Copyright (C) 2013 Attila Molnar <attilamolnar@hush.com> * Copyright (C) 2012 ChrisTX <xpipe@hotmail.de> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include "inspircd.h" #include "modules/regex.h" #include <regex> class StdLibPattern final : public Regex::Pattern { private: std::regex regex; public: StdLibPattern(const Module* mod, const std::string& pattern, uint8_t options, std::regex::flag_type type) : Regex::Pattern(pattern, options) { // Convert the generic pattern options to stdlib pattern flags. std::regex_constants::syntax_option_type flags = type | std::regex::optimize; if (options & Regex::OPT_CASE_INSENSITIVE) flags |= std::regex::icase; try { regex.assign(pattern, flags); } catch(const std::regex_error& error) { throw Regex::Exception(mod, pattern, error.what()); } } bool IsMatch(const std::string& text) override { return std::regex_search(text, regex); } std::optional<Regex::MatchCollection> Matches(const std::string& text) override { std::smatch matches; if (!std::regex_search(text, matches, regex)) return std::nullopt; Regex::Captures captures(matches.size()); for (const auto& match : matches) captures.push_back(match); // The stdregex engine does not support named captures. static const Regex::NamedCaptures unusednc; return Regex::MatchCollection(captures, unusednc); } }; class StdLibEngine final : public Regex::Engine { public: std::regex::flag_type regextype; StdLibEngine(Module* Creator) : Regex::Engine(Creator, "stdregex") { } Regex::PatternPtr Create(const std::string& pattern, uint8_t options) const override { return std::make_shared<StdLibPattern>(creator, pattern, options, regextype); } }; class ModuleRegexStdLib final : public Module { private: StdLibEngine regex; public: ModuleRegexStdLib() : Module(VF_VENDOR, "Provides the stdregex regular expression engine which uses the C++11 std::regex regular expression matching system.") , regex(this) { } void ReadConfig(ConfigStatus& status) override { const auto& tag = ServerInstance->Config->ConfValue("stdregex"); regex.regextype = tag->getEnum("type", std::regex::ECMAScript, { { "awk", std::regex::awk }, { "bre", std::regex::basic }, { "ecmascript", std::regex::ECMAScript }, { "egrep", std::regex::egrep }, { "ere", std::regex::extended }, { "grep", std::regex::grep }, }); } }; MODULE_INIT(ModuleRegexStdLib) �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/src/modules/m_remove.cpp�������������������������������������������������������������0000664�0000000�0000000�00000014135�14771603147�0020127�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2017 B00mX0r <b00mx0r@aureus.pw> * Copyright (C) 2013, 2018-2024 Sadie Powell <sadie@witchery.services> * Copyright (C) 2012-2014 Attila Molnar <attilamolnar@hush.com> * Copyright (C) 2012 Robby <robby@chatbelgie.be> * Copyright (C) 2012 Justin Crawford <Justasic@Gmail.com> * Copyright (C) 2009 Uli Schlachter <psychon@znc.in> * Copyright (C) 2009 Daniel De Graaf <danieldg@inspircd.org> * Copyright (C) 2008 Thomas Stagner <aquanight@gmail.com> * Copyright (C) 2007 Dennis Friis <peavey@inspircd.org> * Copyright (C) 2006 Oliver Lupton <om@inspircd.org> * Copyright (C) 2005-2006, 2010 Craig Edwards <brain@inspircd.org> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include "inspircd.h" #include "modules/isupport.h" #include "numerichelper.h" class CommandRemove final : public Command { private: ChanModeReference nokicksmode; UserModeReference servprotectmode; public: ModeHandler::Rank protectedrank; bool supportnokicks; CommandRemove(Module* Creator) : Command(Creator, "REMOVE", 2, 3) , nokicksmode(Creator, "nokick") , servprotectmode(Creator, "servprotect") { syntax = { "<channel> <nick> [:<reason>]" }; translation = { TR_TEXT, TR_NICK, TR_TEXT }; } CmdResult Handle(User* user, const CommandBase::Params& parameters) override { // Keep compatibility with v3 servers by allowing them to send removes with the old order. bool neworder = !IS_LOCAL(user) && ServerInstance->Channels.IsPrefix(parameters[0][0]); const std::string& channame = parameters[neworder ? 0 : 1]; const std::string& username = parameters[neworder ? 1 : 0]; /* Look up the user we're meant to be removing from the channel */ User* target; if (IS_LOCAL(user)) target = ServerInstance->Users.FindNick(username, true); else target = ServerInstance->Users.Find(username, true); /* And the channel we're meant to be removing them from */ auto* channel = ServerInstance->Channels.Find(channame); /* Fix by brain - someone needs to learn to validate their input! */ if (!channel) { user->WriteNumeric(Numerics::NoSuchChannel(channame)); return CmdResult::FAILURE; } if (!target) { user->WriteNumeric(Numerics::NoSuchNick(username)); return CmdResult::FAILURE; } if (!channel->HasUser(target)) { user->WriteNotice("*** User {} is not on channel {}", target->nick, channel->name); return CmdResult::FAILURE; } if (target->IsModeSet(servprotectmode)) { user->WriteNumeric(ERR_RESTRICTED, channame, "Only a service may remove a service from a channel."); return CmdResult::FAILURE; } /* We support the +Q channel mode via. the m_nokicks module, if the module is loaded and the mode is set then disallow the /remove */ if ((!IS_LOCAL(user)) || (!supportnokicks) || (!channel->IsModeSet(nokicksmode))) { /* We'll let everyone remove their level and below, eg: * ops can remove ops, halfops, voices, and those with no mode (no moders actually are set to 1) * a services target will get a higher level than it's possible for a /remover to get..so they're safe. * Nobody may remove people with >= protectedrank rank. */ ModeHandler::Rank ulevel = channel->GetPrefixValue(user); ModeHandler::Rank tlevel = channel->GetPrefixValue(target); if ((!IS_LOCAL(user)) || ((ulevel > VOICE_VALUE) && (ulevel >= tlevel) && ((protectedrank == 0) || (tlevel < protectedrank)))) { // REMOVE will be sent to the target's server and it will reply with a PART (or do nothing if it doesn't understand the command) if (!IS_LOCAL(target)) { CommandBase::Params p; p.push_back(channel->name); p.push_back(target->uuid); if (parameters.size() > 2) p.push_back(":" + parameters[2]); ServerInstance->PI->SendEncapsulatedData(target->server->GetName(), "REMOVE", p, user); return CmdResult::SUCCESS; } std::string reasonparam; /* If a reason is given, use it */ if(parameters.size() > 2) reasonparam = parameters[2]; else reasonparam = "No reason given"; /* Build up the part reason string. */ std::string reason = "Removed by " + user->nick + ": " + reasonparam; channel->WriteRemoteNotice(INSP_FORMAT("{} removed {} from the channel", user->nick, target->nick)); target->WriteNotice("*** " + user->nick + " removed you from " + channel->name + " with the message: " + reasonparam); channel->PartUser(target, reason); } else { user->WriteNotice("*** You do not have access to /REMOVE {} from {}", target->nick, channel->name); return CmdResult::FAILURE; } } else { /* m_nokicks.so was loaded and +Q was set, block! */ user->WriteNumeric(ERR_RESTRICTED, channel->name, INSP_FORMAT("Can't remove user {} from channel (+{} is set)", target->nick, servprotectmode->GetModeChar())); return CmdResult::FAILURE; } return CmdResult::SUCCESS; } }; class ModuleRemove final : public Module , public ISupport::EventListener { private: CommandRemove cmd; public: ModuleRemove() : Module(VF_VENDOR | VF_OPTCOMMON, "Adds the /REMOVE command which allows channel operators to force part users from a channel.") , ISupport::EventListener(this) , cmd(this) { } void OnBuildISupport(ISupport::TokenMap& tokens) override { tokens["REMOVE"]; } void ReadConfig(ConfigStatus& status) override { const auto& tag = ServerInstance->Config->ConfValue("remove"); cmd.supportnokicks = tag->getBool("supportnokicks"); cmd.protectedrank = tag->getNum<ModeHandler::Rank>("protectedrank", 50000, 1); } }; MODULE_INIT(ModuleRemove) �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/src/modules/m_repeat.cpp�������������������������������������������������������������0000664�0000000�0000000�00000033673�14771603147�0020122�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2025 iwalkalone <iwalkalone@chathispano.com> * Copyright (C) 2021 Dominic Hamon * Copyright (C) 2021 David Schultz <me@zpld.me> * Copyright (C) 2018 linuxdaemon <linuxdaemon.irc@gmail.com> * Copyright (C) 2018 Matt Schatz <genius3000@g3k.solutions> * Copyright (C) 2017-2025 Sadie Powell <sadie@witchery.services> * Copyright (C) 2013-2014 Attila Molnar <attilamolnar@hush.com> * Copyright (C) 2013 Daniel Vassdal <shutter@canternet.org> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include "inspircd.h" #include "extension.h" #include "modules/exemption.h" #include "numerichelper.h" #include "timeutils.h" class ChannelSettings final { public: enum RepeatAction { ACT_BAN, ACT_BLOCK, ACT_KICK, ACT_KICK_BAN, ACT_MUTE, }; RepeatAction Action; unsigned int Backlog; unsigned int Lines; unsigned int Diff; unsigned long Seconds; void serialize(bool extended, std::string& out) const { if (extended) { switch (Action) { case ACT_BAN: out.append("ban"); break; case ACT_BLOCK: out.append("block"); break; case ACT_MUTE: out.append("mute"); break; case ACT_KICK: out.append("kick"); break; case ACT_KICK_BAN: out.append("kickban"); break; } out.push_back(':'); } else { switch (Action) { case ACT_KICK_BAN: out.push_back('*'); break; case ACT_BLOCK: out.push_back('~'); break; default: break; // No other types are supported in the old mode. } } out.append(ConvToStr(Lines)).push_back(':'); out.append(ConvToStr(Seconds)); if (Diff) { out.push_back(':'); out.append(ConvToStr(Diff)); if (Backlog) { out.push_back(':'); out.append(ConvToStr(Backlog)); } } } }; class RepeatMode final : public ParamMode<RepeatMode, SimpleExtItem<ChannelSettings>> { private: struct RepeatItem final { time_t ts; std::string line; RepeatItem(time_t TS, const std::string& Line) : ts(TS) , line(Line) { } }; typedef std::deque<RepeatItem> RepeatItemList; struct MemberInfo final { RepeatItemList ItemList; unsigned int Counter = 0; }; struct ModuleSettings final { bool Extended = false; unsigned long MaxLines = 0; unsigned long MaxSecs = 0; unsigned long MaxBacklog = 0; unsigned int MaxDiff = 0; size_t MaxMessageSize = 0; std::string Message; }; std::vector<size_t> mx[2]; bool CompareLines(const std::string& message, const std::string& historyline, unsigned long trigger) { if (message == historyline) return true; else if (trigger) return (Levenshtein(message, historyline) <= trigger); return false; } size_t Levenshtein(const std::string& s1, const std::string& s2) { size_t l1 = s1.size(); size_t l2 = s2.size(); for (size_t i = 0; i < l2; i++) mx[0][i] = i; for (size_t i = 0; i < l1; i++) { mx[1][0] = i + 1; for (size_t j = 0; j < l2; j++) mx[1][j + 1] = std::min(std::min(mx[1][j] + 1, mx[0][j + 1] + 1), mx[0][j] + ((s1[i] == s2[j]) ? 0 : 1)); mx[0].swap(mx[1]); } return mx[0][l2]; } public: ModuleSettings ms; SimpleExtItem<MemberInfo> MemberInfoExt; RepeatMode(Module* Creator) : ParamMode<RepeatMode, SimpleExtItem<ChannelSettings>>(Creator, "repeat", 'E') , MemberInfoExt(Creator, "repeat", ExtensionType::MEMBERSHIP) { } void OnUnset(User* source, Channel* chan) override { // Unset the per-membership extension when the mode is removed for (const auto& [_, memb] : chan->GetUsers()) MemberInfoExt.Unset(memb); } bool OnSet(User* source, Channel* channel, std::string& parameter) override { ChannelSettings settings; if (!ParseSettings(source, parameter, settings)) { source->WriteNumeric(Numerics::InvalidModeParameter(channel, this, parameter)); return false; } if ((settings.Backlog > 0) && (settings.Lines > settings.Backlog)) { source->WriteNumeric(Numerics::InvalidModeParameter(channel, this, parameter, "You can't set lines higher than backlog.")); return false; } LocalUser* localsource = IS_LOCAL(source); if ((localsource) && (!ValidateSettings(localsource, channel, parameter, settings))) return false; ext.Set(channel, settings); return true; } bool MatchLine(Membership* memb, ChannelSettings* rs, std::string message) { // If the message is larger than whatever size it's set to, // let's pretend it isn't. If the first 512 (def. setting) match, it's probably spam. if (message.size() > ms.MaxMessageSize) message.erase(ms.MaxMessageSize); MemberInfo* rp = MemberInfoExt.Get(memb); if (!rp) { rp = new MemberInfo; MemberInfoExt.Set(memb, rp); } unsigned int matches = 0; if (!rs->Backlog) matches = rp->Counter; RepeatItemList& items = rp->ItemList; const unsigned long trigger = (message.size() * rs->Diff / 100); const time_t now = ServerInstance->Time(); std::transform(message.begin(), message.end(), message.begin(), ::tolower); for (std::deque<RepeatItem>::iterator it = items.begin(); it != items.end(); ++it) { if (it->ts < now) { items.erase(it, items.end()); matches = 0; break; } if (CompareLines(message, it->line, trigger)) { if (++matches >= rs->Lines) { if (rs->Action != ChannelSettings::ACT_BLOCK) rp->Counter = 0; return true; } } else if ((ms.MaxBacklog == 0) || (rs->Backlog == 0)) { matches = 0; items.clear(); break; } } unsigned int max_items = (rs->Backlog ? rs->Backlog : 1); if (items.size() >= max_items) items.pop_back(); items.push_front(RepeatItem(now + rs->Seconds, message)); rp->Counter = matches; return false; } void Resize(size_t size) { size_t newsize = size+1; if (newsize <= mx[0].size()) return; ms.MaxMessageSize = size; mx[0].resize(newsize); mx[1].resize(newsize); } void SerializeParam(Channel* chan, const ChannelSettings* chset, std::string& out) { chset->serialize(ms.Extended, out); } void SetSyntax() { if (ms.Extended) syntax = "{ban|block|mute|kick|kickban}:<lines>:<duration>[:<difference>][:<backlog>]"; else syntax = "[~|*]<lines>:<duration>[:<difference>][:<backlog>]"; } private: bool ParseAction(irc::sepstream& stream, ChannelSettings::RepeatAction& action) { std::string actionstr; if (!stream.GetToken(actionstr)) return false; if (irc::equals(actionstr, "ban")) action = ChannelSettings::ACT_BAN; else if (irc::equals(actionstr, "kick")) action = ChannelSettings::ACT_KICK; else if (irc::equals(actionstr, "block")) action = ChannelSettings::ACT_BLOCK; else if (irc::equals(actionstr, "mute")) action = ChannelSettings::ACT_MUTE; else if (irc::equals(actionstr, "kickban")) action = ChannelSettings::ACT_KICK_BAN; else return false; return true; } bool ParseSettings(User* source, std::string& parameter, ChannelSettings& settings) { irc::sepstream stream(parameter, ':'); std::string item; if (ms.Extended) { if (!ParseAction(stream, settings.Action) || !stream.GetToken(item)) return false; } else { if (!stream.GetToken(item)) return false; // Required parameter missing settings.Action = ChannelSettings::ACT_KICK; if ((item[0] == '*') || (item[0] == '~')) { settings.Action = ((item[0] == '*') ? ChannelSettings::ACT_KICK_BAN : ChannelSettings::ACT_BLOCK); item.erase(item.begin()); } } if ((settings.Lines = ConvToNum<unsigned int>(item)) == 0) return false; if ((!stream.GetToken(item)) || !Duration::TryFrom(item, settings.Seconds) || (settings.Seconds == 0)) // Required parameter missing return false; // The diff and backlog parameters are optional settings.Diff = settings.Backlog = 0; if (stream.GetToken(item)) { // There is a diff parameter, see if it's valid (> 0) if ((settings.Diff = ConvToNum<unsigned int>(item)) == 0) return false; if (stream.GetToken(item)) { // There is a backlog parameter, see if it's valid if ((settings.Backlog = ConvToNum<unsigned int>(item)) == 0) return false; // If there are still tokens, then it's invalid because we allow only 4 if (stream.GetToken(item)) return false; } } return true; } bool ValidateSettings(LocalUser* source, Channel* channel, const std::string& parameter, const ChannelSettings& settings) { if (ms.MaxLines && settings.Lines > ms.MaxLines) { source->WriteNumeric(Numerics::InvalidModeParameter(channel, this, parameter, INSP_FORMAT( "The line number you specified is too big. Maximum allowed is {}.", ms.MaxLines))); return false; } if (ms.MaxSecs && settings.Seconds > ms.MaxSecs) { source->WriteNumeric(Numerics::InvalidModeParameter(channel, this, parameter, INSP_FORMAT( "The seconds you specified are too big. Maximum allowed is {}.", ms.MaxSecs))); return false; } if (settings.Diff && settings.Diff > ms.MaxDiff) { if (ms.MaxDiff == 0) source->WriteNumeric(Numerics::InvalidModeParameter(channel, this, parameter, "The server administrator has disabled matching on edit distance.")); else source->WriteNumeric(Numerics::InvalidModeParameter(channel, this, parameter, INSP_FORMAT( "The distance you specified is too big. Maximum allowed is {}.", ms.MaxDiff))); return false; } if (settings.Backlog && settings.Backlog > ms.MaxBacklog) { if (ms.MaxBacklog == 0) source->WriteNumeric(Numerics::InvalidModeParameter(channel, this, parameter, "The server administrator has disabled backlog matching.")); else source->WriteNumeric(Numerics::InvalidModeParameter(channel, this, parameter, INSP_FORMAT( "The backlog you specified is too big. Maximum allowed is {}.", ms.MaxBacklog))); return false; } return true; } }; class RepeatModule final : public Module { private: ChanModeReference banmode; CheckExemption::EventProvider exemptionprov; RepeatMode rm; void CreateBan(Channel* channel, User* user, bool mute) { std::string banmask(mute ? "m:*!" : "*!"); banmask.append(user->GetBanUser(false)); banmask.append("@"); banmask.append(user->GetDisplayedHost()); Modes::ChangeList changelist; changelist.push_add(*banmode, banmask); ServerInstance->Modes.Process(ServerInstance->FakeClient, channel, nullptr, changelist); } public: RepeatModule() : Module(VF_VENDOR | VF_COMMON, "Adds channel mode E (repeat) which helps protect against spammers which spam the same message repeatedly.") , banmode(this, "ban") , exemptionprov(this) , rm(this) { } void ReadConfig(ConfigStatus& status) override { const auto& tag = ServerInstance->Config->ConfValue("repeat"); rm.ms.Message = tag->getString("message", tag->getString("kickmessage", "Repeat flood detected (trigger is %lines% messages in %duration%)"), 1); rm.ms.Extended = tag->getBool("extended"); rm.ms.MaxBacklog = tag->getNum<unsigned long>("maxbacklog", 20); rm.ms.MaxDiff = tag->getNum<unsigned int>("maxdistance", 50, 0, 100); rm.ms.MaxLines = tag->getNum<unsigned long>("maxlines", 20); rm.ms.MaxSecs = tag->getDuration("maxtime", 0); rm.Resize(tag->getNum<size_t>("size", 512, 1, ServerInstance->Config->Limits.MaxLine)); } ModResult OnUserPreMessage(User* user, MessageTarget& target, MessageDetails& details) override { if (target.type != MessageTarget::TYPE_CHANNEL || !IS_LOCAL(user)) return MOD_RES_PASSTHRU; auto* chan = target.Get<Channel>(); ChannelSettings* settings = rm.ext.Get(chan); if (!settings) return MOD_RES_PASSTHRU; Membership* memb = chan->GetUser(user); if (!memb) return MOD_RES_PASSTHRU; ModResult res = exemptionprov.Check(user, chan, "repeat"); if (res == MOD_RES_ALLOW) return MOD_RES_PASSTHRU; if (user->HasPrivPermission("channels/ignore-repeat")) return MOD_RES_PASSTHRU; if (rm.MatchLine(memb, settings, details.text)) { const std::string message = Template::Replace(rm.ms.Message, { { "channel", chan->name }, { "diff", ConvToStr(settings->Diff) }, { "duration", Duration::ToString(settings->Seconds) }, { "lines", ConvToStr(settings->Lines) }, { "seconds", ConvToStr(settings->Seconds) }, }); switch (settings->Action) { case ChannelSettings::ACT_BAN: memb->WriteNotice(message); CreateBan(chan, user, false); break; case ChannelSettings::ACT_BLOCK: memb->WriteNotice(message); break; case ChannelSettings::ACT_KICK: chan->KickUser(ServerInstance->FakeClient, user, message); break; case ChannelSettings::ACT_KICK_BAN: CreateBan(chan, user, false); chan->KickUser(ServerInstance->FakeClient, user, message); break; case ChannelSettings::ACT_MUTE: memb->WriteNotice(message); CreateBan(chan, user, true); break; } return MOD_RES_DENY; } return MOD_RES_PASSTHRU; } void Prioritize() override { ServerInstance->Modules.SetPriority(this, I_OnUserPreMessage, PRIORITY_LAST); } void GetLinkData(LinkData& data, std::string& compatdata) override { data["actions"] = rm.ms.Extended ? "ban block kick kickban mute" : "block kick kickban"; data["max-lines"] = ConvToStr(rm.ms.MaxLines); data["max-secs"] = ConvToStr(rm.ms.MaxSecs); data["max-diff"] = ConvToStr(rm.ms.MaxDiff); data["max-backlog"] = ConvToStr(rm.ms.MaxBacklog); compatdata = INSP_FORMAT("{}{}:{}:{}:{}", rm.ms.Extended ? "extended:" : "", rm.ms.MaxLines, rm.ms.MaxSecs, rm.ms.MaxDiff, rm.ms.MaxBacklog); } }; MODULE_INIT(RepeatModule) ���������������������������������������������������������������������inspircd-4.7.0/src/modules/m_restrictchans.cpp������������������������������������������������������0000664�0000000�0000000�00000005720�14771603147�0021506�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2019-2024 Sadie Powell <sadie@witchery.services> * Copyright (C) 2018-2019 linuxdaemon <linuxdaemon.irc@gmail.com> * Copyright (C) 2013 Attila Molnar <attilamolnar@hush.com> * Copyright (C) 2012 Robby <robby@chatbelgie.be> * Copyright (C) 2009 Daniel De Graaf <danieldg@inspircd.org> * Copyright (C) 2007 Dennis Friis <peavey@inspircd.org> * Copyright (C) 2005, 2007 Craig Edwards <brain@inspircd.org> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include "inspircd.h" #include "modules/account.h" typedef insp::flat_set<std::string, irc::insensitive_swo> AllowChans; class ModuleRestrictChans final : public Module { private: Account::API accountapi; AllowChans allowchans; bool allowregistered = false; bool CanCreateChannel(LocalUser* user, const std::string& name) { if (allowregistered && accountapi && accountapi->GetAccountName(user)) return true; if (user->HasPrivPermission("channels/restricted-create")) return true; for (const auto& allowchan : allowchans) { if (InspIRCd::Match(name, allowchan)) return true; } return false; } public: ModuleRestrictChans() : Module(VF_VENDOR, "Prevents unprivileged users from creating new channels.") , accountapi(this) { } void ReadConfig(ConfigStatus& status) override { AllowChans newallows; for (const auto& [_, tag] : ServerInstance->Config->ConfTags("allowchannel")) { const std::string name = tag->getString("name"); if (name.empty()) throw ModuleException(this, "Empty <allowchannel:name> at " + tag->source.str()); newallows.insert(name); } allowchans.swap(newallows); // Global config const auto& tag = ServerInstance->Config->ConfValue("restrictchans"); allowregistered = tag->getBool("allowregistered", false); } ModResult OnUserPreJoin(LocalUser* user, Channel* chan, const std::string& cname, std::string& privs, const std::string& keygiven, bool override) override { // channel does not yet exist (record is null, about to be created IF we were to allow it) if (!override && !chan && !CanCreateChannel(user, cname)) { const auto* reason = allowregistered ? "logged into an account" : "a server operator"; user->WriteNumeric(ERR_RESTRICTED, cname, INSP_FORMAT("You must be {} to create new channels.", reason)); return MOD_RES_DENY; } return MOD_RES_PASSTHRU; } }; MODULE_INIT(ModuleRestrictChans) ������������������������������������������������inspircd-4.7.0/src/modules/m_restrictmsg.cpp��������������������������������������������������������0000664�0000000�0000000�00000004401�14771603147�0021173�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2017, 2019-2024 Sadie Powell <sadie@witchery.services> * Copyright (C) 2012 Robby <robby@chatbelgie.be> * Copyright (C) 2009 Daniel De Graaf <danieldg@inspircd.org> * Copyright (C) 2008 Robin Burchell <robin+git@viroteck.net> * Copyright (C) 2005-2006 Craig Edwards <brain@inspircd.org> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include "inspircd.h" #include "modules/ctctags.h" #include "numerichelper.h" class ModuleRestrictMsg final : public Module , public CTCTags::EventListener { private: static ModResult HandleMessage(User* user, const MessageTarget& target) { if ((target.type == MessageTarget::TYPE_USER) && (IS_LOCAL(user))) { const auto* u = target.Get<User>(); // message allowed if: // (1) the sender is opered // (2) the recipient is opered // (3) the recipient is on a services server // anything else, blocked. if (u->IsOper() || user->IsOper() || u->server->IsService()) return MOD_RES_PASSTHRU; user->WriteNumeric(Numerics::CannotSendTo(u, "You cannot send messages to this user.")); return MOD_RES_DENY; } // however, we must allow channel messages... return MOD_RES_PASSTHRU; } public: ModuleRestrictMsg() : Module(VF_VENDOR, "Prevents users who are not server operators from messaging each other.") , CTCTags::EventListener(this) { } ModResult OnUserPreMessage(User* user, MessageTarget& target, MessageDetails& details) override { return HandleMessage(user, target); } ModResult OnUserPreTagMessage(User* user, MessageTarget& target, CTCTags::TagMessageDetails& details) override { return HandleMessage(user, target); } }; MODULE_INIT(ModuleRestrictMsg) ���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/src/modules/m_rline.cpp��������������������������������������������������������������0000664�0000000�0000000�00000022532�14771603147�0017743�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2019 Matt Schatz <genius3000@g3k.solutions> * Copyright (C) 2018 linuxdaemon <linuxdaemon.irc@gmail.com> * Copyright (C) 2013, 2018-2023, 2025 Sadie Powell <sadie@witchery.services> * Copyright (C) 2012-2013, 2016 Attila Molnar <attilamolnar@hush.com> * Copyright (C) 2012, 2019 Robby <robby@chatbelgie.be> * Copyright (C) 2009-2010 Daniel De Graaf <danieldg@inspircd.org> * Copyright (C) 2008-2009 Robin Burchell <robin+git@viroteck.net> * Copyright (C) 2008 Thomas Stagner <aquanight@gmail.com> * Copyright (C) 2008 Craig Edwards <brain@inspircd.org> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include "inspircd.h" #include "modules/regex.h" #include "modules/stats.h" #include "timeutils.h" #include "xline.h" static bool ZlineOnMatch = false; static bool added_zline = false; class RLine final : public XLine { public: RLine(time_t s_time, unsigned long d, const std::string& src, const std::string& re, const std::string& regexs, Regex::EngineReference& rxfactory) : XLine(s_time, d, src, re, "R") , matchtext(regexs) { /* This can throw on failure, but if it does we DONT catch it here, we catch it and display it * where the object is created, we might not ALWAYS want it to output stuff to snomask x all the time */ regex = rxfactory->Create(regexs); } bool Matches(User* u) const override { LocalUser* lu = IS_LOCAL(u); if (lu && lu->exempt) return false; const std::string host = u->nick + "!" + u->GetRealUser() + "@" + u->GetRealHost() + " " + u->GetRealName(); const std::string ip = u->nick + "!" + u->GetRealUser() + "@" + u->GetAddress() + " " + u->GetRealName(); return (regex->IsMatch(host) || regex->IsMatch(ip)); } bool Matches(const std::string& compare) const override { return regex->IsMatch(compare); } void Apply(User* u) override { if (ZlineOnMatch) { auto* zl = new ZLine(ServerInstance->Time(), duration ? expiry - ServerInstance->Time() : 0, MODNAME "@" + ServerInstance->Config->ServerName, reason, u->GetAddress()); if (ServerInstance->XLines->AddLine(zl, nullptr)) { if (!duration) { ServerInstance->SNO.WriteToSnoMask('x', "{} added a permanent Z-line on {}: {}", zl->source, u->GetAddress(), zl->reason); } else { ServerInstance->SNO.WriteToSnoMask('x', "{} added a timed Z-line on {}, expires in {} (on {}): {}", zl->source, u->GetAddress(), Duration::ToLongString(zl->duration), Time::ToString(zl->duration), zl->reason); } added_zline = true; } else delete zl; } DefaultApply(u, false); } const std::string& Displayable() const override { return matchtext; } std::string matchtext; Regex::PatternPtr regex; }; /** An XLineFactory specialized to generate RLine* pointers */ class RLineFactory final : public XLineFactory { private: const Module* creator; Regex::EngineReference& rxfactory; public: RLineFactory(const Module* mod, Regex::EngineReference& rx) : XLineFactory("R") , creator(mod) , rxfactory(rx) { } /** Generate a RLine */ XLine* Generate(time_t set_time, unsigned long duration, const std::string& source, const std::string& reason, const std::string& xline_specific_mask) override { if (!rxfactory) { ServerInstance->SNO.WriteToSnoMask('a', "Cannot create regexes until engine is set to a loaded provider!"); throw ModuleException(creator, "Regex engine not set or loaded!"); } return new RLine(set_time, duration, source, reason, xline_specific_mask, rxfactory); } }; class CommandRLine final : public Command { std::string rxengine; RLineFactory& factory; public: CommandRLine(Module* Creator, RLineFactory& rlf) : Command(Creator, "RLINE", 1, 3) , factory(rlf) { access_needed = CmdAccess::OPERATOR; syntax = { "<regex> [[<duration>] :<reason>]" }; } CmdResult Handle(User* user, const Params& parameters) override { if (parameters.size() > 1) { // Adding - XXX todo make this respect <insane> tag perhaps.. unsigned long duration = 0; if (parameters.size() > 2 && !Duration::TryFrom(parameters[1], duration)) { user->WriteNotice("*** Invalid duration for R-line."); return CmdResult::FAILURE; } XLine* r = nullptr; try { r = factory.Generate(ServerInstance->Time(), duration, user->nick, parameters.back(), parameters[0]); } catch (const ModuleException& e) { ServerInstance->SNO.WriteToSnoMask('a', "Could not add R-line: " + e.GetReason()); } if (r) { if (ServerInstance->XLines->AddLine(r, user)) { if (!duration) { ServerInstance->SNO.WriteToSnoMask('x', "{} added a permanent R-line on {}: {}", user->nick, parameters[0], r->reason); } else { ServerInstance->SNO.WriteToSnoMask('x', "{} added a timed R-line on {}, expires in {} (on {}): {}", user->nick, parameters[0], Duration::ToLongString(duration), Time::FromNow(duration), r->reason); } ServerInstance->XLines->ApplyLines(); } else { delete r; user->WriteNotice("*** R-line for " + parameters[0] + " already exists."); } } } else { std::string reason; if (ServerInstance->XLines->DelLine(parameters[0], "R", reason, user)) { ServerInstance->SNO.WriteToSnoMask('x', "{} removed R-line on {}: {}", user->nick, parameters[0], reason); } else { user->WriteNotice("*** R-line " + parameters[0] + " not found on the list."); } } return CmdResult::SUCCESS; } }; class ModuleRLine final : public Module , public Stats::EventListener { private: Regex::EngineReference rxfactory; RLineFactory f; CommandRLine r; bool MatchOnNickChange; bool initing = true; Regex::Engine* factory; public: ModuleRLine() : Module(VF_VENDOR | VF_COMMON, "Adds the /RLINE command which allows server operators to prevent users matching a nickname!username@hostname+realname regular expression from connecting to the server.") , Stats::EventListener(this) , rxfactory(this) , f(this, rxfactory) , r(this, f) { } void init() override { ServerInstance->XLines->RegisterFactory(&f); } ~ModuleRLine() override { ServerInstance->XLines->DelAll("R"); ServerInstance->XLines->UnregisterFactory(&f); } void GetLinkData(LinkData& data, std::string& compatdata) override { if (rxfactory) { compatdata = rxfactory->name; // e.g. regex/pcre data["regex"] = rxfactory->GetName(); // e.g. pcre } else data["regex"] = "broken"; } ModResult OnUserRegister(LocalUser* user) override { // Apply lines on user connect XLine* rl = ServerInstance->XLines->MatchesLine("R", user); if (rl) { // Bang. :P rl->Apply(user); return MOD_RES_DENY; } return MOD_RES_PASSTHRU; } void ReadConfig(ConfigStatus& status) override { const auto& tag = ServerInstance->Config->ConfValue("rline"); MatchOnNickChange = tag->getBool("matchonnickchange"); ZlineOnMatch = tag->getBool("zlineonmatch"); std::string newrxengine = tag->getString("engine"); factory = rxfactory ? (rxfactory.operator->()) : nullptr; rxfactory.SetEngine(newrxengine); if (!rxfactory) { if (newrxengine.empty()) ServerInstance->SNO.WriteToSnoMask('r', "WARNING: No regex engine loaded - R-line functionality disabled until this is corrected."); else ServerInstance->SNO.WriteToSnoMask('r', "WARNING: Regex engine '{}' is not loaded - R-line functionality disabled until this is corrected.", newrxengine); ServerInstance->XLines->DelAll(f.GetType()); } else if ((!initing) && (rxfactory.operator->() != factory)) { ServerInstance->SNO.WriteToSnoMask('r', "Regex engine has changed, removing all R-lines."); ServerInstance->XLines->DelAll(f.GetType()); } initing = false; } ModResult OnStats(Stats::Context& stats) override { if (stats.GetSymbol() != 'R') return MOD_RES_PASSTHRU; ServerInstance->XLines->InvokeStats("R", stats); return MOD_RES_DENY; } void OnUserPostNick(User* user, const std::string& oldnick) override { if (!IS_LOCAL(user)) return; if (!MatchOnNickChange) return; XLine* rl = ServerInstance->XLines->MatchesLine("R", user); if (rl) { // Bang! :D rl->Apply(user); } } void OnBackgroundTimer(time_t curtime) override { if (added_zline) { added_zline = false; ServerInstance->XLines->ApplyLines(); } } void OnUnloadModule(Module* mod) override { // If the regex engine became unavailable or has changed, remove all R-lines. if (!rxfactory) { ServerInstance->XLines->DelAll(f.GetType()); } else if (rxfactory.operator->() != factory) { factory = rxfactory.operator->(); ServerInstance->XLines->DelAll(f.GetType()); } } void Prioritize() override { Module* mod = ServerInstance->Modules.Find("gateway"); ServerInstance->Modules.SetPriority(this, I_OnUserRegister, PRIORITY_AFTER, mod); } }; MODULE_INIT(ModuleRLine) ����������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/src/modules/m_rmode.cpp��������������������������������������������������������������0000664�0000000�0000000�00000006636�14771603147�0017747�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2017, 2019-2024 Sadie Powell <sadie@witchery.services> * Copyright (C) 2013-2014 Attila Molnar <attilamolnar@hush.com> * Copyright (C) 2013 Daniel Vassdal <shutter@canternet.org> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include "inspircd.h" #include "listmode.h" #include "numerichelper.h" class CommandRMode final : public Command { private: static ModeHandler* FindMode(const std::string& mode) { if (mode.length() == 1) { ModeHandler* mh = ServerInstance->Modes.FindMode(mode[0], MODETYPE_CHANNEL); if (!mh) mh = ServerInstance->Modes.FindPrefix(mode[0]); return mh; } return ServerInstance->Modes.FindMode(mode, MODETYPE_CHANNEL); } public: CommandRMode(Module* Creator) : Command(Creator, "RMODE", 2, 3) { syntax = { "<channel> <mode> [<pattern>]" }; } CmdResult Handle(User* user, const Params& parameters) override { auto* chan = ServerInstance->Channels.Find(parameters[0]); if (!chan) { user->WriteNumeric(Numerics::NoSuchChannel(parameters[0])); return CmdResult::FAILURE; } ModeHandler* mh = FindMode(parameters[1]); if (!mh) { user->WriteNumeric(ERR_UNKNOWNMODE, parameters[1], "is not a recognised channel mode."); return CmdResult::FAILURE; } if (chan->GetPrefixValue(user) < mh->GetLevelRequired(false)) { user->WriteNumeric(Numerics::ChannelPrivilegesNeeded(chan, mh->GetLevelRequired(false), INSP_FORMAT("unset channel mode {} ({})", mh->GetModeChar(), mh->name))); return CmdResult::FAILURE; } std::string pattern = parameters.size() > 2 ? parameters[2] : "*"; PrefixMode* pm; ListModeBase* lm; ListModeBase::ModeList* ml; Modes::ChangeList changelist; if ((pm = mh->IsPrefixMode())) { // As user prefix modes don't have a GetList() method, let's iterate through the channel's users. for (const auto& [u, memb] : chan->GetUsers()) { if (!InspIRCd::Match(u->nick, pattern)) continue; if (memb->HasMode(pm) && !((u == user) && (pm->GetPrefixRank() > VOICE_VALUE))) changelist.push_remove(mh, u->nick); } } else if ((lm = mh->IsListModeBase()) && ((ml = lm->GetList(chan)) != nullptr)) { auto* targuser = parameters.size() > 2 ? ServerInstance->Users.FindNick(parameters[2]) : nullptr; for (const auto& entry : *ml) { if (targuser ? chan->CheckBan(targuser, entry.mask) : InspIRCd::Match(entry.mask, pattern)) changelist.push_remove(mh, entry.mask); } } else { if (chan->IsModeSet(mh)) changelist.push_remove(mh); } ServerInstance->Modes.Process(user, chan, nullptr, changelist); return CmdResult::SUCCESS; } }; class ModuleRMode final : public Module { private: CommandRMode cmd; public: ModuleRMode() : Module(VF_VENDOR, "Allows removal of channel list modes using glob patterns.") , cmd(this) { } }; MODULE_INIT(ModuleRMode) ��������������������������������������������������������������������������������������������������inspircd-4.7.0/src/modules/m_sajoin.cpp�������������������������������������������������������������0000664�0000000�0000000�00000010134�14771603147�0020110�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2019-2023 Sadie Powell <sadie@witchery.services> * Copyright (C) 2013-2014, 2016 Attila Molnar <attilamolnar@hush.com> * Copyright (C) 2013 Daniel Vassdal <shutter@canternet.org> * Copyright (C) 2012, 2019 Robby <robby@chatbelgie.be> * Copyright (C) 2009 Daniel De Graaf <danieldg@inspircd.org> * Copyright (C) 2007 Dennis Friis <peavey@inspircd.org> * Copyright (C) 2007 Craig Edwards <brain@inspircd.org> * Copyright (C) 2006 jamie * Copyright (C) 2005 Robin Burchell <robin+git@viroteck.net> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include "inspircd.h" class CommandSajoin final : public Command { private: UserModeReference servprotectmode; public: CommandSajoin(Module* Creator) : Command(Creator, "SAJOIN", 1) , servprotectmode(Creator, "servprotect") { access_needed = CmdAccess::OPERATOR; syntax = { "[<nick>] <channel>[,<channel>]+" }; translation = { TR_NICK, TR_TEXT }; } CmdResult Handle(User* user, const Params& parameters) override { const unsigned int channelindex = (parameters.size() > 1) ? 1 : 0; if (CommandParser::LoopCall(user, this, parameters, channelindex)) return CmdResult::FAILURE; const std::string& channel = parameters[channelindex]; const std::string& nickname = parameters.size() > 1 ? parameters[0] : user->nick; auto* dest = ServerInstance->Users.Find(nickname, true); if (dest) { if (user != dest && !user->HasPrivPermission("users/sajoin-others")) { user->WriteNotice("*** You are not allowed to /SAJOIN other users (the privilege users/sajoin-others is needed to /SAJOIN others)."); return CmdResult::FAILURE; } if (dest->IsModeSet(servprotectmode)) { user->WriteNumeric(ERR_NOPRIVILEGES, "Cannot use an SA command on a service"); return CmdResult::FAILURE; } if (IS_LOCAL(user) && !ServerInstance->Channels.IsChannel(channel)) { /* we didn't need to check this for each character ;) */ user->WriteNumeric(ERR_BADCHANMASK, channel, "Invalid channel name"); return CmdResult::FAILURE; } auto* chan = ServerInstance->Channels.Find(channel); if ((chan) && (chan->HasUser(dest))) { user->WriteRemoteNotice("*** " + dest->nick + " is already on " + channel); return CmdResult::FAILURE; } /* For local users, we call Channel::JoinUser which may create a channel and set its TS. * For non-local users, we just return CmdResult::SUCCESS, knowing this will propagate it where it needs to be * and then that server will handle the command. */ LocalUser* localuser = IS_LOCAL(dest); if (localuser) { Membership* memb = Channel::JoinUser(localuser, channel, true); if (memb) { ServerInstance->SNO.WriteGlobalSno('a', user->nick+" used SAJOIN to make "+dest->nick+" join "+channel); return CmdResult::SUCCESS; } else { user->WriteNotice("*** Could not join "+dest->nick+" to "+channel); return CmdResult::FAILURE; } } else { return CmdResult::SUCCESS; } } else { user->WriteNotice("*** No such nickname: '" + nickname + "'"); return CmdResult::FAILURE; } } RouteDescriptor GetRouting(User* user, const Params& parameters) override { return ROUTE_OPT_UCAST(parameters[0]); } }; class ModuleSajoin final : public Module { private: CommandSajoin cmd; public: ModuleSajoin() : Module(VF_VENDOR | VF_OPTCOMMON, "Adds the /SAJOIN command which allows server operators to force users to join one or more channels.") , cmd(this) { } }; MODULE_INIT(ModuleSajoin) ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/src/modules/m_sakick.cpp�������������������������������������������������������������0000664�0000000�0000000�00000006027�14771603147�0020100�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2013, 2019-2023 Sadie Powell <sadie@witchery.services> * Copyright (C) 2013, 2016 Attila Molnar <attilamolnar@hush.com> * Copyright (C) 2012 Robby <robby@chatbelgie.be> * Copyright (C) 2009 John Brooks <john@jbrooks.io> * Copyright (C) 2009 Daniel De Graaf <danieldg@inspircd.org> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include "inspircd.h" class CommandSakick final : public Command { private: UserModeReference servprotectmode; public: CommandSakick(Module* Creator) : Command(Creator, "SAKICK", 2, 3) , servprotectmode(Creator, "servprotect") { access_needed = CmdAccess::OPERATOR; allow_empty_last_param = true; syntax = { "<channel> <nick> [:<reason>]" }; translation = { TR_TEXT, TR_NICK, TR_TEXT }; } CmdResult Handle(User* user, const Params& parameters) override { auto* channel = ServerInstance->Channels.Find(parameters[0]); auto* dest = ServerInstance->Users.Find(parameters[1], true); if (channel && dest) { const std::string& reason = (parameters.size() > 2) ? parameters[2] : dest->nick; if (dest->IsModeSet(servprotectmode)) { user->WriteNumeric(ERR_NOPRIVILEGES, "Cannot use an SA command on a service"); return CmdResult::FAILURE; } if (!channel->HasUser(dest)) { user->WriteNotice("*** " + dest->nick + " is not on " + channel->name); return CmdResult::FAILURE; } /* For local clients, directly kick them. For remote clients, * just return CmdResult::SUCCESS knowing the protocol module will route the SAKICK to the user's * local server and that will kick them instead. */ if (IS_LOCAL(dest)) { // Target is on this server, kick them and send the snotice channel->KickUser(ServerInstance->FakeClient, dest, reason); ServerInstance->SNO.WriteGlobalSno('a', user->nick + " SAKICKed " + dest->nick + " on " + channel->name); } return CmdResult::SUCCESS; } else { user->WriteNotice("*** Invalid nickname or channel"); } return CmdResult::FAILURE; } RouteDescriptor GetRouting(User* user, const Params& parameters) override { return ROUTE_OPT_UCAST(parameters[1]); } }; class ModuleSakick final : public Module { private: CommandSakick cmd; public: ModuleSakick() : Module(VF_VENDOR | VF_OPTCOMMON, "Adds the /SAKICK command which allows server operators to kick users from a channel without having any privileges in the channel.") , cmd(this) { } }; MODULE_INIT(ModuleSakick) ���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/src/modules/m_samode.cpp�������������������������������������������������������������0000664�0000000�0000000�00000010433�14771603147�0020077�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2018-2023 Sadie Powell <sadie@witchery.services> * Copyright (C) 2013-2014, 2016, 2018 Attila Molnar <attilamolnar@hush.com> * Copyright (C) 2013 Daniel Vassdal <shutter@canternet.org> * Copyright (C) 2012 Robby <robby@chatbelgie.be> * Copyright (C) 2009 Daniel De Graaf <danieldg@inspircd.org> * Copyright (C) 2006 Craig Edwards <brain@inspircd.org> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include "inspircd.h" #include "clientprotocolmsg.h" #include "numerichelper.h" #include "utility/string.h" class CommandSamode final : public Command { bool logged; public: bool active; CommandSamode(Module* Creator) : Command(Creator, "SAMODE", 2) { access_needed = CmdAccess::OPERATOR; syntax = { "<target> (+|-)<modes> [<mode-parameters>]" }; active = false; } CmdResult Handle(User* user, const Params& parameters) override { if (!ServerInstance->Channels.IsPrefix(parameters[0][0])) { auto* target = ServerInstance->Users.FindNick(parameters[0], true); if (!target) { user->WriteNumeric(Numerics::NoSuchNick(parameters[0])); return CmdResult::FAILURE; } // Changing the modes of another user requires a special permission if ((target != user) && (!user->HasPrivPermission("users/samode-usermodes"))) { user->WriteNotice("*** You are not allowed to /SAMODE other users (the privilege users/samode-usermodes is needed to /SAMODE others)."); return CmdResult::FAILURE; } } // XXX: Make ModeParser clear LastParse Modes::ChangeList emptychangelist; ServerInstance->Modes.ProcessSingle(ServerInstance->FakeClient, nullptr, ServerInstance->FakeClient, emptychangelist); logged = false; this->active = true; ServerInstance->Parser.CallHandler("MODE", parameters, user); this->active = false; if (!logged) { // If we haven't logged anything yet then the client queried the list of a listmode // (e.g. /SAMODE #chan b), which was handled internally by the MODE command handler. // // Viewing the modes of a user or a channel could also result in this, but // that is not possible with /SAMODE because we require at least 2 parameters. LogUsage(user, insp::join(parameters)); } return CmdResult::SUCCESS; } void LogUsage(const User* user, const std::string& text) { logged = true; ServerInstance->SNO.WriteGlobalSno('a', user->nick + " used SAMODE: " + text); } }; class ModuleSaMode final : public Module { private: CommandSamode cmd; public: ModuleSaMode() : Module(VF_VENDOR, "Adds the /SAMODE command which allows server operators to change the modes of a target (channel, user) that they would not otherwise have the privileges to change.") , cmd(this) { } ModResult OnPreMode(User* source, User* dest, Channel* channel, Modes::ChangeList& modes) override { if (cmd.active) return MOD_RES_ALLOW; return MOD_RES_PASSTHRU; } void OnMode(User* user, User* destuser, Channel* destchan, const Modes::ChangeList& modes, ModeParser::ModeProcessFlag processflags) override { if (!cmd.active) return; std::string logtext = (destuser ? destuser->nick : destchan->name); logtext.push_back(' '); logtext += ClientProtocol::Messages::Mode::ToModeLetters(modes); for (const auto& item : modes.getlist()) { if (!item.param.empty()) logtext.append(1, ' ').append(item.param); } cmd.LogUsage(user, logtext); } void Prioritize() override { Module* disable = ServerInstance->Modules.Find("disable"); ServerInstance->Modules.SetPriority(this, I_OnRawMode, PRIORITY_BEFORE, disable); Module* override = ServerInstance->Modules.Find("override"); ServerInstance->Modules.SetPriority(this, I_OnPreMode, PRIORITY_BEFORE, override); } }; MODULE_INIT(ModuleSaMode) �������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/src/modules/m_sanick.cpp�������������������������������������������������������������0000664�0000000�0000000�00000005731�14771603147�0020104�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2016 Attila Molnar <attilamolnar@hush.com> * Copyright (C) 2013, 2019-2023 Sadie Powell <sadie@witchery.services> * Copyright (C) 2012, 2019 Robby <robby@chatbelgie.be> * Copyright (C) 2009 Daniel De Graaf <danieldg@inspircd.org> * Copyright (C) 2008 Robin Burchell <robin+git@viroteck.net> * Copyright (C) 2007, 2009 Dennis Friis <peavey@inspircd.org> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include "inspircd.h" class CommandSanick final : public Command { private: UserModeReference servprotectmode; public: CommandSanick(Module* Creator) : Command(Creator, "SANICK", 2) , servprotectmode(Creator, "servprotect") { access_needed = CmdAccess::OPERATOR; syntax = { "<nick> <newnick>" }; translation = { TR_NICK, TR_TEXT }; } CmdResult Handle(User* user, const Params& parameters) override { auto* target = ServerInstance->Users.Find(parameters[0], true); /* Do local sanity checks and bails */ if (IS_LOCAL(user)) { if (target && target->IsModeSet(servprotectmode)) { user->WriteNumeric(ERR_NOPRIVILEGES, "Cannot use an SA command on a service"); return CmdResult::FAILURE; } if (!target) { user->WriteNotice("*** No such nickname: '" + parameters[0] + "'"); return CmdResult::FAILURE; } if (!ServerInstance->IsNick(parameters[1])) { user->WriteNotice("*** Invalid nickname: '" + parameters[1] + "'"); return CmdResult::FAILURE; } } /* Have we hit target's server yet? */ if (target && IS_LOCAL(target)) { const std::string oldnick = target->nick; const std::string& newnick = parameters[1]; if (!ServerInstance->Users.FindNick(newnick) && target->ChangeNick(newnick)) { ServerInstance->SNO.WriteGlobalSno('a', user->nick + " used SANICK to change " + oldnick + " to " + newnick); } else { ServerInstance->SNO.WriteGlobalSno('a', user->nick + " failed SANICK (from " + oldnick + " to " + newnick + ")"); } } return CmdResult::SUCCESS; } RouteDescriptor GetRouting(User* user, const Params& parameters) override { return ROUTE_OPT_UCAST(parameters[0]); } }; class ModuleSanick final : public Module { private: CommandSanick cmd; public: ModuleSanick() : Module(VF_VENDOR | VF_OPTCOMMON, "Adds the /SANICK command which allows server operators to change the nickname of a user.") , cmd(this) { } }; MODULE_INIT(ModuleSanick) ���������������������������������������inspircd-4.7.0/src/modules/m_sapart.cpp�������������������������������������������������������������0000664�0000000�0000000�00000006340�14771603147�0020123�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2013-2014, 2016 Attila Molnar <attilamolnar@hush.com> * Copyright (C) 2013, 2019-2023 Sadie Powell <sadie@witchery.services> * Copyright (C) 2012 Robby <robby@chatbelgie.be> * Copyright (C) 2009 Daniel De Graaf <danieldg@inspircd.org> * Copyright (C) 2008 Robin Burchell <robin+git@viroteck.net> * Copyright (C) 2007-2008 Craig Edwards <brain@inspircd.org> * Copyright (C) 2007 Dennis Friis <peavey@inspircd.org> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include "inspircd.h" class CommandSapart final : public Command { private: UserModeReference servprotectmode; public: CommandSapart(Module* Creator) : Command(Creator, "SAPART", 2, 3) , servprotectmode(Creator, "servprotect") { access_needed = CmdAccess::OPERATOR; allow_empty_last_param = true; syntax = { "<nick> <channel>[,<channel>]+ [:<reason>]" }; translation = { TR_NICK, TR_TEXT, TR_TEXT }; } CmdResult Handle(User* user, const Params& parameters) override { if (CommandParser::LoopCall(user, this, parameters, 1)) return CmdResult::FAILURE; auto* dest = ServerInstance->Users.Find(parameters[0], true); auto* channel = ServerInstance->Channels.Find(parameters[1]); if (dest && channel) { std::string reason; if (parameters.size() > 2) reason = parameters[2]; if (dest->IsModeSet(servprotectmode)) { user->WriteNumeric(ERR_NOPRIVILEGES, "Cannot use an SA command on a service"); return CmdResult::FAILURE; } if (!channel->HasUser(dest)) { user->WriteNotice("*** " + dest->nick + " is not on " + channel->name); return CmdResult::FAILURE; } /* For local clients, directly part them generating a PART message. For remote clients, * just return CmdResult::SUCCESS knowing the protocol module will route the SAPART to the users * local server and that will generate the PART instead */ if (IS_LOCAL(dest)) { channel->PartUser(dest, reason); ServerInstance->SNO.WriteGlobalSno('a', user->nick+" used SAPART to make "+dest->nick+" part "+channel->name); } return CmdResult::SUCCESS; } else { user->WriteNotice("*** Invalid nickname or channel"); } return CmdResult::FAILURE; } RouteDescriptor GetRouting(User* user, const Params& parameters) override { return ROUTE_OPT_UCAST(parameters[0]); } }; class ModuleSapart final : public Module { private: CommandSapart cmd; public: ModuleSapart() : Module(VF_VENDOR | VF_OPTCOMMON, "Adds the /SAPART command which allows server operators to force part users from one or more channels without having any privileges in these channels.") , cmd(this) { } }; MODULE_INIT(ModuleSapart) ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/src/modules/m_saquit.cpp�������������������������������������������������������������0000664�0000000�0000000�00000005311�14771603147�0020134�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2019-2023 Sadie Powell <sadie@witchery.services> * Copyright (C) 2016 Attila Molnar <attilamolnar@hush.com> * Copyright (C) 2012, 2019 Robby <robby@chatbelgie.be> * Copyright (C) 2009 Thomas Stagner <aquanight@gmail.com> * Copyright (C) 2009 Daniel De Graaf <danieldg@inspircd.org> * Copyright (C) 2008 Robin Burchell <robin+git@viroteck.net> * Copyright (C) 2007 John Brooks <john@jbrooks.io> * Copyright (C) 2007 Dennis Friis <peavey@inspircd.org> * Copyright (C) 2007 Craig Edwards <brain@inspircd.org> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include "inspircd.h" class CommandSaquit final : public Command { private: UserModeReference servprotectmode; public: CommandSaquit(Module* Creator) : Command(Creator, "SAQUIT", 2, 2) , servprotectmode(Creator, "servprotect") { access_needed = CmdAccess::OPERATOR; syntax = { "<nick> :<reason>" }; translation = { TR_NICK, TR_TEXT }; } CmdResult Handle(User* user, const Params& parameters) override { auto* dest = ServerInstance->Users.Find(parameters[0], true); if (dest) { if (dest->IsModeSet(servprotectmode)) { user->WriteNumeric(ERR_NOPRIVILEGES, "Cannot use an SA command on a service"); return CmdResult::FAILURE; } // Pass the command on, so the client's server can quit it properly. if (!IS_LOCAL(dest)) return CmdResult::SUCCESS; ServerInstance->SNO.WriteGlobalSno('a', user->nick+" used SAQUIT to make "+dest->nick+" quit with a reason of "+parameters[1]); ServerInstance->Users.QuitUser(dest, parameters[1]); return CmdResult::SUCCESS; } else { user->WriteNotice("*** Invalid nickname: '" + parameters[0] + "'"); return CmdResult::FAILURE; } } RouteDescriptor GetRouting(User* user, const Params& parameters) override { return ROUTE_OPT_UCAST(parameters[0]); } }; class ModuleSaquit final : public Module { private: CommandSaquit cmd; public: ModuleSaquit() : Module(VF_VENDOR | VF_OPTCOMMON, "Adds the /SAQUIT command which allows server operators to disconnect users from the server.") , cmd(this) { } }; MODULE_INIT(ModuleSaquit) �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/src/modules/m_sasl.cpp���������������������������������������������������������������0000664�0000000�0000000�00000026327�14771603147�0017602�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2021 Herman <GermanAizek@yandex.ru> * Copyright (C) 2016 Adam <Adam@anope.org> * Copyright (C) 2014 Mantas MikulФ—nas <grawity@gmail.com> * Copyright (C) 2013, 2017-2024 Sadie Powell <sadie@witchery.services> * Copyright (C) 2013, 2015-2016, 2018 Attila Molnar <attilamolnar@hush.com> * Copyright (C) 2013 Daniel Vassdal <shutter@canternet.org> * Copyright (C) 2012 Robby <robby@chatbelgie.be> * Copyright (C) 2009-2010 Daniel De Graaf <danieldg@inspircd.org> * Copyright (C) 2008 Thomas Stagner <aquanight@gmail.com> * Copyright (C) 2008 Craig Edwards <brain@inspircd.org> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include "inspircd.h" #include "modules/account.h" #include "modules/cap.h" #include "modules/server.h" #include "modules/ssl.h" enum { // From IRCv3 sasl-3.1 RPL_SASLSUCCESS = 903, ERR_SASLFAIL = 904, ERR_SASLTOOLONG = 905, ERR_SASLABORTED = 906, RPL_SASLMECHS = 908 }; static std::string sasl_target; class ServerTracker final : public ServerProtocol::LinkEventListener { private: bool online; void Update(const Server* server, bool linked) { if (sasl_target == "*") return; if (InspIRCd::Match(server->GetName(), sasl_target)) { ServerInstance->Logs.Debug(MODNAME, "SASL target server \"{}\" {}", sasl_target, (linked ? "came online" : "went offline")); online = linked; } } void OnServerLink(const Server* server) override { Update(server, true); } void OnServerSplit(const Server* server, bool error) override { Update(server, false); } public: ServerTracker(Module* mod) : ServerProtocol::LinkEventListener(mod) { Reset(); } void Reset() { if (sasl_target == "*") { online = true; return; } online = false; ProtocolInterface::ServerList servers; ServerInstance->PI->GetServerList(servers); for (const auto& server : servers) { if (InspIRCd::Match(server.servername, sasl_target)) { online = true; break; } } } bool IsOnline() const { return online; } }; class SASLCap final : public Cap::Capability { private: std::string mechlist; const ServerTracker& servertracker; UserCertificateAPI sslapi; bool OnRequest(LocalUser* user, bool adding) override { // Servers MUST NAK any sasl capability request if the authentication layer // is unavailable. return OnList(user); } bool OnList(LocalUser* user) override { if (requiressl && sslapi && !sslapi->IsSecure(user)) return false; // Servers MUST NOT advertise the sasl capability if the authentication layer // is unavailable. return servertracker.IsOnline(); } const std::string* GetValue(LocalUser* user) const override { return &mechlist; } public: bool requiressl; SASLCap(Module* mod, const ServerTracker& tracker) : Cap::Capability(mod, "sasl") , servertracker(tracker) , sslapi(mod) { } void SetMechlist(const std::string& newmechlist) { if (mechlist == newmechlist) return; mechlist = newmechlist; NotifyValueChange(); } }; enum SaslState { SASL_INIT, SASL_COMM, SASL_DONE }; enum SaslResult { SASL_OK, SASL_FAIL, SASL_ABORT }; static void SendSASL(LocalUser* user, const std::string& agent, char mode, const std::vector<std::string>& parameters) { CommandBase::Params params; params.push_back(user->uuid); params.push_back(agent); params.push_back(ConvToStr(mode)); params.insert(params.end(), parameters.begin(), parameters.end()); ServerInstance->PI->SendEncapsulatedData(sasl_target, "SASL", params); } static ClientProtocol::EventProvider* g_protoev; /** * Tracks SASL authentication state like charybdis does. --nenolod */ class SaslAuthenticator final { private: std::string agent; LocalUser* user; SaslState state = SASL_INIT; SaslResult result; bool state_announced = false; void SendHostIP(UserCertificateAPI& sslapi) { std::vector<std::string> params; params.reserve(3); params.push_back(user->GetRealHost()); params.push_back(user->GetAddress()); params.emplace_back(sslapi && sslapi->IsSecure(user) ? "S" : "P"); SendSASL(user, "*", 'H', params); } public: SaslAuthenticator(LocalUser* user_, const std::string& method, UserCertificateAPI& sslapi) : user(user_) { SendHostIP(sslapi); std::vector<std::string> params; params.push_back(method); if (sslapi) { for (const auto& fingerprint : sslapi->GetFingerprints(user)) params.push_back(fingerprint); } SendSASL(user, "*", 'S', params); } static SaslResult GetSaslResult(const std::string& result_) { if (result_ == "F") return SASL_FAIL; if (result_ == "A") return SASL_ABORT; return SASL_OK; } /* checks for and deals with a state change. */ SaslState ProcessInboundMessage(const CommandBase::Params& msg) { switch (this->state) { case SASL_INIT: this->agent = msg[0]; this->state = SASL_COMM; [[fallthrough]]; case SASL_COMM: if (msg[0] != this->agent) return this->state; if (msg.size() < 4) return this->state; if (msg[2] == "C") { LocalUser* const localuser = IS_LOCAL(user); if (localuser) { ClientProtocol::Message authmsg("AUTHENTICATE"); authmsg.PushParamRef(msg[3]); ClientProtocol::Event authevent(*g_protoev, authmsg); localuser->Send(authevent); } } else if (msg[2] == "D") { this->state = SASL_DONE; this->result = GetSaslResult(msg[3]); } else if (msg[2] == "M") this->user->WriteNumeric(RPL_SASLMECHS, msg[3], "are available SASL mechanisms"); else ServerInstance->Logs.Debug(MODNAME, "Services sent an unknown SASL message \"{}\" \"{}\"", msg[2], msg[3]); break; case SASL_DONE: break; } return this->state; } void Abort() { this->state = SASL_DONE; this->result = SASL_ABORT; } bool SendClientMessage(const std::vector<std::string>& parameters) { if (this->state != SASL_COMM) return true; SendSASL(this->user, this->agent, 'C', parameters); if (parameters.empty() || parameters[0] == "*") { this->Abort(); return false; } return true; } void AnnounceState() { if (this->state_announced) return; switch (this->result) { case SASL_OK: this->user->WriteNumeric(RPL_SASLSUCCESS, "SASL authentication successful"); break; case SASL_ABORT: this->user->WriteNumeric(ERR_SASLABORTED, "SASL authentication aborted"); break; case SASL_FAIL: this->user->WriteNumeric(ERR_SASLFAIL, "SASL authentication failed"); break; } this->state_announced = true; } }; class CommandAuthenticate final : public SplitCommand { private: // The maximum length of an AUTHENTICATE request. static constexpr size_t MAX_AUTHENTICATE_SIZE = 400; public: SimpleExtItem<SaslAuthenticator>& authExt; Cap::Capability& cap; UserCertificateAPI sslapi; CommandAuthenticate(Module* Creator, SimpleExtItem<SaslAuthenticator>& ext, Cap::Capability& Cap) : SplitCommand(Creator, "AUTHENTICATE", 1) , authExt(ext) , cap(Cap) , sslapi(Creator) { works_before_reg = true; } CmdResult HandleLocal(LocalUser* user, const Params& parameters) override { { if (!cap.IsEnabled(user)) { user->WriteNumeric(ERR_UNKNOWNCOMMAND, name, "You must request the sasl capability to use this command"); return CmdResult::FAILURE; } if (parameters[0].find(' ') != std::string::npos || parameters[0][0] == ':') { user->WriteNumeric(ERR_SASLABORTED, "SASL authentication aborted"); return CmdResult::FAILURE; } if (parameters[0].length() > MAX_AUTHENTICATE_SIZE) { user->WriteNumeric(ERR_SASLTOOLONG, "SASL message too long"); return CmdResult::FAILURE; } SaslAuthenticator* sasl = authExt.Get(user); if (!sasl) authExt.SetFwd(user, user, parameters[0], sslapi); else if (!sasl->SendClientMessage(parameters)) { sasl->AnnounceState(); authExt.Unset(user); } } return CmdResult::FAILURE; } }; class CommandSASL final : public Command { public: SimpleExtItem<SaslAuthenticator>& authExt; CommandSASL(Module* Creator, SimpleExtItem<SaslAuthenticator>& ext) : Command(Creator, "SASL", 2) , authExt(ext) { this->access_needed = CmdAccess::SERVER; // should not be called by users } CmdResult Handle(User* user, const Params& parameters) override { auto* target = ServerInstance->Users.FindUUID(parameters[1]); if (!target) { ServerInstance->Logs.Debug(MODNAME, "User not found in sasl ENCAP event: {}", parameters[1]); return CmdResult::FAILURE; } SaslAuthenticator* sasl = authExt.Get(target); if (!sasl) return CmdResult::FAILURE; SaslState state = sasl->ProcessInboundMessage(parameters); if (state == SASL_DONE) { sasl->AnnounceState(); authExt.Unset(target); } return CmdResult::SUCCESS; } RouteDescriptor GetRouting(User* user, const Params& parameters) override { return ROUTE_BROADCAST; } }; class ModuleSASL final : public Module { private: SimpleExtItem<SaslAuthenticator> authExt; ServerTracker servertracker; SASLCap cap; CommandAuthenticate auth; CommandSASL sasl; ClientProtocol::EventProvider protoev; public: ModuleSASL() : Module(VF_VENDOR, "Provides the IRCv3 sasl client capability.") , authExt(this, "sasl-state", ExtensionType::USER) , servertracker(this) , cap(this, servertracker) , auth(this, authExt, cap) , sasl(this, authExt) , protoev(this, auth.name) { g_protoev = &protoev; } void init() override { if (!ServerInstance->Modules.Find("account") || !ServerInstance->Modules.Find("cap")) ServerInstance->Logs.Normal(MODNAME, "WARNING: the cap and services modules are not loaded! The sasl module will NOT function correctly until these two modules are loaded!"); } void ReadConfig(ConfigStatus& status) override { const auto& tag = ServerInstance->Config->ConfValue("sasl"); const std::string target = tag->getString("target"); if (target.empty()) throw ModuleException(this, "<sasl:target> must be set to the name of your services server!"); cap.requiressl = tag->getBool("requiressl"); sasl_target = target; servertracker.Reset(); } void OnUserConnect(LocalUser* user) override { // If the client completes connection (with CAP END, NICK, USER and // any other necessary messages) while the SASL authentication is still // in progress, the server SHOULD abort it and send a 906 numeric, then // register the client without authentication. SaslAuthenticator* saslauth = authExt.Get(user); if (saslauth && cap.GetProtocol(user) == Cap::CAP_LEGACY) { saslauth->Abort(); saslauth->AnnounceState(); authExt.Unset(user); } } void OnDecodeMetadata(Extensible* target, const std::string& extname, const std::string& extdata) override { if (!target && irc::equals(extname, "saslmechlist")) cap.SetMechlist(extdata); } }; MODULE_INIT(ModuleSASL) ���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/src/modules/m_satopic.cpp������������������������������������������������������������0000664�0000000�0000000�00000005032�14771603147�0020270�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2019-2024 Sadie Powell <sadie@witchery.services> * Copyright (C) 2017 B00mX0r <b00mx0r@aureus.pw> * Copyright (C) 2016 Attila Molnar <attilamolnar@hush.com> * Copyright (C) 2012 Robby <robby@chatbelgie.be> * Copyright (C) 2009 Uli Schlachter <psychon@znc.in> * Copyright (C) 2009 Daniel De Graaf <danieldg@inspircd.org> * Copyright (C) 2008 Robin Burchell <robin+git@viroteck.net> * Copyright (C) 2008 Oliver Lupton <om@inspircd.org> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include "inspircd.h" #include "numerichelper.h" class CommandSATopic final : public Command { public: CommandSATopic(Module* Creator) : Command(Creator, "SATOPIC", 2, 2) { access_needed = CmdAccess::OPERATOR; allow_empty_last_param = true; syntax = { "<channel> :<topic>" }; } CmdResult Handle(User* user, const Params& parameters) override { /* * Handles a SATOPIC request. Notifies all +s users. */ auto* target = ServerInstance->Channels.Find(parameters[0]); if(target) { const std::string newTopic(parameters[1], 0, ServerInstance->Config->Limits.MaxTopic); if (target->topic == newTopic) { user->WriteNotice("The topic on {} is already what ou are trying to change it to.", target->name); return CmdResult::SUCCESS; } target->SetTopic(user, newTopic, ServerInstance->Time(), nullptr); ServerInstance->SNO.WriteGlobalSno('a', user->nick + " used SATOPIC on " + target->name + ", new topic: " + newTopic); return CmdResult::SUCCESS; } else { user->WriteNumeric(Numerics::NoSuchChannel(parameters[0])); return CmdResult::FAILURE; } } }; class ModuleSATopic final : public Module { private: CommandSATopic cmd; public: ModuleSATopic() : Module(VF_VENDOR, "Adds the /SATOPIC command which allows server operators to change the topic of a channel that they would not otherwise have the privileges to change.") , cmd(this) { } }; MODULE_INIT(ModuleSATopic) ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/src/modules/m_securelist.cpp���������������������������������������������������������0000664�0000000�0000000�00000014462�14771603147�0021017�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2021 Dominic Hamon * Copyright (C) 2018-2025 Sadie Powell <sadie@witchery.services> * Copyright (C) 2018 linuxdaemon <linuxdaemon.irc@gmail.com> * Copyright (C) 2013, 2016 Attila Molnar <attilamolnar@hush.com> * Copyright (C) 2012 Robby <robby@chatbelgie.be> * Copyright (C) 2009 Daniel De Graaf <danieldg@inspircd.org> * Copyright (C) 2007-2008 Craig Edwards <brain@inspircd.org> * Copyright (C) 2007 Robin Burchell <robin+git@viroteck.net> * Copyright (C) 2007 Dennis Friis <peavey@inspircd.org> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include "inspircd.h" #include "modules/account.h" #include "modules/isupport.h" #include "timeutils.h" typedef std::vector<std::string> AllowList; class ModuleSecureList final : public Module , public ISupport::EventListener { private: Account::API accountapi; AllowList allowlist; bool exemptregistered; unsigned long fakechans; std::string fakechanprefix; std::string fakechantopic; size_t hidesmallchans; bool sendingfakelist = false; bool showmsg; unsigned long waittime; bool IsExempt(User* user) { // Allow if the source is a privileged server operator. if (user->HasPrivPermission("servers/ignore-securelist")) return true; // Allow if the source is logged in and <securelist:exemptregistered> is set. if (exemptregistered && accountapi && accountapi->GetAccountName(user)) return true; // Allow if the source matches an <securehost> entry. for (const auto& allowhost : allowlist) { if (InspIRCd::Match(user->GetRealUserHost(), allowhost, ascii_case_insensitive_map)) return true; if (InspIRCd::Match(user->GetUserAddress(), allowhost, ascii_case_insensitive_map)) return true; } // The user does not appear to be exempt. return false; } public: ModuleSecureList() : Module(VF_VENDOR, "Prevents users from using the /LIST command until a predefined period has passed.") , ISupport::EventListener(this) , accountapi(this) { } void ReadConfig(ConfigStatus& status) override { AllowList newallows; for (const auto& [_, tag] : ServerInstance->Config->ConfTags("securehost")) { const std::string host = tag->getString("exception"); if (host.empty()) throw ModuleException(this, "<securehost:exception> is a required field at " + tag->source.str()); newallows.push_back(host); } const auto& tag = ServerInstance->Config->ConfValue("securelist"); exemptregistered = tag->getBool("exemptregistered", true); fakechans = tag->getNum<unsigned long>("fakechans", 5, 0); fakechanprefix = tag->getString("fakechanprefix", "#", 1, ServerInstance->Config->Limits.MaxChannel - 1); fakechantopic = tag->getString("fakechantopic", "Fake channel for confusing spambots", 1, ServerInstance->Config->Limits.MaxTopic - 1); hidesmallchans = tag->getNum<size_t>("hidesmallchans", 0); showmsg = tag->getBool("showmsg", true); waittime = tag->getDuration("waittime", 60, !exemptregistered, 60*60*24); allowlist.swap(newallows); } ModResult OnPreCommand(std::string& command, CommandBase::Params& parameters, LocalUser* user, bool validated) override { // Ignore unless the command is a validated LIST command from a non-exempt user. if (!validated || command != "LIST" || IsExempt(user)) return MOD_RES_PASSTHRU; // Allow if the wait time has passed. time_t maxwaittime = user->signon + waittime; if (waittime && ServerInstance->Time() > maxwaittime) return MOD_RES_PASSTHRU; // If <securehost:showmsg> is set then tell the user that they need to wait. if (showmsg) { if (waittime) { user->WriteNotice("*** You cannot view the channel list right now. Please {}try again in {}.", exemptregistered ? "log in to an account or " : "", Duration::ToLongString(maxwaittime - ServerInstance->Time())); } else { user->WriteNotice("*** You must be logged into an account to view the channel list."); } } // The client might be waiting on a response to do something so send them an // fake list response to satisfy that. size_t maxfakesuffix = ServerInstance->Config->Limits.MaxChannel - fakechanprefix.size(); sendingfakelist = true; user->WriteNumeric(RPL_LISTSTART, "Channel", "Users Name"); for (unsigned long fakechan = 0; fakechan < fakechans; ++fakechan) { // Generate the fake channel name. unsigned long chansuffixsize = ServerInstance->GenRandomInt(maxfakesuffix) + 1; const std::string chansuffix = ServerInstance->GenRandomStr(chansuffixsize); // Generate the fake channel size. unsigned long chanusers = ServerInstance->GenRandomInt(ServerInstance->Users.GetUsers().size()) + 1; // Generate the fake channel topic. std::string chantopic(fakechantopic); chantopic.insert(ServerInstance->GenRandomInt(chantopic.size()), 1, "\x02\x1D\x11\x1E\x1F"[fakechan % 5]); // Send the fake channel list entry. user->WriteNumeric(RPL_LIST, fakechanprefix + chansuffix, chanusers, chantopic); } user->WriteNumeric(RPL_LISTEND, "End of channel list."); sendingfakelist = false; return MOD_RES_DENY; } ModResult OnNumeric(User* user, const Numeric::Numeric& numeric) override { if (numeric.GetNumeric() != RPL_LIST || numeric.GetParams().size() < 2) return MOD_RES_PASSTHRU; // The numeric isn't the one we care about. if (sendingfakelist || IsExempt(user)) return MOD_RES_PASSTHRU; // This numeric should be shown even if too small. // If the channel has less than the minimum amount of users then hide it from /LIST. auto usercount = ConvToNum<size_t>(numeric.GetParams()[1]); return usercount < hidesmallchans ? MOD_RES_DENY : MOD_RES_PASSTHRU; } void OnBuildISupport(ISupport::TokenMap& tokens) override { if (showmsg) tokens["SECURELIST"] = ConvToStr(waittime); } }; MODULE_INIT(ModuleSecureList) ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/src/modules/m_seenicks.cpp�����������������������������������������������������������0000664�0000000�0000000�00000003035�14771603147�0020433�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2019-2021, 2025 Sadie Powell <sadie@witchery.services> * Copyright (C) 2012 Robby <robby@chatbelgie.be> * Copyright (C) 2009 Daniel De Graaf <danieldg@inspircd.org> * Copyright (C) 2007-2008 Craig Edwards <brain@inspircd.org> * Copyright (C) 2007 Dennis Friis <peavey@inspircd.org> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include "inspircd.h" class ModuleSeeNicks final : public Module { public: ModuleSeeNicks() : Module(VF_VENDOR, "Sends a notice to snomasks n (local) and N (remote) when a user changes their nickname.") { } void init() override { ServerInstance->SNO.EnableSnomask('n', "NICK"); } void OnUserPostNick(User* user, const std::string& oldnick) override { ServerInstance->SNO.WriteToSnoMask(IS_LOCAL(user) ? 'n' : 'N', "User {}!{} ({}) changed their nickname to {}", oldnick, user->GetRealUserHost(), user->GetAddress(), user->nick); } }; MODULE_INIT(ModuleSeeNicks) ���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/src/modules/m_serverban.cpp����������������������������������������������������������0000664�0000000�0000000�00000003145�14771603147�0020620�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2020-2021 Sadie Powell <sadie@witchery.services> * Copyright (C) 2012 Robby <robby@chatbelgie.be> * Copyright (C) 2009 Uli Schlachter <psychon@znc.in> * Copyright (C) 2009 Daniel De Graaf <danieldg@inspircd.org> * Copyright (C) 2008 Robin Burchell <robin+git@viroteck.net> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include "inspircd.h" #include "modules/extban.h" class ServerExtBan final : public ExtBan::MatchingBase { public: ServerExtBan(Module* Creator) : ExtBan::MatchingBase(Creator, "server", 's') { } bool IsMatch(User* user, Channel* channel, const std::string& text) override { return InspIRCd::Match(user->server->GetPublicName(), text); } }; class ModuleServerBan final : public Module { private: ServerExtBan extban; public: ModuleServerBan() : Module(VF_VENDOR | VF_OPTCOMMON, "Adds extended ban s: (server) which check whether users are on a server matching the specified glob pattern.") , extban(this) { } }; MODULE_INIT(ModuleServerBan) ���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/src/modules/m_services.cpp�����������������������������������������������������������0000664�0000000�0000000�00000045152�14771603147�0020460�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2022-2024 Sadie Powell <sadie@witchery.services> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include "inspircd.h" #include "listmode.h" #include "modules/account.h" #include "modules/ctctags.h" #include "modules/server.h" #include "modules/stats.h" #include "timeutils.h" #include "xline.h" enum { // From UnrealIRCd. ERR_KILLDENY = 485, // From Charybdis. ERR_MLOCKRESTRICTED = 742, // InspIRCd-specific. ERR_TOPICLOCK = 744, }; class RegisteredChannel final : public SimpleChannelMode { public: RegisteredChannel(Module* Creator) : SimpleChannelMode(Creator, "c_registered", 'r') { if (ServerInstance->Config->ConfValue("servicesintegration")->getBool("disablemodes")) DisableAutoRegister(); } bool OnModeChange(User* source, User* dest, Channel* channel, Modes::Change& change) override { if (IS_LOCAL(source)) { source->WriteNumeric(ERR_NOPRIVILEGES, INSP_FORMAT("Only a server may modify the +{} channel mode", GetModeChar())); return false; } return SimpleChannelMode::OnModeChange(source, dest, channel, change); } }; class RegisteredUser final : public SimpleUserMode { public: RegisteredUser(Module* Creator) : SimpleUserMode(Creator, "u_registered", 'r') { if (ServerInstance->Config->ConfValue("servicesintegration")->getBool("disablemodes")) DisableAutoRegister(); } bool OnModeChange(User* source, User* dest, Channel* channel, Modes::Change& change) override { if (IS_LOCAL(source)) { source->WriteNumeric(ERR_NOPRIVILEGES, INSP_FORMAT("Only a server may modify the +{} user mode", GetModeChar())); return false; } return SimpleUserMode::OnModeChange(source, dest, channel, change); } }; class ServiceTag final : public CTCTags::TagProvider { public: ServiceTag(Module* mod) : CTCTags::TagProvider(mod) { } void OnPopulateTags(ClientProtocol::Message& msg) override { const auto* user = msg.GetSourceUser(); if (user && user->server->IsService()) msg.AddTag("inspircd.org/service", this, ""); } }; class ServProtect final : public SimpleUserMode { public: ServProtect(Module* Creator) : SimpleUserMode(Creator, "servprotect", 'k', true) { } bool OnModeChange(User* source, User* dest, Channel* channel, Modes::Change& change) override { // As this mode is only intended for use by pseudoclients the only way // to set it is by introducing a user with it. return false; } }; class SVSHold final : public XLine { private: std::string nickname; public: SVSHold(time_t settime, unsigned long period, const std::string& setter, const std::string& message, const std::string& nick) : XLine(settime, period, setter, message, "SVSHOLD") , nickname(nick) { } void Apply(User* u) override { u->WriteNumeric(RPL_SAVENICK, u->nick, INSP_FORMAT("Services reserved nickname: {}", reason)); u->ChangeNick(u->uuid); } const std::string& Displayable() const override { return nickname; } void DisplayExpiry() override { // SVSHOLDs do not generate any messages. } bool Matches(User* user) const override { return irc::equals(user->nick, nickname); } bool Matches(const std::string& text) const override { return irc::equals(text, nickname); } }; class SVSHoldFactory final : public XLineFactory { public: SVSHoldFactory() : XLineFactory("SVSHOLD") { } XLine* Generate(time_t settime, unsigned long duration, const std::string& source, const std::string& reason, const std::string& nick) override { return new SVSHold(settime, duration, source, reason, nick); } }; class CommandSVSCMode final : public Command { public: CommandSVSCMode(Module* mod) : Command(mod, "SVSCMODE", 3) { access_needed = CmdAccess::SERVER; } CmdResult Handle(User* user, const Params& parameters) override { // The command can only be executed by remote services servers. if (IS_LOCAL(user) || !user->server->IsService()) return CmdResult::FAILURE; auto* u = ServerInstance->Users.FindUUID(parameters[0]); if (!u) return CmdResult::FAILURE; auto* c = ServerInstance->Channels.Find(parameters[1]); if (!c) return CmdResult::FAILURE; for (auto mode : parameters[2]) { auto* mh = ServerInstance->Modes.FindMode(mode, MODETYPE_CHANNEL); if (!mh || !mh->IsListModeBase()) continue; // Not a list mode. auto* list = mh->IsListModeBase()->GetList(c); if (!list) continue; // No list modes set. Modes::ChangeList changelist; for (const auto& entry : *list) { if (c->CheckBan(u, entry.mask)) changelist.push(mh, false, entry.mask); } ServerInstance->Modes.Process(user, c, nullptr, changelist); } return CmdResult::SUCCESS; } }; class CommandSVSHold final : public Command { public: CommandSVSHold(Module* Creator) : Command(Creator, "SVSHOLD") { access_needed = CmdAccess::SERVER; } CmdResult Handle(User* user, const Params& parameters) override { // The command can only be executed by remote services servers. if (IS_LOCAL(user) || !user->server->IsService()) return CmdResult::FAILURE; if (parameters.size() == 1) { // :36DAAAAAA SVSHOLD ChanServ std::string reason; return ServerInstance->XLines->DelLine(parameters[0], "SVSHOLD", reason, user) ? CmdResult::SUCCESS : CmdResult::FAILURE; } if (parameters.size() == 3) { /// :36DAAAAAA SVSHOLD NickServ 86400 :Reserved for services /// :36DAAAAAA SVSHOLD NickServ 1d :Reserved for services unsigned long duration; if (!Duration::TryFrom(parameters[1], duration)) return CmdResult::FAILURE; auto* svshold = new SVSHold(ServerInstance->Time(), duration, user->nick, parameters[2], parameters[0]); return ServerInstance->XLines->AddLine(svshold, user) ? CmdResult::SUCCESS : CmdResult::FAILURE; } return CmdResult::FAILURE; } RouteDescriptor GetRouting(User* user, const Params& parameters) override { return ROUTE_BROADCAST; } }; class CommandSVSJoin final : public Command { public: CommandSVSJoin(Module* mod) : Command(mod, "SVSJOIN", 2) { access_needed = CmdAccess::SERVER; } CmdResult Handle(User* user, const Params& parameters) override { // The command can only be executed by remote services servers. if (IS_LOCAL(user) || !user->server->IsService()) return CmdResult::FAILURE; // Check for a valid channel name. if (!ServerInstance->Channels.IsChannel(parameters[1])) return CmdResult::FAILURE; // Check the target exists/ auto* u = ServerInstance->Users.FindUUID(parameters[0]); if (!u) return CmdResult::FAILURE; /* only join if it's local, otherwise just pass it on! */ auto* lu = IS_LOCAL(u); if (lu) { bool override = false; std::string key; if (parameters.size() >= 3) { key = parameters[2]; if (key.empty()) override = true; } Channel::JoinUser(lu, parameters[1], override, key); } return CmdResult::SUCCESS; } RouteDescriptor GetRouting(User* user, const Params& parameters) override { return ROUTE_UNICAST(parameters[0]); } }; class CommandSVSNick final : public Command { public: CommandSVSNick(Module* mod) : Command(mod, "SVSNICK", 3) { access_needed = CmdAccess::SERVER; } CmdResult Handle(User* user, const Params& parameters) override { // The command can only be executed by remote services servers. if (IS_LOCAL(user) || !user->server->IsService()) return CmdResult::FAILURE; auto* u = ServerInstance->Users.Find(parameters[0]); if (u && IS_LOCAL(u)) { // The 4th parameter is optional and it is the expected nick TS of the target user. If // this parameter is present and it doesn't match the user's nick TS, the SVSNICK is not // acted upon. // // This makes it possible to detect the case when services wants to change the nick of // a user, but the user changes their nick before the SVSNICK arrives, making the // SVSNICK nick change (usually to a guest nick) unnecessary. Consider the following for // example: // // 1. test changes nick to Attila which is protected by services // 2. Services SVSNICKs the user to Guest12345 // 3. Attila changes nick to Attila_ which isn't protected by services // 4. SVSNICK arrives // 5. Attila_ gets his nick changed to Guest12345 unnecessarily // // In this case when the SVSNICK is processed the target has already changed their nick // to something which isn't protected, so changing the nick again to a Guest nick is not // desired. However, if the expected nick TS parameter is present in the SVSNICK then // the nick change in step 5 won't happen because the timestamps won't match. if (parameters.size() > 3) { time_t expectedts = ConvToNum<time_t>(parameters[3]); if (!expectedts) return CmdResult::INVALID; // Malformed message if (u->nickchanged != expectedts) return CmdResult::FAILURE; // Ignore SVSNICK } std::string nick = parameters[1]; if (isdigit(nick[0])) nick = u->uuid; time_t nickts = ConvToNum<time_t>(parameters[2]); if (!nickts) return CmdResult::INVALID; // Malformed message if (!u->ChangeNick(nick, nickts)) { // Changing to 'nick' failed (it may already be in use), change to the uuid u->WriteNumeric(RPL_SAVENICK, u->uuid, "Your nickname is in use by an older user on a new server."); u->ChangeNick(u->uuid); } } return CmdResult::SUCCESS; } RouteDescriptor GetRouting(User* user, const Params& parameters) override { return ROUTE_UNICAST(parameters[0]); } }; class CommandSVSOper final : public Command { public: CommandSVSOper(Module* Creator) : Command(Creator, "SVSOPER", 2, 2) { access_needed = CmdAccess::SERVER; } CmdResult Handle(User* user, const Params& parameters) override { if (!user->server->IsService()) return CmdResult::FAILURE; auto* target = ServerInstance->Users.FindUUID(parameters[0]); if (!target) return CmdResult::FAILURE; if (IS_LOCAL(target)) { auto iter = ServerInstance->Config->OperTypes.find(parameters[1]); if (iter == ServerInstance->Config->OperTypes.end()) return CmdResult::FAILURE; auto automatic = parameters.GetTags().find("~automatic") != parameters.GetTags().end(); auto account = std::make_shared<OperAccount>(MODNAME, iter->second, ServerInstance->Config->EmptyTag); target->OperLogin(account, automatic, true); } return CmdResult::SUCCESS; } RouteDescriptor GetRouting(User* user, const Params& parameters) override { auto* target = ServerInstance->Users.FindUUID(parameters[0]); if (!target) return ROUTE_LOCALONLY; return ROUTE_OPT_UCAST(target->server); } }; class CommandSVSPart final : public Command { public: CommandSVSPart(Module* mod) : Command(mod, "SVSPART", 2) { access_needed = CmdAccess::SERVER; } CmdResult Handle(User* user, const Params& parameters) override { // The command can only be executed by remote services servers. if (IS_LOCAL(user) || !user->server->IsService()) return CmdResult::FAILURE; auto* u = ServerInstance->Users.FindUUID(parameters[0]); if (!u) return CmdResult::FAILURE; auto* c = ServerInstance->Channels.Find(parameters[1]); if (!c) return CmdResult::FAILURE; if (IS_LOCAL(u)) c->PartUser(u, parameters.size() == 3 ? parameters[2] : "Services forced part"); return CmdResult::SUCCESS; } RouteDescriptor GetRouting(User* user, const Params& parameters) override { return ROUTE_UNICAST(parameters[0]); } }; class CommandSVSTopic final : public Command { public: CommandSVSTopic(Module* mod) : Command(mod, "SVSTOPIC", 1, 4) { access_needed = CmdAccess::SERVER; allow_empty_last_param = true; } CmdResult Handle(User* user, const Params& parameters) override { // The command can only be executed by remote services servers. if (IS_LOCAL(user) || !user->server->IsService()) return CmdResult::FAILURE; auto* chan = ServerInstance->Channels.Find(parameters[0]); if (!chan) return CmdResult::FAILURE; if (parameters.size() == 4) { // 4 parameter version, set all topic data on the channel to the ones given in the parameters. time_t topicts = ConvToNum<time_t>(parameters[1]); if (!topicts) { ServerInstance->Logs.Debug(MODNAME, "Received SVSTOPIC with a 0 topicts; dropped."); return CmdResult::INVALID; } chan->SetTopic(user, parameters[3], topicts, &parameters[2]); } else { // 1 parameter version, nuke the topic chan->SetTopic(user, std::string(), 0); chan->setby.clear(); } return CmdResult::SUCCESS; } RouteDescriptor GetRouting(User* user, const Params& parameters) override { return ROUTE_BROADCAST; } }; class ModuleServices final : public Module , public ServerProtocol::RouteEventListener , public Stats::EventListener { private: Account::API accountapi; RegisteredChannel registeredcmode; RegisteredUser registeredumode; ServiceTag servicetag; ServProtect servprotectmode; SVSHoldFactory svsholdfactory; BoolExtItem auspexext; StringExtItem mlockext; BoolExtItem topiclockext; CommandSVSCMode svscmodecmd; CommandSVSHold svsholdcmd; CommandSVSJoin svsjoincmd; CommandSVSNick svsnickcmd; CommandSVSOper svsopercmd; CommandSVSPart svspartcmd; CommandSVSTopic svstopiccmd; bool accountoverrideshold; bool HandleModeLock(User* user, Channel* chan, const Modes::Change& change) { const auto* mlock = mlockext.Get(chan); if (!mlock) return true; // No mode lock. if (mlock->find(change.mh->GetModeChar()) == std::string::npos) return true; // Mode is not locked. user->WriteNumeric(ERR_MLOCKRESTRICTED, chan->name, change.mh->GetModeChar(), *mlock, INSP_FORMAT("Mode cannot be changed as it has been locked {} by services!", chan->IsModeSet(change.mh) ? "on" : "off")); return false; } bool HandleProtectedService(User* user, Channel* chan, const Modes::Change& change) { if (change.adding || change.param.empty()) return true; // We only care about local users removing prefix modes. const auto* pm = change.mh->IsPrefixMode(); if (!pm) return true; // Mode is not a prefix mode. auto* target = ServerInstance->Users.Find(change.param); if (!target) return true; // Target does not exist. Membership* memb = chan->GetUser(target); if (!memb || !memb->HasMode(pm)) return true; // Target does not have the mode. if (!target->IsModeSet(servprotectmode)) return true; // Target is not a protected service. user->WriteNumeric(ERR_RESTRICTED, chan->name, INSP_FORMAT("You are not permitted to remove privileges from {} services!", ServerInstance->Config->Network)); return false; } public: ModuleServices() : Module(VF_COMMON | VF_VENDOR, "Provides support for integrating with a services server.") , ServerProtocol::RouteEventListener(this) , Stats::EventListener(this) , accountapi(this) , registeredcmode(this) , registeredumode(this) , servicetag(this) , servprotectmode(this) , auspexext(this, "auspex", ExtensionType::CHANNEL, true) , mlockext(this, "mlock", ExtensionType::CHANNEL, true) , topiclockext(this, "topiclock", ExtensionType::CHANNEL, true) , svscmodecmd(this) , svsholdcmd(this) , svsjoincmd(this) , svsnickcmd(this) , svsopercmd(this) , svspartcmd(this) , svstopiccmd(this) { } ~ModuleServices() override { ServerInstance->XLines->DelAll("SVSHOLD"); ServerInstance->XLines->UnregisterFactory(&svsholdfactory); } void init() override { ServerInstance->XLines->RegisterFactory(&svsholdfactory); } void ReadConfig(ConfigStatus& status) override { const auto& tag = ServerInstance->Config->ConfValue("servicesintegration"); accountoverrideshold = tag->getBool("accountoverrideshold"); } ModResult OnRouteMessage(const Channel* channel, const Server* server) override { if (!server->IsService() || !auspexext.Get(channel)) return MOD_RES_PASSTHRU; // Allow services to see messages in this channel even if not guarded. return MOD_RES_ALLOW; } ModResult OnKill(User* source, User* dest, const std::string& reason) override { if (!source) return MOD_RES_PASSTHRU; if (dest->IsModeSet(servprotectmode)) { source->WriteNumeric(ERR_KILLDENY, INSP_FORMAT("You are not permitted to kill {} services!", ServerInstance->Config->Network)); return MOD_RES_DENY; } return MOD_RES_PASSTHRU; } ModResult OnPreTopicChange(User* user, Channel* chan, const std::string& topic) override { if (!IS_LOCAL(user) || !topiclockext.Get(chan)) return MOD_RES_PASSTHRU; // Remote user or no topiclock. user->WriteNumeric(ERR_TOPICLOCK, chan->name, "Topic cannot be changed as it has been locked by services!"); return MOD_RES_DENY; } ModResult OnRawMode(User* user, Channel* chan, const Modes::Change& change) override { if (!IS_LOCAL(user) || !chan) return MOD_RES_PASSTHRU; // Not our job to handle. if (!HandleProtectedService(user, chan, change)) return MOD_RES_DENY; if (!HandleModeLock(user, chan, change)) return MOD_RES_DENY; return MOD_RES_PASSTHRU; } ModResult OnStats(Stats::Context& stats) override { if (stats.GetSymbol() != 'S') return MOD_RES_PASSTHRU; ServerInstance->XLines->InvokeStats("SVSHOLD", stats); return MOD_RES_DENY; } ModResult OnUserPreKick(User* source, Membership* memb, const std::string& reason) override { if (memb->user->IsModeSet(servprotectmode)) { source->WriteNumeric(ERR_RESTRICTED, memb->chan->name, INSP_FORMAT("You are not permitted to kick {} services!", ServerInstance->Config->Network)); return MOD_RES_DENY; } return MOD_RES_PASSTHRU; } ModResult OnUserPreNick(LocalUser* user, const std::string& newnick) override { auto* svshold = ServerInstance->XLines->MatchesLine("SVSHOLD", newnick); if (!svshold) return MOD_RES_PASSTHRU; if (accountoverrideshold && accountapi) { Account::NickList* nicks = accountapi->GetAccountNicks(user); if (nicks && nicks->find(svshold->Displayable()) != nicks->end()) { std::string reason; ServerInstance->XLines->DelLine(svshold, reason, user); return MOD_RES_PASSTHRU; } } user->WriteNumeric(ERR_ERRONEUSNICKNAME, newnick, INSP_FORMAT("Services reserved nickname: {}", svshold->reason)); return MOD_RES_DENY; } void OnUserPostNick(User* user, const std::string& oldnick) override { if (user->IsModeSet(registeredumode) && !irc::equals(oldnick, user->nick)) registeredumode.RemoveMode(user); } }; MODULE_INIT(ModuleServices) ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/src/modules/m_sethost.cpp������������������������������������������������������������0000664�0000000�0000000�00000005770�14771603147�0020330�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2013, 2017, 2019-2023, 2025 Sadie Powell <sadie@witchery.services> * Copyright (C) 2012-2013 Attila Molnar <attilamolnar@hush.com> * Copyright (C) 2012 Robby <robby@chatbelgie.be> * Copyright (C) 2009 Daniel De Graaf <danieldg@inspircd.org> * Copyright (C) 2007 Dennis Friis <peavey@inspircd.org> * Copyright (C) 2006 Craig Edwards <brain@inspircd.org> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include "inspircd.h" class CommandSethost final : public Command { public: CharState hostmap; CommandSethost(Module* Creator) : Command(Creator, "SETHOST", 1) { access_needed = CmdAccess::OPERATOR; syntax = { "<host>" }; } CmdResult Handle(User* user, const Params& parameters) override { if (parameters[0].length() > ServerInstance->Config->Limits.MaxHost) { user->WriteNotice("*** SETHOST: Host too long"); return CmdResult::FAILURE; } for (const auto chr : parameters[0]) { if (!hostmap.test(static_cast<unsigned char>(chr))) { user->WriteNotice("*** SETHOST: Invalid characters in hostname"); return CmdResult::FAILURE; } } user->ChangeDisplayedHost(parameters[0]); ServerInstance->SNO.WriteGlobalSno('a', user->nick+" used SETHOST to change their displayed host to "+user->GetDisplayedHost()); return CmdResult::SUCCESS; } }; class ModuleSetHost final : public Module { private: CommandSethost cmd; public: ModuleSetHost() : Module(VF_VENDOR, "Adds the /SETHOST command which allows server operators to change their displayed hostname.") , cmd(this) { } void ReadConfig(ConfigStatus& status) override { const auto& tag = ServerInstance->Config->ConfValue("hostname"); const std::string hmap = tag->getString("charmap", "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz.-_/0123456789", 1); CharState newhostmap; for (const auto chr : hmap) { // A hostname can not contain NUL, LF, CR, or SPACE. if (chr == 0x00 || chr == 0x0A || chr == 0x0D || chr == 0x20) throw ModuleException(this, "<hostname:charmap> can not contain character 0x{:02X} ({})", chr, chr); newhostmap.set(static_cast<unsigned char>(chr)); } std::swap(newhostmap, cmd.hostmap); } void GetLinkData(Module::LinkData& data, std::string& compatdata) override { for (size_t i = 0; i < cmd.hostmap.size(); ++i) if (cmd.hostmap[i]) data["hostchars"].push_back(static_cast<unsigned char>(i)); } }; MODULE_INIT(ModuleSetHost) ��������inspircd-4.7.0/src/modules/m_setident.cpp�����������������������������������������������������������0000664�0000000�0000000�00000004116�14771603147�0020447�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2019-2023 Sadie Powell <sadie@witchery.services> * Copyright (C) 2012 Robby <robby@chatbelgie.be> * Copyright (C) 2012 Attila Molnar <attilamolnar@hush.com> * Copyright (C) 2009 Daniel De Graaf <danieldg@inspircd.org> * Copyright (C) 2007 Dennis Friis <peavey@inspircd.org> * Copyright (C) 2006, 2008 Craig Edwards <brain@inspircd.org> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include "inspircd.h" class CommandSetident final : public Command { public: CommandSetident(Module* Creator) : Command(Creator, "SETIDENT", 1) { access_needed = CmdAccess::OPERATOR; syntax = { "<username>" }; } CmdResult Handle(User* user, const Params& parameters) override { if (parameters[0].size() > ServerInstance->Config->Limits.MaxUser) { user->WriteNotice("*** SETIDENT: Username is too long"); return CmdResult::FAILURE; } if (!ServerInstance->IsUser(parameters[0])) { user->WriteNotice("*** SETIDENT: Invalid characters in username"); return CmdResult::FAILURE; } user->ChangeDisplayedUser(parameters[0]); ServerInstance->SNO.WriteGlobalSno('a', "{} used SETIDENT to change their username to '{}'", user->nick, user->GetRealUser()); return CmdResult::SUCCESS; } }; class ModuleSetIdent final : public Module { private: CommandSetident cmd; public: ModuleSetIdent() : Module(VF_VENDOR, "Adds the /SETIDENT command which allows server operators to change their username.") , cmd(this) { } }; MODULE_INIT(ModuleSetIdent) ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/src/modules/m_setidle.cpp������������������������������������������������������������0000664�0000000�0000000�00000005133�14771603147�0020261�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2019-2023, 2025 Sadie Powell <sadie@witchery.services> * Copyright (C) 2018 linuxdaemon <linuxdaemon.irc@gmail.com> * Copyright (C) 2012 Robby <robby@chatbelgie.be> * Copyright (C) 2009 Uli Schlachter <psychon@znc.in> * Copyright (C) 2009 Robin Burchell <robin+git@viroteck.net> * Copyright (C) 2009 Daniel De Graaf <danieldg@inspircd.org> * Copyright (C) 2007 Dennis Friis <peavey@inspircd.org> * Copyright (C) 2005 Craig Edwards <brain@inspircd.org> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include "inspircd.h" #include "modules/ircv3_replies.h" #include "timeutils.h" class CommandSetidle final : public SplitCommand { private: IRCv3::Replies::Fail failrpl; IRCv3::Replies::Fail noterpl; IRCv3::Replies::CapReference stdrplcap; public: CommandSetidle(Module* Creator) : SplitCommand(Creator, "SETIDLE", 1) , failrpl(Creator) , noterpl(Creator) , stdrplcap(Creator) { access_needed = CmdAccess::OPERATOR; syntax = { "<duration>" }; } CmdResult HandleLocal(LocalUser* user, const Params& parameters) override { unsigned long idle; if (!Duration::TryFrom(parameters[0], idle)) { failrpl.SendIfCap(user, stdrplcap, this, "INVALID_IDLE_TIME", parameters[0], "Invalid idle time."); return CmdResult::FAILURE; } user->idle_lastmsg = (ServerInstance->Time() - idle); // minor tweak - we cant have signon time shorter than our idle time! if (user->signon > user->idle_lastmsg) user->signon = user->idle_lastmsg; ServerInstance->SNO.WriteToSnoMask('a', "{} used SETIDLE to set their idle time to {}", user->nick, Duration::ToLongString(idle)); noterpl.SendIfCap(user, stdrplcap, this, "IDLE_TIME_SET", user->idle_lastmsg, "Idle time set."); return CmdResult::SUCCESS; } }; class ModuleSetIdle final : public Module { private: CommandSetidle cmd; public: ModuleSetIdle() : Module(VF_VENDOR, "Adds the /SETIDLE command which allows server operators to change their idle time.") , cmd(this) { } }; MODULE_INIT(ModuleSetIdle) �������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/src/modules/m_setname.cpp������������������������������������������������������������0000664�0000000�0000000�00000006114�14771603147�0020264�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2022 delthas * Copyright (C) 2018-2023 Sadie Powell <sadie@witchery.services> * Copyright (C) 2012 Robby <robby@chatbelgie.be> * Copyright (C) 2012 Attila Molnar <attilamolnar@hush.com> * Copyright (C) 2009 Daniel De Graaf <danieldg@inspircd.org> * Copyright (C) 2007 John Brooks <john@jbrooks.io> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include "inspircd.h" #include "modules/ircv3.h" #include "modules/ircv3_replies.h" #include "modules/monitor.h" class CommandSetName final : public SplitCommand { private: IRCv3::Replies::Fail fail; public: Cap::Capability cap; bool notifyopers; CommandSetName(Module* Creator) : SplitCommand(Creator, "SETNAME", 1, 1) , fail(Creator) , cap(Creator, "setname") { syntax = { ":<realname>" }; } CmdResult HandleLocal(LocalUser* user, const Params& parameters) override { if (parameters[0].size() > ServerInstance->Config->Limits.MaxReal) { fail.SendIfCap(user, &cap, this, "INVALID_REALNAME", "Real name is too long"); return CmdResult::FAILURE; } user->ChangeRealName(parameters[0]); if (notifyopers) ServerInstance->SNO.WriteGlobalSno('a', "{} used SETNAME to change their real name to '{}'", user->nick, parameters[0]); return CmdResult::SUCCESS; } }; class ModuleSetName final : public Module { private: CommandSetName cmd; ClientProtocol::EventProvider setnameevprov; Monitor::API monitorapi; public: ModuleSetName() : Module(VF_VENDOR, "Adds the /SETNAME command which allows users to change their real name.") , cmd(this) , setnameevprov(this, "SETNAME") , monitorapi(this) { } void ReadConfig(ConfigStatus& status) override { const auto& tag = ServerInstance->Config->ConfValue("setname"); // Whether the module should only be usable by server operators. bool operonly = tag->getBool("operonly"); cmd.access_needed = operonly ? CmdAccess::OPERATOR : CmdAccess::NORMAL; // Whether a snotice should be sent out when a user changes their real name. cmd.notifyopers = tag->getBool("notifyopers", !operonly); } void OnChangeRealName(User* user, const std::string& real) override { if (!(user->connected & User::CONN_NICKUSER)) return; ClientProtocol::Message msg("SETNAME", user); msg.PushParamRef(real); ClientProtocol::Event protoev(setnameevprov, msg); IRCv3::WriteNeighborsWithCap res(user, protoev, cmd.cap, true); Monitor::WriteWatchersWithCap(monitorapi, user, protoev, cmd.cap, res.GetAlreadySentId()); } }; MODULE_INIT(ModuleSetName) ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/src/modules/m_sha1.cpp���������������������������������������������������������������0000664�0000000�0000000�00000017263�14771603147�0017473�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2019-2021 Sadie Powell <sadie@witchery.services> * Copyright (C) 2016 Attila Molnar <attilamolnar@hush.com> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ /* SHA-1 in C By Steve Reid <steve@edmweb.com> 100% Public Domain */ #include "inspircd.h" #include "modules/hash.h" union CHAR64LONG16 { unsigned char c[64]; uint32_t l[16]; }; inline static uint32_t rol(uint32_t value, uint32_t bits) { return (value << bits) | (value >> (32 - bits)); } // blk0() and blk() perform the initial expand. // I got the idea of expanding during the round function from SSLeay static bool big_endian; inline static uint32_t blk0(CHAR64LONG16& block, uint32_t i) { if (big_endian) return block.l[i]; else return block.l[i] = (rol(block.l[i], 24) & 0xFF00FF00) | (rol(block.l[i], 8) & 0x00FF00FF); } inline static uint32_t blk(CHAR64LONG16 &block, uint32_t i) { return block.l[i & 15] = rol(block.l[(i + 13) & 15] ^ block.l[(i + 8) & 15] ^ block.l[(i + 2) & 15] ^ block.l[i & 15],1); } // (R0+R1), R2, R3, R4 are the different operations used in SHA1 inline static void R0(CHAR64LONG16& block, uint32_t v, uint32_t &w, uint32_t x, uint32_t y, uint32_t &z, uint32_t i) { z += ((w & (x ^ y)) ^ y) + blk0(block, i) + 0x5A827999 + rol(v, 5); w = rol(w, 30); } inline static void R1(CHAR64LONG16& block, uint32_t v, uint32_t &w, uint32_t x, uint32_t y, uint32_t &z, uint32_t i) { z += ((w & (x ^ y)) ^ y) + blk(block, i) + 0x5A827999 + rol(v, 5); w = rol(w, 30); } inline static void R2(CHAR64LONG16& block, uint32_t v, uint32_t &w, uint32_t x, uint32_t y, uint32_t &z, uint32_t i) { z += (w ^ x ^ y) + blk(block, i) + 0x6ED9EBA1 + rol(v, 5); w = rol(w, 30); } inline static void R3(CHAR64LONG16& block, uint32_t v, uint32_t &w, uint32_t x, uint32_t y, uint32_t &z, uint32_t i) { z += (((w | x) & y) | (w & x)) + blk(block, i) + 0x8F1BBCDC + rol(v, 5); w = rol(w, 30); } inline static void R4(CHAR64LONG16& block, uint32_t v, uint32_t &w, uint32_t x, uint32_t y, uint32_t &z, uint32_t i) { z += (w ^ x ^ y) + blk(block, i) + 0xCA62C1D6 + rol(v, 5); w = rol(w, 30); } static const uint32_t sha1_iv[5] = { 0x67452301, 0xEFCDAB89, 0x98BADCFE, 0x10325476, 0xC3D2E1F0 }; class SHA1Context final { uint32_t state[5]; uint32_t count[2]; unsigned char buffer[64]; unsigned char digest[20]; void Transform(const unsigned char buf[64]) { uint32_t a, b, c, d, e; CHAR64LONG16 block; memcpy(block.c, buf, 64); // Copy state[] to working vars a = this->state[0]; b = this->state[1]; c = this->state[2]; d = this->state[3]; e = this->state[4]; // 4 rounds of 20 operations each. Loop unrolled. R0(block, a, b, c, d, e, 0); R0(block, e, a, b, c, d, 1); R0(block, d, e, a, b, c, 2); R0(block, c, d, e, a, b, 3); R0(block, b, c, d, e, a, 4); R0(block, a, b, c, d, e, 5); R0(block, e, a, b, c, d, 6); R0(block, d, e, a, b, c, 7); R0(block, c, d, e, a, b, 8); R0(block, b, c, d, e, a, 9); R0(block, a, b, c, d, e, 10); R0(block, e, a, b, c, d, 11); R0(block, d, e, a, b, c, 12); R0(block, c, d, e, a, b, 13); R0(block, b, c, d, e, a, 14); R0(block, a, b, c, d, e, 15); R1(block, e, a, b, c, d, 16); R1(block, d, e, a, b, c, 17); R1(block, c, d, e, a, b, 18); R1(block, b, c, d, e, a, 19); R2(block, a, b, c, d, e, 20); R2(block, e, a, b, c, d, 21); R2(block, d, e, a, b, c, 22); R2(block, c, d, e, a, b, 23); R2(block, b, c, d, e, a, 24); R2(block, a, b, c, d, e, 25); R2(block, e, a, b, c, d, 26); R2(block, d, e, a, b, c, 27); R2(block, c, d, e, a, b, 28); R2(block, b, c, d, e, a, 29); R2(block, a, b, c, d, e, 30); R2(block, e, a, b, c, d, 31); R2(block, d, e, a, b, c, 32); R2(block, c, d, e, a, b, 33); R2(block, b, c, d, e, a, 34); R2(block, a, b, c, d, e, 35); R2(block, e, a, b, c, d, 36); R2(block, d, e, a, b, c, 37); R2(block, c, d, e, a, b, 38); R2(block, b, c, d, e, a, 39); R3(block, a, b, c, d, e, 40); R3(block, e, a, b, c, d, 41); R3(block, d, e, a, b, c, 42); R3(block, c, d, e, a, b, 43); R3(block, b, c, d, e, a, 44); R3(block, a, b, c, d, e, 45); R3(block, e, a, b, c, d, 46); R3(block, d, e, a, b, c, 47); R3(block, c, d, e, a, b, 48); R3(block, b, c, d, e, a, 49); R3(block, a, b, c, d, e, 50); R3(block, e, a, b, c, d, 51); R3(block, d, e, a, b, c, 52); R3(block, c, d, e, a, b, 53); R3(block, b, c, d, e, a, 54); R3(block, a, b, c, d, e, 55); R3(block, e, a, b, c, d, 56); R3(block, d, e, a, b, c, 57); R3(block, c, d, e, a, b, 58); R3(block, b, c, d, e, a, 59); R4(block, a, b, c, d, e, 60); R4(block, e, a, b, c, d, 61); R4(block, d, e, a, b, c, 62); R4(block, c, d, e, a, b, 63); R4(block, b, c, d, e, a, 64); R4(block, a, b, c, d, e, 65); R4(block, e, a, b, c, d, 66); R4(block, d, e, a, b, c, 67); R4(block, c, d, e, a, b, 68); R4(block, b, c, d, e, a, 69); R4(block, a, b, c, d, e, 70); R4(block, e, a, b, c, d, 71); R4(block, d, e, a, b, c, 72); R4(block, c, d, e, a, b, 73); R4(block, b, c, d, e, a, 74); R4(block, a, b, c, d, e, 75); R4(block, e, a, b, c, d, 76); R4(block, d, e, a, b, c, 77); R4(block, c, d, e, a, b, 78); R4(block, b, c, d, e, a, 79); // Add the working vars back into state[] this->state[0] += a; this->state[1] += b; this->state[2] += c; this->state[3] += d; this->state[4] += e; } public: SHA1Context() { for (int i = 0; i < 5; ++i) this->state[i] = sha1_iv[i]; this->count[0] = this->count[1] = 0; memset(this->buffer, 0, sizeof(this->buffer)); memset(this->digest, 0, sizeof(this->digest)); } void Update(const unsigned char* data, size_t len) { uint32_t i, j; j = (this->count[0] >> 3) & 63; if ((this->count[0] += len << 3) < (len << 3)) ++this->count[1]; this->count[1] += len >> 29; if (j + len > 63) { memcpy(&this->buffer[j], data, (i = 64 - j)); this->Transform(this->buffer); for (; i + 63 < len; i += 64) this->Transform(&data[i]); j = 0; } else i = 0; memcpy(&this->buffer[j], &data[i], len - i); } void Finalize() { uint32_t i; unsigned char finalcount[8]; for (i = 0; i < 8; ++i) finalcount[i] = static_cast<unsigned char>((this->count[i >= 4 ? 0 : 1] >> ((3 - (i & 3)) * 8)) & 255); /* Endian independent */ this->Update(reinterpret_cast<const unsigned char *>("\200"), 1); while ((this->count[0] & 504) != 448) this->Update(reinterpret_cast<const unsigned char *>("\0"), 1); this->Update(finalcount, 8); // Should cause a SHA1Transform() for (i = 0; i < 20; ++i) this->digest[i] = static_cast<unsigned char>((this->state[i>>2] >> ((3 - (i & 3)) * 8)) & 255); this->Transform(this->buffer); } std::string GetRaw() const { return std::string((const char*)digest, sizeof(digest)); } }; class SHA1HashProvider final : public HashProvider { public: SHA1HashProvider(Module* mod) : HashProvider(mod, "sha1", 20, 64) { } std::string GenerateRaw(const std::string& data) override { SHA1Context ctx; ctx.Update(reinterpret_cast<const unsigned char*>(data.data()), data.length()); ctx.Finalize(); return ctx.GetRaw(); } }; class ModuleSHA1 final : public Module { private: SHA1HashProvider sha1; public: ModuleSHA1() : Module(VF_VENDOR, "Allows other modules to generate SHA-1 hashes.") , sha1(this) { big_endian = (htonl(1337) == 1337); } }; MODULE_INIT(ModuleSHA1) ���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/src/modules/m_sha2.cpp���������������������������������������������������������������0000664�0000000�0000000�00000004534�14771603147�0017471�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2013, 2018-2022 Sadie Powell <sadie@witchery.services> * Copyright (C) 2012 Robby <robby@chatbelgie.be> * Copyright (C) 2009 Daniel De Graaf <danieldg@inspircd.org> * Copyright (C) 2007-2008 Robin Burchell <robin+git@viroteck.net> * Copyright (C) 2007 Dennis Friis <peavey@inspircd.org> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ // Fix a collision between the Haiku uint64 typedef and the // one from the sha2 library. #ifdef __HAIKU__ # define uint64 sha2_uint64 #endif #include <sha2/sha2.c> #ifdef __HAIKU__ # undef uint64 #endif #include "inspircd.h" #include "modules/hash.h" template<void (*SHA)(const unsigned char*, unsigned int, unsigned char*)> class HashSHA2 final : public HashProvider { public: HashSHA2(Module* parent, const std::string& Name, unsigned int osize, unsigned int bsize) : HashProvider(parent, Name, osize, bsize) { } std::string GenerateRaw(const std::string& data) override { std::vector<char> bytes(out_size); SHA(reinterpret_cast<const unsigned char*>(data.data()), static_cast<unsigned int>(data.size()), reinterpret_cast<unsigned char*>(bytes.data())); return std::string(bytes.data(), bytes.size()); } }; class ModuleSHA2 final : public Module { private: HashSHA2<sha224> sha224algo; HashSHA2<sha256> sha256algo; HashSHA2<sha384> sha384algo; HashSHA2<sha512> sha512algo; public: ModuleSHA2() : Module(VF_VENDOR, "Allows other modules to generate SHA-2 hashes.") , sha224algo(this, "sha224", SHA224_DIGEST_SIZE, SHA224_BLOCK_SIZE) , sha256algo(this, "sha256", SHA256_DIGEST_SIZE, SHA256_BLOCK_SIZE) , sha384algo(this, "sha384", SHA384_DIGEST_SIZE, SHA384_BLOCK_SIZE) , sha512algo(this, "sha512", SHA512_DIGEST_SIZE, SHA512_BLOCK_SIZE) { } }; MODULE_INIT(ModuleSHA2) ��������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/src/modules/m_showfile.cpp�����������������������������������������������������������0000664�0000000�0000000�00000012753�14771603147�0020456�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2018-2024 Sadie Powell <sadie@witchery.services> * Copyright (C) 2013-2014, 2016, 2018 Attila Molnar <attilamolnar@hush.com> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include "inspircd.h" #include "clientprotocolmsg.h" enum { // From UnrealIRCd. RPL_RULES = 232, RPL_RULESTART = 308, RPL_RULESEND = 309, ERR_NORULES = 434 }; class CommandShowFile final : public Command { enum Method { SF_MSG, SF_NOTICE, SF_NUMERIC }; std::string introtext; std::string endtext; unsigned int intronumeric; unsigned int textnumeric; unsigned int endnumeric; std::vector<std::string> contents; Method method; public: CommandShowFile(Module* parent, const std::string& cmdname) : Command(parent, cmdname) { } CmdResult Handle(User* user, const Params& parameters) override { if (method == SF_NUMERIC) { if (!introtext.empty() && intronumeric) user->WriteRemoteNumeric(intronumeric, introtext); for (const auto& line : contents) user->WriteRemoteNumeric(textnumeric, line); if (!endtext.empty() && endnumeric) user->WriteRemoteNumeric(endnumeric, endtext); } else if (IS_LOCAL(user)) { LocalUser* const localuser = IS_LOCAL(user); for (const auto& line : contents) { ClientProtocol::Messages::Privmsg msg(ClientProtocol::Messages::Privmsg::nocopy, ServerInstance->FakeClient, localuser, line, ((method == SF_MSG) ? MessageType::PRIVMSG : MessageType::NOTICE)); localuser->Send(ServerInstance->GetRFCEvents().privmsg, msg); } } return CmdResult::SUCCESS; } void UpdateSettings(const std::shared_ptr<ConfigTag>& tag, const std::string& filecontents) { introtext = tag->getString("introtext", "Showing " + name); endtext = tag->getString("endtext", "End of " + name); intronumeric = tag->getNum<unsigned int>("intronumeric", RPL_RULESTART, 0, 999); textnumeric = tag->getNum<unsigned int>("numeric", RPL_RULES, 0, 999); endnumeric = tag->getNum<unsigned int>("endnumeric", RPL_RULESEND, 0, 999); std::string smethod = tag->getString("method"); method = SF_NUMERIC; if (smethod == "msg") method = SF_MSG; else if (smethod == "notice") method = SF_NOTICE; // Process the entry. contents.clear(); irc::sepstream linestream(filecontents, '\n', true); for (std::string line; linestream.GetToken(line); ) { // Some clients can not handle receiving NOTICE/PRIVMSG/RPL_RULES // with an empty trailing parameter so if a line is empty we // replace it with a single space. InspIRCd::ProcessColors(line); contents.push_back(line.empty() ? " " : line); } contents.shrink_to_fit(); } }; class ModuleShowFile final : public Module { private: std::vector<CommandShowFile*> cmds; void ReadTag(const std::shared_ptr<ConfigTag>& tag, std::vector<CommandShowFile*>& newcmds) { std::string cmdname = tag->getString("name"); if (cmdname.empty()) throw ModuleException(this, "Empty value for 'name'"); std::transform(cmdname.begin(), cmdname.end(), cmdname.begin(), ::toupper); const std::string file = tag->getString("file", cmdname); if (file.empty()) throw ModuleException(this, "Empty value for 'file'"); auto reader = ServerInstance->Config->ReadFile(file); if (!reader) throw ModuleException(this, "Unable to read " + file + ": " + reader.error); CommandShowFile* sfcmd; Command* handler = ServerInstance->Parser.GetHandler(cmdname); if (handler) { // Command exists, check if it is ours if (handler->creator != this) throw ModuleException(this, "Command " + cmdname + " already exists"); // This is our command, make sure we don't have the same entry twice sfcmd = static_cast<CommandShowFile*>(handler); if (stdalgo::isin(newcmds, sfcmd)) throw ModuleException(this, "Command " + cmdname + " is already used in a <showfile> tag"); } else { // Command doesn't exist, create it sfcmd = new CommandShowFile(this, cmdname); ServerInstance->Modules.AddService(*sfcmd); } sfcmd->UpdateSettings(tag, reader.contents); newcmds.push_back(sfcmd); } public: ModuleShowFile() : Module(VF_VENDOR, "Adds support for showing the contents of files to users when they execute a command.") { } void ReadConfig(ConfigStatus& status) override { std::vector<CommandShowFile*> newcmds; for (const auto& [_, tag] : ServerInstance->Config->ConfTags("showfile")) { try { ReadTag(tag, newcmds); } catch (const CoreException& ex) { ServerInstance->Logs.Warning(MODNAME, "Error: " + ex.GetReason() + " at " + tag->source.str()); } } // Remove all commands that were removed from the config std::vector<CommandShowFile*> removed(cmds.size()); std::sort(newcmds.begin(), newcmds.end()); std::set_difference(cmds.begin(), cmds.end(), newcmds.begin(), newcmds.end(), removed.begin()); stdalgo::delete_all(removed); cmds.swap(newcmds); } ~ModuleShowFile() override { stdalgo::delete_all(cmds); } }; MODULE_INIT(ModuleShowFile) ���������������������inspircd-4.7.0/src/modules/m_showwhois.cpp����������������������������������������������������������0000664�0000000�0000000�00000006173�14771603147�0020667�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2018-2024 Sadie Powell <sadie@witchery.services> * Copyright (C) 2012-2015 Attila Molnar <attilamolnar@hush.com> * Copyright (C) 2012 Robby <robby@chatbelgie.be> * Copyright (C) 2009-2010 Daniel De Graaf <danieldg@inspircd.org> * Copyright (C) 2007-2008 Robin Burchell <robin+git@viroteck.net> * Copyright (C) 2007 Dennis Friis <peavey@inspircd.org> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include "inspircd.h" #include "modules/whois.h" /** Handle user mode +W */ class SeeWhois final : public SimpleUserMode { public: SeeWhois(Module* Creator) : SimpleUserMode(Creator, "showwhois", 'W') { } void SetOperOnly(bool operonly) { oper = operonly; } }; class WhoisNoticeCmd final : public Command { public: WhoisNoticeCmd(Module* Creator) : Command(Creator, "WHOISNOTICE", 2) { access_needed = CmdAccess::SERVER; } static void HandleFast(User* dest, User* src) { const std::string& userhost = dest->HasPrivPermission("users/auspex") ? src->GetRealUserHost() : src->GetUserHost(); dest->WriteNotice("{} ({}) did a /WHOIS on you", src->nick, userhost); } CmdResult Handle(User* user, const Params& parameters) override { auto* dest = ServerInstance->Users.Find(parameters[0]); if (!dest) return CmdResult::FAILURE; auto* source = ServerInstance->Users.Find(parameters[1]); if (IS_LOCAL(dest) && source) HandleFast(dest, source); return CmdResult::SUCCESS; } }; class ModuleShowwhois final : public Module , public Whois::EventListener { private: SeeWhois sw; WhoisNoticeCmd cmd; public: ModuleShowwhois() : Module(VF_VENDOR | VF_OPTCOMMON, "Adds user mode W (showwhois) which allows users to be informed when someone does a /WHOIS query on their nick.") , Whois::EventListener(this) , sw(this) , cmd(this) { } void ReadConfig(ConfigStatus& status) override { const auto& tag = ServerInstance->Config->ConfValue("showwhois"); sw.SetOperOnly(tag->getBool("opersonly", true)); } void OnWhois(Whois::Context& whois) override { User* const dest = whois.GetTarget(); if (!dest->IsModeSet(sw) || whois.IsSelfWhois()) return; User* const source = whois.GetSource(); if (source->HasPrivPermission("users/secret-whois")) return; if (IS_LOCAL(dest)) { WhoisNoticeCmd::HandleFast(dest, source); } else { CommandBase::Params params; params.push_back(dest->uuid); params.push_back(source->uuid); ServerInstance->PI->SendEncapsulatedData(dest->server->GetName(), cmd.name, params); } } }; MODULE_INIT(ModuleShowwhois) �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/src/modules/m_shun.cpp���������������������������������������������������������������0000664�0000000�0000000�00000016467�14771603147�0017621�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2019 Matt Schatz <genius3000@g3k.solutions> * Copyright (C) 2018 linuxdaemon <linuxdaemon.irc@gmail.com> * Copyright (C) 2017-2025 Sadie Powell <sadie@witchery.services> * Copyright (C) 2017 B00mX0r <b00mx0r@aureus.pw> * Copyright (C) 2012-2013, 2016 Attila Molnar <attilamolnar@hush.com> * Copyright (C) 2012, 2019 Robby <robby@chatbelgie.be> * Copyright (C) 2012 Jens Voss <DukePyrolator@anope.org> * Copyright (C) 2009 John Brooks <john@jbrooks.io> * Copyright (C) 2009 Dennis Friis <peavey@inspircd.org> * Copyright (C) 2009 Daniel De Graaf <danieldg@inspircd.org> * Copyright (C) 2008-2009 Craig Edwards <brain@inspircd.org> * Copyright (C) 2008 Thomas Stagner <aquanight@gmail.com> * Copyright (C) 2008 Robin Burchell <robin+git@viroteck.net> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include "inspircd.h" #include "modules/shun.h" #include "modules/stats.h" #include "timeutils.h" #include "xline.h" /** An XLineFactory specialized to generate shun pointers */ class ShunFactory final : public XLineFactory { public: ShunFactory() : XLineFactory("SHUN") { } XLine* Generate(time_t set_time, unsigned long duration, const std::string& source, const std::string& reason, const std::string& xline_specific_mask) override { return new Shun(set_time, duration, source, reason, xline_specific_mask); } bool AutoApplyToUserList(XLine* x) override { return false; } }; class CommandShun final : public Command { public: CommandShun(Module* Creator) : Command(Creator, "SHUN", 1, 3) { access_needed = CmdAccess::OPERATOR; syntax = { "<nick!user@host>[,<nick!user@host>]+ [<duration> :<reason>]" }; } CmdResult Handle(User* user, const Params& parameters) override { /* syntax: SHUN nick!user@host time :reason goes here */ /* 'time' is a human-readable timestring, like 2d3h2s. */ if (CommandParser::LoopCall(user, this, parameters, 0)) return CmdResult::SUCCESS; std::string target = parameters[0]; auto* find = ServerInstance->Users.Find(target, true); if (find) target = "*!" + find->GetBanUser(true) + "@" + find->GetAddress(); if (parameters.size() == 1) { std::string reason; if (ServerInstance->XLines->DelLine(parameters[0], "SHUN", reason, user)) { ServerInstance->SNO.WriteToSnoMask('x', "{} removed SHUN on {}: {}", user->nick, parameters[0], reason); } else if (ServerInstance->XLines->DelLine(target, "SHUN", reason, user)) { ServerInstance->SNO.WriteToSnoMask('x', "{} removed SHUN on {}: {}", user->nick, target, reason); } else { user->WriteNotice("*** Shun " + parameters[0] + " not found on the list."); return CmdResult::FAILURE; } } else { // Adding - XXX todo make this respect <insane> tag perhaps.. unsigned long duration; std::string expr; if (parameters.size() > 2) { if (!Duration::TryFrom(parameters[1], duration)) { user->WriteNotice("*** Invalid duration for SHUN."); return CmdResult::FAILURE; } expr = parameters[2]; } else { duration = 0; expr = parameters[1]; } auto* r = new Shun(ServerInstance->Time(), duration, user->nick, expr, target); if (ServerInstance->XLines->AddLine(r, user)) { if (!duration) { ServerInstance->SNO.WriteToSnoMask('x', "{} added permanent SHUN for {}: {}", user->nick, target, expr); } else { ServerInstance->SNO.WriteToSnoMask('x', "{} added a timed SHUN on {}, expires in {} (on {}): {}", user->nick, target, Duration::ToLongString(duration), Time::FromNow(duration), expr); } } else { delete r; user->WriteNotice("*** Shun for " + target + " already exists."); return CmdResult::FAILURE; } } return CmdResult::SUCCESS; } }; class ModuleShun final : public Module , public Stats::EventListener { private: CommandShun cmd; ShunFactory shun; bool allowconnect; bool allowtags; TokenList cleanedcommands; TokenList enabledcommands; bool notifyuser; bool IsShunned(LocalUser* user) const { // Exempt the user if they are not fully connected and allowconnect is enabled. if (allowconnect && !user->IsFullyConnected()) return false; // Exempt the user from shuns if they are an oper with the servers/ignore-shun privilege. if (user->HasPrivPermission("servers/ignore-shun")) return false; // Check whether the user is actually shunned. return ServerInstance->XLines->MatchesLine("SHUN", user); } public: ModuleShun() : Module(VF_VENDOR | VF_COMMON, "Adds the /SHUN command which allows server operators to prevent users from executing commands.") , Stats::EventListener(this) , cmd(this) { } void init() override { ServerInstance->XLines->RegisterFactory(&shun); } ~ModuleShun() override { ServerInstance->XLines->DelAll("SHUN"); ServerInstance->XLines->UnregisterFactory(&shun); } void Prioritize() override { Module* alias = ServerInstance->Modules.Find("alias"); ServerInstance->Modules.SetPriority(this, I_OnPreCommand, PRIORITY_BEFORE, alias); } ModResult OnStats(Stats::Context& stats) override { if (stats.GetSymbol() != 'H') return MOD_RES_PASSTHRU; ServerInstance->XLines->InvokeStats("SHUN", stats); return MOD_RES_DENY; } void ReadConfig(ConfigStatus& status) override { cleanedcommands.Clear(); enabledcommands.Clear(); const auto& tag = ServerInstance->Config->ConfValue("shun"); allowconnect = tag->getBool("allowconnect"); allowtags = tag->getBool("allowtags"); cleanedcommands.AddList(tag->getString("cleanedcommands", "AWAY PART QUIT")); enabledcommands.AddList(tag->getString("enabledcommands", "ADMIN OPER PING PONG QUIT")); notifyuser = tag->getBool("notifyuser", true); } ModResult OnPreCommand(std::string& command, CommandBase::Params& parameters, LocalUser* user, bool validated) override { if (validated || !IsShunned(user)) return MOD_RES_PASSTHRU; if (!enabledcommands.Contains(command)) { if (notifyuser) user->WriteNotice("*** " + command + " command not processed as you have been blocked from issuing commands."); return MOD_RES_DENY; } if (!allowtags) { // Remove all client tags. ClientProtocol::TagMap& tags = parameters.GetTags(); for (ClientProtocol::TagMap::iterator tag = tags.begin(); tag != tags.end(); ) { if (tag->first[0] == '+') tag = tags.erase(tag); else tag++; } } if (!cleanedcommands.Contains(command)) return MOD_RES_PASSTHRU; switch (parameters.size()) { case 0: { if (command == "AWAY" || command == "QUIT") parameters.clear(); break; } case 1: { if (command == "CYCLE" || command == "KNOCK" || command == "PART") parameters.resize(1); break; } } return MOD_RES_PASSTHRU; } }; MODULE_INIT(ModuleShun) ���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/src/modules/m_silence.cpp������������������������������������������������������������0000664�0000000�0000000�00000035616�14771603147�0020263�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2021 Dominic Hamon * Copyright (C) 2019 linuxdaemon <linuxdaemon.irc@gmail.com> * Copyright (C) 2019 iwalkalone <iwalkalone69@gmail.com> * Copyright (C) 2018-2024 Sadie Powell <sadie@witchery.services> * Copyright (C) 2015 Renegade334 <contact.caaeed4f@renegade334.me.uk> * Copyright (C) 2012, 2019 Robby <robby@chatbelgie.be> * Copyright (C) 2012 Attila Molnar <attilamolnar@hush.com> * Copyright (C) 2009-2010 Daniel De Graaf <danieldg@inspircd.org> * Copyright (C) 2008 Robin Burchell <robin+git@viroteck.net> * Copyright (C) 2006-2007 Dennis Friis <peavey@inspircd.org> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include "inspircd.h" #include "clientprotocolmsg.h" #include "modules/ctctags.h" #include "modules/isupport.h" enum { // From ircu? RPL_SILELIST = 271, RPL_ENDOFSILELIST = 272, ERR_SILELISTFULL = 511, // InspIRCd-specific. ERR_SILENCE = 952 }; class SilenceEntry final { public: enum SilenceFlags { // Does nothing; for internal use only. SF_NONE = 0, // Exclude users who match this flags ("x"). SF_EXEMPT = 1, // Hide the contents of the message when sent to the silencer ("H"). SF_HIDE_SILENCER = 2, // 4, 8, 16 are reserved for future use. // Matches a NOTICE targeted at a channel ("n"). SF_NOTICE_CHANNEL = 32, // Matches a NOTICE targeted at a user ("N"). SF_NOTICE_USER = 64, // Matches a PRIVMSG targeted at a channel ("p"). SF_PRIVMSG_CHANNEL = 128, // Matches a PRIVMSG targeted at a user ("P"). SF_PRIVMSG_USER = 256, // Matches a TAGMSG targeted at a channel ("t"). SF_TAGMSG_CHANNEL = 512, // Matches a TAGMSG targeted at a user ("T"). SF_TAGMSG_USER = 1024, // Matches a CTCP targeted at a channel ("c"). SF_CTCP_CHANNEL = 2048, // Matches a CTCP targeted at a user ("C"). SF_CTCP_USER = 4096, // Matches an invite to a channel ("i"). SF_INVITE = 8192, // The default if no flags have been specified. SF_DEFAULT = SF_NOTICE_CHANNEL | SF_NOTICE_USER | SF_PRIVMSG_CHANNEL | SF_PRIVMSG_USER | SF_TAGMSG_CHANNEL | SF_TAGMSG_USER | SF_CTCP_CHANNEL | SF_CTCP_USER | SF_INVITE }; // The flags that this mask is silenced for. uint32_t flags; // The mask which is silenced (e.g. *!*@example.com). std::string mask; SilenceEntry(uint32_t Flags, const std::string& Mask) : flags(Flags) , mask(Mask) { } bool operator <(const SilenceEntry& other) const { if (flags & SF_EXEMPT && other.flags & ~SF_EXEMPT) return true; if (other.flags & SF_EXEMPT && flags & ~SF_EXEMPT) return false; if (flags < other.flags) return true; if (other.flags < flags) return false; return mask < other.mask; } // Converts a flag list to a bitmask. static bool FlagsToBits(const std::string& flags, uint32_t& out, bool strict) { out = SF_NONE; for (const auto flag : flags) { switch (flag) { case 'C': out |= SF_CTCP_USER; break; case 'c': out |= SF_CTCP_CHANNEL; break; case 'd': out |= SF_DEFAULT; break; case 'H': out |= SF_HIDE_SILENCER; break; case 'i': out |= SF_INVITE; break; case 'N': out |= SF_NOTICE_USER; break; case 'n': out |= SF_NOTICE_CHANNEL; break; case 'P': out |= SF_PRIVMSG_USER; break; case 'p': out |= SF_PRIVMSG_CHANNEL; break; case 'T': out |= SF_TAGMSG_USER; break; case 't': out |= SF_TAGMSG_CHANNEL; break; case 'x': out |= SF_EXEMPT; break; default: if (!strict) continue; out = SF_NONE; return false; } } return true; } // Converts a bitmask to a flag list. static std::string BitsToFlags(uint32_t flags) { std::string out; if (flags & SF_CTCP_USER) out.push_back('C'); if (flags & SF_CTCP_CHANNEL) out.push_back('c'); if (flags & SF_HIDE_SILENCER) out.push_back('H'); if (flags & SF_INVITE) out.push_back('i'); if (flags & SF_NOTICE_USER) out.push_back('N'); if (flags & SF_NOTICE_CHANNEL) out.push_back('n'); if (flags & SF_PRIVMSG_USER) out.push_back('P'); if (flags & SF_PRIVMSG_CHANNEL) out.push_back('p'); if (flags & SF_TAGMSG_USER) out.push_back('T'); if (flags & SF_TAGMSG_CHANNEL) out.push_back('t'); if (flags & SF_EXEMPT) out.push_back('x'); return out; } }; typedef insp::flat_set<SilenceEntry> SilenceList; class SilenceExtItem final : public SimpleExtItem<SilenceList> { public: unsigned long maxsilence; SilenceExtItem(Module* Creator) : SimpleExtItem<SilenceList>(Creator, "silence-list", ExtensionType::USER) { } void FromInternal(Extensible* container, const std::string& value) noexcept override { if (container->extype != this->extype) return; LocalUser* user = IS_LOCAL(static_cast<User*>(container)); if (!user) return; // Remove the old list and create a new one. Unset(user, false); auto* list = new SilenceList(); irc::spacesepstream ts(value); while (!ts.StreamEnd()) { // Check we have space for another entry. if (list->size() >= maxsilence) { ServerInstance->Logs.Debug(MODNAME, "Oversized silence list received for {}: {}", user->uuid, value); delete list; return; } // Extract the mask and the flags. std::string mask; std::string flagstr; if (!ts.GetToken(mask) || !ts.GetToken(flagstr)) { ServerInstance->Logs.Debug(MODNAME, "Malformed silence list received for {}: {}", user->uuid, value); delete list; return; } // Try to parse the flags. uint32_t flags; if (!SilenceEntry::FlagsToBits(flagstr, flags, false)) { ServerInstance->Logs.Debug(MODNAME, "Malformed silence flags received for {}: {}", user->uuid, flagstr); delete list; return; } // Store the silence entry. list->emplace(flags, mask); } // If we have an empty list then don't store it. if (list->empty()) { delete list; return; } // The value was well formed. Set(user, list, false); } std::string ToInternal(const Extensible* container, void* item) const noexcept override { SilenceList* list = static_cast<SilenceList*>(item); std::string buf; for (SilenceList::const_iterator iter = list->begin(); iter != list->end(); ++iter) { if (iter != list->begin()) buf.push_back(' '); buf.append(iter->mask); buf.push_back(' '); buf.append(SilenceEntry::BitsToFlags(iter->flags)); } return buf; } }; class SilenceMessage final : public ClientProtocol::Message { public: SilenceMessage(const std::string& mask, const std::string& flags) : ClientProtocol::Message("SILENCE") { PushParam(mask); PushParam(flags); } }; class CommandSilence final : public SplitCommand { private: ClientProtocol::EventProvider msgprov; CmdResult AddSilence(LocalUser* user, const std::string& mask, uint32_t flags) { SilenceList* list = ext.Get(user); if (list && list->size() > ext.maxsilence) { user->WriteNumeric(ERR_SILELISTFULL, mask, SilenceEntry::BitsToFlags(flags), "Your SILENCE list is full"); return CmdResult::FAILURE; } else if (!list) { // There is no list; create it. list = new SilenceList(); ext.Set(user, list); } if (!list->emplace(flags, mask).second) { user->WriteNumeric(ERR_SILENCE, mask, SilenceEntry::BitsToFlags(flags), "The SILENCE entry you specified already exists"); return CmdResult::FAILURE; } SilenceMessage msg("+" + mask, SilenceEntry::BitsToFlags(flags)); user->Send(msgprov, msg); return CmdResult::SUCCESS; } CmdResult RemoveSilence(LocalUser* user, const std::string& mask, uint32_t flags) { SilenceList* list = ext.Get(user); if (list) { for (SilenceList::iterator iter = list->begin(); iter != list->end(); ++iter) { if (!irc::equals(iter->mask, mask) || iter->flags != flags) continue; list->erase(iter); SilenceMessage msg("-" + mask, SilenceEntry::BitsToFlags(flags)); user->Send(msgprov, msg); return CmdResult::SUCCESS; } } user->WriteNumeric(ERR_SILENCE, mask, SilenceEntry::BitsToFlags(flags), "The SILENCE entry you specified could not be found"); return CmdResult::FAILURE; } CmdResult ShowSilenceList(LocalUser* user) { SilenceList* list = ext.Get(user); if (list) { for (const auto& entry : *list) user->WriteNumeric(RPL_SILELIST, entry.mask, SilenceEntry::BitsToFlags(entry.flags)); } user->WriteNumeric(RPL_ENDOFSILELIST, "End of SILENCE list"); return CmdResult::SUCCESS; } public: SilenceExtItem ext; CommandSilence(Module* Creator) : SplitCommand(Creator, "SILENCE") , msgprov(Creator, "SILENCE") , ext(Creator) { syntax = { "[(+|-)<mask> [CcdiNnPpTtx]]" }; } CmdResult HandleLocal(LocalUser* user, const Params& parameters) override { if (parameters.empty()) return ShowSilenceList(user); // If neither add nor remove are specified we default to add. bool is_remove = parameters[0][0] == '-'; // If a prefix mask has been given then strip it and clean it up. std::string mask = parameters[0]; if (mask[0] == '-' || mask[0] == '+') { mask.erase(0, 1); if (mask.empty()) mask.assign("*"); ModeParser::CleanMask(mask); } // If the user specified a flags then use that. Otherwise, default to blocking // all CTCPs, invites, notices, privmsgs, and invites. uint32_t flags = SilenceEntry::SF_DEFAULT; if (parameters.size() > 1) { if (!SilenceEntry::FlagsToBits(parameters[1], flags, true)) { user->WriteNumeric(ERR_SILENCE, mask, parameters[1], "You specified one or more invalid SILENCE flags"); return CmdResult::FAILURE; } else if (flags == SilenceEntry::SF_EXEMPT) { // The user specified "x" with no other flags which does not make sense; add the "d" flag. flags |= SilenceEntry::SF_DEFAULT; } } return is_remove ? RemoveSilence(user, mask, flags) : AddSilence(user, mask, flags); } }; class ModuleSilence final : public Module , public CTCTags::EventListener , public ISupport::EventListener { private: bool exemptservice; CommandSilence cmd; void BuildChannelExempts(User* source, Channel* channel, SilenceEntry::SilenceFlags flag, CUList& exemptions, CUList& hides) { for (const auto& [user, _] : channel->GetUsers()) { uint32_t flags; if (!CanReceiveMessage(source, user, flag, &flags)) { exemptions.insert(user); if (user != source && flags & SilenceEntry::SF_HIDE_SILENCER) hides.insert(user); } } } bool CanReceiveMessage(User* source, User* target, SilenceEntry::SilenceFlags flag, uint32_t* flags = nullptr) { // Servers handle their own clients. if (!IS_LOCAL(target)) return true; if (exemptservice && source->server->IsService()) return true; SilenceList* list = cmd.ext.Get(target); if (!list) return true; for (const auto& entry : *list) { if (!(entry.flags & flag)) continue; if (InspIRCd::Match(source->GetMask(), entry.mask)) { if (flags) *flags = entry.flags; return entry.flags & SilenceEntry::SF_EXEMPT; } } return true; } void HideMessage(std::string& message) { InspIRCd::StripColor(message); message.insert(0, "\x1DSilenced\x1D: \00315,15"); } public: ModuleSilence() : Module(VF_VENDOR | VF_OPTCOMMON, "Adds the /SILENCE command which allows users to ignore other users on server-side.") , CTCTags::EventListener(this) , ISupport::EventListener(this) , cmd(this) { } void ReadConfig(ConfigStatus& status) override { const auto& tag = ServerInstance->Config->ConfValue("silence"); exemptservice = tag->getBool("exemptservice", tag->getBool("exemptuline", true)); cmd.ext.maxsilence = tag->getNum<unsigned long>("maxentries", 32, 1); } void OnBuildISupport(ISupport::TokenMap& tokens) override { tokens["ESILENCE"] = "CcdiNnPpTtx"; tokens["SILENCE"] = ConvToStr(cmd.ext.maxsilence); } ModResult OnUserPreInvite(User* source, User* dest, Channel* channel, time_t timeout) override { return CanReceiveMessage(source, dest, SilenceEntry::SF_INVITE) ? MOD_RES_PASSTHRU : MOD_RES_DENY; } ModResult OnUserPreMessage(User* user, MessageTarget& target, MessageDetails& details) override { std::string_view ctcpname; bool is_ctcp = details.IsCTCP(ctcpname) && !irc::equals(ctcpname, "ACTION"); SilenceEntry::SilenceFlags flag = SilenceEntry::SF_NONE; switch (target.type) { case MessageTarget::TYPE_CHANNEL: { if (is_ctcp) flag = SilenceEntry::SF_CTCP_CHANNEL; else if (details.type == MessageType::NOTICE) flag = SilenceEntry::SF_NOTICE_CHANNEL; else if (details.type == MessageType::PRIVMSG) flag = SilenceEntry::SF_PRIVMSG_CHANNEL; CUList hides; BuildChannelExempts(user, target.Get<Channel>(), flag, details.exemptions, hides); if (!hides.empty()) { // In this mode we just strip formatting and hide the message. std::string message = details.text; HideMessage(message); // Servers handle their own users so this cast will always work. ClientProtocol::Messages::Privmsg msg(user, target.Get<Channel>(), message, details.type, target.status); for (auto* hideuser : hides) static_cast<LocalUser*>(hideuser)->Send(ServerInstance->GetRFCEvents().privmsg, msg); } return MOD_RES_PASSTHRU; } case MessageTarget::TYPE_USER: { if (is_ctcp) flag = SilenceEntry::SF_CTCP_USER; else if (details.type == MessageType::NOTICE) flag = SilenceEntry::SF_NOTICE_USER; else if (details.type == MessageType::PRIVMSG) flag = SilenceEntry::SF_PRIVMSG_USER; uint32_t flags; if (!CanReceiveMessage(user, target.Get<User>(), flag, &flags)) { details.echo_original = true; if (flags & SilenceEntry::SF_HIDE_SILENCER) { // In this mode we just strip formatting and hide the message. HideMessage(details.text); break; } return MOD_RES_DENY; } break; } case MessageTarget::TYPE_SERVER: break; } return MOD_RES_PASSTHRU; } ModResult OnUserPreTagMessage(User* user, MessageTarget& target, CTCTags::TagMessageDetails& details) override { if (target.type == MessageTarget::TYPE_CHANNEL) { CUList unused; BuildChannelExempts(user, target.Get<Channel>(), SilenceEntry::SF_TAGMSG_CHANNEL, details.exemptions, unused); return MOD_RES_PASSTHRU; } if (target.type == MessageTarget::TYPE_USER && !CanReceiveMessage(user, target.Get<User>(), SilenceEntry::SF_TAGMSG_USER)) { details.echo_original = true; return MOD_RES_DENY; } return MOD_RES_PASSTHRU; } }; MODULE_INIT(ModuleSilence) ������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/src/modules/m_spanningtree/����������������������������������������������������������0000775�0000000�0000000�00000000000�14771603147�0020617�5����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/src/modules/m_spanningtree/addline.cpp�����������������������������������������������0000664�0000000�0000000�00000005621�14771603147�0022727�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2018, 2020-2023, 2025 Sadie Powell <sadie@witchery.services> * Copyright (C) 2013-2014 Attila Molnar <attilamolnar@hush.com> * Copyright (C) 2012 Robby <robby@chatbelgie.be> * Copyright (C) 2009 Uli Schlachter <psychon@znc.in> * Copyright (C) 2009 Daniel De Graaf <danieldg@inspircd.org> * Copyright (C) 2008 Robin Burchell <robin+git@viroteck.net> * Copyright (C) 2008 Craig Edwards <brain@inspircd.org> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include "inspircd.h" #include "timeutils.h" #include "xline.h" #include "treeserver.h" #include "utils.h" #include "commands.h" CmdResult CommandAddLine::Handle(User* usr, Params& params) { XLineFactory* xlf = ServerInstance->XLines->GetFactory(params[0]); const std::string& setter = usr->nick; if (!xlf) { ServerInstance->SNO.WriteToSnoMask('x', "{} sent me an unknown ADDLINE type ({}).", setter, params[0]); return CmdResult::FAILURE; } XLine* xl = nullptr; try { xl = xlf->Generate(ServerInstance->Time(), ConvToNum<unsigned long>(params[4]), params[2], params[5], params[1]); } catch (const ModuleException& e) { ServerInstance->SNO.WriteToSnoMask('x', "Unable to ADDLINE type {} from {}: {}", params[0], setter, e.GetReason()); return CmdResult::FAILURE; } xl->SetCreateTime(ServerCommand::ExtractTS(params[3])); if (ServerInstance->XLines->AddLine(xl, nullptr)) { if (xl->duration) { ServerInstance->SNO.WriteToSnoMask('X', "{} added a timed {}{} on {}, expires in {} (on {}): {}", setter, params[0], params[0].length() <= 2 ? "-line" : "", params[1], Duration::ToLongString(xl->duration), Time::ToString(xl->expiry), params[5]); } else { ServerInstance->SNO.WriteToSnoMask('X', "{} added a permanent {}{} on {}: {}", setter, params[0], params[0].length() <= 2 ? "-line" : "", params[1], params[5]); } TreeServer* remoteserver = TreeServer::Get(usr); if (!remoteserver->IsBursting()) { ServerInstance->XLines->ApplyLines(); } return CmdResult::SUCCESS; } else { delete xl; return CmdResult::FAILURE; } } CommandAddLine::Builder::Builder(XLine* xline, User* user) : CmdBuilder(user, "ADDLINE") { push(xline->type); push(xline->Displayable()); push(xline->source); push_int(xline->set_time); push_int(xline->duration); push_last(xline->reason); } ���������������������������������������������������������������������������������������������������������������inspircd-4.7.0/src/modules/m_spanningtree/away.cpp��������������������������������������������������0000664�0000000�0000000�00000003200�14771603147�0022257�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2018, 2020, 2023 Sadie Powell <sadie@witchery.services> * Copyright (C) 2018 B00mX0r <b00mx0r@aureus.pw> * Copyright (C) 2013 Attila Molnar <attilamolnar@hush.com> * Copyright (C) 2012 Robby <robby@chatbelgie.be> * Copyright (C) 2009 Daniel De Graaf <danieldg@inspircd.org> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include "inspircd.h" #include "main.h" #include "utils.h" #include "commands.h" CmdResult CommandAway::HandleRemote(::RemoteUser* u, Params& params) { const auto prevstate = u->away; if (!params.empty()) { time_t awaytime = params.size() > 1 ? ServerCommand::ExtractTS(params[0]) : 0; u->away.emplace(params.back(), awaytime); awayevprov.Call(&Away::EventListener::OnUserAway, u, prevstate); } else { u->away.reset(); awayevprov.Call(&Away::EventListener::OnUserBack, u, prevstate); } return CmdResult::SUCCESS; } CommandAway::Builder::Builder(User* user) : CmdBuilder(user, "AWAY") { if (user->IsAway()) push_int(user->away->time).push_last(user->away->message); } ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/src/modules/m_spanningtree/cachetimer.h����������������������������������������������0000664�0000000�0000000�00000002315�14771603147�0023075�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2013, 2021 Sadie Powell <sadie@witchery.services> * Copyright (C) 2013, 2015 Attila Molnar <attilamolnar@hush.com> * Copyright (C) 2012 Robby <robby@chatbelgie.be> * Copyright (C) 2007 Robin Burchell <robin+git@viroteck.net> * Copyright (C) 2007 Dennis Friis <peavey@inspircd.org> * Copyright (C) 2007 Craig Edwards <brain@inspircd.org> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #pragma once /** Timer that fires when we need to refresh the IP cache of servers */ class CacheRefreshTimer final : public Timer { public: CacheRefreshTimer(); bool Tick() override; }; �������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/src/modules/m_spanningtree/capab.cpp�������������������������������������������������0000664�0000000�0000000�00000050106�14771603147�0022373�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2017-2025 Sadie Powell <sadie@witchery.services> * Copyright (C) 2013-2016 Attila Molnar <attilamolnar@hush.com> * Copyright (C) 2012 Robby <robby@chatbelgie.be> * Copyright (C) 2009-2010 Daniel De Graaf <danieldg@inspircd.org> * Copyright (C) 2008 Robin Burchell <robin+git@viroteck.net> * Copyright (C) 2008 Craig Edwards <brain@inspircd.org> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include "inspircd.h" #include "dynamic.h" #include "modules/extban.h" #include "utility/map.h" #include "treeserver.h" #include "utils.h" #include "link.h" #include "main.h" namespace { // A map which holds the difference between local and remote tokens. typedef std::map<std::string, std::pair<std::optional<std::string>, std::optional<std::string>>, irc::insensitive_swo> TokenDiff; // Builds a list of the local modules with the specified property. CapabData::ModuleMap BuildModuleList(ModuleFlags property, uint16_t protocol) { CapabData::ModuleMap modules; for (const auto& [name, module] : ServerInstance->Modules.GetModules()) { if (!(module->properties & property)) continue; std::string modname; size_t endpos = name.length() - strlen(DLL_EXTENSION); if (protocol <= PROTO_INSPIRCD_3) { // Replace m_foo.dylib with m_foo.so modname.append(name.substr(0, endpos)).append(".so"); // Handle renamed modules. if (insp::equalsci(modname, "m_cloak.so") && ServerInstance->Modules.Find("cloak_md5")) modname = "m_cloaking.so"; else if (insp::equalsci(modname, "m_realnameban.so")) modname = "m_gecosban.so"; else if (insp::equalsci(modname, "m_account.so") && ServerInstance->Modules.Find("services")) modname = "m_services_account.so"; else if (insp::equalsci(modname, "m_services.so")) { modules["m_svshold.so"]; modules["m_topiclock.so"]; continue; } // Handle modules with changed properties. else if (insp::equalsci(modname, "m_globops.so")) continue; // This module was made VF_OPTCOMMON in v4. } else { // Replace m_foo.dylib with foo size_t startpos = name.compare(0, 2, "m_", 2) ? 0 : 2; modname.assign(name.substr(startpos, endpos - startpos)); } modules[modname] = SpanningTreeUtilities::BuildLinkString(protocol, module); } return modules; } // Compares the module data sent by a remote server to that of the local server. bool CompareModuleData(Module* mod, const Module::LinkData& otherdata, std::ostringstream& diffconfig) { Module::LinkDataDiff datadiff; mod->CompareLinkData(otherdata, datadiff); if (!datadiff.empty()) { diffconfig << ' ' << ModuleManager::ShrinkModName(mod->ModuleFile) << " ("; bool first = true; for (const auto& [key, values] : datadiff) { // Keys are separated by commas. if (!first) diffconfig << ", "; first = false; diffconfig << key; if (values.first && values.second) { // Exists on both but with a different value. diffconfig << " set to " << *values.first << " here and " << *values.second << " there"; } else if (values.first && !values.second) { // Only exists on the local server. diffconfig << " only set here"; } else if (!values.first && values.second) { // Only exists on the remote server. diffconfig << " only set there"; } } diffconfig << ')'; return false; } return true; } // Compares the lists of module on a remote v3 server to the local server. bool CompareModulesOld(ModuleFlags property, const CapabData::ModuleMap& remote, std::ostringstream& diffconfig, std::ostringstream& localmissing, std::ostringstream& remotemissing) { // Retrieve the local module list and compare to the remote. CapabData::ModuleMap mymodules = BuildModuleList(property, PROTO_INSPIRCD_3); TokenDiff modulediff; insp::map::difference(mymodules, remote, modulediff); for (const auto& [module, values] : modulediff) { if (values.first && values.second) { // Exists on both but with different link data. diffconfig << ' ' << module << " (" << *values.first << " here, " << *values.second << " there)"; } else if (values.first && !values.second) { // Only exists on the local server. remotemissing << ' ' << module; } else if (!values.first && values.second) { // Only exists on the remote server. localmissing << ' ' << module; } } return modulediff.empty(); } // Compares the lists of module on a remote v4+ server to the local server. bool CompareModulesNew(ModuleFlags property, const CapabData::ModuleMap& remote, std::ostringstream& diffconfig, std::ostringstream& localmissing, std::ostringstream& remotemissing) { // Retrieve the local module list. bool okay = true; ModuleManager::ModuleMap local; for (const auto& [name, module] : ServerInstance->Modules.GetModules()) { if (module->properties & property) local[ModuleManager::ShrinkModName(name)] = module; } for (const auto& [name, linkdata] : remote) { auto moditer = local.find(name); if (moditer == local.end()) { // Only exists on the remote server. localmissing << ' ' << name; okay = false; continue; } // Parse the remote link data. Module::LinkData otherdata; irc::sepstream datastream(linkdata, '&'); for (std::string datapair; datastream.GetToken(datapair); ) { size_t split = datapair.find('='); if (split == std::string::npos) otherdata.emplace(datapair, ""); else otherdata.emplace(datapair.substr(0, split), Percent::Decode(datapair.substr(split + 1))); } // Compare the link data. if (!CompareModuleData(moditer->second, otherdata, diffconfig)) okay = false; local.erase(moditer); } for (const auto& [name, _] : local) { // Only exists on the local server. remotemissing << ' ' << name; okay = false; } return okay; } // Compares the lists of module on a remote server to the local server. bool CompareModules(ModuleFlags property, uint16_t protocol, std::optional<CapabData::ModuleMap>& remote, std::ostringstream& out) { // If the remote didn't send a module list then don't compare. if (!remote) return true; bool okay; std::ostringstream diffconfig; std::ostringstream localmissing; std::ostringstream remotemissing; if (protocol <= PROTO_INSPIRCD_3) okay = CompareModulesOld(property, *remote, diffconfig, localmissing, remotemissing); else okay = CompareModulesNew(property, *remote, diffconfig, localmissing, remotemissing); if (!diffconfig.str().empty()) out << " Loaded on both with different config:" << diffconfig.str() << '.'; if (!localmissing.str().empty()) out << " Not loaded on the local server:" << localmissing.str() << '.'; if (!remotemissing.str().empty()) out << " Not loaded on the remote server:" << remotemissing.str() << '.'; return okay; } // Generates a module list in the format "m_foo.so=bar m_bar.so=baz". std::string FormatModules(ModuleFlags property, uint16_t protocol) { std::ostringstream modules; CapabData::ModuleMap mymodules = BuildModuleList(property, protocol); for (const auto& [module, linkdata] : mymodules) { modules << module; if (!linkdata.empty()) modules << '=' << linkdata; modules << ' '; } return modules.str(); } // Parses a module list in the format "m_foo.so=bar m_bar.so=baz" to a map. void ParseModules(const std::string& modlist, std::optional<CapabData::ModuleMap>& out) { CapabData::ModuleMap& map = out ? *out : out.emplace(); irc::spacesepstream modstream(modlist); for (std::string mod; modstream.GetToken(mod); ) { size_t split = mod.find('='); if (split == std::string::npos) map.emplace(mod, ""); else map.emplace(mod.substr(0, split), mod.substr(split + 1)); } } } std::string TreeSocket::BuildModeList(ModeType mtype) { std::vector<std::string> modes; for (const auto& [_, mh] : ServerInstance->Modes.GetModes(mtype)) { const PrefixMode* const pm = mh->IsPrefixMode(); std::string mdesc; if (pm) mdesc.append("prefix:").append(ConvToStr(pm->GetPrefixRank())).push_back(':'); else if (mh->IsListMode()) mdesc.append("list:"); else if (mh->NeedsParam(true)) mdesc.append(mh->NeedsParam(false) ? "param:" : "param-set:"); else mdesc.append("simple:"); mdesc.append(mh->name); mdesc.push_back('='); if (pm) { if (pm->GetPrefix()) mdesc.push_back(pm->GetPrefix()); } mdesc.push_back(mh->GetModeChar()); modes.push_back(mdesc); } std::sort(modes.begin(), modes.end()); return insp::join(modes); } bool TreeSocket::BuildExtBanList(std::string& out) { ExtBan::ManagerRef extbanmgr(Utils->Creator); if (!extbanmgr) return false; const auto& extbans = extbanmgr->GetNameMap(); for (auto iter = extbans.begin(); iter != extbans.end(); ++iter) { if (iter != extbans.begin()) out.push_back(' '); const ExtBan::Base* extban = iter->second; switch (extban->GetType()) { case ExtBan::Type::ACTING: out.append("acting:"); break; case ExtBan::Type::MATCHING: out.append("matching:"); break; } out.append(extban->GetName()); if (extban->GetLetter()) out.append("=").push_back(extban->GetLetter()); } return true; } void TreeSocket::SendCapabilities(int phase) { if (capab->capab_phase >= phase) return; if (capab->capab_phase < 1 && phase >= 1) WriteLine(INSP_FORMAT("CAPAB START {}", (uint16_t)PROTO_NEWEST)); capab->capab_phase = phase; if (phase < 2) return; WriteLine("CAPAB MODULES :" + FormatModules(VF_COMMON, proto_version)); WriteLine("CAPAB MODSUPPORT :" + FormatModules(VF_OPTCOMMON, proto_version)); WriteLine("CAPAB CHANMODES :" + BuildModeList(MODETYPE_CHANNEL)); WriteLine("CAPAB USERMODES :" + BuildModeList(MODETYPE_USER)); std::unordered_map<std::string, std::string> capabilities = { { "CASEMAPPING", ServerInstance->Config->CaseMapping }, { "MAXAWAY", ConvToStr(ServerInstance->Config->Limits.MaxAway) }, { "MAXCHANNEL", ConvToStr(ServerInstance->Config->Limits.MaxChannel) }, { "MAXHOST", ConvToStr(ServerInstance->Config->Limits.MaxHost) }, { "MAXKICK", ConvToStr(ServerInstance->Config->Limits.MaxKick) }, { "MAXLINE", ConvToStr(ServerInstance->Config->Limits.MaxLine) }, { "MAXMODES", ConvToStr(ServerInstance->Config->Limits.MaxModes) }, { "MAXNICK", ConvToStr(ServerInstance->Config->Limits.MaxNick) }, { "MAXQUIT", ConvToStr(ServerInstance->Config->Limits.MaxQuit) }, { "MAXREAL", ConvToStr(ServerInstance->Config->Limits.MaxReal) }, { "MAXTOPIC", ConvToStr(ServerInstance->Config->Limits.MaxTopic) }, { "MAXUSER", ConvToStr(ServerInstance->Config->Limits.MaxUser) }, }; ExtBan::ManagerRef extbanmgr(Utils->Creator); if (proto_version <= PROTO_INSPIRCD_3) { // 1205 HACK: Allow services to know what extbans exist. if (extbanmgr) { std::string extbans; for (const auto& [extban, _] : extbanmgr->GetLetterMap()) extbans.push_back(extban); if (!extbans.empty()) capabilities["EXTBANS"] = extbans; } // These have been renamed in the 1206 protocol. capabilities["CHANMAX"] = capabilities["MAXCHANNEL"]; capabilities["IDENTMAX"] = capabilities["MAXUSER"]; capabilities["NICKMAX"] = capabilities["MAXNICK"]; // Advertise the presence or absence of the globops snomask in CAPAB CAPABILITIES. Services // needs to know about it and since m_globops is not marked as VF_(OPT)COMMON in v3 we // advertise it here to not break linking to previous versions. capabilities["GLOBOPS"] = ConvToStr(!!ServerInstance->Modules.Find("globops")); } else { std::string extbans; if (BuildExtBanList(extbans)) WriteLine("CAPAB EXTBANS :" + extbans); if (extbanmgr) { std::string& xbformat = capabilities["EXTBANFORMAT"]; switch (extbanmgr->GetFormat()) { case ExtBan::Format::ANY: xbformat = "any"; break; case ExtBan::Format::NAME: xbformat = "name"; break; case ExtBan::Format::LETTER: xbformat = "letter"; break; } } } // If SHA256 hashing support is available then send a challenge token. if (ServerInstance->Modules.FindService(SERVICE_DATA, "hash/sha256")) { SetOurChallenge(ServerInstance->GenRandomStr(20)); capabilities["CHALLENGE"] = GetOurChallenge(); } std::stringstream capabilitystr; char separator = ':'; for (const auto& [capkey, capvalue] : capabilities) { capabilitystr << separator << capkey << '=' << capvalue; separator = ' '; } this->WriteLine("CAPAB CAPABILITIES " + capabilitystr.str()); this->WriteLine("CAPAB END"); } /* Isolate and return the elements that are different between two comma separated lists */ void TreeSocket::ListDifference(const std::string& one, const std::string& two, char sep, std::string& mleft, std::string& mright) { std::set<std::string> values; irc::sepstream sepleft(one, sep); irc::sepstream sepright(two, sep); std::string item; while (sepleft.GetToken(item)) { values.insert(item); } while (sepright.GetToken(item)) { if (!values.erase(item)) { mright.push_back(sep); mright.append(item); } } for (const auto& value : values) { mleft.push_back(sep); mleft.append(value); } } bool TreeSocket::Capab(const CommandBase::Params& params) { if (params.empty()) { this->SendError("Invalid number of parameters for CAPAB - Mismatched version"); return false; } if (irc::equals(params[0], "START")) { capab->requiredmodules.reset(); capab->optionalmodules.reset(); capab->CapKeys.clear(); if (params.size() > 1) proto_version = ConvToNum<uint16_t>(params[1]); if (proto_version < PROTO_OLDEST) { SendError("CAPAB negotiation failed: Server is using protocol version " + (proto_version ? ConvToStr(proto_version) : "1201 or older") + " which is too old to link with this server (protocol versions " + ConvToStr(PROTO_OLDEST) + " to " + ConvToStr(PROTO_NEWEST) + " are supported)"); return false; } SendCapabilities(2); } else if (irc::equals(params[0], "END")) { std::ostringstream errormsg; if (!CompareModules(VF_COMMON, proto_version, this->capab->requiredmodules, errormsg)) { SendError("CAPAB negotiation failed. Required modules incorrectly matched on these servers." + errormsg.str()); return false; } else if (!CompareModules(VF_OPTCOMMON, proto_version, this->capab->optionalmodules, errormsg)) { if (Utils->AllowOptCommon) { ServerInstance->SNO.WriteToSnoMask('l', "Optional modules do not match. Some features may not work globally!" + errormsg.str()); } else { SendError("CAPAB negotiation failed. Optional modules incorrectly matched on these servers and <options:allowmismatch> is not enabled." + errormsg.str()); return false; } } if (!capab->ChanModes.empty()) { if (capab->ChanModes != BuildModeList(MODETYPE_CHANNEL)) { std::string diffIneed; std::string diffUneed; ListDifference(capab->ChanModes, BuildModeList(MODETYPE_CHANNEL), ' ', diffIneed, diffUneed); if (diffIneed.length() || diffUneed.length()) { std::string reason = "Channel modes not matched on these servers."; if (diffIneed.length()) reason += " Not loaded here:" + diffIneed; if (diffUneed.length()) reason += " Not loaded there:" + diffUneed; this->SendError("CAPAB negotiation failed: " + reason); } } } if (!capab->UserModes.empty()) { if (capab->UserModes != BuildModeList(MODETYPE_USER)) { std::string diffIneed; std::string diffUneed; ListDifference(capab->UserModes, BuildModeList(MODETYPE_USER), ' ', diffIneed, diffUneed); if (diffIneed.length() || diffUneed.length()) { std::string reason = "User modes not matched on these servers."; if (diffIneed.length()) reason += " Not loaded here:" + diffIneed; if (diffUneed.length()) reason += " Not loaded there:" + diffUneed; this->SendError("CAPAB negotiation failed: " + reason); } } } if (!capab->ExtBans.empty()) { std::string myextbans; if (BuildExtBanList(myextbans)) { std::string missing_here; std::string missing_there; ListDifference(capab->ExtBans, myextbans, ' ', missing_here, missing_there); if (!missing_here.empty() || !missing_there.empty()) { if (Utils->AllowOptCommon) { ServerInstance->SNO.WriteToSnoMask('l', "ExtBan lists do not match, some bans/exemptions may not work globally.{}{}{}{}", missing_here.length() ? " Not loaded here:" : "", missing_here, missing_there.length() ? " Not loaded there:" : "", missing_there); } else { std::string reason = "ExtBans not matched on these servers."; if (missing_here.length()) reason += " Not loaded here:" + missing_here; if (missing_there.length()) reason += " Not loaded there:" + missing_there; this->SendError("CAPAB negotiation failed: " + reason); return false; } } } } if (this->capab->CapKeys.find("CASEMAPPING") != this->capab->CapKeys.end()) { const std::string casemapping = this->capab->CapKeys.find("CASEMAPPING")->second; if (casemapping != ServerInstance->Config->CaseMapping) { std::string reason = "The casemapping of the remote server differs to that of the local server." " Local casemapping: " + ServerInstance->Config->CaseMapping + " Remote casemapping: " + casemapping; this->SendError("CAPAB negotiation failed: " + reason); return false; } } /* Challenge response, store their challenge for our password */ std::map<std::string, std::string>::iterator n = this->capab->CapKeys.find("CHALLENGE"); if ((n != this->capab->CapKeys.end()) && (ServerInstance->Modules.FindService(SERVICE_DATA, "hash/sha256"))) { /* Challenge-response is on now */ this->SetTheirChallenge(n->second); if (!this->GetTheirChallenge().empty() && (this->LinkState == CONNECTING)) { this->SendCapabilities(2); this->WriteLine(INSP_FORMAT("SERVER {} {} {}{} :{}", ServerInstance->Config->ServerName, TreeSocket::MakePass(capab->link->SendPass, capab->theirchallenge), proto_version == PROTO_INSPIRCD_3 ? "0 " : "", ServerInstance->Config->ServerId, ServerInstance->Config->ServerDesc )); } } else { // They didn't specify a challenge or we don't have sha256, we use plaintext if (this->LinkState == CONNECTING) { this->SendCapabilities(2); this->WriteLine(INSP_FORMAT("SERVER {} {} {}{} :{}", ServerInstance->Config->ServerName, capab->link->SendPass, proto_version == PROTO_INSPIRCD_3 ? "0 " : "", ServerInstance->Config->ServerId, ServerInstance->Config->ServerDesc )); } } } else if (irc::equals(params[0] , "MODULES")) { if (params.size() >= 2) ParseModules(params[1], capab->requiredmodules); } else if (irc::equals(params[0], "MODSUPPORT")) { if (params.size() >= 2) ParseModules(params[1], capab->optionalmodules); } else if (irc::equals(params[0], "CHANMODES") && (params.size() == 2)) { capab->ChanModes = params[1]; } else if (irc::equals(params[0], "USERMODES") && (params.size() == 2)) { capab->UserModes = params[1]; } else if (irc::equals(params[0], "EXTBANS") && (params.size() == 2)) { capab->ExtBans = params[1]; } else if (irc::equals(params[0], "CAPABILITIES") && (params.size() == 2)) { irc::spacesepstream capabs(params[1]); std::string item; while (capabs.GetToken(item)) { /* Process each key/value pair */ std::string::size_type equals = item.find('='); if (equals != std::string::npos) { std::string var(item, 0, equals); std::string value(item, equals+1); capab->CapKeys[var] = value; } } } return true; } ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/src/modules/m_spanningtree/commandbuilder.h������������������������������������������0000664�0000000�0000000�00000007444�14771603147�0023766�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2019-2023 Sadie Powell <sadie@witchery.services> * Copyright (C) 2013-2015 Attila Molnar <attilamolnar@hush.com> * Copyright (C) 2013 Adam <Adam@anope.org> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #pragma once #include "utils.h" class TreeServer; class CmdBuilder { protected: /** The raw message contents. */ std::string content = ":"; /** Tags which have been added to this message. */ ClientProtocol::TagMap tags; /** The size of tags within the contents. */ size_t tagsize = 0; /** Fires the ServerProtocol::MessageEventListener::OnBuildServerMessage event. */ void FireEvent(const Server* target, const char* cmd, ClientProtocol::TagMap& taglist); /** Fires the ServerProtocol::MessageEventListener::OnBuildUserMessage. */ void FireEvent(const User* target, const char* cmd, ClientProtocol::TagMap& taglist); /** Updates the tag string within the buffer. */ void UpdateTags(); public: CmdBuilder(const char* cmd) { content.append(ServerInstance->Config->ServerId); push(cmd); FireEvent(ServerInstance->FakeClient->server, cmd, tags); } CmdBuilder(const TreeServer* src, const char* cmd) { content.append(src->GetId()); push(cmd); FireEvent(src, cmd, tags); } CmdBuilder(const User* src, const char* cmd) { content.append(src->uuid); push(cmd); if (InspIRCd::IsSID(src->uuid)) FireEvent(src->server, cmd, tags); else FireEvent(src, cmd, tags); } CmdBuilder& push_raw(const std::string& s) { content.append(s); return *this; } CmdBuilder& push_raw(const char* s) { content.append(s); return *this; } CmdBuilder& push_raw(char c) { content.push_back(c); return *this; } template <typename T> CmdBuilder& push_raw_int(T i) { content.append(ConvToStr(i)); return *this; } template <typename InputIterator> CmdBuilder& push_raw(InputIterator first, InputIterator last) { content.append(first, last); return *this; } CmdBuilder& push(const std::string& s) { content.push_back(' '); content.append(s); return *this; } CmdBuilder& push(const char* s) { content.push_back(' '); content.append(s); return *this; } CmdBuilder& push(char c) { content.push_back(' '); content.push_back(c); return *this; } template <typename T> CmdBuilder& push_int(T i) { content.push_back(' '); content.append(ConvToStr(i)); return *this; } CmdBuilder& push_last(const std::string& s) { content.push_back(' '); content.push_back(':'); content.append(s); return *this; } CmdBuilder& push_tags(ClientProtocol::TagMap newtags) { // It has to be this way around so new tags get priority. newtags.insert(tags.begin(), tags.end()); std::swap(tags, newtags); UpdateTags(); return *this; } template<typename T> CmdBuilder& insert(const T& cont) { for (const auto& elem : cont) push(elem); return *this; } const std::string& str() const { return content; } operator const std::string&() const { return str(); } void Broadcast() const { Utils->DoOneToAllButSender(*this, nullptr); } void Forward(const TreeServer* omit) const { Utils->DoOneToAllButSender(*this, omit); } void Unicast(const User* target) const { Utils->DoOneToOne(*this, target->server); } }; ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/src/modules/m_spanningtree/commands.h������������������������������������������������0000664�0000000�0000000�00000031272�14771603147�0022576�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2013, 2018-2019, 2021-2024 Sadie Powell <sadie@witchery.services> * Copyright (C) 2012-2016 Attila Molnar <attilamolnar@hush.com> * Copyright (C) 2012 Robby <robby@chatbelgie.be> * Copyright (C) 2010 Daniel De Graaf <danieldg@inspircd.org> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #pragma once #include "servercommand.h" #include "commandbuilder.h" #include "remoteuser.h" #include "modules/away.h" namespace SpanningTree { class CommandAway; class CommandNick; class CommandPing; class CommandPong; class CommandServer; } using SpanningTree::CommandAway; using SpanningTree::CommandNick; using SpanningTree::CommandPing; using SpanningTree::CommandPong; using SpanningTree::CommandServer; class CommandRConnect final : public Command { public: CommandRConnect(Module* Creator); CmdResult Handle(User* user, const Params& parameters) override; RouteDescriptor GetRouting(User* user, const Params& parameters) override; }; class CommandRSQuit final : public Command { public: CommandRSQuit(Module* Creator); CmdResult Handle(User* user, const Params& parameters) override; RouteDescriptor GetRouting(User* user, const Params& parameters) override; }; class CommandMap final : public Command { public: CommandMap(Module* Creator); CmdResult Handle(User* user, const Params& parameters) override; RouteDescriptor GetRouting(User* user, const Params& parameters) override; }; class CommandMetadata final : public ServerCommand { public: CommandMetadata(Module* Creator) : ServerCommand(Creator, "METADATA", 2) { } CmdResult Handle(User* user, Params& params) override; class Builder final : public CmdBuilder { public: Builder(const Extensible* ext, const std::string& key, const std::string& val); Builder(const std::string& key, const std::string& val); }; }; class CommandUID final : public ServerOnlyServerCommand<CommandUID> { public: CommandUID(Module* Creator) : ServerOnlyServerCommand<CommandUID>(Creator, "UID", 11) { } CmdResult HandleServer(TreeServer* server, CommandBase::Params& params); class Builder final : public CmdBuilder { public: Builder(User* user); }; }; class CommandOpertype final : public UserOnlyServerCommand<CommandOpertype> { public: CommandOpertype(Module* Creator) : UserOnlyServerCommand<CommandOpertype>(Creator, "OPERTYPE", 1) { } CmdResult HandleRemote(RemoteUser* user, Params& params); class Builder final : public CmdBuilder { public: Builder(User* user, const std::shared_ptr<OperAccount>& oper, bool automatic = false); }; }; class TreeSocket; class FwdFJoinBuilder; class CommandFJoin final : public ServerCommand { /** Remove all modes from a channel, including statusmodes (+qaovh etc), simplemodes, parameter modes. * This does not update the timestamp of the target channel, this must be done separately. */ static void RemoveStatus(Channel* c); /** * Lowers the TS on the given channel: removes all modes, unsets all extensions, * clears the topic and removes all pending invites. * @param chan The target channel whose TS to lower * @param TS The new TS to set * @param newname The new name of the channel; must be the same or a case change of the current name */ static void LowerTS(Channel* chan, time_t TS, const std::string& newname); static void ProcessModeUUIDPair(const std::string& item, TreeServer* sourceserver, Channel* chan, Modes::ChangeList* modechangelist, FwdFJoinBuilder& fwdfjoin); public: CommandFJoin(Module* Creator) : ServerCommand(Creator, "FJOIN", 3) { } CmdResult Handle(User* user, Params& params) override; RouteDescriptor GetRouting(User* user, const Params& parameters) override { return ROUTE_LOCALONLY; } class Builder : public CmdBuilder { /** Maximum possible Membership::Id length in decimal digits, used for determining whether a user will fit into * a message or not */ static constexpr size_t membid_max_digits = 20; static constexpr size_t maxline = 510; std::string::size_type pos; protected: void add(Membership* memb, std::string::const_iterator mbegin, std::string::const_iterator mend); public: Builder(Channel* chan, TreeServer* source = Utils->TreeRoot); void add(Membership* memb) { const std::string modes = memb->GetAllPrefixModes(); add(memb, modes.begin(), modes.end()); } void clear(); const std::string& finalize(); }; }; class CommandFMode final : public ServerCommand { public: CommandFMode(Module* Creator) : ServerCommand(Creator, "FMODE", 3) { } CmdResult Handle(User* user, Params& params) override; }; class CommandFTopic final : public ServerCommand { public: CommandFTopic(Module* Creator) : ServerCommand(Creator, "FTOPIC", 4, 5) { } CmdResult Handle(User* user, Params& params) override; class Builder final : public CmdBuilder { public: Builder(Channel* chan); Builder(User* user, Channel* chan); }; }; class CommandFHost final : public UserOnlyServerCommand<CommandFHost> { public: CommandFHost(Module* Creator) : UserOnlyServerCommand<CommandFHost>(Creator, "FHOST", 2) { } CmdResult HandleRemote(RemoteUser* user, Params& params); }; class CommandFIdent final : public UserOnlyServerCommand<CommandFIdent> { public: CommandFIdent(Module* Creator) : UserOnlyServerCommand<CommandFIdent>(Creator, "FIDENT", 2) { } CmdResult HandleRemote(RemoteUser* user, Params& params); }; class CommandFName final : public UserOnlyServerCommand<CommandFName> { public: CommandFName(Module* Creator) : UserOnlyServerCommand<CommandFName>(Creator, "FNAME", 1) { } CmdResult HandleRemote(RemoteUser* user, Params& params); }; class CommandIJoin final : public UserOnlyServerCommand<CommandIJoin> { public: CommandIJoin(Module* Creator) : UserOnlyServerCommand<CommandIJoin>(Creator, "IJOIN", 2) { } CmdResult HandleRemote(RemoteUser* user, Params& params); }; class CommandResync final : public ServerOnlyServerCommand<CommandResync> { public: CommandResync(Module* Creator) : ServerOnlyServerCommand<CommandResync>(Creator, "RESYNC", 1) { } CmdResult HandleServer(TreeServer* server, Params& parameters); RouteDescriptor GetRouting(User* user, const Params& parameters) override { return ROUTE_LOCALONLY; } }; class SpanningTree::CommandAway final : public UserOnlyServerCommand<SpanningTree::CommandAway> { private: Away::EventProvider awayevprov; public: CommandAway(Module* Creator) : UserOnlyServerCommand<SpanningTree::CommandAway>(Creator, "AWAY", 0, 2) , awayevprov(Creator) { } CmdResult HandleRemote(::RemoteUser* user, Params& parameters); class Builder final : public CmdBuilder { public: Builder(User* user); }; }; class XLine; class CommandAddLine final : public ServerCommand { public: CommandAddLine(Module* Creator) : ServerCommand(Creator, "ADDLINE", 6, 6) { } CmdResult Handle(User* user, Params& parameters) override; class Builder final : public CmdBuilder { public: Builder(XLine* xline, User* user = ServerInstance->FakeClient); }; }; class CommandDelLine final : public ServerCommand { public: CommandDelLine(Module* Creator) : ServerCommand(Creator, "DELLINE", 2, 2) { } CmdResult Handle(User* user, Params& parameters) override; }; class CommandEncap final : public ServerCommand { public: CommandEncap(Module* Creator) : ServerCommand(Creator, "ENCAP", 2) { } CmdResult Handle(User* user, Params& parameters) override; RouteDescriptor GetRouting(User* user, const Params& parameters) override; }; class CommandIdle final : public UserOnlyServerCommand<CommandIdle> { public: CommandIdle(Module* Creator) : UserOnlyServerCommand<CommandIdle>(Creator, "IDLE", 1) { } CmdResult HandleRemote(RemoteUser* user, Params& parameters); RouteDescriptor GetRouting(User* user, const Params& parameters) override { return ROUTE_UNICAST(parameters[0]); } }; class SpanningTree::CommandNick final : public UserOnlyServerCommand<SpanningTree::CommandNick> { public: CommandNick(Module* Creator) : UserOnlyServerCommand<SpanningTree::CommandNick>(Creator, "NICK", 2) { } CmdResult HandleRemote(::RemoteUser* user, Params& parameters); }; class SpanningTree::CommandPing final : public ServerCommand { public: CommandPing(Module* Creator) : ServerCommand(Creator, "PING", 1) { } CmdResult Handle(User* user, Params& parameters) override; RouteDescriptor GetRouting(User* user, const Params& parameters) override { return ROUTE_UNICAST(parameters[0]); } }; class SpanningTree::CommandPong final : public ServerOnlyServerCommand<SpanningTree::CommandPong> { public: CommandPong(Module* Creator) : ServerOnlyServerCommand<SpanningTree::CommandPong>(Creator, "PONG", 1) { } CmdResult HandleServer(TreeServer* server, Params& parameters); RouteDescriptor GetRouting(User* user, const Params& parameters) override { return ROUTE_UNICAST(parameters[0]); } }; class DllExport CommandSave final : public ServerCommand { public: /** Timestamp of the uuid nick of all users who collided and got their nick changed to uuid */ static constexpr time_t SavedTimestamp = 100; CommandSave(Module* Creator) : ServerCommand(Creator, "SAVE", 2) { } CmdResult Handle(User* user, Params& parameters) override; }; class SpanningTree::CommandServer final : public ServerOnlyServerCommand<SpanningTree::CommandServer> { static void HandleExtra(TreeServer* newserver, Params& params); public: CommandServer(Module* Creator) : ServerOnlyServerCommand<SpanningTree::CommandServer>(Creator, "SERVER", 3) { } CmdResult HandleServer(TreeServer* server, Params& parameters); class Builder final : public CmdBuilder { void push_property(const char* key, const std::string& val) { push(key).push_raw('=').push_raw(val); } public: Builder(TreeServer* server); }; }; class CommandSQuit final : public ServerOnlyServerCommand<CommandSQuit> { public: CommandSQuit(Module* Creator) : ServerOnlyServerCommand<CommandSQuit>(Creator, "SQUIT", 2) { } CmdResult HandleServer(TreeServer* server, Params& parameters); }; class CommandSNONotice final : public ServerCommand { public: CommandSNONotice(Module* Creator) : ServerCommand(Creator, "SNONOTICE", 2) { } CmdResult Handle(User* user, Params& parameters) override; }; class CommandEndBurst final : public ServerOnlyServerCommand<CommandEndBurst> { public: CommandEndBurst(Module* Creator) : ServerOnlyServerCommand<CommandEndBurst>(Creator, "ENDBURST") { } CmdResult HandleServer(TreeServer* server, Params& parameters); }; class CommandSInfo final : public ServerOnlyServerCommand<CommandSInfo> { public: CommandSInfo(Module* Creator) : ServerOnlyServerCommand<CommandSInfo>(Creator, "SINFO", 2) { } CmdResult HandleServer(TreeServer* server, Params& parameters); class Builder final : public CmdBuilder { public: Builder(TreeServer* server, const char* type, const std::string& value); }; }; class CommandNum final : public ServerOnlyServerCommand<CommandNum> { public: CommandNum(Module* Creator) : ServerOnlyServerCommand<CommandNum>(Creator, "NUM", 3) { } CmdResult HandleServer(TreeServer* server, Params& parameters); RouteDescriptor GetRouting(User* user, const Params& parameters) override; class Builder final : public CmdBuilder { public: Builder(SpanningTree::RemoteUser* target, const Numeric::Numeric& numeric); }; }; class CommandLMode final : public ServerCommand { public: CommandLMode(Module* Creator) : ServerCommand(Creator, "LMODE", 3) { } CmdResult Handle(User* user, Params& params) override; }; class SpanningTreeCommands final { public: CommandMetadata metadata; CommandUID uid; CommandOpertype opertype; CommandFJoin fjoin; CommandIJoin ijoin; CommandResync resync; CommandFMode fmode; CommandFTopic ftopic; CommandFHost fhost; CommandFHost frhost; CommandFIdent fident; CommandFName fname; SpanningTree::CommandAway away; CommandAddLine addline; CommandDelLine delline; CommandEncap encap; CommandIdle idle; SpanningTree::CommandNick nick; SpanningTree::CommandPing ping; SpanningTree::CommandPong pong; CommandSave save; SpanningTree::CommandServer server; CommandSQuit squit; CommandSNONotice snonotice; CommandEndBurst endburst; CommandSInfo sinfo; CommandNum num; CommandLMode lmode; SpanningTreeCommands(ModuleSpanningTree* module); }; ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/src/modules/m_spanningtree/compat.cpp������������������������������������������������0000664�0000000�0000000�00000020523�14771603147�0022610�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2021, 2024-2025 Sadie Powell <sadie@witchery.services> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include "inspircd.h" #include "main.h" namespace { size_t NextToken(const std::string& line, size_t start) { if (start == std::string::npos || start + 1 > line.length()) return std::string::npos; return line.find(' ', start + 1); } } void TreeSocket::WriteLine(const std::string& original_line) { if (LinkState != CONNECTED || proto_version == PROTO_NEWEST) { // Don't translate connections which have negotiated PROTO_NEWEST or // where the protocol hasn't been negotiated yet. WriteLineInternal(original_line); return; } std::string line = original_line; size_t cmdstart = 0; if (line[0] == '@') // Skip the tags. { cmdstart = NextToken(line, 0); if (cmdstart != std::string::npos) cmdstart++; } size_t sidstart = std::string::npos; if (line[cmdstart] == ':') // Skip the prefix. { sidstart = cmdstart + 1; cmdstart = NextToken(line, cmdstart); if (cmdstart != std::string::npos) cmdstart++; } // Find the end of the command. size_t cmdend = NextToken(line, cmdstart); if (cmdend == std::string::npos) cmdend = line.size() - 1; std::string command(line, cmdstart, cmdend - cmdstart); if (proto_version == PROTO_INSPIRCD_3) { if (irc::equals(command, "ENCAP")) { // :<sid> ENCAP <server> <real-command> auto serverend = NextToken(line, cmdend); auto actualcmdend = NextToken(line, serverend); if (actualcmdend != std::string::npos) { std::string realcommand(line, serverend + 1, actualcmdend - serverend - 1); if (irc::equals(realcommand, "SASL")) { auto suidend = NextToken(line, actualcmdend); auto tuidend = NextToken(line, suidend); auto flagend = NextToken(line, tuidend); if (flagend != std::string::npos) { std::string flag(line, tuidend + 1, flagend - tuidend - 1); if (irc::equals(flag, "S")) { // SASL <uid> <uid> S <mech> <fp> [<fp>]+ auto mechend = NextToken(line, flagend); auto fpend = NextToken(line, mechend); if (fpend != std::string::npos) line.erase(fpend); // Multiple fingerprints in ssl_cert was introduced in PROTO_INSPIRCD_4; drop it. } } } } } else if (irc::equals(command, "FHOST") || irc::equals(command, "FIDENT")) { // FIDENT/FHOST has two parameters in v4; drop the real username/hostname. // :<sid> FIDENT|FHOST <display|*> <real|*> size_t displayend = NextToken(line, cmdend); if (displayend != std::string::npos) { if ((displayend - cmdend) == 2 && line[displayend - 1] == '*') return; // FIDENT/FHOST is only changing the real username/hostname; drop. // Trim the rest of the line. line.erase(displayend); } } else if (irc::equals(command, "LMODE")) { // LMODE is new in v4; downgrade to FMODE. // :<sid> LMODE <chan> <chants> <modechr> [<mask> <setts> <setter>]+ auto chanend = NextToken(line, cmdend); auto chantsend = NextToken(line, chanend); auto modechrend = NextToken(line, chantsend); if (modechrend != std::string::npos) { // This should only be one character but its best to be sure... auto modechr = line.substr(chantsend + 1, modechrend - chantsend - 1); auto prevend = modechrend; // Build a new mode and parameter list. std::string modelist = "+"; std::string paramlist; while (prevend != std::string::npos) { // We drop the setts and setter for the old protocol. auto maskend = NextToken(line, prevend); auto settsend = NextToken(line, maskend); if (settsend != std::string::npos) { modelist.append(modechr); paramlist.append(" ").append(line.substr(prevend + 1, maskend - prevend - 1)); } prevend = NextToken(line, settsend); } // Replace the mode tuples with a list of mode values. line.replace(modechrend, line.length() - modechrend, paramlist); // Replace the mode character with a list of +modes line.replace(chantsend + 1, modechrend - chantsend - 1, modelist); // Replace LMODE with FMODE. line.replace(cmdstart, 5, "FMODE"); } } else if (irc::equals(command, "METADATA")) { // :<sid> METADATA <uuid|chan|*|@> <name> :<value> size_t targetend = NextToken(line, cmdend); size_t nameend = NextToken(line, targetend); size_t flagend = NextToken(line, nameend); if (flagend != std::string::npos) { std::string extname(line, targetend + 1, nameend - targetend - 1); if (irc::equals(extname, "ssl_cert")) { // Check we have the "e" flag (no error). if (line.find('e', nameend + 1) < flagend) { size_t fpend = NextToken(line, flagend); if (fpend != std::string::npos) { size_t commapos = line.find(',', flagend + 1); if (commapos < fpend) { // Multiple fingerprints in ssl_cert was introduced in PROTO_INSPIRCD_4; drop it. line.erase(commapos, fpend - commapos); } } } } } } else if (irc::equals(command, "SINFO")) { // :<sid> SINFO <key> :<value> auto keyend = NextToken(line, cmdend); if (keyend != std::string::npos && sidstart != std::string::npos) { auto skey = line.substr(cmdend + 1, keyend - cmdend - 1); if (irc::equals(skey, "customversion")) return; else if (irc::equals(skey, "rawbranch")) { // InspIRCd-4. testnet.inspircd.org :Test auto* sid = Utils->FindServerID(line.substr(sidstart, cmdstart - sidstart - 1)); if (sid) { line.replace(cmdend + 1, keyend - cmdend - 1, "version"); line.append(INSP_FORMAT(". {} :{}", sid->GetPublicName(), sid->GetDesc())); } } else if (irc::equals(skey, "rawversion")) { // InspIRCd-4.0.0-a10. sadie.testnet.inspircd.org :[597] Test auto* sid = Utils->FindServerID(line.substr(sidstart, cmdstart - sidstart - 1)); if (sid) { line.replace(cmdend + 1, keyend - cmdend - 1, "fullversion"); line.append(INSP_FORMAT(". {} :[{}] {}", sid->GetName(), sid->GetId(), sid->GetDesc())); } } } } else if (irc::equals(command, "SQUERY")) { // SQUERY was introduced in PROTO_INSPIRCD_4; convert to PRIVMSG. line.replace(cmdstart, 6, "PRIVMSG"); } else if (irc::equals(command, "UID")) { // :<sid> UID <uuid> <nickchanged> <nick> <host> <dhost> <user> <duser> <ip.string> <signon> <modes> [<modepara>] :<real> // ^^^^^^ New in 1206 size_t uuidend = NextToken(line, cmdend); size_t nickchangedend = NextToken(line, uuidend); size_t nickend = NextToken(line, nickchangedend); size_t hostend = NextToken(line, nickend); size_t dhostend = NextToken(line, hostend); size_t userend = NextToken(line, dhostend); if (userend != std::string::npos) line.erase(dhostend, userend - dhostend); } } WriteLineInternal(line); } bool TreeSocket::PreProcessOldProtocolMessage(User*& who, std::string& cmd, CommandBase::Params& params) { if (irc::equals(cmd, "FHOST") || irc::equals(cmd, "FIDENT")) { if (params.size() < 2) params.push_back("*"); } else if (irc::equals(cmd, "SVSJOIN") || irc::equals(cmd, "SVSNICK") || irc::equals(cmd, "SVSPART")) { if (params.empty()) return false; // Malformed. auto* target = ServerInstance->Users.FindUUID(params[0]); if (!target) return false; // User gone. params.insert(params.begin(), { target->uuid.substr(0, 3), cmd }); cmd = "ENCAP"; } else if (irc::equals(cmd, "UID")) { if (params.size() < 6) return false; // Malformed. // :<sid> UID <uuid> <nickchanged> <nick> <host> <dhost> <user> <duser> <ip.string> <signon> <modes> [<modepara>] :<real> // ^^^^^^ New in 1206 params.insert(params.begin() + 5, params[5]); } return true; } �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/src/modules/m_spanningtree/delline.cpp�����������������������������������������������0000664�0000000�0000000�00000003212�14771603147�0022735�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2019 Matt Schatz <genius3000@g3k.solutions> * Copyright (C) 2018, 2020, 2023 Sadie Powell <sadie@witchery.services> * Copyright (C) 2013, 2015 Attila Molnar <attilamolnar@hush.com> * Copyright (C) 2012 Robby <robby@chatbelgie.be> * Copyright (C) 2009 Uli Schlachter <psychon@znc.in> * Copyright (C) 2009 Daniel De Graaf <danieldg@inspircd.org> * Copyright (C) 2008 Robin Burchell <robin+git@viroteck.net> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include "inspircd.h" #include "xline.h" #include "commands.h" CmdResult CommandDelLine::Handle(User* user, Params& params) { const std::string& setter = user->nick; std::string reason; // XLineManager::DelLine() returns true if the xline existed, false if it didn't if (ServerInstance->XLines->DelLine(params[1], params[0], reason, user)) { ServerInstance->SNO.WriteToSnoMask('X', "{} removed {}{} on {}: {}", setter, params[0], params[0].length() <= 2 ? "-line" : "", params[1], reason); return CmdResult::SUCCESS; } return CmdResult::FAILURE; } ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/src/modules/m_spanningtree/encap.cpp�������������������������������������������������0000664�0000000�0000000�00000003474�14771603147�0022421�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2018, 2020, 2022-2023 Sadie Powell <sadie@witchery.services> * Copyright (C) 2012-2014, 2016 Attila Molnar <attilamolnar@hush.com> * Copyright (C) 2012 Robby <robby@chatbelgie.be> * Copyright (C) 2009 Uli Schlachter <psychon@znc.in> * Copyright (C) 2009 Daniel De Graaf <danieldg@inspircd.org> * Copyright (C) 2008 Craig Edwards <brain@inspircd.org> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include "inspircd.h" #include "commands.h" #include "main.h" /** ENCAP */ CmdResult CommandEncap::Handle(User* user, Params& params) { if (ServerInstance->Config->ServerId == params[0] || InspIRCd::Match(ServerInstance->Config->ServerName, params[0])) { CommandBase::Params plist(params.begin() + 2, params.end()); Command* cmd = nullptr; ServerInstance->Parser.CallHandler(params[1], plist, user, &cmd); // Discard return value, ENCAP shall succeed even if the command does not exist if ((cmd) && (cmd->force_manual_route)) return CmdResult::FAILURE; } return CmdResult::SUCCESS; } RouteDescriptor CommandEncap::GetRouting(User* user, const Params& params) { if (params[0].find_first_of("*?") != std::string::npos) return ROUTE_BROADCAST; return ROUTE_UNICAST(params[0]); } ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/src/modules/m_spanningtree/fjoin.cpp�������������������������������������������������0000664�0000000�0000000�00000030155�14771603147�0022434�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2018-2024 Sadie Powell <sadie@witchery.services> * Copyright (C) 2012-2016 Attila Molnar <attilamolnar@hush.com> * Copyright (C) 2012 Robby <robby@chatbelgie.be> * Copyright (C) 2009-2010 Daniel De Graaf <danieldg@inspircd.org> * Copyright (C) 2008, 2012 Robin Burchell <robin+git@viroteck.net> * Copyright (C) 2008 Craig Edwards <brain@inspircd.org> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include "inspircd.h" #include "timeutils.h" #include "commands.h" #include "treeserver.h" #include "treesocket.h" /** FJOIN builder for rebuilding incoming FJOINs and splitting them up into multiple messages if necessary */ class FwdFJoinBuilder final : public CommandFJoin::Builder { public: FwdFJoinBuilder(Channel* chan, TreeServer* server) : CommandFJoin::Builder(chan, server) { } void add(Membership* memb, std::string::const_iterator mbegin, std::string::const_iterator mend); }; /** FJOIN, almost identical to TS6 SJOIN, except for nicklist handling. */ CmdResult CommandFJoin::Handle(User* srcuser, Params& params) { /* 1.1+ FJOIN works as follows: * * Each FJOIN is sent along with a timestamp, and the side with the lowest * timestamp 'wins'. From this point on we will refer to this side as the * winner. The side with the higher timestamp loses, from this point on we * will call this side the loser or losing side. This should be familiar to * anyone who's dealt with dreamforge or TS6 before. * * When two sides of a split heal and this occurs, the following things * will happen: * * If the timestamps are exactly equal, both sides merge their privileges * and users, as in InspIRCd 1.0 and ircd2.8. The channels have not been * re-created during a split, this is safe to do. * * If the timestamps are NOT equal, the losing side removes all of its * modes from the channel, before introducing new users into the channel * which are listed in the FJOIN command's parameters. The losing side then * LOWERS its timestamp value of the channel to match that of the winning * side, and the modes of the users of the winning side are merged in with * the losing side. * * The winning side on the other hand will ignore all user modes from the * losing side, so only its own modes get applied. Life is simple for those * who succeed at internets. :-) * * Outside of netbursts, the winning side also resyncs the losing side if it * detects that the other side recreated the channel. * * Syntax: * :<sid> FJOIN <chan> <TS> <modes> :[<member> [<member> ...]] * The last parameter is a list consisting of zero or more channel members * (permanent channels may have zero users). Each entry on the list is in the * following format: * [[<modes>,]<uuid>[:<membid>] * <modes> is a concatenation of the mode letters the user has on the channel * (e.g.: "ov" if the user is opped and voiced). The order of the mode letters * are not important but if a server encounters an unknown mode letter, it will * drop the link to avoid desync. * * InspIRCd 2.0 and older required a comma before the uuid even if the user * had no prefix modes on the channel, InspIRCd 3.0 and later does not require * a comma in this case anymore. * * <membid> is a positive integer representing the id of the membership. * If not present (in FJOINs coming from pre-1205 servers), 0 is assumed. * * Forwarding: * FJOIN messages are forwarded with the new TS and modes. Prefix modes of * members on the losing side are not forwarded. * This is required to only have one server on each side of the network who * decides the fate of a channel during a network merge. Otherwise, if the * clock of a server is slightly off it may make a different decision than * the rest of the network and desync. * The prefix modes are always forwarded as-is, or not at all. * * Forwarding examples: * Existing channel #chan with TS 1000, modes +n. * Incoming: :220 FJOIN #chan 1000 +t :o,220AAAAAB:0 * Forwarded: :220 FJOIN #chan 1000 +nt :o,220AAAAAB:0 * Merge modes and forward the result. Forward their prefix modes as well. * * Existing channel #chan with TS 1000, modes +nt. * Incoming: :220 FJOIN #CHAN 2000 +i :ov,220AAAAAB:0 o,220AAAAAC:20 * Forwarded: :220 FJOIN #chan 1000 +nt :,220AAAAAB:0 ,220AAAAAC:20 * Drop their modes, forward our modes and TS, use our channel name * capitalization. Don't forward prefix modes. * */ time_t TS = ServerCommand::ExtractTS(params[1]); const std::string& channel = params[0]; auto* chan = ServerInstance->Channels.Find(channel); bool apply_other_sides_modes = true; TreeServer* const sourceserver = TreeServer::Get(srcuser); if (!chan) { if (!ServerInstance->Channels.IsPrefix(channel[0])) throw ProtocolException("Malformed channel name in FJOIN: " + channel); chan = new Channel(channel, TS); } else { time_t ourTS = chan->age; if (TS != ourTS) { ServerInstance->Logs.Debug(MODNAME, "Merge FJOIN received for {}, ourTS: {}, TS: {}, difference: {}", chan->name, ourTS, TS, ourTS - TS); /* If our TS is less than theirs, we dont accept their modes */ if (ourTS < TS) { // If the source server isn't bursting then this FJOIN is the result of them recreating the channel with a higher TS. // This happens if the last user on the channel hops and before the PART propagates a user on another server joins. Fix it by doing a resync. // Servers behind us won't react this way because the forwarded FJOIN will have the correct TS. if (!sourceserver->IsBursting()) { ServerInstance->Logs.Debug(MODNAME, "Server {} recreated channel {} with higher TS, resyncing", sourceserver->GetName(), chan->name); sourceserver->GetSocket()->SyncChannel(chan, sourceserver); } apply_other_sides_modes = false; } else if (ourTS > TS) { // Our TS is greater than theirs, remove all modes, extensions, etc. from the channel LowerTS(chan, TS, channel); // XXX: If the channel does not exist in the chan hash at this point, create it so the remote modes can be applied on it. // This happens to 0-user permanent channels on the losing side, because those are removed (from the chan hash, then // deleted later) as soon as the permchan mode is removed from them. if (!ServerInstance->Channels.Find(channel)) { chan = new Channel(channel, TS); } } } } // Apply their channel modes if we have to Modes::ChangeList modechangelist; if (apply_other_sides_modes) { ServerInstance->Modes.ModeParamsToChangeList(srcuser, MODETYPE_CHANNEL, params, modechangelist, 2, params.size() - 1); ServerInstance->Modes.Process(srcuser, chan, nullptr, modechangelist, ModeParser::MODE_LOCALONLY | ModeParser::MODE_MERGE); // Reuse for prefix modes modechangelist.clear(); } // Build a new FJOIN for forwarding. Put the correct TS in it and the current modes of the channel // after applying theirs. If they lost, the prefix modes from their message are not forwarded. FwdFJoinBuilder fwdfjoin(chan, sourceserver); // Process every member in the message irc::spacesepstream users(params.back()); std::string item; Modes::ChangeList* modechangelistptr = (apply_other_sides_modes ? &modechangelist : nullptr); while (users.GetToken(item)) { ProcessModeUUIDPair(item, sourceserver, chan, modechangelistptr, fwdfjoin); } fwdfjoin.finalize(); fwdfjoin.Forward(sourceserver->GetRoute()); // Set prefix modes on their users if we lost the FJOIN or had equal TS if (apply_other_sides_modes) ServerInstance->Modes.Process(srcuser, chan, nullptr, modechangelist, ModeParser::MODE_LOCALONLY); return CmdResult::SUCCESS; } void CommandFJoin::ProcessModeUUIDPair(const std::string& item, TreeServer* sourceserver, Channel* chan, Modes::ChangeList* modechangelist, FwdFJoinBuilder& fwdfjoin) { std::string::size_type comma = item.find(','); // Comma not required anymore if the user has no modes const std::string::size_type ubegin = (comma == std::string::npos ? 0 : comma+1); std::string uuid(item, ubegin, UIDGenerator::UUID_LENGTH); auto* who = ServerInstance->Users.FindUUID(uuid); if (!who) { // Probably KILLed, ignore return; } TreeSocket* src_socket = sourceserver->GetSocket(); /* Check that the user's 'direction' is correct */ TreeServer* route_back_again = TreeServer::Get(who); if (route_back_again->GetSocket() != src_socket) { return; } std::string::const_iterator modeendit = item.begin(); // End of the "ov" mode string /* Check if the user received at least one mode */ if ((modechangelist) && (comma != std::string::npos)) { modeendit += comma; /* Iterate through the modes and see if they are valid here, if so, apply */ for (std::string::const_iterator i = item.begin(); i != modeendit; ++i) { ModeHandler* mh = ServerInstance->Modes.FindMode(*i, MODETYPE_CHANNEL); if (!mh) throw ProtocolException("Unrecognised mode '" + std::string(1, *i) + "'"); /* Add any modes this user had to the mode stack */ modechangelist->push_add(mh, who->nick); } } Membership* memb = chan->ForceJoin(who, nullptr, sourceserver->IsBursting()); if (!memb) { // User was already on the channel, forward because of the modes they potentially got memb = chan->GetUser(who); if (memb) fwdfjoin.add(memb, item.begin(), modeendit); return; } // Assign the id to the new Membership Membership::Id membid = 0; const std::string::size_type colon = item.rfind(':'); if (colon != std::string::npos) membid = Membership::IdFromString(item.substr(colon+1)); memb->id = membid; // Add member to fwdfjoin with prefix modes fwdfjoin.add(memb, item.begin(), modeendit); } void CommandFJoin::RemoveStatus(Channel* c) { Modes::ChangeList changelist; for (const auto& [_, mh] : ServerInstance->Modes.GetModes(MODETYPE_CHANNEL)) { // Add the removal of this mode to the changelist. This handles all kinds of modes, including prefix modes. mh->RemoveMode(c, changelist); } ServerInstance->Modes.Process(ServerInstance->FakeClient, c, nullptr, changelist, ModeParser::MODE_LOCALONLY); } void CommandFJoin::LowerTS(Channel* chan, time_t TS, const std::string& newname) { if (Utils->AnnounceTSChange) { // WriteRemoteNotice is not used here because the message only needs to go to the local server. chan->WriteNotice(INSP_FORMAT("Creation time of {} changed from {} to {}", newname, Time::ToString(chan->age), Time::ToString(TS))); } // While the name is equal in case-insensitive compare, it might differ in case; use the remote version chan->name = newname; chan->age = TS; // Clear all modes CommandFJoin::RemoveStatus(chan); // Unset all extensions chan->FreeAllExtItems(); // Clear the topic chan->SetTopic(ServerInstance->FakeClient, std::string(), 0); chan->setby.clear(); } CommandFJoin::Builder::Builder(Channel* chan, TreeServer* source) : CmdBuilder(source, "FJOIN") { push(chan->name).push_int(chan->age).push_raw(" +"); pos = str().size(); push_raw(chan->ChanModes(true)).push_raw(" :"); } void CommandFJoin::Builder::add(Membership* memb, std::string::const_iterator mbegin, std::string::const_iterator mend) { push_raw(mbegin, mend).push_raw(',').push_raw(memb->user->uuid); push_raw(':').push_raw_int(memb->id); push_raw(' '); } void CommandFJoin::Builder::clear() { content.erase(pos); push_raw(" :"); } const std::string& CommandFJoin::Builder::finalize() { if (content.back() == ' ') content.pop_back(); return str(); } void FwdFJoinBuilder::add(Membership* memb, std::string::const_iterator mbegin, std::string::const_iterator mend) { // Add the member and their modes exactly as they sent them CommandFJoin::Builder::add(memb, mbegin, mend); } �������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/src/modules/m_spanningtree/fmode.cpp�������������������������������������������������0000664�0000000�0000000�00000006663�14771603147�0022430�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2018, 2020-2022 Sadie Powell <sadie@witchery.services> * Copyright (C) 2012-2015 Attila Molnar <attilamolnar@hush.com> * Copyright (C) 2012 Robby <robby@chatbelgie.be> * Copyright (C) 2010 Daniel De Graaf <danieldg@inspircd.org> * Copyright (C) 2008 Robin Burchell <robin+git@viroteck.net> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include "inspircd.h" #include "commands.h" /** FMODE command - channel mode change with timestamp checks */ CmdResult CommandFMode::Handle(User* who, Params& params) { time_t TS = ServerCommand::ExtractTS(params[1]); Channel* const chan = ServerInstance->Channels.Find(params[0]); if (!chan) // Channel doesn't exist return CmdResult::FAILURE; // Extract the TS of the channel in question time_t ourTS = chan->age; /* If the TS is greater than ours, we drop the mode and don't pass it anywhere. */ if (TS > ourTS) return CmdResult::FAILURE; /* TS is equal or less: apply the mode change locally and forward the message */ // Turn modes into a Modes::ChangeList; may have more elements than max modes Modes::ChangeList changelist; ServerInstance->Modes.ModeParamsToChangeList(who, MODETYPE_CHANNEL, params, changelist, 2); ModeParser::ModeProcessFlag flags = ModeParser::MODE_LOCALONLY; if ((TS == ourTS) && IS_SERVER(who)) flags |= ModeParser::MODE_MERGE; ServerInstance->Modes.Process(who, chan, nullptr, changelist, flags); return CmdResult::SUCCESS; } CmdResult CommandLMode::Handle(User* who, Params& params) { // :<sid> LMODE <chan> <chants> <modechr> [<mask> <setts> <setter>]+ time_t chants = ServerCommand::ExtractTS(params[1]); Channel* const chan = ServerInstance->Channels.Find(params[0]); if (!chan) return CmdResult::FAILURE; // Channel doesn't exist. // If the TS is greater than ours, we drop the mode and don't pass it anywhere. if (chants > chan->age) return CmdResult::FAILURE; ModeHandler* mh = ServerInstance->Modes.FindMode(params[2][0], MODETYPE_CHANNEL); if (!mh || !mh->IsListMode()) return CmdResult::FAILURE; // Mode doesn't exist or isn't a list mode. if (params.size() % 3) return CmdResult::FAILURE; // Invalid parameter count. Modes::ChangeList changelist; for (Params::const_iterator iter = params.begin() + 3; iter != params.end(); ) { // The mode mask (e.g. foo!bar@baz). const std::string& mask = *iter++; // Who the mode was set by (e.g. Sadie!sadie@sadie.moe). const std::string& set_by = *iter++; // The time at which the mode was set (e.g. 956204400). time_t set_at = ServerCommand::ExtractTS(*iter++); changelist.push(mh, true, mask, set_by, set_at); } ModeParser::ModeProcessFlag flags = ModeParser::MODE_LOCALONLY; if (chants == chan->age && IS_SERVER(who)) flags |= ModeParser::MODE_MERGE; ServerInstance->Modes.Process(who, chan, nullptr, changelist, flags); return CmdResult::SUCCESS; } �����������������������������������������������������������������������������inspircd-4.7.0/src/modules/m_spanningtree/ftopic.cpp������������������������������������������������0000664�0000000�0000000�00000006156�14771603147�0022617�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2018, 2020, 2023 Sadie Powell <sadie@witchery.services> * Copyright (C) 2012-2014, 2016 Attila Molnar <attilamolnar@hush.com> * Copyright (C) 2012 Robby <robby@chatbelgie.be> * Copyright (C) 2010 Daniel De Graaf <danieldg@inspircd.org> * Copyright (C) 2009 Uli Schlachter <psychon@znc.in> * Copyright (C) 2008 Robin Burchell <robin+git@viroteck.net> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include "inspircd.h" #include "commands.h" /** FTOPIC command */ CmdResult CommandFTopic::Handle(User* user, Params& params) { auto* c = ServerInstance->Channels.Find(params[0]); if (!c) return CmdResult::FAILURE; if (c->age < ServerCommand::ExtractTS(params[1])) // Our channel TS is older, nothing to do return CmdResult::FAILURE; // Channel::topicset is initialized to 0 on channel creation, so their ts will always win if we never had a topic time_t ts = ServerCommand::ExtractTS(params[2]); if (ts < c->topicset) return CmdResult::FAILURE; // The topic text is always the last parameter const std::string& newtopic = params.back(); // If there is a setter in the message use that, otherwise use the message source const std::string& setter = ((params.size() > 4) ? params[3] : (ServerInstance->Config->MaskInTopic ? user->GetMask() : user->nick)); /* * If the topics were updated at the exact same second, accept * the remote only when it's "bigger" than ours as defined by * string comparison, so non-empty topics always override * empty topics if their timestamps are equal * * Similarly, if the topic texts are equal too, keep one topic * setter and discard the other */ if (ts == c->topicset) { // Discard if their topic text is "smaller" if (c->topic > newtopic) return CmdResult::FAILURE; // If the texts are equal in addition to the timestamps, decide which setter to keep if ((c->topic == newtopic) && (c->setby >= setter)) return CmdResult::FAILURE; } c->SetTopic(user, newtopic, ts, &setter); return CmdResult::SUCCESS; } // Used when bursting and in reply to RESYNC, contains topic setter as the 4th parameter CommandFTopic::Builder::Builder(Channel* chan) : CmdBuilder("FTOPIC") { push(chan->name); push_int(chan->age); push_int(chan->topicset); push(chan->setby); push_last(chan->topic); } // Used when changing the topic, the setter is the message source CommandFTopic::Builder::Builder(User* user, Channel* chan) : CmdBuilder(user, "FTOPIC") { push(chan->name); push_int(chan->age); push_int(chan->topicset); push_last(chan->topic); } ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/src/modules/m_spanningtree/hmac.cpp��������������������������������������������������0000664�0000000�0000000�00000007355�14771603147�0022245�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2014 Matthew Martin <phy1729@gmail.com> * Copyright (C) 2013-2014 Attila Molnar <attilamolnar@hush.com> * Copyright (C) 2013, 2019, 2021-2024 Sadie Powell <sadie@witchery.services> * Copyright (C) 2012 Robby <robby@chatbelgie.be> * Copyright (C) 2009-2010 Daniel De Graaf <danieldg@inspircd.org> * Copyright (C) 2008 Robin Burchell <robin+git@viroteck.net> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include "inspircd.h" #include "modules/hash.h" #include "modules/ssl.h" #include "main.h" #include "link.h" #include "treesocket.h" const std::string& TreeSocket::GetOurChallenge() { return capab->ourchallenge; } void TreeSocket::SetOurChallenge(const std::string& c) { capab->ourchallenge = c; } const std::string& TreeSocket::GetTheirChallenge() { return capab->theirchallenge; } void TreeSocket::SetTheirChallenge(const std::string& c) { capab->theirchallenge = c; } std::string TreeSocket::MakePass(const std::string& password, const std::string& challenge) { /* This is a simple (maybe a bit hacky?) HMAC algorithm, thanks to jilles for * suggesting the use of HMAC to secure the password against various attacks. * * Note: If an sha256 provider is not available, we MUST fall back to plaintext with no * HMAC challenge/response. */ HashProvider* sha256 = ServerInstance->Modules.FindDataService<HashProvider>("hash/sha256"); if (sha256 && !challenge.empty()) return "AUTH:" + Base64::Encode(sha256->hmac(password, challenge)); if (!challenge.empty() && !sha256) ServerInstance->Logs.Warning(MODNAME, "Not authenticating to server using HMAC-SHA256 because we don't have an SHA256 provider (e.g. the sha2 module) loaded!"); return password; } bool TreeSocket::ComparePass(const Link& link, const std::string& theirs) { capab->auth_fingerprint = !link.Fingerprint.empty(); capab->auth_challenge = !capab->ourchallenge.empty() && !capab->theirchallenge.empty(); std::string fp = SSLClientCert::GetFingerprint(this); if (capab->auth_fingerprint) { /* Require fingerprint to exist and match */ if (!InspIRCd::TimingSafeCompare(link.Fingerprint, fp)) { ServerInstance->SNO.WriteToSnoMask('l', "Invalid TLS certificate fingerprint on link {}: need \"{}\" got \"{}\"", link.Name, link.Fingerprint, fp); SendError("Invalid TLS certificate fingerprint " + fp + " - expected " + link.Fingerprint); return false; } } if (capab->auth_challenge) { std::string our_hmac = MakePass(link.RecvPass, capab->ourchallenge); // Use the timing-safe compare function to compare the hashes if (!InspIRCd::TimingSafeCompare(our_hmac, theirs)) return false; } else { // Use the timing-safe compare function to compare the passwords if (!InspIRCd::TimingSafeCompare(link.RecvPass, theirs)) return false; } // Tell opers to set up fingerprint verification if it's not already set up and the TLS mod gave us a fingerprint // this time if ((!capab->auth_fingerprint) && (!fp.empty())) { ServerInstance->SNO.WriteToSnoMask('l', "TLS certificate fingerprint for link {} is \"{}\". " "You can improve security by specifying this in <link:fingerprint>.", link.Name, fp); } return true; } �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/src/modules/m_spanningtree/idle.cpp��������������������������������������������������0000664�0000000�0000000�00000004541�14771603147�0022244�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2018-2020, 2022-2023 Sadie Powell <sadie@witchery.services> * Copyright (C) 2012-2014 Attila Molnar <attilamolnar@hush.com> * Copyright (C) 2012 Robby <robby@chatbelgie.be> * Copyright (C) 2009 Uli Schlachter <psychon@znc.in> * Copyright (C) 2009 Daniel De Graaf <danieldg@inspircd.org> * Copyright (C) 2008 Robin Burchell <robin+git@viroteck.net> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include "inspircd.h" #include "utils.h" #include "commands.h" CmdResult CommandIdle::HandleRemote(RemoteUser* issuer, Params& params) { /** * There are two forms of IDLE: request and reply. Requests have one parameter, * replies have more than one. * * If this is a request, 'issuer' did a /whois and its server wants to learn the * idle time of the user in params[0]. * * If this is a reply, params[0] is the user who did the whois and params.back() is * the number of seconds 'issuer' has been idle. */ auto* target = ServerInstance->Users.FindUUID(params[0], true); if (!target) return CmdResult::FAILURE; LocalUser* localtarget = IS_LOCAL(target); if (!localtarget) { // Forward to target's server return CmdResult::SUCCESS; } if (params.size() >= 2) { ServerInstance->Parser.CallHandler("WHOIS", params, issuer); } else { // A server is asking us the idle time of our user unsigned int idle; if (localtarget->idle_lastmsg >= ServerInstance->Time()) // Possible case when our clock ticked backwards idle = 0; else idle = ((unsigned int) (ServerInstance->Time() - localtarget->idle_lastmsg)); CmdBuilder reply(target, "IDLE"); reply.push(issuer->uuid); reply.push(ConvToStr(target->signon)); reply.push(ConvToStr(idle)); reply.Unicast(issuer); } return CmdResult::SUCCESS; } ���������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/src/modules/m_spanningtree/ijoin.cpp�������������������������������������������������0000664�0000000�0000000�00000004632�14771603147�0022440�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2018, 2020, 2022-2025 Sadie Powell <sadie@witchery.services> * Copyright (C) 2013-2014, 2016 Attila Molnar <attilamolnar@hush.com> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include "inspircd.h" #include "commands.h" #include "utils.h" #include "treeserver.h" #include "treesocket.h" CmdResult CommandIJoin::HandleRemote(RemoteUser* user, Params& params) { auto* chan = ServerInstance->Channels.Find(params[0]); if (!chan) { // Desync detected, recover // Ignore the join and send RESYNC, this will result in the remote server sending all channel data to us ServerInstance->Logs.Debug(MODNAME, "Received IJOIN for nonexistent channel: {}", params[0]); CmdBuilder("RESYNC").push(params[0]).Unicast(user); return CmdResult::FAILURE; } bool apply_modes; if (params.size() > 3) { time_t RemoteTS = ServerCommand::ExtractTS(params[2]); apply_modes = (RemoteTS <= chan->age); } else apply_modes = false; // Join the user and set the membership id to what they sent Membership* memb = chan->ForceJoin(user, apply_modes ? &params[3] : nullptr); if (!memb) return CmdResult::FAILURE; memb->id = Membership::IdFromString(params[1]); return CmdResult::SUCCESS; } CmdResult CommandResync::HandleServer(TreeServer* server, CommandBase::Params& params) { ServerInstance->Logs.Debug(MODNAME, "Resyncing {}", params[0]); auto* chan = ServerInstance->Channels.Find(params[0]); if (!chan) { // This can happen for a number of reasons, safe to ignore ServerInstance->Logs.Debug(MODNAME, "Channel does not exist"); return CmdResult::FAILURE; } if (!server->IsLocal()) throw ProtocolException("RESYNC from a server that is not directly connected"); // Send all known information about the channel server->GetSocket()->SyncChannel(chan, server); return CmdResult::SUCCESS; } ������������������������������������������������������������������������������������������������������inspircd-4.7.0/src/modules/m_spanningtree/link.h����������������������������������������������������0000664�0000000�0000000�00000003520�14771603147�0021725�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2021 Dominic Hamon * Copyright (C) 2016 Attila Molnar <attilamolnar@hush.com> * Copyright (C) 2013, 2020-2023 Sadie Powell <sadie@witchery.services> * Copyright (C) 2013 Adam <Adam@anope.org> * Copyright (C) 2012 Robby <robby@chatbelgie.be> * Copyright (C) 2009 Uli Schlachter <psychon@znc.in> * Copyright (C) 2009 Daniel De Graaf <danieldg@inspircd.org> * Copyright (C) 2007 Dennis Friis <peavey@inspircd.org> * Copyright (C) 2007 Craig Edwards <brain@inspircd.org> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #pragma once class Link final { public: std::shared_ptr<ConfigTag> tag; std::string Name; std::string IPAddr; in_port_t Port; std::string SendPass; std::string RecvPass; std::string Fingerprint; std::vector<std::string> AllowMasks; bool HiddenFromStats; std::string Hook; unsigned long Timeout; std::string Bind; bool Hidden; int Protocol = 0; Link(const std::shared_ptr<ConfigTag>& Tag) : tag(Tag) { } }; class Autoconnect final { public: std::shared_ptr<ConfigTag> tag; std::vector<std::string> servers; unsigned long Period; time_t NextConnectTime; /** Negative == inactive */ int position; Autoconnect(const std::shared_ptr<ConfigTag>& Tag) : tag(Tag) { } }; ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/src/modules/m_spanningtree/main.cpp��������������������������������������������������0000664�0000000�0000000�00000062534�14771603147�0022261�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2020 Matt Schatz <genius3000@g3k.solutions> * Copyright (C) 2019 linuxdaemon <linuxdaemon.irc@gmail.com> * Copyright (C) 2013, 2017-2025 Sadie Powell <sadie@witchery.services> * Copyright (C) 2013, 2016 Adam <Adam@anope.org> * Copyright (C) 2012-2016, 2018 Attila Molnar <attilamolnar@hush.com> * Copyright (C) 2012 Robby <robby@chatbelgie.be> * Copyright (C) 2009-2010 Daniel De Graaf <danieldg@inspircd.org> * Copyright (C) 2007-2009 Robin Burchell <robin+git@viroteck.net> * Copyright (C) 2007-2008 Dennis Friis <peavey@inspircd.org> * Copyright (C) 2005, 2007-2009 Craig Edwards <brain@inspircd.org> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include "inspircd.h" #include "clientprotocolmsg.h" #include "iohook.h" #include "socket.h" #include "timeutils.h" #include "xline.h" #include "commands.h" #include "link.h" #include "main.h" #include "resolvers.h" #include "translate.h" #include "treeserver.h" #include "treesocket.h" #include "utils.h" ModuleSpanningTree::ModuleSpanningTree() : Module(VF_VENDOR, "Allows linking multiple servers together as part of one network.") , Away::EventListener(this) , Stats::EventListener(this) , CTCTags::EventListener(this) , rconnect(this) , rsquit(this) , map(this) , commands(this) , routeeventprov(this, "event/server-route") , linkeventprov(this, "event/server-link") , messageeventprov(this, "event/server-message") , synceventprov(this, "event/server-sync") , sslapi(this) , servertags(this) , DNS(this) , tagevprov(this) { } SpanningTreeCommands::SpanningTreeCommands(ModuleSpanningTree* module) : metadata(module) , uid(module) , opertype(module) , fjoin(module) , ijoin(module) , resync(module) , fmode(module) , ftopic(module) , fhost(module) , frhost(module) , fident(module) , fname(module) , away(module) , addline(module) , delline(module) , encap(module) , idle(module) , nick(module) , ping(module) , pong(module) , save(module) , server(module) , squit(module) , snonotice(module) , endburst(module) , sinfo(module) , num(module) , lmode(module) { } namespace { void SetLocalUsersServer(Server* newserver) { // Does not change the server of quitting users because those are not in the list ServerInstance->FakeClient->server = newserver; for (auto* user : ServerInstance->Users.GetLocalUsers()) user->server = newserver; } void ResetMembershipIds() { // Set all membership ids to 0 for (const auto* user : ServerInstance->Users.GetLocalUsers()) { for (auto* memb : user->chans) memb->id = 0; } } } void ModuleSpanningTree::init() { ServerInstance->SNO.EnableSnomask('l', "LINK"); ResetMembershipIds(); Utils = new SpanningTreeUtilities(this); Utils->TreeRoot = new TreeServer; ServerInstance->PI = &protocolinterface; delete ServerInstance->FakeClient->server; SetLocalUsersServer(Utils->TreeRoot); } void ModuleSpanningTree::ShowLinks(TreeServer* Current, User* user, int hops) { std::string Parent = Utils->TreeRoot->GetName(); if (Current->GetParent()) { Parent = Current->GetParent()->GetName(); } for (auto* server : Current->GetChildren()) { if ((server->Hidden) || ((Utils->HideServices) && (server->IsService()))) { if (user->IsOper()) { ShowLinks(server, user, hops+1); } } else { ShowLinks(server, user, hops+1); } } /* Don't display the line if its a service, hide services is on, and the user isn't an oper */ if ((Utils->HideServices) && (Current->IsService()) && (!user->IsOper())) return; /* Or if the server is hidden and they're not an oper */ else if ((Current->Hidden) && (!user->IsOper())) return; user->WriteNumeric(RPL_LINKS, Current->GetName(), (((Utils->FlatLinks) && (!user->IsOper())) ? ServerInstance->Config->GetServerName() : Parent), INSP_FORMAT("{} {}", (((Utils->FlatLinks) && (!user->IsOper())) ? 0 : hops), Current->GetDesc())); } void ModuleSpanningTree::HandleLinks(const CommandBase::Params& parameters, User* user) { ShowLinks(Utils->TreeRoot, user, 0); user->WriteNumeric(RPL_ENDOFLINKS, '*', "End of /LINKS list."); } void ModuleSpanningTree::ConnectServer(const std::shared_ptr<Autoconnect>& a, bool on_timer) { if (!a) return; for(unsigned int j=0; j < a->servers.size(); j++) { if (Utils->FindServer(a->servers[j])) { // found something in this block. Should the server fail, // we want to start at the start of the list, not in the // middle where we left off a->position = -1; return; } } if (on_timer && a->position >= 0) return; if (!on_timer && a->position < 0) return; a->position++; while (a->position < (int)a->servers.size()) { std::shared_ptr<Link> x = Utils->FindLink(a->servers[a->position]); if (x) { ServerInstance->SNO.WriteToSnoMask('l', "AUTOCONNECT: Auto-connecting server \002{}\002", x->Name); ConnectServer(x, a); return; } a->position++; } // Autoconnect chain has been fully iterated; start at the beginning on the // next AutoConnectServers run a->position = -1; } void ModuleSpanningTree::ConnectServer(const std::shared_ptr<Link>& x, const std::shared_ptr<Autoconnect>& y) { if (InspIRCd::Match(ServerInstance->Config->ServerName, x->Name, ascii_case_insensitive_map)) { ServerInstance->SNO.WriteToSnoMask('l', "CONNECT: Not connecting to myself."); return; } irc::sockets::sockaddrs sa; if (x->IPAddr.find('/') != std::string::npos) { if (!irc::sockets::isunix(x->IPAddr) || !sa.from_unix(x->IPAddr)) { // We don't use the family() != AF_UNSPEC check below for UNIX sockets as // that results in a DNS lookup. ServerInstance->SNO.WriteToSnoMask('l', "CONNECT: Error connecting \002{}\002: {} is not a UNIX socket!", x->Name, x->IPAddr); return; } } else { // If this fails then the IP sa will be AF_UNSPEC. sa.from_ip_port(x->IPAddr, x->Port); } /* Do we already have an IP? If so, no need to resolve it. */ if (sa.family() != AF_UNSPEC) { // Create a TreeServer object that will start connecting immediately in the background auto* newsocket = new TreeSocket(x, y, sa); if (!newsocket->HasFd()) { ServerInstance->SNO.WriteToSnoMask('l', "CONNECT: Error connecting \002{}\002: {}.", x->Name, newsocket->GetError()); ServerInstance->GlobalCulls.AddItem(newsocket); } } else if (!DNS) { ServerInstance->SNO.WriteToSnoMask('l', "CONNECT: Error connecting \002{}\002: Hostname given and core_dns is not loaded, unable to resolve.", x->Name); } else { // Guess start_type from bindip aftype DNS::QueryType start_type = DNS::QUERY_AAAA; irc::sockets::sockaddrs bind; if (!x->Bind.empty() && bind.from_ip(x->Bind)) { if (bind.family() == AF_INET) start_type = DNS::QUERY_A; } auto* snr = new ServerNameResolver(*DNS, x->IPAddr, x, start_type, y); try { DNS->Process(snr); } catch (const DNS::Exception& e) { delete snr; ServerInstance->SNO.WriteToSnoMask('l', "CONNECT: Error connecting \002{}\002: {}.", x->Name, e.GetReason()); ConnectServer(y, false); } } } void ModuleSpanningTree::AutoConnectServers(time_t curtime) { for (const auto& x : Utils->AutoconnectBlocks) { if (curtime >= x->NextConnectTime) { x->NextConnectTime = curtime + x->Period; ConnectServer(x, true); } } } void ModuleSpanningTree::DoConnectTimeout(time_t curtime) { SpanningTreeUtilities::TimeoutList::iterator i = Utils->timeoutlist.begin(); while (i != Utils->timeoutlist.end()) { TreeSocket* s = i->first; std::pair<std::string, unsigned int> p = i->second; SpanningTreeUtilities::TimeoutList::iterator me = i; i++; if (s->GetLinkState() == DYING) { Utils->timeoutlist.erase(me); s->Close(); } else if (curtime > s->age + (time_t)p.second) { ServerInstance->SNO.WriteToSnoMask('l', "CONNECT: Error connecting \002{}\002 (timeout of {})", p.first, Duration::ToLongString(p.second)); Utils->timeoutlist.erase(me); s->Close(); } } } ModResult ModuleSpanningTree::HandleVersion(const CommandBase::Params& parameters, User* user) { // We've already confirmed that !parameters.empty(), so this is safe TreeServer* found = Utils->FindServerMask(parameters[0]); if (found) { if (found == Utils->TreeRoot) { // Pass to default VERSION handler. return MOD_RES_PASSTHRU; } Numeric::Numeric numeric(RPL_VERSION); if (user->IsOper()) { numeric.push(found->rawversion + "."); numeric.push(found->GetName()); numeric.push("[" + found->GetId() + "] " + found->customversion); } else { numeric.push(found->rawbranch + "."); numeric.push(found->GetPublicName()); numeric.push(found->customversion); } user->WriteNumeric(numeric); } else { user->WriteNumeric(ERR_NOSUCHSERVER, parameters[0], "No such server"); } return MOD_RES_DENY; } ModResult ModuleSpanningTree::HandleConnect(const CommandBase::Params& parameters, User* user) { for (const auto& x : Utils->LinkBlocks) { if (InspIRCd::Match(x->Name, parameters[0], ascii_case_insensitive_map)) { if (InspIRCd::Match(ServerInstance->Config->ServerName, x->Name, ascii_case_insensitive_map)) { user->WriteRemoteNotice("*** CONNECT: Server \002{}\002 is ME, not connecting.", x->Name); return MOD_RES_DENY; } TreeServer* CheckDupe = Utils->FindServer(x->Name); if (!CheckDupe) { user->WriteRemoteNotice("*** CONNECT: Connecting to server: \002{}\002 ({}:{})", x->Name, (x->HiddenFromStats ? "<hidden>" : x->IPAddr), x->Port); ConnectServer(x); return MOD_RES_DENY; } else { user->WriteRemoteNotice("*** CONNECT: Server \002{}\002 already exists on the network and is connected via \002{}\002", x->Name, CheckDupe->GetParent()->GetName()); return MOD_RES_DENY; } } } user->WriteRemoteNotice("*** CONNECT: No server matching \002{}\002 could be found in the config file.", parameters[0]); return MOD_RES_DENY; } void ModuleSpanningTree::OnUserInvite(User* source, User* dest, Channel* channel, time_t expiry, ModeHandler::Rank notifyrank, CUList& notifyexcepts) { if (IS_LOCAL(source)) { CmdBuilder params(source, "INVITE"); params.push(dest->uuid); params.push(channel->name); params.push_int(channel->age); params.push(ConvToStr(expiry)); params.Broadcast(); } } ModResult ModuleSpanningTree::OnPreTopicChange(User* user, Channel* chan, const std::string& topic) { // XXX: Deny topic changes if the current topic set time is the current time or is in the future because // other servers will drop our FTOPIC. This restriction will be removed when the protocol is updated. if ((chan->topicset >= ServerInstance->Time()) && (Utils->serverlist.size() > 1)) { user->WriteNumeric(ERR_UNAVAILRESOURCE, chan->name, "Retry topic change later"); return MOD_RES_DENY; } return MOD_RES_PASSTHRU; } void ModuleSpanningTree::OnPostTopicChange(User* user, Channel* chan, const std::string& topic) { // Drop remote events on the floor. if (!IS_LOCAL(user)) return; CommandFTopic::Builder(user, chan).Broadcast(); } void ModuleSpanningTree::OnUserPostMessage(User* user, const MessageTarget& target, const MessageDetails& details) { if (!IS_LOCAL(user)) return; const char* message_type = (details.type == MessageType::PRIVMSG ? "PRIVMSG" : "NOTICE"); switch (target.type) { case MessageTarget::TYPE_USER: { auto* d = target.Get<User>(); if (!IS_LOCAL(d)) { CmdBuilder params(user, message_type); params.push_tags(details.tags_out); params.push(d->uuid); params.push_last(details.text); params.Unicast(d); } break; } case MessageTarget::TYPE_CHANNEL: { Utils->SendChannelMessage(user, target.Get<Channel>(), details.text, target.status, details.tags_out, details.exemptions, message_type); break; } case MessageTarget::TYPE_SERVER: { const auto* serverglob = target.Get<std::string>(); CmdBuilder par(user, message_type); par.push_tags(details.tags_out); par.push(std::string("$") + *serverglob); par.push_last(details.text); par.Broadcast(); break; } } } void ModuleSpanningTree::OnUserPostTagMessage(User* user, const MessageTarget& target, const CTCTags::TagMessageDetails& details) { if (!IS_LOCAL(user)) return; switch (target.type) { case MessageTarget::TYPE_USER: { auto* d = target.Get<User>(); if (!IS_LOCAL(d)) { CmdBuilder params(user, "TAGMSG"); params.push_tags(details.tags_out); params.push(d->uuid); params.Unicast(d); } break; } case MessageTarget::TYPE_CHANNEL: { Utils->SendChannelMessage(user, target.Get<Channel>(), "", target.status, details.tags_out, details.exemptions, "TAGMSG"); break; } case MessageTarget::TYPE_SERVER: { const auto* serverglob = target.Get<std::string>(); CmdBuilder par(user, "TAGMSG"); par.push_tags(details.tags_out); par.push(std::string("$") + *serverglob); par.Broadcast(); break; } } } void ModuleSpanningTree::OnBackgroundTimer(time_t curtime) { AutoConnectServers(curtime); DoConnectTimeout(curtime); } void ModuleSpanningTree::OnUserConnect(LocalUser* user) { if (user->quitting) return; // Create the lazy ssl_cert metadata for this user if not already created. if (sslapi) sslapi->GetCertificate(user); CommandUID::Builder(user).Broadcast(); if (user->IsOper()) CommandOpertype::Builder(user, user->oper).Broadcast(); if (user->IsAway()) CommandAway::Builder(user).Broadcast(); if (user->uniqueusername) // TODO: convert this to BooleanExtItem. CommandMetadata::Builder(user, "uniqueusername", "1").Broadcast(); for (const auto& [item, obj] : user->GetExtList()) { const std::string value = item->ToNetwork(user, obj); if (!value.empty()) { ServerInstance->PI->SendMetadata(user, item->name, value); item->OnSync(user, obj, nullptr); } } Utils->TreeRoot->UserCount++; } void ModuleSpanningTree::OnUserJoin(Membership* memb, bool sync, bool created_by_local, CUList& excepts) { // Only do this for local users if (!IS_LOCAL(memb->user)) return; // Assign the current membership id to the new Membership and increase it memb->id = currmembid++; if (created_by_local) { CommandFJoin::Builder params(memb->chan); params.add(memb); params.finalize(); params.Broadcast(); SpanningTreeUtilities::SendListLimits(memb->chan, nullptr); } else { CmdBuilder params(memb->user, "IJOIN"); params.push(memb->chan->name); params.push_int(memb->id); if (!memb->modes.empty()) { params.push(ConvToStr(memb->chan->age)); params.push(memb->GetAllPrefixModes()); } params.Broadcast(); } } void ModuleSpanningTree::OnChangeHost(User* user, const std::string& newhost) { if (!user->IsFullyConnected() || !IS_LOCAL(user)) return; CmdBuilder(user, "FHOST").push(newhost).push('*').Broadcast(); } void ModuleSpanningTree::OnChangeRealHost(User* user, const std::string& newhost) { if (!user->IsFullyConnected() || !IS_LOCAL(user)) return; CmdBuilder(user, "FHOST").push('*').push(newhost).Broadcast(); } void ModuleSpanningTree::OnChangeRealName(User* user, const std::string& real) { if (!user->IsFullyConnected() || !IS_LOCAL(user)) return; CmdBuilder(user, "FNAME").push_last(real).Broadcast(); } void ModuleSpanningTree::OnChangeUser(User* user, const std::string& newuser) { if (!user->IsFullyConnected() || !IS_LOCAL(user)) return; CmdBuilder(user, "FIDENT").push(newuser).push("*").Broadcast(); } void ModuleSpanningTree::OnChangeRealUser(User* user, const std::string& newuser) { if (!user->IsFullyConnected() || !IS_LOCAL(user)) return; CmdBuilder(user, "FIDENT").push("*").push(newuser).Broadcast(); } void ModuleSpanningTree::OnUserPart(Membership* memb, std::string& partmessage, CUList& excepts) { if (IS_LOCAL(memb->user)) { CmdBuilder params(memb->user, "PART"); params.push(memb->chan->name); if (!partmessage.empty()) params.push_last(partmessage); params.Broadcast(); } } void ModuleSpanningTree::OnUserQuit(User* user, const std::string& reason, const std::string& oper_message) { if (IS_LOCAL(user)) { if (oper_message != reason) ServerInstance->PI->SendMetadata(user, "operquit", oper_message); CmdBuilder(user, "QUIT").push_last(reason).Broadcast(); } else { // Hide the message if one of the following is true: // - User is being quit due to a netsplit and quietbursts is on // - User is on a silent services server TreeServer* server = TreeServer::Get(user); bool hide = (((server->IsDead()) && (Utils->quiet_bursts)) || (server->IsSilentService())); if (!hide) { ServerInstance->SNO.WriteToSnoMask('Q', "Client exiting on server {}: {} ({}) [{}]", user->server->GetName(), user->GetRealMask(), user->GetAddress(), oper_message); } } // Regardless, update the UserCount TreeServer::Get(user)->UserCount--; } void ModuleSpanningTree::OnUserPostNick(User* user, const std::string& oldnick) { if (IS_LOCAL(user)) { // The nick TS is updated by the core, we don't do it CmdBuilder params(user, "NICK"); params.push(user->nick); params.push(ConvToStr(user->nickchanged)); params.Broadcast(); } else if (!loopCall) { ServerInstance->Logs.Normal(MODNAME, "WARNING: Changed nick of remote user {} from {} to {} TS {} by ourselves!", user->uuid, oldnick, user->nick, user->nickchanged); } } void ModuleSpanningTree::OnUserKick(User* source, Membership* memb, const std::string& reason, CUList& excepts) { if ((!IS_LOCAL(source)) && (source != ServerInstance->FakeClient)) return; CmdBuilder params(source, "KICK"); params.push(memb->chan->name); params.push(memb->user->uuid); // If a remote user is being kicked by us then send the membership id in the kick too if (!IS_LOCAL(memb->user)) params.push_int(memb->id); params.push_last(reason); params.Broadcast(); } void ModuleSpanningTree::OnPreRehash(User* user, const std::string& parameter) { ServerInstance->Logs.Debug(MODNAME, "OnPreRehash called with param {}", parameter); // Send out to other servers if (!parameter.empty() && parameter[0] != '-') { CmdBuilder params(user ? user : ServerInstance->FakeClient, "REHASH"); params.push(parameter); params.Forward(user ? TreeServer::Get(user)->GetRoute() : nullptr); } } void ModuleSpanningTree::ReadConfig(ConfigStatus& status) { // Did this rehash change the description of this server? const std::string& newdesc = ServerInstance->Config->ServerDesc; if (newdesc != Utils->TreeRoot->GetDesc()) { // Broadcast a SINFO desc message to let the network know about the new description. This is the description // string that is sent in the SERVER message initially and shown for example in WHOIS. // We don't need to update the field itself in the Server object - the core does that. CommandSInfo::Builder(Utils->TreeRoot, "desc", newdesc).Broadcast(); } const auto& newcustomversion = ServerInstance->Config->CustomVersion; if (newcustomversion != Utils->TreeRoot->customversion) { Utils->TreeRoot->customversion = newcustomversion; CommandSInfo::Builder(Utils->TreeRoot, "customversion", newcustomversion).Broadcast(); } // Re-read config stuff try { Utils->ReadConfiguration(); } catch (const ModuleException& e) { // Refresh the IP cache anyway, so servers read before the error will be allowed to connect Utils->RefreshIPCache(); // Always warn local opers with snomask +l, also warn globally (snomask +L) if the rehash was issued by a remote user std::string msg = "Error in configuration: "; msg.append(e.GetReason()); ServerInstance->SNO.WriteToSnoMask('l', msg); if (status.srcuser && !IS_LOCAL(status.srcuser)) ServerInstance->PI->SendSNONotice('L', msg); } } namespace { void BroadcastModuleState(Module* mod, bool loading) { std::stringstream buffer; buffer << (loading ? '+' : '-') << ModuleManager::ShrinkModName(mod->ModuleFile); std::stringstream compatbuffer; compatbuffer << (loading ? '+' : '-') << mod->ModuleFile; if (loading) { const std::string linkstring = SpanningTreeUtilities::BuildLinkString(PROTO_INSPIRCD_4, mod); if (!linkstring.empty()) buffer << '=' << linkstring; const std::string compatlinkstring = SpanningTreeUtilities::BuildLinkString(PROTO_INSPIRCD_3, mod); if (!compatlinkstring.empty()) compatbuffer << '=' << compatlinkstring; } for (const auto* child : Utils->TreeRoot->GetChildren()) { if (!child->GetSocket()) continue; // Should never happen? if (child->GetSocket()->proto_version <= PROTO_INSPIRCD_3) CommandMetadata::Builder("modules", buffer.str()).Forward(child); else CommandMetadata::Builder("modules", compatbuffer.str()).Forward(child); } } } void ModuleSpanningTree::OnLoadModule(Module* mod) { BroadcastModuleState(mod, true); } void ModuleSpanningTree::OnUnloadModule(Module* mod) { if (!Utils) return; BroadcastModuleState(mod, false); if (mod == this) { // We are being unloaded, inform modules about all servers splitting which cannot be done later when the servers are actually disconnected for (const auto& [_, server] : Utils->serverlist) { if (!server->IsRoot()) linkeventprov.Call(&ServerProtocol::LinkEventListener::OnServerSplit, server, false); } return; } // Some other module is being unloaded. If it provides an IOHook we use, we must close that server connection now. restart: // Close all connections which use an IO hook provided by this module for (const auto* child : Utils->TreeRoot->GetChildren()) { TreeSocket* sock = child->GetSocket(); if (sock->GetModHook(mod)) { sock->SendError("TLS module unloaded"); sock->Close(); // XXX: The list we're iterating is modified by TreeServer::SQuit() which is called by Close() goto restart; } } for (const auto& [sock, _] : Utils->timeoutlist) { if (sock->GetModHook(mod)) sock->Close(); } } void ModuleSpanningTree::OnOperLogin(User* user, const std::shared_ptr<OperAccount>& oper, bool automatic) { if (!user->IsFullyConnected() || !IS_LOCAL(user)) return; // Note: The protocol does not allow direct umode +o; // sending OPERTYPE infers +o modechange locally. CommandOpertype::Builder(user, oper, automatic).Broadcast(); } void ModuleSpanningTree::OnAddLine(User* user, XLine* x) { if (!x->IsBurstable() || loopCall || (user && !IS_LOCAL(user))) return; if (!user) user = ServerInstance->FakeClient; CommandAddLine::Builder(x, user).Broadcast(); } void ModuleSpanningTree::OnDelLine(User* user, XLine* x) { if (!x->IsBurstable() || loopCall || (user && !IS_LOCAL(user))) return; if (!user) user = ServerInstance->FakeClient; CmdBuilder params(user, "DELLINE"); params.push(x->type); params.push(x->Displayable()); params.Broadcast(); } void ModuleSpanningTree::OnUserAway(User* user, const std::optional<AwayState>& prevstate) { if (IS_LOCAL(user) && user->IsFullyConnected()) CommandAway::Builder(user).Broadcast(); } void ModuleSpanningTree::OnUserBack(User* user, const std::optional<AwayState>& prevstate) { OnUserAway(user, prevstate); } void ModuleSpanningTree::OnMode(User* source, User* u, Channel* c, const Modes::ChangeList& modes, ModeParser::ModeProcessFlag processflags) { if (processflags & ModeParser::MODE_LOCALONLY) return; if (u) { if (!u->IsFullyConnected()) return; CmdBuilder params(source, "MODE"); params.push(u->uuid); params.push(ClientProtocol::Messages::Mode::ToModeLetters(modes)); params.push_raw(Translate::ModeChangeListToParams(modes.getlist())); params.Broadcast(); } else { CmdBuilder params(source, "FMODE"); params.push(c->name); params.push_int(c->age); params.push(ClientProtocol::Messages::Mode::ToModeLetters(modes)); params.push_raw(Translate::ModeChangeListToParams(modes.getlist())); params.Broadcast(); } } void ModuleSpanningTree::OnShutdown(const std::string& reason) { const TreeServer::ChildServers& children = Utils->TreeRoot->GetChildren(); while (!children.empty()) children.front()->SQuit(reason, true); } void ModuleSpanningTree::OnDecodeMetadata(Extensible* target, const std::string& extname, const std::string& extdata) { // HACK: this should use automatically synced user metadata. if (target && target->extype == ExtensionType::USER && irc::equals(extname, "uniqueusername")) static_cast<User*>(target)->uniqueusername = (extdata != "0"); } Cullable::Result ModuleSpanningTree::Cull() { if (Utils) Utils->Cull(); return Module::Cull(); } ModuleSpanningTree::~ModuleSpanningTree() { ServerInstance->PI = &ServerInstance->DefaultProtocolInterface; auto* newsrv = new Server(ServerInstance->Config->ServerId, ServerInstance->Config->ServerName, ServerInstance->Config->ServerDesc); SetLocalUsersServer(newsrv); delete Utils; } /* It is IMPORTANT that m_spanningtree is the last module in the chain * so that any activity it sees is FINAL, e.g. we arent going to send out * a NICK message before the cloak module has finished putting the +x on the user, * etc etc. * Therefore, we set our priority to PRIORITY_LAST to make sure we end up at the END of * the module call queue. */ void ModuleSpanningTree::Prioritize() { ServerInstance->Modules.SetPriority(this, PRIORITY_LAST); ServerInstance->Modules.SetPriority(this, I_OnPreTopicChange, PRIORITY_FIRST); } MODULE_INIT(ModuleSpanningTree) ��������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/src/modules/m_spanningtree/main.h����������������������������������������������������0000664�0000000�0000000�00000016216�14771603147�0021722�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2019 linuxdaemon <linuxdaemon.irc@gmail.com> * Copyright (C) 2013-2015 Attila Molnar <attilamolnar@hush.com> * Copyright (C) 2013, 2018-2024 Sadie Powell <sadie@witchery.services> * Copyright (C) 2013 Adam <Adam@anope.org> * Copyright (C) 2012 Robby <robby@chatbelgie.be> * Copyright (C) 2009-2010 Daniel De Graaf <danieldg@inspircd.org> * Copyright (C) 2009 Uli Schlachter <psychon@znc.in> * Copyright (C) 2007-2008 Dennis Friis <peavey@inspircd.org> * Copyright (C) 2007, 2009 Craig Edwards <brain@inspircd.org> * Copyright (C) 2007 Robin Burchell <robin+git@viroteck.net> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #pragma once #include "inspircd.h" #include "event.h" #include "modules/dns.h" #include "modules/ssl.h" #include "modules/stats.h" #include "modules/ctctags.h" #include "modules/server.h" #include "servercommand.h" #include "commands.h" #include "protocolinterface.h" #include "tags.h" /** Forward declarations */ class SpanningTreeUtilities; class CacheRefreshTimer; class TreeServer; class Link; class Autoconnect; /** This is the main class for the spanningtree module */ class ModuleSpanningTree final : public Module , public Away::EventListener , public Stats::EventListener , public CTCTags::EventListener { /** Client to server commands, registered in the core */ CommandRConnect rconnect; CommandRSQuit rsquit; CommandMap map; /** Server to server only commands, not registered in the core */ SpanningTreeCommands commands; /** Next membership id assigned when a local user joins a channel */ Membership::Id currmembid = 1; public: /** The specialized ProtocolInterface that is assigned to ServerInstance->PI on load */ SpanningTreeProtocolInterface protocolinterface; /** Event provider for our routing event. */ Events::ModuleEventProvider routeeventprov; /** Event provider for our link events. */ Events::ModuleEventProvider linkeventprov; /** Event provider for our message events. */ Events::ModuleEventProvider messageeventprov; /** Event provider for our sync events. */ Events::ModuleEventProvider synceventprov; /** API for accessing user client certificates. */ UserCertificateAPI sslapi; /** Tags for server to server messages. */ ServerTags servertags; /** The DNS manager service provided by core_dns. */ DNS::ManagerRef DNS; /** Event provider for message tags. */ ClientProtocol::MessageTagEvent tagevprov; /** Manager for server commands. */ ServerCommandManager CmdManager; /** Set to true if inside a spanningtree call, to prevent sending * xlines and other things back to their source */ bool loopCall = false; /** Constructor */ ModuleSpanningTree(); void init() override; /** Shows /LINKS */ void ShowLinks(TreeServer* Current, User* user, int hops); /** Handle LINKS command */ void HandleLinks(const CommandBase::Params& parameters, User* user); /** Handle SQUIT */ static ModResult HandleSquit(const CommandBase::Params& parameters, User* user); /** Handle remote WHOIS */ static ModResult HandleRemoteWhois(const CommandBase::Params& parameters, User* user); /** Connect a server locally */ void ConnectServer(const std::shared_ptr<Link>& x, const std::shared_ptr<Autoconnect>& y = nullptr); /** Connect the next autoconnect server */ void ConnectServer(const std::shared_ptr<Autoconnect>& y, bool on_timer); /** Check if any servers are due to be autoconnected */ void AutoConnectServers(time_t curtime); /** Check if any connecting servers should timeout */ static void DoConnectTimeout(time_t curtime); /** Handle remote VERSION */ static ModResult HandleVersion(const CommandBase::Params& parameters, User* user); /** Handle CONNECT */ ModResult HandleConnect(const CommandBase::Params& parameters, User* user); ModResult OnPreCommand(std::string& command, CommandBase::Params& parameters, LocalUser* user, bool validated) override; void OnPostCommand(Command*, const CommandBase::Params& parameters, LocalUser* user, CmdResult result, bool loop) override; void OnUserConnect(LocalUser* source) override; void OnUserInvite(User* source, User* dest, Channel* channel, time_t timeout, ModeHandler::Rank notifyrank, CUList& notifyexcepts) override; ModResult OnPreTopicChange(User* user, Channel* chan, const std::string& topic) override; void OnPostTopicChange(User* user, Channel* chan, const std::string& topic) override; void OnUserPostMessage(User* user, const MessageTarget& target, const MessageDetails& details) override; void OnUserPostTagMessage(User* user, const MessageTarget& target, const CTCTags::TagMessageDetails& details) override; void OnBackgroundTimer(time_t curtime) override; void OnUserJoin(Membership* memb, bool sync, bool created, CUList& excepts) override; void OnChangeHost(User* user, const std::string& newhost) override; void OnChangeRealHost(User* user, const std::string& newhost) override; void OnChangeRealName(User* user, const std::string& real) override; void OnChangeUser(User* user, const std::string& newuser) override; void OnChangeRealUser(User* user, const std::string& newuser) override; void OnUserPart(Membership* memb, std::string& partmessage, CUList& excepts) override; void OnUserQuit(User* user, const std::string& reason, const std::string& oper_message) override; void OnUserPostNick(User* user, const std::string& oldnick) override; void OnUserKick(User* source, Membership* memb, const std::string& reason, CUList& excepts) override; void OnPreRehash(User* user, const std::string& parameter) override; void ReadConfig(ConfigStatus& status) override; void OnOperLogin(User* user, const std::shared_ptr<OperAccount>& oper, bool automatic) override; void OnAddLine(User* u, XLine* x) override; void OnDelLine(User* u, XLine* x) override; ModResult OnStats(Stats::Context& stats) override; void OnUserAway(User* user, const std::optional<AwayState>& prevstate) override; void OnUserBack(User* user, const std::optional<AwayState>& prevstate) override; void OnLoadModule(Module* mod) override; void OnUnloadModule(Module* mod) override; ModResult OnAcceptConnection(int newsock, ListenSocket* from, const irc::sockets::sockaddrs& client, const irc::sockets::sockaddrs& server) override; void OnMode(User* source, User* u, Channel* c, const Modes::ChangeList& modes, ModeParser::ModeProcessFlag processflags) override; void OnShutdown(const std::string& reason) override; void OnDecodeMetadata(Extensible* target, const std::string& extname, const std::string& extdata) override; Cullable::Result Cull() override; ~ModuleSpanningTree() override; void Prioritize() override; }; ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/src/modules/m_spanningtree/metadata.cpp����������������������������������������������0000664�0000000�0000000�00000011147�14771603147�0023107�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2018-2023 Sadie Powell <sadie@witchery.services> * Copyright (C) 2013-2015 Attila Molnar <attilamolnar@hush.com> * Copyright (C) 2012 Robby <robby@chatbelgie.be> * Copyright (C) 2009-2010 Daniel De Graaf <danieldg@inspircd.org> * Copyright (C) 2009 Uli Schlachter <psychon@znc.in> * Copyright (C) 2008 Robin Burchell <robin+git@viroteck.net> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include "inspircd.h" #include "extension.h" #include "commands.h" CmdResult CommandMetadata::Handle(User* srcuser, Params& params) { if (params[0] == "*") { std::string value = params.size() < 3 ? "" : params[2]; FOREACH_MOD(OnDecodeMetadata, (nullptr, params[1], value)); return CmdResult::SUCCESS; } if (params[0] == "@") { // Membership METADATA has four additional parameters: // 1. The uuid of the membership's user. // 2. The name of the membership's channel. // 3. The channel creation timestamp. // 4. The membership identifier. // // :22D METADATA @ uuid #channel 12345 12345 extname :extdata if (params.size() < 6) throw ProtocolException("Insufficient parameters for channel METADATA"); auto* u = ServerInstance->Users.FindUUID(params[1]); if (!u) return CmdResult::FAILURE; // User does not exist. auto* c = ServerInstance->Channels.Find(params[2]); if (!c) return CmdResult::FAILURE; // Channel does not exist. time_t chants = ServerCommand::ExtractTS(params[3]); if (c->age < chants) return CmdResult::FAILURE; // Their channel is newer than ours (probably recreated). Membership* m = c->GetUser(u); if (!m || m->id != Membership::IdFromString(params[4])) return CmdResult::FAILURE; // User is not in the channel. ExtensionItem* item = ServerInstance->Extensions.GetItem(params[5]); const std::string value = params.size() < 7 ? "" : params[6]; if (item && item->extype == ExtensionType::MEMBERSHIP) item->FromNetwork(m, value); FOREACH_MOD(OnDecodeMetadata, (m, params[5], value)); } if (ServerInstance->Channels.IsPrefix(params[0][0])) { // Channel METADATA has an additional parameter: the channel TS // :22D METADATA #channel 12345 extname :extdata if (params.size() < 3) throw ProtocolException("Insufficient parameters for channel METADATA"); auto* c = ServerInstance->Channels.Find(params[0]); if (!c) return CmdResult::FAILURE; time_t ChanTS = ServerCommand::ExtractTS(params[1]); if (c->age < ChanTS) // Their TS is newer than ours, discard this command and do not propagate return CmdResult::FAILURE; std::string value = params.size() < 4 ? "" : params[3]; ExtensionItem* item = ServerInstance->Extensions.GetItem(params[2]); if (item && item->extype == ExtensionType::CHANNEL) item->FromNetwork(c, value); FOREACH_MOD(OnDecodeMetadata, (c, params[2], value)); } else { auto* u = ServerInstance->Users.FindUUID(params[0]); if (u) { ExtensionItem* item = ServerInstance->Extensions.GetItem(params[1]); std::string value = params.size() < 3 ? "" : params[2]; if (item && item->extype == ExtensionType::USER) item->FromNetwork(u, value); FOREACH_MOD(OnDecodeMetadata, (u, params[1], value)); } } return CmdResult::SUCCESS; } CommandMetadata::Builder::Builder(const Extensible* ext, const std::string& key, const std::string& val) : CmdBuilder("METADATA") { switch (ext->extype) { case ExtensionType::CHANNEL: { const Channel* chan = static_cast<const Channel*>(ext); push(chan->name); push_int(chan->age); break; } case ExtensionType::MEMBERSHIP: { const Membership* memb = static_cast<const Membership*>(ext); push_raw("@"); push(memb->user->uuid); push_raw(memb->chan->name); push_int(memb->chan->age); push_int(memb->id); break; } case ExtensionType::USER: { const User* user = static_cast<const User*>(ext); push(user->uuid); break; } } push(key); push_last(val); } CommandMetadata::Builder::Builder(const std::string& key, const std::string& val) : CmdBuilder("METADATA") { push("*"); push(key); push_last(val); } �������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/src/modules/m_spanningtree/misccommands.cpp������������������������������������������0000664�0000000�0000000�00000004304�14771603147�0024001�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2018-2022 Sadie Powell <sadie@witchery.services> * Copyright (C) 2013 Attila Molnar <attilamolnar@hush.com> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include "inspircd.h" #include "main.h" #include "commands.h" #include "treeserver.h" void CmdBuilder::FireEvent(const Server* target, const char* cmd, ClientProtocol::TagMap& taglist) { if (!Utils->Creator || Utils->Creator->dying) return; Utils->Creator->messageeventprov.Call(&ServerProtocol::MessageEventListener::OnBuildServerMessage, target, cmd, taglist); UpdateTags(); } void CmdBuilder::FireEvent(const User* target, const char* cmd, ClientProtocol::TagMap& taglist) { if (!Utils->Creator || Utils->Creator->dying) return; Utils->Creator->messageeventprov.Call(&ServerProtocol::MessageEventListener::OnBuildUserMessage, target, cmd, taglist); UpdateTags(); } void CmdBuilder::UpdateTags() { std::string taglist; if (!tags.empty()) { char separator = '@'; for (const auto& [tagname, tagvalue] : tags) { taglist.push_back(separator); separator = ';'; taglist.append(tagname); if (!tagvalue.value.empty()) { taglist.push_back('='); taglist.append(tagvalue.value); } } taglist.push_back(' '); } content.replace(0, tagsize, taglist); tagsize = taglist.length(); } CmdResult CommandSNONotice::Handle(User* user, Params& params) { ServerInstance->SNO.WriteToSnoMask(params[0][0], "From " + user->nick + ": " + params[1]); return CmdResult::SUCCESS; } CmdResult CommandEndBurst::HandleServer(TreeServer* server, Params& params) { server->FinishBurst(); return CmdResult::SUCCESS; } ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/src/modules/m_spanningtree/netburst.cpp����������������������������������������������0000664�0000000�0000000�00000015010�14771603147�0023166�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2019-2024 Sadie Powell <sadie@witchery.services> * Copyright (C) 2012-2015 Attila Molnar <attilamolnar@hush.com> * Copyright (C) 2012 Robby <robby@chatbelgie.be> * Copyright (C) 2009-2010 Daniel De Graaf <danieldg@inspircd.org> * Copyright (C) 2008 Robin Burchell <robin+git@viroteck.net> * Copyright (C) 2008 Craig Edwards <brain@inspircd.org> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include "inspircd.h" #include "listmode.h" #include "xline.h" #include "treesocket.h" #include "treeserver.h" #include "main.h" #include "commands.h" /** This function is called when we want to send a netburst to a local * server. There is a set order we must do this, because for example * users require their servers to exist, and channels require their * users to exist. You get the idea. */ void TreeSocket::DoBurst(TreeServer* s) { ServerInstance->SNO.WriteToSnoMask('l', "Bursting to \002{}\002 (Authentication: {}{}).", s->GetName(), capab->auth_fingerprint ? "TLS certificate fingerprint and " : "", capab->auth_challenge ? "challenge-response" : "plaintext password"); this->CleanNegotiationInfo(); this->WriteLine(CmdBuilder("BURST").push_int(ServerInstance->Time())); // Introduce all servers behind us this->SendServers(Utils->TreeRoot, s); // Introduce all users this->SendUsers(s); // Sync all channels for (const auto& [_, chan] : ServerInstance->Channels.GetChans()) SyncChannel(chan, s); // Send all xlines this->SendXLines(); Utils->Creator->synceventprov.Call(&ServerProtocol::SyncEventListener::OnSyncNetwork, *s); this->WriteLine(CmdBuilder("ENDBURST")); ServerInstance->SNO.WriteToSnoMask('l', "Finished bursting to \002"+ s->GetName()+"\002."); } void TreeSocket::SendServerInfo(TreeServer* from) { this->WriteLine(CommandSInfo::Builder(from, "customversion", from->customversion)); this->WriteLine(CommandSInfo::Builder(from, "rawbranch", from->rawbranch)); this->WriteLine(CommandSInfo::Builder(from, "rawversion", from->rawversion)); } /** Recursively send the server tree. * This is used during network burst to inform the other server * (and any of ITS servers too) of what servers we know about. * If at any point any of these servers already exist on the other * end, our connection may be terminated. */ void TreeSocket::SendServers(TreeServer* Current, TreeServer* s) { SendServerInfo(Current); for (auto* recursive_server : Current->GetChildren()) { if (recursive_server != s) { this->WriteLine(CommandServer::Builder(recursive_server)); /* down to next level */ this->SendServers(recursive_server, s); } } } // Send one or more FJOINs for a channel of users. void TreeSocket::SendFJoins(Channel* chan) { CommandFJoin::Builder fjoin(chan); for (const auto& [_, memb] : chan->GetUsers()) fjoin.add(memb); this->WriteLine(fjoin.finalize()); } /** Send all XLines we know about */ void TreeSocket::SendXLines() { for (const auto& xltype : ServerInstance->XLines->GetAllTypes()) { /* Expired lines are removed in XLineManager::GetAll() */ XLineLookup* lookup = ServerInstance->XLines->GetAll(xltype); /* lookup cannot be NULL in this case but a check won't hurt */ if (lookup) { for (const auto& [_, xline] : *lookup) { /* Is it burstable? this is better than an explicit check for type 'K'. * We break the loop as NONE of the items in this group are worth iterating. */ if (xline->IsBurstable()) this->WriteLine(CommandAddLine::Builder(xline)); } } } } void TreeSocket::SendListModes(Channel* chan) { for (auto* mode : ServerInstance->Modes.GetListModes()) { ListModeBase::ModeList* list = mode->GetList(chan); if (!list || list->empty()) continue; CmdBuilder lmode("LMODE"); lmode.push(chan->name).push_int(chan->age).push(mode->GetModeChar()); for (const auto& entry : *list) lmode.push(entry.mask).push(entry.setter).push_int(entry.time); this->WriteLine(lmode.str()); } } /** Send channel users, topic, modes and global metadata */ void TreeSocket::SyncChannel(Channel* chan, TreeServer* s) { SendFJoins(chan); // If the topic was ever set, send it, even if it's empty now // because a new empty topic should override an old non-empty topic if (chan->topicset != 0) this->WriteLine(CommandFTopic::Builder(chan)); SpanningTreeUtilities::SendListLimits(chan, this); SendListModes(chan); for (const auto& [item, value] : chan->GetExtList()) { const std::string valuestr = item->ToNetwork(chan, value); if (!valuestr.empty()) { this->WriteLine(CommandMetadata::Builder(chan, item->name, valuestr)); item->OnSync(chan, value, s); } } for (const auto& [_, memb] : chan->GetUsers()) { for (const auto& [item, value] : memb->GetExtList()) { const std::string valuestr = item->ToNetwork(memb, value); if (!valuestr.empty()) { this->WriteLine(CommandMetadata::Builder(memb, item->name, valuestr)); item->OnSync(memb, value, s); } } } Utils->Creator->synceventprov.Call(&ServerProtocol::SyncEventListener::OnSyncChannel, chan, *s); } /** Send all users and their state, including oper and away status and global metadata */ void TreeSocket::SendUsers(TreeServer* s) { for (const auto& [_, user] : ServerInstance->Users.GetUsers()) { if (!user->IsFullyConnected()) continue; this->WriteLine(CommandUID::Builder(user)); if (user->IsOper()) this->WriteLine(CommandOpertype::Builder(user, user->oper)); if (user->IsAway()) this->WriteLine(CommandAway::Builder(user)); if (user->uniqueusername) // TODO: convert this to BooleanExtItem. this->WriteLine(CommandMetadata::Builder(user, "uniqueusername", "1")); for (const auto& [item, obj] : user->GetExtList()) { const std::string value = item->ToNetwork(user, obj); if (!value.empty()) { this->WriteLine(CommandMetadata::Builder(user, item->name, value)); item->OnSync(user, obj, s); } } Utils->Creator->synceventprov.Call(&ServerProtocol::SyncEventListener::OnSyncUser, user, *s); } } ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/src/modules/m_spanningtree/nick.cpp��������������������������������������������������0000664�0000000�0000000�00000004047�14771603147�0022254�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2018, 2020, 2022-2023 Sadie Powell <sadie@witchery.services> * Copyright (C) 2013-2014 Attila Molnar <attilamolnar@hush.com> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include "inspircd.h" #include "main.h" #include "utils.h" #include "commands.h" #include "treeserver.h" CmdResult CommandNick::HandleRemote(::RemoteUser* user, Params& params) { if ((isdigit(params[0][0])) && (params[0] != user->uuid)) throw ProtocolException("Attempted to change nick to an invalid or non-matching UUID"); // Timestamp of the new nick time_t newts = ServerCommand::ExtractTS(params[1]); /* * On nick messages, check that the nick doesn't already exist here. * If it does, perform collision logic. */ auto* x = ServerInstance->Users.FindNick(params[0], true); if (x && x != user) { // 'x' is the already existing user using the same nick as params[0] // 'user' is the user trying to change nick to the in use nick bool they_change = SpanningTreeUtilities::DoCollision(x, TreeServer::Get(user), newts, user->GetRealUser(), user->GetAddress(), user->uuid, "NICK"); if (they_change) { // Remote client lost, or both lost, rewrite this nick change as a change to uuid before // calling ChangeNick() and forwarding the message params[0] = user->uuid; params[1] = ConvToStr(CommandSave::SavedTimestamp); newts = CommandSave::SavedTimestamp; } } user->ChangeNick(params[0], newts); return CmdResult::SUCCESS; } �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/src/modules/m_spanningtree/nickcollide.cpp�������������������������������������������0000664�0000000�0000000�00000011037�14771603147�0023605�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2019, 2021-2023 Sadie Powell <sadie@witchery.services> * Copyright (C) 2013-2015 Attila Molnar <attilamolnar@hush.com> * Copyright (C) 2012 Robby <robby@chatbelgie.be> * Copyright (C) 2009 Uli Schlachter <psychon@znc.in> * Copyright (C) 2009 Daniel De Graaf <danieldg@inspircd.org> * Copyright (C) 2008, 2010 Craig Edwards <brain@inspircd.org> * Copyright (C) 2008 Robin Burchell <robin+git@viroteck.net> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include "inspircd.h" #include "treesocket.h" #include "treeserver.h" #include "utils.h" #include "commandbuilder.h" #include "commands.h" /* * Yes, this function looks a little ugly. * However, in some circumstances we may not have a User, so we need to do things this way. * Returns true if remote or both lost, false otherwise. * Sends SAVEs as appropriate and forces nick change of the user 'u' if our side loses or if both lose. * Does not change the nick of the user that is trying to claim the nick of 'u', i.e. the "remote" user. */ bool SpanningTreeUtilities::DoCollision(User* u, TreeServer* server, time_t remotets, const std::string& remoteuser, const std::string& remoteip, const std::string& remoteuid, const char* collidecmd) { // At this point we're sure that a collision happened, increment the counter regardless of who wins ServerInstance->Stats.Collisions++; /* * Under old protocol rules, we would have had to kill both clients. * Really, this sucks. * These days, we have UID. And, so what we do is, force nick change client(s) * involved according to timestamp rules. * * RULES: * user@ip equal: * Force nick change on OLDER timestamped client * user@ip differ: * Force nick change on NEWER timestamped client * TS EQUAL: * FNC both. * * This stops abusive use of collisions, simplifies problems with loops, and so on. * -- w00t */ bool bChangeLocal = true; bool bChangeRemote = true; // If the timestamps are not equal only one of the users has to change nick, // otherwise both have to change const time_t localts = u->nickchanged; if (remotets != localts) { /* first, let's see if user@host matches. */ const std::string& localuser = u->GetRealUser(); const std::string& localip = u->GetAddress(); bool SamePerson = (localuser == remoteuser) && (localip == remoteip); /* * if user@ip is equal, and theirs is newer, or * user@ip differ, and ours is newer */ if ((SamePerson && remotets < localts) || (!SamePerson && remotets > localts)) { // Only remote needs to change bChangeLocal = false; } else { // Only ours needs to change bChangeRemote = false; } } ServerInstance->Logs.Debug(MODNAME, "Nick collision on \"{}\" caused by {}: {}/{}/{}@{} {} <-> {}/{}/{}@{} {}", u->nick, collidecmd, u->uuid, localts, u->GetRealUser(), u->GetAddress(), bChangeLocal, remoteuid, remotets, remoteuser, remoteip, bChangeRemote); /* * Send SAVE and accept the losing client with its UID (as we know the SAVE will * not fail under any circumstances -- UIDs are netwide exclusive). * * This means that each side of a collide will generate one extra NICK back to where * they have just linked (and where it got the SAVE from), however, it will * be dropped harmlessly as it will come in as :928AAAB NICK 928AAAB, and we already * have 928AAAB's nick set to that. * -- w00t */ if (bChangeLocal) { /* * Local-side nick needs to change. Just in case we are hub, and * this "local" nick is actually behind us, send a SAVE out. */ CmdBuilder params("SAVE"); params.push(u->uuid); params.push(ConvToStr(u->nickchanged)); params.Broadcast(); u->ChangeNick(u->uuid, CommandSave::SavedTimestamp); } if (bChangeRemote) { /* * Remote side needs to change. If this happens, we modify the UID or NICK and * send back a SAVE to the source. */ CmdBuilder("SAVE").push(remoteuid).push_int(remotets).Unicast(server->ServerUser); } return bChangeRemote; } �������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/src/modules/m_spanningtree/num.cpp���������������������������������������������������0000664�0000000�0000000�00000004266�14771603147�0022132�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2018, 2020, 2022-2023 Sadie Powell <sadie@witchery.services> * Copyright (C) 2016 Attila Molnar <attilamolnar@hush.com> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include "inspircd.h" #include "utils.h" #include "commands.h" #include "remoteuser.h" CmdResult CommandNum::HandleServer(TreeServer* server, CommandBase::Params& params) { User* const target = ServerInstance->Users.FindUUID(params[1]); if (!target) return CmdResult::FAILURE; LocalUser* const localtarget = IS_LOCAL(target); if (!localtarget) return CmdResult::SUCCESS; Numeric::Numeric numeric(ConvToNum<unsigned int>(params[2])); // Passing NULL is ok, in that case the numeric source becomes this server numeric.SetServer(Utils->FindServerID(params[0])); numeric.GetParams().insert(numeric.GetParams().end(), params.begin()+3, params.end()); localtarget->WriteNumeric(numeric); return CmdResult::SUCCESS; } RouteDescriptor CommandNum::GetRouting(User* user, const Params& params) { return ROUTE_UNICAST(params[1]); } CommandNum::Builder::Builder(SpanningTree::RemoteUser* target, const Numeric::Numeric& numeric) : CmdBuilder("NUM") { TreeServer* const server = (numeric.GetServer() ? (static_cast<TreeServer*>(numeric.GetServer())) : Utils->TreeRoot); push(server->GetId()).push(target->uuid).push(INSP_FORMAT("{:03}", numeric.GetNumeric())); const CommandBase::Params& params = numeric.GetParams(); if (!params.empty()) { for (CommandBase::Params::const_iterator i = params.begin(); i != params.end()-1; ++i) push(*i); push_last(params.back()); } push_tags(params.GetTags()); } ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/src/modules/m_spanningtree/opertype.cpp����������������������������������������������0000664�0000000�0000000�00000011356�14771603147�0023200�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2018, 2020-2024 Sadie Powell <sadie@witchery.services> * Copyright (C) 2013-2014 Attila Molnar <attilamolnar@hush.com> * Copyright (C) 2012 Robby <robby@chatbelgie.be> * Copyright (C) 2009-2010 Daniel De Graaf <danieldg@inspircd.org> * Copyright (C) 2008 Robin Burchell <robin+git@viroteck.net> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include "inspircd.h" #include "commands.h" #include "treeserver.h" #include "utils.h" #include "main.h" class RemoteOperAccount final : public OperAccount { private: static void ReadModes(ModeParser::ModeStatus& modes, const ClientProtocol::TagMap& tags, const std::string& tag) { auto it = tags.find(tag); if (it != tags.end()) { for (const auto chr : ClientProtocol::Message::UnescapeTag(it->second.value)) { size_t idx = ModeParser::GetModeIndex(chr); if (idx != ModeParser::MODEID_MAX) modes.set(idx); } return; } // Probably a legacy server. modes.set(); } static void ReadTokens(TokenList& tokens, const ClientProtocol::TagMap& tags, const std::string& tag) { auto it = tags.find(tag); if (it != tags.end()) { tokens.AddList(ClientProtocol::Message::UnescapeTag(it->second.value)); return; } // Probably a legacy server. tokens.Add("*"); } public: RemoteOperAccount(const std::string& n, const ClientProtocol::TagMap& tags) : OperAccount(n, nullptr, ServerInstance->Config->EmptyTag) { auto it = tags.find("~name"); if (it != tags.end()) name = ClientProtocol::Message::UnescapeTag(it->second.value); ReadModes(chanmodes, tags, "~chanmodes"); ReadModes(usermodes, tags, "~usermodes"); ReadModes(snomasks, tags, "~snomasks"); ReadTokens(commands, tags, "~commands"); ReadTokens(privileges, tags, "~privileges"); } }; CmdResult CommandOpertype::HandleRemote(RemoteUser* u, CommandBase::Params& params) { // Remote servers might be using entirely different oper privileges to us // so instead of looking up the remote oper type we just create a new tag // with the details sent by the remote. For legacy servers that don't send // the oper details we instead just assume they have access to everything // as was the default until 1206. bool automatic = params.GetTags().find("~automatic") != params.GetTags().end(); u->OperLogin(std::make_shared<RemoteOperAccount>(params.back(), params.GetTags()), automatic, true); if (Utils->quiet_bursts) { /* * If quiet bursts are enabled, and server is bursting or a silent services server * then do nothing. -- w00t */ TreeServer* remoteserver = TreeServer::Get(u); if (remoteserver->IsBehindBursting() || remoteserver->IsSilentService()) return CmdResult::SUCCESS; } std::string extra; if (params.GetTags().find("~name") != params.GetTags().end()) { extra += INSP_FORMAT(" ({}using account \x02{}\x02)", automatic ? "automatically " : "", u->oper->GetName()); } ServerInstance->SNO.WriteToSnoMask('O', "From {}: {} ({}) [{}] is now a server operator of type \x02{}\x02{}.", u->server->GetName(), u->nick, u->GetRealUserHost(), u->GetAddress(), u->oper->GetType(), extra); return CmdResult::SUCCESS; } CommandOpertype::Builder::Builder(User* user, const std::shared_ptr<OperAccount>& oper, bool automatic) : CmdBuilder(user, "OPERTYPE") { push_tags({ { "~name", { &Utils->Creator->servertags, ClientProtocol::Message::EscapeTag(oper->GetName()) } }, { "~chanmodes", { &Utils->Creator->servertags, ClientProtocol::Message::EscapeTag(oper->GetModes(MODETYPE_CHANNEL, true)) } }, { "~usermodes", { &Utils->Creator->servertags, ClientProtocol::Message::EscapeTag(oper->GetModes(MODETYPE_USER, true)) } }, { "~snomasks", { &Utils->Creator->servertags, ClientProtocol::Message::EscapeTag(oper->GetSnomasks(true)) } }, { "~commands", { &Utils->Creator->servertags, ClientProtocol::Message::EscapeTag(oper->GetCommands(true)) } }, { "~privileges", { &Utils->Creator->servertags, ClientProtocol::Message::EscapeTag(oper->GetPrivileges()) } }, }); if (automatic) { push_tags({ { "~automatic", { &Utils->Creator->servertags, "" } }, }); } push_last(oper->GetType()); } ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/src/modules/m_spanningtree/override_map.cpp������������������������������������������0000664�0000000�0000000�00000015234�14771603147�0024004�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2021 Dominic Hamon * Copyright (C) 2018-2025 Sadie Powell <sadie@witchery.services> * Copyright (C) 2017 B00mX0r <b00mx0r@aureus.pw> * Copyright (C) 2014 Adam <Adam@anope.org> * Copyright (C) 2013-2016 Attila Molnar <attilamolnar@hush.com> * Copyright (C) 2012 Robby <robby@chatbelgie.be> * Copyright (C) 2009 Daniel De Graaf <danieldg@inspircd.org> * Copyright (C) 2008 Robin Burchell <robin+git@viroteck.net> * Copyright (C) 2007 Craig Edwards <brain@inspircd.org> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include "inspircd.h" #include "timeutils.h" #include "main.h" #include "utils.h" #include "treeserver.h" #include "commands.h" CommandMap::CommandMap(Module* Creator) : Command(Creator, "MAP") { penalty = 2000; } static inline bool IsHidden(User* user, TreeServer* server) { if (!user->IsOper()) { if (server->Hidden) return true; if (Utils->HideServices && server->IsService()) return true; } return false; } // Calculate the map depth the servers go, and the longest server name static void GetDepthAndLen(TreeServer* current, unsigned int depth, unsigned int& max_depth, size_t& max_len, size_t& max_version) { if (depth > max_depth) max_depth = depth; if (current->GetName().length() > max_len) max_len = current->GetName().length(); if (current->rawversion.length() > max_version) max_version = current->rawversion.length(); for (auto* child : current->GetChildren()) GetDepthAndLen(child, depth + 1, max_depth, max_len, max_version); } static std::vector<std::string> GetMap(User* user, TreeServer* current, size_t max_len, size_t max_version_len, unsigned int depth) { float percent = 0; const UserMap& users = ServerInstance->Users.GetUsers(); if (!users.empty()) { // If there are no users, WHO THE HELL DID THE /MAP?!?!?! percent = current->UserCount * 100.0 / users.size(); } std::string buffer = current->GetName(); if (user->IsOper()) { buffer += " (" + current->GetId(); if (!current->rawversion.empty()) buffer += " " + current->rawversion; buffer += ")"; buffer.append(max_version_len - current->rawversion.length(), ' '); } // Pad with spaces until its at max len, max_len must always be >= my names length buffer.append(max_len - current->GetName().length(), ' '); buffer += INSP_FORMAT("{:5} [{:3.2f}%]", current->UserCount, percent); if (user->IsOper()) { time_t secs_up = ServerInstance->Time() - current->age; buffer += INSP_FORMAT(" [Up: {}", Duration::ToString(secs_up)); if (current->rtt) buffer += INSP_FORMAT(" Lag: {}ms", current->rtt); buffer += "]"; } std::vector<std::string> map; map.push_back(buffer); const TreeServer::ChildServers& servers = current->GetChildren(); for (TreeServer::ChildServers::const_iterator i = servers.begin(); i != servers.end(); ++i) { TreeServer* child = *i; if (IsHidden(user, child)) continue; bool last = true; for (TreeServer::ChildServers::const_iterator j = i + 1; last && j != servers.end(); ++j) if (!IsHidden(user, *j)) last = false; size_t next_len; if (user->IsOper() || !Utils->FlatLinks) { // This child is indented by us, so remove the depth from the max length to align the users properly next_len = max_len - 2; } else { // This user can not see depth, so max_len remains constant next_len = max_len; } // Build the map for this child std::vector<std::string> child_map = GetMap(user, child, next_len, max_version_len, depth + 1); for (std::vector<std::string>::const_iterator j = child_map.begin(); j != child_map.end(); ++j) { const char* prefix; if (user->IsOper() || !Utils->FlatLinks) { // If this server is not the root child if (j != child_map.begin()) { // If this child is not my last child, then add | // to be able to "link" the next server in my list to me, and to indent this child's servers if (!last) prefix = "т”‚ "; // Otherwise this is my last child, so just use a space as there's nothing else linked to me below this else prefix = " "; } // If we get here, this server must be the root child else { // If this is the last child, it gets a `- if (last) prefix = "т””т”€"; // Otherwise this isn't the last child, so it gets |- else prefix = "т”œт”€"; } } else // User can't see depth, so use no prefix prefix = ""; // Add line to the map map.push_back(prefix + *j); } } return map; } CmdResult CommandMap::Handle(User* user, const Params& parameters) { if (!parameters.empty()) { // Remote MAP, the target server is the 1st parameter TreeServer* s = Utils->FindServerMask(parameters[0]); if (!s) { user->WriteNumeric(ERR_NOSUCHSERVER, parameters[0], "No such server"); return CmdResult::FAILURE; } if (!s->IsRoot()) return CmdResult::SUCCESS; } // Max depth and max server name length unsigned int max_depth = 0; size_t max_len = 0; size_t max_version = 0; GetDepthAndLen(Utils->TreeRoot, 0, max_depth, max_len, max_version); size_t max; if (user->IsOper() || !Utils->FlatLinks) { // Each level of the map is indented by 2 characters, making the max possible line (max_depth * 2) + max_len max = (max_depth * 2) + max_len; } else { // This user can't see any depth max = max_len; if (!user->IsOper()) max_version = 0; } std::vector<std::string> map = GetMap(user, Utils->TreeRoot, max, max_version, 0); for (const auto& line : map) user->WriteRemoteNumeric(RPL_MAP, line); size_t totusers = ServerInstance->Users.GetUsers().size(); float avg_users = (float) totusers / Utils->serverlist.size(); user->WriteRemoteNumeric(RPL_MAPUSERS, INSP_FORMAT("{} server{} and {} user{}, average {:.2} users per server", Utils->serverlist.size(), (Utils->serverlist.size() > 1 ? "s" : ""), totusers, (totusers > 1 ? "s" : ""), avg_users)); user->WriteRemoteNumeric(RPL_ENDMAP, "End of /MAP"); return CmdResult::SUCCESS; } RouteDescriptor CommandMap::GetRouting(User* user, const Params& parameters) { if (!parameters.empty()) return ROUTE_UNICAST(parameters[0]); return ROUTE_LOCALONLY; } ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/src/modules/m_spanningtree/override_squit.cpp����������������������������������������0000664�0000000�0000000�00000003714�14771603147�0024374�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2013, 2018, 2023 Sadie Powell <sadie@witchery.services> * Copyright (C) 2013 Attila Molnar <attilamolnar@hush.com> * Copyright (C) 2012 Robby <robby@chatbelgie.be> * Copyright (C) 2009 Daniel De Graaf <danieldg@inspircd.org> * Copyright (C) 2008 Thomas Stagner <aquanight@gmail.com> * Copyright (C) 2007 Craig Edwards <brain@inspircd.org> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include "inspircd.h" #include "socket.h" #include "main.h" #include "utils.h" #include "treeserver.h" #include "treesocket.h" ModResult ModuleSpanningTree::HandleSquit(const CommandBase::Params& parameters, User* user) { TreeServer* s = Utils->FindServerMask(parameters[0]); if (s) { if (s->IsRoot()) { user->WriteNotice("*** SQUIT: Foolish mortal, you cannot make a server SQUIT itself! (" + parameters[0] + " matches local server name)"); return MOD_RES_DENY; } if (s->IsLocal()) { ServerInstance->SNO.WriteToSnoMask('l', "SQUIT: Server \002{}\002 removed from network by {}", parameters[0], user->nick); s->SQuit("Server quit by " + user->GetRealMask()); } else { user->WriteNotice("*** SQUIT may not be used to remove remote servers. Please use RSQUIT instead."); } } else { user->WriteNotice("*** SQUIT: The server \002" + parameters[0] + "\002 does not exist on the network."); } return MOD_RES_DENY; } ����������������������������������������������������inspircd-4.7.0/src/modules/m_spanningtree/override_stats.cpp����������������������������������������0000664�0000000�0000000�00000003627�14771603147�0024370�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2020, 2023 Sadie Powell <sadie@witchery.services> * Copyright (C) 2014, 2016 Attila Molnar <attilamolnar@hush.com> * Copyright (C) 2012 Robby <robby@chatbelgie.be> * Copyright (C) 2009 Daniel De Graaf <danieldg@inspircd.org> * Copyright (C) 2007 Craig Edwards <brain@inspircd.org> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include "inspircd.h" #include "main.h" #include "utils.h" #include "link.h" ModResult ModuleSpanningTree::OnStats(Stats::Context& stats) { if ((stats.GetSymbol() == 'c') || (stats.GetSymbol() == 'n')) { for (const auto& L : Utils->LinkBlocks) { std::string ipaddr = "*@"; if (L->HiddenFromStats) ipaddr.append("<hidden>"); else ipaddr.append(L->IPAddr); const std::string hook = (L->Hook.empty() ? "plaintext" : L->Hook); stats.AddRow(213, stats.GetSymbol(), ipaddr, '*', L->Name, L->Port, hook); if (stats.GetSymbol() == 'c') stats.AddRow(244, 'H', '*', '*', L->Name); } return MOD_RES_DENY; } else if (stats.GetSymbol() == 'U') { for (const auto& [_, tag] : ServerInstance->Config->ConfTags("services", ServerInstance->Config->ConfTags("uline"))) { std::string name = tag->getString("server"); if (!name.empty()) stats.AddRow(248, 'U', name); } return MOD_RES_DENY; } return MOD_RES_PASSTHRU; } ���������������������������������������������������������������������������������������������������������inspircd-4.7.0/src/modules/m_spanningtree/override_whois.cpp����������������������������������������0000664�0000000�0000000�00000003200�14771603147�0024346�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2018, 2021-2023 Sadie Powell <sadie@witchery.services> * Copyright (C) 2013, 2016 Attila Molnar <attilamolnar@hush.com> * Copyright (C) 2012 Robby <robby@chatbelgie.be> * Copyright (C) 2009 Uli Schlachter <psychon@znc.in> * Copyright (C) 2009 Daniel De Graaf <danieldg@inspircd.org> * Copyright (C) 2007 Craig Edwards <brain@inspircd.org> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include "inspircd.h" #include "modules/whois.h" #include "numerichelper.h" #include "main.h" #include "commandbuilder.h" ModResult ModuleSpanningTree::HandleRemoteWhois(const CommandBase::Params& parameters, User* user) { auto* remote = ServerInstance->Users.FindNick(parameters[1]); if (remote && !IS_LOCAL(remote)) { CmdBuilder(user, "IDLE").push(remote->uuid).Unicast(remote); return MOD_RES_DENY; } else if (!remote) { user->WriteNumeric(Numerics::NoSuchNick(parameters[0])); user->WriteNumeric(RPL_ENDOFWHOIS, parameters[0], "End of /WHOIS list."); return MOD_RES_DENY; } return MOD_RES_PASSTHRU; } ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/src/modules/m_spanningtree/ping.cpp��������������������������������������������������0000664�0000000�0000000�00000002632�14771603147�0022263�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2018-2020, 2023 Sadie Powell <sadie@witchery.services> * Copyright (C) 2013 Attila Molnar <attilamolnar@hush.com> * Copyright (C) 2012 Robby <robby@chatbelgie.be> * Copyright (C) 2009 Daniel De Graaf <danieldg@inspircd.org> * Copyright (C) 2008 Robin Burchell <robin+git@viroteck.net> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include "inspircd.h" #include "utils.h" #include "treeserver.h" #include "commands.h" CmdResult CommandPing::Handle(User* user, Params& params) { if (params[0] == ServerInstance->Config->ServerId) { // PING for us, reply with a PONG CmdBuilder reply("PONG"); reply.push(user->uuid); if (params.size() >= 2) // If there is a second parameter, append it reply.push(params[1]); reply.Unicast(user); } return CmdResult::SUCCESS; } ������������������������������������������������������������������������������������������������������inspircd-4.7.0/src/modules/m_spanningtree/pingtimer.cpp���������������������������������������������0000664�0000000�0000000�00000006110�14771603147�0023317�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2019, 2021-2022, 2025 Sadie Powell <sadie@witchery.services> * Copyright (C) 2015 Attila Molnar <attilamolnar@hush.com> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include "inspircd.h" #include "timeutils.h" #include "pingtimer.h" #include "treeserver.h" #include "commandbuilder.h" PingTimer::PingTimer(TreeServer* ts) : Timer(Utils->PingFreq, false) , server(ts) , state(PS_SENDPING) { } PingTimer::State PingTimer::TickInternal() { // Timer expired, take next action based on what happened last time if (state == PS_SENDPING) { // Last ping was answered, send next ping server->GetSocket()->WriteLine(CmdBuilder("PING").push(server->GetId())); LastPingMsec = ServerInstance->Time() * 1000 + (ServerInstance->Time_ns() / 1000000); // Warn next unless warnings are disabled. If they are, jump straight to timeout. if (Utils->PingWarnTime) return PS_WARN; else return PS_TIMEOUT; } else if (state == PS_WARN) { // No pong arrived in PingWarnTime seconds, send a warning to opers ServerInstance->SNO.WriteToSnoMask('l', "Server \002{}\002 has not responded to PING for {}, high latency.", server->GetName(), Duration::ToLongString(GetInterval())); return PS_TIMEOUT; } else // PS_TIMEOUT { // They didn't answer the last ping, if they are locally connected, get rid of them if (server->IsLocal()) { TreeSocket* sock = server->GetSocket(); sock->SendError("Ping timeout"); sock->Close(); } // If the server is non-locally connected, don't do anything until we get a PONG. // This is to avoid pinging the server and warning opers more than once. // If they do answer eventually, we will move to the PS_SENDPING state and ping them again. return PS_IDLE; } } void PingTimer::SetState(State newstate) { state = newstate; // Set when should the next Tick() happen based on the state if (state == PS_SENDPING) SetInterval(Utils->PingFreq); else if (state == PS_WARN) SetInterval(Utils->PingWarnTime); else if (state == PS_TIMEOUT) SetInterval(Utils->PingFreq - Utils->PingWarnTime); // If state == PS_IDLE, do not set the timer, see above why } bool PingTimer::Tick() { if (server->IsDead()) return false; SetState(TickInternal()); return false; } void PingTimer::OnPong() { // Calculate RTT long ts = ServerInstance->Time() * 1000 + (ServerInstance->Time_ns() / 1000000); server->rtt = ts - LastPingMsec; // Change state to send ping next, also reschedules the timer appropriately SetState(PS_SENDPING); } ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/src/modules/m_spanningtree/pingtimer.h�����������������������������������������������0000664�0000000�0000000�00000003547�14771603147�0022777�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2021 Sadie Powell <sadie@witchery.services> * Copyright (C) 2015 Attila Molnar <attilamolnar@hush.com> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #pragma once class TreeServer; /** Handles PINGing servers and killing them on timeout */ class PingTimer final : public Timer { enum State { /** Send PING next */ PS_SENDPING, /** Warn opers next */ PS_WARN, /** Kill the server next due to ping timeout */ PS_TIMEOUT, /** Do nothing */ PS_IDLE }; /** Server the timer is interacting with */ TreeServer* const server; /** What to do when the timer ticks next */ State state; /** Last ping time in milliseconds, used to calculate round trip time */ unsigned long LastPingMsec; /** Update internal state and reschedule timer according to the new state * @param newstate State to change to */ void SetState(State newstate); /** Process timer tick event * @return State to change to */ State TickInternal(); /** Called by the TimerManager when the timer expires */ bool Tick() override; public: /** Construct the timer. This doesn't schedule the timer. * @param server TreeServer to interact with */ PingTimer(TreeServer* server); /** Register a PONG from the server */ void OnPong(); }; ���������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/src/modules/m_spanningtree/pong.cpp��������������������������������������������������0000664�0000000�0000000�00000002726�14771603147�0022275�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2018, 2020, 2023 Sadie Powell <sadie@witchery.services> * Copyright (C) 2013-2015 Attila Molnar <attilamolnar@hush.com> * Copyright (C) 2012 Robby <robby@chatbelgie.be> * Copyright (C) 2009 Daniel De Graaf <danieldg@inspircd.org> * Copyright (C) 2008 Robin Burchell <robin+git@viroteck.net> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include "inspircd.h" #include "utils.h" #include "treeserver.h" #include "commands.h" CmdResult CommandPong::HandleServer(TreeServer* server, CommandBase::Params& params) { if (server->IsBursting()) { ServerInstance->SNO.WriteGlobalSno('l', "Server \002{}\002 has not finished burst, forcing end of burst (send ENDBURST!)", server->GetName()); server->FinishBurst(); } if (params[0] == ServerInstance->Config->ServerId) { // PONG for us server->OnPong(); } return CmdResult::SUCCESS; } ������������������������������������������inspircd-4.7.0/src/modules/m_spanningtree/postcommand.cpp�������������������������������������������0000664�0000000�0000000�00000010402�14771603147�0023644�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2018-2024 Sadie Powell <sadie@witchery.services> * Copyright (C) 2013-2016 Attila Molnar <attilamolnar@hush.com> * Copyright (C) 2012 Robby <robby@chatbelgie.be> * Copyright (C) 2009-2010 Daniel De Graaf <danieldg@inspircd.org> * Copyright (C) 2007 Craig Edwards <brain@inspircd.org> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include "inspircd.h" #include "main.h" #include "utils.h" #include "treeserver.h" #include "commandbuilder.h" void ModuleSpanningTree::OnPostCommand(Command* command, const CommandBase::Params& parameters, LocalUser* user, CmdResult result, bool loop) { if (result == CmdResult::SUCCESS) Utils->RouteCommand(nullptr, command, parameters, user); } void SpanningTreeUtilities::RouteCommand(TreeServer* origin, CommandBase* thiscmd, const CommandBase::Params& parameters, User* user) { RouteDescriptor routing = thiscmd->GetRouting(user, parameters); if (routing.type == RouteType::LOCAL) return; const std::string& command = thiscmd->name; const bool encap = ((routing.type == RouteType::OPTIONAL_BROADCAST) || (routing.type == RouteType::OPTIONAL_UNICAST)); CmdBuilder params(user, encap ? "ENCAP" : command.c_str()); params.push_tags(parameters.GetTags()); const TreeServer* sdest = nullptr; if (routing.type == RouteType::OPTIONAL_BROADCAST) { params.push('*'); params.push(command); } else if (routing.type == RouteType::UNICAST || routing.type == RouteType::OPTIONAL_UNICAST) { sdest = static_cast<const TreeServer*>(routing.server); if (!sdest) { // Assume the command handler already validated routing.target and have only returned success if the target is something that the // user executing the command is allowed to look up e.g. target is not an uuid if user is local. sdest = FindRouteTarget(routing.target); if (!sdest) { ServerInstance->Logs.Debug(MODNAME, "Trying to route {}{} to nonexistent server {}", (encap ? "ENCAP " : ""), command, routing.target); return; } } if (encap) { params.push(sdest->GetId()); params.push(command); } } else { Module* srcmodule = thiscmd->creator; if (!(srcmodule->properties & (VF_COMMON | VF_CORE)) && srcmodule != Creator) { ServerInstance->Logs.Normal(MODNAME, "Routed command {} from non-VF_COMMON module {}", command, srcmodule->ModuleFile); return; } } std::string output_text = CommandParser::TranslateUIDs(thiscmd->translation, parameters, true, thiscmd); params.push(output_text); if (routing.type == RouteType::MESSAGE) { char pfx = 0; std::string dest = routing.target; if (ServerInstance->Modes.FindPrefix(dest[0])) { pfx = dest[0]; dest.erase(dest.begin()); } if (ServerInstance->Channels.IsPrefix(dest[0])) { auto* c = ServerInstance->Channels.Find(dest); if (!c) return; // TODO OnBuildExemptList hook was here CUList exempts; std::string message; if (parameters.size() >= 2) message.assign(parameters[1]); SendChannelMessage(user, c, message, pfx, parameters.GetTags(), exempts, command.c_str(), origin ? origin->GetSocket() : nullptr); } else if (dest[0] == '$') { params.Forward(origin); } else { // user target? auto* d = ServerInstance->Users.Find(dest); if (!d || IS_LOCAL(d)) return; TreeServer* tsd = TreeServer::Get(d)->GetRoute(); if (tsd == origin) // huh? no routing stuff around in a circle, please. return; params.Unicast(d); } } else if (routing.type == RouteType::BROADCAST || routing.type == RouteType::OPTIONAL_BROADCAST) { params.Forward(origin); } else if (routing.type == RouteType::UNICAST || routing.type == RouteType::OPTIONAL_UNICAST) { params.Unicast(sdest->ServerUser); } } ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/src/modules/m_spanningtree/precommand.cpp��������������������������������������������0000664�0000000�0000000�00000003422�14771603147�0023451�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2018, 2022-2023 Sadie Powell <sadie@witchery.services> * Copyright (C) 2012 Robby <robby@chatbelgie.be> * Copyright (C) 2009-2010 Daniel De Graaf <danieldg@inspircd.org> * Copyright (C) 2008 Thomas Stagner <aquanight@gmail.com> * Copyright (C) 2007 Craig Edwards <brain@inspircd.org> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include "inspircd.h" #include "main.h" ModResult ModuleSpanningTree::OnPreCommand(std::string& command, CommandBase::Params& parameters, LocalUser* user, bool validated) { /* If the command doesnt appear to be valid, we dont want to mess with it. */ if (!validated) return MOD_RES_PASSTHRU; if (command == "CONNECT") { return this->HandleConnect(parameters, user); } else if (command == "SQUIT") { return HandleSquit(parameters, user); } else if (command == "LINKS") { this->HandleLinks(parameters, user); return MOD_RES_DENY; } else if (command == "WHOIS") { if (parameters.size() > 1) { // remote whois return HandleRemoteWhois(parameters, user); } } else if ((command == "VERSION") && (!parameters.empty())) { return HandleVersion(parameters, user); } return MOD_RES_PASSTHRU; } ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/src/modules/m_spanningtree/protocolinterface.cpp�������������������������������������0000664�0000000�0000000�00000010103�14771603147�0025040�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2019, 2021-2023 Sadie Powell <sadie@witchery.services> * Copyright (C) 2012-2014 Attila Molnar <attilamolnar@hush.com> * Copyright (C) 2012 Robby <robby@chatbelgie.be> * Copyright (C) 2009-2010 Daniel De Graaf <danieldg@inspircd.org> * Copyright (C) 2008 Robin Burchell <robin+git@viroteck.net> * Copyright (C) 2008 Craig Edwards <brain@inspircd.org> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include "inspircd.h" #include "utils.h" #include "treeserver.h" #include "protocolinterface.h" #include "commands.h" /* * For documentation on this class, see include/protocol.h. */ void SpanningTreeProtocolInterface::GetServerList(ServerList& sl) { for (const auto& [_, server] : Utils->serverlist) { ServerInfo ps; ps.servername = server->GetName(); TreeServer* s = server->GetParent(); ps.parentname = s ? s->GetName() : ""; ps.usercount = server->UserCount; ps.opercount = server->OperCount; ps.description = server->GetDesc(); ps.latencyms = server->rtt; sl.push_back(ps); } } bool SpanningTreeProtocolInterface::SendEncapsulatedData(const std::string& targetmask, const std::string& cmd, const CommandBase::Params& params, const User* source) { if (!source) source = ServerInstance->FakeClient; CmdBuilder encap(source, "ENCAP"); // Are there any wildcards in the target string? if (targetmask.find_first_of("*?") != std::string::npos) { // Yes, send the target string as-is; servers will decide whether or not it matches them encap.push(targetmask).push(cmd).insert(params).Broadcast(); } else { // No wildcards which means the target string has to be the name of a known server TreeServer* server = Utils->FindServer(targetmask); if (!server) return false; // Use the SID of the target in the message instead of the server name encap.push(server->GetId()).push(cmd).insert(params).Unicast(server->ServerUser); } return true; } void SpanningTreeProtocolInterface::BroadcastEncap(const std::string& cmd, const CommandBase::Params& params, const User* source, const User* omit) { if (!source) source = ServerInstance->FakeClient; // If omit is non-NULL we pass the route belonging to the user to Forward(), // otherwise we pass NULL, which is equivalent to Broadcast() TreeServer* server = (omit ? TreeServer::Get(omit)->GetRoute() : nullptr); CmdBuilder(source, "ENCAP * ").push_raw(cmd).insert(params).Forward(server); } void SpanningTreeProtocolInterface::SendMetadata(const Extensible* ext, const std::string& key, const std::string& data) { CommandMetadata::Builder(ext, key, data).Broadcast(); } void SpanningTreeProtocolInterface::SendMetadata(const std::string& key, const std::string& data) { CommandMetadata::Builder(key, data).Broadcast(); } void SpanningTreeProtocolInterface::SendSNONotice(char snomask, const std::string& text) { CmdBuilder("SNONOTICE").push(snomask).push_last(text).Broadcast(); } void SpanningTreeProtocolInterface::SendMessage(const Channel* target, char status, const std::string& text, MessageType msgtype) { const char* cmd = (msgtype == MessageType::PRIVMSG ? "PRIVMSG" : "NOTICE"); CUList exempt_list; ClientProtocol::TagMap tags; Utils->SendChannelMessage(ServerInstance->FakeClient, target, text, status, tags, exempt_list, cmd); } void SpanningTreeProtocolInterface::SendMessage(const User* target, const std::string& text, MessageType msgtype) { CmdBuilder p(msgtype == MessageType::PRIVMSG ? "PRIVMSG" : "NOTICE"); p.push(target->uuid); p.push_last(text); p.Unicast(target); } �������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/src/modules/m_spanningtree/protocolinterface.h���������������������������������������0000664�0000000�0000000�00000003400�14771603147�0024507�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2013, 2019, 2021-2023 Sadie Powell <sadie@witchery.services> * Copyright (C) 2012 Robby <robby@chatbelgie.be> * Copyright (C) 2009 Daniel De Graaf <danieldg@inspircd.org> * Copyright (C) 2008 Craig Edwards <brain@inspircd.org> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #pragma once class SpanningTreeProtocolInterface final : public ProtocolInterface { public: bool SendEncapsulatedData(const std::string& targetmask, const std::string& cmd, const CommandBase::Params& params, const User* source) override; void BroadcastEncap(const std::string& cmd, const CommandBase::Params& params, const User* source, const User* omit) override; void SendMetadata(const Extensible* ext, const std::string& key, const std::string& data) override; void SendMetadata(const std::string& key, const std::string& data) override; void SendSNONotice(char snomask, const std::string& text) override; void SendMessage(const Channel* target, char status, const std::string& text, MessageType msgtype) override; void SendMessage(const User* target, const std::string& text, MessageType msgtype) override; void GetServerList(ServerList& sl) override; }; ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/src/modules/m_spanningtree/rconnect.cpp����������������������������������������������0000664�0000000�0000000�00000005773�14771603147�0023152�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2013, 2018, 2020, 2023-2024 Sadie Powell <sadie@witchery.services> * Copyright (C) 2012-2013 Attila Molnar <attilamolnar@hush.com> * Copyright (C) 2012 Robby <robby@chatbelgie.be> * Copyright (C) 2009-2010 Daniel De Graaf <danieldg@inspircd.org> * Copyright (C) 2008 Thomas Stagner <aquanight@gmail.com> * Copyright (C) 2008 Robin Burchell <robin+git@viroteck.net> * Copyright (C) 2007-2008 Dennis Friis <peavey@inspircd.org> * Copyright (C) 2007 Craig Edwards <brain@inspircd.org> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include "inspircd.h" #include "main.h" #include "utils.h" #include "commands.h" CommandRConnect::CommandRConnect (Module* Creator) : Command(Creator, "RCONNECT", 2) { access_needed = CmdAccess::OPERATOR; syntax = { "<remote-server-mask> <target-server-mask>" }; } CmdResult CommandRConnect::Handle(User* user, const Params& parameters) { /* First see if the server which is being asked to connect to another server in fact exists */ if (!Utils->FindServerMask(parameters[0])) { user->WriteRemoteNotice("*** RCONNECT: Server \002{}\002 isn't connected to the network!", parameters[0]); return CmdResult::FAILURE; } /* Is this aimed at our server? */ if (InspIRCd::Match(ServerInstance->Config->ServerName, parameters[0])) { /* Yes, initiate the given connect */ ServerInstance->SNO.WriteToSnoMask('l', "Remote CONNECT from {} matching \002{}\002, connecting server \002{}\002", user->nick, parameters[0], parameters[1]); CommandBase::Params para; para.push_back(parameters[1]); static_cast<ModuleSpanningTree*>(creator.ptr())->HandleConnect(para, user); } else { /* It's not aimed at our server, but if the request originates from our user * acknowledge that we sent the request. * * It's possible that we're asking a server for something that makes no sense * (e.g. connect to itself or to an already connected server), but we don't check * for those conditions here, as ModuleSpanningTree::HandleConnect() (which will run * on the target) does all the checking and error reporting. */ if (IS_LOCAL(user)) { user->WriteNotice("*** RCONNECT: Sending remote connect to \002 " + parameters[0] + "\002 to connect server \002" + parameters[1] + "\002."); } } return CmdResult::SUCCESS; } RouteDescriptor CommandRConnect::GetRouting(User* user, const Params& parameters) { return ROUTE_UNICAST(parameters[0]); } �����inspircd-4.7.0/src/modules/m_spanningtree/remoteuser.cpp��������������������������������������������0000664�0000000�0000000�00000002016�14771603147�0023514�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2016 Attila Molnar <attilamolnar@hush.com> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include "inspircd.h" #include "main.h" #include "remoteuser.h" SpanningTree::RemoteUser::RemoteUser(const std::string& uid, Server* srv) : ::RemoteUser(uid, srv) { } void SpanningTree::RemoteUser::WriteRemoteNumeric(const Numeric::Numeric& numeric) { CommandNum::Builder(this, numeric).Unicast(this); } ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/src/modules/m_spanningtree/remoteuser.h����������������������������������������������0000664�0000000�0000000�00000002032�14771603147�0023157�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2019, 2021 Sadie Powell <sadie@witchery.services> * Copyright (C) 2016 Attila Molnar <attilamolnar@hush.com> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #pragma once namespace SpanningTree { class RemoteUser; } class SpanningTree::RemoteUser final : public ::RemoteUser { public: RemoteUser(const std::string& uid, Server* srv); void WriteRemoteNumeric(const Numeric::Numeric& numeric) override; }; ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/src/modules/m_spanningtree/resolvers.cpp���������������������������������������������0000664�0000000�0000000�00000011356�14771603147�0023355�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2019-2023 Sadie Powell <sadie@witchery.services> * Copyright (C) 2013, 2016 Adam <Adam@anope.org> * Copyright (C) 2012-2014, 2016 Attila Molnar <attilamolnar@hush.com> * Copyright (C) 2012 Robby <robby@chatbelgie.be> * Copyright (C) 2009 Daniel De Graaf <danieldg@inspircd.org> * Copyright (C) 2007 Robin Burchell <robin+git@viroteck.net> * Copyright (C) 2007 Dennis Friis <peavey@inspircd.org> * Copyright (C) 2007 Craig Edwards <brain@inspircd.org> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include "inspircd.h" #include "cachetimer.h" #include "resolvers.h" #include "main.h" #include "utils.h" #include "treeserver.h" #include "link.h" #include "treesocket.h" ServerNameResolver::ServerNameResolver(DNS::Manager* mgr, const std::string& hostname, const std::shared_ptr<Link>& l, DNS::QueryType qt, const std::shared_ptr<Autoconnect>& a) : DNS::Request(mgr, Utils->Creator, hostname, qt) , autoconnect(a) , link(l) { } void ServerNameResolver::OnLookupComplete(const DNS::Query* r) { const DNS::ResourceRecord* const ans_record = r->FindAnswerOfType(this->question.type); if (!ans_record) { OnError(r); return; } irc::sockets::sockaddrs sa(false); if (!sa.from_ip_port(ans_record->rdata, link->Port)) { // We had a result but it wasn't a valid IPv4/IPv6. OnError(r); return; } /* Initiate the connection, now that we have an IP to use. * Passing a hostname directly to BufferedSocket causes it to * just bail and set its FD to -1. */ TreeServer* CheckDupe = Utils->FindServer(link->Name); if (!CheckDupe) /* Check that nobody tried to connect it successfully while we were resolving */ { auto* newsocket = new TreeSocket(link, autoconnect, sa); if (!newsocket->HasFd()) { /* Something barfed, show the opers */ ServerInstance->SNO.WriteToSnoMask('l', "CONNECT: Error connecting \002{}\002: {}.", link->Name, newsocket->GetError()); ServerInstance->GlobalCulls.AddItem(newsocket); } } } void ServerNameResolver::OnError(const DNS::Query* r) { if (r->error == DNS::ERROR_UNLOADED) { // We're being unloaded, skip the snotice and ConnectServer() below to prevent autoconnect creating new sockets return; } if (question.type == DNS::QUERY_AAAA) { auto* snr = new ServerNameResolver(this->manager, question.name, link, DNS::QUERY_A, autoconnect); try { this->manager->Process(snr); return; } catch (const DNS::Exception&) { delete snr; } } ServerInstance->SNO.WriteToSnoMask('l', "CONNECT: Error connecting \002{}\002: Unable to resolve hostname - {}", link->Name, this->manager->GetErrorStr(r->error)); Utils->Creator->ConnectServer(autoconnect, false); } SecurityIPResolver::SecurityIPResolver(Module* me, DNS::Manager* mgr, const std::string& hostname, const std::shared_ptr<Link>& l, DNS::QueryType qt) : DNS::Request(mgr, me, hostname, qt) , link(l) { } bool SecurityIPResolver::CheckIPv4() { // We only check IPv4 addresses if we have checked IPv6. if (question.type != DNS::QUERY_AAAA) return false; auto* res = new SecurityIPResolver(creator, manager, question.name, link, DNS::QUERY_A); try { this->manager->Process(res); return true; } catch (const DNS::Exception&) { delete res; return false; } } void SecurityIPResolver::OnLookupComplete(const DNS::Query* r) { for (const auto& L : Utils->LinkBlocks) { if (L->IPAddr == question.name) { for (const auto& ans_record : r->answers) { if (ans_record.type != this->question.type) continue; Utils->ValidIPs.push_back(ans_record.rdata); ServerInstance->Logs.Normal(MODNAME, "Resolved '{}' as a valid IP address for link '{}'", ans_record.rdata, link->Name); } break; } } CheckIPv4(); } void SecurityIPResolver::OnError(const DNS::Query* r) { // This can be called because of us being unloaded but we don't have to do anything differently if (CheckIPv4()) return; ServerInstance->Logs.Warning(MODNAME, "Could not resolve IP associated with link '{}': {}", link->Name, this->manager->GetErrorStr(r->error)); } CacheRefreshTimer::CacheRefreshTimer() : Timer(3600, true) { } bool CacheRefreshTimer::Tick() { Utils->RefreshIPCache(); return true; } ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/src/modules/m_spanningtree/resolvers.h�����������������������������������������������0000664�0000000�0000000�00000003777�14771603147�0023032�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2013, 2019, 2021-2023 Sadie Powell <sadie@witchery.services> * Copyright (C) 2013 Adam <Adam@anope.org> * Copyright (C) 2012 Robby <robby@chatbelgie.be> * Copyright (C) 2009 Daniel De Graaf <danieldg@inspircd.org> * Copyright (C) 2007 Dennis Friis <peavey@inspircd.org> * Copyright (C) 2007 Craig Edwards <brain@inspircd.org> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #pragma once #include "inspircd.h" #include "modules/dns.h" #include "utils.h" #include "link.h" // Handles resolving whitelisted hostnames for the inbound connection whitelist. class SecurityIPResolver final : public DNS::Request { private: std::shared_ptr<Link> link; bool CheckIPv4(); public: SecurityIPResolver(Module* mod, DNS::Manager* mgr, const std::string& hostname, const std::shared_ptr<Link>& l, DNS::QueryType qt); void OnLookupComplete(const DNS::Query* r) override; void OnError(const DNS::Query* q) override; }; // Handles resolving server hostnames when making an outbound connection. class ServerNameResolver final : public DNS::Request { private: std::shared_ptr<Autoconnect> autoconnect; std::shared_ptr<Link> link; public: ServerNameResolver(DNS::Manager* mgr, const std::string& hostname, const std::shared_ptr<Link>& l, DNS::QueryType qt, const std::shared_ptr<Autoconnect>& a); void OnLookupComplete(const DNS::Query* r) override; void OnError(const DNS::Query* q) override; }; �inspircd-4.7.0/src/modules/m_spanningtree/rsquit.cpp������������������������������������������������0000664�0000000�0000000�00000004674�14771603147�0022665�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2018, 2020, 2023-2024 Sadie Powell <sadie@witchery.services> * Copyright (C) 2013 Attila Molnar <attilamolnar@hush.com> * Copyright (C) 2012 Robby <robby@chatbelgie.be> * Copyright (C) 2009-2010 Daniel De Graaf <danieldg@inspircd.org> * Copyright (C) 2008 Thomas Stagner <aquanight@gmail.com> * Copyright (C) 2008 Robin Burchell <robin+git@viroteck.net> * Copyright (C) 2007 Dennis Friis <peavey@inspircd.org> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include "inspircd.h" #include "main.h" #include "utils.h" #include "treeserver.h" #include "commands.h" CommandRSQuit::CommandRSQuit(Module* Creator) : Command(Creator, "RSQUIT", 1) { access_needed = CmdAccess::OPERATOR; syntax = { "<target-server-mask> [:<reason>]" }; } CmdResult CommandRSQuit::Handle(User* user, const Params& parameters) { TreeServer* server_target; // Server to squit server_target = Utils->FindServerMask(parameters[0]); if (!server_target) { user->WriteRemoteNotice("*** RSQUIT: Server \002{}\002 isn't connected to the network!", parameters[0]); return CmdResult::FAILURE; } if (server_target->IsRoot()) { user->WriteRemoteNotice("*** RSQUIT: Foolish mortal, you cannot make a server SQUIT itself! ({} matches local server name)", parameters[0]); return CmdResult::FAILURE; } if (server_target->IsLocal()) { // We have been asked to remove server_target. const char* reason = parameters.size() == 2 ? parameters[1].c_str() : "No reason"; ServerInstance->SNO.WriteToSnoMask('l', "RSQUIT: Server \002{}\002 removed from network by {} ({})", parameters[0], user->nick, reason); server_target->SQuit("Server quit by " + user->GetRealMask() + " (" + reason + ")"); } return CmdResult::SUCCESS; } RouteDescriptor CommandRSQuit::GetRouting(User* user, const Params& parameters) { return ROUTE_UNICAST(parameters[0]); } ��������������������������������������������������������������������inspircd-4.7.0/src/modules/m_spanningtree/save.cpp��������������������������������������������������0000664�0000000�0000000�00000002552�14771603147�0022265�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2018, 2020-2023 Sadie Powell <sadie@witchery.services> * Copyright (C) 2013-2015 Attila Molnar <attilamolnar@hush.com> * Copyright (C) 2012 Robby <robby@chatbelgie.be> * Copyright (C) 2009 Daniel De Graaf <danieldg@inspircd.org> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include "inspircd.h" #include "utils.h" #include "treesocket.h" #include "commands.h" /** * SAVE command - force nick change to UID on timestamp match */ CmdResult CommandSave::Handle(User* user, Params& params) { auto* u = ServerInstance->Users.FindUUID(params[0]); if (!u) return CmdResult::FAILURE; time_t ts = ServerCommand::ExtractTS(params[1]); if (u->nickchanged == ts) u->ChangeNick(u->uuid, SavedTimestamp); return CmdResult::SUCCESS; } ������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/src/modules/m_spanningtree/server.cpp������������������������������������������������0000664�0000000�0000000�00000021541�14771603147�0022634�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2017-2020, 2022-2025 Sadie Powell <sadie@witchery.services> * Copyright (C) 2013-2016 Attila Molnar <attilamolnar@hush.com> * Copyright (C) 2012, 2019 Robby <robby@chatbelgie.be> * Copyright (C) 2009-2010 Daniel De Graaf <danieldg@inspircd.org> * Copyright (C) 2009 Uli Schlachter <psychon@znc.in> * Copyright (C) 2008-2010 Craig Edwards <brain@inspircd.org> * Copyright (C) 2008 Robin Burchell <robin+git@viroteck.net> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include <filesystem> #include "inspircd.h" #include "modules/ssl.h" #include "main.h" #include "utils.h" #include "link.h" #include "treeserver.h" #include "treesocket.h" #include "commands.h" namespace { bool RunningInContainer() { std::error_code ec; if (std::filesystem::is_regular_file("/.dockerenv", ec)) { // We are running inside of Docker so all IP addresses are // non-local and as far as I can see there isn't a way to // reliably detect the Docker network. return true; } return false; } } /* * Some server somewhere in the network introducing another server. * -- w */ CmdResult CommandServer::HandleServer(TreeServer* ParentOfThis, Params& params) { const std::string& servername = params[0]; const std::string& sid = params[1]; const std::string& description = params.back(); TreeSocket* socket = ParentOfThis->GetSocket(); if (!InspIRCd::IsSID(sid)) { socket->SendError("Invalid format server ID: "+sid+"!"); return CmdResult::FAILURE; } TreeServer* CheckDupe = Utils->FindServer(servername); if (CheckDupe) { socket->SendError("Server "+servername+" already exists!"); ServerInstance->SNO.WriteToSnoMask('L', "Server \002"+CheckDupe->GetName()+"\002 being introduced from \002" + ParentOfThis->GetName() + "\002 denied, already exists. Closing link with " + ParentOfThis->GetName()); return CmdResult::FAILURE; } CheckDupe = Utils->FindServer(sid); if (CheckDupe) { socket->SendError("Server ID "+sid+" already exists! You may want to specify the server ID for the server manually with <server:id> so they do not conflict."); ServerInstance->SNO.WriteToSnoMask('L', "Server \002"+servername+"\002 being introduced from \002" + ParentOfThis->GetName() + "\002 denied, server ID already exists on the network. Closing link with " + ParentOfThis->GetName()); return CmdResult::FAILURE; } TreeServer* route = ParentOfThis->GetRoute(); std::shared_ptr<Link> lnk = Utils->FindLink(route->GetName()); auto* Node = new TreeServer(servername, description, sid, ParentOfThis, ParentOfThis->GetSocket(), lnk ? lnk->Hidden : false); HandleExtra(Node, params); ServerInstance->SNO.WriteToSnoMask('L', "Server \002"+ParentOfThis->GetName()+"\002 introduced server \002"+servername+"\002 ("+description+")"); return CmdResult::SUCCESS; } void CommandServer::HandleExtra(TreeServer* newserver, Params& params) { for (CommandBase::Params::const_iterator i = params.begin() + 2; i != params.end() - 1; ++i) { const std::string& prop = *i; std::string::size_type p = prop.find('='); std::string key = prop; std::string val; if (p != std::string::npos) { key.erase(p); val.assign(prop, p+1, std::string::npos); } if (irc::equals(key, "burst")) newserver->BeginBurst(ConvToNum<uint64_t>(val)); else if (irc::equals(key, "hidden")) newserver->Hidden = !!ConvToNum<uint8_t>(val); } } std::shared_ptr<Link> TreeSocket::AuthRemote(const CommandBase::Params& params) { size_t offset = proto_version == PROTO_INSPIRCD_3; if (params.size() < 4+offset) { SendError("Protocol error - Not enough parameters for SERVER command"); return nullptr; } const std::string& sname = params[0]; const std::string& password = params[1]; const std::string& sid = params[2+offset]; const std::string& description = params.back(); this->SendCapabilities(2); if (!InspIRCd::IsSID(sid)) { this->SendError("Invalid format server ID: "+sid+"!"); return nullptr; } for (const auto& x : Utils->LinkBlocks) { if (!InspIRCd::Match(sname, x->Name)) continue; if (!ComparePass(*x, password)) { ServerInstance->SNO.WriteToSnoMask('l', "Invalid password on link: {}", x->Name); continue; } if (!CheckDuplicate(sname, sid)) return nullptr; const SSLIOHook* const ssliohook = SSLIOHook::IsSSL(this); if (ssliohook) { std::string ciphersuite; ssliohook->GetCiphersuite(ciphersuite); ServerInstance->SNO.WriteToSnoMask('l', "Negotiated ciphersuite {} on link {}", ciphersuite, x->Name); } else if (!capab->remotesa.is_local() && !RunningInContainer()) { this->SendError("Non-local server connections MUST be linked with SSL!"); return nullptr; } ServerInstance->SNO.WriteToSnoMask('l', "Verified server connection " + linkID + " ("+description+")"); return x; } this->SendError("Mismatched server name or password (check the other server's snomask output for details - e.g. user mode +s +Ll)"); ServerInstance->SNO.WriteToSnoMask('l', "Server connection from \002"+sname+"\002 denied, invalid link credentials"); return nullptr; } /* * This is used after the other side of a connection has accepted our credentials. * They are then introducing themselves to us, BEFORE either of us burst. -- w */ bool TreeSocket::Outbound_Reply_Server(CommandBase::Params& params) { const std::shared_ptr<Link> x = AuthRemote(params); if (x) { /* * They're in WAIT_AUTH_2 (having accepted our credentials). * Set our state to CONNECTED (since everything's peachy so far) and send our * netburst to them, which will trigger their CONNECTED state, and BURST in reply. * * While we're at it, create a treeserver object so we know about them. * -- w */ FinishAuth(params[0], params[proto_version == PROTO_INSPIRCD_3 ? 3 : 2], params.back(), x->Hidden); return true; } return false; } bool TreeSocket::CheckDuplicate(const std::string& sname, const std::string& sid) { // Check if the server name is not in use by a server that's already fully connected TreeServer* CheckDupe = Utils->FindServer(sname); if (CheckDupe) { std::string pname = CheckDupe->GetParent() ? CheckDupe->GetParent()->GetName() : "<ourself>"; SendError("Server "+sname+" already exists on server "+pname+"!"); ServerInstance->SNO.WriteToSnoMask('l', "Server connection from \002"+sname+"\002 denied, already exists on server "+pname); return false; } // Check if the id is not in use by a server that's already fully connected ServerInstance->Logs.Debug(MODNAME, "Looking for dupe SID {}", sid); CheckDupe = Utils->FindServerID(sid); if (CheckDupe) { this->SendError("Server ID "+CheckDupe->GetId()+" already exists on server "+CheckDupe->GetName()+"! You may want to specify the server ID for the server manually with <server:id> so they do not conflict."); ServerInstance->SNO.WriteToSnoMask('l', "Server connection from \002"+sname+"\002 denied, server ID '"+CheckDupe->GetId()+ "' already exists on server "+CheckDupe->GetName()); return false; } return true; } /* * Someone else is attempting to connect to us if this is called. Validate their credentials etc. * -- w */ bool TreeSocket::Inbound_Server(CommandBase::Params& params) { const std::shared_ptr<Link> x = AuthRemote(params); if (x) { // Save these for later, so when they accept our credentials (indicated by BURST) we remember them this->capab->hidden = x->Hidden; this->capab->sid = params[proto_version == PROTO_INSPIRCD_3 ? 3 : 2]; this->capab->description = params.back(); this->capab->name = params[0]; // Send our details: Our server name and description and hopcount of 0, // along with the sendpass from this block. this->WriteLine(INSP_FORMAT("SERVER {} {} {}{} :{}", ServerInstance->Config->ServerName, TreeSocket::MakePass(x->SendPass, this->GetTheirChallenge()), proto_version == PROTO_INSPIRCD_3 ? "0 " : "", ServerInstance->Config->ServerId, ServerInstance->Config->ServerDesc )); // move to the next state, we are now waiting for THEM. this->LinkState = WAIT_AUTH_2; return true; } return false; } CommandServer::Builder::Builder(TreeServer* server) : CmdBuilder(server->GetParent(), "SERVER") { push(server->GetName()); push(server->GetId()); if (server->IsBursting()) push_property("burst", ConvToStr(server->StartBurst)); push_property("hidden", ConvToStr(server->Hidden)); push_last(server->GetDesc()); } ���������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/src/modules/m_spanningtree/servercommand.cpp�����������������������������������������0000664�0000000�0000000�00000003515�14771603147�0024174�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2018, 2021-2022, 2024 Sadie Powell <sadie@witchery.services> * Copyright (C) 2013-2015 Attila Molnar <attilamolnar@hush.com> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include "inspircd.h" #include "main.h" #include "servercommand.h" ServerCommand::ServerCommand(Module* Creator, const std::string& Name, unsigned int MinParams, unsigned int MaxParams) : CommandBase(Creator, Name, MinParams, MaxParams) { } void ServerCommand::RegisterService() { auto* st = static_cast<ModuleSpanningTree*>(creator.ptr()); st->CmdManager.AddCommand(this); } RouteDescriptor ServerCommand::GetRouting(User* user, const Params& parameters) { // Broadcast server-to-server commands unless overridden return ROUTE_BROADCAST; } time_t ServerCommand::ExtractTS(const std::string& tsstr) { time_t ts = ConvToNum<time_t>(tsstr); if (ts <= 0) throw ProtocolException("Invalid TS: " + tsstr); return ts; } ServerCommand* ServerCommandManager::GetHandler(const std::string& command) const { ServerCommandMap::const_iterator it = commands.find(command); if (it != commands.end()) return it->second; return nullptr; } bool ServerCommandManager::AddCommand(ServerCommand* cmd) { return commands.emplace(cmd->name, cmd).second; } �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/src/modules/m_spanningtree/servercommand.h�������������������������������������������0000664�0000000�0000000�00000007102�14771603147�0023635�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2018-2019, 2021-2022 Sadie Powell <sadie@witchery.services> * Copyright (C) 2013-2015 Attila Molnar <attilamolnar@hush.com> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #pragma once #include "utils.h" #include "treeserver.h" class ProtocolException final : public ModuleException { public: ProtocolException(const std::string& msg) : ModuleException((Module*)Utils->Creator, "Protocol violation: " + msg) { } }; /** Base class for server-to-server commands that may have a (remote) user source or server source. */ class ServerCommand : public CommandBase { public: ServerCommand(Module* Creator, const std::string& Name, unsigned int MinPara = 0, unsigned int MaxPara = 0); /** Register this object in the ServerCommandManager */ void RegisterService() override; virtual CmdResult Handle(User* user, Params& parameters) = 0; RouteDescriptor GetRouting(User* user, const Params& parameters) override; /** * Extract the TS from a string. * @param tsstr The string containing the TS. * @return The raw timestamp value. * This function throws a ProtocolException if it considers the TS invalid. Note that the detection of * invalid timestamps is not designed to be bulletproof, only some cases - like "0" - trigger an exception. */ static time_t ExtractTS(const std::string& tsstr); }; /** Base class for server-to-server command handlers which are only valid if their source is a user. * When a server sends a command of this type and the source is a server (sid), the link is aborted. */ template <class T> class UserOnlyServerCommand : public ServerCommand { public: UserOnlyServerCommand(Module* Creator, const std::string& Name, unsigned int MinPara = 0, unsigned int MaxPara = 0) : ServerCommand(Creator, Name, MinPara, MaxPara) { } CmdResult Handle(User* user, Params& parameters) override { RemoteUser* remoteuser = IS_REMOTE(user); if (!remoteuser) throw ProtocolException("Invalid source"); return static_cast<T*>(this)->HandleRemote(remoteuser, parameters); } }; /** Base class for server-to-server command handlers which are only valid if their source is a server. * When a server sends a command of this type and the source is a user (uuid), the link is aborted. */ template <class T> class ServerOnlyServerCommand : public ServerCommand { public: ServerOnlyServerCommand(Module* Creator, const std::string& Name, unsigned int MinPara = 0, unsigned int MaxPara = 0) : ServerCommand(Creator, Name, MinPara, MaxPara) { } CmdResult Handle(User* user, CommandBase::Params& parameters) override { if (!IS_SERVER(user)) throw ProtocolException("Invalid source"); TreeServer* server = TreeServer::Get(user); return static_cast<T*>(this)->HandleServer(server, parameters); } }; class ServerCommandManager final { typedef std::unordered_map<std::string, ServerCommand*> ServerCommandMap; ServerCommandMap commands; public: ServerCommand* GetHandler(const std::string& command) const; bool AddCommand(ServerCommand* cmd); }; ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/src/modules/m_spanningtree/sinfo.cpp�������������������������������������������������0000664�0000000�0000000�00000006125�14771603147�0022445�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2018-2020, 2022-2023, 2025 Sadie Powell <sadie@witchery.services> * Copyright (C) 2017 B00mX0r <b00mx0r@aureus.pw> * Copyright (C) 2014 Attila Molnar <attilamolnar@hush.com> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include "inspircd.h" #include "treeserver.h" #include "commands.h" CmdResult CommandSInfo::HandleServer(TreeServer* server, CommandBase::Params& params) { const std::string& key = params.front(); const std::string& value = params.back(); if (irc::equals(key, "customversion")) { server->customversion = value; } else if (irc::equals(key, "desc")) { // Only sent when the description of a server changes because of a rehash; not sent on burst ServerInstance->Logs.Debug(MODNAME, "Server description of {} changed: {}", server->GetName(), value); server->SetDesc(value); } else if (irc::equals(key, "rawbranch")) { server->rawbranch = value; } else if (irc::equals(key, "rawversion")) { server->rawversion = value; } // BEGIN DEPRECATED KEYS else if (irc::equals(key, "fullversion")) { // InspIRCd-4.0.0-a10. sadie.testnet.inspircd.org :[597] Test // version server uid custom-version irc::tokenstream versionstream(value); versionstream.GetMiddle(server->rawversion); if (server->rawversion.back() == '.') server->rawversion.pop_back(); for (std::string token; versionstream.GetTrailing(token); ) server->customversion = token; const std::string sidprefix = INSP_FORMAT("[{}] ", server->GetId()); if (!server->customversion.compare(0, sidprefix.size(), sidprefix)) server->customversion.erase(0, sidprefix.size()); ServerInstance->Logs.Debug(MODNAME, "Extracted entries from fullversion key: rawversion={} customversion={}", server->rawversion, server->customversion); } else if (irc::equals(key, "version")) { // InspIRCd-4. testnet.inspircd.org :Test irc::tokenstream versionstream(value); versionstream.GetMiddle(server->rawbranch); if (server->rawbranch.back() == '.') server->rawbranch.pop_back(); for (std::string token; versionstream.GetTrailing(token); ) server->customversion = token; ServerInstance->Logs.Debug(MODNAME, "Extracted entries from version key: rawbranch={} customversion={}", server->rawbranch, server->customversion); } // END DEPRECATED KEYS return CmdResult::SUCCESS; } CommandSInfo::Builder::Builder(TreeServer* server, const char* key, const std::string& val) : CmdBuilder(server, "SINFO") { push(key).push_last(val); } �������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/src/modules/m_spanningtree/tags.cpp��������������������������������������������������0000664�0000000�0000000�00000002401�14771603147�0022256�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2019, 2021 Sadie Powell <sadie@witchery.services> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include "main.h" ServerTags::ServerTags(Module* Creator) : ClientProtocol::MessageTagProvider(Creator) { } ModResult ServerTags::OnProcessTag(User* user, const std::string& tagname, std::string& tagvalue) { if (tagname[0] != '~' || tagname.length() < 2) return MOD_RES_PASSTHRU; // Only allow tags from remote users. return IS_LOCAL(user) ? MOD_RES_DENY : MOD_RES_ALLOW; } bool ServerTags::ShouldSendTag(LocalUser* user, const ClientProtocol::MessageTagData& tagdata) { // Server tags should never be sent to users. return false; } ���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/src/modules/m_spanningtree/tags.h����������������������������������������������������0000664�0000000�0000000�00000002071�14771603147�0021726�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2019-2021 Sadie Powell <sadie@witchery.services> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #pragma once #include "modules/ctctags.h" class ServerTags final : public ClientProtocol::MessageTagProvider { public: ServerTags(Module* Creator); ModResult OnProcessTag(User* user, const std::string& tagname, std::string& tagvalue) override; bool ShouldSendTag(LocalUser* user, const ClientProtocol::MessageTagData& tagdata) override; }; �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/src/modules/m_spanningtree/translate.cpp���������������������������������������������0000664�0000000�0000000�00000002421�14771603147�0023317�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2021, 2023 Sadie Powell <sadie@witchery.services> * Copyright (C) 2014, 2016 Attila Molnar <attilamolnar@hush.com> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include "inspircd.h" #include "translate.h" std::string Translate::ModeChangeListToParams(const Modes::ChangeList::List& modes) { std::string ret; for (const auto& item : modes) { ModeHandler* mh = item.mh; if (!mh->NeedsParam(item.adding)) continue; ret.push_back(' '); if (mh->IsPrefixMode()) { auto* target = ServerInstance->Users.Find(item.param); if (target) { ret.append(target->uuid); continue; } } ret.append(item.param); } return ret; } �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/src/modules/m_spanningtree/translate.h�����������������������������������������������0000664�0000000�0000000�00000002116�14771603147�0022765�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2014 Attila Molnar <attilamolnar@hush.com> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #pragma once namespace Translate { /** Generate a list of mode parameters suitable for FMODE/MODE from a Modes::ChangeList::List * @param modes List of mode changes * @return List of mode parameters built from the input. Does not include the modes themselves, * only the parameters. */ std::string ModeChangeListToParams(const Modes::ChangeList::List& modes); } ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/src/modules/m_spanningtree/treeserver.cpp��������������������������������������������0000664�0000000�0000000�00000024115�14771603147�0023514�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2021 Dominic Hamon * Copyright (C) 2018-2024 Sadie Powell <sadie@witchery.services> * Copyright (C) 2017 B00mX0r <b00mx0r@aureus.pw> * Copyright (C) 2013-2016 Attila Molnar <attilamolnar@hush.com> * Copyright (C) 2012 Robby <robby@chatbelgie.be> * Copyright (C) 2009 Daniel De Graaf <danieldg@inspircd.org> * Copyright (C) 2008 Robin Burchell <robin+git@viroteck.net> * Copyright (C) 2007 Dennis Friis <peavey@inspircd.org> * Copyright (C) 2007 Craig Edwards <brain@inspircd.org> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include "inspircd.h" #include "xline.h" #include "main.h" #include "utils.h" #include "treeserver.h" /** We use this constructor only to create the 'root' item, Utils->TreeRoot, which * represents our own server. Therefore, it has no route, no parent, and * no socket associated with it. Its version string is our own local version. */ TreeServer::TreeServer() : Server(ServerInstance->Config->ServerId, ServerInstance->Config->ServerName, ServerInstance->Config->ServerDesc) , pingtimer(this) , ServerUser(ServerInstance->FakeClient) , age(ServerInstance->Time()) , UserCount(ServerInstance->Users.LocalUserCount()) , customversion(ServerInstance->Config->CustomVersion) , rawbranch(INSPIRCD_BRANCH) , rawversion(INSPIRCD_VERSION) { AddHashEntry(); } /** When we create a new server, we call this constructor to initialize it. * This constructor initializes the server's Route and Parent, and sets up * the ping timer for the server. */ TreeServer::TreeServer(const std::string& Name, const std::string& Desc, const std::string& Sid, TreeServer* Above, TreeSocket* Sock, bool Hide) : Server(Sid, Name, Desc) , Parent(Above) , Socket(Sock) , behind_bursting(Parent->behind_bursting) , pingtimer(this) , ServerUser(new FakeUser(id, this)) , age(ServerInstance->Time()) , rawbranch("unknown") , rawversion("unknown") , Hidden(Hide) { ServerInstance->Logs.Debug(MODNAME, "New server {} behind_bursting {}", GetName(), behind_bursting); CheckService(); ServerInstance->Timers.AddTimer(&pingtimer); /* find the 'route' for this server (e.g. the one directly connected * to the local server, which we can use to reach it) * * In the following example, consider we have just added a TreeServer * class for server G on our network, of which we are server A. * To route traffic to G (marked with a *) we must send the data to * B (marked with a +) so this algorithm initializes the 'Route' * value to point at whichever server traffic must be routed through * to get here. If we were to try this algorithm with server B, * the Route pointer would point at its own object ('this'). * * A * / \ * + B C * / \ \ * D E F * / \ * * G H * * We only run this algorithm when a server is created, as * the routes remain constant while ever the server exists, and * do not need to be re-calculated. */ Route = Above; if (Route == Utils->TreeRoot) { Route = this; } else { while (this->Route->GetParent() != Utils->TreeRoot) { this->Route = Route->GetParent(); } } /* Because recursive code is slow and takes a lot of resources, * we store two representations of the server tree. The first * is a recursive structure where each server references its * children and its parent, which is used for netbursts and * netsplits to dump the whole dataset to the other server, * and the second is used for very fast lookups when routing * messages and is instead a hash_map, where each item can * be referenced by its server name. The AddHashEntry() * call below automatically inserts each TreeServer class * into the hash_map as it is created. There is a similar * maintenance call in the destructor to tidy up deleted * servers. */ this->AddHashEntry(); Parent->Children.push_back(this); Utils->Creator->linkeventprov.Call(&ServerProtocol::LinkEventListener::OnServerLink, this); } void TreeServer::BeginBurst(uint64_t startms) { behind_bursting++; uint64_t now = ServerInstance->Time() * 1000 + (ServerInstance->Time_ns() / 1000000); // If the start time is in the future (clocks are not synced) then use current time if ((!startms) || (startms > now)) startms = now; this->StartBurst = startms; ServerInstance->Logs.Debug(MODNAME, "Server {} started bursting at time {} behind_bursting {}", GetId(), startms, behind_bursting); } void TreeServer::FinishBurstInternal() { // Check is needed because some older servers don't send the bursting state of a server, so servers // introduced during a netburst may later send ENDBURST which would normally decrease this counter if (behind_bursting > 0) behind_bursting--; ServerInstance->Logs.Debug(MODNAME, "FinishBurstInternal() {} behind_bursting {}", GetName(), behind_bursting); for (auto* child : Children) child->FinishBurstInternal(); } void TreeServer::FinishBurst() { ServerInstance->XLines->ApplyLines(); uint64_t ts = ServerInstance->Time() * 1000 + (ServerInstance->Time_ns() / 1000000); unsigned long bursttime = ts - this->StartBurst; ServerInstance->SNO.WriteToSnoMask(Parent == Utils->TreeRoot ? 'l' : 'L', "Received end of netburst from \002{}\002 (burst time: {} {})", GetName(), (bursttime > 10000 ? bursttime / 1000 : bursttime), (bursttime > 10000 ? "secs" : "msecs")); Utils->Creator->linkeventprov.Call(&ServerProtocol::LinkEventListener::OnServerBurst, this); StartBurst = 0; FinishBurstInternal(); } void TreeServer::SQuitChild(TreeServer* server, const std::string& reason, bool error) { stdalgo::erase(Children, server); if (IsRoot()) { // Server split from us, generate a SQUIT message and broadcast it ServerInstance->SNO.WriteGlobalSno('l', "Server \002" + server->GetName() + "\002 split: " + reason); CmdBuilder("SQUIT").push(server->GetId()).push_last(reason).Broadcast(); } else { ServerInstance->SNO.WriteToSnoMask('L', "Server \002" + server->GetName() + "\002 split from server \002" + GetName() + "\002 with reason: " + reason); } unsigned int num_lost_servers = 0; server->SQuitInternal(num_lost_servers, error); const std::string quitreason = GetName() + " " + server->GetName(); size_t num_lost_users = QuitUsers(quitreason); ServerInstance->SNO.WriteToSnoMask(IsRoot() ? 'l' : 'L', "Netsplit complete, lost \002{}\002 user{} on \002{}\002 server{}.", num_lost_users, num_lost_users != 1 ? "s" : "", num_lost_servers, num_lost_servers != 1 ? "s" : ""); // No-op if the socket is already closed (i.e. it called us) if (server->IsLocal()) server->GetSocket()->Close(); // Add the server to the cull list, the servers behind it are handled by Cull() and the destructor ServerInstance->GlobalCulls.AddItem(server); } void TreeServer::SQuitInternal(unsigned int& num_lost_servers, bool error) { // Don't squit a server which is already dead. if (isdead) return; ServerInstance->Logs.Debug(MODNAME, "Server {} lost in split", GetName()); for (auto* server : Children) server->SQuitInternal(num_lost_servers, error); // Mark server as dead isdead = true; num_lost_servers++; RemoveHash(); if (!Utils->Creator->dying) Utils->Creator->linkeventprov.Call(&ServerProtocol::LinkEventListener::OnServerSplit, this, error); } size_t TreeServer::QuitUsers(const std::string& reason) { std::string publicreason = Utils->HideSplits ? "*.net *.split" : reason; const UserMap& users = ServerInstance->Users.GetUsers(); size_t original_size = users.size(); for (UserMap::const_iterator i = users.begin(); i != users.end(); ) { User* user = i->second; // Increment the iterator now because QuitUser() removes the user from the container ++i; TreeServer* server = TreeServer::Get(user); if (server->IsDead()) ServerInstance->Users.QuitUser(user, publicreason, &reason); } return original_size - users.size(); } void TreeServer::CheckService() { service = silentservice = false; for (const auto& [_, tag] : ServerInstance->Config->ConfTags("services", ServerInstance->Config->ConfTags("uline"))) { std::string server = tag->getString("server"); if (irc::equals(server, GetName())) { if (this->IsRoot()) { ServerInstance->Logs.Warning(MODNAME, "Servers should not mark themselves as a service (at " + tag->source.str() + ")"); return; } service = true; silentservice = tag->getBool("silent"); break; } } } /** This method is used to add the server to the * maps for linear searches. It is only called * by the constructors. */ void TreeServer::AddHashEntry() { Utils->serverlist[GetName()] = this; Utils->sidlist[GetId()] = this; } Cullable::Result TreeServer::Cull() { // Recursively cull all servers that are under us in the tree for (auto* server : Children) server->Cull(); if (!IsRoot()) ServerUser->Cull(); return Cullable::Cull(); } TreeServer::~TreeServer() { // Recursively delete all servers that are under us in the tree first for (const auto* child : Children) delete child; // Delete server user unless it's us if (!IsRoot()) delete ServerUser; } void TreeServer::RemoveHash() { Utils->sidlist.erase(GetId()); Utils->serverlist.erase(GetName()); } void TreeServer::SendMetadata(const std::string& key, const std::string& data) const { if (GetRoute() && GetRoute()->GetSocket()) GetRoute()->GetSocket()->WriteLine(CommandMetadata::Builder(key, data)); } void TreeServer::SendMetadata(const Extensible* ext, const std::string& key, const std::string& data) const { if (GetRoute() && GetRoute()->GetSocket()) GetRoute()->GetSocket()->WriteLine(CommandMetadata::Builder(ext, key, data)); } ���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/src/modules/m_spanningtree/treeserver.h����������������������������������������������0000664�0000000�0000000�00000017433�14771603147�0023166�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2021 Dominic Hamon * Copyright (C) 2013, 2019-2022, 2024 Sadie Powell <sadie@witchery.services> * Copyright (C) 2012-2015 Attila Molnar <attilamolnar@hush.com> * Copyright (C) 2012, 2019 Robby <robby@chatbelgie.be> * Copyright (C) 2009-2010 Daniel De Graaf <danieldg@inspircd.org> * Copyright (C) 2008 Robin Burchell <robin+git@viroteck.net> * Copyright (C) 2007 Dennis Friis <peavey@inspircd.org> * Copyright (C) 2007 Craig Edwards <brain@inspircd.org> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #pragma once #include "treesocket.h" #include "pingtimer.h" /** Each server in the tree is represented by one class of * type TreeServer. A locally connected TreeServer can * have a class of type TreeSocket associated with it, for * remote servers, the TreeSocket entry will be NULL. * Each server also maintains a pointer to its parent * (NULL if this server is ours, at the top of the tree) * and a pointer to its "Route" (see the comments in the * constructors below), and also a dynamic list of pointers * to its children which can be iterated recursively * if required. Creating or deleting objects of type i* TreeServer automatically maintains the hash_map of * TreeServer items, deleting and inserting them as they * are created and destroyed. */ class TreeServer final : public Server { TreeServer* Parent = nullptr; /* Parent entry */ TreeServer* Route = nullptr; /* Route entry */ std::vector<TreeServer*> Children; /* List of child objects */ TreeSocket* Socket = nullptr; /* Socket used to communicate with this server */ /** Counter counting how many servers are bursting in front of this server, including * this server. Set to parents' value on construction then it is increased if the * server itself starts bursting. Decreased when a server on the path to this server * finishes burst. */ unsigned int behind_bursting = 0; /** True if this server has been lost in a split and is awaiting destruction */ bool isdead = false; /** Timer handling PINGing the server and killing it on timeout */ PingTimer pingtimer; /** This method is used to add this TreeServer to the * hash maps. It is only called by the constructors. */ void AddHashEntry(); /** Used by SQuit logic to recursively remove servers */ void SQuitInternal(unsigned int& num_lost_servers, bool error); /** Remove the reference to this server from the hash maps */ void RemoveHash(); public: typedef std::vector<TreeServer*> ChildServers; FakeUser* const ServerUser; /* User representing this server */ const time_t age; size_t UserCount = 0; /* How many users are on this server? [note: doesn't care about +i] */ size_t OperCount = 0; /* How many opers are on this server? */ std::string customversion; std::string rawbranch; std::string rawversion; /** We use this constructor only to create the 'root' item, Utils->TreeRoot, which * represents our own server. Therefore, it has no route, no parent, and * no socket associated with it. Its version string is our own local version. */ TreeServer(); void SendMetadata(const std::string& key, const std::string& data) const override; void SendMetadata(const Extensible* ext, const std::string& key, const std::string& data) const override; /** When we create a new server, we call this constructor to initialize it. * This constructor initializes the server's Route and Parent, and sets up * its ping counters so that it will be pinged one minute from now. */ TreeServer(const std::string& Name, const std::string& Desc, const std::string& id, TreeServer* Above, TreeSocket* Sock, bool Hide); /** SQuit a server connected to this server, removing the given server and all servers behind it * @param server Server to squit, must be directly below this server * @param reason Reason for quitting the server, sent to opers and other servers * @param error Whether the server is being squit because of an error. */ void SQuitChild(TreeServer* server, const std::string& reason, bool error = false); /** SQuit this server, removing this server and all servers behind it * @param reason Reason for quitting the server, sent to opers and other servers * @param error Whether the server is being squit because of an error. */ void SQuit(const std::string& reason, bool error = false) { GetParent()->SQuitChild(this, reason, error); } static size_t QuitUsers(const std::string& reason); /** Get route. * The 'route' is defined as the locally- * connected server which can be used to reach this server. */ TreeServer* GetRoute() const { return Route; } /** Returns true if this server is the tree root (i.e.: us) */ bool IsRoot() const { return (!this->Parent); } /** Returns true if this server is locally connected */ bool IsLocal() const { return (this->Route == this); } /** Returns true if the server is awaiting destruction * @return True if the server is waiting to be culled and deleted, false otherwise */ bool IsDead() const { return isdead; } /** Round trip time of last ping */ unsigned long rtt = 0; /** When we received BURST from this server, used to calculate total burst time at ENDBURST. */ uint64_t StartBurst = 0; /** True if this server is hidden */ bool Hidden = false; /** Get the TreeSocket pointer for local servers. * For remote servers, this returns NULL. */ TreeSocket* GetSocket() const { return Socket; } /** Get the parent server. * For the root node, this returns NULL. */ TreeServer* GetParent() const { return Parent; } /** Sets the description of this server. Called when the description of a remote server changes * and we are notified about it. * @param descstr The description to set */ void SetDesc(const std::string& descstr) { description = descstr; } /** Return all child servers */ const ChildServers& GetChildren() const { return Children; } /** Marks a server as having finished bursting and performs appropriate actions. */ void FinishBurst(); /** Recursive call for child servers */ void FinishBurstInternal(); /** (Re)check the service state of this server */ void CheckService(); /** Get the bursting state of this server * @return True if this server is bursting, false if it isn't */ bool IsBursting() const { return (StartBurst != 0); } /** Check whether this server is behind a bursting server or is itself bursting. * This can tell whether a user is on a part of the network that is still bursting. * @return True if this server is bursting or is behind a server that is bursting, false if it isn't */ bool IsBehindBursting() const { return (behind_bursting != 0); } /** Set the bursting state of the server * @param startms Time the server started bursting, if 0 or omitted, use current time */ void BeginBurst(uint64_t startms = 0); /** Register a PONG from the server */ void OnPong() { pingtimer.OnPong(); } Cullable::Result Cull() override; /** Destructor, deletes ServerUser unless IsRoot() */ ~TreeServer() override; /** Returns the TreeServer the given user is connected to * @param user The user whose server to return * @return The TreeServer this user is connected to. */ static TreeServer* Get(const User* user) { return static_cast<TreeServer*>(user->server); } }; �������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/src/modules/m_spanningtree/treesocket.h����������������������������������������������0000664�0000000�0000000�00000032340�14771603147�0023142�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2019 Matt Schatz <genius3000@g3k.solutions> * Copyright (C) 2013, 2018-2024 Sadie Powell <sadie@witchery.services> * Copyright (C) 2012-2015 Attila Molnar <attilamolnar@hush.com> * Copyright (C) 2012, 2019 Robby <robby@chatbelgie.be> * Copyright (C) 2009-2010 Daniel De Graaf <danieldg@inspircd.org> * Copyright (C) 2009 Uli Schlachter <psychon@znc.in> * Copyright (C) 2007-2008 Robin Burchell <robin+git@viroteck.net> * Copyright (C) 2007, 2010 Craig Edwards <brain@inspircd.org> * Copyright (C) 2007 Dennis Friis <peavey@inspircd.org> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #pragma once #include "inspircd.h" #include "utils.h" /** An enumeration of all known protocol versions. * * If you introduce new protocol versions please document them here: * https://docs.inspircd.org/server/change-log/ */ enum ProtocolVersion : uint16_t { /** The linking protocol version introduced in InspIRCd v3.0. */ PROTO_INSPIRCD_3 = 1205, /** The linking protocol version introduced in InspIRCd v4.0. */ PROTO_INSPIRCD_4 = 1206, /** The oldest version of the protocol that we support. */ PROTO_OLDEST = PROTO_INSPIRCD_3, /** The newest version of the protocol that we support. */ PROTO_NEWEST = PROTO_INSPIRCD_4 }; /* * The server list in InspIRCd is maintained as two structures * which hold the data in different ways. Most of the time, we * want to very quickly obtain three pieces of information: * * (1) The information on a server * (2) The information on the server we must send data through * to actually REACH the server we're after * (3) Potentially, the child/parent objects of this server * * The InspIRCd spanning protocol provides easy access to these * by storing the data firstly in a recursive structure, where * each item references its parent item, and a dynamic list * of child items, and another structure which stores the items * hashed, linearly. This means that if we want to find a server * by name quickly, we can look it up in the hash, avoiding * any O(n) lookups. If however, during a split or sync, we want * to apply an operation to a server, and any of its child objects * we can resort to recursion to walk the tree structure. * Any socket can have one of five states at any one time. * * CONNECTING: indicates an outbound socket which is * waiting to be writeable. * WAIT_AUTH_1: indicates the socket is outbound and * has successfully connected, but has not * yet sent and received SERVER strings. * WAIT_AUTH_2: indicates that the socket is inbound * but has not yet sent and received * SERVER strings. * CONNECTED: represents a fully authorized, fully * connected server. * DYING: represents a server that has had an error. */ enum ServerState { CONNECTING, WAIT_AUTH_1, WAIT_AUTH_2, CONNECTED, DYING }; struct CapabData final { // A map of module names to their link data. typedef std::map<std::string, std::string, irc::insensitive_swo> ModuleMap; // The optional modules sent by the remote server. std::optional<ModuleMap> optionalmodules; // The required modules sent by the remote server. std::optional<ModuleMap> requiredmodules; std::shared_ptr<Link> link; /* Link block used for this connection */ std::shared_ptr<Autoconnect> ac; /* Autoconnect used to cause this connection, if any */ std::string ChanModes; std::string UserModes; std::string ExtBans; std::map<std::string, std::string> CapKeys; /* CAPAB keys from other server */ std::string ourchallenge; /* Challenge sent for challenge/response */ std::string theirchallenge; /* Challenge recv for challenge/response */ int capab_phase = 0; /* Have sent CAPAB already */ bool auth_fingerprint; /* Did we auth using a client certificate fingerprint */ bool auth_challenge; /* Did we auth using challenge/response */ irc::sockets::sockaddrs remotesa; /* The remote socket address. */ // Data saved from incoming SERVER command, for later use when our credentials have been accepted by the other party std::string description; std::string sid; std::string name; bool hidden; CapabData(const irc::sockets::sockaddrs& sa) : remotesa(sa) { } }; /** Every SERVER connection inbound or outbound is represented by an object of * type TreeSocket. During setup, the object can be found in Utils->timeoutlist; * after setup, MyRoot will have been created as a child of Utils->TreeRoot */ class TreeSocket final : public BufferedSocket { std::string linkID; /* Description for this link */ ServerState LinkState; /* Link state */ std::unique_ptr<CapabData> capab; /* Link setup data (held until burst is sent) */ /* The server we are talking to */ TreeServer* MyRoot = nullptr; /** Checks if the given servername and sid are both free */ bool CheckDuplicate(const std::string& servername, const std::string& sid); /** Send all ListModeBase modes set on the channel */ void SendListModes(Channel* chan); /** Send all users and their oper state, away state and metadata */ void SendUsers(TreeServer* s); /** Send all additional info about the given server to this server */ void SendServerInfo(TreeServer* from); /** Find the User source of a command given a prefix and a command string. * This connection must be fully up when calling this function. * @param prefix Prefix string to find the source User object for. Can be a sid, a uuid or a server name. * @param command The command whose source to find. This is required because certain commands (like mode * changes and kills) must be processed even if their claimed source doesn't exist. If the given command is * such a command and the source does not exist, the function returns a valid FakeUser that can be used to * to process the command with. * @return The command source to use when processing the command or NULL if the source wasn't found. * Note that the direction of the returned source is not verified. */ User* FindSource(const std::string& prefix, const std::string& command); /** Finish the authentication phase of this connection. * Change the state of the connection to CONNECTED, create a TreeServer object for the server on the * other end of the connection using the details provided in the parameters, and finally send a burst. * @param remotename Name of the remote server * @param remotesid SID of the remote server * @param remotedesc Description of the remote server * @param hidden True if the remote server is hidden according to the configuration */ void FinishAuth(const std::string& remotename, const std::string& remotesid, const std::string& remotedesc, bool hidden); /** Authenticate the remote server. * Validate the parameters and find the link block that matches the remote server. In case of an error, * an appropriate snotice is generated, an ERROR message is sent and the connection is closed. * Failing to find a matching link block counts as an error. * @param params Parameters they sent in the SERVER command * @return Link block for the remote server, or NULL if an error occurred */ std::shared_ptr<Link> AuthRemote(const CommandBase::Params& params); /** Convenience function: read a line from the socket * @param line The line read * @param delim The line delimiter * @return true if a line was read */ bool GetNextLine(std::string& line, char delim = '\n'); /** Write a line directly to the socket bypassing the older protocol translation layer. * @param line The line to write directly to the socket. */ void WriteLineInternal(const std::string& line); public: const time_t age; // The protocol version which has been negotiated with the remote server. uint16_t proto_version = PROTO_NEWEST; /** Because most of the I/O gubbins are encapsulated within * BufferedSocket, we just call the superclass constructor for * most of the action, and append a few of our own values * to it. */ TreeSocket(const std::shared_ptr<Link>& link, const std::shared_ptr<Autoconnect>& myac, const irc::sockets::sockaddrs& sa); /** When a listening socket gives us a new file descriptor, * we must associate it with a socket without creating a new * connection. This constructor is used for this purpose. */ TreeSocket(int newfd, ListenSocket* via, const irc::sockets::sockaddrs& client, const irc::sockets::sockaddrs& server); /** Get link state */ ServerState GetLinkState() const { return LinkState; } /** Get challenge set in our CAPAB for challenge/response */ const std::string& GetOurChallenge(); /** Get challenge set in our CAPAB for challenge/response */ void SetOurChallenge(const std::string& c); /** Get challenge set in their CAPAB for challenge/response */ const std::string& GetTheirChallenge(); /** Get challenge set in their CAPAB for challenge/response */ void SetTheirChallenge(const std::string& c); /** Compare two passwords based on authentication scheme */ bool ComparePass(const Link& link, const std::string& theirs); /** Clean up information used only during server negotiation */ void CleanNegotiationInfo(); Cullable::Result Cull() override; /** Construct a password, optionally hashed with the other side's * challenge string */ static std::string MakePass(const std::string& password, const std::string& challenge); /** When an outbound connection finishes connecting, we receive * this event, and must send our SERVER string to the other * side. If the other side is happy, as outlined in the server * to server docs on the inspircd.org site, the other side * will then send back its own server string. */ void OnConnected() override; /** Handle socket error event */ void OnError(BufferedSocketError e) override; /** Sends an error to the remote server, and displays it locally to show * that it was sent. */ void SendError(const std::string& errormessage); /** Recursively send the server tree with distances as hops. * This is used during network burst to inform the other server * (and any of ITS servers too) of what servers we know about. */ void SendServers(TreeServer* Current, TreeServer* s); /** Returns mode list as a string, filtered by type. * @param type The type of modes to return. */ static std::string BuildModeList(ModeType type); /** If the extban manager exists then build an extban list. * @param out The buffer to put the extban list in. * @return True if the extban manager exists; otherwise, false. */ static bool BuildExtBanList(std::string& out); /** Send my capabilities to the remote side */ void SendCapabilities(int phase); /* Isolate and return the elements that are different between two lists */ static void ListDifference(const std::string& one, const std::string& two, char sep, std::string& mleft, std::string& mright); bool Capab(const CommandBase::Params& params); /** Send one or more FJOINs for a channel of users. * If the length of a single line is more than 480-NICKMAX * in length, it is split over multiple lines. */ void SendFJoins(Channel* c); /** Send G-, Q-, Z- and E-lines */ void SendXLines(); /** Send all known information about a channel */ void SyncChannel(Channel* chan, TreeServer* s); /** This function is called when we want to send a netburst to a local * server. There is a set order we must do this, because for example * users require their servers to exist, and channels require their * users to exist. You get the idea. */ void DoBurst(TreeServer* s); /** This function is called when we receive data from a remote * server. */ void OnDataReady() override; /** Send one or more complete lines down the socket */ void WriteLine(const std::string& line); /** Handle ERROR command */ void Error(CommandBase::Params& params); /** (local) -> SERVER */ bool Outbound_Reply_Server(CommandBase::Params& params); /** (local) <- SERVER */ bool Inbound_Server(CommandBase::Params& params); /** Handle IRC line split */ void Split(const std::string& line, std::string& tags, std::string& prefix, std::string& command, CommandBase::Params& params); /** Process complete line from buffer */ void ProcessLine(std::string& line); /** Process message tags received from a remote server. */ static void ProcessTag(User* source, const std::string& tag, ClientProtocol::TagMap& tags); /** Process a message for a fully connected server. */ void ProcessConnectedLine(std::string& tags, std::string& prefix, std::string& command, CommandBase::Params& params); /** Handle socket timeout from connect() */ void OnTimeout() override; /** Handle server quit on close */ void Close() override; /** Fixes messages coming from old servers so the new command handlers understand them. */ bool PreProcessOldProtocolMessage(User*& who, std::string& cmd, CommandBase::Params& params); }; ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/src/modules/m_spanningtree/treesocket1.cpp�������������������������������������������0000664�0000000�0000000�00000015752�14771603147�0023566�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2017-2023 Sadie Powell <sadie@witchery.services> * Copyright (C) 2013-2016 Attila Molnar <attilamolnar@hush.com> * Copyright (C) 2012, 2019 Robby <robby@chatbelgie.be> * Copyright (C) 2009-2010 Daniel De Graaf <danieldg@inspircd.org> * Copyright (C) 2007-2008 Dennis Friis <peavey@inspircd.org> * Copyright (C) 2007-2008 Craig Edwards <brain@inspircd.org> * Copyright (C) 2007 Robin Burchell <robin+git@viroteck.net> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include "inspircd.h" #include "iohook.h" #include "main.h" #include "utils.h" #include "treeserver.h" #include "link.h" #include "treesocket.h" #include "commands.h" /** Constructor for outgoing connections. * Because most of the I/O gubbins are encapsulated within * BufferedSocket, we just call DoConnect() for most of the action, * and only do minor initialization tasks ourselves. */ TreeSocket::TreeSocket(const std::shared_ptr<Link>& link, const std::shared_ptr<Autoconnect>& myac, const irc::sockets::sockaddrs& dest) : linkID(link->Name) , LinkState(CONNECTING) , capab(std::make_unique<CapabData>(dest)) , age(ServerInstance->Time()) { capab->link = link; capab->ac = myac; irc::sockets::sockaddrs bind; if (!link->Bind.empty() && (dest.family() == AF_INET || dest.family() == AF_INET6)) { if (!bind.from_ip(link->Bind)) { state = I_ERROR; SetError("Bind address '" + link->Bind + "' is not a valid IPv4 or IPv6 address"); TreeSocket::OnError(I_ERR_BIND); return; } else if (bind.family() != dest.family()) { state = I_ERROR; SetError("Bind address '" + bind.addr() + "' is not the same address family as destination address '" + dest.addr() + "'"); TreeSocket::OnError(I_ERR_BIND); return; } } DoConnect(dest, bind, link->Timeout, link->Protocol); Utils->timeoutlist[this] = std::pair<std::string, unsigned int>(linkID, link->Timeout); SendCapabilities(1); } /** Constructor for incoming connections */ TreeSocket::TreeSocket(int newfd, ListenSocket* via, const irc::sockets::sockaddrs& client, const irc::sockets::sockaddrs& server) : BufferedSocket(newfd) , linkID("inbound from " + client.addr()) , LinkState(WAIT_AUTH_1) , capab(std::make_unique<CapabData>(client)) , age(ServerInstance->Time()) { for (auto& iohookprovref : via->iohookprovs) { if (!iohookprovref) continue; iohookprovref->OnAccept(this, client, server); // IOHook could have encountered a fatal error, e.g. if the TLS ClientHello was already in the queue and there was no common TLS version if (!GetError().empty()) { TreeSocket::OnError(I_ERR_OTHER); return; } } SendCapabilities(1); Utils->timeoutlist[this] = std::pair<std::string, unsigned int>(linkID, 30); } void TreeSocket::CleanNegotiationInfo() { // connect is good, reset the autoconnect block (if used) if (capab->ac) capab->ac->position = -1; capab.reset(); } Cullable::Result TreeSocket::Cull() { Utils->timeoutlist.erase(this); if (capab && capab->ac) Utils->Creator->ConnectServer(capab->ac, false); return this->BufferedSocket::Cull(); } /** When an outbound connection finishes connecting, we receive * this event, and must do CAPAB negotiation with the other * side. If the other side is happy, as outlined in the server * to server docs on the inspircd.org site, the other side * will then send back its own SERVER string eventually. */ void TreeSocket::OnConnected() { if (this->LinkState == CONNECTING) { if (!capab->link->Hook.empty()) { ServiceProvider* prov = ServerInstance->Modules.FindService(SERVICE_IOHOOK, "ssl/" + capab->link->Hook); if (!prov) { SetError("Could not find hook '" + capab->link->Hook + "' for connection to " + linkID); return; } static_cast<IOHookProvider*>(prov)->OnConnect(this); } ServerInstance->SNO.WriteGlobalSno('l', "Connection to \002{}\002[{}] started.", linkID, (capab->link->HiddenFromStats ? "<hidden>" : capab->link->IPAddr)); this->SendCapabilities(1); } } void TreeSocket::OnError(BufferedSocketError e) { ServerInstance->SNO.WriteGlobalSno('l', "Connection to '\002{}\002' failed with error: {}", linkID, GetError()); LinkState = DYING; Close(); } void TreeSocket::SendError(const std::string& errormessage) { WriteLine("ERROR :"+errormessage); DoWrite(); LinkState = DYING; SetError(errormessage); } CmdResult CommandSQuit::HandleServer(TreeServer* server, CommandBase::Params& params) { TreeServer* quitting = Utils->FindServer(params[0]); if (!quitting) { ServerInstance->Logs.Normal(MODNAME, "Squit from unknown server"); return CmdResult::FAILURE; } CmdResult ret = CmdResult::SUCCESS; if (quitting == server) { ret = CmdResult::FAILURE; server = server->GetParent(); } else if (quitting->GetParent() != server) throw ProtocolException("Attempted to SQUIT a non-directly connected server or the parent"); server->SQuitChild(quitting, params[1]); // XXX: Return CmdResult::FAILURE when servers SQUIT themselves (i.e. :00S SQUIT 00S :Shutting down) // to stop this message from being forwarded. // The squit logic generates a SQUIT message with our sid as the source and sends it to the // remaining servers. return ret; } bool TreeSocket::GetNextLine(std::string& line, char delim) { std::string::size_type i = recvq.find(delim); if (i == std::string::npos) return false; line.assign(recvq, 0, i); recvq.erase(0, i + 1); return true; } /** This function is called when we receive data from a remote * server. */ void TreeSocket::OnDataReady() { Utils->Creator->loopCall = true; std::string line; while (GetNextLine(line)) { std::string::size_type rline = line.find('\r'); if (rline != std::string::npos) line.erase(rline); if (line.find('\0') != std::string::npos) { SendError("Read null character from socket"); break; } try { ProcessLine(line); } catch (const CoreException& ex) { ServerInstance->Logs.Normal(MODNAME, "Error while processing: " + line); ServerInstance->Logs.Normal(MODNAME, ex.GetReason()); SendError(ex.GetReason() + " - check the log file for details"); } if (!GetError().empty()) break; } if (LinkState != CONNECTED && recvq.length() > 4096) SendError("RecvQ overrun (line too long)"); Utils->Creator->loopCall = false; } static std::string newline("\n"); void TreeSocket::WriteLineInternal(const std::string& line) { ServerInstance->Logs.RawIO(MODNAME, "S[{}] O {}", GetFd(), line); this->WriteData(line); this->WriteData(newline); } ����������������������inspircd-4.7.0/src/modules/m_spanningtree/treesocket2.cpp�������������������������������������������0000664�0000000�0000000�00000033022�14771603147�0023555�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2019 linuxdaemon <linuxdaemon.irc@gmail.com> * Copyright (C) 2018-2025 Sadie Powell <sadie@witchery.services> * Copyright (C) 2012-2016, 2018 Attila Molnar <attilamolnar@hush.com> * Copyright (C) 2012 Robby <robby@chatbelgie.be> * Copyright (C) 2009-2010 Daniel De Graaf <danieldg@inspircd.org> * Copyright (C) 2008, 2012 Robin Burchell <robin+git@viroteck.net> * Copyright (C) 2007-2008 Dennis Friis <peavey@inspircd.org> * Copyright (C) 2007-2008 Craig Edwards <brain@inspircd.org> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include "inspircd.h" #include "timeutils.h" #include "main.h" #include "utils.h" #include "treeserver.h" #include "treesocket.h" #include "resolvers.h" #include "commands.h" /* Handle ERROR command */ void TreeSocket::Error(CommandBase::Params& params) { const std::string msg = params.empty() ? "" : params[0]; SetError("received ERROR " + msg); } void TreeSocket::Split(const std::string& line, std::string& tags, std::string& prefix, std::string& command, CommandBase::Params& params) { std::string token; irc::tokenstream tokens(line); if (!tokens.GetMiddle(token)) return; if (token[0] == '@') { if (token.length() <= 1) { this->SendError("BUG: Received a message with empty tags: " + line); return; } tags.assign(token, 1, std::string::npos); if (!tokens.GetMiddle(token)) { this->SendError("BUG: Received a message with no command: " + line); return; } } if (token[0] == ':') { if (token.length() <= 1) { this->SendError("BUG: Received a message with an empty prefix: " + line); return; } prefix.assign(token, 1, std::string::npos); if (!tokens.GetMiddle(token)) { this->SendError("BUG: Received a message with no command: " + line); return; } } command.assign(token); while (tokens.GetTrailing(token)) params.push_back(token); } void TreeSocket::ProcessLine(std::string& line) { std::string tags; std::string prefix; std::string command; CommandBase::Params params; ServerInstance->Logs.RawIO(MODNAME, "S[{}] I {}", GetFd(), line); Split(line, tags, prefix, command, params); if (command.empty()) return; switch (this->LinkState) { case WAIT_AUTH_1: /* * State WAIT_AUTH_1: * Waiting for SERVER command from remote server. Server initiating * the connection sends the first SERVER command, listening server * replies with theirs if its happy, then if the initiator is happy, * it starts to send its net sync, which starts the merge, otherwise * it sends an ERROR. */ if (command == "PASS") { /* * Ignore this silently. Some services packages insist on sending PASS, even * when it is not required (i.e. by us). We have to ignore this here, otherwise * as it's an unknown command (effectively), it will cause the connection to be * closed, which probably isn't what people want. -- w00t */ } else if (command == "SERVER") { this->Inbound_Server(params); } else if (command == "ERROR") { this->Error(params); } else if (command == "USER") { this->SendError("Client connections to this port are prohibited."); } else if (command == "CAPAB") { this->Capab(params); } else { this->SendError("Invalid command in negotiation phase: " + command); } break; case WAIT_AUTH_2: /* * State WAIT_AUTH_2: * We have sent SERVER to the other side of the connection. Now we're waiting for them to start BURST. * The other option at this stage of things, of course, is for them to close our connection thanks * to invalid credentials.. -- w */ if (command == "SERVER") { /* * Connection is either attempting to re-auth itself (stupid) or sending netburst without sending BURST. * Both of these aren't allowable, so block them here. -- w */ this->SendError("You may not re-authenticate or commence netburst without sending BURST."); } else if (command == "BURST") { if (!params.empty()) { time_t them = ServerCommand::ExtractTS(params[0]); time_t delta = std::abs(them - ServerInstance->Time()); if (delta > 15) { ServerInstance->SNO.WriteGlobalSno('l', "\002ERROR\002: Your clocks are off by {} (this is more than fifteen seconds). Link aborted, \002PLEASE SYNC YOUR CLOCKS!\002", Duration::ToLongString(delta)); SendError(INSP_FORMAT("Your clocks are out by {} (this is more than fifteen seconds). Link aborted, PLEASE SYNC YOUR CLOCKS!", Duration::ToLongString(delta))); return; } else if (delta > 5) { ServerInstance->SNO.WriteGlobalSno('l', "\002WARNING\002: Your clocks are off by {}. Please consider syncing your clocks.", Duration::ToLongString(delta)); } } // Check for duplicate server name/sid again, it's possible that a new // server was introduced while we were waiting for them to send BURST. // (we do not reserve their server name/sid when they send SERVER, we do it now) if (!CheckDuplicate(capab->name, capab->sid)) return; FinishAuth(capab->name, capab->sid, capab->description, capab->hidden); } else if (command == "ERROR") { this->Error(params); } else if (command == "CAPAB") { this->Capab(params); } else { ServerInstance->Logs.Debug(MODNAME, "Unknown command from fd {} in the WAIT_AUTH_2 phase: {}", GetFd(), command); } break; case CONNECTING: /* * State CONNECTING: * We're connecting (OUTGOING) to another server. They are in state WAIT_AUTH_1 until they verify * our credentials, when they proceed into WAIT_AUTH_2 and send SERVER to us. We then send BURST * + our netburst, which will put them into CONNECTED state. -- w */ if (command == "SERVER") { // Our credentials have been accepted, send netburst. (this puts US into the CONNECTED state) this->Outbound_Reply_Server(params); } else if (command == "ERROR") { this->Error(params); } else if (command == "CAPAB") { this->Capab(params); } else { ServerInstance->Logs.Debug(MODNAME, "Unknown command from fd {} in the CONNECTING phase: {}", GetFd(), command); } break; case CONNECTED: /* * State CONNECTED: * Credentials have been exchanged, we've gotten their 'BURST' (or sent ours). * Anything from here on should be accepted a little more reasonably. */ this->ProcessConnectedLine(tags, prefix, command, params); break; case DYING: break; } } User* TreeSocket::FindSource(const std::string& prefix, const std::string& command) { // Empty prefix means the source is the directly connected server that sent this command if (prefix.empty()) return MyRoot->ServerUser; if (prefix.size() == 3) { // Prefix looks like a sid TreeServer* server = Utils->FindServerID(prefix); if (server) return server->ServerUser; } else { // If the prefix string is a uuid FindUUID() returns the appropriate User object auto* user = ServerInstance->Users.FindUUID(prefix); if (user) return user; } // Some implementations wrongly send a server name as prefix occasionally, handle that too for now TreeServer* const server = Utils->FindServer(prefix); if (server) return server->ServerUser; /* It is important that we don't close the link here, unknown prefix can occur * due to various race conditions such as the KILL message for a user somehow * crossing the users QUIT further upstream from the server. Thanks jilles! */ if ((prefix.length() == UIDGenerator::UUID_LENGTH) && (isdigit(prefix[0])) && ((command == "FMODE") || (command == "MODE") || (command == "KICK") || (command == "TOPIC") || (command == "KILL") || (command == "ADDLINE") || (command == "DELLINE"))) { /* Special case, we cannot drop these commands as they've been committed already on a * part of the network by the time we receive them, so in this scenario pretend the * command came from a server to avoid desync. */ TreeServer* const usersserver = Utils->FindServerID(prefix.substr(0, 3)); if (usersserver) return usersserver->ServerUser; return this->MyRoot->ServerUser; } // Unknown prefix return nullptr; } void TreeSocket::ProcessTag(User* source, const std::string& tag, ClientProtocol::TagMap& tags) { std::string tagkey; std::string tagval; const std::string::size_type p = tag.find('='); if (p != std::string::npos) { // Tag has a value tagkey.assign(tag, 0, p); tagval.assign(tag, p + 1, std::string::npos); } else { tagkey.assign(tag); } for (auto* subscriber : Utils->Creator->tagevprov.GetSubscribers()) { ClientProtocol::MessageTagProvider* const tagprov = static_cast<ClientProtocol::MessageTagProvider*>(subscriber); const ModResult res = tagprov->OnProcessTag(source, tagkey, tagval); if (res == MOD_RES_ALLOW) tags.emplace(tagkey, ClientProtocol::MessageTagData(tagprov, tagval)); else if (res == MOD_RES_DENY) break; } } void TreeSocket::ProcessConnectedLine(std::string& taglist, std::string& prefix, std::string& command, CommandBase::Params& params) { User* who = FindSource(prefix, command); if (!who) { ServerInstance->Logs.Debug(MODNAME, "Command '{}' from unknown prefix '{}'! Dropping entire command.", command, prefix); return; } /* * Check for fake direction here, and drop any instances that are found. * What is fake direction? Imagine the following server setup: * 0AA <-> 0AB <-> 0AC * Fake direction would be 0AC sending a message to 0AB claiming to be from * 0AA, or something similar. Basically, a message taking a path that *cannot* * be correct. * * When would this be seen? * Well, hopefully never. It could be caused by race conditions, bugs, or * "miscreant" servers, though, so let's check anyway. -- w * * We also check here for totally invalid prefixes (prefixes that are neither * a valid SID or a valid UUID, so that invalid UUID or SID never makes it * to the higher level functions. -- B */ TreeServer* const server = TreeServer::Get(who); if (server->GetSocket() != this) { ServerInstance->Logs.Debug(MODNAME, "Protocol violation: Fake direction '{}' from connection '{}'", prefix, linkID); return; } // Translate commands coming from servers using an older protocol if (proto_version < PROTO_NEWEST) { if (!PreProcessOldProtocolMessage(who, command, params)) return; } ServerCommand* scmd = Utils->Creator->CmdManager.GetHandler(command); CommandBase* cmdbase = scmd; Command* cmd = nullptr; if (!scmd) { // Not a special server-to-server command cmd = ServerInstance->Parser.GetHandler(command); if (!cmd) { if (command == "ERROR") { this->Error(params); return; } else if (command == "BURST") { // This is sent even when there is no need for it, drop it here for now return; } throw ProtocolException("Unknown command: " + command); } cmdbase = cmd; } if (params.size() < cmdbase->min_params) throw ProtocolException("Insufficient parameters"); if ((!params.empty()) && (params.back().empty()) && (!cmdbase->allow_empty_last_param)) { // the last param is empty and the command handler doesn't allow that, check if there will be enough params if we drop the last if (params.size()-1 < cmdbase->min_params) return; params.pop_back(); } CmdResult res; ClientProtocol::TagMap tags; std::string tag; irc::sepstream tagstream(taglist, ';'); while (tagstream.GetToken(tag)) ProcessTag(who, tag, tags); CommandBase::Params newparams(params, tags); if (scmd) res = scmd->Handle(who, newparams); else { res = cmd->Handle(who, newparams); if (res == CmdResult::INVALID) throw ProtocolException("Error in command handler"); } if (res == CmdResult::SUCCESS) Utils->RouteCommand(server->GetRoute(), cmdbase, newparams, who); } void TreeSocket::OnTimeout() { ServerInstance->SNO.WriteGlobalSno('l', "CONNECT: Connection to \002{}\002 timed out.", linkID); } void TreeSocket::Close() { if (!HasFd()) return; ServerInstance->GlobalCulls.AddItem(this); this->BufferedSocket::Close(); SetError("Remote host closed connection"); // Connection closed. // If the connection is fully up (state CONNECTED) // then propagate a netsplit to all peers. if (MyRoot && !MyRoot->IsDead()) MyRoot->SQuit(GetError(), true); else ServerInstance->SNO.WriteGlobalSno('l', "Connection to '\002{}\002' failed.", linkID); time_t server_uptime = ServerInstance->Time() - this->age; if (server_uptime) { std::string timestr = Duration::ToLongString(server_uptime); ServerInstance->SNO.WriteGlobalSno('l', "Connection to '\002{}\002' was established for {}", linkID, timestr); } } void TreeSocket::FinishAuth(const std::string& remotename, const std::string& remotesid, const std::string& remotedesc, bool hidden) { this->LinkState = CONNECTED; Utils->timeoutlist.erase(this); linkID = remotename; MyRoot = new TreeServer(remotename, remotedesc, remotesid, Utils->TreeRoot, this, hidden); // Mark the server as bursting MyRoot->BeginBurst(); this->DoBurst(MyRoot); CommandServer::Builder(MyRoot).Forward(MyRoot); } ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/src/modules/m_spanningtree/uid.cpp���������������������������������������������������0000664�0000000�0000000�00000015216�14771603147�0022111�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2017-2024 Sadie Powell <sadie@witchery.services> * Copyright (C) 2013 Adam <Adam@anope.org> * Copyright (C) 2012-2016 Attila Molnar <attilamolnar@hush.com> * Copyright (C) 2012 Robby <robby@chatbelgie.be> * Copyright (C) 2009-2010 Daniel De Graaf <danieldg@inspircd.org> * Copyright (C) 2008 Robin Burchell <robin+git@viroteck.net> * Copyright (C) 2008 Craig Edwards <brain@inspircd.org> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include "inspircd.h" #include "commands.h" #include "utils.h" #include "treeserver.h" #include "remoteuser.h" CmdResult CommandUID::HandleServer(TreeServer* remoteserver, CommandBase::Params& params) { /** * 0 1 2 3 4 5? 6(5) 7(6) 8(7) 9(8) 10(9) (n-1) * UID uuid nickchanged nick host dhost [user] duser ip.string signon +modes (modepara) :real * * The `duser` field was introduced in the 1206 (v4) protocol. */ time_t nickchanged = ServerCommand::ExtractTS(params[1]); time_t signon = ServerCommand::ExtractTS(params[8]); const std::string& modestr = params[9]; // Check if the length of the uuid is correct and confirm the sid portion of the uuid matches the sid of the server introducing the user if (params[0].length() != UIDGenerator::UUID_LENGTH || params[0].compare(0, 3, remoteserver->GetId())) throw ProtocolException("Bogus UUID"); // Sanity check on mode string: must begin with '+' if (modestr[0] != '+') throw ProtocolException("Invalid mode string"); // See if there is a nick collision auto* collideswith = ServerInstance->Users.FindNick(params[2]); if (collideswith && !collideswith->IsFullyConnected()) { // User that the incoming user is colliding with is not fully connected, we force nick change the // partially connected user to their uuid and tell them what happened LocalUser* const localuser = static_cast<LocalUser*>(collideswith); localuser->OverruleNick(); } else if (collideswith) { // The user on this side is fully connected, handle the collision bool they_change = SpanningTreeUtilities::DoCollision(collideswith, remoteserver, nickchanged, params[5], params[7], params[0], "UID"); if (they_change) { // The client being introduced needs to change nick to uuid, change the nick in the message before // processing/forwarding it. Also change the nick TS to CommandSave::SavedTimestamp. nickchanged = CommandSave::SavedTimestamp; params[1] = ConvToStr(CommandSave::SavedTimestamp); params[2] = params[0]; } } irc::sockets::sockaddrs sa(false); if (!sa.from(params[7])) throw ProtocolException("Invalid IP address or UNIX socket path"); /* For remote users, we pass the UUID they sent to the constructor. * If the UUID already exists User::User() throws an exception which causes this connection to be closed. */ auto* _new = new SpanningTree::RemoteUser(params[0], remoteserver); ServerInstance->Users.clientlist[params[2]] = _new; _new->nick = params[2]; _new->ChangeRealHost(params[3], false); _new->ChangeDisplayedHost(params[4]); _new->ChangeRealUser(params[5], false); _new->ChangeDisplayedUser(params[6]); _new->ChangeRemoteAddress(sa); _new->ChangeRealName(params.back()); _new->connected = User::CONN_FULL; _new->signon = signon; _new->nickchanged = nickchanged; size_t paramptr = 10; for (const auto& modechr : modestr) { // Accept more '+' chars, for now if (modechr == '+') continue; /* For each mode that's set, find the mode handler and set it on the new user */ ModeHandler* mh = ServerInstance->Modes.FindMode(modechr, MODETYPE_USER); if (!mh) throw ProtocolException("Unrecognised mode '" + std::string(1, modechr) + "'"); if (mh->NeedsParam(true)) { if (paramptr >= params.size() - 1) throw ProtocolException("Out of parameters while processing modes"); /* IMPORTANT NOTE: * All modes are assumed to succeed here as they are being set by a remote server. * Modes CANNOT FAIL here. If they DO fail, then the failure is ignored. This is important * to note as all but one modules currently cannot ever fail in this situation, except for * user mode +k which specifically works this way to prevent the mode being set ANYWHERE * but here, at client introduction. You may safely assume this behaviour is standard and * will not change in future versions if you want to make use of this protective behaviour * yourself. */ Modes::Change modechange(mh, true, params[paramptr++]); mh->OnModeChange(_new, _new, nullptr, modechange); } else { Modes::Change modechange(mh, true, ""); mh->OnModeChange(_new, _new, nullptr, modechange); } _new->SetMode(mh, true); } ServerInstance->Users.AddClone(_new); remoteserver->UserCount++; bool dosend = true; if ((Utils->quiet_bursts && remoteserver->IsBehindBursting()) || _new->server->IsSilentService()) dosend = false; if (dosend) { ServerInstance->SNO.WriteToSnoMask('C', "Client connecting at {}: {} ({}) [{}\x0F]", remoteserver->GetName(), _new->GetRealMask(), _new->GetAddress(), _new->GetRealName()); } FOREACH_MOD(OnPostConnect, (_new)); return CmdResult::SUCCESS; } CmdResult CommandFHost::HandleRemote(RemoteUser* src, Params& params) { if (params[0] != "*") src->ChangeDisplayedHost(params[0]); if (params[1] != "*") src->ChangeRealHost(params[1], false); return CmdResult::SUCCESS; } CmdResult CommandFIdent::HandleRemote(RemoteUser* src, Params& params) { if (params[0] != "*") src->ChangeDisplayedUser(params[0]); if (params[1] != "*") src->ChangeRealUser(params[1], false); return CmdResult::SUCCESS; } CmdResult CommandFName::HandleRemote(RemoteUser* src, Params& params) { src->ChangeRealName(params[0]); return CmdResult::SUCCESS; } CommandUID::Builder::Builder(User* user) : CmdBuilder(TreeServer::Get(user), "UID") { push(user->uuid); push_int(user->nickchanged); push(user->nick); push(user->GetRealHost()); push(user->GetDisplayedHost()); push(user->GetRealUser()); push(user->GetDisplayedUser()); push(user->GetAddress()); push_int(user->signon); push(user->GetModeLetters(true)); push_last(user->GetRealName()); } ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/src/modules/m_spanningtree/utils.cpp�������������������������������������������������0000664�0000000�0000000�00000031612�14771603147�0022466�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2013-2014, 2018-2025 Sadie Powell <sadie@witchery.services> * Copyright (C) 2013 Adam <Adam@anope.org> * Copyright (C) 2012-2016 Attila Molnar <attilamolnar@hush.com> * Copyright (C) 2012 Robby <robby@chatbelgie.be> * Copyright (C) 2009-2010 Daniel De Graaf <danieldg@inspircd.org> * Copyright (C) 2008-2009 Robin Burchell <robin+git@viroteck.net> * Copyright (C) 2007-2008 Craig Edwards <brain@inspircd.org> * Copyright (C) 2007 Dennis Friis <peavey@inspircd.org> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include "inspircd.h" #include "listmode.h" #include "main.h" #include "utils.h" #include "treeserver.h" #include "treesocket.h" #include "resolvers.h" #include "commandbuilder.h" SpanningTreeUtilities* Utils = nullptr; ModResult ModuleSpanningTree::OnAcceptConnection(int newsock, ListenSocket* from, const irc::sockets::sockaddrs& client, const irc::sockets::sockaddrs& server) { if (!insp::equalsci(from->bind_tag->getString("type"), "servers")) return MOD_RES_PASSTHRU; const std::string incomingip = client.addr(); for (const auto& validip : Utils->ValidIPs) { if (validip == "*" || validip == incomingip || irc::sockets::cidr_mask(validip).match(client)) { /* we don't need to do anything with the pointer, creating it stores it in the necessary places */ new TreeSocket(newsock, from, client, server); return MOD_RES_ALLOW; } } ServerInstance->SNO.WriteToSnoMask('l', "Server connection from {} denied (no link blocks with that IP address)", incomingip); return MOD_RES_DENY; } TreeServer* SpanningTreeUtilities::FindServer(const std::string& ServerName) { if (InspIRCd::IsSID(ServerName)) return this->FindServerID(ServerName); server_hash::iterator iter = serverlist.find(ServerName); if (iter != serverlist.end()) { return iter->second; } else { return nullptr; } } /** Find the first server matching a given glob mask. * We iterate over the list and match each one until we get a hit. */ TreeServer* SpanningTreeUtilities::FindServerMask(const std::string& ServerName) { for (const auto& [name, server] : serverlist) { if (InspIRCd::Match(name, ServerName)) return server; } return nullptr; } TreeServer* SpanningTreeUtilities::FindServerID(const std::string& id) { server_hash::iterator iter = sidlist.find(id); if (iter != sidlist.end()) return iter->second; else return nullptr; } TreeServer* SpanningTreeUtilities::FindRouteTarget(const std::string& target) { TreeServer* const server = FindServer(target); if (server) return server; User* const user = ServerInstance->Users.Find(target); if (user) return TreeServer::Get(user); return nullptr; } SpanningTreeUtilities::SpanningTreeUtilities(ModuleSpanningTree* C) : Creator(C) { ServerInstance->Timers.AddTimer(&RefreshTimer); } Cullable::Result SpanningTreeUtilities::Cull() { const TreeServer::ChildServers& children = TreeRoot->GetChildren(); while (!children.empty()) { TreeSocket* sock = children.front()->GetSocket(); sock->Close(); } for (const auto& [s, _] : timeoutlist) s->Close(); TreeRoot->Cull(); return Cullable::Cull(); } SpanningTreeUtilities::~SpanningTreeUtilities() { delete TreeRoot; } // Returns a list of DIRECT servers for a specific channel void SpanningTreeUtilities::GetListOfServersForChannel(const Channel* c, TreeSocketSet& list, char status, const CUList& exempt_list) const { ModeHandler::Rank minrank = 0; if (status) { PrefixMode* mh = ServerInstance->Modes.FindPrefix(status); if (mh) minrank = mh->GetPrefixRank(); } TreeServer::ChildServers children = TreeRoot->GetChildren(); for (const auto& [user, memb] : c->GetUsers()) { if (IS_LOCAL(user)) continue; if (minrank && memb->GetRank() < minrank) continue; if (exempt_list.find(user) == exempt_list.end()) { TreeServer* best = TreeServer::Get(user); list.insert(best->GetSocket()); TreeServer::ChildServers::iterator citer = std::find(children.begin(), children.end(), best); if (citer != children.end()) children.erase(citer); } } // Check whether the servers which do not have users in the channel might need this message. This // is used to keep the chanhistory module synchronised between servers. for (const auto &[_, server] : Utils->serverlist) { if (!server->GetRoute()) continue; // Local server ModResult result = Creator->routeeventprov.FirstResult(&ServerProtocol::RouteEventListener::OnRouteMessage, c, server); if (result == MOD_RES_ALLOW) list.insert(server->GetRoute()->GetSocket()); } } void SpanningTreeUtilities::DoOneToAllButSender(const CmdBuilder& params, const TreeServer* omitroute) const { const std::string& FullLine = params.str(); for (const auto* Route : TreeRoot->GetChildren()) { // Send the line if the route isn't the path to the one to be omitted if (Route != omitroute) { Route->GetSocket()->WriteLine(FullLine); } } } void SpanningTreeUtilities::DoOneToOne(const CmdBuilder& params, const Server* server) { const TreeServer* ts = static_cast<const TreeServer*>(server); TreeSocket* sock = ts->GetSocket(); if (sock) sock->WriteLine(params); } void SpanningTreeUtilities::RefreshIPCache() { ValidIPs.clear(); for (const auto& L : LinkBlocks) { bool isunix = L->IPAddr.find('/') != std::string::npos; if (!L->Port && !isunix) { ServerInstance->Logs.Warning(MODNAME, "Ignoring an IP link block without a port."); /* Invalid link block */ continue; } ValidIPs.insert(ValidIPs.end(), L->AllowMasks.begin(), L->AllowMasks.end()); irc::sockets::sockaddrs dummy(false); bool ipvalid = dummy.from_ip_port(L->IPAddr, L->Port); if ((L->IPAddr == "*") || (isunix) || (ipvalid)) ValidIPs.push_back(L->IPAddr); else if (this->Creator->DNS) { auto* sr = new SecurityIPResolver(Creator, *this->Creator->DNS, L->IPAddr, L, DNS::QUERY_AAAA); try { this->Creator->DNS->Process(sr); } catch (const DNS::Exception&) { delete sr; } } } } void SpanningTreeUtilities::ReadConfiguration() { const auto& options = ServerInstance->Config->ConfValue("options"); AllowOptCommon = options->getBool("allowmismatch"); AnnounceTSChange = options->getBool("announcets"); PingWarnTime = options->getDuration("pingwarning", 15); PingFreq = options->getDuration("serverpingfreq", 60, 1); const auto& security = ServerInstance->Config->ConfValue("security"); FlatLinks = security->getBool("flatlinks"); HideServices = security->getBool("hideservices", security->getBool("hideulines")); HideSplits = security->getBool("hidesplits"); const auto& performance = ServerInstance->Config->ConfValue("performance"); quiet_bursts = performance->getBool("quietbursts"); if (PingWarnTime >= PingFreq) PingWarnTime = 0; AutoconnectBlocks.clear(); LinkBlocks.clear(); for (const auto& [_, tag] : ServerInstance->Config->ConfTags("link")) { auto L = std::make_shared<Link>(tag); irc::spacesepstream sep = tag->getString("allowmask"); for (std::string s; sep.GetToken(s);) L->AllowMasks.push_back(s); const std::string path = tag->getString("path"); if (path.empty()) { L->IPAddr = tag->getString("ipaddr"); L->Port = tag->getNum<in_port_t>("port", 0); if (tag->getBool("sctp")) { #ifdef IPPROTO_SCTP L->Protocol = IPPROTO_SCTP; #else throw ModuleException((Module*)Creator, "Unable to use SCTP for outgoing connections as this platform does not support SCTP!"); #endif } } else { L->IPAddr = ServerInstance->Config->Paths.PrependData(path); L->Port = 0; } L->Name = tag->getString("name"); L->SendPass = tag->getString("sendpass", tag->getString("password")); L->RecvPass = tag->getString("recvpass", tag->getString("password")); L->Fingerprint = tag->getString("fingerprint"); L->HiddenFromStats = tag->getBool("statshidden"); L->Timeout = tag->getDuration("timeout", 30); L->Hook = tag->getString("sslprofile"); L->Bind = tag->getString("bind"); L->Hidden = tag->getBool("hidden"); if (L->Name.empty()) throw ModuleException((Module*)Creator, "Invalid configuration, found a link tag without a name!" + (!L->IPAddr.empty() ? " IP address: "+L->IPAddr : "")); if (L->Name.find('.') == std::string::npos) throw ModuleException((Module*)Creator, "The link name '"+L->Name+"' is invalid as it must contain at least one '.' character"); if (L->Name.length() > ServerInstance->Config->Limits.MaxHost) throw ModuleException((Module*)Creator, "The link name '{}' is invalid as it is longer than {} characters", L->Name, ServerInstance->Config->Limits.MaxHost); if (L->RecvPass.empty()) throw ModuleException((Module*)Creator, "Invalid configuration for server '"+L->Name+"', recvpass not defined"); if (L->SendPass.empty()) throw ModuleException((Module*)Creator, "Invalid configuration for server '"+L->Name+"', sendpass not defined"); if ((L->SendPass.find(' ') != std::string::npos) || (L->RecvPass.find(' ') != std::string::npos)) throw ModuleException((Module*)Creator, "Link block '" + L->Name + "' has a password set that contains a space character which is invalid"); if ((L->SendPass[0] == ':') || (L->RecvPass[0] == ':')) throw ModuleException((Module*)Creator, "Link block '" + L->Name + "' has a password set that begins with a colon (:) which is invalid"); if (L->IPAddr.empty()) { L->IPAddr = "*"; ServerInstance->Logs.Warning(MODNAME, "Configuration warning: Link block '" + L->Name + "' has no IP defined! This will allow any IP to connect as this server, and MAY not be what you want."); } if (!L->Port && L->IPAddr.find('/') == std::string::npos) ServerInstance->Logs.Warning(MODNAME, "Configuration warning: Link block '" + L->Name + "' has no port defined, you will not be able to /connect it."); std::transform(L->Fingerprint.begin(), L->Fingerprint.end(), L->Fingerprint.begin(), ::tolower); L->Fingerprint.erase(std::remove(L->Fingerprint.begin(), L->Fingerprint.end(), ':'), L->Fingerprint.end()); LinkBlocks.push_back(L); } for (const auto& [_, tag] : ServerInstance->Config->ConfTags("autoconnect")) { auto A = std::make_shared<Autoconnect>(tag); A->Period = tag->getDuration("period", 60, 1); A->NextConnectTime = ServerInstance->Time() + A->Period; A->position = -1; irc::spacesepstream ss(tag->getString("server")); std::string server; while (ss.GetToken(server)) { A->servers.push_back(server); } if (A->servers.empty()) { throw ModuleException((Module*)Creator, "Invalid configuration for autoconnect, server cannot be empty!"); } AutoconnectBlocks.push_back(A); } for (const auto& [_, server] : serverlist) server->CheckService(); RefreshIPCache(); } std::shared_ptr<Link> SpanningTreeUtilities::FindLink(const std::string& name) { for (const auto& x : LinkBlocks) { if (InspIRCd::Match(x->Name, name, ascii_case_insensitive_map)) { return x; } } return nullptr; } void SpanningTreeUtilities::SendChannelMessage(const User* source, const Channel* target, const std::string& text, char status, const ClientProtocol::TagMap& tags, const CUList& exempt_list, const char* message_type, const TreeSocket* omit) const { CmdBuilder msg(source, message_type); msg.push_tags(tags); msg.push_raw(' '); if (status != 0) msg.push_raw(status); msg.push_raw(target->name); if (!text.empty()) msg.push_last(text); TreeSocketSet list; this->GetListOfServersForChannel(target, list, status, exempt_list); for (auto* Sock : list) { if (Sock != omit) Sock->WriteLine(msg); } } std::string SpanningTreeUtilities::BuildLinkString(uint16_t proto, Module* mod) { Module::LinkData data; std::string compatdata; mod->GetLinkData(data, compatdata); if (proto <= PROTO_INSPIRCD_3) return compatdata; std::stringstream buffer; for (Module::LinkData::const_iterator iter = data.begin(); iter != data.end(); ++iter) { if (iter != data.begin()) buffer << '&'; buffer << iter->first << '=' << Percent::Encode(iter->second); } return buffer.str(); } void SpanningTreeUtilities::SendListLimits(Channel* chan, TreeSocket* sock) { std::stringstream buffer; for (auto* lm : ServerInstance->Modes.GetListModes()) buffer << lm->GetModeChar() << " " << lm->GetLimit(chan) << " "; std::string bufferstr = buffer.str(); if (bufferstr.empty()) return; // Should never happen. bufferstr.pop_back(); if (sock) sock->WriteLine(CommandMetadata::Builder(chan, "maxlist", bufferstr)); else CommandMetadata::Builder(chan, "maxlist", bufferstr).Broadcast(); } ����������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/src/modules/m_spanningtree/utils.h���������������������������������������������������0000664�0000000�0000000�00000013301�14771603147�0022126�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2021 Dominic Hamon * Copyright (C) 2013, 2017-2018, 2020-2023 Sadie Powell <sadie@witchery.services> * Copyright (C) 2012-2013, 2015-2016 Attila Molnar <attilamolnar@hush.com> * Copyright (C) 2012 Robby <robby@chatbelgie.be> * Copyright (C) 2009 Daniel De Graaf <danieldg@inspircd.org> * Copyright (C) 2008 Robin Burchell <robin+git@viroteck.net> * Copyright (C) 2007-2008 Dennis Friis <peavey@inspircd.org> * Copyright (C) 2007 Craig Edwards <brain@inspircd.org> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #pragma once #include "inspircd.h" #include "cachetimer.h" class TreeServer; class TreeSocket; class Link; class Autoconnect; class ModuleSpanningTree; class SpanningTreeUtilities; class CmdBuilder; extern SpanningTreeUtilities* Utils; /** Associative container type, mapping server names/ids to TreeServers */ typedef std::unordered_map<std::string, TreeServer*, irc::insensitive, irc::StrHashComp> server_hash; /** Contains helper functions and variables for this module, * and keeps them out of the global namespace */ class SpanningTreeUtilities final : public Cullable { CacheRefreshTimer RefreshTimer; public: typedef std::set<TreeSocket*> TreeSocketSet; typedef std::map<TreeSocket*, std::pair<std::string, unsigned int>> TimeoutList; /** Creator module */ ModuleSpanningTree* Creator; /** Flatten links and /MAP for non-opers */ bool FlatLinks; /** True if we're going to hide netsplits as *.net *.split for non-opers */ bool HideSplits; /** Hide U-Lined servers in /MAP and /LINKS */ bool HideServices; /** Announce TS changes to channels on merge */ bool AnnounceTSChange; /** Allow modules marked as VF_OPTCOMMON to be mismatched when linking */ bool AllowOptCommon; /** Make snomasks +CQ quiet during bursts and splits */ bool quiet_bursts; /* Number of seconds that a server can go without ping * before opers are warned of high latency. */ unsigned long PingWarnTime; /** This variable represents the root of the server tree */ TreeServer* TreeRoot = nullptr; /** IPs allowed to link to us */ std::vector<std::string> ValidIPs; /** Hash of currently connected servers by name */ server_hash serverlist; /** Hash of currently known server ids */ server_hash sidlist; /** List of all outgoing sockets and their timeouts */ TimeoutList timeoutlist; /** Holds the data from the <link> tags in the conf */ std::vector<std::shared_ptr<Link>> LinkBlocks; /** Holds the data from the <autoconnect> tags in the conf */ std::vector<std::shared_ptr<Autoconnect>> AutoconnectBlocks; /** Ping frequency of server to server links */ unsigned long PingFreq = 60; /** Initialise utility class */ SpanningTreeUtilities(ModuleSpanningTree* Creator); /** Prepare for class destruction */ Cullable::Result Cull() override; /** Destroy class and free listeners etc */ ~SpanningTreeUtilities() override; void RouteCommand(TreeServer* origin, CommandBase* cmd, const CommandBase::Params& parameters, User* user); /** Send a message from this server to one other local or remote */ static void DoOneToOne(const CmdBuilder& params, const Server* target); /** Send a message from this server to all but one other, local or remote */ void DoOneToAllButSender(const CmdBuilder& params, const TreeServer* omit) const; /** Read the spanningtree module's tags from the config file */ void ReadConfiguration(); /** Handle nick collision */ static bool DoCollision(User* u, TreeServer* server, time_t remotets, const std::string& remoteuser, const std::string& remoteip, const std::string& remoteuid, const char* collidecmd); /** Compile a list of servers which contain members of channel c */ void GetListOfServersForChannel(const Channel* c, TreeSocketSet& list, char status, const CUList& exempt_list) const; /** Find a server by name or SID */ TreeServer* FindServer(const std::string& ServerName); /** Find server by SID */ TreeServer* FindServerID(const std::string& id); /** Find a server based on a target string. * @param target Target string where a command should be routed to. May be a server name, a sid, a nickname or a uuid. */ TreeServer* FindRouteTarget(const std::string& target); /** Find a server by glob mask */ TreeServer* FindServerMask(const std::string& ServerName); /** Find a link tag from a server name */ std::shared_ptr<Link> FindLink(const std::string& name); /** Refresh the IP cache used for allowing inbound connections */ void RefreshIPCache(); /** Sends a PRIVMSG or a NOTICE to a channel obeying an exempt list and an optional prefix */ void SendChannelMessage(const User* source, const Channel* target, const std::string& text, char status, const ClientProtocol::TagMap& tags, const CUList& exempt_list, const char* message_type, const TreeSocket* omit = nullptr) const; // Builds link data to be sent to another server. static std::string BuildLinkString(uint16_t protocol, Module* mod); /** Send the channel list mode limits to either the specified server or all servers if nullptr. */ static void SendListLimits(Channel* chan, TreeSocket* sock = nullptr); }; �������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/src/modules/m_sqlauth.cpp������������������������������������������������������������0000664�0000000�0000000�00000015452�14771603147�0020316�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2015 Daniel Vassdal <shutter@canternet.org> * Copyright (C) 2014-2015 Attila Molnar <attilamolnar@hush.com> * Copyright (C) 2013, 2017-2023 Sadie Powell <sadie@witchery.services> * Copyright (C) 2012 Robby <robby@chatbelgie.be> * Copyright (C) 2009-2010 Daniel De Graaf <danieldg@inspircd.org> * Copyright (C) 2007-2008 Craig Edwards <brain@inspircd.org> * Copyright (C) 2007 Robin Burchell <robin+git@viroteck.net> * Copyright (C) 2007 Dennis Friis <peavey@inspircd.org> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include "inspircd.h" #include "extension.h" #include "modules/sql.h" #include "modules/hash.h" #include "modules/ssl.h" enum AuthState { AUTH_STATE_NONE = 0, AUTH_STATE_BUSY = 1, AUTH_STATE_FAIL = 2 }; class AuthQuery final : public SQL::Query { public: const std::string uid; IntExtItem& pendingExt; bool verbose; const std::string& kdf; const std::string& pwcolumn; AuthQuery(Module* me, const std::string& u, IntExtItem& e, bool v, const std::string& kd, const std::string& pwcol) : SQL::Query(me) , uid(u) , pendingExt(e) , verbose(v) , kdf(kd) , pwcolumn(pwcol) { } void OnResult(SQL::Result& res) override { LocalUser* user = ServerInstance->Users.FindUUID<LocalUser>(uid); if (!user) return; if (res.Rows()) { if (!kdf.empty()) { HashProvider* hashprov = ServerInstance->Modules.FindDataService<HashProvider>("hash/" + kdf); if (!hashprov) { if (verbose) ServerInstance->SNO.WriteGlobalSno('a', "Forbidden connection from {} (a provider for {} was not loaded)", user->GetRealMask(), kdf); pendingExt.Set(user, AUTH_STATE_FAIL); return; } size_t colindex = 0; if (!pwcolumn.empty() && !res.HasColumn(pwcolumn, colindex)) { if (verbose) ServerInstance->SNO.WriteGlobalSno('a', "Forbidden connection from {} (the column specified ({}) was not returned)", user->GetRealMask(), pwcolumn); pendingExt.Set(user, AUTH_STATE_FAIL); return; } SQL::Row row; while (res.GetRow(row)) { if (row[colindex].has_value() && hashprov->Compare(user->password, *row[colindex])) { pendingExt.Set(user, AUTH_STATE_NONE); return; } } if (verbose) ServerInstance->SNO.WriteGlobalSno('a', "Forbidden connection from {} (password from the SQL query did not match the user provided password)", user->GetRealMask()); pendingExt.Set(user, AUTH_STATE_FAIL); return; } pendingExt.Set(user, AUTH_STATE_NONE); } else { if (verbose) ServerInstance->SNO.WriteGlobalSno('a', "Forbidden connection from {} (SQL query returned no matches)", user->GetRealMask()); pendingExt.Set(user, AUTH_STATE_FAIL); } } void OnError(const SQL::Error& error) override { auto* user = ServerInstance->Users.Find(uid); if (!user) return; pendingExt.Set(user, AUTH_STATE_FAIL); if (verbose) ServerInstance->SNO.WriteGlobalSno('a', "Forbidden connection from {} (SQL query failed: {})", user->GetRealMask(), error.ToString()); } }; class ModuleSQLAuth final : public Module { IntExtItem pendingExt; dynamic_reference<SQL::Provider> SQL; UserCertificateAPI sslapi; std::string freeformquery; std::string killreason; std::vector<std::string> exemptions; bool verbose; std::vector<std::string> hash_algos; std::string kdf; std::string pwcolumn; public: ModuleSQLAuth() : Module(VF_VENDOR, "Allows connecting users to be authenticated against an arbitrary SQL table.") , pendingExt(this, "sqlauth-wait", ExtensionType::USER) , SQL(this, "SQL") , sslapi(this) { } void ReadConfig(ConfigStatus& status) override { const auto& conf = ServerInstance->Config->ConfValue("sqlauth"); std::string dbid = conf->getString("dbid"); if (dbid.empty()) SQL.SetProvider("SQL"); else SQL.SetProvider("SQL/" + dbid); freeformquery = conf->getString("query"); killreason = conf->getString("killreason"); verbose = conf->getBool("verbose"); kdf = conf->getString("kdf"); pwcolumn = conf->getString("column"); exemptions.clear(); for (const auto& [_, etag] : ServerInstance->Config->ConfTags("sqlexemption")) { const std::string mask = etag->getString("mask"); if (!mask.empty()) exemptions.push_back(mask); } // Begin v3 config compatibility. const std::string allowpattern = conf->getString("allowpattern"); if (!allowpattern.empty()) exemptions.push_back(allowpattern + "!*@*"); // End v3 config compatibility. hash_algos.clear(); irc::commasepstream algos(conf->getString("hash", "md5,sha256")); std::string algo; while (algos.GetToken(algo)) hash_algos.push_back(algo); } ModResult OnUserRegister(LocalUser* user) override { // Note this is their initial (unresolved) connect block if (!user->GetClass()->config->getBool("usesqlauth", true)) return MOD_RES_PASSTHRU; for (const auto& exemption : exemptions) { if (InspIRCd::MatchCIDR(user->GetRealMask(), exemption) || InspIRCd::MatchCIDR(user->GetMask(), exemption)) return MOD_RES_PASSTHRU; } if (pendingExt.Get(user)) return MOD_RES_PASSTHRU; if (!SQL) { ServerInstance->SNO.WriteGlobalSno('a', "Forbidden connection from {} (SQL database not present)", user->GetRealMask()); ServerInstance->Users.QuitUser(user, killreason); return MOD_RES_PASSTHRU; } pendingExt.Set(user, AUTH_STATE_BUSY); SQL::ParamMap userinfo; SQL::PopulateUserInfo(user, userinfo); userinfo["pass"] = user->password; userinfo["sslfp"] = sslapi ? sslapi->GetFingerprint(user) : ""; for (const auto& algo : hash_algos) { HashProvider* hashprov = ServerInstance->Modules.FindDataService<HashProvider>("hash/" + algo); if (hashprov && !hashprov->IsKDF()) userinfo[algo + "pass"] = hashprov->Generate(user->password); } SQL->Submit(new AuthQuery(this, user->uuid, pendingExt, verbose, kdf, pwcolumn), freeformquery, userinfo); return MOD_RES_PASSTHRU; } ModResult OnCheckReady(LocalUser* user) override { switch (pendingExt.Get(user)) { case AUTH_STATE_NONE: return MOD_RES_PASSTHRU; case AUTH_STATE_BUSY: return MOD_RES_DENY; case AUTH_STATE_FAIL: ServerInstance->Users.QuitUser(user, killreason); return MOD_RES_DENY; } return MOD_RES_PASSTHRU; } }; MODULE_INIT(ModuleSQLAuth) ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/src/modules/m_sqloper.cpp������������������������������������������������������������0000664�0000000�0000000�00000017104�14771603147�0020316�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2019 B00mX0r <b00mx0r@aureus.pw> * Copyright (C) 2018 Dylan Frank <b00mx0r@aureus.pw> * Copyright (C) 2014, 2018 Attila Molnar <attilamolnar@hush.com> * Copyright (C) 2013, 2017-2024 Sadie Powell <sadie@witchery.services> * Copyright (C) 2012 Robby <robby@chatbelgie.be> * Copyright (C) 2009-2010 Daniel De Graaf <danieldg@inspircd.org> * Copyright (C) 2009 Uli Schlachter <psychon@znc.in> * Copyright (C) 2007-2008 Dennis Friis <peavey@inspircd.org> * Copyright (C) 2006-2007 Craig Edwards <brain@inspircd.org> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include "inspircd.h" #include "modules/sql.h" class OperQuery final : public SQL::Query { public: // This variable will store all the OPER blocks from the DB std::vector<std::string>& my_blocks; /** We want to store the username and password if this is called during an /OPER, as we're responsible for /OPER post-DB fetch * Note: uid will be empty if this DB update was not called as a result of a user command (i.e. /REHASH) */ const std::string uid, username, password; OperQuery(Module* me, std::vector<std::string>& mb, const std::string& u, const std::string& un, const std::string& pw) : SQL::Query(me) , my_blocks(mb) , uid(u) , username(un) , password(pw) { } OperQuery(Module* me, std::vector<std::string>& mb) : SQL::Query(me) , my_blocks(mb) { } void OnResult(SQL::Result& res) override { // Remove our previous blocks from the core for a clean update for (const auto& block : my_blocks) ServerInstance->Config->OperAccounts.erase(block); my_blocks.clear(); SQL::Row row; // Iterate through DB results to create oper blocks from sqloper rows for (size_t rowidx = 1; res.GetRow(row); ++rowidx) { std::vector<std::string> cols; res.GetCols(cols); // Create the oper tag as if we were the conf file. auto tag = std::make_shared<ConfigTag>("oper", FilePosition("<" MODNAME ">" , rowidx, 0)); /** Iterate through each column in the SQLOpers table. An infinite number of fields can be specified. * Column 'x' with cell value 'y' will be the same as x=y in an OPER block in opers.conf. */ for (unsigned int i=0; i < cols.size(); ++i) { if (row[i].has_value()) tag->GetItems()[cols[i]] = *row[i]; } const std::string name = tag->getString("name"); // Skip both duplicate sqloper blocks and sqloper blocks that attempt to override conf blocks. if (ServerInstance->Config->OperAccounts.find(name) != ServerInstance->Config->OperAccounts.end()) continue; const std::string type = tag->getString("type"); auto tblk = ServerInstance->Config->OperTypes.find(type); if (tblk == ServerInstance->Config->OperTypes.end()) { ServerInstance->Logs.Warning(MODNAME, "Sqloper block " + name + " has missing type " + type); ServerInstance->SNO.WriteGlobalSno('a', "m_sqloper: Oper block {} has missing type {}", name, type); continue; } ServerInstance->Config->OperAccounts[name] = std::make_shared<OperAccount>(name, tblk->second, tag); my_blocks.push_back(name); row.clear(); } // If this was done as a result of /OPER and not a config read if (!uid.empty()) { // Now that we've updated the DB, call any other /OPER hooks and then call /OPER OperExec(); } } void OnError(const SQL::Error& error) override { ServerInstance->Logs.Warning(MODNAME, "query failed ({})", error.ToString()); ServerInstance->SNO.WriteGlobalSno('a', "m_sqloper: Failed to update blocks from database"); if (!uid.empty()) { // Fallback. We don't want to block a netadmin from /OPER OperExec(); } } // Call /oper after placing all blocks from the SQL table into the Config->OperAccounts list. void OperExec() { auto* user = ServerInstance->Users.Find<LocalUser>(uid); if (!user) return; // The user disconnected before the SQL query returned. Command* oper_command = ServerInstance->Parser.GetHandler("OPER"); if (oper_command) { CommandBase::Params params; params.push_back(username); params.push_back(password); // Begin callback to other modules (i.e. sslinfo) now that we completed the DB fetch ModResult modres; std::string origin = "OPER"; FIRST_MOD_RESULT(OnPreCommand, modres, (origin, params, user, true)); if (modres == MOD_RES_DENY) return; // Now handle /OPER. ClientProtocol::TagMap tags; oper_command->Handle(user, CommandBase::Params(params, tags)); } else { ServerInstance->Logs.Debug(MODNAME, "BUG: WHAT?! Why do we have no OPER command?!"); } } }; class ModuleSQLOper final : public Module { private: // Whether OperQuery is running bool active = false; std::string query; // Stores oper blocks from DB std::vector<std::string> my_blocks; dynamic_reference<SQL::Provider> SQL; public: ModuleSQLOper() : Module(VF_VENDOR, "Allows server operators to be authenticated against an SQL table.") , SQL(this, "SQL") { } void ReadConfig(ConfigStatus& status) override { // Clear list of our blocks, as ConfigReader just wiped them anyway my_blocks.clear(); const auto& tag = ServerInstance->Config->ConfValue("sqloper"); std::string dbid = tag->getString("dbid"); if (dbid.empty()) SQL.SetProvider("SQL"); else SQL.SetProvider("SQL/" + dbid); query = tag->getString("query", "SELECT * FROM ircd_opers WHERE active=1;", 1); // Update sqloper list from the database. GetOperBlocks(); } ~ModuleSQLOper() override { // Remove all oper blocks that were from the DB for (const auto& block : my_blocks) ServerInstance->Config->OperAccounts.erase(block); } ModResult OnPreCommand(std::string& command, CommandBase::Params& parameters, LocalUser* user, bool validated) override { // If we are not in the middle of an existing /OPER and someone is trying to oper-up if (validated && command == "OPER" && parameters.size() >= 2 && !active) { if (SQL) { GetOperBlocks(user->uuid, parameters[0], parameters[1]); /** We need to reload oper blocks from the DB before other * hooks can run (i.e. sslinfo). We will re-call /OPER later. */ return MOD_RES_DENY; } ServerInstance->Logs.Warning(MODNAME, "database not present"); } else if (active) { active = false; } // There is either no DB or we successfully reloaded oper blocks return MOD_RES_PASSTHRU; } // The one w/o params is for non-/OPER DB updates, such as a rehash. void GetOperBlocks() { SQL->Submit(new OperQuery(this, my_blocks), query); } void GetOperBlocks(const std::string& u, const std::string& un, const std::string& pw) { active = true; // Call to SQL query to fetch oper list from SQL table. SQL->Submit(new OperQuery(this, my_blocks, u, un, pw), query); } void Prioritize() override { /** Run before other /OPER hooks that expect populated blocks, i.e. sslinfo or a TOTP module. * We issue a DENY first, and will re-run OnPreCommand later to trigger the other hooks post-DB update. */ ServerInstance->Modules.SetPriority(this, I_OnPreCommand, PRIORITY_FIRST); } }; MODULE_INIT(ModuleSQLOper) ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/src/modules/m_sslinfo.cpp������������������������������������������������������������0000664�0000000�0000000�00000037455�14771603147�0020321�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2020 Matt Schatz <genius3000@g3k.solutions> * Copyright (C) 2019 linuxdaemon <linuxdaemon.irc@gmail.com> * Copyright (C) 2013, 2017-2025 Sadie Powell <sadie@witchery.services> * Copyright (C) 2013, 2015-2016 Attila Molnar <attilamolnar@hush.com> * Copyright (C) 2012 Robby <robby@chatbelgie.be> * Copyright (C) 2010 Adam <Adam@anope.org> * Copyright (C) 2009-2010 Daniel De Graaf <danieldg@inspircd.org> * Copyright (C) 2007 Dennis Friis <peavey@inspircd.org> * Copyright (C) 2006-2007, 2009 Craig Edwards <brain@inspircd.org> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include "inspircd.h" #include "extension.h" #include "modules/ssl.h" #include "modules/stats.h" #include "modules/webirc.h" #include "modules/who.h" #include "modules/whois.h" #include "numerichelper.h" #include "timeutils.h" class SSLCertExt final : public ExtensionItem { public: SSLCertExt(Module* parent) : ExtensionItem(parent, "ssl_cert", ExtensionType::USER) { } ssl_cert* Get(const User* user) const { return static_cast<ssl_cert*>(GetRaw(user)); } void Set(User* user, ssl_cert* value, bool sync = true) { value->refcount_inc(); ssl_cert* old = static_cast<ssl_cert*>(SetRaw(user, value)); if (old && old->refcount_dec()) delete old; if (sync) Sync(user, value); } void Unset(User* user) { Delete(user, UnsetRaw(user)); } std::string ToInternal(const Extensible* container, void* item) const noexcept override { return ToNetwork(container, item); } std::string ToNetwork(const Extensible* container, void* item) const noexcept override { const ssl_cert* cert = static_cast<ssl_cert*>(item); std::stringstream value; value << (cert->IsInvalid() ? "v" : "V") << (cert->IsTrusted() ? "T" : "t") << (cert->IsRevoked() ? "R" : "r") << (cert->IsUnknownSigner() ? "s" : "S") << (cert->GetError().empty() ? "e" : "E") << " "; if (cert->GetError().empty()) value << insp::join(cert->GetFingerprints(), ',') << " " << cert->GetDN() << " " << cert->GetIssuer(); else value << cert->GetError(); return value.str(); } void FromInternal(Extensible* container, const std::string& value) noexcept override { FromNetwork(container, value); } void FromNetwork(Extensible* container, const std::string& value) noexcept override { if (container->extype != this->extype) return; auto* cert = new ssl_cert(); Set(static_cast<User*>(container), cert, false); std::stringstream s(value); std::string v; getline(s, v, ' '); cert->invalid = (v.find('v') != std::string::npos); cert->trusted = (v.find('T') != std::string::npos); cert->revoked = (v.find('R') != std::string::npos); cert->unknownsigner = (v.find('s') != std::string::npos); if (v.find('E') != std::string::npos) { getline(s, cert->error, '\n'); } else { std::string fingerprints; getline(s, fingerprints, ' '); irc::commasepstream fingerprintstream(fingerprints); for (std::string fingerprint; fingerprintstream.GetToken(fingerprint); ) cert->fingerprints.push_back(fingerprint); getline(s, cert->dn, ' '); getline(s, cert->issuer, '\n'); } } void Delete(Extensible* container, void* item) override { ssl_cert* old = static_cast<ssl_cert*>(item); if (old && old->refcount_dec()) delete old; } }; class UserCertificateAPIImpl final : public UserCertificateAPIBase { public: BoolExtItem nosslext; SSLCertExt sslext; bool localsecure; UserCertificateAPIImpl(Module* mod) : UserCertificateAPIBase(mod) , nosslext(mod, "no-ssl-cert", ExtensionType::USER) , sslext(mod) { } ssl_cert* GetCertificate(User* user) override { ssl_cert* cert = sslext.Get(user); if (cert) return cert; LocalUser* luser = IS_LOCAL(user); if (!luser || nosslext.Get(luser)) return nullptr; cert = SSLClientCert::GetCertificate(&luser->eh); if (!cert) return nullptr; SetCertificate(user, cert); return cert; } bool IsSecure(User* user) override { auto* cert = GetCertificate(user); if (cert) return !!cert; if (localsecure) return user->client_sa.is_local(); return false; } void SetCertificate(User* user, ssl_cert* cert) override { ServerInstance->Logs.Debug(MODNAME, "Setting TLS client certificate for {}: {}", user->GetMask(), sslext.ToNetwork(user, cert)); sslext.Set(user, cert); } }; class CommandSSLInfo final : public SplitCommand { private: ChanModeReference sslonlymode; void HandleUserInternal(LocalUser* source, User* target, bool verbose) { ssl_cert* cert = sslapi.GetCertificate(target); if (!cert) { source->WriteNotice("*** {} is not connected using TLS.", target->nick); } else if (cert->GetError().length()) { source->WriteNotice("*** {} is connected using TLS but has not specified a valid client certificate ({}).", target->nick, cert->GetError()); } else if (!verbose) { source->WriteNotice("*** {} is connected using TLS with a valid client certificate ({}).", target->nick, cert->GetFingerprint()); } else { source->WriteNotice("*** Distinguished Name: " + cert->GetDN()); source->WriteNotice("*** Issuer: " + cert->GetIssuer()); for (const auto& fingerprint : cert->GetFingerprints()) source->WriteNotice("*** Key Fingerprint: " + fingerprint); } } CmdResult HandleUser(LocalUser* source, const std::string& nick) { auto* target = ServerInstance->Users.FindNick(nick, true); if (!target) { source->WriteNumeric(Numerics::NoSuchNick(nick)); return CmdResult::FAILURE; } if (operonlyfp && !source->IsOper() && source != target) { source->WriteNumeric(ERR_NOPRIVILEGES, "You must be a server operator to view TLS client certificate information for other users."); return CmdResult::FAILURE; } HandleUserInternal(source, target, true); return CmdResult::SUCCESS; } CmdResult HandleChannel(LocalUser* source, const std::string& channel) { auto* chan = ServerInstance->Channels.Find(channel); if (!chan) { source->WriteNumeric(Numerics::NoSuchChannel(channel)); return CmdResult::FAILURE; } if (operonlyfp && !source->IsOper()) { source->WriteNumeric(ERR_NOPRIVILEGES, "You must be a server operator to view TLS client certificate information for channels."); return CmdResult::FAILURE; } if (!source->IsOper() && chan->GetPrefixValue(source) < OP_VALUE) { source->WriteNumeric(Numerics::ChannelPrivilegesNeeded(chan, OP_VALUE, "view TLS client certificate information")); return CmdResult::FAILURE; } if (sslonlymode) { source->WriteNotice("*** {} {} have channel mode +{} ({}) set.", chan->name, chan->IsModeSet(sslonlymode) ? "does" : "does not", sslonlymode->GetModeChar(), sslonlymode->name); } for (const auto& [u, _] : chan->GetUsers()) { if (!u->server->IsService()) HandleUserInternal(source, u, false); } return CmdResult::SUCCESS; } public: UserCertificateAPIImpl sslapi; bool operonlyfp; CommandSSLInfo(Module* Creator) : SplitCommand(Creator, "SSLINFO") , sslonlymode(Creator, "sslonly") , sslapi(Creator) { syntax = { "[<channel|nick>]" }; } CmdResult HandleLocal(LocalUser* user, const Params& parameters) override { if (parameters.empty()) { HandleUserInternal(user, user, true); return CmdResult::SUCCESS; } if (ServerInstance->Channels.IsPrefix(parameters[0][0])) return HandleChannel(user, parameters[0]); return HandleUser(user, parameters[0]); } }; class ModuleSSLInfo final : public Module , public Stats::EventListener , public WebIRC::EventListener , public Who::EventListener , public Whois::EventListener { private: CommandSSLInfo cmd; std::vector<std::string> hashes; unsigned long warnexpiring; bool welcomemsg; static bool MatchFingerprint(const ssl_cert* cert, const std::string& fp) { irc::spacesepstream configfpstream(fp); for (std::string configfp; configfpstream.GetToken(configfp); ) { for (const auto& certfp : cert->GetFingerprints()) { if (InspIRCd::TimingSafeCompare(certfp, configfp)) return true; } } return false; } public: ModuleSSLInfo() : Module(VF_VENDOR, "Adds user facing TLS information, various TLS configuration options, and the /SSLINFO command to look up TLS certificate information for other users.") , Stats::EventListener(this) , WebIRC::EventListener(this) , Who::EventListener(this) , Whois::EventListener(this) , cmd(this) { } void ReadConfig(ConfigStatus& status) override { const auto& tag = ServerInstance->Config->ConfValue("sslinfo"); cmd.operonlyfp = tag->getBool("operonly"); cmd.sslapi.localsecure = tag->getBool("localsecure", true); warnexpiring = tag->getDuration("warnexpiring", 0, 0, 60*60*24*365); welcomemsg = tag->getBool("welcomemsg"); hashes.clear(); irc::spacesepstream hashstream(tag->getString("hash")); for (std::string hash; hashstream.GetToken(hash); ) { if (!hash.compare(0, 5, "spki-", 5)) hash.insert(4, "fp"); // spki-foo => spkifp-foo else hash.insert(0, "certfp-"); // foo => certfp-foo hashes.push_back(hash); } } void OnWhois(Whois::Context& whois) override { if (cmd.sslapi.IsSecure(whois.GetTarget())) whois.SendLine(RPL_WHOISSECURE, "is using a secure connection"); ssl_cert* cert = cmd.sslapi.GetCertificate(whois.GetTarget()); if (cert) { if (!cmd.operonlyfp || whois.IsSelfWhois() || whois.GetSource()->IsOper()) { bool first = true; for (const auto& fingerprint : cert->GetFingerprints()) { whois.SendLine(RPL_WHOISCERTFP, INSP_FORMAT("has {}client certificate fingerprint {}", first ? "" : "old ", fingerprint)); first = false; } } } } ModResult OnWhoLine(const Who::Request& request, LocalUser* source, User* user, Membership* memb, Numeric::Numeric& numeric) override { size_t flag_index; if (!request.GetFieldIndex('f', flag_index)) return MOD_RES_PASSTHRU; ssl_cert* cert = cmd.sslapi.GetCertificate(user); if (cert) numeric.GetParams()[flag_index].push_back('s'); return MOD_RES_PASSTHRU; } ModResult OnPreOperLogin(LocalUser* user, const std::shared_ptr<OperAccount>& oper, bool automatic) override { auto* cert = cmd.sslapi.GetCertificate(user); if (oper->GetConfig()->getBool("sslonly") && !cert) { if (!automatic) { ServerInstance->SNO.WriteGlobalSno('o', "{} ({}) [{}] failed to log into the \x02{}\x02 oper account because they are not connected using TLS.", user->nick, user->GetRealUserHost(), user->GetAddress(), oper->GetName()); } return MOD_RES_DENY; } const std::string fingerprint = oper->GetConfig()->getString("fingerprint"); if (!fingerprint.empty() && (!cert || !MatchFingerprint(cert, fingerprint))) { if (!automatic) { ServerInstance->SNO.WriteGlobalSno('o', "{} ({}) [{}] failed to log into the \x02{}\x02 oper account because they are not using the correct TLS client certificate.", user->nick, user->GetRealUserHost(), user->GetAddress(), oper->GetName()); } return MOD_RES_DENY; } return MOD_RES_PASSTHRU; } void OnPostConnect(User* user) override { LocalUser* const localuser = IS_LOCAL(user); if (!localuser) return; const SSLIOHook* const ssliohook = SSLIOHook::IsSSL(&localuser->eh); if (!ssliohook || cmd.sslapi.nosslext.Get(localuser)) return; ssl_cert* const cert = ssliohook->GetCertificate(); if (welcomemsg) { std::string text = "*** You are connected to "; if (!ssliohook->GetServerName(text)) text.append(ServerInstance->Config->GetServerName()); text.append(" using TLS cipher '"); ssliohook->GetCiphersuite(text); text.push_back('\''); if (cert && !cert->GetFingerprint().empty()) text.append(" and your TLS client certificate fingerprint is ").append(cert->GetFingerprint()); user->WriteNotice(text); } if (!cert || !warnexpiring || !cert->GetExpirationTime()) return; if (ServerInstance->Time() > cert->GetExpirationTime()) { user->WriteNotice("*** Your TLS client certificate has expired."); } else if (static_cast<time_t>(ServerInstance->Time() + warnexpiring) > cert->GetExpirationTime()) { const std::string duration = Duration::ToLongString(cert->GetExpirationTime() - ServerInstance->Time()); user->WriteNotice("*** Your TLS client certificate expires in " + duration + "."); } } ModResult OnPreChangeConnectClass(LocalUser* user, const std::shared_ptr<ConnectClass>& klass, std::optional<Numeric::Numeric>& errnum) override { ssl_cert* cert = cmd.sslapi.GetCertificate(user); const char* error = nullptr; const std::string requiressl = klass->config->getString("requiressl"); if (insp::equalsci(requiressl, "trusted")) { if (!cert || !cert->IsCAVerified()) error = "a trusted TLS client certificate"; } else if (klass->config->getBool("requiressl")) { if (!cert) error = "a TLS connection"; } if (error) { ServerInstance->Logs.Debug("CONNECTCLASS", "The {} connect class is not suitable as it requires {}.", klass->GetName(), error); return MOD_RES_DENY; } return MOD_RES_PASSTHRU; } ModResult OnStats(Stats::Context& stats) override { if (stats.GetSymbol() != 't') return MOD_RES_PASSTHRU; // Counter for the number of users using each ciphersuite. std::map<std::string, size_t> counts; auto& plaintext = counts["Plain text"]; auto& unknown = counts["Unknown"]; for (auto* user : ServerInstance->Users.GetLocalUsers()) { const auto* ssliohook = SSLIOHook::IsSSL(&user->eh); if (!ssliohook) { plaintext++; continue; } std::string ciphersuite; ssliohook->GetCiphersuite(ciphersuite); if (ciphersuite.empty()) unknown++; else counts[ciphersuite]++; } for (const auto& [ciphersuite, count] : counts) { if (!count) continue; stats.AddGenericRow(INSP_FORMAT("{}: {}", ciphersuite, count)) .AddTags(stats, { { "ciphersuite", ciphersuite }, { "count", ConvToStr(count) }, }); } return MOD_RES_DENY; } void OnWebIRCAuth(LocalUser* user, const WebIRC::FlagMap* flags) override { // We are only interested in connection flags. If none have been // given then we have nothing to do. if (!flags) return; // We only care about the tls connection flag if the connection // between the gateway and the server is secure. if (!cmd.sslapi.GetCertificate(user)) return; WebIRC::FlagMap::const_iterator iter = flags->find("secure"); if (iter == flags->end()) { // If this is not set then the connection between the client and // the gateway is not secure. cmd.sslapi.nosslext.Set(user); cmd.sslapi.sslext.Unset(user); return; } // Create a fake ssl_cert for the user. auto* cert = new ssl_cert(); cert->dn = "(unknown)"; cert->invalid = false; cert->issuer = "(unknown)"; cert->trusted = true; cert->unknownsigner = false; for (const auto& hash : hashes) { iter = flags->find(hash); if (iter != flags->end() && !iter->second.empty()) { // If the gateway specifies this flag we put all trust onto them // for having validated the client certificate. This is probably // ill-advised but there's not much else we can do. cert->fingerprints.push_back(iter->second); } } if (cert->GetFingerprints().empty()) { cert->error = "WebIRC gateway did not send a client fingerprint"; cert->revoked = true; } cmd.sslapi.SetCertificate(user, cert); } }; MODULE_INIT(ModuleSSLInfo) �������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/src/modules/m_sslmodes.cpp�����������������������������������������������������������0000664�0000000�0000000�00000014442�14771603147�0020464�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2013, 2017-2024 Sadie Powell <sadie@witchery.services> * Copyright (C) 2013 Shawn Smith <ShawnSmith0828@gmail.com> * Copyright (C) 2012-2013 Attila Molnar <attilamolnar@hush.com> * Copyright (C) 2012 Robby <robby@chatbelgie.be> * Copyright (C) 2009-2010 Daniel De Graaf <danieldg@inspircd.org> * Copyright (C) 2009 Uli Schlachter <psychon@znc.in> * Copyright (C) 2008 Robin Burchell <robin+git@viroteck.net> * Copyright (C) 2007 Dennis Friis <peavey@inspircd.org> * Copyright (C) 2006-2007 Craig Edwards <brain@inspircd.org> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include "inspircd.h" #include "modules/callerid.h" #include "modules/ctctags.h" #include "modules/extban.h" #include "modules/ssl.h" #include "numerichelper.h" enum { // From UnrealIRCd. ERR_SECUREONLYCHAN = 489, // InspIRCd-specific. ERR_ALLMUSTSSL = 490 }; class FingerprintExtBan final : public ExtBan::MatchingBase { private: UserCertificateAPI& sslapi; public: FingerprintExtBan(Module* Creator, UserCertificateAPI& api) : ExtBan::MatchingBase(Creator, "fingerprint", 'z') , sslapi(api) { } bool IsMatch(User* user, Channel* channel, const std::string& text) override { if (!sslapi) return false; for (const auto& fingerprint : sslapi->GetFingerprints(user)) { if (InspIRCd::Match(fingerprint, text)) return true; } return false; } }; /** Handle channel mode +z */ class SSLMode final : public ModeHandler { private: UserCertificateAPI& API; public: SSLMode(Module* Creator, UserCertificateAPI& api) : ModeHandler(Creator, "sslonly", 'z', PARAM_NONE, MODETYPE_CHANNEL) , API(api) { } bool OnModeChange(User* source, User* dest, Channel* channel, Modes::Change& change) override { if (change.adding) { if (!channel->IsModeSet(this)) { if (IS_LOCAL(source)) { if (!API) { source->WriteNumeric(ERR_ALLMUSTSSL, channel->name, "Unable to determine whether all members of the channel are connected via TLS"); return false; } size_t nonssl = 0; for (const auto& [u, _] : channel->GetUsers()) { if (!API->IsSecure(u) && !u->server->IsService()) nonssl++; } if (nonssl) { source->WriteNumeric(ERR_ALLMUSTSSL, channel->name, INSP_FORMAT("All members of the channel must be connected via TLS ({}/{} are non-TLS)", nonssl, channel->GetUsers().size())); return false; } } channel->SetMode(this, true); return true; } else { return false; } } else { if (channel->IsModeSet(this)) { channel->SetMode(this, false); return true; } return false; } } }; /** Handle user mode +z */ class SSLModeUser final : public ModeHandler { private: UserCertificateAPI& API; public: SSLModeUser(Module* Creator, UserCertificateAPI& api) : ModeHandler(Creator, "sslqueries", 'z', PARAM_NONE, MODETYPE_USER) , API(api) { } bool OnModeChange(User* user, User* dest, Channel* channel, Modes::Change& change) override { if (change.adding == dest->IsModeSet(this)) return false; if (change.adding && IS_LOCAL(user) && (!API || !API->IsSecure(user))) return false; dest->SetMode(this, change.adding); return true; } }; class ModuleSSLModes final : public Module , public CTCTags::EventListener { private: UserCertificateAPI api; CallerID::API calleridapi; SSLMode sslm; SSLModeUser sslquery; FingerprintExtBan extban; public: ModuleSSLModes() : Module(VF_VENDOR, "Adds channel mode z (sslonly) which prevents users who are not connecting using TLS from joining the channel and user mode z (sslqueries) to prevent messages from non-TLS users.") , CTCTags::EventListener(this) , api(this) , calleridapi(this) , sslm(this, api) , sslquery(this, api) , extban(this, api) { } ModResult OnUserPreJoin(LocalUser* user, Channel* chan, const std::string& cname, std::string& privs, const std::string& keygiven, bool override) override { if (!override && chan && chan->IsModeSet(sslm)) { if (!api) { user->WriteNumeric(ERR_SECUREONLYCHAN, cname, INSP_FORMAT("Cannot join channel; unable to determine if you are a TLS user (+{} is set)", sslm.GetModeChar())); return MOD_RES_DENY; } if (!api->IsSecure(user)) { user->WriteNumeric(ERR_SECUREONLYCHAN, cname, INSP_FORMAT("Cannot join channel; TLS users only (+{} is set)", sslm.GetModeChar())); return MOD_RES_DENY; } } return MOD_RES_PASSTHRU; } ModResult HandleMessage(User* user, const MessageTarget& msgtarget) { if (msgtarget.type != MessageTarget::TYPE_USER) return MOD_RES_PASSTHRU; auto* target = msgtarget.Get<User>(); /* If one or more of the parties involved is a services user, we won't stop it. */ if (user->server->IsService() || target->server->IsService()) return MOD_RES_PASSTHRU; /* If the target is +z */ if (target->IsModeSet(sslquery)) { if (!api || !api->IsSecure(user) || (calleridapi && !calleridapi->IsOnAcceptList(user, target))) { /* The sending user is not on an TLS connection */ user->WriteNumeric(Numerics::CannotSendTo(target, "messages", &sslquery)); return MOD_RES_DENY; } } /* If the user is +z */ else if (user->IsModeSet(sslquery)) { if (!api || !api->IsSecure(target)) { user->WriteNumeric(Numerics::CannotSendTo(target, "messages", &sslquery, true)); return MOD_RES_DENY; } } return MOD_RES_PASSTHRU; } ModResult OnUserPreMessage(User* user, MessageTarget& target, MessageDetails& details) override { return HandleMessage(user, target); } ModResult OnUserPreTagMessage(User* user, MessageTarget& target, CTCTags::TagMessageDetails& details) override { return HandleMessage(user, target); } }; MODULE_INIT(ModuleSSLModes) ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/src/modules/m_starttls.cpp�����������������������������������������������������������0000664�0000000�0000000�00000006540�14771603147�0020513�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2019-2023 Sadie Powell <sadie@witchery.services> * Copyright (C) 2014 Adam <Adam@anope.org> * Copyright (C) 2013, 2016 Attila Molnar <attilamolnar@hush.com> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include "inspircd.h" #include "modules/ssl.h" #include "modules/cap.h" // From IRCv3 tls-3.1 enum { RPL_STARTTLS = 670, ERR_STARTTLS = 691 }; class CommandStartTLS final : public SplitCommand { dynamic_reference_nocheck<IOHookProvider>& ssl; public: CommandStartTLS(Module* mod, dynamic_reference_nocheck<IOHookProvider>& s) : SplitCommand(mod, "STARTTLS") , ssl(s) { works_before_reg = true; } CmdResult HandleLocal(LocalUser* user, const Params& parameters) override { if (!ssl) { user->WriteNumeric(ERR_STARTTLS, "STARTTLS is not enabled"); return CmdResult::FAILURE; } if (user->IsFullyConnected()) { user->WriteNumeric(ERR_STARTTLS, "STARTTLS is not permitted once you are fully connected"); return CmdResult::FAILURE; } if (user->eh.GetIOHook()) { user->WriteNumeric(ERR_STARTTLS, "STARTTLS failure"); return CmdResult::FAILURE; } user->WriteNumeric(RPL_STARTTLS, "STARTTLS successful, go ahead with TLS handshake"); /* We need to flush the write buffer prior to adding the IOHook, * otherwise we'll be sending this line inside the TLS session - which * won't start its handshake until the client gets this line. Currently, * we assume the write will not block here; this is usually safe, as * STARTTLS is sent very early on in the connection phase, where the * user hasn't built up much sendq. Handling a blocked write here would * be very annoying. */ user->eh.DoWrite(); ssl->OnAccept(&user->eh, user->client_sa, user->server_sa); return CmdResult::SUCCESS; } }; class TLSCap final : public Cap::Capability { private: dynamic_reference_nocheck<IOHookProvider>& sslref; bool OnList(LocalUser* user) override { return sslref; } bool OnRequest(LocalUser* user, bool adding) override { return sslref; } public: TLSCap(Module* mod, dynamic_reference_nocheck<IOHookProvider>& ssl) : Cap::Capability(mod, "tls") , sslref(ssl) { } }; class ModuleStartTLS final : public Module { private: CommandStartTLS starttls; TLSCap tls; dynamic_reference_nocheck<IOHookProvider> ssl; public: ModuleStartTLS() : Module(VF_VENDOR, "Provides the IRCv3 tls client capability.") , starttls(this, ssl) , tls(this, ssl) , ssl(this, "ssl") { } void ReadConfig(ConfigStatus& status) override { const auto& conf = ServerInstance->Config->ConfValue("starttls"); std::string newprovider = conf->getString("provider"); if (newprovider.empty()) ssl.SetProvider("ssl"); else ssl.SetProvider("ssl/" + newprovider); } }; MODULE_INIT(ModuleStartTLS) ����������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/src/modules/m_stripcolor.cpp���������������������������������������������������������0000664�0000000�0000000�00000005446�14771603147�0021037�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2019 linuxdaemon <linuxdaemon.irc@gmail.com> * Copyright (C) 2017, 2019-2021, 2023-2024 Sadie Powell <sadie@witchery.services> * Copyright (C) 2016 0x277F <0x277F@gmail.com> * Copyright (C) 2013 Attila Molnar <attilamolnar@hush.com> * Copyright (C) 2012 Robby <robby@chatbelgie.be> * Copyright (C) 2009-2010 Daniel De Graaf <danieldg@inspircd.org> * Copyright (C) 2006 Craig Edwards <brain@inspircd.org> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include "inspircd.h" #include "modules/exemption.h" #include "modules/extban.h" class ModuleStripColor final : public Module { private: CheckExemption::EventProvider exemptionprov; ExtBan::Acting extban; SimpleChannelMode csc; SimpleUserMode usc; public: ModuleStripColor() : Module(VF_VENDOR, "Adds channel mode S (stripcolor) which allows channels to strip IRC formatting codes from messages.") , exemptionprov(this) , extban(this, "stripcolor", 'S') , csc(this, "stripcolor", 'S') , usc(this, "u_stripcolor", 'S') { } ModResult OnUserPreMessage(User* user, MessageTarget& target, MessageDetails& details) override { if (!IS_LOCAL(user)) return MOD_RES_PASSTHRU; bool active = false; switch (target.type) { case MessageTarget::TYPE_USER: { const auto* t = target.Get<User>(); active = t->IsModeSet(usc); break; } case MessageTarget::TYPE_CHANNEL: { auto* t = target.Get<Channel>(); ModResult res = exemptionprov.Check(user, t, "stripcolor"); if (res == MOD_RES_ALLOW) return MOD_RES_PASSTHRU; active = !extban.GetStatus(user, t).check(!t->IsModeSet(csc)); break; } case MessageTarget::TYPE_SERVER: break; } if (active) { InspIRCd::StripColor(details.text); } return MOD_RES_PASSTHRU; } void OnUserPart(Membership* memb, std::string& partmessage, CUList& except_list) override { User* user = memb->user; Channel* channel = memb->chan; if (!IS_LOCAL(user)) return; if (extban.GetStatus(user, channel).check(!user->IsModeSet(csc))) { ModResult res = exemptionprov.Check(user, channel, "stripcolor"); if (res != MOD_RES_ALLOW) InspIRCd::StripColor(partmessage); } } }; MODULE_INIT(ModuleStripColor) ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/src/modules/m_swhois.cpp�������������������������������������������������������������0000664�0000000�0000000�00000010742�14771603147�0020146�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2017-2023 Sadie Powell <sadie@witchery.services> * Copyright (C) 2012, 2015-2016 Attila Molnar <attilamolnar@hush.com> * Copyright (C) 2012 Robby <robby@chatbelgie.be> * Copyright (C) 2009 Daniel De Graaf <danieldg@inspircd.org> * Copyright (C) 2008 Robin Burchell <robin+git@viroteck.net> * Copyright (C) 2007 Dennis Friis <peavey@inspircd.org> * Copyright (C) 2006 Oliver Lupton <om@inspircd.org> * Copyright (C) 2005, 2007 Craig Edwards <brain@inspircd.org> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include "inspircd.h" #include "extension.h" #include "modules/whois.h" #include "numerichelper.h" class CommandSwhois final : public Command { public: BoolExtItem operblock; StringExtItem swhois; CommandSwhois(Module* Creator) : Command(Creator, "SWHOIS", 2, 2) , operblock(Creator, "swhois-operblock", ExtensionType::USER) , swhois(Creator, "swhois", ExtensionType::USER, true) { access_needed = CmdAccess::OPERATOR; allow_empty_last_param = true; syntax = { "<nick> :<swhois>" }; translation = { TR_NICK, TR_TEXT }; } CmdResult Handle(User* user, const Params& parameters) override { auto* dest = ServerInstance->Users.Find(parameters[0]); if (!dest) // allow setting swhois using SWHOIS before reg { user->WriteNumeric(Numerics::NoSuchNick(parameters[0])); return CmdResult::FAILURE; } std::string* text = swhois.Get(dest); if (text) { // We already had it set... if (!user->server->IsService()) // Ulines set SWHOISes silently ServerInstance->SNO.WriteGlobalSno('a', "{} used SWHOIS to set {}'s extra whois from '{}' to '{}'", user->nick, dest->nick, *text, parameters[1]); } else if (!user->server->IsService()) { // Ulines set SWHOISes silently ServerInstance->SNO.WriteGlobalSno('a', "{} used SWHOIS to set {}'s extra whois to '{}'", user->nick, dest->nick, parameters[1]); } operblock.Unset(user); if (parameters[1].empty()) swhois.Unset(dest); else swhois.Set(dest, parameters[1]); return CmdResult::SUCCESS; } }; class ModuleSWhois final : public Module , public Whois::LineEventListener { private: CommandSwhois cmd; UserModeReference hideopermode; public: ModuleSWhois() : Module(VF_VENDOR | VF_OPTCOMMON, "Adds the /SWHOIS command which adds custom lines to a user's WHOIS response.") , Whois::LineEventListener(this) , cmd(this) , hideopermode(this, "hideoper") { } // :kenny.chatspike.net 320 Brain Azhrarn :is getting paid to play games. ModResult OnWhoisLine(Whois::Context& whois, Numeric::Numeric& numeric) override { // We use this and not OnWhois because this triggers for remote users too. if (numeric.GetNumeric() != RPL_WHOISSERVER) return MOD_RES_PASSTHRU; // Don't send soper swhois if hideoper is set. if (cmd.operblock.Get(whois.GetTarget()) && whois.GetTarget()->IsModeSet(hideopermode)) return MOD_RES_PASSTHRU; // Insert our numeric before RPL_WHOISSERVER. const std::string* swhois = cmd.swhois.Get(whois.GetTarget()); if (swhois && !swhois->empty()) whois.SendLine(RPL_WHOISSPECIAL, *swhois); return MOD_RES_PASSTHRU; } void OnPostOperLogin(User* user, bool automatic) override { if (!IS_LOCAL(user)) return; const std::string swhois = user->oper->GetConfig()->getString("swhois"); if (!swhois.length()) return; cmd.operblock.Set(user); cmd.swhois.Set(user, swhois); } void OnPostOperLogout(User* user, const std::shared_ptr<OperAccount>& oper) override { std::string* swhois = cmd.swhois.Get(user); if (!swhois) return; if (!cmd.operblock.Get(user)) return; cmd.operblock.Unset(user); cmd.swhois.Unset(user); } void OnDecodeMetadata(Extensible* target, const std::string& extname, const std::string&) override { if (target && target->extype == ExtensionType::USER && irc::equals(extname, "swhois")) cmd.operblock.Unset(static_cast<User*>(target)); } }; MODULE_INIT(ModuleSWhois) ������������������������������inspircd-4.7.0/src/modules/m_timedbans.cpp����������������������������������������������������������0000664�0000000�0000000�00000016023�14771603147�0020576�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2020 iwalkalone <iwalkalone69@gmail.com> * Copyright (C) 2019 Matt Schatz <genius3000@g3k.solutions> * Copyright (C) 2018 linuxdaemon <linuxdaemon.irc@gmail.com> * Copyright (C) 2017 B00mX0r <b00mx0r@aureus.pw> * Copyright (C) 2013, 2017, 2019-2023, 2025 Sadie Powell <sadie@witchery.services> * Copyright (C) 2012-2016 Attila Molnar <attilamolnar@hush.com> * Copyright (C) 2012 Robby <robby@chatbelgie.be> * Copyright (C) 2009-2010 Daniel De Graaf <danieldg@inspircd.org> * Copyright (C) 2009 John Brooks <john@jbrooks.io> * Copyright (C) 2008 Robin Burchell <robin+git@viroteck.net> * Copyright (C) 2005, 2007 Craig Edwards <brain@inspircd.org> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include "inspircd.h" #include "listmode.h" #include "modules/extban.h" #include "numerichelper.h" #include "timeutils.h" // Holds a timed ban class TimedBan final { public: std::string mask; std::string setter; time_t expire; Channel* chan; }; typedef std::vector<TimedBan> timedbans; timedbans TimedBanList; class CommandTban final : public Command { private: ChanModeReference banmode; ExtBan::ManagerRef extbanmgr; bool IsBanSet(Channel* chan, const std::string& mask) { ListModeBase* banlm = static_cast<ListModeBase*>(*banmode); if (!banlm) return false; const ListModeBase::ModeList* bans = banlm->GetList(chan); if (bans) { for (const auto& ban : *bans) { if (banlm->CompareEntry(ban.mask, mask)) return true; } } return false; } public: bool sendnotice; CommandTban(Module* Creator) : Command(Creator, "TBAN", 3) , banmode(Creator, "ban") , extbanmgr(Creator) { syntax = { "<channel> <duration> <banmask>" }; } CmdResult Handle(User* user, const Params& parameters) override { auto* channel = ServerInstance->Channels.Find(parameters[0]); if (!channel) { user->WriteNumeric(Numerics::NoSuchChannel(parameters[0])); return CmdResult::FAILURE; } ModeHandler::Rank cm = channel->GetPrefixValue(user); if (cm < HALFOP_VALUE) { user->WriteNumeric(Numerics::ChannelPrivilegesNeeded(channel, HALFOP_VALUE, "set timed bans")); return CmdResult::FAILURE; } TimedBan T; unsigned long duration; if (!Duration::TryFrom(parameters[1], duration)) { user->WriteNotice("Invalid ban time"); return CmdResult::FAILURE; } unsigned long expire = duration + ServerInstance->Time(); std::string mask = parameters[2]; if (!extbanmgr || !extbanmgr->Canonicalize(mask)) ModeParser::CleanMask(mask); if (IsBanSet(channel, mask)) { user->WriteNotice("Ban already set"); return CmdResult::FAILURE; } Modes::ChangeList setban; setban.push_add(*banmode, mask); // Pass the user (instead of ServerInstance->FakeClient) to ModeHandler::Process() to // make it so that the user sets the mode themselves ServerInstance->Modes.Process(user, channel, nullptr, setban); if (ServerInstance->Modes.GetLastChangeList().empty()) { user->WriteNotice("Invalid ban mask"); return CmdResult::FAILURE; } // Attempt to find the actual set ban mask. for (const auto& mc : ServerInstance->Modes.GetLastChangeList().getlist()) { if (mc.mh == *banmode) { // We found the actual mask. mask = mc.param; break; } } T.mask = mask; T.setter = user->nick; T.expire = expire + (IS_REMOTE(user) ? 5 : 0); T.chan = channel; TimedBanList.push_back(T); if (sendnotice) { const std::string message = INSP_FORMAT("Timed ban {} added by {} on {} lasting for {}.", mask, user->nick, channel->name, Duration::ToLongString(duration)); // If halfop is loaded, send notice to halfops and above, otherwise send to ops and above PrefixMode* mh = ServerInstance->Modes.FindNearestPrefixMode(HALFOP_VALUE); char pfxchar = mh ? mh->GetPrefix() : '@'; channel->WriteRemoteNotice(message, pfxchar); } return CmdResult::SUCCESS; } RouteDescriptor GetRouting(User* user, const Params& parameters) override { return ROUTE_BROADCAST; } }; class BanWatcher final : public ModeWatcher { public: BanWatcher(Module* parent) : ModeWatcher(parent, "ban", MODETYPE_CHANNEL) { } void AfterMode(User* source, User* dest, Channel* chan, const Modes::Change& change) override { if (change.adding) return; for (timedbans::iterator i = TimedBanList.begin(); i != TimedBanList.end(); ++i) { if (i->chan != chan) continue; const std::string& target = i->mask; if (irc::equals(change.param, target)) { TimedBanList.erase(i); break; } } } }; class ChannelMatcher final { Channel* const chan; public: ChannelMatcher(Channel* ch) : chan(ch) { } bool operator()(const TimedBan& tb) const { return (tb.chan == chan); } }; class ModuleTimedBans final : public Module { private: ChanModeReference banmode; CommandTban cmd; BanWatcher banwatcher; public: ModuleTimedBans() : Module(VF_VENDOR | VF_COMMON, "Adds the /TBAN command which allows channel operators to add bans which will be expired after the specified period.") , banmode(this, "ban") , cmd(this) , banwatcher(this) { } void ReadConfig(ConfigStatus& status) override { const auto& tag = ServerInstance->Config->ConfValue("timedbans"); cmd.sendnotice = tag->getBool("sendnotice", true); } void OnBackgroundTimer(time_t curtime) override { timedbans expired; for (timedbans::iterator i = TimedBanList.begin(); i != TimedBanList.end();) { if (curtime > i->expire) { expired.push_back(*i); i = TimedBanList.erase(i); } else ++i; } for (const auto& timedban : expired) { if (cmd.sendnotice) { const std::string message = INSP_FORMAT("Timed ban {} set by {} on {} has expired.", timedban.mask, timedban.setter, timedban.chan->name); // If halfop is loaded, send notice to halfops and above, otherwise send to ops and above PrefixMode* mh = ServerInstance->Modes.FindNearestPrefixMode(HALFOP_VALUE); char pfxchar = mh ? mh->GetPrefix() : '@'; timedban.chan->WriteRemoteNotice(message, pfxchar); } Modes::ChangeList setban; setban.push_remove(*banmode, timedban.mask); ServerInstance->Modes.Process(ServerInstance->FakeClient, timedban.chan, nullptr, setban); } } void OnChannelDelete(Channel* chan) override { // Remove all timed bans affecting the channel from internal bookkeeping TimedBanList.erase(std::remove_if(TimedBanList.begin(), TimedBanList.end(), ChannelMatcher(chan)), TimedBanList.end()); } }; MODULE_INIT(ModuleTimedBans) �������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/src/modules/m_tline.cpp��������������������������������������������������������������0000664�0000000�0000000�00000004766�14771603147�0017756�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2019-2024 Sadie Powell <sadie@witchery.services> * Copyright (C) 2014 Attila Molnar <attilamolnar@hush.com> * Copyright (C) 2012 Robby <robby@chatbelgie.be> * Copyright (C) 2009 Daniel De Graaf <danieldg@inspircd.org> * Copyright (C) 2007 Dennis Friis <peavey@inspircd.org> * Copyright (C) 2006, 2008 Craig Edwards <brain@inspircd.org> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include "inspircd.h" class CommandTline final : public Command { public: CommandTline(Module* Creator) : Command(Creator, "TLINE", 1) { access_needed = CmdAccess::OPERATOR; syntax = { "<mask>" }; } CmdResult Handle(User* user, const Params& parameters) override { unsigned int n_matched = 0; unsigned int n_match_host = 0; unsigned int n_match_ip = 0; for (const auto& [_, u] : ServerInstance->Users.GetUsers()) { if (InspIRCd::Match(u->GetRealMask(), parameters[0])) { n_matched++; n_match_host++; } else { if (InspIRCd::MatchCIDR(u->GetUserAddress(), parameters[0])) { n_matched++; n_match_ip++; } } } unsigned long n_counted = ServerInstance->Users.GetUsers().size(); if (n_matched) { float p = (n_matched / (float)n_counted) * 100; user->WriteNotice("*** TLINE: Counted {} user(s). Matched '{}' against {} user(s) ({:0.2}% of the userbase). {} by hostname and {} by IP address.", n_counted, parameters[0], n_matched, p, n_match_host, n_match_ip); } else user->WriteNotice("*** TLINE: Counted {} user(s). Matched '{}' against no user(s).", n_counted, parameters[0]); return CmdResult::SUCCESS; } }; class ModuleTLine final : public Module { private: CommandTline cmd; public: ModuleTLine() : Module(VF_VENDOR, "Adds the /TLINE command which allows server operators to determine how many users would be affected by an X-line on a specified pattern.") , cmd(this) { } }; MODULE_INIT(ModuleTLine) ����������inspircd-4.7.0/src/modules/m_uhnames.cpp������������������������������������������������������������0000664�0000000�0000000�00000003167�14771603147�0020275�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2013, 2019-2021, 2023 Sadie Powell <sadie@witchery.services> * Copyright (C) 2012, 2015 Attila Molnar <attilamolnar@hush.com> * Copyright (C) 2012 Robby <robby@chatbelgie.be> * Copyright (C) 2009-2010 Daniel De Graaf <danieldg@inspircd.org> * Copyright (C) 2009 Uli Schlachter <psychon@znc.in> * Copyright (C) 2007 Craig Edwards <brain@inspircd.org> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include "inspircd.h" #include "modules/cap.h" #include "modules/names.h" class ModuleUHNames final : public Module , public Names::EventListener { private: Cap::Capability cap; public: ModuleUHNames() : Module(VF_VENDOR, "Provides the IRCv3 userhost-in-names client capability.") , Names::EventListener(this) , cap(this, "userhost-in-names") { } ModResult OnNamesListItem(LocalUser* issuer, Membership* memb, std::string& prefixes, std::string& nick) override { if (cap.IsEnabled(issuer)) nick = memb->user->GetMask(); return MOD_RES_PASSTHRU; } }; MODULE_INIT(ModuleUHNames) ���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/src/modules/m_uninvite.cpp�����������������������������������������������������������0000664�0000000�0000000�00000007262�14771603147�0020476�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2018-2024 Sadie Powell <sadie@witchery.services> * Copyright (C) 2017 B00mX0r <b00mx0r@aureus.pw> * Copyright (C) 2012, 2014-2016 Attila Molnar <attilamolnar@hush.com> * Copyright (C) 2012 Robby <robby@chatbelgie.be> * Copyright (C) 2009-2010 Daniel De Graaf <danieldg@inspircd.org> * Copyright (C) 2008 Robin Burchell <robin+git@viroteck.net> * Copyright (C) 2007 Dennis Friis <peavey@inspircd.org> * Copyright (C) 2006 Craig Edwards <brain@inspircd.org> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include "inspircd.h" #include "modules/invite.h" #include "numerichelper.h" enum { // InspIRCd-specific. ERR_INVITEREMOVED = 494, ERR_NOTINVITED = 505, RPL_UNINVITED = 653 }; class CommandUninvite final : public Command { Invite::API invapi; public: CommandUninvite(Module* Creator) : Command(Creator, "UNINVITE", 2) , invapi(Creator) { syntax = { "<nick> <channel>" }; translation = { TR_NICK, TR_TEXT }; } CmdResult Handle(User* user, const Params& parameters) override { User* u; if (IS_LOCAL(user)) u = ServerInstance->Users.FindNick(parameters[0], true); else u = ServerInstance->Users.Find(parameters[0]); auto* c = ServerInstance->Channels.Find(parameters[1]); if (!c || !u) { if (!c) { user->WriteNumeric(Numerics::NoSuchChannel(parameters[1])); } else { user->WriteNumeric(Numerics::NoSuchNick(parameters[0])); } return CmdResult::FAILURE; } if (IS_LOCAL(user)) { if (c->GetPrefixValue(user) < HALFOP_VALUE) { user->WriteNumeric(Numerics::ChannelPrivilegesNeeded(c, HALFOP_VALUE, "remove an invite")); return CmdResult::FAILURE; } } /* Servers remember invites only for their local users, so act * only if the target is local. Otherwise the command will be * passed to the target users server. */ LocalUser* lu = IS_LOCAL(u); if (lu) { // XXX: The source of the numeric we send must be the server of the user doing the /UNINVITE, // so they don't see where the target user is connected to if (!invapi->Remove(lu, c)) { Numeric::Numeric n(ERR_NOTINVITED); n.SetServer(user->server); n.push(u->nick, c->name).push_fmt("Is not invited to channel {}", c->name); user->WriteRemoteNumeric(n); return CmdResult::FAILURE; } Numeric::Numeric n(ERR_INVITEREMOVED); n.SetServer(user->server); n.push(c->name).push(u->nick).push("Uninvited"); user->WriteRemoteNumeric(n); lu->WriteNumeric(RPL_UNINVITED, INSP_FORMAT("You were uninvited from {} by {}", c->name, user->nick)); c->WriteRemoteNotice(INSP_FORMAT("*** {} uninvited {}.", user->nick, u->nick)); } return CmdResult::SUCCESS; } RouteDescriptor GetRouting(User* user, const Params& parameters) override { return ROUTE_OPT_UCAST(parameters[0]); } }; class ModuleUninvite final : public Module { private: CommandUninvite cmd; public: ModuleUninvite() : Module(VF_VENDOR | VF_OPTCOMMON, "Adds the /UNINVITE command which allows users who have invited another user to a channel to withdraw their invite.") , cmd(this) { } }; MODULE_INIT(ModuleUninvite) ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/src/modules/m_vhost.cpp��������������������������������������������������������������0000664�0000000�0000000�00000007001�14771603147�0017767�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2018 linuxdaemon <linuxdaemon.irc@gmail.com> * Copyright (C) 2013, 2019-2023 Sadie Powell <sadie@witchery.services> * Copyright (C) 2012 Robby <robby@chatbelgie.be> * Copyright (C) 2012 Attila Molnar <attilamolnar@hush.com> * Copyright (C) 2009 Daniel De Graaf <danieldg@inspircd.org> * Copyright (C) 2007 Robin Burchell <robin+git@viroteck.net> * Copyright (C) 2007 Dennis Friis <peavey@inspircd.org> * Copyright (C) 2006 Craig Edwards <brain@inspircd.org> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include "inspircd.h" #include "utility/string.h" struct CustomVhost final { const std::string name; const std::string password; const std::string hash; const std::string vhost; CustomVhost(const std::string& n, const std::string& p, const std::string& h, const std::string& v) : name(n) , password(p) , hash(h) , vhost(v) { } bool CheckPass(const std::string& pass) const { return InspIRCd::CheckPassword(password, hash, pass); } }; typedef std::multimap<std::string, CustomVhost> CustomVhostMap; class CommandVhost final : public Command { public: CustomVhostMap vhosts; CommandVhost(Module* Creator) : Command(Creator, "VHOST", 2) { syntax = { "<username> <password>" }; } CmdResult Handle(User* user, const Params& parameters) override { for (const auto& [_, config] : insp::equal_range(vhosts, parameters[0])) { if (config.CheckPass(parameters[1])) { user->WriteNotice("Setting your VHost: " + config.vhost); user->ChangeDisplayedHost(config.vhost); return CmdResult::SUCCESS; } } user->WriteNotice("Invalid username or password."); return CmdResult::FAILURE; } }; class ModuleVHost final : public Module { private: CommandVhost cmd; public: ModuleVHost() : Module(VF_VENDOR, "Allows the server administrator to define accounts which can grant a custom virtual host.") , cmd(this) { } void ReadConfig(ConfigStatus& status) override { CustomVhostMap newhosts; for (const auto& [_, tag] : ServerInstance->Config->ConfTags("vhost")) { std::string mask = tag->getString("host"); if (mask.empty()) throw ModuleException(this, "<vhost:host> is empty! at " + tag->source.str()); std::string username = tag->getString("user"); if (username.empty()) throw ModuleException(this, "<vhost:user> is empty! at " + tag->source.str()); std::string pass = tag->getString("pass"); if (pass.empty()) throw ModuleException(this, "<vhost:pass> is empty! at " + tag->source.str()); const std::string hash = tag->getString("hash", "plaintext", 1); if (insp::equalsci(hash, "plaintext")) { ServerInstance->Logs.Warning(MODNAME, "<vhost> tag for {} at {} contains an plain text password, this is insecure!", username, tag->source.str()); } CustomVhost vhost(username, pass, hash, mask); newhosts.emplace(username, vhost); } cmd.vhosts.swap(newhosts); } }; MODULE_INIT(ModuleVHost) �������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/src/modules/m_watch.cpp��������������������������������������������������������������0000664�0000000�0000000�00000016762�14771603147�0017750�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2021 Dominic Hamon * Copyright (C) 2018-2023 Sadie Powell <sadie@witchery.services> * Copyright (C) 2016 Attila Molnar <attilamolnar@hush.com> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include "inspircd.h" #include "modules/away.h" #include "modules/isupport.h" #define INSPIRCD_MONITOR_MANAGER_ONLY #include "m_monitor.cpp" enum { RPL_REAWAY = 597, RPL_GONEAWAY = 598, RPL_NOTAWAY = 599, RPL_LOGON = 600, RPL_LOGOFF = 601, RPL_WATCHOFF = 602, RPL_WATCHSTAT = 603, RPL_NOWON = 604, RPL_NOWOFF = 605, RPL_WATCHLIST = 606, RPL_ENDOFWATCHLIST = 607, // RPL_CLEARWATCH = 608, // unused RPL_NOWISAWAY = 609, ERR_TOOMANYWATCH = 512, ERR_INVALIDWATCHNICK = 942 }; class CommandWatch final : public SplitCommand { // Additional penalty for /WATCH commands that request a list from the server static constexpr unsigned int ListPenalty = 4000; IRCv3::Monitor::Manager& manager; static void SendOnlineOffline(LocalUser* user, const std::string& nick, bool show_offline = true) { User* target = ServerInstance->Users.FindNick(nick, true); if (target) { // The away state should only be sent if the client requests away notifications for a nick but 2.0 always sends them so we do that too if (target->IsAway()) user->WriteNumeric(RPL_NOWISAWAY, target->nick, target->GetDisplayedHost(), target->GetDisplayedHost(), target->away->time, "is away"); else user->WriteNumeric(RPL_NOWON, target->nick, target->GetDisplayedHost(), target->GetDisplayedHost(), target->nickchanged, "is online"); } else if (show_offline) user->WriteNumeric(RPL_NOWOFF, nick, "*", "*", "0", "is offline"); } void HandlePlus(LocalUser* user, const std::string& nick) { IRCv3::Monitor::Manager::WatchResult result = manager.Watch(user, nick, maxwatch); if (result == IRCv3::Monitor::Manager::WR_TOOMANY) { // List is full, send error numeric user->WriteNumeric(ERR_TOOMANYWATCH, nick, "Too many WATCH entries"); return; } else if (result == IRCv3::Monitor::Manager::WR_INVALIDNICK) { user->WriteNumeric(ERR_INVALIDWATCHNICK, nick, "Invalid nickname"); return; } else if (result != IRCv3::Monitor::Manager::WR_OK) return; SendOnlineOffline(user, nick); } void HandleMinus(LocalUser* user, const std::string& nick) { if (!manager.Unwatch(user, nick)) return; User* target = ServerInstance->Users.FindNick(nick, true); if (target) user->WriteNumeric(RPL_WATCHOFF, target->nick, target->GetDisplayedHost(), target->GetDisplayedHost(), target->nickchanged, "stopped watching"); else user->WriteNumeric(RPL_WATCHOFF, nick, "*", "*", "0", "stopped watching"); } void HandleList(LocalUser* user, bool show_offline) { user->CommandFloodPenalty += ListPenalty; for (const auto* entry : manager.GetWatched(user)) SendOnlineOffline(user, entry->GetNick(), show_offline); user->WriteNumeric(RPL_ENDOFWATCHLIST, "End of WATCH list"); } void HandleStats(LocalUser* user) { user->CommandFloodPenalty += ListPenalty; // Do not show how many clients are watching this nick, it's pointless const IRCv3::Monitor::WatchedList& list = manager.GetWatched(user); user->WriteNumeric(RPL_WATCHSTAT, INSP_FORMAT("You have {} and are on 0 WATCH entries", list.size())); Numeric::Builder<' '> out(user, RPL_WATCHLIST); for (const auto* entry : list) out.Add(entry->GetNick()); out.Flush(); user->WriteNumeric(RPL_ENDOFWATCHLIST, "End of WATCH S"); } public: unsigned long maxwatch; CommandWatch(Module* mod, IRCv3::Monitor::Manager& managerref) : SplitCommand(mod, "WATCH") , manager(managerref) { syntax = { "C", "L", "l", "S", "(+|-)<nick> [(+|-)<nick>]+" }; } CmdResult HandleLocal(LocalUser* user, const Params& parameters) override { if (parameters.empty()) { HandleList(user, false); return CmdResult::SUCCESS; } bool watch_l_done = false; bool watch_s_done = false; for (const auto& token : parameters) { char subcmd = toupper(token[0]); if (subcmd == '+') { HandlePlus(user, token.substr(1)); } else if (subcmd == '-') { HandleMinus(user, token.substr(1)); } else if (subcmd == 'C') { manager.UnwatchAll(user); } else if ((subcmd == 'L') && (!watch_l_done)) { watch_l_done = true; // WATCH L requests a full list with online and offline nicks // WATCH l requests a list with only online nicks HandleList(user, (token[0] == 'L')); } else if ((subcmd == 'S') && (!watch_s_done)) { watch_s_done = true; HandleStats(user); } } return CmdResult::SUCCESS; } }; class ModuleWatch final : public Module , public Away::EventListener , public ISupport::EventListener { private: IRCv3::Monitor::Manager manager; CommandWatch cmd; void SendAlert(User* user, const std::string& nick, unsigned int numeric, const char* numerictext, time_t shownts) { const IRCv3::Monitor::WatcherList* list = manager.GetWatcherList(nick); if (!list) return; Numeric::Numeric num(numeric); num.push(nick).push(user->GetDisplayedUser()).push(user->GetDisplayedHost()).push(ConvToStr(shownts)).push(numerictext); for (const auto& curr : *list) curr->WriteNumeric(num); } void Online(User* user) { SendAlert(user, user->nick, RPL_LOGON, "arrived online", user->nickchanged); if (user->IsAway()) OnUserAway(user, std::nullopt); } void Offline(User* user, const std::string& nick) { SendAlert(user, nick, RPL_LOGOFF, "went offline", user->nickchanged); } public: ModuleWatch() : Module(VF_VENDOR, "Adds the /WATCH command which allows users to find out when their friends are connected to the server.") , Away::EventListener(this) , ISupport::EventListener(this) , manager(this, "watch") , cmd(this, manager) { } void ReadConfig(ConfigStatus& status) override { const auto& tag = ServerInstance->Config->ConfValue("watch"); cmd.maxwatch = tag->getNum<unsigned long>("maxwatch", 30, 1); } void OnPostConnect(User* user) override { Online(user); } void OnUserPostNick(User* user, const std::string& oldnick) override { // Detect and ignore nickname case change if (ServerInstance->Users.FindNick(oldnick) == user) return; Offline(user, oldnick); Online(user); } void OnUserQuit(User* user, const std::string& message, const std::string& oper_message) override { LocalUser* localuser = IS_LOCAL(user); if (localuser) manager.UnwatchAll(localuser); Offline(user, user->nick); } void OnUserAway(User* user, const std::optional<AwayState>& prevstate) override { unsigned int numeric = prevstate ? RPL_REAWAY : RPL_GONEAWAY; SendAlert(user, user->nick, numeric, user->away->message.c_str(), user->away->time); } void OnUserBack(User* user, const std::optional<AwayState>& prevstate) override { SendAlert(user, user->nick, RPL_NOTAWAY, "is no longer away", ServerInstance->Time()); } void OnBuildISupport(ISupport::TokenMap& tokens) override { tokens["WATCH"] = ConvToStr(cmd.maxwatch); } }; MODULE_INIT(ModuleWatch) ��������������inspircd-4.7.0/src/modules/m_websocket.cpp����������������������������������������������������������0000664�0000000�0000000�00000054215�14771603147�0020623�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2021 Dominic Hamon * Copyright (C) 2019 iwalkalone <iwalkalone69@gmail.com> * Copyright (C) 2018-2025 Sadie Powell <sadie@witchery.services> * Copyright (C) 2016 Attila Molnar <attilamolnar@hush.com> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include "inspircd.h" #include "extension.h" #include "iohook.h" #include "modules/hash.h" #include "modules/isupport.h" #include "modules/whois.h" #include "utility/string.h" #define UTF_CPP_CPLUSPLUS 199711L #include <utfcpp/unchecked.h> static constexpr char MagicGUID[] = "258EAFA5-E914-47DA-95CA-C5AB0DC85B11"; static constexpr char newline[] = "\r\n"; static constexpr char whitespace[] = " \t"; struct SharedData final { // An extension that stores the value of the Origin header. StringExtItem origin; // An extension that stores the real hostname for proxied hosts. StringExtItem realhost; // An extension that stores the real IP for proxied hosts. StringExtItem realip; // A reference to the SHA-1 provider. dynamic_reference_nocheck<HashProvider> sha1; SharedData(Module* mod) : origin(mod, "websocket-origin", ExtensionType::USER, true) , realhost(mod, "websocket-realhost", ExtensionType::USER, true) , realip(mod, "websocket-realip", ExtensionType::USER, true) , sha1(mod, "hash/sha1") { } }; static SharedData* g_data; struct WebSocketConfig final { enum DefaultMode { // Reject connections if a subprotocol is not requested. DM_REJECT, // Use binary frames if a subprotocol is not requested. DM_BINARY, // Use UTF-8 text frames if a subprotocol is not requested. DM_TEXT }; typedef std::vector<std::string> OriginList; typedef std::vector<std::string> ProxyRanges; // The HTTP origins that can connect to the server. OriginList allowedorigins; // Whether text encoding can be used on this server. bool allowtext; // The method to use if a subprotocol is not negotiated. DefaultMode defaultmode; // The IP ranges which send trustworthy X-Real-IP or X-Forwarded-For headers. ProxyRanges proxyranges; // Whether to allow connections from clients that do not send an Origin header. bool allowmissingorigin; // Whether to send WebSocket ping messages instead of IRC ping messages. bool nativeping; }; class WebSocketHookProvider final : public IOHookProvider { public: WebSocketConfig config; WebSocketHookProvider(Module* mod) : IOHookProvider(mod, "websocket", IOHookProvider::IOH_UNKNOWN, true) { } void OnAccept(StreamSocket* sock, const irc::sockets::sockaddrs& client, const irc::sockets::sockaddrs& server) override; void OnConnect(StreamSocket* sock) override { } }; class WebSocketHook final : public IOHookMiddle { class HTTPHeaderFinder final { private: std::string::size_type bpos; std::string::size_type len; public: bool Find(const std::string& req, const char* header, std::string::size_type headerlen, std::string::size_type maxpos) { // Skip the GET /wibble HTTP/1.1 line. size_t startpos = req.find(newline) + sizeof(newline) - 1; while (startpos < maxpos) { size_t endpos = req.find(newline, startpos); if (strncasecmp(req.c_str() + startpos, header, headerlen) != 0) { startpos = endpos + sizeof(newline) - 1; continue; // Incorrect header. } bpos = req.find_first_not_of(whitespace, startpos + headerlen); if (bpos >= endpos) return false; // Empty value. size_t epos = std::min(req.find_last_not_of(whitespace), endpos); if (epos < bpos) return false; // Should never happen. len = epos - bpos; return true; } // No header found. return false; } std::string ExtractValue(const std::string& req) const { return std::string(req, bpos, len); } }; enum CloseCode { CLOSE_PROTOCOL_ERROR = 1002, CLOSE_POLICY_VIOLATION = 1008, CLOSE_TOO_LARGE = 1009 }; enum OpCode { OP_CONTINUATION = 0x00, OP_TEXT = 0x01, OP_BINARY = 0x02, OP_CLOSE = 0x08, OP_PING = 0x09, OP_PONG = 0x0a }; enum State { STATE_HTTPREQ, STATE_ESTABLISHED }; static constexpr unsigned char WS_MASKBIT = (1 << 7); static constexpr unsigned char WS_FINBIT = (1 << 7); static constexpr unsigned char WS_PAYLOAD_LENGTH_MAGIC_LARGE = 126; static constexpr unsigned char WS_PAYLOAD_LENGTH_MAGIC_HUGE = 127; static constexpr size_t WS_MAX_PAYLOAD_LENGTH_SMALL = 125; static constexpr size_t WS_MAX_PAYLOAD_LENGTH_LARGE = 65535; static constexpr size_t MAXHEADERSIZE = sizeof(uint64_t) + 2; // Clients sending ping or pong frames faster than this are killed static constexpr time_t MINPINGPONGDELAY = 10; State state = STATE_HTTPREQ; time_t lastpingpong = 0; WebSocketConfig& config; bool sendastext; static size_t FillHeader(unsigned char* outbuf, size_t sendlength, OpCode opcode) { size_t pos = 0; outbuf[pos++] = WS_FINBIT | opcode; if (sendlength <= WS_MAX_PAYLOAD_LENGTH_SMALL) { outbuf[pos++] = sendlength; } else if (sendlength <= WS_MAX_PAYLOAD_LENGTH_LARGE) { outbuf[pos++] = WS_PAYLOAD_LENGTH_MAGIC_LARGE; outbuf[pos++] = (sendlength >> 8) & 0xff; outbuf[pos++] = sendlength & 0xff; } else { outbuf[pos++] = WS_PAYLOAD_LENGTH_MAGIC_HUGE; const uint64_t len = sendlength; for (int i = sizeof(uint64_t)-1; i >= 0; i--) outbuf[pos++] = ((len >> i*8) & 0xff); } return pos; } static StreamSocket::SendQueue::Element PrepareSendQElem(size_t size, OpCode opcode) { unsigned char header[MAXHEADERSIZE]; const size_t n = FillHeader(header, size, opcode); return StreamSocket::SendQueue::Element(reinterpret_cast<const char*>(header), n); } int HandleAppData(StreamSocket* sock, std::string& appdataout, bool allowlarge) { std::string& myrecvq = GetRecvQ(); // Need 1 byte opcode, minimum 1 byte len, 4 bytes masking key if (myrecvq.length() < 6) return 0; const std::string& cmyrecvq = myrecvq; unsigned char len1 = (unsigned char)cmyrecvq[1]; if (!(len1 & WS_MASKBIT)) { CloseConnection(sock, CLOSE_PROTOCOL_ERROR, "WebSocket protocol violation: unmasked client frame"); return -1; } len1 &= ~WS_MASKBIT; // Assume the length is a single byte, if not, update values later unsigned int len = len1; unsigned int payloadstartoffset = 6; const unsigned char* maskkey = reinterpret_cast<const unsigned char*>(&cmyrecvq[2]); if (len1 == WS_PAYLOAD_LENGTH_MAGIC_LARGE) { // allowlarge is false for control frames according to the RFC meaning large pings, etc. are not allowed if (!allowlarge) { CloseConnection(sock, CLOSE_PROTOCOL_ERROR, "WebSocket protocol violation: large control frame"); return -1; } // Large frame, has 2 bytes len after the magic byte indicating the length // Need 1 byte opcode, 3 bytes len, 4 bytes masking key if (myrecvq.length() < 8) return 0; unsigned char len2 = (unsigned char)cmyrecvq[2]; unsigned char len3 = (unsigned char)cmyrecvq[3]; len = (len2 << 8) | len3; if (len <= WS_MAX_PAYLOAD_LENGTH_SMALL) { CloseConnection(sock, CLOSE_PROTOCOL_ERROR, "WebSocket protocol violation: non-minimal length encoding used"); return -1; } maskkey += 2; payloadstartoffset += 2; } else if (len1 == WS_PAYLOAD_LENGTH_MAGIC_HUGE) { CloseConnection(sock, CLOSE_TOO_LARGE, "WebSocket: Huge frames are not supported"); return -1; } if (myrecvq.length() < payloadstartoffset + len) return 0; unsigned int maskkeypos = 0; const std::string::iterator endit = myrecvq.begin() + payloadstartoffset + len; for (std::string::const_iterator i = myrecvq.begin() + payloadstartoffset; i != endit; ++i) { const unsigned char c = (unsigned char)*i; appdataout.push_back(c ^ maskkey[maskkeypos++]); maskkeypos %= 4; } myrecvq.erase(myrecvq.begin(), endit); return 1; } int HandlePingPongFrame(StreamSocket* sock, bool isping) { if (lastpingpong + MINPINGPONGDELAY >= ServerInstance->Time()) { CloseConnection(sock, CLOSE_POLICY_VIOLATION, "WebSocket: Ping/pong flood"); return -1; } lastpingpong = ServerInstance->Time(); std::string appdata; const int result = HandleAppData(sock, appdata, false); if (result <= 0) return result; if (isping) { StreamSocket::SendQueue::Element elem = PrepareSendQElem(appdata.length(), OP_PONG); elem.append(appdata); GetSendQ().push_back(elem); SocketEngine::ChangeEventMask(sock, FD_ADD_TRIAL_WRITE); } else if (sock->type == StreamSocket::SS_USER && config.nativeping) { // Pong reply on user socket; reset their idle time. UserIOHandler* ioh = static_cast<UserIOHandler*>(sock); ioh->user->lastping = 1; } return 1; } int HandleWS(StreamSocket* sock, std::string& destrecvq) { if (GetRecvQ().empty()) return 0; unsigned char opcode = (unsigned char)GetRecvQ()[0]; switch (opcode & ~WS_FINBIT) { case OP_CONTINUATION: case OP_TEXT: case OP_BINARY: { std::string appdata; const int result = HandleAppData(sock, appdata, true); if (result != 1) return result; // Strip out any CR+LF which may have been erroneously sent. for (const auto chr : appdata) { if (chr != '\r' && chr != '\n') destrecvq.push_back(chr); } // If we are on the final message of this block append a line terminator. if (opcode & WS_FINBIT) destrecvq.append("\r\n"); return 1; } case OP_PING: { return HandlePingPongFrame(sock, true); } case OP_PONG: { // A pong frame may be sent unsolicited, so we have to handle it. // It may carry application data which we need to remove from the recvq as well. return HandlePingPongFrame(sock, false); } case OP_CLOSE: { sock->SetError("Connection closed"); return -1; } default: { CloseConnection(sock, CLOSE_PROTOCOL_ERROR, "WebSocket: Invalid opcode"); return -1; } } } void CloseConnection(StreamSocket* sock, CloseCode closecode, const std::string& reason) { uint16_t netcode = htons(closecode); std::string packedcode; packedcode.push_back(netcode & 0x00FF); packedcode.push_back(netcode >> 8); GetSendQ().push_back(PrepareSendQElem(reason.length() + 2, OP_CLOSE)); GetSendQ().push_back(packedcode); GetSendQ().push_back(reason); sock->DoWrite(); sock->SetError(reason); } void FailHandshake(StreamSocket* sock, const char* httpreply, const char* sockerror) { GetSendQ().push_back(StreamSocket::SendQueue::Element(httpreply)); GetSendQ().push_back(StreamSocket::SendQueue::Element(sockerror)); sock->DoWrite(); sock->SetError(sockerror); } int HandleHTTPReq(StreamSocket* sock) { std::string& recvq = GetRecvQ(); const std::string::size_type reqend = recvq.find("\r\n\r\n"); if (reqend == std::string::npos) return 0; LocalUser* luser = nullptr; if (sock->type == StreamSocket::SS_USER) luser = static_cast<UserIOHandler*>(sock)->user; bool allowedorigin = false; HTTPHeaderFinder originheader; if (originheader.Find(recvq, "Origin:", 7, reqend)) { const std::string origin = originheader.ExtractValue(recvq); for (const auto& cfgorigin : config.allowedorigins) { if (InspIRCd::Match(origin, cfgorigin, ascii_case_insensitive_map)) { allowedorigin = true; if (luser) g_data->origin.Set(luser, origin); break; } } } else if (config.allowmissingorigin) { // This is a non-web WebSocket connection. allowedorigin = true; } else { FailHandshake(sock, "HTTP/1.1 400 Bad Request\r\nConnection: close\r\n\r\n", "WebSocket: Received HTTP request that did not send the Origin header"); return -1; } if (!allowedorigin) { FailHandshake(sock, "HTTP/1.1 403 Forbidden\r\nConnection: close\r\n\r\n", "WebSocket: Received HTTP request from a non-whitelisted origin"); return -1; } if (!config.proxyranges.empty() && luser) { irc::sockets::sockaddrs realsa(luser->client_sa); HTTPHeaderFinder proxyheader; if (proxyheader.Find(recvq, "X-Real-IP:", 10, reqend) || proxyheader.Find(recvq, "X-Forwarded-For:", 16, reqend)) { // Attempt to parse the proxy HTTP header. if (!realsa.from_ip_port(proxyheader.ExtractValue(recvq), realsa.port())) { // The proxy header value contains a malformed value. FailHandshake(sock, "HTTP/1.1 400 Bad Request\r\nConnection: close\r\n\r\n", "WebSocket: Received a proxied HTTP request that sent a malformed real IP address"); return -1; } } else { // The proxy header is missing. FailHandshake(sock, "HTTP/1.1 400 Bad Request\r\nConnection: close\r\n\r\n", "WebSocket: Received a proxied HTTP request that did not send a real IP address header"); return -1; } for (const auto& proxyrange : config.proxyranges) { if (InspIRCd::MatchCIDR(luser->GetAddress(), proxyrange, ascii_case_insensitive_map)) { // Give the user their real IP address. if (realsa != luser->client_sa) { g_data->realhost.Set(luser, luser->GetRealHost()); g_data->realip.Set(luser, luser->GetAddress()); luser->ChangeRemoteAddress(realsa); } // Error if changing their IP gets them banned. if (luser->quitting) return -1; break; } } } std::string selectedproto; HTTPHeaderFinder protocolheader; if (protocolheader.Find(recvq, "Sec-WebSocket-Protocol:", 23, reqend)) { irc::commasepstream protostream(protocolheader.ExtractValue(recvq)); for (std::string proto; protostream.GetToken(proto); ) { proto.erase(std::remove_if(proto.begin(), proto.end(), ::isspace), proto.end()); auto is_binary = (sock->type == StreamSocket::SS_USER && insp::equalsci(proto, "binary.ircv3.net")) || insp::equalsci(proto, "binary.inspircd.org"); auto is_text = (sock->type == StreamSocket::SS_USER && insp::equalsci(proto, "text.ircv3.net")) || insp::equalsci(proto, "text.inspircd.org"); if (is_binary || is_text) { selectedproto = std::move(proto); sendastext = is_text; break; } } } if (selectedproto.empty() && config.defaultmode == WebSocketConfig::DM_REJECT) { FailHandshake(sock, "HTTP/1.1 400 Bad Request\r\nConnection: close\r\n\r\n", "WebSocket: Received HTTP request that did not send the Sec-WebSocket-Protocol header"); return -1; } if (sendastext && !config.allowtext) { FailHandshake(sock, "HTTP/1.1 400 Bad Request\r\nConnection: close\r\n\r\n", "WebSocket: Received HTTP request that requested a text protocol which is not compatible with the server character set"); return -1; } HTTPHeaderFinder keyheader; if (!keyheader.Find(recvq, "Sec-WebSocket-Key:", 18, reqend)) { FailHandshake(sock, "HTTP/1.1 501 Not Implemented\r\nConnection: close\r\n\r\n", "WebSocket: Received HTTP request which is not a websocket upgrade"); return -1; } if (!*g_data->sha1) { FailHandshake(sock, "HTTP/1.1 503 Service Unavailable\r\nConnection: close\r\n\r\n", "WebSocket: SHA-1 provider missing"); return -1; } state = STATE_ESTABLISHED; std::string key = keyheader.ExtractValue(recvq); key.append(MagicGUID); std::string reply = "HTTP/1.1 101 Switching Protocols\r\nUpgrade: websocket\r\nConnection: Upgrade\r\nSec-WebSocket-Accept: "; reply.append(Base64::Encode((*g_data->sha1)->GenerateRaw(key), nullptr, '=')).append(newline); if (!selectedproto.empty()) reply.append("Sec-WebSocket-Protocol: ").append(selectedproto).append(newline); reply.append(newline); GetSendQ().push_back(StreamSocket::SendQueue::Element(reply)); SocketEngine::ChangeEventMask(sock, FD_ADD_TRIAL_WRITE); recvq.erase(0, reqend + 4); return 1; } public: WebSocketHook(const std::shared_ptr<IOHookProvider>& Prov, StreamSocket* sock, WebSocketConfig& cfg) : IOHookMiddle(Prov) , config(cfg) , sendastext(config.defaultmode != WebSocketConfig::DM_BINARY) { sock->AddIOHook(this); } bool IsHookReady() const override { return state == STATE_ESTABLISHED; } ssize_t OnStreamSocketWrite(StreamSocket* sock, StreamSocket::SendQueue& uppersendq) override { StreamSocket::SendQueue& mysendq = GetSendQ(); // Return 1 to allow sending back an error HTTP response if (state != STATE_ESTABLISHED) return (mysendq.empty() ? 0 : 1); std::string message; for (const auto& elem : uppersendq) { for (const auto chr : elem) { if (chr == '\n') { // We have found an entire message. Send it in its own frame. if (sendastext) { // If we send messages as text then we need to ensure they are valid UTF-8. std::string encoded; utf8::unchecked::replace_invalid(message.begin(), message.end(), std::back_inserter(encoded)); mysendq.push_back(PrepareSendQElem(encoded.length(), OP_TEXT)); mysendq.push_back(encoded); } else { // Otherwise, send the raw message as a binary frame. mysendq.push_back(PrepareSendQElem(message.length(), OP_BINARY)); mysendq.push_back(message); } message.clear(); } else if (chr != '\r') { message.push_back(chr); } } } // Empty the upper send queue and push whatever is left back onto it. uppersendq.clear(); if (!message.empty()) { uppersendq.push_back(message); return 0; } return 1; } ssize_t OnStreamSocketRead(StreamSocket* sock, std::string& destrecvq) override { if (state == STATE_HTTPREQ) { int httpret = HandleHTTPReq(sock); if (httpret <= 0) return httpret; } int wsret; do { wsret = HandleWS(sock, destrecvq); } while ((!GetRecvQ().empty()) && (wsret > 0)); return wsret; } bool Ping() override { if (!config.nativeping) return false; StreamSocket::SendQueue& mysendq = GetSendQ(); const std::string& message = ServerInstance->Config->GetServerName(); mysendq.push_back(PrepareSendQElem(message.length(), OP_PING)); mysendq.push_back(message); return true; } }; void WebSocketHookProvider::OnAccept(StreamSocket* sock, const irc::sockets::sockaddrs& client, const irc::sockets::sockaddrs& server) { new WebSocketHook(shared_from_this(), sock, config); } class ModuleWebSocket final : public Module , public Whois::EventListener { private: std::shared_ptr<WebSocketHookProvider> hookprov; ISupport::EventProvider isupportprov; SharedData data; public: ModuleWebSocket() : Module(VF_VENDOR, "Allows WebSocket clients to connect to the IRC server.") , Whois::EventListener(this) , hookprov(std::make_shared<WebSocketHookProvider>(this)) , isupportprov(this) , data(this) { g_data = &data; } void ReadConfig(ConfigStatus& status) override { auto tags = ServerInstance->Config->ConfTags("wsorigin"); if (tags.empty()) throw ModuleException(this, "You have loaded the websocket module but not configured any allowed origins!"); WebSocketConfig config; // If a server has a non-utf8 compatible character set configured // then we can not support text encoding. ISupport::TokenMap tokens; isupportprov.Call(&ISupport::EventListener::OnBuildISupport, tokens); auto it = tokens.find("CHARSET"); config.allowtext = it == tokens.end() || irc::equals(it->second, "ascii") || irc::equals(it->second, "utf8"); for (const auto& [_, tag] : tags) { // Ensure that we have the <wsorigin:allow> parameter. const std::string allow = tag->getString("allow"); if (allow.empty()) throw ModuleException(this, "<wsorigin:allow> is a mandatory field, at " + tag->source.str()); config.allowedorigins.push_back(allow); } const auto& tag = ServerInstance->Config->ConfValue("websocket"); const std::string defaultmodestr = tag->getString("defaultmode", tag->getBool("sendastext", config.allowtext) ? "text" : "binary", 1); if (insp::equalsci(defaultmodestr, "reject")) config.defaultmode = WebSocketConfig::DM_REJECT; else if (insp::equalsci(defaultmodestr, "binary")) config.defaultmode = WebSocketConfig::DM_BINARY; else if (insp::equalsci(defaultmodestr, "text")) config.defaultmode = WebSocketConfig::DM_TEXT; else throw ModuleException(this, defaultmodestr + " is an invalid value for <websocket:defaultmode>; acceptable values are 'binary', 'text' and 'reject', at " + tag->source.str()); if (config.defaultmode == WebSocketConfig::DM_TEXT && !config.allowtext) throw ModuleException(this, "You can not use text websockets when using a non-utf8 compatible server charset, at " + tag->source.str()); irc::spacesepstream proxyranges(tag->getString("proxyranges")); for (std::string proxyrange; proxyranges.GetToken(proxyrange); ) config.proxyranges.push_back(proxyrange); config.allowmissingorigin = tag->getBool("allowmissingorigin", true); config.nativeping = tag->getBool("nativeping", true); // Everything is okay; apply the new config. hookprov->config = config; } void OnCleanup(ExtensionType type, Extensible* item) override { if (type != ExtensionType::USER) return; LocalUser* user = IS_LOCAL(static_cast<User*>(item)); if ((user) && (user->eh.GetModHook(this))) ServerInstance->Users.QuitUser(user, "WebSocket module unloading"); } void OnWhois(Whois::Context& whois) override { if (!whois.GetSource()->HasPrivPermission("users/auspex")) return; // Only visible to opers. const auto* origin = data.origin.Get(whois.GetTarget()); const auto* realhost = data.realhost.Get(whois.GetTarget()); const auto* realip = data.realip.Get(whois.GetTarget()); if (!origin && !realhost && !realip) return; // If these fields are not set then the client is not a WebSocket user. // If either of these aren't set then the user's connection isn't proxied. std::string missing = "*"; if (!realhost || !realip) realhost = realip = &missing; if (origin) whois.SendLine(RPL_WHOISGATEWAY, *realhost, *realip, "is connected from the " + *origin + " WebSocket origin"); else whois.SendLine(RPL_WHOISGATEWAY, *realhost, *realip, "is connected from a non-web WebSocket origin"); } }; MODULE_INIT(ModuleWebSocket) �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/src/modules/m_xline_db.cpp�����������������������������������������������������������0000664�0000000�0000000�00000021231�14771603147�0020411�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2021 Herman <GermanAizek@yandex.ru> * Copyright (C) 2019 Matt Schatz <genius3000@g3k.solutions> * Copyright (C) 2013, 2015, 2018-2025 Sadie Powell <sadie@witchery.services> * Copyright (C) 2012-2013 Attila Molnar <attilamolnar@hush.com> * Copyright (C) 2012, 2014 Adam <Adam@anope.org> * Copyright (C) 2012 Robby <robby@chatbelgie.be> * Copyright (C) 2012 ChrisTX <xpipe@hotmail.de> * Copyright (C) 2009 Daniel De Graaf <danieldg@inspircd.org> * Copyright (C) 2008 Robin Burchell <robin+git@viroteck.net> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include <filesystem> #include <fstream> #include "inspircd.h" #include "timeutils.h" #include "xline.h" class ModuleXLineDB final : public Module , public Timer { private: bool dirty; std::string xlinedbpath; unsigned long saveperiod; unsigned long maxbackoff; unsigned char backoff; public: ModuleXLineDB() : Module(VF_VENDOR, "Allows X-lines to be saved and reloaded on restart.") , Timer(0, true) { } void init() override { /* Load the configuration * Note: * This is on purpose not changed on a rehash. It would be non-trivial to change the database on-the-fly. * Imagine a scenario where the new file already exists. Merging the current XLines with the existing database is likely a bad idea * ...and so is discarding all current in-memory XLines for the ones in the database. */ const auto& Conf = ServerInstance->Config->ConfValue("xlinedb"); xlinedbpath = ServerInstance->Config->Paths.PrependData(Conf->getString("filename", "xline.db", 1)); saveperiod = Conf->getDuration("saveperiod", 5); backoff = Conf->getNum<uint8_t>("backoff", 0); maxbackoff = Conf->getDuration("maxbackoff", saveperiod * 120, saveperiod); SetInterval(saveperiod); // Read xlines before attaching to events ReadDatabase(); dirty = false; } /** Called whenever an xline is added by a local user. * This method is triggered after the line is added. * @param source The sender of the line or NULL for local server * @param line The xline being added */ void OnAddLine(User* source, XLine* line) override { if (!line->from_config) dirty = true; } /** Called whenever an xline is deleted. * This method is triggered after the line is deleted. * @param source The user removing the line or NULL for local server * @param line the line being deleted */ void OnDelLine(User* source, XLine* line) override { OnAddLine(source, line); } bool Tick() override { if (dirty) { if (WriteDatabase()) { // If we were previously unable to write but now can then reset the time interval. if (GetInterval() != saveperiod) SetInterval(saveperiod, false); dirty = false; } else { // Back off a bit to avoid spamming opers. if (backoff > 1) SetInterval(std::min(GetInterval() * backoff, maxbackoff), false); ServerInstance->Logs.Debug(MODNAME, "Trying again in {}", Duration::ToLongString(GetInterval())); } } return true; } bool WriteDatabase() { /* * We need to perform an atomic write so as not to fuck things up. * So, let's write to a temporary file, flush it, then rename the file.. * Technically, that means that this can block, but I have *never* seen that. * -- w00t */ ServerInstance->Logs.Debug(MODNAME, "Opening temporary database"); const auto xlinenewdbpath = INSP_FORMAT("{}.new.{}", xlinedbpath, ServerInstance->Time()); std::ofstream stream(xlinenewdbpath); if (!stream.is_open()) { ServerInstance->Logs.Critical(MODNAME, "Cannot create database \"{}\"! {} ({})", xlinenewdbpath, strerror(errno), errno); ServerInstance->SNO.WriteToSnoMask('x', "database: cannot create new xline db \"{}\": {} ({})", xlinenewdbpath, strerror(errno), errno); return false; } ServerInstance->Logs.Debug(MODNAME, "Opened. Writing.."); /* * Now, much as I hate writing semi-unportable formats, additional * xline types may not have a conf tag, so let's just write them. * In addition, let's use a file version, so we can maintain some * semblance of backwards compatibility for reading on startup.. * -- w00t */ stream << "VERSION 1" << std::endl; // Now, let's write. for (const auto& xltype : ServerInstance->XLines->GetAllTypes()) { XLineLookup* lookup = ServerInstance->XLines->GetAll(xltype); if (!lookup) continue; // Not possible as we just obtained the list from XLineManager for (const auto& [_, line] : *lookup) { if (line->from_config) continue; stream << "LINE " << line->type << " " << line->Displayable() << " " << line->source << " " << line->set_time << " " << line->duration << " :" << line->reason << std::endl; } } ServerInstance->Logs.Debug(MODNAME, "Finished writing XLines. Checking for error.."); if (stream.fail()) { ServerInstance->Logs.Critical(MODNAME, "Cannot write to new database \"{}\"! {} ({})", xlinenewdbpath, strerror(errno), errno); ServerInstance->SNO.WriteToSnoMask('x', "database: cannot write to new xline db \"{}\": {} ({})", xlinenewdbpath, strerror(errno), errno); return false; } stream.close(); #ifdef _WIN32 remove(xlinedbpath.c_str()); #endif // Use rename to move temporary to new db - this is guaranteed not to fuck up, even in case of a crash. if (rename(xlinenewdbpath.c_str(), xlinedbpath.c_str()) < 0) { ServerInstance->Logs.Critical(MODNAME, "Cannot replace old database \"{}\" with new database \"{}\"! {} ({})", xlinedbpath, xlinenewdbpath, strerror(errno), errno); ServerInstance->SNO.WriteToSnoMask('x', "database: cannot replace old xline db \"{}\" with new db \"{}\": {} ({})", xlinedbpath, xlinenewdbpath, strerror(errno), errno); return false; } return true; } bool ReadDatabase() { // If the xline database doesn't exist then we don't need to load it. std::error_code ec; if (!std::filesystem::is_regular_file(xlinedbpath, ec)) return true; std::ifstream stream(xlinedbpath); if (!stream.is_open()) { ServerInstance->Logs.Critical(MODNAME, "Cannot read database \"{}\"! {} ({})", xlinedbpath, strerror(errno), errno); ServerInstance->SNO.WriteToSnoMask('x', "database: cannot read xline db \"{}\": {} ({})", xlinedbpath, strerror(errno), errno); return false; } std::string line; while (std::getline(stream, line)) { // Inspired by the command parser. :) irc::tokenstream tokens(line); int items = 0; std::string command_p[7]; std::string tmp; while (tokens.GetTrailing(tmp) && (items < 7)) { command_p[items] = tmp; items++; } ServerInstance->Logs.Debug(MODNAME, "Processing {}", line); if (command_p[0] == "VERSION") { if (command_p[1] != "1") { stream.close(); ServerInstance->Logs.Critical(MODNAME, "I got database version {} - I don't understand it", command_p[1]); ServerInstance->SNO.WriteToSnoMask('x', "database: I got a database version ({}) I don't understand", command_p[1]); return false; } } else if (command_p[0] == "LINE") { // Mercilessly stolen from spanningtree XLineFactory* xlf = ServerInstance->XLines->GetFactory(command_p[1]); if (!xlf) { ServerInstance->SNO.WriteToSnoMask('x', "database: Unknown line type ({}).", command_p[1]); continue; } XLine* xl = xlf->Generate(ServerInstance->Time(), ConvToNum<unsigned long>(command_p[5]), command_p[3], command_p[6], command_p[2]); xl->SetCreateTime(ConvToNum<time_t>(command_p[4])); if (!ServerInstance->XLines->AddLine(xl, nullptr)) { continue; delete xl; } if (xl->duration) { ServerInstance->SNO.WriteToSnoMask('x', "database: added a timed {}{} on {}, expires in {} (on {}): {}", xl->type, xl->type.length() <= 2 ? "-line" : "", xl->Displayable(), Duration::ToLongString(xl->duration), Time::FromNow(xl->duration), xl->reason); } else { ServerInstance->SNO.WriteToSnoMask('x', "database: added a permanent {}{} on {}: {}", xl->type, xl->type.length() <= 2 ? "-line" : "", xl->Displayable(), xl->reason); } } } stream.close(); return true; } }; MODULE_INIT(ModuleXLineDB) �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/src/server.cpp�����������������������������������������������������������������������0000664�0000000�0000000�00000010445�14771603147�0016154�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2020-2025 Sadie Powell <sadie@witchery.services> * Copyright (C) 2013-2014 Attila Molnar <attilamolnar@hush.com> * Copyright (C) 2012 Robby <robby@chatbelgie.be> * Copyright (C) 2012 ChrisTX <xpipe@hotmail.de> * Copyright (C) 2009 Daniel De Graaf <danieldg@inspircd.org> * Copyright (C) 2008 Craig Edwards <brain@inspircd.org> * Copyright (C) 2007-2008 Robin Burchell <robin+git@viroteck.net> * Copyright (C) 2007 Dennis Friis <peavey@inspircd.org> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include "inspircd.h" void InspIRCd::HandleSignal(sig_atomic_t signal) { switch (signal) { case SIGTERM: Exit(EXIT_FAILURE); #ifndef _WIN32 case SIGHUP: ServerInstance->SNO.WriteGlobalSno('r', "Rehashing due to SIGHUP"); Rehash(); break; #endif default: ServerInstance->Logs.Debug("SIGNAL", "BUG: InspIRCd::SignalHandler: unknown signal: {}", signal); break; } } void InspIRCd::Exit(int status) { #ifdef _WIN32 SetServiceStopped(status); #endif this->Cleanup(); ServerInstance = nullptr; delete this; exit(status); } void InspIRCd::Rehash(const std::string& uuid) { if (!ConfigThread) { ConfigThread = new ConfigReaderThread(uuid); ConfigThread->Start(); } } std::string UIDGenerator::GenerateSID(const std::string& servername, const std::string& serverdesc) { unsigned int sid = 0; for (const auto chr : servername) sid = 5 * sid + chr; for (const auto chr : serverdesc) sid = 5 * sid + chr; std::string sidstr = ConvToStr(sid % 1000); sidstr.insert(0, 3 - sidstr.length(), '0'); return sidstr; } void UIDGenerator::IncrementUID(unsigned int pos) { /* * Okay. The rules for generating a UID go like this... * -- > ABCDEFGHIJKLMNOPQRSTUVWXYZ --> 012345679 --> WRAP * That is, we start at A. When we reach Z, we go to 0. At 9, we go to * A again, in an iterative fashion.. so.. * AAA9 -> AABA, and so on. -- w00t */ // If we hit Z, wrap around to 0. if (current_uid[pos] == 'Z') { current_uid[pos] = '0'; } else if (current_uid[pos] == '9') { /* * Or, if we hit 9, wrap around to pos = 'A' and (pos - 1)++, * e.g. A9 -> BA -> BB .. */ current_uid[pos] = 'A'; if (pos == 3) { // At pos 3, if we hit '9', we've run out of available UIDs, and reset to AAA..AAA. return; } this->IncrementUID(pos - 1); } else { // Anything else, nobody gives a shit. Just increment. current_uid[pos]++; } } void UIDGenerator::init(const std::string& sid) { /* * Copy SID into the first three digits, 9's to the rest, null term at the end * Why 9? Well, we increment before we find, otherwise we have an unnecessary copy, and I want UID to start at AAA..AA * and not AA..AB. So by initialising to 99999, we force it to rollover to AAAAA on the first IncrementUID call. * Kind of silly, but I like how it looks. * -- w */ current_uid.resize(UUID_LENGTH, '9'); current_uid[0] = sid[0]; current_uid[1] = sid[1]; current_uid[2] = sid[2]; } /* * Retrieve the next valid UUID that is free for this server. */ std::string UIDGenerator::GetUID() { while (true) { // Add one to the last UID this->IncrementUID(UUID_LENGTH - 1); if (!ServerInstance->Users.FindUUID(current_uid)) break; /* * It's in use. We need to try the loop again. */ } return current_uid; } const std::string& Server::GetPublicName() const { if (!ServerInstance->Config->HideServer.empty()) return ServerInstance->Config->HideServer; return GetName(); } void Server::SendMetadata(const std::string& key, const std::string& data) const { // Do nothing for the local server. } void Server::SendMetadata(const Extensible* ext, const std::string& key, const std::string& data) const { // Do nothing for the local server. } ���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/src/snomasks.cpp���������������������������������������������������������������������0000664�0000000�0000000�00000007403�14771603147�0016504�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2021-2025 Sadie Powell <sadie@witchery.services> * Copyright (C) 2013-2014 Attila Molnar <attilamolnar@hush.com> * Copyright (C) 2013 Adam <Adam@anope.org> * Copyright (C) 2012 Robby <robby@chatbelgie.be> * Copyright (C) 2009-2010 Daniel De Graaf <danieldg@inspircd.org> * Copyright (C) 2008 Robin Burchell <robin+git@viroteck.net> * Copyright (C) 2007 Dennis Friis <peavey@inspircd.org> * Copyright (C) 2006 Craig Edwards <brain@inspircd.org> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include "inspircd.h" void SnomaskManager::FlushSnotices() { for (auto& mask : masks) mask.Flush(); } void SnomaskManager::EnableSnomask(char letter, const std::string& type) { if (letter >= 'a' && letter <= 'z') masks[letter - 'a'].Description = type; } void SnomaskManager::WriteToSnoMask(char letter, const std::string& text) { if (letter >= 'a' && letter <= 'z') masks[letter - 'a'].SendMessage(text, letter); if (letter >= 'A' && letter <= 'Z') masks[letter - 'A'].SendMessage(text, letter); } void SnomaskManager::WriteGlobalSno(char letter, const std::string& text) { WriteToSnoMask(letter, text); letter = toupper(letter); ServerInstance->PI->SendSNONotice(letter, text); } SnomaskManager::SnomaskManager() { EnableSnomask('a', "ANNOUNCEMENT"); EnableSnomask('c', "CONNECT"); EnableSnomask('k', "KILL"); EnableSnomask('o', "OPER"); EnableSnomask('q', "QUIT"); EnableSnomask('r', "REHASH"); } bool SnomaskManager::IsSnomask(char ch) { return (ch >= 'a' && ch <= 'z') || (ch >= 'A' && ch <= 'Z'); } bool SnomaskManager::IsSnomaskUsable(char ch) const { return IsSnomask(ch) && !masks[tolower(ch) - 'a'].Description.empty(); } void Snomask::SendMessage(const std::string& message, char letter) { if ((!ServerInstance->Config->NoSnoticeStack) && (message == LastMessage) && (letter == LastLetter)) { Count++; return; } this->Flush(); std::string desc = GetDescription(letter); ModResult modres; FIRST_MOD_RESULT(OnSendSnotice, modres, (letter, desc, message)); if (modres == MOD_RES_DENY) return; Snomask::Send(letter, desc, message); LastMessage = message; LastLetter = letter; Count++; } void Snomask::Flush() { if (Count > 1) { std::string desc = GetDescription(LastLetter); std::string msg = INSP_FORMAT("(last message repeated {} times)", Count); FOREACH_MOD(OnSendSnotice, (LastLetter, desc, msg)); Snomask::Send(LastLetter, desc, msg); } LastMessage.clear(); Count = 0; } void Snomask::Send(char letter, const std::string& desc, const std::string& msg) { ServerInstance->Logs.Normal(desc, msg); const std::string finalmsg = INSP_FORMAT("*** {}: {}", desc, msg); /* Only opers can receive snotices, so we iterate the oper list */ for (auto* user : ServerInstance->Users.all_opers) { // IsNoticeMaskSet() returns false for opers who aren't +s, no need to check for it separately if (IS_LOCAL(user) && user->IsNoticeMaskSet(letter)) user->WriteNotice(finalmsg); } } std::string Snomask::GetDescription(char letter) const { std::string ret; if (isupper(letter)) ret = "REMOTE"; if (!Description.empty()) ret += Description; else ret += INSP_FORMAT("SNO-{}", tolower(letter)); return ret; } �������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/src/socket.cpp�����������������������������������������������������������������������0000664�0000000�0000000�00000035503�14771603147�0016140�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2019 linuxdaemon <linuxdaemon.irc@gmail.com> * Copyright (C) 2017-2025 Sadie Powell <sadie@witchery.services> * Copyright (C) 2013 Daniel Vassdal <shutter@canternet.org> * Copyright (C) 2012 Robby <robby@chatbelgie.be> * Copyright (C) 2009-2011 Daniel De Graaf <danieldg@inspircd.org> * Copyright (C) 2008 Thomas Stagner <aquanight@gmail.com> * Copyright (C) 2006 Craig Edwards <brain@inspircd.org> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #ifndef _WIN32 # include <arpa/inet.h> # include <netinet/in.h> #endif #include "inspircd.h" #include "utility/string.h" namespace { #ifdef IPPROTO_SCTP // Checks whether the system can create SCTP sockets. bool CanCreateSCTPSocket() { int fd = socket(AF_INET, SOCK_STREAM, IPPROTO_SCTP); if (fd >= 0) { SocketEngine::Close(fd); return true; } return false; } #endif } bool InspIRCd::BindPort(const std::shared_ptr<ConfigTag>& tag, const irc::sockets::sockaddrs& sa, std::vector<ListenSocket*>& old_ports, sa_family_t protocol) { for (std::vector<ListenSocket*>::iterator n = old_ports.begin(); n != old_ports.end(); ++n) { ListenSocket* ls = *n; if (ls->bind_sa == sa && protocol == ls->bind_protocol) { // Replace tag, we know addr and port match, but other info (type, ssl) may not. ServerInstance->Logs.Debug("SOCKET", "Replacing listener on {} from old tag at {} with new tag from {}", sa.str(), ls->bind_tag->source.str(), tag->source.str()); ls->bind_tag = tag; ls->ResetIOHookProvider(); old_ports.erase(n); return true; } } auto* ll = new ListenSocket(tag, sa, protocol); if (!ll->HasFd()) { ServerInstance->Logs.Normal("SOCKET", "Failed to listen on {} from tag at {}: {}", sa.str(), tag->source.str(), SocketEngine::LastError()); delete ll; return false; } ServerInstance->Logs.Debug("SOCKET", "Added a listener on {} from tag at {}", sa.str(), tag->source.str()); ports.push_back(ll); return true; } size_t InspIRCd::BindPorts(FailedPortList& failed_ports) { size_t bound = 0; std::vector<ListenSocket*> old_ports(ports.begin(), ports.end()); for (const auto& [_, tag] : ServerInstance->Config->ConfTags("bind")) { // Are we creating a TCP/SCTP listener? const std::string address = tag->getString("address"); const std::string portlist = tag->getString("port"); if (!address.empty() || !portlist.empty()) { // InspIRCd supports IPv4 and IPv6 natively; no 4in6 required. if (strncasecmp(address.c_str(), "::ffff:", 7) == 0) this->Logs.Warning("SOCKET", "Using 4in6 (::ffff:) isn't recommended. You should bind IPv4 addresses directly instead."); // Try to parse the bind address. irc::sockets::sockaddrs bindspec(true); if (!bindspec.from_ip(address)) { failed_ports.emplace_back("Address is not valid: " + address, tag); continue; } // A TCP listener with no ports is not very useful. if (portlist.empty()) { failed_ports.emplace_back("No ports specified", bindspec, tag); continue; } irc::portparser portrange(portlist, false); while (long port = portrange.GetToken()) { // Check if the port is out of range. if (port <= std::numeric_limits<in_port_t>::min() || port > std::numeric_limits<in_port_t>::max()) { failed_ports.emplace_back(INSP_FORMAT("Port is not valid: {}", port), bindspec, tag); continue; } switch (bindspec.family()) { case AF_INET: bindspec.in4.sin_port = htons(static_cast<in_port_t>(port)); break; case AF_INET6: bindspec.in6.sin6_port = htons(static_cast<in_port_t>(port)); break; default: continue; // Should never happen. } std::vector<int> protocols; irc::spacesepstream protostream(tag->getString("protocols", "all", 1)); for (std::string protocol; protostream.GetToken(protocol); ) { if (insp::equalsci(protocol, "all")) { protocols.push_back(0); // IPPROTO_TCP #ifdef IPPROTO_SCTP if (CanCreateSCTPSocket()) protocols.push_back(IPPROTO_SCTP); #endif } else if (insp::equalsci(protocol, "sctp")) { #ifdef IPPROTO_SCTP protocols.push_back(IPPROTO_SCTP); #else failed_ports.emplace_back("Platform does not support SCTP", tag); #endif } else if (insp::equalsci(protocol, "tcp")) { protocols.push_back(0); // IPPROTO_TCP } else { failed_ports.emplace_back("Protocol is not valid: " + protocol, tag); } } for (const auto protocol : protocols) { if (!BindPort(tag, bindspec, old_ports, protocol)) failed_ports.emplace_back(SocketEngine::LastError(), bindspec, tag); else bound++; } } continue; } // Are we creating a UNIX listener? const std::string path = tag->getString("path"); if (!path.empty()) { // Expand the path relative to the config directory. const std::string fullpath = ServerInstance->Config->Paths.PrependRuntime(path); // UNIX socket paths are length limited to less than PATH_MAX. irc::sockets::sockaddrs bindspec; if (fullpath.length() > std::min(ServerInstance->Config->Limits.MaxHost, sizeof(bindspec.un.sun_path) - 1)) { failed_ports.emplace_back("Path is too long: " + fullpath, tag); continue; } // Check for characters which are problematic in the IRC message format. if (fullpath.find_first_of("\n\r\t!@: ") != std::string::npos) { failed_ports.emplace_back("Path contains invalid characters: " + fullpath, tag); continue; } bindspec.from_unix(fullpath); if (!BindPort(tag, bindspec, old_ports, 0)) failed_ports.emplace_back(SocketEngine::LastError(), bindspec, tag); else bound++; } } std::vector<ListenSocket*>::iterator n = ports.begin(); for (auto* old_port : old_ports) { while (n != ports.end() && *n != old_port) n++; if (n == ports.end()) { this->Logs.Warning("SOCKET", "Port bindings slipped out of vector, aborting close!"); break; } this->Logs.Debug("SOCKET", "Port binding {} was removed from the config file, closing.", (**n).bind_sa.str()); delete *n; // this keeps the iterator valid, pointing to the next element n = ports.erase(n); } return bound; } irc::sockets::sockaddrs::sockaddrs(bool initialize) { if (initialize) memset(this, 0, sizeof(*this)); } bool irc::sockets::sockaddrs::from_ip_port(const std::string& addr, in_port_t port) { if (addr.empty() || addr == "*") { if (ServerInstance->Config->WildcardIPv6) { memset(&in6.sin6_addr, 0, sizeof(in6.sin6_addr)); in6.sin6_family = AF_INET6; in6.sin6_port = htons(port); } else { memset(&in4.sin_addr, 0, sizeof(in4.sin_addr)); in4.sin_family = AF_INET; in4.sin_port = htons(port); } return true; } else if (inet_pton(AF_INET, addr.c_str(), &in4.sin_addr) > 0) { in4.sin_family = AF_INET; in4.sin_port = htons(port); return true; } else if (inet_pton(AF_INET6, addr.c_str(), &in6.sin6_addr) > 0) { in6.sin6_family = AF_INET6; in6.sin6_port = htons(port); return true; } return false; } bool irc::sockets::sockaddrs::from_unix(const std::string& path) { if (path.length() >= sizeof(un.sun_path)) return false; un.sun_family = AF_UNIX; memcpy(&un.sun_path, path.c_str(), path.length() + 1); return true; } bool irc::sockets::isunix(const std::string& file) { #ifndef _WIN32 struct stat sb; if (stat(file.c_str(), &sb) == 0 && S_ISSOCK(sb.st_mode)) return true; #endif return false; } sa_family_t irc::sockets::sockaddrs::family() const { return sa.sa_family; } bool irc::sockets::sockaddrs::is_local() const { switch (family()) { case AF_INET: return irc::sockets::cidr_mask("127.0.0.0/8").match(*this); case AF_INET6: return irc::sockets::cidr_mask("::1/128").match(*this); case AF_UNIX: return true; } // If we have reached this point then we have encountered a bug. ServerInstance->Logs.Debug("SOCKET", "BUG: irc::sockets::sockaddrs::is_local(): socket type {} is unknown!", family()); return false; } in_port_t irc::sockets::sockaddrs::port() const { switch (family()) { case AF_INET: return ntohs(in4.sin_port); case AF_INET6: return ntohs(in6.sin6_port); case AF_UNIX: return 0; } // If we have reached this point then we have encountered a bug. ServerInstance->Logs.Debug("SOCKET", "BUG: irc::sockets::sockaddrs::port(): socket type {} is unknown!", family()); return 0; } std::string irc::sockets::sockaddrs::addr() const { switch (family()) { case AF_INET: char ip4addr[INET_ADDRSTRLEN]; if (!inet_ntop(AF_INET, static_cast<const void*>(&in4.sin_addr), ip4addr, sizeof(ip4addr))) return "0.0.0.0"; return ip4addr; case AF_INET6: char ip6addr[INET6_ADDRSTRLEN]; if (!inet_ntop(AF_INET6, static_cast<const void*>(&in6.sin6_addr), ip6addr, sizeof(ip6addr))) return "0:0:0:0:0:0:0:0"; return ip6addr; case AF_UNIX: return un.sun_path; } // If we have reached this point then we have encountered a bug. ServerInstance->Logs.Debug("SOCKET", "BUG: irc::sockets::sockaddrs::addr(): socket type {} is unknown!", family()); return "<unknown>"; } std::string irc::sockets::sockaddrs::str() const { switch (family()) { case AF_INET: char ip4addr[INET_ADDRSTRLEN]; if (!inet_ntop(AF_INET, static_cast<const void*>(&in4.sin_addr), ip4addr, sizeof(ip4addr))) strcpy(ip4addr, "0.0.0.0"); return INSP_FORMAT("{}:{}", ip4addr, ntohs(in4.sin_port)); case AF_INET6: char ip6addr[INET6_ADDRSTRLEN]; if (!inet_ntop(AF_INET6, static_cast<const void*>(&in6.sin6_addr), ip6addr, sizeof(ip6addr))) strcpy(ip6addr, "0:0:0:0:0:0:0:0"); return INSP_FORMAT("[{}]:{}", ip6addr, ntohs(in6.sin6_port)); case AF_UNIX: return un.sun_path; } // If we have reached this point then we have encountered a bug. ServerInstance->Logs.Debug("SOCKET", "BUG: irc::sockets::sockaddrs::str(): socket type {} is unknown!", family()); return "<unknown>"; } socklen_t irc::sockets::sockaddrs::sa_size() const { switch (family()) { case AF_INET: return sizeof(in4); case AF_INET6: return sizeof(in6); case AF_UNIX: return sizeof(un); } // If we have reached this point then we have encountered a bug. ServerInstance->Logs.Debug("SOCKET", "BUG: irc::sockets::sockaddrs::sa_size(): socket type {} is unknown!", family()); return 0; } bool irc::sockets::sockaddrs::operator==(const irc::sockets::sockaddrs& other) const { if (family() != other.family()) return false; switch (family()) { case AF_INET: return (in4.sin_port == other.in4.sin_port) && (in4.sin_addr.s_addr == other.in4.sin_addr.s_addr); case AF_INET6: return (in6.sin6_port == other.in6.sin6_port) && !memcmp(in6.sin6_addr.s6_addr, other.in6.sin6_addr.s6_addr, 16); case AF_UNIX: return !strcmp(un.sun_path, other.un.sun_path); } // If we have reached this point then we have encountered a bug. ServerInstance->Logs.Debug("SOCKET", "BUG: irc::sockets::sockaddrs::operator==(): socket type {} is unknown!", family()); return !memcmp(this, &other, sizeof(*this)); } static void sa2cidr(irc::sockets::cidr_mask& cidr, const irc::sockets::sockaddrs& sa, unsigned char range) { const unsigned char* base; unsigned char target_byte; memset(cidr.bits, 0, sizeof(cidr.bits)); cidr.type = sa.family(); switch (cidr.type) { case AF_UNIX: // XXX: UNIX sockets don't support CIDR. This fix is non-ideal but I can't // really think of another way to handle it. cidr.length = 0; return; case AF_INET: cidr.length = range > 32 ? 32 : range; target_byte = sizeof(sa.in4.sin_addr); base = reinterpret_cast<const unsigned char*>(&sa.in4.sin_addr); break; case AF_INET6: cidr.length = range > 128 ? 128 : range; target_byte = sizeof(sa.in6.sin6_addr); base = reinterpret_cast<const unsigned char*>(&sa.in6.sin6_addr); break; default: // If we have reached this point then we have encountered a bug. ServerInstance->Logs.Debug("SOCKET", "BUG: sa2cidr(): socket type {} is unknown!", cidr.type); cidr.length = 0; return; } unsigned int border = cidr.length / 8; unsigned int bitmask = (0xFF00 >> (range & 7)) & 0xFF; for(unsigned int i=0; i < target_byte; i++) { if (i < border) cidr.bits[i] = base[i]; else if (i == border) cidr.bits[i] = base[i] & bitmask; else return; } } irc::sockets::cidr_mask::cidr_mask(const irc::sockets::sockaddrs& sa, unsigned char range) { sa2cidr(*this, sa, range); } irc::sockets::cidr_mask::cidr_mask(const std::string& mask) { std::string::size_type bits_chars = mask.rfind('/'); irc::sockets::sockaddrs sa; if (bits_chars == std::string::npos) { if (!sa.from_ip(mask)) { memset(this, 0, sizeof(*this)); return; } sa2cidr(*this, sa, 128); } else { unsigned char range = ConvToNum<unsigned char>(mask.substr(bits_chars + 1)); if (!sa.from_ip(mask.substr(0, bits_chars))) { memset(this, 0, sizeof(*this)); return; } sa2cidr(*this, sa, range); } } std::string irc::sockets::cidr_mask::str() const { irc::sockets::sockaddrs sa; sa.sa.sa_family = type; unsigned char* base; size_t len; unsigned char maxlen; switch (type) { case AF_INET: base = reinterpret_cast<unsigned char*>(&sa.in4.sin_addr); len = 4; maxlen = 32; break; case AF_INET6: base = reinterpret_cast<unsigned char*>(&sa.in6.sin6_addr); len = 16; maxlen = 128; break; case AF_UNIX: // TODO: make bits a vector<uint8_t> so we can return the actual path here. return "/*"; default: // If we have reached this point then we have encountered a bug. ServerInstance->Logs.Debug("SOCKET", "BUG: irc::sockets::cidr_mask::str(): socket type {} is unknown!", type); return "<unknown>"; } memcpy(base, bits, len); std::string value = sa.addr(); if (length < maxlen) { value.push_back('/'); value.append(ConvToStr(static_cast<uint16_t>(length))); } return value; } bool irc::sockets::cidr_mask::operator==(const cidr_mask& other) const { return type == other.type && length == other.length && 0 == memcmp(bits, other.bits, 16); } bool irc::sockets::cidr_mask::operator<(const cidr_mask& other) const { if (type != other.type) return type < other.type; if (length != other.length) return length < other.length; return memcmp(bits, other.bits, 16) < 0; } bool irc::sockets::cidr_mask::match(const irc::sockets::sockaddrs& addr) const { if (addr.family() != type) return false; irc::sockets::cidr_mask tmp(addr, length); return tmp == *this; } ���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/src/socketengine.cpp�����������������������������������������������������������������0000664�0000000�0000000�00000021634�14771603147�0017326�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2021 Dominic Hamon * Copyright (C) 2017-2018, 2021-2024 Sadie Powell <sadie@witchery.services> * Copyright (C) 2017 Robin Burchell <robin+git@viroteck.net> * Copyright (C) 2013-2014 Adam <Adam@anope.org> * Copyright (C) 2012, 2014-2015 Attila Molnar <attilamolnar@hush.com> * Copyright (C) 2012 Robby <robby@chatbelgie.be> * Copyright (C) 2012 ChrisTX <xpipe@hotmail.de> * Copyright (C) 2009 Daniel De Graaf <danieldg@inspircd.org> * Copyright (C) 2007 burlex * Copyright (C) 2007 Dennis Friis <peavey@inspircd.org> * Copyright (C) 2006-2008 Craig Edwards <brain@inspircd.org> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #ifndef _WIN32 # include <fcntl.h> # include <sys/resource.h> # include <unistd.h> #endif #include <fmt/color.h> #include "inspircd.h" /** Reference table, contains all current handlers **/ std::vector<EventHandler*> SocketEngine::ref; /** Current number of descriptors in the engine */ size_t SocketEngine::CurrentSetSize = 0; /** List of handlers that want a trial read/write */ std::set<int> SocketEngine::trials; size_t SocketEngine::MaxSetSize = 0; /** Socket engine statistics: count of various events, bandwidth usage */ SocketEngine::Statistics SocketEngine::stats; void EventHandler::SetFd(int FD) { this->fd = FD; } void EventHandler::OnEventHandlerWrite() { } void EventHandler::OnEventHandlerError(int errornum) { } void SocketEngine::InitError() { fmt::println(stderr, "{} Socket engine initialization failed. {}.", fmt::styled("FATAL ERROR!", fmt::emphasis::bold | fmt::fg(fmt::terminal_color::red)), strerror(errno)); exit(EXIT_FAILURE); } void SocketEngine::LookupMaxFds() { #if defined _WIN32 MaxSetSize = FD_SETSIZE; #else struct rlimit limits; if (!getrlimit(RLIMIT_NOFILE, &limits)) MaxSetSize = limits.rlim_cur; #if defined __APPLE__ limits.rlim_cur = limits.rlim_max == RLIM_INFINITY ? OPEN_MAX : limits.rlim_max; #else limits.rlim_cur = limits.rlim_max; #endif if (!setrlimit(RLIMIT_NOFILE, &limits)) MaxSetSize = limits.rlim_cur; #endif } void SocketEngine::ChangeEventMask(EventHandler* eh, int change) { int old_m = eh->event_mask; int new_m = old_m; // if we are changing read/write type, remove the previously set bit if (change & FD_WANT_READ_MASK) new_m &= ~FD_WANT_READ_MASK; if (change & FD_WANT_WRITE_MASK) new_m &= ~FD_WANT_WRITE_MASK; // if adding a trial read/write, insert it into the set if (change & FD_TRIAL_NOTE_MASK && !(old_m & FD_TRIAL_NOTE_MASK)) trials.insert(eh->GetFd()); new_m |= change; if (new_m == old_m) return; eh->event_mask = new_m; OnSetEvent(eh, old_m, new_m); } void SocketEngine::DispatchTrialWrites() { std::vector<int> working_list; working_list.reserve(trials.size()); working_list.assign(trials.begin(), trials.end()); trials.clear(); for(int fd : working_list) { EventHandler* eh = GetRef(fd); if (!eh) continue; int mask = eh->event_mask; eh->event_mask &= ~(FD_ADD_TRIAL_READ | FD_ADD_TRIAL_WRITE); if ((mask & (FD_ADD_TRIAL_READ | FD_READ_WILL_BLOCK)) == FD_ADD_TRIAL_READ) eh->OnEventHandlerRead(); if ((mask & (FD_ADD_TRIAL_WRITE | FD_WRITE_WILL_BLOCK)) == FD_ADD_TRIAL_WRITE) eh->OnEventHandlerWrite(); } } bool SocketEngine::AddFdRef(EventHandler* eh) { int fd = eh->GetFd(); if (HasFd(fd)) return false; while (static_cast<unsigned int>(fd) >= ref.size()) ref.resize(ref.empty() ? 1 : (ref.size() * 2)); ref[fd] = eh; CurrentSetSize++; return true; } void SocketEngine::DelFdRef(EventHandler* eh) { int fd = eh->GetFd(); if (GetRef(fd) == eh) { ref[fd] = nullptr; CurrentSetSize--; } } bool SocketEngine::HasFd(int fd) { return GetRef(fd) != nullptr; } EventHandler* SocketEngine::GetRef(int fd) { if (fd < 0 || static_cast<size_t>(fd) >= ref.size()) return nullptr; return ref[fd]; } int SocketEngine::Accept(EventHandler* eh, sockaddr* addr, socklen_t* addrlen) { return accept(eh->GetFd(), addr, addrlen); } int SocketEngine::Close(EventHandler* eh) { DelFd(eh); int ret = Close(eh->GetFd()); eh->SetFd(-1); return ret; } int SocketEngine::Close(int fd) { #ifdef _WIN32 return closesocket(fd); #else return close(fd); #endif } int SocketEngine::Blocking(int fd) { #ifdef _WIN32 unsigned long opt = 0; return ioctlsocket(fd, FIONBIO, &opt); #else int flags = fcntl(fd, F_GETFL, 0); return fcntl(fd, F_SETFL, flags & ~O_NONBLOCK); #endif } int SocketEngine::NonBlocking(int fd) { #ifdef _WIN32 unsigned long opt = 1; return ioctlsocket(fd, FIONBIO, &opt); #else int flags = fcntl(fd, F_GETFL, 0); return fcntl(fd, F_SETFL, flags | O_NONBLOCK); #endif } ssize_t SocketEngine::RecvFrom(EventHandler* eh, void* buf, size_t len, int flags, sockaddr* from, socklen_t* fromlen) { ssize_t nbRecvd = recvfrom(eh->GetFd(), static_cast<char*>(buf), len, flags, from, fromlen); stats.UpdateReadCounters(nbRecvd); return nbRecvd; } ssize_t SocketEngine::Send(EventHandler* eh, const void* buf, size_t len, int flags) { ssize_t nbSent = send(eh->GetFd(), static_cast<const char*>(buf), len, flags); stats.UpdateWriteCounters(nbSent); return nbSent; } ssize_t SocketEngine::Recv(EventHandler* eh, void* buf, size_t len, int flags) { ssize_t nbRecvd = recv(eh->GetFd(), static_cast<char*>(buf), len, flags); stats.UpdateReadCounters(nbRecvd); return nbRecvd; } ssize_t SocketEngine::SendTo(EventHandler* eh, const void* buf, size_t len, int flags, const irc::sockets::sockaddrs& address) { ssize_t nbSent = sendto(eh->GetFd(), static_cast<const char*>(buf), len, flags, &address.sa, address.sa_size()); stats.UpdateWriteCounters(nbSent); return nbSent; } ssize_t SocketEngine::WriteV(EventHandler* eh, const IOVector* iov, int count) { ssize_t sent = writev(eh->GetFd(), iov, count); stats.UpdateWriteCounters(sent); return sent; } #ifdef _WIN32 int SocketEngine::WriteV(EventHandler* eh, const iovec* iovec, int count) { // On Windows the fields in iovec are not in the order required by the Winsock API; IOVector has // the fields in the correct order. // Create temporary IOVectors from the iovecs and pass them to the WriteV() method that accepts the // platform's native struct. IOVector wiovec[128]; count = std::min(count, static_cast<int>(sizeof(wiovec) / sizeof(IOVector))); for (int i = 0; i < count; i++) { wiovec[i].iov_len = iovec[i].iov_len; wiovec[i].iov_base = reinterpret_cast<char*>(iovec[i].iov_base); } return WriteV(eh, wiovec, count); } #endif int SocketEngine::Connect(EventHandler* eh, const irc::sockets::sockaddrs& address) { int ret = connect(eh->GetFd(), &address.sa, address.sa_size()); #ifdef _WIN32 if ((ret == SOCKET_ERROR) && (WSAGetLastError() == WSAEWOULDBLOCK)) errno = EINPROGRESS; #endif return ret; } int SocketEngine::Shutdown(EventHandler* eh, int how) { return shutdown(eh->GetFd(), how); } int SocketEngine::Bind(EventHandler* eh, const irc::sockets::sockaddrs& addr) { return bind(eh->GetFd(), &addr.sa, addr.sa_size()); } int SocketEngine::Listen(EventHandler* eh, int backlog) { return listen(eh->GetFd(), backlog); } void SocketEngine::Statistics::UpdateReadCounters(ssize_t len_in) { CheckFlush(); ReadEvents++; if (len_in > 0) indata += static_cast<size_t>(len_in); else if (len_in < 0) ErrorEvents++; } void SocketEngine::Statistics::UpdateWriteCounters(ssize_t len_out) { CheckFlush(); WriteEvents++; if (len_out > 0) outdata += static_cast<size_t>(len_out); else if (len_out < 0) ErrorEvents++; } void SocketEngine::Statistics::CheckFlush() const { // Reset the in/out byte counters if it has been more than a second time_t now = ServerInstance->Time(); if (lastempty != now) { lastempty = now; indata = outdata = 0; } } void SocketEngine::Statistics::GetBandwidth(float& kbitpersec_in, float& kbitpersec_out, float& kbitpersec_total) const { CheckFlush(); float in_kbit = static_cast<float>(indata) * 8; float out_kbit = static_cast<float>(outdata) * 8; kbitpersec_total = ((in_kbit + out_kbit) / 1024); kbitpersec_in = in_kbit / 1024; kbitpersec_out = out_kbit / 1024; } std::string SocketEngine::LastError() { #ifndef _WIN32 return strerror(errno); #else std::string err = GetErrorMessage(WSAGetLastError()); for (size_t pos = 0; ((pos = err.find_first_of("\r\n", pos)) != std::string::npos); ) err[pos] = ' '; return err; #endif } std::string SocketEngine::GetError(int errnum) { #ifndef _WIN32 return strerror(errnum); #else WSASetLastError(errnum); return LastError(); #endif } ����������������������������������������������������������������������������������������������������inspircd-4.7.0/src/socketengines/�������������������������������������������������������������������0000775�0000000�0000000�00000000000�14771603147�0016777�5����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/src/socketengines/epoll.cpp����������������������������������������������������������0000664�0000000�0000000�00000014001�14771603147�0020612�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2017, 2019, 2022-2023 Sadie Powell <sadie@witchery.services> * Copyright (C) 2014-2015 Attila Molnar <attilamolnar@hush.com> * Copyright (C) 2014, 2016 Adam <Adam@anope.org> * Copyright (C) 2012 Robby <robby@chatbelgie.be> * Copyright (C) 2012 Ariadne Conill <ariadne@dereferenced.org> * Copyright (C) 2009-2010 Daniel De Graaf <danieldg@inspircd.org> * Copyright (C) 2008 Thomas Stagner <aquanight@gmail.com> * Copyright (C) 2007-2008 Dennis Friis <peavey@inspircd.org> * Copyright (C) 2006-2008 Craig Edwards <brain@inspircd.org> * Copyright (C) 2006, 2008 Robin Burchell <robin+git@viroteck.net> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include "inspircd.h" #include <sys/epoll.h> #include <sys/resource.h> /** A specialisation of the SocketEngine class, designed to use linux 2.6 epoll(). */ namespace { int EngineHandle; /** These are used by epoll() to hold socket events */ std::vector<struct epoll_event> events(16); } void SocketEngine::Init() { LookupMaxFds(); // 128 is not a maximum, just a hint at the eventual number of sockets that may be polled, // and it is completely ignored by 2.6.8 and later kernels, except it must be larger than zero. EngineHandle = epoll_create(128); if (EngineHandle == -1) InitError(); } void SocketEngine::RecoverFromFork() { } void SocketEngine::Deinit() { Close(EngineHandle); } static unsigned mask_to_epoll(int event_mask) { unsigned rv = 0; if (event_mask & (FD_WANT_POLL_READ | FD_WANT_POLL_WRITE | FD_WANT_SINGLE_WRITE)) { // we need to use standard polling on this FD if (event_mask & (FD_WANT_POLL_READ | FD_WANT_FAST_READ)) rv |= EPOLLIN; if (event_mask & (FD_WANT_POLL_WRITE | FD_WANT_FAST_WRITE | FD_WANT_SINGLE_WRITE)) rv |= EPOLLOUT; } else { // we can use edge-triggered polling on this FD rv = EPOLLET; if (event_mask & (FD_WANT_FAST_READ | FD_WANT_EDGE_READ)) rv |= EPOLLIN; if (event_mask & (FD_WANT_FAST_WRITE | FD_WANT_EDGE_WRITE)) rv |= EPOLLOUT; } return rv; } bool SocketEngine::AddFd(EventHandler* eh, int event_mask) { int fd = eh->GetFd(); if (!eh->HasFd()) { ServerInstance->Logs.Debug("SOCKET", "AddFd out of range: (fd: {})", fd); return false; } if (!SocketEngine::AddFdRef(eh)) { ServerInstance->Logs.Debug("SOCKET", "Attempt to add duplicate fd: {}", fd); return false; } struct epoll_event ev; memset(&ev, 0, sizeof(ev)); ev.events = mask_to_epoll(event_mask); ev.data.ptr = static_cast<void*>(eh); int i = epoll_ctl(EngineHandle, EPOLL_CTL_ADD, fd, &ev); if (i < 0) { ServerInstance->Logs.Debug("SOCKET", "Error adding fd: {} to socketengine: {}", fd, strerror(errno)); return false; } ServerInstance->Logs.Debug("SOCKET", "New file descriptor: {}", fd); eh->SetEventMask(event_mask); ResizeDouble(events); return true; } void SocketEngine::OnSetEvent(EventHandler* eh, int old_mask, int new_mask) { unsigned old_events = mask_to_epoll(old_mask); unsigned new_events = mask_to_epoll(new_mask); if (old_events != new_events) { // ok, we actually have something to tell the kernel about struct epoll_event ev; memset(&ev, 0, sizeof(ev)); ev.events = new_events; ev.data.ptr = static_cast<void*>(eh); epoll_ctl(EngineHandle, EPOLL_CTL_MOD, eh->GetFd(), &ev); } } void SocketEngine::DelFd(EventHandler* eh) { int fd = eh->GetFd(); if (!eh->HasFd()) { ServerInstance->Logs.Debug("SOCKET", "DelFd out of range: (fd: {})", fd); return; } // Do not initialize epoll_event because for EPOLL_CTL_DEL operations the event is ignored and can be NULL. // In kernel versions before 2.6.9, the EPOLL_CTL_DEL operation required a non-NULL pointer in event, // even though this argument is ignored. Since Linux 2.6.9, event can be specified as NULL when using EPOLL_CTL_DEL. struct epoll_event ev; int i = epoll_ctl(EngineHandle, EPOLL_CTL_DEL, fd, &ev); if (i < 0) { ServerInstance->Logs.Debug("SOCKET", "epoll_ctl can't remove socket: {}", strerror(errno)); } SocketEngine::DelFdRef(eh); ServerInstance->Logs.Debug("SOCKET", "Remove file descriptor: {}", fd); } int SocketEngine::DispatchEvents() { int i = epoll_wait(EngineHandle, events.data(), static_cast<int>(events.size()), 1000); ServerInstance->UpdateTime(); stats.TotalEvents += i; for (int j = 0; j < i; j++) { // Copy these in case the vector gets resized and ev invalidated const epoll_event ev = events[j]; EventHandler* const eh = static_cast<EventHandler*>(ev.data.ptr); if (!eh->HasFd()) continue; const int fd = eh->GetFd(); if (ev.events & EPOLLHUP) { stats.ErrorEvents++; eh->OnEventHandlerError(0); continue; } if (ev.events & EPOLLERR) { stats.ErrorEvents++; /* Get error number */ socklen_t codesize = sizeof(int); int errcode; if (getsockopt(fd, SOL_SOCKET, SO_ERROR, &errcode, &codesize) < 0) errcode = errno; eh->OnEventHandlerError(errcode); continue; } int mask = eh->GetEventMask(); if (ev.events & EPOLLIN) mask &= ~FD_READ_WILL_BLOCK; if (ev.events & EPOLLOUT) { mask &= ~FD_WRITE_WILL_BLOCK; if (mask & FD_WANT_SINGLE_WRITE) { int nm = mask & ~FD_WANT_SINGLE_WRITE; OnSetEvent(eh, mask, nm); mask = nm; } } eh->SetEventMask(mask); if (ev.events & EPOLLIN) { eh->OnEventHandlerRead(); if (eh != GetRef(fd)) // whoa! we got deleted, better not give out the write event continue; } if (ev.events & EPOLLOUT) { eh->OnEventHandlerWrite(); } } return i; } �������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/src/socketengines/kqueue.cpp���������������������������������������������������������0000664�0000000�0000000�00000013270�14771603147�0021005�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2021 Dominic Hamon * Copyright (C) 2014-2015 Attila Molnar <attilamolnar@hush.com> * Copyright (C) 2014 Adam <Adam@anope.org> * Copyright (C) 2012, 2017, 2019, 2022-2023 Sadie Powell <sadie@witchery.services> * Copyright (C) 2012 Robby <robby@chatbelgie.be> * Copyright (C) 2009-2010 Daniel De Graaf <danieldg@inspircd.org> * Copyright (C) 2009 Uli Schlachter <psychon@znc.in> * Copyright (C) 2008 Thomas Stagner <aquanight@gmail.com> * Copyright (C) 2007 Dennis Friis <peavey@inspircd.org> * Copyright (C) 2006-2008 Craig Edwards <brain@inspircd.org> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include "inspircd.h" #include <sys/types.h> #include <sys/event.h> #include <sys/sysctl.h> /** A specialisation of the SocketEngine class, designed to use BSD kqueue(). */ namespace { int EngineHandle; unsigned int ChangePos = 0; /** These are used by kqueue() to hold socket events */ std::vector<struct kevent> ke_list(16); /** Pending changes */ std::vector<struct kevent> changelist(8); #if defined __NetBSD__ && __NetBSD_Version__ <= 999001400 inline intptr_t udata_cast(EventHandler* eh) { // On NetBSD <10 the last parameter of EV_SET is intptr_t. return reinterpret_cast<intptr_t>(eh); } #else inline void* udata_cast(EventHandler* eh) { // On other platforms the last parameter of EV_SET is void*. return static_cast<void*>(eh); } #endif } /** Initialize the kqueue engine */ void SocketEngine::Init() { LookupMaxFds(); RecoverFromFork(); } void SocketEngine::RecoverFromFork() { /* * The only bad thing about kqueue is that its fd cant survive a fork and is not inherited. * BUM HATS. * */ EngineHandle = kqueue(); if (EngineHandle == -1) InitError(); } /** Shutdown the kqueue engine */ void SocketEngine::Deinit() { Close(EngineHandle); } static struct kevent* GetChangeKE() { if (ChangePos >= changelist.size()) changelist.resize(changelist.size() * 2); return &changelist[ChangePos++]; } bool SocketEngine::AddFd(EventHandler* eh, int event_mask) { if (!eh->HasFd()) return false; if (!SocketEngine::AddFdRef(eh)) return false; // We always want to read from the socket... int fd = eh->GetFd(); struct kevent* ke = GetChangeKE(); EV_SET(ke, fd, EVFILT_READ, EV_ADD, 0, 0, udata_cast(eh)); ServerInstance->Logs.Debug("SOCKET", "New file descriptor: {}", fd); eh->SetEventMask(event_mask); OnSetEvent(eh, 0, event_mask); ResizeDouble(ke_list); return true; } void SocketEngine::DelFd(EventHandler* eh) { int fd = eh->GetFd(); if (!eh->HasFd()) { ServerInstance->Logs.Debug("SOCKET", "DelFd() on invalid fd: {}", fd); return; } // First remove the write filter ignoring errors, since we can't be // sure if there are actually any write filters registered. struct kevent* ke = GetChangeKE(); EV_SET(ke, eh->GetFd(), EVFILT_WRITE, EV_DELETE, 0, 0, nullptr); // Then remove the read filter. ke = GetChangeKE(); EV_SET(ke, eh->GetFd(), EVFILT_READ, EV_DELETE, 0, 0, nullptr); SocketEngine::DelFdRef(eh); ServerInstance->Logs.Debug("SOCKET", "Remove file descriptor: {}", fd); } void SocketEngine::OnSetEvent(EventHandler* eh, int old_mask, int new_mask) { if ((new_mask & FD_WANT_POLL_WRITE) && !(old_mask & FD_WANT_POLL_WRITE)) { // new poll-style write struct kevent* ke = GetChangeKE(); EV_SET(ke, eh->GetFd(), EVFILT_WRITE, EV_ADD, 0, 0, udata_cast(eh)); } else if ((old_mask & FD_WANT_POLL_WRITE) && !(new_mask & FD_WANT_POLL_WRITE)) { // removing poll-style write struct kevent* ke = GetChangeKE(); EV_SET(ke, eh->GetFd(), EVFILT_WRITE, EV_DELETE, 0, 0, nullptr); } if ((new_mask & (FD_WANT_FAST_WRITE | FD_WANT_SINGLE_WRITE)) && !(old_mask & (FD_WANT_FAST_WRITE | FD_WANT_SINGLE_WRITE))) { struct kevent* ke = GetChangeKE(); EV_SET(ke, eh->GetFd(), EVFILT_WRITE, EV_ADD | EV_ONESHOT, 0, 0, udata_cast(eh)); } } int SocketEngine::DispatchEvents() { struct timespec ts; ts.tv_nsec = 0; ts.tv_sec = 1; int i = kevent(EngineHandle, &changelist.front(), ChangePos, &ke_list.front(), static_cast<int>(ke_list.size()), &ts); ChangePos = 0; ServerInstance->UpdateTime(); if (i < 0) return i; stats.TotalEvents += i; for (int j = 0; j < i; j++) { // This can't be a static_cast because udata is intptr_t on NetBSD. struct kevent& kev = ke_list[j]; EventHandler* eh = reinterpret_cast<EventHandler*>(kev.udata); if (!eh || !eh->HasFd()) continue; // Copy this in case the vector gets resized and kev invalidated const short filter = kev.filter; if (kev.flags & EV_EOF) { stats.ErrorEvents++; eh->OnEventHandlerError(kev.fflags); continue; } if (filter == EVFILT_WRITE) { /* When mask is FD_WANT_FAST_WRITE or FD_WANT_SINGLE_WRITE, * we set a one-shot write, so we need to clear that bit * to detect when it set again. */ const int bits_to_clr = FD_WANT_SINGLE_WRITE | FD_WANT_FAST_WRITE | FD_WRITE_WILL_BLOCK; eh->SetEventMask(eh->GetEventMask() & ~bits_to_clr); eh->OnEventHandlerWrite(); } else if (filter == EVFILT_READ) { eh->SetEventMask(eh->GetEventMask() & ~FD_READ_WILL_BLOCK); eh->OnEventHandlerRead(); } } return i; } ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/src/socketengines/poll.cpp�����������������������������������������������������������0000664�0000000�0000000�00000013257�14771603147�0020461�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2021 Dominic Hamon * Copyright (C) 2014-2015 Attila Molnar <attilamolnar@hush.com> * Copyright (C) 2014, 2017 Adam <Adam@anope.org> * Copyright (C) 2013, 2016-2017, 2022-2023 Sadie Powell <sadie@witchery.services> * Copyright (C) 2012 Robby <robby@chatbelgie.be> * Copyright (C) 2009-2010 Daniel De Graaf <danieldg@inspircd.org> * Copyright (C) 2009 Uli Schlachter <psychon@znc.in> * Copyright (C) 2008 Robin Burchell <robin+git@viroteck.net> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include "inspircd.h" #include <poll.h> #include <sys/resource.h> /** A specialisation of the SocketEngine class, designed to use poll(). */ namespace { /** These are used by poll() to hold socket events */ std::vector<struct pollfd> events(16); /** This vector maps fds to an index in the events array. */ std::vector<int> fd_mappings(16, -1); } void SocketEngine::Init() { LookupMaxFds(); } void SocketEngine::Deinit() { } void SocketEngine::RecoverFromFork() { } static int mask_to_poll(int event_mask) { int rv = 0; if (event_mask & (FD_WANT_POLL_READ | FD_WANT_FAST_READ)) rv |= POLLIN; if (event_mask & (FD_WANT_POLL_WRITE | FD_WANT_FAST_WRITE | FD_WANT_SINGLE_WRITE)) rv |= POLLOUT; return rv; } bool SocketEngine::AddFd(EventHandler* eh, int event_mask) { int fd = eh->GetFd(); if (!eh->HasFd()) { ServerInstance->Logs.Debug("SOCKET", "AddFd out of range: (fd: {})", fd); return false; } if (static_cast<unsigned int>(fd) < fd_mappings.size() && fd_mappings[fd] != -1) { ServerInstance->Logs.Debug("SOCKET", "Attempt to add duplicate fd: {}", fd); return false; } unsigned int index = static_cast<unsigned int>(CurrentSetSize); if (!SocketEngine::AddFdRef(eh)) { ServerInstance->Logs.Debug("SOCKET", "Attempt to add duplicate fd: {}", fd); return false; } while (static_cast<unsigned int>(fd) >= fd_mappings.size()) fd_mappings.resize(fd_mappings.size() * 2, -1); fd_mappings[fd] = index; ResizeDouble(events); events[index].fd = fd; events[index].events = mask_to_poll(event_mask); ServerInstance->Logs.Debug("SOCKET", "New file descriptor: {} ({}; index {})", fd, events[index].events, index); eh->SetEventMask(event_mask); return true; } void SocketEngine::OnSetEvent(EventHandler* eh, int old_mask, int new_mask) { int fd = eh->GetFd(); if (!eh->HasFd() || static_cast<unsigned int>(fd) >= fd_mappings.size() || fd_mappings[fd] == -1) { ServerInstance->Logs.Debug("SOCKET", "SetEvents() on unknown fd: {}", eh->GetFd()); return; } events[fd_mappings[fd]].events = mask_to_poll(new_mask); } void SocketEngine::DelFd(EventHandler* eh) { int fd = eh->GetFd(); if (!eh->HasFd()) { ServerInstance->Logs.Debug("SOCKET", "DelFd out of range: (fd: {})", fd); return; } if (static_cast<unsigned int>(fd) >= fd_mappings.size() || fd_mappings[fd] == -1) { ServerInstance->Logs.Debug("SOCKET", "DelFd() on unknown fd: {}", fd); return; } unsigned int index = fd_mappings[fd]; unsigned int last_index = static_cast<unsigned int>(CurrentSetSize - 1); int last_fd = events[last_index].fd; if (index != last_index) { // We need to move the last fd we got into this gap (gaps are evil!) // So update the mapping for the last fd to its new position fd_mappings[last_fd] = index; // move last_fd from last_index into index events[index].fd = last_fd; events[index].events = events[last_index].events; } // Now remove all data for the last fd we got into out list. // Above code made sure this always is right fd_mappings[fd] = -1; events[last_index].fd = 0; events[last_index].events = 0; SocketEngine::DelFdRef(eh); ServerInstance->Logs.Debug("SOCKET", "Remove file descriptor: {} (index: {}) " "(Filled gap with: {} (index: {}))", fd, index, last_fd, last_index); } int SocketEngine::DispatchEvents() { int i = poll(&events[0], static_cast<unsigned int>(CurrentSetSize), 1000); int processed = 0; ServerInstance->UpdateTime(); for (size_t index = 0; index < CurrentSetSize && processed < i; index++) { struct pollfd& pfd = events[index]; // Copy these in case the vector gets resized and pfd invalidated const int fd = pfd.fd; const short revents = pfd.revents; if (revents) processed++; EventHandler* eh = GetRef(fd); if (!eh) continue; if (revents & POLLHUP) { eh->OnEventHandlerError(0); continue; } if (revents & POLLERR) { // Get error number socklen_t codesize = sizeof(int); int errcode; if (getsockopt(fd, SOL_SOCKET, SO_ERROR, &errcode, &codesize) < 0) errcode = errno; eh->OnEventHandlerError(errcode); continue; } if (revents & POLLIN) { eh->SetEventMask(eh->GetEventMask() & ~FD_READ_WILL_BLOCK); eh->OnEventHandlerRead(); if (eh != GetRef(fd)) // whoops, deleted out from under us continue; } if (revents & POLLOUT) { int mask = eh->GetEventMask(); mask &= ~(FD_WRITE_WILL_BLOCK | FD_WANT_SINGLE_WRITE); eh->SetEventMask(mask); // The vector could've been resized, reference can be invalid by now; don't use it events[index].events = mask_to_poll(mask); eh->OnEventHandlerWrite(); } } return i; } �������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/src/socketengines/select.cpp���������������������������������������������������������0000664�0000000�0000000�00000010320�14771603147�0020756�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2017, 2019, 2022-2023 Sadie Powell <sadie@witchery.services> * Copyright (C) 2013-2015 Attila Molnar <attilamolnar@hush.com> * Copyright (C) 2012 Robby <robby@chatbelgie.be> * Copyright (C) 2012 ChrisTX <xpipe@hotmail.de> * Copyright (C) 2011, 2014 Adam <Adam@anope.org> * Copyright (C) 2009-2010 Daniel De Graaf <danieldg@inspircd.org> * Copyright (C) 2008 Robin Burchell <robin+git@viroteck.net> * Copyright (C) 2007 Dennis Friis <peavey@inspircd.org> * Copyright (C) 2006-2008 Craig Edwards <brain@inspircd.org> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #ifndef _WIN32 #include <sys/select.h> #endif // _WIN32 #include "inspircd.h" /** A specialisation of the SocketEngine class, designed to use traditional select(). */ namespace { fd_set ReadSet, WriteSet, ErrSet; int MaxFD = 0; } void SocketEngine::Init() { #ifdef _WIN32 // Set up winsock. WSADATA wsadata; WSAStartup(MAKEWORD(2, 2), &wsadata); #endif MaxSetSize = FD_SETSIZE; FD_ZERO(&ReadSet); FD_ZERO(&WriteSet); FD_ZERO(&ErrSet); } void SocketEngine::Deinit() { } void SocketEngine::RecoverFromFork() { } bool SocketEngine::AddFd(EventHandler* eh, int event_mask) { if (!eh->HasFd()) return false; int fd = eh->GetFd(); if (static_cast<size_t>(fd) >= GetMaxFds()) return false; if (!SocketEngine::AddFdRef(eh)) return false; eh->SetEventMask(event_mask); OnSetEvent(eh, 0, event_mask); FD_SET(fd, &ErrSet); if (fd > MaxFD) MaxFD = fd; ServerInstance->Logs.Debug("SOCKET", "New file descriptor: {}", fd); return true; } void SocketEngine::DelFd(EventHandler* eh) { if (!eh->HasFd()) return; int fd = eh->GetFd(); if (static_cast<size_t>(fd) >= GetMaxFds()) return; SocketEngine::DelFdRef(eh); FD_CLR(fd, &ReadSet); FD_CLR(fd, &WriteSet); FD_CLR(fd, &ErrSet); if (fd == MaxFD) --MaxFD; ServerInstance->Logs.Debug("SOCKET", "Remove file descriptor: {}", fd); } void SocketEngine::OnSetEvent(EventHandler* eh, int old_mask, int new_mask) { int fd = eh->GetFd(); int diff = old_mask ^ new_mask; if (diff & (FD_WANT_POLL_READ | FD_WANT_FAST_READ)) { if (new_mask & (FD_WANT_POLL_READ | FD_WANT_FAST_READ)) FD_SET(fd, &ReadSet); else FD_CLR(fd, &ReadSet); } if (diff & (FD_WANT_POLL_WRITE | FD_WANT_FAST_WRITE | FD_WANT_SINGLE_WRITE)) { if (new_mask & (FD_WANT_POLL_WRITE | FD_WANT_FAST_WRITE | FD_WANT_SINGLE_WRITE)) FD_SET(fd, &WriteSet); else FD_CLR(fd, &WriteSet); } } int SocketEngine::DispatchEvents() { timeval tval; tval.tv_sec = 1; tval.tv_usec = 0; fd_set rfdset = ReadSet, wfdset = WriteSet, errfdset = ErrSet; int sresult = select(MaxFD + 1, &rfdset, &wfdset, &errfdset, &tval); ServerInstance->UpdateTime(); for (int i = 0, j = sresult; i <= MaxFD && j > 0; i++) { int has_read = FD_ISSET(i, &rfdset), has_write = FD_ISSET(i, &wfdset), has_error = FD_ISSET(i, &errfdset); if (!(has_read || has_write || has_error)) continue; --j; EventHandler* ev = GetRef(i); if (!ev) continue; if (has_error) { stats.ErrorEvents++; socklen_t codesize = sizeof(int); int errcode = 0; if (getsockopt(i, SOL_SOCKET, SO_ERROR, (char*)&errcode, &codesize) < 0) errcode = errno; ev->OnEventHandlerError(errcode); continue; } if (has_read) { ev->SetEventMask(ev->GetEventMask() & ~FD_READ_WILL_BLOCK); ev->OnEventHandlerRead(); if (ev != GetRef(i)) continue; } if (has_write) { int newmask = (ev->GetEventMask() & ~(FD_WRITE_WILL_BLOCK | FD_WANT_SINGLE_WRITE)); SocketEngine::OnSetEvent(ev, ev->GetEventMask(), newmask); ev->SetEventMask(newmask); ev->OnEventHandlerWrite(); } } return sresult; } ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/src/streamsocket.cpp�����������������������������������������������������������������0000664�0000000�0000000�00000030314�14771603147�0017347�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2021 Dominic Hamon * Copyright (C) 2020 Matt Schatz <genius3000@g3k.solutions> * Copyright (C) 2019 linuxdaemon <linuxdaemon.irc@gmail.com> * Copyright (C) 2018, 2020-2024 Sadie Powell <sadie@witchery.services> * Copyright (C) 2018 Dylan Frank <b00mx0r@aureus.pw> * Copyright (C) 2013-2016 Attila Molnar <attilamolnar@hush.com> * Copyright (C) 2013 Adam <Adam@anope.org> * Copyright (C) 2012 Robby <robby@chatbelgie.be> * Copyright (C) 2009-2010 Daniel De Graaf <danieldg@inspircd.org> * Copyright (C) 2007-2008 Robin Burchell <robin+git@viroteck.net> * Copyright (C) 2007 John Brooks <john@jbrooks.io> * Copyright (C) 2007 Dennis Friis <peavey@inspircd.org> * Copyright (C) 2006-2007 Craig Edwards <brain@inspircd.org> * Copyright (C) 2006 Oliver Lupton <om@inspircd.org> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include "inspircd.h" #include "iohook.h" static IOHook* GetNextHook(IOHook* hook) { IOHookMiddle* const iohm = IOHookMiddle::ToMiddleHook(hook); if (iohm) return iohm->GetNextHook(); return nullptr; } BufferedSocket::BufferedSocket() : state(I_ERROR) { } BufferedSocket::BufferedSocket(int newfd) : state(I_CONNECTED) { SetFd(newfd); if (HasFd()) SocketEngine::AddFd(this, FD_WANT_FAST_READ | FD_WANT_EDGE_WRITE); } void BufferedSocket::DoConnect(const irc::sockets::sockaddrs& dest, const irc::sockets::sockaddrs& bind, unsigned long maxtime, sa_family_t protocol) { BufferedSocketError err = BeginConnect(dest, bind, maxtime, protocol); if (err != I_ERR_NONE) { state = I_ERROR; SetError(SocketEngine::LastError()); OnError(err); } } BufferedSocketError BufferedSocket::BeginConnect(const irc::sockets::sockaddrs& dest, const irc::sockets::sockaddrs& bind, unsigned long timeout, sa_family_t protocol) { if (!HasFd()) SetFd(socket(dest.family(), SOCK_STREAM, protocol)); if (!HasFd()) return I_ERR_SOCKET; if (bind.family() != 0) { if (SocketEngine::Bind(this, bind) < 0) return I_ERR_BIND; } SocketEngine::NonBlocking(GetFd()); if (SocketEngine::Connect(this, dest) == -1) { if (errno != EINPROGRESS) return I_ERR_CONNECT; } this->state = I_CONNECTING; if (!SocketEngine::AddFd(this, FD_WANT_NO_READ | FD_WANT_SINGLE_WRITE | FD_WRITE_WILL_BLOCK)) return I_ERR_NOMOREFDS; this->Timeout = new SocketTimeout(this->GetFd(), this, timeout); ServerInstance->Timers.AddTimer(this->Timeout); ServerInstance->Logs.Debug("SOCKET", "BufferedSocket::DoConnect success"); return I_ERR_NONE; } void StreamSocket::Close() { if (closing) return; closing = true; if (HasFd()) { // final chance, dump as much of the sendq as we can DoWrite(); IOHook* hook = GetIOHook(); DelIOHook(); while (hook) { hook->OnStreamSocketClose(this); IOHook* const nexthook = GetNextHook(hook); delete hook; hook = nexthook; } SocketEngine::Shutdown(this, 2); SocketEngine::Close(this); } } void StreamSocket::Close(bool writeblock) { if (GetSendQSize() != 0 && writeblock) closeonempty = true; else Close(); } Cullable::Result StreamSocket::Cull() { Close(); return EventHandler::Cull(); } ssize_t StreamSocket::HookChainRead(IOHook* hook, std::string& rq) { if (!hook) return ReadToRecvQ(rq); IOHookMiddle* const iohm = IOHookMiddle::ToMiddleHook(hook); if (iohm) { // Call the next hook to put data into the recvq of the current hook const ssize_t ret = HookChainRead(iohm->GetNextHook(), iohm->GetRecvQ()); if (ret <= 0) return ret; } return hook->OnStreamSocketRead(this, rq); } void StreamSocket::DoRead() { const std::string::size_type prevrecvqsize = recvq.size(); const ssize_t result = HookChainRead(GetIOHook(), recvq); if (result < 0) { SetError("Read Error"); // will not overwrite a better error message return; } if (recvq.size() > prevrecvqsize) OnDataReady(); } ssize_t StreamSocket::ReadToRecvQ(std::string& rq) { char* ReadBuffer = ServerInstance->GetReadBuffer(); ssize_t n = SocketEngine::Recv(this, ReadBuffer, ServerInstance->Config->NetBufferSize, 0); if (n >= 0) { size_t nrecv = static_cast<size_t>(n); if (nrecv == ServerInstance->Config->NetBufferSize) { SocketEngine::ChangeEventMask(this, FD_WANT_FAST_READ | FD_ADD_TRIAL_READ); rq.append(ReadBuffer, n); } else if (nrecv > 0) { SocketEngine::ChangeEventMask(this, FD_WANT_FAST_READ); rq.append(ReadBuffer, n); } else if (nrecv == 0) { error = "Connection closed"; SocketEngine::ChangeEventMask(this, FD_WANT_NO_READ | FD_WANT_NO_WRITE); return -1; } } else if (SocketEngine::IgnoreError()) { SocketEngine::ChangeEventMask(this, FD_WANT_FAST_READ | FD_READ_WILL_BLOCK); return 0; } else if (errno == EINTR) { SocketEngine::ChangeEventMask(this, FD_WANT_FAST_READ | FD_ADD_TRIAL_READ); return 0; } else { error = SocketEngine::LastError(); SocketEngine::ChangeEventMask(this, FD_WANT_NO_READ | FD_WANT_NO_WRITE); return -1; } return n; } /* Don't try to prepare huge blobs of data to send to a blocked socket */ static constexpr size_t MYIOV_MAX = std::min<size_t>(IOV_MAX, 128); void StreamSocket::DoWrite() { if (GetSendQSize() == 0) { if (closeonempty) Close(); return; } if (!error.empty() || !HasFd()) { ServerInstance->Logs.Debug("SOCKET", "DoWrite on errored or closed socket"); return; } SendQueue* psendq = &sendq; IOHook* hook = GetIOHook(); while (hook) { ssize_t rv = hook->OnStreamSocketWrite(this, *psendq); psendq = nullptr; // rv == 0 means the socket has blocked. Stop trying to send data. // IOHook has requested unblock notification from the socketengine. if (rv == 0) break; if (rv < 0) { SetError("Write Error"); // will not overwrite a better error message break; } IOHookMiddle* const iohm = IOHookMiddle::ToMiddleHook(hook); hook = nullptr; if (iohm) { psendq = &iohm->GetSendQ(); hook = iohm->GetNextHook(); } } if (psendq) FlushSendQ(*psendq); if (GetSendQSize() == 0 && closeonempty) Close(); } void StreamSocket::FlushSendQ(SendQueue& sq) { // don't even try if we are known to be blocking if (GetEventMask() & FD_WRITE_WILL_BLOCK) return; // start out optimistic - we won't need to write any more int eventChange = FD_WANT_EDGE_WRITE; while (error.empty() && !sq.empty() && eventChange == FD_WANT_EDGE_WRITE) { // Prepare a writev() call to write all buffers efficiently. int bufcount = static_cast<int>(std::min<size_t>(sq.size(), MYIOV_MAX)); int rv_max = 0; ssize_t rv; { SocketEngine::IOVector iovecs[MYIOV_MAX]; size_t j = 0; for (SendQueue::const_iterator i = sq.begin(), end = i+bufcount; i != end; ++i, j++) { const SendQueue::Element& elem = *i; iovecs[j].iov_base = const_cast<char*>(elem.data()); iovecs[j].iov_len = elem.length(); rv_max += iovecs[j].iov_len; } rv = SocketEngine::WriteV(this, iovecs, bufcount); } if (rv == static_cast<int>(sq.bytes())) { // it's our lucky day, everything got written out. Fast cleanup. // This won't ever happen if the number of buffers got capped. sq.clear(); } else if (rv > 0) { // Partial write. Clean out strings from the sendq if (rv < rv_max) { // it's going to block now eventChange = FD_WANT_FAST_WRITE | FD_WRITE_WILL_BLOCK; } while (rv > 0 && !sq.empty()) { const SendQueue::Element& front = sq.front(); if (front.length() <= static_cast<size_t>(rv)) { // this string got fully written out rv -= front.length(); sq.pop_front(); } else { // stopped in the middle of this string sq.erase_front(rv); rv = 0; } } } else if (rv == 0) { error = "Connection closed"; } else if (SocketEngine::IgnoreError()) { eventChange = FD_WANT_FAST_WRITE | FD_WRITE_WILL_BLOCK; } else if (errno == EINTR) { // restart interrupted syscall errno = 0; } else { error = SocketEngine::LastError(); } } if (!error.empty()) { // error - kill all events SocketEngine::ChangeEventMask(this, FD_WANT_NO_READ | FD_WANT_NO_WRITE); } else { SocketEngine::ChangeEventMask(this, eventChange); } } void StreamSocket::WriteData(const std::string& data) { if (!HasFd()) { ServerInstance->Logs.Debug("SOCKET", "Attempt to write data to dead socket: {}", data); return; } /* Append the data to the back of the queue ready for writing */ sendq.push_back(data); SocketEngine::ChangeEventMask(this, FD_ADD_TRIAL_WRITE); } bool SocketTimeout::Tick() { ServerInstance->Logs.Debug("SOCKET", "SocketTimeout::Tick"); if (SocketEngine::GetRef(this->sfd) != this->sock) { delete this; return false; } if (this->sock->state == I_CONNECTING) { // for connecting sockets, the timeout can occur // which causes termination of the connection after // the given number of seconds without a successful // connection. this->sock->OnTimeout(); this->sock->OnError(I_ERR_TIMEOUT); this->sock->state = I_ERROR; ServerInstance->GlobalCulls.AddItem(sock); } this->sock->Timeout = nullptr; delete this; return false; } void BufferedSocket::OnConnected() { } void BufferedSocket::OnTimeout() { } void BufferedSocket::OnEventHandlerWrite() { if (state == I_CONNECTING) { state = I_CONNECTED; this->OnConnected(); if (!GetIOHook()) SocketEngine::ChangeEventMask(this, FD_WANT_FAST_READ | FD_WANT_EDGE_WRITE); } this->StreamSocket::OnEventHandlerWrite(); } BufferedSocket::~BufferedSocket() { this->Close(); // The timer is removed from the TimerManager in Timer::~Timer() delete Timeout; } void StreamSocket::OnEventHandlerError(int errornum) { if (!error.empty()) return; if (errornum == 0) SetError("Connection closed"); else SetError(SocketEngine::GetError(errornum)); BufferedSocketError errcode = I_ERR_OTHER; switch (errornum) { case ETIMEDOUT: errcode = I_ERR_TIMEOUT; break; case ECONNREFUSED: case 0: errcode = I_ERR_CONNECT; break; case EADDRINUSE: errcode = I_ERR_BIND; break; case EPIPE: case EIO: errcode = I_ERR_WRITE; break; } // Log and call OnError() CheckError(errcode); } void StreamSocket::OnEventHandlerRead() { if (!error.empty()) return; try { DoRead(); } catch (const CoreException& ex) { ServerInstance->Logs.Normal("SOCKET", "Caught exception in socket processing on FD {} - '{}'", GetFd(), ex.GetReason()); SetError(ex.GetReason()); } CheckError(I_ERR_OTHER); } void StreamSocket::OnEventHandlerWrite() { if (!error.empty()) return; DoWrite(); CheckError(I_ERR_OTHER); } void StreamSocket::CheckError(BufferedSocketError errcode) { if (!error.empty()) { ServerInstance->Logs.Debug("SOCKET", "Error on FD {} - '{}'", GetFd(), error); OnError(errcode); } } IOHook* StreamSocket::GetModHook(Module* mod) const { for (IOHook* curr = GetIOHook(); curr; curr = GetNextHook(curr)) { if (curr->prov->creator == mod) return curr; } return nullptr; } IOHook* StreamSocket::GetLastHook() const { IOHook* curr = GetIOHook(); IOHook* last = curr; for (; curr; curr = GetNextHook(curr)) last = curr; return last; } void StreamSocket::AddIOHook(IOHook* newhook) { IOHook* curr = GetIOHook(); if (!curr) { iohook = newhook; return; } IOHookMiddle* lasthook = nullptr; while (curr) { lasthook = IOHookMiddle::ToMiddleHook(curr); if (!lasthook) return; curr = lasthook->GetNextHook(); } lasthook->SetNextHook(newhook); } size_t StreamSocket::GetSendQSize() const { size_t ret = sendq.bytes(); IOHook* curr = GetIOHook(); while (curr) { const IOHookMiddle* const iohm = IOHookMiddle::ToMiddleHook(curr); if (!iohm) break; ret += iohm->GetSendQ().bytes(); curr = iohm->GetNextHook(); } return ret; } ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/src/stringutils.cpp������������������������������������������������������������������0000664�0000000�0000000�00000024113�14771603147�0017232�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2021 Dominic Hamon * Copyright (C) 2017, 2021-2024 Sadie Powell <sadie@witchery.services> * Copyright (C) 2014 Attila Molnar <attilamolnar@hush.com> * Copyright (C) 2012 Robby <robby@chatbelgie.be> * Copyright (C) 2010 Craig Edwards <brain@inspircd.org> * Copyright (C) 2009-2010 Daniel De Graaf <danieldg@inspircd.org> * Copyright (C) 2009 Uli Schlachter <psychon@znc.in> * Copyright (C) 2007 Robin Burchell <robin+git@viroteck.net> * Copyright (C) 2007 Dennis Friis <peavey@inspircd.org> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include <fmt/format.cc> #include "inspircd.h" #include "stringutils.h" #include "utility/string.h" std::string Percent::Encode(const void* data, size_t length, const char* table, bool upper) { if (!table) table = Percent::TABLE; // Preallocate the output buffer to avoid constant reallocations. std::string buffer; buffer.reserve(length * 3); const char* hex_table = upper ? Hex::TABLE_UPPER : Hex::TABLE_LOWER; const unsigned char* udata = reinterpret_cast<const unsigned char*>(data); for (size_t idx = 0; idx < length; ++idx) { unsigned char chr = udata[idx]; if (strchr(table, chr)) { // The character is on the safe list; push it as is. buffer.push_back(chr); } else { // The character is not on the safe list; percent encode it. buffer.push_back('%'); buffer.push_back(hex_table[chr >> 4]); buffer.push_back(hex_table[chr & 15]); } } return buffer; } std::string Percent::Decode(const void* data, size_t length) { // Preallocate the output buffer to avoid constant reallocations. std::string buffer; buffer.reserve(length * 3); const char* cdata = reinterpret_cast<const char*>(data); for (size_t idx = 0; idx < length; ++idx) { if (cdata[idx] == '%') { // Percent encoding encodes two octets into 1-2 characters. const char octet1 = ++idx < length ? toupper(cdata[idx]) : 0; const char octet2 = ++idx < length ? toupper(cdata[idx]) : 0; const char* table1 = strchr(Hex::TABLE_UPPER, octet1); const char* table2 = strchr(Hex::TABLE_UPPER, octet2); char pair = ((table1 ? table1 - Hex::TABLE_UPPER : 0) << 4) + (table2 ? table2 - Hex::TABLE_UPPER : 0); buffer.push_back(pair); } else { buffer.push_back(cdata[idx]); } } return buffer; } std::string Hex::Encode(const void* data, size_t length, const char* table, char separator) { if (!table) table = Hex::TABLE_LOWER; // Preallocate the output buffer to avoid constant reallocations. std::string buffer; buffer.reserve((length * 2) + (!!separator * length)); const unsigned char* udata = reinterpret_cast<const unsigned char*>(data); for (size_t idx = 0; idx < length; ++idx) { if (idx && separator) buffer.push_back(separator); const unsigned char chr = udata[idx]; buffer.push_back(table[chr >> 4]); buffer.push_back(table[chr & 15]); } return buffer; } std::string Hex::Decode(const void* data, size_t length, const char* table, char separator) { if (!table) table = Hex::TABLE_LOWER; // The size of each hex segment. size_t segment = (separator ? 3 : 2); // Preallocate the output buffer to avoid constant reallocations. std::string buffer; buffer.reserve(length / segment); const char* cdata = static_cast<const char*>(data); for (size_t idx = 0; idx + 1 < length; idx += segment) { // Attempt to find the octets in the table. const char* table1 = strchr(table, cdata[idx]); const char* table2 = strchr(table, cdata[idx + 1]); char pair = ((table1 ? table1 - table : 0) << 4) + (table2 ? table2 - table : 0); buffer.push_back(pair); } return buffer; } std::string Base64::Encode(const void* data, size_t length, const char* table, char padding) { // Use the default table if one is not specified. if (!table) table = Base64::TABLE; // Preallocate the output buffer to avoid constant reallocations. std::string buffer; buffer.reserve(4 * ((length + 2) / 3)); const uint8_t* udata = static_cast<const uint8_t*>(data); for (size_t idx = 0; idx < length; ) { // Base64 encodes three octets into four characters. uint32_t octet1 = idx < length ? udata[idx++] : 0; uint32_t octet2 = idx < length ? udata[idx++] : 0; uint32_t octet3 = idx < length ? udata[idx++] : 0; uint32_t triple = (octet1 << 16) + (octet2 << 8) + octet3; buffer.push_back(table[(triple >> 3 * 6) & 63]); buffer.push_back(table[(triple >> 2 * 6) & 63]); buffer.push_back(table[(triple >> 1 * 6) & 63]); buffer.push_back(table[(triple >> 0 * 6) & 63]); } static constexpr size_t padding_count[] = { 0, 2, 1 }; if (padding) { // Replace any trailing characters with padding. for (size_t idx = 0; idx < padding_count[length % 3]; ++idx) buffer[buffer.length() - 1 - idx] = '='; } else { // Remove any trailing characters. buffer.erase(buffer.length() - padding_count[length % 3]); } return buffer; } std::string Base64::Decode(const void* data, size_t length, const char* table) { if (!table) table = Base64::TABLE; // Preallocate the output buffer to avoid constant reallocations. std::string buffer; buffer.reserve((length / 4) * 3); uint32_t current_bits = 0; size_t seen_bits = 0; const char* cdata = static_cast<const char*>(data); for (size_t idx = 0; idx < length; ++idx) { // Attempt to find the octet in the table. const char* chr = strchr(table, cdata[idx]); if (!chr) continue; // Skip invalid octets. // Add the bits for this octet to the active buffer. current_bits = (current_bits << 6) | uint32_t(chr - table); seen_bits += 6; if (seen_bits >= 8) { // We have seen an entire octet; add it to the buffer. seen_bits -= 8; buffer.push_back((current_bits >> seen_bits) & 0xFF); } } return buffer; } std::string Template::Replace(const std::string& str, const VariableMap& vars) { std::string out; out.reserve(str.length()); for (size_t idx = 0; idx < str.size(); ++idx) { if (str[idx] != '%') { out.push_back(str[idx]); continue; } for (size_t endidx = idx + 1; endidx < str.size(); ++endidx) { if (str[endidx] == '%') { if (endidx - idx == 1) { // foo%%bar is an escape of foo%bar out.push_back('%'); idx = endidx; break; } auto var = vars.find(str.substr(idx + 1, endidx - idx - 1)); if (var != vars.end()) { // We have a variable, replace it in the string. out.append(var->second); } idx = endidx; break; } } } return out; } bool InspIRCd::TimingSafeCompare(const std::string& one, const std::string& two) { if (one.length() != two.length()) return false; unsigned int diff = 0; for (std::string::const_iterator i = one.begin(), j = two.begin(); i != one.end(); ++i, ++j) { unsigned char a = static_cast<unsigned char>(*i); unsigned char b = static_cast<unsigned char>(*j); diff |= a ^ b; } return (diff == 0); } TokenList::TokenList(const std::string& tokenlist) { AddList(tokenlist); } void TokenList::AddList(const std::string& tokenlist) { std::string token; irc::spacesepstream tokenstream(tokenlist); while (tokenstream.GetToken(token)) { if (token[0] == '-') Remove(token.substr(1)); else Add(token); } } void TokenList::Add(const std::string& token) { // If the token is empty or contains just whitespace it is invalid. if (token.empty() || token.find_first_not_of(" \t") == std::string::npos) return; // If the token is a wildcard entry then permissive mode has been enabled. if (token == "*") { permissive = true; tokens.clear(); return; } // If we are in permissive mode then remove the token from the token list. // Otherwise, add it to the token list. if (permissive) tokens.erase(token); else tokens.insert(token); } void TokenList::Clear() { permissive = false; tokens.clear(); } bool TokenList::Contains(const std::string& token) const { // If we are in permissive mode and the token is in the list // then we don't have it. if (permissive && tokens.find(token) != tokens.end()) return false; // If we are not in permissive mode and the token is not in // the list then we don't have it. if (!permissive && tokens.find(token) == tokens.end()) return false; // We have the token! return true; } void TokenList::Remove(const std::string& token) { // If the token is empty or contains just whitespace it is invalid. if (token.empty() || token.find_first_not_of(" \t") == std::string::npos) return; // If the token is a wildcard entry then permissive mode has been disabled. if (token == "*") { permissive = false; tokens.clear(); return; } // If we are in permissive mode then add the token to the token list. // Otherwise, remove it from the token list. if (permissive) tokens.insert(token); else tokens.erase(token); } std::string TokenList::ToString() const { if (permissive) { // If the token list is in permissive mode then the tokens are a list // of disallowed tokens. std::string buffer("*"); for (const auto& token : tokens) buffer.append(" -").append(token); return buffer; } // If the token list is not in permissive mode then the token list is just // a list of allowed tokens. return insp::join(tokens); } bool TokenList::operator==(const TokenList& other) const { // Both sets must be in the same mode to be equal. if (permissive != other.permissive) return false; // Both sets must be the same size to be equal. if (tokens.size() != other.tokens.size()) return false; for (const auto& token : tokens) { // Both sets must contain the same tokens to be equal. if (other.tokens.find(token) == other.tokens.end()) return false; } return true; } �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/src/thread.cpp�����������������������������������������������������������������������0000664�0000000�0000000�00000007562�14771603147�0016123�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2019-2023 Sadie Powell <sadie@witchery.services> * Copyright (C) 2013-2015 Attila Molnar <attilamolnar@hush.com> * Copyright (C) 2012 Robby <robby@chatbelgie.be> * Copyright (C) 2009-2010 Daniel De Graaf <danieldg@inspircd.org> * Copyright (C) 2008 Craig Edwards <brain@inspircd.org> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include "inspircd.h" #include "threadsocket.h" bool Thread::Start() { try { if (thread) return false; thread = new std::thread(Thread::StartInternal, this); return true; } catch (const std::system_error& err) { throw CoreException("Unable to start new thread: " + std::string(err.what())); } } void Thread::StartInternal(Thread* thread) { #ifndef _WIN32 // C++ does not have an API for this so we still need to use pthreads. sigset_t set; sigemptyset(&set); sigaddset(&set, SIGPIPE); pthread_sigmask(SIG_BLOCK, &set, nullptr); #endif thread->OnStart(); } bool Thread::Stop() { if (!thread) return false; OnStop(); stopping = true; thread->join(); stdalgo::delete_zero(thread); return true; } #if __has_include(<sys/eventfd.h>) #include <sys/eventfd.h> class ThreadSignalSocket final : public EventHandler { private: SocketThread* parent = nullptr; public: ThreadSignalSocket(SocketThread* p, int newfd) : parent(p) { SetFd(newfd); SocketEngine::AddFd(this, FD_WANT_FAST_READ | FD_WANT_NO_WRITE); } ~ThreadSignalSocket() override { SocketEngine::Close(this); } void Notify() { eventfd_write(GetFd(), 1); } void OnEventHandlerRead() override { eventfd_t dummy; eventfd_read(GetFd(), &dummy); parent->OnNotify(); } void OnEventHandlerWrite() override { ServerInstance->GlobalCulls.AddItem(this); } void OnEventHandlerError(int errcode) override { ThreadSignalSocket::OnEventHandlerWrite(); } }; SocketThread::SocketThread() { int fd = eventfd(0, EFD_NONBLOCK); if (fd < 0) throw CoreException("Could not create pipe " + std::string(strerror(errno))); socket = new ThreadSignalSocket(this, fd); } #else # ifdef _WIN32 # define pipe(fd) _pipe(fd, 1, 0) # else # include <unistd.h> # endif class ThreadSignalSocket final : public EventHandler { private: SocketThread* parent; int send_fd; public: ThreadSignalSocket(SocketThread* p, int recvfd, int sendfd) : parent(p) , send_fd(sendfd) { SetFd(recvfd); SocketEngine::NonBlocking(GetFd()); SocketEngine::AddFd(this, FD_WANT_FAST_READ | FD_WANT_NO_WRITE); } ~ThreadSignalSocket() { SocketEngine::Close(send_fd); SocketEngine::Close(this); } void Notify() { static constexpr char dummy = '*'; write(send_fd, &dummy, 1); } void OnEventHandlerRead() override { char dummy[128]; read(GetFd(), dummy, 128); parent->OnNotify(); } void OnEventHandlerWrite() override { ServerInstance->GlobalCulls.AddItem(this); } void OnEventHandlerError(int errcode) override { ThreadSignalSocket::OnEventHandlerWrite(); } }; SocketThread::SocketThread() { socket = nullptr; int fds[2]; if (pipe(fds)) throw CoreException("Could not create pipe " + std::string(strerror(errno))); socket = new ThreadSignalSocket(this, fds[0], fds[1]); } #endif void SocketThread::NotifyParent() { socket->Notify(); } SocketThread::~SocketThread() { if (socket) { socket->Cull(); delete socket; } } ����������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/src/timer.cpp������������������������������������������������������������������������0000664�0000000�0000000�00000004641�14771603147�0015767�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2021-2023 Sadie Powell <sadie@witchery.services> * Copyright (C) 2021 Dominic Hamon * Copyright (C) 2013-2014 Attila Molnar <attilamolnar@hush.com> * Copyright (C) 2012 Robby <robby@chatbelgie.be> * Copyright (C) 2009 Uli Schlachter <psychon@znc.in> * Copyright (C) 2009 Daniel De Graaf <danieldg@inspircd.org> * Copyright (C) 2008 Robin Burchell <robin+git@viroteck.net> * Copyright (C) 2007 Dennis Friis <peavey@inspircd.org> * Copyright (C) 2007 Craig Edwards <brain@inspircd.org> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include "inspircd.h" void Timer::SetInterval(unsigned long newinterval, bool restart) { secs = newinterval; if (!restart) return; ServerInstance->Timers.DelTimer(this); SetTrigger(ServerInstance->Time() + newinterval); ServerInstance->Timers.AddTimer(this); } Timer::Timer(unsigned long secs_from_now, bool repeating) : secs(secs_from_now) , repeat(repeating) { } Timer::~Timer() { if (GetTrigger()) ServerInstance->Timers.DelTimer(this); } void TimerManager::TickTimers() { const time_t now = ServerInstance->Time(); for (TimerMap::iterator i = Timers.begin(); i != Timers.end(); ) { Timer* t = i->second; if (t->GetTrigger() > now) break; Timers.erase(i++); if (!t->Tick()) continue; if (t->GetRepeat()) { t->SetTrigger(now + t->GetInterval()); AddTimer(t); } } } void TimerManager::DelTimer(Timer* t) { std::pair<TimerMap::iterator, TimerMap::iterator> itpair = Timers.equal_range(t->GetTrigger()); for (TimerMap::iterator i = itpair.first; i != itpair.second; ++i) { if (i->second == t) { t->SetTrigger(0); Timers.erase(i); break; } } } void TimerManager::AddTimer(Timer* t) { time_t trigger = ServerInstance->Time() + t->GetInterval(); t->SetTrigger(trigger); Timers.emplace(trigger, t); } �����������������������������������������������������������������������������������������������inspircd-4.7.0/src/usermanager.cpp������������������������������������������������������������������0000664�0000000�0000000�00000031103�14771603147�0017151�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2019 iwalkalone <iwalkalone69@gmail.com> * Copyright (C) 2013-2016, 2018 Attila Molnar <attilamolnar@hush.com> * Copyright (C) 2013, 2018-2025 Sadie Powell <sadie@witchery.services> * Copyright (C) 2013, 2015 Adam <Adam@anope.org> * Copyright (C) 2012 Robby <robby@chatbelgie.be> * Copyright (C) 2009-2010 Daniel De Graaf <danieldg@inspircd.org> * Copyright (C) 2008-2009 Craig Edwards <brain@inspircd.org> * Copyright (C) 2008 Robin Burchell <robin+git@viroteck.net> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include "inspircd.h" #include "clientprotocolmsg.h" #include "iohook.h" #include "timeutils.h" #include "xline.h" namespace { class WriteCommonQuit final : public User::ForEachNeighborHandler { ClientProtocol::Messages::Quit quitmsg; ClientProtocol::Event quitevent; ClientProtocol::Messages::Quit operquitmsg; ClientProtocol::Event operquitevent; void Execute(LocalUser* user) override { user->Send(user->IsOper() ? operquitevent : quitevent); } public: WriteCommonQuit(User* user, const std::string& msg, const std::string& opermsg) : quitmsg(user, msg) , quitevent(ServerInstance->GetRFCEvents().quit, quitmsg) , operquitmsg(user, opermsg) , operquitevent(ServerInstance->GetRFCEvents().quit, operquitmsg) { user->ForEachNeighbor(*this, false); } }; void CheckPingTimeout(LocalUser* user) { // Check if it is time to ping the user yet. if (ServerInstance->Time() < user->nextping) return; // This user didn't answer the last ping, remove them. if (!user->lastping) { time_t secs = ServerInstance->Time() - (user->nextping - user->GetClass()->pingtime); const std::string message = INSP_FORMAT("Ping timeout: {}", Duration::ToLongString(secs)); ServerInstance->Users.QuitUser(user, message); return; } user->lastping = 0; user->nextping = ServerInstance->Time() + user->GetClass()->pingtime; // If the user has an I/O hook that can handle pinging use that instead. IOHook* hook = user->eh.GetIOHook(); while (hook) { if (hook->Ping()) return; // Client has been pinged. IOHookMiddle* middlehook = IOHookMiddle::ToMiddleHook(hook); hook = middlehook ? middlehook->GetNextHook() : nullptr; } // Send a ping to the client using an IRC message. ClientProtocol::Messages::Ping ping; user->Send(ServerInstance->GetRFCEvents().ping, ping); } void CheckConnectionTimeout(LocalUser* user) { if (user->GetClass() && (ServerInstance->Time() > static_cast<time_t>(user->signon + user->GetClass()->connection_timeout))) { // Either the user did not send NICK/USER or a module blocked connection in // OnCheckReady until the client timed out. ServerInstance->Users.QuitUser(user, "Connection timeout"); } } void CheckModulesReady(LocalUser* user) { ModResult res; FIRST_MOD_RESULT(OnCheckReady, res, (user)); if (res == MOD_RES_PASSTHRU) { // User has sent NICK/USER and modules are ready. user->FullConnect(); return; } // If the user has been quit in OnCheckReady then we shouldn't quit // them again for having a registration timeout. if (!user->quitting) CheckConnectionTimeout(user); } } UserManager::UserManager() { // We need to define a constructor here to work around a Clang bug. } UserManager::~UserManager() { for (const auto& [_, client] : clientlist) delete client; } void UserManager::AddUser(int socket, ListenSocket* via, const irc::sockets::sockaddrs& client, const irc::sockets::sockaddrs& server) { // User constructor allocates a new UUID for the user and inserts it into the uuidlist LocalUser* const New = new LocalUser(socket, client, server); UserIOHandler* eh = &New->eh; ServerInstance->Logs.Debug("USERS", "New user fd: {}", socket); this->unknown_count++; this->clientlist[New->nick] = New; this->AddClone(New); this->local_users.push_front(New); FOREACH_MOD(OnUserInit, (New)); if (!SocketEngine::AddFd(eh, FD_WANT_FAST_READ | FD_WANT_EDGE_WRITE)) { ServerInstance->Logs.Debug("USERS", "Internal error on new connection"); this->QuitUser(New, "Internal error handling connection"); return; } // If this listener has an IO hook provider set then tell it about the connection for (ListenSocket::IOHookProvList::iterator i = via->iohookprovs.begin(); i != via->iohookprovs.end(); ++i) { ListenSocket::IOHookProvRef& iohookprovref = *i; if (!iohookprovref) { if (iohookprovref.GetProvider().empty()) continue; const char* hooktype = i == via->iohookprovs.begin() ? "hook" : "sslprofile"; ServerInstance->Logs.Warning("USERS", "Non-existent I/O hook '{}' in <bind:{}> tag at {}", iohookprovref.GetProvider(), hooktype, via->bind_tag->source.str()); this->QuitUser(New, INSP_FORMAT("Internal error handling connection (misconfigured {})", hooktype)); return; } iohookprovref->OnAccept(eh, client, server); // IOHook could have encountered a fatal error, e.g. if the TLS ClientHello // was already in the queue and there was no common TLS version. if (!eh->GetError().empty()) { QuitUser(New, eh->GetError()); return; } } if (this->local_users.size() > ServerInstance->Config->SoftLimit) { ServerInstance->SNO.WriteToSnoMask('a', "Warning: softlimit value has been reached: {} clients", ServerInstance->Config->SoftLimit); this->QuitUser(New, "No more connections allowed"); return; } if (!New->FindConnectClass()) return; // User does not match any connect classes. /* * even with bancache, we still have to keep User::exempt current. * besides that, if we get a positive bancache hit, we still won't fuck * them over if they are exempt. -- w00t */ New->exempt = (ServerInstance->XLines->MatchesLine("E", New) != nullptr); BanCacheHit* const b = ServerInstance->BanCache.GetHit(New->GetAddress()); if (b) { if (!b->Type.empty() && !New->exempt) { /* user banned */ ServerInstance->Logs.Debug("BANCACHE", "Positive hit for {}", New->GetAddress()); if (!ServerInstance->Config->XLineMessage.empty()) New->WriteNumeric(ERR_YOUREBANNEDCREEP, ServerInstance->Config->XLineMessage); // IMPORTANT: we don't check XLineQuitPublic here because the only // person who might see the ban at this point is the affected user. this->QuitUser(New, b->Reason); return; } else { ServerInstance->Logs.Debug("BANCACHE", "Negative hit for {}", New->GetAddress()); } } else { if (!New->exempt) { XLine* r = ServerInstance->XLines->MatchesLine("Z", New); if (r) { r->Apply(New); return; } } } if (ServerInstance->Config->RawLog) Log::NotifyRawIO(New, MessageType::NOTICE); FOREACH_MOD(OnChangeRemoteAddress, (New)); if (!New->quitting) FOREACH_MOD(OnUserPostInit, (New)); } void UserManager::QuitUser(User* user, const std::string& quitmessage, const std::string* operquitmessage) { if (user->quitting) { ServerInstance->Logs.Debug("USERS", "BUG: Tried to quit quitting user: {}", user->nick); return; } if (IS_SERVER(user)) { ServerInstance->Logs.Debug("USERS", "BUG: Tried to quit server user: {}", user->nick); return; } std::string quitmsg(quitmessage); std::string operquitmsg; if (operquitmessage) operquitmsg.assign(*operquitmessage); LocalUser* const localuser = IS_LOCAL(user); if (localuser) { ModResult modres; FIRST_MOD_RESULT(OnUserPreQuit, modres, (localuser, quitmsg, operquitmsg)); if (modres == MOD_RES_DENY) return; } if (quitmsg.length() > ServerInstance->Config->Limits.MaxQuit) quitmsg.erase(ServerInstance->Config->Limits.MaxQuit + 1); if (operquitmsg.empty()) operquitmsg.assign(quitmsg); else if (operquitmsg.length() > ServerInstance->Config->Limits.MaxQuit) operquitmsg.erase(ServerInstance->Config->Limits.MaxQuit + 1); user->quitting = true; ServerInstance->Logs.Debug("USERS", "QuitUser: {}={} '{}'", user->uuid, user->nick, quitmessage); if (localuser) { ClientProtocol::Messages::Error errormsg(INSP_FORMAT("Closing link: ({}) [{}]", user->GetRealUserHost(), operquitmsg)); localuser->Send(ServerInstance->GetRFCEvents().error, errormsg); } ServerInstance->GlobalCulls.AddItem(user); if (user->IsFullyConnected()) { FOREACH_MOD(OnUserQuit, (user, quitmsg, operquitmsg)); WriteCommonQuit(user, quitmsg, operquitmsg); } else unknown_count--; if (IS_LOCAL(user)) { LocalUser* lu = IS_LOCAL(user); FOREACH_MOD(OnUserDisconnect, (lu)); lu->eh.Close(); if (lu->IsFullyConnected()) { ServerInstance->SNO.WriteToSnoMask('q', "Client exiting: {} ({}) [{}]", user->GetRealMask(), user->GetAddress(), operquitmsg); } local_users.erase(lu); if (lu->GetClass()) lu->GetClass()->use_count--; } if (!clientlist.erase(user->nick)) ServerInstance->Logs.Debug("USERS", "BUG: Nick not found in clientlist, cannot remove: {}", user->nick); uuidlist.erase(user->uuid); user->PurgeEmptyChannels(); user->OperLogout(); } void UserManager::AddClone(User* user) { CloneCounts& counts = clonemap[user->GetCIDRMask()]; counts.global++; if (IS_LOCAL(user)) counts.local++; } void UserManager::RemoveCloneCounts(User* user) { CloneMap::iterator it = clonemap.find(user->GetCIDRMask()); if (it != clonemap.end()) { CloneCounts& counts = it->second; counts.global--; if (counts.global == 0) { // No more users from this IP, remove entry from the map clonemap.erase(it); return; } if (IS_LOCAL(user)) counts.local--; } } void UserManager::RehashCloneCounts() { clonemap.clear(); for (const auto& [_, u] : ServerInstance->Users.GetUsers()) AddClone(u); } void UserManager::RehashServices() { UserManager::ServiceList newservices; for (const auto& [_, user] : ServerInstance->Users.GetUsers()) { if (user->server->IsService()) newservices.push_back(user); } std::swap(ServerInstance->Users.all_services, newservices); } const UserManager::CloneCounts& UserManager::GetCloneCounts(User* user) const { CloneMap::const_iterator it = clonemap.find(user->GetCIDRMask()); if (it != clonemap.end()) return it->second; else return zeroclonecounts; } /** * This function is called once a second from the mainloop. * It is intended to do background checking on all the users, e.g. do * ping checks, connection timeouts, etc. */ void UserManager::DoBackgroundUserStuff() { for (LocalList::iterator i = local_users.begin(); i != local_users.end(); ) { // It's possible that we quit the user below due to ping timeout etc. and QuitUser() removes it from the list LocalUser* curr = *i; ++i; if (curr->CommandFloodPenalty || curr->eh.GetSendQSize()) { unsigned long rate = curr->GetClass()->commandrate; if (curr->CommandFloodPenalty > rate) curr->CommandFloodPenalty -= rate; else curr->CommandFloodPenalty = 0; curr->eh.OnDataReady(); } switch (curr->connected) { case User::CONN_FULL: CheckPingTimeout(curr); break; case User::CONN_NICKUSER: CheckModulesReady(curr); break; default: CheckConnectionTimeout(curr); break; } } } uint64_t UserManager::NextAlreadySentId() { if (++already_sent_id == 0) { // Wrapped around, reset the already_sent ids of all users already_sent_id = 1; for (auto* user : GetLocalUsers()) user->already_sent = 0; } return already_sent_id; } User* UserManager::Find(const std::string& nickuuid, bool fullyconnected) { if (nickuuid.empty()) return nullptr; if (isdigit(nickuuid[0])) return FindUUID(nickuuid, fullyconnected); return FindNick(nickuuid, fullyconnected); } User* UserManager::FindNick(const std::string& nick, bool fullyconnected) { if (nick.empty()) return nullptr; UserMap::iterator uiter = this->clientlist.find(nick); if (uiter == this->clientlist.end()) return nullptr; User* user = uiter->second; if (fullyconnected && !user->IsFullyConnected()) return nullptr; return user; } User* UserManager::FindUUID(const std::string& uuid, bool fullyconnected) { if (uuid.empty()) return nullptr; UserMap::iterator uiter = this->uuidlist.find(uuid); if (uiter == this->uuidlist.end()) return nullptr; User* user = uiter->second; if (fullyconnected && !user->IsFullyConnected()) return nullptr; return user; } �������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/src/users.cpp������������������������������������������������������������������������0000664�0000000�0000000�00000111513�14771603147�0016005�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2019 linuxdaemon <linuxdaemon.irc@gmail.com> * Copyright (C) 2018 systocrat <systocrat@outlook.com> * Copyright (C) 2018 Dylan Frank <b00mx0r@aureus.pw> * Copyright (C) 2013, 2017-2025 Sadie Powell <sadie@witchery.services> * Copyright (C) 2013 Adam <Adam@anope.org> * Copyright (C) 2012-2016, 2018 Attila Molnar <attilamolnar@hush.com> * Copyright (C) 2012 Robby <robby@chatbelgie.be> * Copyright (C) 2011 jackmcbarn <jackmcbarn@inspircd.org> * Copyright (C) 2009-2010 Daniel De Graaf <danieldg@inspircd.org> * Copyright (C) 2007-2008 Robin Burchell <robin+git@viroteck.net> * Copyright (C) 2007, 2009 Dennis Friis <peavey@inspircd.org> * Copyright (C) 2006-2009 Craig Edwards <brain@inspircd.org> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include "inspircd.h" #include "clientprotocolevent.h" #include "utility/string.h" #include "xline.h" ClientProtocol::MessageList LocalUser::sendmsglist; bool User::IsNoticeMaskSet(unsigned char sm) const { if (!SnomaskManager::IsSnomask(sm)) return false; return (snomasks[sm-65]); } bool User::IsModeSet(unsigned char m) const { ModeHandler* mh = ServerInstance->Modes.FindMode(m, MODETYPE_USER); return (mh && modes[mh->GetId()]); } std::string User::GetModeLetters(bool includeparams) const { std::string ret(1, '+'); std::string params; for (const auto& [_, mh] : ServerInstance->Modes.GetModes(MODETYPE_USER)) { if (!IsModeSet(mh)) continue; ret.push_back(mh->GetModeChar()); if ((includeparams) && (mh->NeedsParam(true))) { const std::string val = mh->GetUserParameter(this); if (!val.empty()) params.append(1, ' ').append(val); } } ret += params; return ret; } User::User(const std::string& uid, Server* srv, Type type) : Extensible(ExtensionType::USER) , nickchanged(ServerInstance->Time()) , uuid(uid) , server(srv) , connected(CONN_NONE) , quitting(false) , uniqueusername(false) , usertype(type) { ServerInstance->Logs.Debug("USERS", "New UUID for user: {}", uuid); if (srv->IsService()) ServerInstance->Users.all_services.push_back(this); // Do not insert FakeUsers into the uuidlist so FindUUID() won't return them which is the desired behavior if (type != User::TYPE_SERVER) { if (!ServerInstance->Users.uuidlist.emplace(uuid, this).second) throw CoreException("Duplicate UUID in User constructor: " + uuid); } } const std::string& User::GetAddress() { if (cached_address.empty()) { cached_address = client_sa.addr(); // If the user is connecting from an IPv4 address like ::1 we // need to partially expand the address to avoid issues with // the IRC wire format. if (cached_address[0] == ':') cached_address.insert(cached_address.begin(), 1, '0'); cached_address.shrink_to_fit(); } return cached_address; } const std::string& User::GetUserAddress() { if (cached_useraddress.empty()) { cached_useraddress = INSP_FORMAT("{}@{}", GetRealUser(), GetAddress()); cached_useraddress.shrink_to_fit(); } return cached_useraddress; } const std::string& User::GetUserHost() { if (cached_userhost.empty()) { cached_userhost = INSP_FORMAT("{}@{}", GetDisplayedUser(), GetDisplayedHost()); cached_userhost.shrink_to_fit(); } return cached_userhost; } const std::string& User::GetRealUserHost() { if (cached_realuserhost.empty()) { cached_realuserhost = INSP_FORMAT("{}@{}", GetRealUser(), GetRealHost()); cached_realuserhost.shrink_to_fit(); } return cached_realuserhost; } const std::string& User::GetMask() { if (cached_mask.empty()) { cached_mask = INSP_FORMAT("{}!{}@{}", nick, GetDisplayedUser(), GetDisplayedHost()); cached_mask.shrink_to_fit(); } return cached_mask; } const std::string& User::GetRealMask() { if (cached_realmask.empty()) { cached_realmask = INSP_FORMAT("{}!{}@{}", nick, GetRealUser(), GetRealHost()); cached_realmask.shrink_to_fit(); } return cached_realmask; } LocalUser::LocalUser(int myfd, const irc::sockets::sockaddrs& clientsa, const irc::sockets::sockaddrs& serversa) : User(ServerInstance->UIDGen.GetUID(), ServerInstance->FakeClient->server, User::TYPE_LOCAL) , eh(this) , server_sa(serversa) , quitting_sendq(false) , lastping(true) , exempt(false) { signon = ServerInstance->Time(); // The user's default nick is their UUID nick = uuid; eh.SetFd(myfd); memcpy(&client_sa, &clientsa, sizeof(irc::sockets::sockaddrs)); ChangeRealUser(uuid, true); ChangeRealHost(GetAddress(), true); } FakeUser::FakeUser(const std::string& uid, Server* srv) : User(uid, srv, TYPE_SERVER) { nick = srv->GetName(); } FakeUser::FakeUser(const std::string& uid, const std::string& sname, const std::string& sdesc) : User(uid, new Server(uid, sname, sdesc), TYPE_SERVER) { nick = sname; } const std::string& FakeUser::GetMask() { return server->GetPublicName(); } const std::string& FakeUser::GetRealMask() { return server->GetPublicName(); } void UserIOHandler::OnDataReady() { if (user->quitting) return; if (recvq.length() > user->GetClass()->recvqmax && !user->HasPrivPermission("users/flood/increased-buffers")) { ServerInstance->Users.QuitUser(user, "RecvQ exceeded"); ServerInstance->SNO.WriteToSnoMask('a', "User {} RecvQ of {} exceeds connect class maximum of {}", user->nick, recvq.length(), user->GetClass()->recvqmax); return; } unsigned long sendqmax = ULONG_MAX; if (!user->HasPrivPermission("users/flood/increased-buffers")) sendqmax = user->GetClass()->softsendqmax; unsigned long penaltymax = ULONG_MAX; if (!user->HasPrivPermission("users/flood/no-fakelag")) penaltymax = user->GetClass()->penaltythreshold * 1000; // The cleaned message sent by the user or empty if not found yet. std::string line; // The position of the most \n character or npos if not found yet. std::string::size_type eolpos; // The position within the recvq of the current character. std::string::size_type qpos; while (user->CommandFloodPenalty < penaltymax && GetSendQSize() < sendqmax) { // Check the newly received data for an EOL. eolpos = recvq.find('\n', checked_until); if (eolpos == std::string::npos) { checked_until = recvq.length(); return; } // We've found a line! Clean it up and move it to the line buffer. line.reserve(eolpos); for (qpos = 0; qpos < eolpos; ++qpos) { char c = recvq[qpos]; switch (c) { case '\0': c = ' '; break; case '\r': continue; } line.push_back(c); } // just found a newline. Terminate the string, and pull it out of recvq recvq.erase(0, eolpos + 1); checked_until = 0; // TODO should this be moved to when it was inserted in recvq? ServerInstance->Stats.Recv += qpos; user->bytes_in += qpos; user->cmds_in++; ServerInstance->Parser.ProcessBuffer(user, line); if (user->quitting) return; // clear() does not reclaim memory associated with the string, so our .reserve() call is safe line.clear(); } if (user->CommandFloodPenalty >= penaltymax && !user->GetClass()->fakelag) ServerInstance->Users.QuitUser(user, "Excess Flood"); } void UserIOHandler::AddWriteBuf(const std::string& data) { if (user->quitting_sendq) return; if (!user->quitting && (user->GetClass() && GetSendQSize() + data.length() > user->GetClass()->hardsendqmax) && !user->HasPrivPermission("users/flood/increased-buffers")) { user->quitting_sendq = true; ServerInstance->GlobalCulls.AddSQItem(user); return; } // We still want to append data to the sendq of a quitting user, // e.g. their ERROR message that says 'closing link' WriteData(data); } bool UserIOHandler::OnChangeLocalSocketAddress(const irc::sockets::sockaddrs& sa) { memcpy(&user->server_sa, &sa, sizeof(irc::sockets::sockaddrs)); return true; } bool UserIOHandler::OnChangeRemoteSocketAddress(const irc::sockets::sockaddrs& sa) { user->ChangeRemoteAddress(sa); return !user->quitting; } void UserIOHandler::OnError(BufferedSocketError sockerr) { ServerInstance->Users.QuitUser(user, GetError()); } Cullable::Result User::Cull() { if (!quitting) { ServerInstance->Logs.Debug("CULL", "BUG: User {} (@{}) was culled without being quit first!", uuid, fmt::ptr(this)); ServerInstance->Users.QuitUser(this, "Culled without QuitUser"); } if (client_sa.family() != AF_UNSPEC) ServerInstance->Users.RemoveCloneCounts(this); if (server->IsService()) stdalgo::erase(ServerInstance->Users.all_services, this); return Extensible::Cull(); } Cullable::Result LocalUser::Cull() { eh.Cull(); return User::Cull(); } Cullable::Result FakeUser::Cull() { // Fake users don't quit, they just get culled. quitting = true; // Fake users are not inserted into UserManager::clientlist or uuidlist, so we don't need to modify those here return User::Cull(); } bool User::OperLogin(const std::shared_ptr<OperAccount>& account, bool automatic, bool force) { LocalUser* luser = IS_LOCAL(this); if (luser && !quitting && !force) { ModResult modres; FIRST_MOD_RESULT(OnPreOperLogin, modres, (luser, account, automatic)); if (modres == MOD_RES_DENY) return false; // Module rejected the oper attempt. } // If this user is already logged in to an oper account then log them out. if (IsOper()) OperLogout(); FOREACH_MOD(OnOperLogin, (this, account, automatic)); // When a user logs in we need to: // 1. Set the operator account (this is what IsOper checks). // 2. Set user mode o (oper) *WITHOUT* calling the mode handler. // 3. Add the user to the operator list. oper = account; auto* opermh = ServerInstance->Modes.FindMode('o', MODETYPE_USER); if (opermh) { SetMode(opermh, true); if (luser) { Modes::ChangeList changelist; changelist.push_add(opermh); ClientProtocol::Events::Mode modemsg(ServerInstance->FakeClient, nullptr, luser, changelist); luser->Send(modemsg); } } ServerInstance->Users.all_opers.push_back(this); FOREACH_MOD(OnPostOperLogin, (this, automatic)); return true; } void User::OperLogout() { if (!IsOper()) return; FOREACH_MOD(OnOperLogout, (this)); // When a user logs OUT we need to: // 1. Unset the operator account (this is what IsOper checks). // 2. Unset user mode o (oper) *WITHOUT* calling the mode handler. // 3. Remove the user from the operator list. auto account = oper; oper = nullptr; // If the user is quitting we shouldn't remove any modes as it results in // mode messages being broadcast across the network. if (!quitting) { // Remove any oper-only modes from the user. Modes::ChangeList changelist; for (const auto& [_, mh] : ServerInstance->Modes.GetModes(MODETYPE_USER)) { if (mh->NeedsOper() && IsModeSet(mh)) changelist.push_remove(mh); } ServerInstance->Modes.Process(this, nullptr, this, changelist); auto* opermh = ServerInstance->Modes.FindMode('o', MODETYPE_USER); if (opermh) SetMode(opermh, false); } stdalgo::vector::swaperase(ServerInstance->Users.all_opers, this); FOREACH_MOD(OnPostOperLogout, (this, account)); } bool LocalUser::CheckLines(bool doZline) { const char* check[] = { "G" , "K", (doZline) ? "Z" : nullptr, nullptr }; if (!this->exempt) { for (int n = 0; check[n]; ++n) { XLine* r = ServerInstance->XLines->MatchesLine(check[n], this); if (r) { r->Apply(this); return true; } } } return false; } void LocalUser::FullConnect() { ServerInstance->Stats.Connects++; this->idle_lastmsg = ServerInstance->Time(); /* * You may be thinking "wtf, we checked this in User::AddClient!" - and yes, we did, BUT. * At the time AddClient is called, we don't have a resolved host, by here we probably do - which * may put the user into a totally separate class with different restrictions! so we *must* check again. * Don't remove this! -- w00t */ if (!FindConnectClass()) return; // User does not match any connect classes. CheckLines(); if (quitting) return; /* * We don't set CONN_FULL until triggering OnUserConnect, so some module events don't spew out stuff * for a user that doesn't exist yet. */ FOREACH_MOD(OnUserConnect, (this)); // The user is now fully connected. if (ServerInstance->Users.unknown_count) ServerInstance->Users.unknown_count--; this->connected = CONN_FULL; FOREACH_MOD(OnPostConnect, (this)); ServerInstance->SNO.WriteToSnoMask('c', "Client connecting on port {} (class {}): {} ({}) [{}\x0F]", server_sa.port(), GetClass()->GetName(), GetRealMask(), GetAddress(), GetRealName()); ServerInstance->Logs.Debug("BANCACHE", "Adding NEGATIVE hit for {}", this->GetAddress()); ServerInstance->BanCache.AddHit(this->GetAddress(), "", ""); // reset the flood penalty (which could have been raised due to things like auto +x) CommandFloodPenalty = 0; } void User::InvalidateCache() { /* Invalidate cache */ cached_address.clear(); cached_useraddress.clear(); cached_userhost.clear(); cached_realuserhost.clear(); cached_mask.clear(); cached_realmask.clear(); } bool User::ChangeNick(const std::string& newnick, time_t newts) { if (quitting) { ServerInstance->Logs.Debug("USERS", "BUG: Attempted to change nick of a quitting user: {}", this->nick); return false; } User* const InUse = ServerInstance->Users.FindNick(newnick); if (InUse == this) { // case change, don't need to check campers // and, if it's identical including case, we can leave right now // We also don't update the nick TS if it's a case change, either if (newnick == nick) return true; } else { /* * Uh oh.. if the nickname is in use, and it's not in use by the person using it (doh) -- * then we have a potential collide. Check whether someone else is camping on the nick * (i.e. connect -> send NICK, don't send USER.) If they are camping, force-change the * camper to their UID, and allow the incoming nick change. * * If the guy using the nick is already using it, tell the incoming nick change to gtfo, * because the nick is already (rightfully) in use. -- w00t */ if (InUse) { if (!InUse->IsFullyConnected()) { /* force the camper to their UUID, and ask them to re-send a NICK. */ LocalUser* const localuser = static_cast<LocalUser*>(InUse); localuser->OverruleNick(); } else { /* No camping, tell the incoming user to stop trying to change nick ;p */ this->WriteNumeric(ERR_NICKNAMEINUSE, newnick, "Nickname is already in use."); return false; } } nickchanged = newts ? newts : ServerInstance->Time(); } if (IsFullyConnected()) { ClientProtocol::Messages::Nick nickmsg(this, newnick); ClientProtocol::Event nickevent(ServerInstance->GetRFCEvents().nick, nickmsg); this->WriteCommonRaw(nickevent, true); } const std::string oldnick = nick; nick = newnick; nick.shrink_to_fit(); InvalidateCache(); ServerInstance->Users.clientlist.erase(oldnick); ServerInstance->Users.clientlist[newnick] = this; if (IsFullyConnected()) FOREACH_MOD(OnUserPostNick, (this, oldnick)); return true; } void LocalUser::OverruleNick() { { ClientProtocol::Messages::Nick nickmsg(this, this->uuid); this->Send(ServerInstance->GetRFCEvents().nick, nickmsg); } this->WriteNumeric(ERR_NICKNAMEINUSE, this->nick, "Nickname overruled."); // Clear the bit before calling ChangeNick() to make it NOT run the OnUserPostNick() hook this->connected &= ~CONN_NICK; this->ChangeNick(this->uuid); } const std::string& User::GetBanUser(bool real) const { static const std::string wildcard = "*"; return uniqueusername ? GetUser(real) : wildcard; } irc::sockets::cidr_mask User::GetCIDRMask() const { unsigned char range = 0; switch (client_sa.family()) { case AF_INET6: range = ServerInstance->Config->IPv6Range; break; case AF_INET: range = ServerInstance->Config->IPv4Range; break; case AF_UNIX: break; // CIDR not supported. default: ServerInstance->Logs.Debug("SOCKET", "BUG: User::GetCIDRMask(): socket type {} is unknown!", client_sa.family()); break; } return irc::sockets::cidr_mask(client_sa, range); } void User::ChangeRemoteAddress(const irc::sockets::sockaddrs& sa) { const std::string oldip(client_sa.family() == AF_UNSPEC ? "" : GetAddress()); memcpy(&client_sa, &sa, sizeof(irc::sockets::sockaddrs)); this->InvalidateCache(); // If the users hostname was their IP then update it. if (GetRealHost() == oldip) ChangeRealHost(GetAddress(), false); if (GetDisplayedHost() == oldip) ChangeDisplayedHost(GetAddress()); } void LocalUser::ChangeRemoteAddress(const irc::sockets::sockaddrs& sa) { if (sa == client_sa) return; ServerInstance->Users.RemoveCloneCounts(this); User::ChangeRemoteAddress(sa); ServerInstance->Users.AddClone(this); // Recheck the connect class. if (FindConnectClass()) FOREACH_MOD(OnChangeRemoteAddress, (this)); } bool LocalUser::FindConnectClass(bool keepexisting) { ServerInstance->Logs.Debug("CONNECTCLASS", "Finding a connect class for {} ({}) ...", uuid, GetRealMask()); std::optional<Numeric::Numeric> errnum; for (const auto& klass : ServerInstance->Config->Classes) { ServerInstance->Logs.Debug("CONNECTCLASS", "Checking the {} connect class ...", klass->GetName()); // Users can not be automatically assigned to a named class. if (klass->type == ConnectClass::NAMED) { ServerInstance->Logs.Debug("CONNECTCLASS", "The {} connect class is not suitable as neither <connect:allow> nor <connect:deny> are set.", klass->GetName()); continue; } ModResult modres; FIRST_MOD_RESULT(OnPreChangeConnectClass, modres, (this, klass, errnum)); if (modres != MOD_RES_DENY) { ServerInstance->Logs.Debug("CONNECTCLASS", "The {} connect class is suitable for {} ({}).", klass->GetName(), uuid, GetRealMask()); ChangeConnectClass(klass, false); return !quitting; } } // The user didn't match any connect classes. if (connectclass) { if (keepexisting) return false; // They're fine keeping their existing one. connectclass->use_count--; connectclass = nullptr; } if (errnum) WriteNumeric(*errnum); ServerInstance->Users.QuitUser(this, "You are not allowed to connect to this server"); return false; } void LocalUser::ChangeConnectClass(const std::shared_ptr<ConnectClass>& klass, bool force) { // Let modules know the class is about to be changed. FOREACH_MOD(OnChangeConnectClass, (this, klass, force)); if (quitting) return; // User hit some kind of restriction. // Assign the new connect class. if (connectclass) connectclass->use_count--; connectclass = klass; connectclass->use_count++; // Update the core user data that depends on connect class. nextping = ServerInstance->Time() + klass->pingtime; uniqueusername = klass->uniqueusername; // Let modules know the class has been changed. FOREACH_MOD(OnPostChangeConnectClass, (this, force)); } void LocalUser::Write(const ClientProtocol::SerializedMessage& text) { if (!eh.HasFd() || text.empty()) return; if (ServerInstance->Config->RawLog) { std::string::size_type nlpos = text.find_first_of("\r\n", 0, 2); if (nlpos == std::string::npos) nlpos = text.length(); ServerInstance->Logs.RawIO("USEROUTPUT", "C[{}] O {}", uuid, std::string_view(text.c_str(), nlpos)); } eh.AddWriteBuf(text); const size_t bytessent = text.length() + 2; ServerInstance->Stats.Sent += bytessent; this->bytes_out += bytessent; this->cmds_out++; } void LocalUser::Send(ClientProtocol::Event& protoev) { if (!serializer) { ServerInstance->Logs.Debug("USERS", "BUG: LocalUser::Send() called on {} who does not have a serializer!", GetRealMask()); return; } // In the most common case a static LocalUser field, sendmsglist, is passed to the event to be // populated. The list is cleared before returning. // To handle re-enters, if sendmsglist is non-empty upon entering the method then a temporary // list is used instead of the static one. if (sendmsglist.empty()) { Send(protoev, sendmsglist); sendmsglist.clear(); } else { ClientProtocol::MessageList msglist; Send(protoev, msglist); } } void LocalUser::Send(ClientProtocol::Event& protoev, ClientProtocol::MessageList& msglist) { // Modules can personalize the messages sent per user for the event protoev.GetMessagesForUser(this, msglist); for (auto* msg : msglist) { ClientProtocol::Message& curr = *msg; ModResult res; FIRST_MOD_RESULT(OnUserWrite, res, (this, curr)); if (res != MOD_RES_DENY) Write(serializer->SerializeForUser(this, curr)); } } void User::WriteNumeric(const Numeric::Numeric& numeric) { LocalUser* const localuser = IS_LOCAL(this); if (!localuser) return; ModResult modres; FIRST_MOD_RESULT(OnNumeric, modres, (this, numeric)); if (modres == MOD_RES_DENY) return; ClientProtocol::Messages::Numeric numericmsg(numeric, localuser); localuser->Send(ServerInstance->GetRFCEvents().numeric, numericmsg); } void User::WriteRemoteNotice(const std::string& text) { ServerInstance->PI->SendMessage(this, text, MessageType::NOTICE); } void LocalUser::WriteRemoteNotice(const std::string& text) { WriteNotice(text); } namespace { class WriteCommonRawHandler final : public User::ForEachNeighborHandler { ClientProtocol::Event& ev; void Execute(LocalUser* user) override { user->Send(ev); } public: WriteCommonRawHandler(ClientProtocol::Event& protoev) : ev(protoev) { } }; } void User::WriteCommonRaw(ClientProtocol::Event& protoev, bool include_self) { WriteCommonRawHandler handler(protoev); ForEachNeighbor(handler, include_self); } uint64_t User::ForEachNeighbor(ForEachNeighborHandler& handler, bool include_self) { // The basic logic for visiting the neighbors of a user is to iterate the channel list of the user // and visit all users on those channels. Because two users may share more than one common channel, // we must skip users that we have already visited. // To do this, we make use of a global counter and an integral 'already_sent' field in LocalUser. // The global counter is incremented every time we do something for each neighbor of a user. Then, // before visiting a member we examine user->already_sent. If it's equal to the current counter, we // skip the member. Otherwise, we set it to the current counter and visit the member. // Ask modules to build a list of exceptions. // Mods may also exclude entire channels by erasing them from include_chans. User::NeighborList include_chans(chans.begin(), chans.end()); User::NeighborExceptions exceptions; exceptions[this] = include_self; FOREACH_MOD(OnBuildNeighborList, (this, include_chans, exceptions)); // Get next id, guaranteed to differ from the already_sent field of all users const uint64_t newid = ServerInstance->Users.NextAlreadySentId(); // Handle exceptions first for (NeighborExceptions::const_iterator i = exceptions.begin(); i != exceptions.end(); ++i) { LocalUser* curr = IS_LOCAL(i->first); if (curr) { // Mark as visited to ensure we won't visit again if there is a common channel curr->already_sent = newid; // Always treat quitting users as excluded if ((i->second) && (!curr->quitting)) handler.Execute(curr); } } // Now consider the real neighbors for (const auto* memb : include_chans) { for (const auto& [user, _] : memb->chan->GetUsers()) { LocalUser* curr = IS_LOCAL(user); // User not yet visited? if ((curr) && (curr->already_sent != newid)) { // Mark as visited and execute function curr->already_sent = newid; handler.Execute(curr); } } } return newid; } void User::WriteRemoteNumeric(const Numeric::Numeric& numeric) { WriteNumeric(numeric); } /* return 0 or 1 depending if users u and u2 share one or more common channels * (used by QUIT, NICK etc which arent channel specific notices) * * The old algorithm in 1.0 for this was relatively inefficient, iterating over * the first users channels then the second users channels within the outer loop, * therefore it was a maximum of x*y iterations (upon returning 0 and checking * all possible iterations). However this new function instead checks against the * channel's userlist in the inner loop which is a std::map<User*,User*> * and saves us time as we already know what pointer value we are after. * Don't quote me on the maths as i am not a mathematician or computer scientist, * but i believe this algorithm is now x+(log y) maximum iterations instead. */ bool User::SharesChannelWith(User* other) const { for (const auto* memb : chans) { if (memb->chan->HasUser(other)) return true; } return false; } void User::ChangeRealName(const std::string& real) { if (!this->realname.compare(real)) return; FOREACH_MOD(OnChangeRealName, (this, real)); this->realname.assign(real, 0, ServerInstance->Config->Limits.MaxReal); this->realname.shrink_to_fit(); } void User::ChangeDisplayedHost(const std::string& newhost) { if (GetDisplayedHost() == newhost) return; FOREACH_MOD(OnChangeHost, (this, newhost)); if (realhost == newhost) this->displayhost.clear(); else this->displayhost.assign(newhost, 0, ServerInstance->Config->Limits.MaxHost); this->displayhost.shrink_to_fit(); this->InvalidateCache(); if (IS_LOCAL(this) && connected != User::CONN_NONE) this->WriteNumeric(RPL_YOURDISPLAYEDHOST, this->GetDisplayedHost(), "is now your displayed host"); } void User::ChangeRealHost(const std::string& newhost, bool resetdisplay) { // If the real host is the new host and we are not resetting the // display host then we have nothing to do. const bool changehost = (realhost != newhost); if (!changehost && !resetdisplay) return; // If the displayhost is not set and we are not resetting it then // we need to copy it to the displayhost field. if (displayhost.empty() && !resetdisplay) displayhost = realhost; // If the displayhost is the new host or we are resetting it then // we clear its contents to save memory. else if (displayhost == newhost || resetdisplay) displayhost.clear(); // If we are just resetting the display host then we don't need to // do anything else. if (!changehost) { InvalidateCache(); return; } // Don't call the OnChangeRealHost event when initialising a user. const bool initializing = realhost.empty(); if (!initializing) FOREACH_MOD(OnChangeRealHost, (this, newhost)); realhost = newhost; realhost.shrink_to_fit(); this->InvalidateCache(); // Don't call the OnPostChangeRealHost event when initialising a user. if (!this->quitting && !initializing) FOREACH_MOD(OnPostChangeRealHost, (this)); } void User::ChangeRealUser(const std::string& newuser, bool resetdisplay) { // If the real user is the new user and we are not resetting the // display user then we have nothing to do. const bool changeuser = (realuser != newuser); if (!changeuser && !resetdisplay) return; // If the displayuser is not set and we are not resetting it then // we need to copy it to the displayuser field. if (displayuser.empty() && !resetdisplay) displayuser = realuser; // If the displayuser is the new user or we are resetting it then // we clear its contents to save memory. else if (displayuser == newuser || resetdisplay) displayuser.clear(); // If we are just resetting the display user then we don't need to // do anything else. if (!changeuser) return; // Don't call the OnChangeRealUser event when initialising a user. const bool initializing = realuser.empty(); if (!initializing) FOREACH_MOD(OnChangeRealUser, (this, newuser)); realuser = newuser; realuser.shrink_to_fit(); this->InvalidateCache(); // Don't call the OnPostChangeRealUser event when initialising a user. if (!this->quitting && !initializing) FOREACH_MOD(OnPostChangeRealUser, (this)); } void User::ChangeDisplayedUser(const std::string& newuser) { if (GetDisplayedUser() == newuser) return; FOREACH_MOD(OnChangeUser, (this, newuser)); if (realuser == newuser) this->displayuser.clear(); else this->displayuser.assign(newuser, 0, ServerInstance->Config->Limits.MaxUser); this->displayuser.shrink_to_fit(); this->InvalidateCache(); } void User::PurgeEmptyChannels() { // firstly decrement the count on each channel for (User::ChanList::iterator i = this->chans.begin(); i != this->chans.end(); ) { Channel* c = (*i)->chan; ++i; c->DelUser(this); } } void User::WriteNotice(const std::string& text) { LocalUser* const localuser = IS_LOCAL(this); if (!localuser) return; ClientProtocol::Messages::Privmsg msg(ClientProtocol::Messages::Privmsg::nocopy, ServerInstance->FakeClient, localuser, text, MessageType::NOTICE); localuser->Send(ServerInstance->GetRFCEvents().privmsg, msg); } ConnectClass::ConnectClass(const std::shared_ptr<ConfigTag>& tag, Type t, const std::vector<std::string>& masks) : config(tag) , hosts(masks) , name("unnamed") , type(t) , fakelag(true) , maxconnwarn(true) , resolvehostnames(true) , uniqueusername(false) { } ConnectClass::ConnectClass(const std::shared_ptr<ConfigTag>& tag, Type t, const std::vector<std::string>& masks, const std::shared_ptr<ConnectClass>& parent) { Update(parent); name = "unnamed"; type = t; hosts = masks; // Connect classes can inherit from each other but this is problematic for modules which can't use // ConnectClass::Update so we build a hybrid tag containing all of the values set on this class as // well as the parent class. config = std::make_shared<ConfigTag>(tag->name, tag->source); for (const auto& [key, value] : parent->config->GetItems()) { // The class name and parent name are not inherited if (insp::equalsci(key, "name") || insp::equalsci(key, "parent")) continue; // Store the item in the config tag. If this item also // exists in the child it will be overwritten. config->GetItems()[key] = value; } for (const auto& [key, value] : tag->GetItems()) { // This will overwrite the parent value if present. config->GetItems()[key] = value; } } void ConnectClass::Configure(const std::string& classname, const std::shared_ptr<ConfigTag>& tag) { name = classname; password = tag->getString("password", password); passwordhash = tag->getString("hash", passwordhash); if (!password.empty() && (passwordhash.empty() || insp::equalsci(passwordhash, "plaintext"))) { ServerInstance->Logs.Normal("CONNECTCLASS", "<connect> tag '{}' at {} contains an plain text password, this is insecure!", name, tag->source.str()); } irc::portparser portrange(tag->getString("port"), false); while (long port = portrange.GetToken()) { if (port > std::numeric_limits<in_port_t>::min() && port <= std::numeric_limits<in_port_t>::max()) ports.insert(static_cast<in_port_t>(port)); } commandrate = tag->getNum<unsigned long>("commandrate", commandrate, 1); fakelag = tag->getBool("fakelag", fakelag); hardsendqmax = tag->getNum<unsigned long>("hardsendq", hardsendqmax, ServerInstance->Config->Limits.MaxLine); limit = tag->getNum<unsigned long>("limit", limit, 1); maxchans = tag->getNum<unsigned long>("maxchans", maxchans); maxconnwarn = tag->getBool("maxconnwarn", maxconnwarn); maxlocal = tag->getNum<unsigned long>("localmax", maxlocal); maxglobal = tag->getNum<unsigned long>("globalmax", maxglobal, maxlocal); penaltythreshold = tag->getNum<unsigned long>("threshold", penaltythreshold, 1); pingtime = tag->getDuration("pingfreq", pingtime); recvqmax = tag->getNum<unsigned long>("recvq", recvqmax, ServerInstance->Config->Limits.MaxLine); connection_timeout = tag->getDuration("timeout", connection_timeout); resolvehostnames = tag->getBool("resolvehostnames", resolvehostnames); softsendqmax = tag->getNum<unsigned long>("softsendq", softsendqmax, ServerInstance->Config->Limits.MaxLine); uniqueusername = tag->getBool("uniqueusername", uniqueusername); } void ConnectClass::Update(const std::shared_ptr<ConnectClass>& src) { ServerInstance->Logs.Debug("CONNECTCLASS", "Updating {} from {}", name, src->name); commandrate = src->commandrate; config = src->config; fakelag = src->fakelag; hardsendqmax = src->hardsendqmax; hosts = src->hosts; limit = src->limit; maxchans = src->maxchans; maxconnwarn = src->maxconnwarn; maxglobal = src->maxglobal; maxlocal = src->maxlocal; name = src->name; password = src->password; passwordhash = src->passwordhash; penaltythreshold = src->penaltythreshold; pingtime = src->pingtime; ports = src->ports; recvqmax = src->recvqmax; connection_timeout = src->connection_timeout; resolvehostnames = src->resolvehostnames; softsendqmax = src->softsendqmax; type = src->type; uniqueusername = src->uniqueusername; } AwayState::AwayState(const std::string& m, time_t t) : message(m, 0, ServerInstance->Config->Limits.MaxAway) , time(t ? t : ServerInstance->Time()) { } OperType::OperType(const std::string& n, const std::shared_ptr<ConfigTag>& t) : config(std::make_shared<ConfigTag>("generated", FilePosition("<generated>", 0, 0))) , name(n) { if (t) Configure(t, true); } void OperType::Configure(const std::shared_ptr<ConfigTag>& tag, bool merge) { commands.AddList(tag->getString("commands")); privileges.AddList(tag->getString("privs")); auto modefn = [&tag](ModeParser::ModeStatus& modes, const std::string& key) { bool adding = true; for (const auto chr : tag->getString(key)) { if (chr == '+' || chr == '-') adding = (chr == '+'); else if (chr == '*' && adding) modes.set(); else if (chr == '*' && !adding) modes.reset(); else if (ModeParser::IsModeChar(chr)) modes.set(ModeParser::GetModeIndex(chr), adding); } }; modefn(chanmodes, "chanmodes"); modefn(usermodes, "usermodes"); modefn(snomasks, "snomasks"); if (merge) MergeTag(tag); } std::string OperType::GetCommands(bool all) const { if (all) return commands.ToString(); std::vector<std::string> ret; for (const auto& [_, cmd] : ServerInstance->Parser.GetCommands()) { if (cmd->access_needed == CmdAccess::OPERATOR && CanUseCommand(cmd->name)) ret.push_back(cmd->name); } std::sort(ret.begin(), ret.end()); return insp::join(ret); } std::string OperType::GetModes(ModeType mt, bool all) const { std::string ret; for (unsigned char chr = '0'; chr <= 'z'; ++chr) { if (!ModeParser::IsModeChar(chr)) continue; ModeHandler* mh = ServerInstance->Modes.FindMode(chr, mt); if ((all || (mh && mh->NeedsOper())) && CanUseMode(mt, chr)) ret.push_back(chr); } return ret; } std::string OperType::GetSnomasks(bool all) const { std::string ret; for (unsigned char sno = 'A'; sno <= 'z'; ++sno) { if (!SnomaskManager::IsSnomask(sno)) continue; if ((all || ServerInstance->SNO.IsSnomaskUsable(sno)) && CanUseSnomask(sno)) ret.push_back(sno); } return ret; } bool OperType::CanUseCommand(const std::string& cmd) const { return commands.Contains(cmd); } bool OperType::CanUseMode(ModeType mt, unsigned char chr) const { const size_t index = ModeParser::GetModeIndex(chr); if (index == ModeParser::MODEID_MAX) return false; return (mt == MODETYPE_USER ? usermodes : chanmodes)[index]; } bool OperType::CanUseSnomask(unsigned char chr) const { if (SnomaskManager::IsSnomask(chr)) return snomasks[ModeParser::GetModeIndex(chr)]; return false; } bool OperType::HasPrivilege(const std::string& priv) const { return privileges.Contains(priv); } void OperType::MergeTag(const std::shared_ptr<ConfigTag>& tag) { for (const auto& [key, value] : tag->GetItems()) { if (insp::equalsci(key, "name") || insp::equalsci(key, "type") || insp::equalsci(key, "classes")) { // These are meta keys for linking the oper/type/class tags. continue; } if (insp::equalsci(key, "commands") || insp::equalsci(key, "privs") || insp::equalsci(key, "chanmodes") || insp::equalsci(key, "usermodes") || insp::equalsci(key, "snomasks")) { // These have already been parsed into the object. continue; } config->GetItems()[key] = value; } } OperAccount::OperAccount(const std::string& n, const std::shared_ptr<OperType>& o, const std::shared_ptr<ConfigTag>& t) : OperType(n, nullptr) , nopassword(t->getBool("nopassword")) , password(nopassword ? "" : t->getString("password")) , passwordhash(nopassword ? "" : t->getString("hash", "plaintext", 1)) , type(o ? o->GetName() : n) { autologin = t->getEnum("autologin", AutoLogin::NEVER, { { "strict", AutoLogin::STRICT }, { "relaxed", AutoLogin::RELAXED }, { "never", AutoLogin::NEVER }, }); if (o) { chanmodes = o->chanmodes; commands = o->commands; privileges = o->privileges; snomasks = o->snomasks; usermodes = o->usermodes; Configure(o->GetConfig(), true); } Configure(t, true); } bool OperAccount::CanAutoLogin(LocalUser* user) const { switch (autologin) { case AutoLogin::STRICT: return user->nick == GetName(); case AutoLogin::RELAXED: return true; case AutoLogin::NEVER: return false; } // Should never be reached. return false; } bool OperAccount::CheckPassword(const std::string& pw) const { if (nopassword) return true; // <oper nopassword="yes"> return !password.empty() && InspIRCd::CheckPassword(password, passwordhash, pw); } �������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/src/version.sh�����������������������������������������������������������������������0000775�0000000�0000000�00000000040�14771603147�0016154�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������#!/bin/sh echo "InspIRCd-4.7.0" ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/src/wildcard.cpp���������������������������������������������������������������������0000664�0000000�0000000�00000006376�14771603147�0016447�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2013, 2017, 2021-2022 Sadie Powell <sadie@witchery.services> * Copyright (C) 2012 Robby <robby@chatbelgie.be> * Copyright (C) 2009 Uli Schlachter <psychon@znc.in> * Copyright (C) 2008 Craig Edwards <brain@inspircd.org> * Copyright (C) 2007-2008 Robin Burchell <robin+git@viroteck.net> * Copyright (C) 2007-2008 Dennis Friis <peavey@inspircd.org> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include "inspircd.h" static bool MatchInternal(const unsigned char* str, const unsigned char* mask, const unsigned char* map) { const unsigned char* cp = nullptr; const unsigned char* mp = nullptr; const unsigned char* string = reinterpret_cast<const unsigned char*>(str); const unsigned char* wild = reinterpret_cast<const unsigned char*>(mask); while ((*string) && (*wild != '*')) { if ((map[*wild] != map[*string]) && (*wild != '?')) { return false; } wild++; string++; } while (*string) { if (*wild == '*') { if (!*++wild) { return true; } mp = wild; cp = string+1; } else if ((map[*wild] == map[*string]) || (*wild == '?')) { wild++; string++; } else { wild = mp; string = cp++; } } while (*wild == '*') { wild++; } return !*wild; } // Below here is all wrappers around MatchInternal bool InspIRCd::Match(const std::string& str, const std::string& mask, const unsigned char* map) { if (!map) map = national_case_insensitive_map; return MatchInternal(reinterpret_cast<const unsigned char*>(str.c_str()), reinterpret_cast<const unsigned char*>(mask.c_str()), map); } bool InspIRCd::Match(const char* str, const char* mask, const unsigned char* map) { if (!map) map = national_case_insensitive_map; return MatchInternal(reinterpret_cast<const unsigned char*>(str), reinterpret_cast<const unsigned char*>(mask), map); } bool InspIRCd::MatchCIDR(const std::string& str, const std::string& mask, const unsigned char* map) { if (irc::sockets::MatchCIDR(str, mask, true)) return true; // Fall back to regular match return InspIRCd::Match(str, mask, map); } bool InspIRCd::MatchCIDR(const char* str, const char* mask, const unsigned char* map) { if (irc::sockets::MatchCIDR(str, mask, true)) return true; // Fall back to regular match return InspIRCd::Match(str, mask, map); } bool InspIRCd::MatchMask(const std::string& masks, const std::string& hostname, const std::string& ipaddr) { irc::spacesepstream masklist(masks); std::string mask; while (masklist.GetToken(mask)) { if (InspIRCd::Match(hostname, mask, ascii_case_insensitive_map) || InspIRCd::MatchCIDR(ipaddr, mask, ascii_case_insensitive_map)) { return true; } } return false; } ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/src/xline.cpp������������������������������������������������������������������������0000664�0000000�0000000�00000047024�14771603147�0015770�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2019 Matt Schatz <genius3000@g3k.solutions> * Copyright (C) 2013, 2017-2023, 2025 Sadie Powell <sadie@witchery.services> * Copyright (C) 2013 Adam <Adam@anope.org> * Copyright (C) 2012-2014, 2016 Attila Molnar <attilamolnar@hush.com> * Copyright (C) 2012, 2019 Robby <robby@chatbelgie.be> * Copyright (C) 2009 Daniel De Graaf <danieldg@inspircd.org> * Copyright (C) 2007-2009 Robin Burchell <robin+git@viroteck.net> * Copyright (C) 2007 Dennis Friis <peavey@inspircd.org> * Copyright (C) 2004, 2006-2008 Craig Edwards <brain@inspircd.org> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include "inspircd.h" #include "modules/stats.h" #include "stringutils.h" #include "timeutils.h" #include "xline.h" /** An XLineFactory specialized to generate GLine* pointers */ class GLineFactory final : public XLineFactory { public: GLineFactory() : XLineFactory("G") { } /** Generate a GLine */ XLine* Generate(time_t set_time, unsigned long duration, const std::string& source, const std::string& reason, const std::string& xline_specific_mask) override { UserHostPair ih = XLineManager::SplitUserHost(xline_specific_mask); return new GLine(set_time, duration, source, reason, ih.first, ih.second); } }; /** An XLineFactory specialized to generate ELine* pointers */ class ELineFactory final : public XLineFactory { public: ELineFactory() : XLineFactory("E") { } /** Generate an ELine */ XLine* Generate(time_t set_time, unsigned long duration, const std::string& source, const std::string& reason, const std::string& xline_specific_mask) override { UserHostPair ih = XLineManager::SplitUserHost(xline_specific_mask); return new ELine(set_time, duration, source, reason, ih.first, ih.second); } }; /** An XLineFactory specialized to generate KLine* pointers */ class KLineFactory final : public XLineFactory { public: KLineFactory() : XLineFactory("K") { } /** Generate a KLine */ XLine* Generate(time_t set_time, unsigned long duration, const std::string& source, const std::string& reason, const std::string& xline_specific_mask) override { UserHostPair ih = XLineManager::SplitUserHost(xline_specific_mask); return new KLine(set_time, duration, source, reason, ih.first, ih.second); } }; /** An XLineFactory specialized to generate QLine* pointers */ class QLineFactory final : public XLineFactory { public: QLineFactory() : XLineFactory("Q") { } /** Generate a QLine */ XLine* Generate(time_t set_time, unsigned long duration, const std::string& source, const std::string& reason, const std::string& xline_specific_mask) override { return new QLine(set_time, duration, source, reason, xline_specific_mask); } }; /** An XLineFactory specialized to generate ZLine* pointers */ class ZLineFactory final : public XLineFactory { public: ZLineFactory() : XLineFactory("Z") { } /** Generate a ZLine */ XLine* Generate(time_t set_time, unsigned long duration, const std::string& source, const std::string& reason, const std::string& xline_specific_mask) override { return new ZLine(set_time, duration, source, reason, xline_specific_mask); } }; /* * This is now version 3 of the XLine subsystem, let's see if we can get it as nice and * efficient as we can this time so we can close this file and never ever touch it again .. * * Background: * Version 1 stored all line types in one list (one for g, one for z, etc). This was fine, * but both version 1 and 2 suck at applying lines efficiently. That is, every time a new line * was added, it iterated every existing line for every existing user. Ow. Expiry was also * expensive, as the lists were NOT sorted. * * Version 2 moved permanent lines into a separate list from non-permanent to help optimize * matching speed, but matched in the same way. * Expiry was also sped up by sorting the list by expiry (meaning just remove the items at the * head of the list that are outdated.) * * This was fine and good, but it looked less than ideal in code, and matching was still slower * than it could have been, something which we address here. * * VERSION 3: * All lines are (as in v1) stored together -- no separation of perm and non-perm. They are stored in * a map of maps (first map is line type, second map is for quick lookup on add/delete/etc). * * Expiry is *no longer* performed on a timer, and no longer uses a sorted list of any variety. This * is now done by only checking for expiry when a line is accessed, meaning that expiry is no longer * a resource intensive problem. * * Application no longer tries to apply every single line on every single user - instead, now only lines * added since the previous application are applied. This keeps S2S ADDLINE during burst nice and fast, * while at the same time not slowing things the fuck down when we try adding a ban with lots of preexisting * bans. :) */ bool XLine::Matches(User* u) const { return false; } /* * Checks what users match a given vector of ELines and sets their ban exempt flag accordingly. */ void XLineManager::CheckELines() { ContainerIter n = lookup_lines.find("E"); if (n == lookup_lines.end()) return; XLineLookup& ELines = n->second; if (ELines.empty()) return; for (auto* u : ServerInstance->Users.GetLocalUsers()) { u->exempt = false; /* This uses safe iteration to ensure that if a line expires here, it doesn't trash the iterator */ LookupIter safei; for (LookupIter i = ELines.begin(); i != ELines.end(); ) { safei = i; safei++; XLine* e = i->second; if ((!e->duration || ServerInstance->Time() < e->expiry) && e->Matches(u)) u->exempt = true; i = safei; } } } XLineLookup* XLineManager::GetAll(const std::string& type) { ContainerIter n = lookup_lines.find(type); if (n == lookup_lines.end()) return nullptr; LookupIter safei; const time_t current = ServerInstance->Time(); /* Expire any dead ones, before sending */ for (LookupIter x = n->second.begin(); x != n->second.end(); ) { safei = x; safei++; if (x->second->duration && current > x->second->expiry) { ExpireLine(n, x); } x = safei; } return &(n->second); } void XLineManager::DelAll(const std::string& type) { ContainerIter n = lookup_lines.find(type); if (n == lookup_lines.end()) return; LookupIter x; /* Delete all of a given type (this should probably use DelLine, but oh well) */ while ((x = n->second.begin()) != n->second.end()) { ExpireLine(n, x); } } std::vector<std::string> XLineManager::GetAllTypes() { std::vector<std::string> items; for (const auto& [type, _] : lookup_lines) items.push_back(type); return items; } UserHostPair XLineManager::SplitUserHost(const std::string& user_and_host) { UserHostPair n = std::make_pair("*", "*"); std::string::size_type x = user_and_host.find('@'); if (x != std::string::npos) { n.second = user_and_host.substr(x + 1, user_and_host.length()); n.first = user_and_host.substr(0, x); if (!n.first.length()) n.first.assign("*"); if (!n.second.length()) n.second.assign("*"); } else { n.first.clear(); n.second = user_and_host; } return n; } // adds a line bool XLineManager::AddLine(XLine* line, User* user) { if (line->duration && ServerInstance->Time() > line->expiry) return false; // Don't apply expired XLines. /* Don't apply duplicate xlines */ ContainerIter x = lookup_lines.find(line->type); if (x != lookup_lines.end()) { LookupIter i = x->second.find(line->Displayable()); if (i != x->second.end()) { bool silent = false; // Allow replacing a config line for an updated config line. if (i->second->from_config && line->from_config) { // Nothing changed, skip adding this one. if (i->second->reason == line->reason) return false; silent = true; } // Allow replacing a non-config line for a new config line. else if (!line->from_config) { // X-line propagation bug was here, if the line to be added already exists and // it's expired then expire it and add the new one instead of returning false if ((!i->second->duration) || (ServerInstance->Time() < i->second->expiry)) return false; } else { silent = true; } ExpireLine(x, i, silent); } } XLineFactory* xlf = GetFactory(line->type); if (!xlf) return false; ServerInstance->BanCache.RemoveEntries(line->type, false); // XXX perhaps remove ELines here? if (xlf->AutoApplyToUserList(line)) pending_lines.push_back(line); lookup_lines[line->type][line->Displayable()] = line; line->OnAdd(); FOREACH_MOD(OnAddLine, (user, line)); return true; } // deletes a line, returns true if the line existed and was removed bool XLineManager::DelLine(const std::string& hostmask, const std::string& type, std::string& reason, User* user, bool simulate) { ContainerIter x = lookup_lines.find(type); if (x == lookup_lines.end()) return false; LookupIter y = x->second.find(hostmask); if (y == x->second.end()) return false; reason.assign(y->second->reason); if (simulate) return true; ServerInstance->BanCache.RemoveEntries(y->second->type, true); FOREACH_MOD(OnDelLine, (user, y->second)); y->second->Unset(); stdalgo::erase(pending_lines, y->second); delete y->second; x->second.erase(y); return true; } void ELine::Unset() { ServerInstance->XLines->CheckELines(); } // returns a pointer to the reason if a nickname matches a Q-line, NULL if it didn't match XLine* XLineManager::MatchesLine(const std::string& type, User* user) { ContainerIter x = lookup_lines.find(type); if (x == lookup_lines.end()) return nullptr; const time_t current = ServerInstance->Time(); LookupIter safei; for (LookupIter i = x->second.begin(); i != x->second.end(); ) { safei = i; safei++; if (i->second->duration && current > i->second->expiry) { /* Expire the line, proceed to next one */ ExpireLine(x, i); i = safei; continue; } if (i->second->Matches(user)) { return i->second; } i = safei; } return nullptr; } XLine* XLineManager::MatchesLine(const std::string& type, const std::string& pattern) { ContainerIter x = lookup_lines.find(type); if (x == lookup_lines.end()) return nullptr; const time_t current = ServerInstance->Time(); LookupIter safei; for (LookupIter i = x->second.begin(); i != x->second.end(); ) { safei = i; safei++; if (i->second->Matches(pattern)) { if (i->second->duration && current > i->second->expiry) { /* Expire the line, return nothing */ ExpireLine(x, i); /* See above */ i = safei; continue; } else return i->second; } i = safei; } return nullptr; } // removes lines that have expired void XLineManager::ExpireLine(ContainerIter container, LookupIter item, bool silent) { ServerInstance->BanCache.RemoveEntries(item->second->type, true); FOREACH_MOD(OnExpireLine, (item->second)); if (!silent) item->second->DisplayExpiry(); item->second->Unset(); /* TODO: Can we skip this loop by having a 'pending' field in the XLine class, which is set when a line * is pending, cleared when it is no longer pending, so we skip over this loop if its not pending? * -- Brain */ stdalgo::erase(pending_lines, item->second); delete item->second; container->second.erase(item); } // applies lines, removing clients and changing nicks etc as applicable void XLineManager::ApplyLines() { const UserManager::LocalList& list = ServerInstance->Users.GetLocalUsers(); for (UserManager::LocalList::const_iterator j = list.begin(); j != list.end(); ) { LocalUser* u = *j++; // Don't ban people who are exempt. if (u->exempt) continue; for (auto* x : pending_lines) { if (x->Matches(u)) { x->Apply(u); // If applying the X-line has killed the user then don't // apply any more lines to them. if (u->quitting) break; } } } pending_lines.clear(); } bool XLineManager::InvokeStats(const std::string& type, Stats::Context& context) { ContainerIter citer = lookup_lines.find(type); if (citer == lookup_lines.end()) return false; for (LookupIter liter = citer->second.begin(); liter != citer->second.end(); ) { // We might be about to expire the XLine so we have to increment the // iterator early to avoid doing that causing iterator invalidation. LookupIter current = liter++; XLine* xline = current->second; if (xline->duration && xline->expiry <= ServerInstance->Time()) { // This XLine has expired so remove and skip it. ExpireLine(citer, current); continue; } context.AddGenericRow(xline->Displayable(), xline->set_time, xline->duration, xline->source, xline->reason); } return true; } XLineManager::XLineManager() { RegisterFactory(new ELineFactory()); RegisterFactory(new GLineFactory()); RegisterFactory(new KLineFactory()); RegisterFactory(new QLineFactory()); RegisterFactory(new ZLineFactory()); } XLineManager::~XLineManager() { for(const char line : "GEKQZ") { XLineFactory* xlf = GetFactory(std::string(1, line)); delete xlf; } // Delete all existing XLines for (const auto& [_, lines] : lookup_lines) { for (const auto& [__, line] : lines) delete line; } } void XLine::Apply(User* u) { } bool XLine::IsBurstable() { return !from_config; } void XLine::DefaultApply(User* u, bool bancache) { if (!ServerInstance->Config->XLineMessage.empty()) u->WriteNumeric(ERR_YOUREBANNEDCREEP, ServerInstance->Config->XLineMessage); Template::VariableMap vars = { { "created", Time::ToString(set_time) }, { "duration", Duration::ToString(duration) }, { "duration.long", Duration::ToLongString(duration) }, { "expiry", Time::ToString(expiry) }, { "fulltype", type.length() <= 2 ? type + "-lined" : type }, { "reason", reason }, { "remaining", Duration::ToString(ServerInstance->Time() - expiry) }, { "remaining.long", Duration::ToLongString(ServerInstance->Time() - expiry) }, { "setter", source }, { "type", type }, }; const std::string banreason = Template::Replace(ServerInstance->Config->XLineQuit, vars); if (ServerInstance->Config->XLineQuitPublic.empty()) ServerInstance->Users.QuitUser(u, banreason); else { const std::string publicreason = Template::Replace(ServerInstance->Config->XLineQuitPublic, vars); ServerInstance->Users.QuitUser(u, publicreason, &banreason); } if (bancache) { ServerInstance->Logs.Debug("BANCACHE", "Adding positive hit ({}) for {}", type, u->GetAddress()); ServerInstance->BanCache.AddHit(u->GetAddress(), this->type, banreason, (this->duration > 0 ? (this->expiry - ServerInstance->Time()) : 0)); } } bool KLine::Matches(User* u) const { LocalUser* lu = IS_LOCAL(u); if (lu && lu->exempt) return false; if (InspIRCd::Match(u->GetRealUser(), this->usermask, ascii_case_insensitive_map)) { if (InspIRCd::MatchCIDR(u->GetRealHost(), this->hostmask, ascii_case_insensitive_map) || InspIRCd::MatchCIDR(u->GetAddress(), this->hostmask, ascii_case_insensitive_map)) { return true; } } return false; } void KLine::Apply(User* u) { DefaultApply(u, this->usermask == "*"); } bool GLine::Matches(User* u) const { LocalUser* lu = IS_LOCAL(u); if (lu && lu->exempt) return false; if (InspIRCd::Match(u->GetRealUser(), this->usermask, ascii_case_insensitive_map)) { if (InspIRCd::MatchCIDR(u->GetRealHost(), this->hostmask, ascii_case_insensitive_map) || InspIRCd::MatchCIDR(u->GetAddress(), this->hostmask, ascii_case_insensitive_map)) { return true; } } return false; } void GLine::Apply(User* u) { DefaultApply(u, this->usermask == "*"); } bool ELine::Matches(User* u) const { if (InspIRCd::Match(u->GetRealUser(), this->usermask, ascii_case_insensitive_map)) { if (InspIRCd::MatchCIDR(u->GetRealHost(), this->hostmask, ascii_case_insensitive_map) || InspIRCd::MatchCIDR(u->GetAddress(), this->hostmask, ascii_case_insensitive_map)) { return true; } } return false; } bool ZLine::Matches(User* u) const { LocalUser* lu = IS_LOCAL(u); if (lu && lu->exempt) return false; return InspIRCd::MatchCIDR(u->GetAddress(), this->ipaddr); } void ZLine::Apply(User* u) { DefaultApply(u, true); } bool QLine::Matches(User* u) const { return InspIRCd::Match(u->nick, this->nick); } void QLine::Apply(User* u) { /* Force to uuid on apply of Q-line, no need to disconnect anymore :) */ u->WriteNumeric(RPL_SAVENICK, u->uuid, "Your nickname has been Q-lined."); u->ChangeNick(u->uuid); } bool ZLine::Matches(const std::string& str) const { return InspIRCd::MatchCIDR(str, this->ipaddr); } bool QLine::Matches(const std::string& str) const { return InspIRCd::Match(str, this->nick); } bool ELine::Matches(const std::string& str) const { return InspIRCd::MatchCIDR(str, matchtext); } bool KLine::Matches(const std::string& str) const { return InspIRCd::MatchCIDR(str, matchtext); } bool GLine::Matches(const std::string& str) const { return InspIRCd::MatchCIDR(str, matchtext); } void ELine::OnAdd() { /* When adding one E-line, only check the one E-line */ for (auto* u : ServerInstance->Users.GetLocalUsers()) { if (this->Matches(u)) u->exempt = true; } } void XLine::DisplayExpiry() { ServerInstance->SNO.WriteToSnoMask('x', "Removing an expired {}{} on {} (set by {} {} ago): {}", type, (type.length() <= 2 ? "-line" : ""), Displayable(), source, Duration::ToLongString(ServerInstance->Time() - set_time), reason); } const std::string& ELine::Displayable() const { return matchtext; } const std::string& KLine::Displayable() const { return matchtext; } const std::string& GLine::Displayable() const { return matchtext; } const std::string& ZLine::Displayable() const { return ipaddr; } const std::string& QLine::Displayable() const { return nick; } bool KLine::IsBurstable() { return false; } bool XLineManager::RegisterFactory(XLineFactory* xlf) { XLineFactMap::iterator n = line_factory.find(xlf->GetType()); if (n != line_factory.end()) return false; line_factory[xlf->GetType()] = xlf; return true; } bool XLineManager::UnregisterFactory(XLineFactory* xlf) { XLineFactMap::iterator n = line_factory.find(xlf->GetType()); if (n == line_factory.end()) return false; line_factory.erase(n); return true; } XLineFactory* XLineManager::GetFactory(const std::string& type) { XLineFactMap::iterator n = line_factory.find(type); if (n == line_factory.end()) return nullptr; return n->second; } void XLineManager::ExpireRemovedConfigLines(const std::string& type, const insp::flat_set<std::string>& configlines) { // Nothing to do. if (lookup_lines.empty()) return; ContainerIter xlines = lookup_lines.find(type); if (xlines == lookup_lines.end()) return; for (LookupIter xline = xlines->second.begin(); xline != xlines->second.end(); ) { LookupIter cachedxline = xline++; if (!cachedxline->second->from_config) continue; if (!configlines.count(cachedxline->second->Displayable())) ExpireLine(xlines, cachedxline); } } ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/tools/�������������������������������������������������������������������������������0000775�0000000�0000000�00000000000�14771603147�0014507�5����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/tools/convert-unreal-channel���������������������������������������������������������0000775�0000000�0000000�00000007577�14771603147�0021027�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������#!/usr/bin/env python3 # # InspIRCd -- Internet Relay Chat Daemon # # Copyright (C) 2024 Val Lorentz <progval+git@progval.net> # Copyright (C) 2024 Sadie Powell <sadie@witchery.services> # # This file is part of InspIRCd. InspIRCd is free software: you can # redistribute it and/or modify it under the terms of the GNU General Public # License as published by the Free Software Foundation, version 2. # # This program is distributed in the hope that it will be useful, but WITHOUT # ANY WARRANTY without even the implied warranty of MERCHANTABILITY or FITNESS # FOR A PARTICULAR PURPOSE. See the GNU General Public License for more # details. # # You should have received a copy of the GNU General Public License # along with this program. If not, see <http://www.gnu.org/licenses/>. # import io import os import sys class UnrealDB: def __init__(self, path): self.error = None try: with open(sys.argv[1], mode="rb") as fh: data = fh.read() if data.startswith(b"UnrealIRCd-DB-v1"): self.data = io.BytesIO(data[40:]) elif data.startswith(b"UnrealIRCd-DB"): self.error = f"Unsupported database version: {data[0:32]}" else: self.data = io.BytesIO(data) except OSError as e: self.error = f"Read error: {e}" def read_i16(self): return int.from_bytes(self.data.read(2), byteorder="little") def read_i32(self): return int.from_bytes(self.data.read(4), byteorder="little") def read_i64(self): return int.from_bytes(self.data.read(8), byteorder="little") def read_str(self): len = self.read_i16() if len == 0 or len == 0xFFFF: return "" return self.data.read(len).decode("utf-8") def error(msg): print(msg, file=sys.stderr) sys.exit(1) if len(sys.argv) < 3: program = os.path.basename(__file__) error(f"Usage: {program} <input-file> <output-file>") db = UnrealDB(sys.argv[1]) if db.error: error(db.error) version = db.read_i32() if version != 100: error(f"Unrecognised channel database version: {version}") count = db.read_i64() print(f"Converting {count} channels ...") try: with open(sys.argv[2], mode="w") as fh: for i in range(count): magic = db.read_i32() if magic != 0x11111111: error(f"Unrecognised database start magic: {magic}") channel = db.read_str() print(f'<permchannels name="{channel}"', file=fh) created = db.read_i64() print(f' ts="{created}"', file=fh) topic = db.read_str() print(f' topic="{topic}"', file=fh) topic_set_by = db.read_str() print(f' topicsetby="{topic_set_by}"', file=fh) topic_set_at = db.read_i64() print(f' topicts="{topic_set_at}"', file=fh) modes = db.read_str() mode_params = db.read_str() print(f' modes="{modes} {mode_params}"', file=fh) mode_lock = db.read_str() # unused for mode in ["ban", "banexception", "invex"]: mode_count = db.read_i32() if mode_count == 0: continue print(f' {mode}list="', end="", file=fh) for j in range(mode_count): mode_str = db.read_str() mode_set_by = db.read_str() mode_set_at = db.read_i64() print(f"{mode_str} {mode_set_by} {mode_set_at} ", end="", file=fh) print('"', file=fh) magic = db.read_i32() if magic != 0x22222222: error(f"Unrecognised database end magic: {magic}") print(">", file=fh) except OSError as e: error(f"Write error: {e}") ���������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/tools/convert-unreal-tkl�������������������������������������������������������������0000775�0000000�0000000�00000010112�14771603147�0020164�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������#!/usr/bin/env python3 # # InspIRCd -- Internet Relay Chat Daemon # # Copyright (C) 2024 Val Lorentz <progval+git@progval.net> # Copyright (C) 2024 Sadie Powell <sadie@witchery.services> # # This file is part of InspIRCd. InspIRCd is free software: you can # redistribute it and/or modify it under the terms of the GNU General Public # License as published by the Free Software Foundation, version 2. # # This program is distributed in the hope that it will be useful, but WITHOUT # ANY WARRANTY without even the implied warranty of MERCHANTABILITY or FITNESS # FOR A PARTICULAR PURPOSE. See the GNU General Public License for more # details. # # You should have received a copy of the GNU General Public License # along with this program. If not, see <http://www.gnu.org/licenses/>. # import io import os import sys class UnrealDB: def __init__(self, path): self.error = None try: with open(sys.argv[1], mode="rb") as fh: data = fh.read() if data.startswith(b"UnrealIRCd-DB-v1"): self.data = io.BytesIO(data[40:]) elif data.startswith(b"UnrealIRCd-DB"): self.error = f"Unsupported database version: {data[0:32]}" else: self.data = io.BytesIO(data) except OSError as e: self.error = f"Read error: {e}" def read_char(self): return self.data.read(1).decode("utf-8") def read_i16(self): return int.from_bytes(self.data.read(2), byteorder="little") def read_i32(self): return int.from_bytes(self.data.read(4), byteorder="little") def read_i64(self): return int.from_bytes(self.data.read(8), byteorder="little") def read_str(self): len = self.read_i16() if len == 0 or len == 0xFFFF: return "" return self.data.read(len).decode("utf-8") def error(msg): print(msg, file=sys.stderr) sys.exit(1) if len(sys.argv) < 3: program = os.path.basename(__file__) error(f"Usage: {program} <input-file> <output-file>") db = UnrealDB(sys.argv[1]) if db.error: error(db.error) magic = db.read_i32() if magic != 0x10101010: error(f"Unrecognised database magic: {magic}") version = db.read_i32() if version != 4999: error(f"Unrecognised TKL database version: {version}") count = db.read_i64() print(f"Converting {count} TKLs ...") try: with open(sys.argv[2], mode="w") as fh: print("VERSION 1", file=fh) for i in range(count): type = db.read_char() set_by = db.read_str() set_at = db.read_i64() expire_at = db.read_i64() duration = expire_at - set_at if type in "Ee": username = db.read_str() hostname = db.read_str() etype = db.read_str() # unused reason = db.read_str() print( f"LINE E {username}@{hostname} {set_by} {set_at} {duration} :{reason}", file=fh, ) elif type in "Ff": method = db.read_str() # unused pattern = db.read_str() # unused target = db.read_str() # unused action = db.read_char() # unused reason = db.read_str() # unused duration = db.read_i64() # unused elif type in "GksZz": username = db.read_str() hostname = db.read_str() reason = db.read_str() line = "SHUN" if type == "s" else type.upper() print( f"LINE {line} {username}@{hostname} {set_by} {set_at} {duration} :{reason}", file=fh, ) elif type in "Qq": etype = db.read_str() # unused name = db.read_str() reason = db.read_str() print(f"LINE Q {name} {set_by} {set_at} {duration} :{reason}", file=fh) else: error(f"Unsupported row type: {type}") except OSError as e: error(f"Write error: {e}") ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/tools/directive����������������������������������������������������������������������0000775�0000000�0000000�00000002500�14771603147�0016410�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������#!/usr/bin/env perl # # InspIRCd -- Internet Relay Chat Daemon # # Copyright (C) 2020-2021 Sadie Powell <sadie@witchery.services> # # This file is part of InspIRCd. InspIRCd is free software: you can # redistribute it and/or modify it under the terms of the GNU General Public # License as published by the Free Software Foundation, version 2. # # This program is distributed in the hope that it will be useful, but WITHOUT # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS # FOR A PARTICULAR PURPOSE. See the GNU General Public License for more # details. # # You should have received a copy of the GNU General Public License # along with this program. If not, see <http://www.gnu.org/licenses/>. # use v5.26.0; use strict; use warnings FATAL => qw(all); use File::Basename qw(dirname); use FindBin qw($RealDir); use lib dirname $RealDir; use make::console; use make::directive; if (scalar @ARGV < 2) { say STDERR console_format "<|GREEN Usage:|> $0 <<|UNDERLINE FILE|>> [<|UNDERLINE DIRECTIVES...|>]"; exit 1 } my $file = shift; print_error "<|GREEN $file|> does not exist and/or is not a file!" unless -f $file; for my $directive (@ARGV) { my $value = get_directive $file, $directive, ''; if (-t STDOUT) { say console_format "<|GREEN $directive|>: $value"; } else { say $value; } } ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/tools/mkauthors����������������������������������������������������������������������0000775�0000000�0000000�00000004366�14771603147�0016463�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������#!/usr/bin/env perl # # InspIRCd -- Internet Relay Chat Daemon # # Copyright (C) 2021-2022, 2024 Sadie Powell <sadie@witchery.services> # # This file is part of InspIRCd. InspIRCd is free software: you can # redistribute it and/or modify it under the terms of the GNU General Public # License as published by the Free Software Foundation, version 2. # # This program is distributed in the hope that it will be useful, but WITHOUT # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS # FOR A PARTICULAR PURPOSE. See the GNU General Public License for more # details. # # You should have received a copy of the GNU General Public License # along with this program. If not, see <http://www.gnu.org/licenses/>. # use v5.26.0; use strict; use warnings FATAL => qw(all); use File::Basename qw(dirname); use File::Spec::Functions qw(catfile); use FindBin qw($RealDir); use lib dirname $RealDir; use make::common; use make::console; my %committers; for my $committer (split /\n+/, `git log --pretty='%an <%ae>%n%(trailers:key=Co-Authored-By,valueonly)' HEAD`) { $committers{$committer} ||= 0; $committers{$committer} += 1; } my %authors; for my $committer (keys %committers) { open(my $fh, '-|', 'git', 'check-mailmap', $committer); chomp(my $author = <$fh>); close $fh; $author = $1 if $author =~ /^(.+) <(?:unknown\@email.invalid|\S+\@users.noreply.github.com)>$/; next if $author =~ /\[bot\]$/; $authors{$author} ||= 0; $authors{$author} += $committers{$committer}; } my $author_file = catfile dirname($RealDir), 'docs', 'AUTHORS.txt'; open(my $fh, '>', $author_file) or print_error "unable to write $author_file: $!"; say $fh <<"EOH"; Since the first commit in January 2003 ${\scalar %authors} people have submitted patches, commits, and other useful contributions to InspIRCd. These people, ordered by the number of contributions they have made, are: EOH for my $author (sort { $authors{$b} <=> $authors{$a} or lc($a) cmp lc($b) } keys %authors) { next if $author eq 'InspIRCd Robot <noreply@inspircd.org>'; say $fh " * $author"; } close $fh; if ($ENV{MKAUTHORS_COMMIT} // 1) { execute 'git', 'commit', '--author', 'InspIRCd Robot <noreply@inspircd.org>', '--message', 'Update author list.', '--', $author_file; } ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/tools/mkdescriptions�����������������������������������������������������������������0000775�0000000�0000000�00000006024�14771603147�0017475�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������#!/usr/bin/env perl # # InspIRCd -- Internet Relay Chat Daemon # # Copyright (C) 2020-2021, 2024 Sadie Powell <sadie@witchery.services> # # This file is part of InspIRCd. InspIRCd is free software: you can # redistribute it and/or modify it under the terms of the GNU General Public # License as published by the Free Software Foundation, version 2. # # This program is distributed in the hope that it will be useful, but WITHOUT # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS # FOR A PARTICULAR PURPOSE. See the GNU General Public License for more # details. # # You should have received a copy of the GNU General Public License # along with this program. If not, see <http://www.gnu.org/licenses/>. # use v5.26.0; use strict; use warnings FATAL => qw(all); use CommonMark (); use File::Basename qw(basename dirname); use File::Spec::Functions qw(catdir catfile rel2abs); use FindBin qw($RealDir); use HTML::FormatText (); use HTML::TreeBuilder (); use Text::Sentence qw(split_sentences); use YAML qw(LoadFile); use lib dirname $RealDir; use make::common; use make::console; unless (scalar @ARGV) { say STDERR console_format "<|GREEN Usage:|> $0 <<|UNDERLINE DOCS-SITE|>>"; exit 1; } my %version = get_version(); my $docdir = rel2abs catdir $ARGV[0], 'docs', $version{MAJOR}, 'modules'; print_error "unable to find the module directory at $docdir!" unless -d $docdir; my @updated; my $root = dirname $RealDir; for my $module (<$root/src/modules/extra/m_*.cpp>, <$root/src/modules/m_*.cpp>, <$root/src/modules/m_*/main.cpp>) { print_error "unable to extract module name from $module!" unless $module =~ /m_(\w+)[.\/]/; my $docfile = catfile $docdir, "$1.yml"; print_error "unable to find the module documentation at $docfile!" unless -f $docfile; my ($docdata, undef, undef) = LoadFile($docfile) or print_error "unable to read from $docfile: $!"; print_error "unable to find the module description in $docfile!" unless $docdata->{description}; my $docraw = $docdata->{description} =~ s/(?:^This module |\{\{\s*[a-z_]+\s*\}\})//gr; my $docrendered = CommonMark->markdown_to_html(ucfirst $docraw); my $docplain = HTML::FormatText->new(leftmargin => 0, rightmargin => ~0)->format(HTML::TreeBuilder->new->parse($docrendered)); my $description = (split_sentences $docplain)[0] =~ s/"/\\"/gr; chomp($description); open(my $mih, $module) or print_error "unable to read from $module: $!"; my @lines; for my $line (<$mih>) { chomp $line; if ($line =~ /^(\t+:\s+Module\([^,]+,\s+")[^"]+("\))$/) { push @lines, join '', $1, $description, $2; push @updated, $module; } else { push @lines, $line; } } close $mih; open(my $moh, '>', $module) or print_error "unable to write to $module: $!"; for my $line (@lines) { say $moh $line; } close $moh; } if ($ENV{MKDESCRIPTIONS_COMMIT} // 0) { execute 'git', 'commit', '--author', 'InspIRCd Robot <noreply@inspircd.org>', '--message', 'Update module descriptions.', '--', @updated; } ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/tools/mkheaders����������������������������������������������������������������������0000775�0000000�0000000�00000012324�14771603147�0016402�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������#!/usr/bin/env perl # # InspIRCd -- Internet Relay Chat Daemon # # Copyright (C) 2020-2025 Sadie Powell <sadie@witchery.services> # # This file is part of InspIRCd. InspIRCd is free software: you can # redistribute it and/or modify it under the terms of the GNU General Public # License as published by the Free Software Foundation, version 2. # # This program is distributed in the hope that it will be useful, but WITHOUT # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS # FOR A PARTICULAR PURPOSE. See the GNU General Public License for more # details. # # You should have received a copy of the GNU General Public License # along with this program. If not, see <http://www.gnu.org/licenses/>. # use v5.26.0; use strict; use warnings FATAL => qw(all); use File::Basename qw(dirname); use File::Util (); use FindBin qw($RealDir); use List::Util qw(uniq); use POSIX qw(strftime); use lib dirname $RealDir; use make::common; use make::console; my @ignored_revisions = ( '46a39046196f55b52336e19662bb7bac85b731ac', # adding copyright headers '4a6fedd9324d87349a806c9c1d0ae6e7d3c1fd38', # mass-updating descriptions 'bab14f0dd2345c9d7dcbc47c918563709e1ac094', # peavey breaking line endings 'de6d4dbd1e8845e08c2d87cd89a919e5b21ba619', # jsoref fixing a ton of typos 'f2acdbc3820f0f4f5ef76a0a64e73d2a320df91f', # peavey fixing line endings ); sub make_range($@) { my ($separator, @nums) = @_; my ($last_num, $start_num, @num_ranges); for my $num (uniq sort { $a <=> $b } @nums) { if (!defined $last_num) { $start_num = $last_num = $num } elsif ($num == $last_num + 1) { $last_num = $num; } else { if ($last_num == $start_num) { push @num_ranges, $last_num; } else { push @num_ranges, "$start_num$separator$last_num"; } $start_num = $last_num = $num; } } if (defined $last_num) { if ($last_num == $start_num) { push @num_ranges, $last_num; } else { push @num_ranges, "$start_num$separator$last_num"; } } return @num_ranges; } my @paths = File::Util->new->list_dir(dirname($RealDir) => { recurse => 1 }); my @updated; for my $path (@paths) { next unless -f $path; next if $path =~ /\/\./; next if $path =~ /\/build\//; next if $path =~ /\/vendor\//; if (system "git ls-files --error-unmatch -- $path 1>/dev/null 2>/dev/null") { say STDERR console_format "Skipping <|YELLOW $path|> as it has not been committed." if defined $ENV{MKHEADERS_VERBOSE}; next; } open(my $fh, $path) or print_error "unable to read from $path: $!"; my ($copyright, $indent, $linenum, @linenums, @lines); for my $line (<$fh>) { $linenum += 1; chomp $line; if ($line =~ /^([^0-9A-Za-z]+\s)Copyright\s+\(C\)\s+[^<]+(\s+<[^>]+>)?[\r\s]*$/) { $copyright = scalar @lines; $indent = $1; } else { push @lines, $line; push(@linenums, $linenum) if $line =~ /\S/; } } close $fh; if (defined $copyright) { say console_format "Updating copyright headers in <|GREEN $path|>." if defined $ENV{MKHEADERS_VERBOSE}; my (%authors, $commit, %commits); my $ignored_args = join ' ', map { "--ignore-rev $_" } @ignored_revisions; my $line_args = join ' ', map { "-L $_" } make_range ',', @linenums; for my $line (split /\n+/, `git blame $ignored_args $line_args --incremental -M -w HEAD -- $path`) { if ($line =~ /^([0-9a-f]{40})(?:\s\d+){3}$/) { $commit = $1; $commits{$commit} //= {}; } elsif ($line =~ /^author (.+)/) { $commits{$commit}->{NAME} = $1; } elsif ($line =~ /^author-mail <(.+)>/) { next if $1 eq 'unknown@email.invalid'; next if $1 =~ /\@users.noreply.github.com$/; $commits{$commit}->{EMAIL} = $1; } elsif ($line =~ /^author-time (.+)/) { $commits{$commit}->{YEAR} = strftime '%Y', gmtime $1; } elsif ($line =~ /^filename /) { my $display = $commits{$commit}->{NAME}; if (exists $commits{$commit}->{EMAIL}) { $display .= sprintf " <%s>", $commits{$commit}->{EMAIL}; } $authors{$display} //= []; push @{$authors{$display}}, $commits{$commit}->{YEAR}; my $details = `git rev-list --format=%B --max-count=1 $commit`; while ($details =~ /co-authored-by: ([^<]+<[^>]+>)/gi) { open(my $fh, '-|', 'git', 'check-mailmap', $1); chomp(my $coauthor = <$fh>); close $fh; my $year = $details =~ /co-authored-year: (\d+)/i ? $1 : $commits{$commit}->{YEAR}; $authors{$coauthor} //= []; push @{$authors{$coauthor}}, $year; } undef $commit; } } my @copyrights; while (my ($display, $years) = each %authors) { next if $display eq 'InspIRCd Robot <noreply@inspircd.org>'; my @year_ranges = make_range '-', @$years; my $joined_years = join ', ', @year_ranges; push @copyrights, "${\$indent}Copyright (C) $joined_years $display"; } splice @lines, $copyright, 0, reverse sort @copyrights; open(my $fh, '>', $path) or print_error "unable to write to $path: $!"; for my $line (@lines) { say $fh $line; } close $fh; push @updated, $path; } else { say STDERR console_format "Skipping <|YELLOW $path|> as it contains no copyright headers." if defined $ENV{MKHEADERS_VERBOSE}; } } if ($ENV{MKHEADERS_COMMIT} // 1) { execute 'git', 'commit', '--author', 'InspIRCd Robot <noreply@inspircd.org>', '--message', 'Update copyright headers.', '--', @updated; } ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/tools/testssl������������������������������������������������������������������������0000775�0000000�0000000�00000012242�14771603147�0016137�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������#!/usr/bin/env perl # # InspIRCd -- Internet Relay Chat Daemon # # Copyright (C) 2021 Matt Schatz <genius3000@g3k.solutions> # Copyright (C) 2020-2022, 2024 Sadie Powell <sadie@witchery.services> # # This file is part of InspIRCd. InspIRCd is free software: you can # redistribute it and/or modify it under the terms of the GNU General Public # License as published by the Free Software Foundation, version 2. # # This program is distributed in the hope that it will be useful, but WITHOUT # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS # FOR A PARTICULAR PURPOSE. See the GNU General Public License for more # details. # # You should have received a copy of the GNU General Public License # along with this program. If not, see <http://www.gnu.org/licenses/>. # use v5.26.0; use strict; use warnings FATAL => qw(all); use IO::Socket(); use IO::Socket::SSL(); use constant { CC_BOLD => -t STDOUT ? "\e[1m" : '', CC_RESET => -t STDOUT ? "\e[0m" : '', CC_GREEN => -t STDOUT ? "\e[1;32m" : '', CC_RED => -t STDOUT ? "\e[1;31m" : '', }; if (scalar @ARGV < 2) { say STDERR "Usage: $0 <hostip> <port> [selfsigned]"; exit 1; } # By default STDOUT is only flushed at the end of each line. This sucks for our # needs so we disable it. STDOUT->autoflush(1); # If a server closes the connection whilst an SSL session is being initiated we # want EPIPE instead of SIGPIPE. $SIG{PIPE} = 'IGNORE'; my $hostip = shift @ARGV; if ($hostip =~ /[^A-Za-z0-9.:-]/) { say STDERR "Error: invalid hostname or IP address: $hostip"; exit 1; } my $port = shift @ARGV; if ($port =~ /\D/ || $port < 1 || $port > 65535) { say STDERR "Error: invalid TCP port: $port"; exit 1; } my $self_signed = shift // '' eq 'selfsigned'; print "Checking whether ${\CC_BOLD}$hostip/$port${\CC_RESET} is reachable ... "; my $sock = IO::Socket::INET->new( PeerAddr => $hostip, PeerPort => $port, ); unless ($sock) { say <<"EOM"; ${\CC_RED}no${\CC_RESET} It seems like the server endpoint you specified is not reachable! Make sure that: * You have specified a <bind> tag in your config for this endpoint. * You have rehashed or restarted the server since adding the <bind> tag. * If you are using a firewall incoming connections on TCP port $port are allowed. * The endpoint your server is listening on is not local or private. The error provided by the socket library was: $IO::Socket::errstr See https://docs.inspircd.org/4/configuration/#bind for more information. EOM exit 1; } say "${\CC_GREEN}yes${\CC_RESET}"; print "Checking whether ${\CC_BOLD}$hostip/$port${\CC_RESET} is using plaintext ... "; my $error = $sock->recv(my $data, 1); if (!defined $error || $data eq '') { say <<"EOM"; ${\CC_RED}error${\CC_RESET} It seems like the server dropped the connection before sending anything! Make sure that: * The endpoint you specified is actually your IRC server. * If you are using a firewall incoming data on TCP port $port are allowed. * The IP address you are connecting from has not been banned from the server. See https://docs.inspircd.org/4/configuration/#bind for more information. EOM exit 1; } elsif ($data =~ /[A-Z:@]/) { say <<"EOM"; ${\CC_RED}yes${\CC_RESET} It appears that the server endpoint is using plaintext! Make sure that: * You have one or more of the following modules loaded: - ssl_gnutls - ssl_openssl * The value of <bind:sslprofile> is the same as an <sslprofile:name> field. * The value of <sslprofile:provider> for your used TLS profile is set to "gnutls" if using the ssl_gnutls module or "openssl" if using the ssl_openssl module. * If you have your TLS configuration in a file other than inspircd.conf then that file is included by inspircd.conf. See the following links for more information: https://docs.inspircd.org/4/modules/ssl_gnutls/#configuration https://docs.inspircd.org/4/modules/ssl_openssl/#configuration EOM exit 1; } $sock->close(); say "${\CC_GREEN}no${\CC_RESET}"; print "Checking whether ${\CC_BOLD}$hostip/$port${\CC_RESET} can have an TLS session negotiated ... "; $sock = IO::Socket::SSL->new( PeerAddr => $hostip, PeerPort => $port, SSL_hostname => $hostip, SSL_verify_mode => $self_signed ? IO::Socket::SSL::SSL_VERIFY_NONE : IO::Socket::SSL::SSL_VERIFY_PEER, ); unless ($sock) { say <<"EOM"; ${\CC_RED}no${\CC_RESET} It appears that something is wrong with your server. Make sure that: * You are not using an old version of GnuTLS or OpenSSL which only supports deprecated algorithms like SSLv3. * If you are using a self-signed certificate (not recommended) that you passed the `selfsigned` argument to this script. The error provided by the TLS library was: $IO::Socket::SSL::SSL_ERROR EOM exit 1; } say <<"EOM"; ${\CC_GREEN}yes${\CC_RESET} It seems like TLS is working fine on your server. If you are having trouble connecting try using a different client or connecting from a different host. You may also find running some of the following commands to be helpful: gnutls-cli-debug --port $port $hostip openssl s_client -connect $hostip:$port -debug -security_debug If you need any help working out what is wrong then visit our support channel at ircs://irc.teranova.net/inspircd. EOM ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/vendor/������������������������������������������������������������������������������0000775�0000000�0000000�00000000000�14771603147�0014644�5����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/vendor/README.md���������������������������������������������������������������������0000664�0000000�0000000�00000003432�14771603147�0016125�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������# Vendored Libraries This directory contains vendored dependencies that are shipped with InspIRCd to avoid users needing to install them manually. ## bcrypt **Author** &mdash; [Solar Designer](mailto:solar@openwall.com) **License** &mdash; Public Domain **Version** &mdash; v1.3 **Website** &mdash; [https://www.openwall.com/crypt/](https://www.openwall.com/crypt/) ## fmt **Author** &mdash; Victor Zverovich and fmt contributors **License** &mdash; MIT License **Version** &mdash; 11.1.4 **Website** &mdash; [https://github.com/fmtlib/fmt/](https://github.com/fmtlib/fmt/) ## http_parser **Author** &mdash; Joyent, Inc. and other Node contributors **License** &mdash; MIT License **Version** &mdash; debian/2.9.4-6 **Website** &mdash; [https://git.in-ulm.de/cbiedl/http-parser](https://git.in-ulm.de/cbiedl/http-parser) ## lyra **Author** &mdash; Build Frameworks Group **License** &mdash; Boost Software License **Version** &mdash; 1.6.1 **Website** &mdash; [https://github.com/bfgroup/Lyra](https://github.com/bfgroup/Lyra) ## md5 **Author** &mdash; [Solar Designer](mailto:solar@openwall.com) **License** &mdash; Cut-down BSD License **Version** &mdash; v2.0 **Website** &mdash; [https://openwall.info/wiki/people/solar/software/public-domain-source-code/md5](https://openwall.info/wiki/people/solar/software/public-domain-source-code/md5) ## sha2 **Author** &mdash; [Olivier Gay](mailto:olivier.gay@a3.epfl.ch) **License** &mdash; 3-clause BSD License **Version** &mdash; 2007-02-02 **Website** &mdash; [http://www.ouah.org/ogay/sha2/](http://www.ouah.org/ogay/sha2/) ## utfcpp **Author** &mdash; Nemanja Trifunovic **License** &mdash; Boost Software License **Version** &mdash; v4.0.6 **Website** &mdash; [https://github.com/nemtrif/utfcpp](https://github.com/nemtrif/utfcpp) ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/vendor/bcrypt/�����������������������������������������������������������������������0000775�0000000�0000000�00000000000�14771603147�0016147�5����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/vendor/bcrypt/crypt_blowfish.c�������������������������������������������������������0000664�0000000�0000000�00000077051�14771603147�0021363�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * The crypt_blowfish homepage is: * * http://www.openwall.com/crypt/ * * This code comes from John the Ripper password cracker, with reentrant * and crypt(3) interfaces added, but optimizations specific to password * cracking removed. * * Written by Solar Designer <solar at openwall.com> in 1998-2014. * No copyright is claimed, and the software is hereby placed in the public * domain. In case this attempt to disclaim copyright and place the software * in the public domain is deemed null and void, then the software is * Copyright (c) 1998-2014 Solar Designer and it is hereby released to the * general public under the following terms: * * Redistribution and use in source and binary forms, with or without * modification, are permitted. * * There's ABSOLUTELY NO WARRANTY, express or implied. * * It is my intent that you should be able to use this on your system, * as part of a software package, or anywhere else to improve security, * ensure compatibility, or for any other purpose. I would appreciate * it if you give credit where it is due and keep your modifications in * the public domain as well, but I don't require that in order to let * you place this code and any modifications you make under a license * of your choice. * * This implementation is fully compatible with OpenBSD's bcrypt.c for prefix * "$2b$", originally by Niels Provos <provos at citi.umich.edu>, and it uses * some of his ideas. The password hashing algorithm was designed by David * Mazieres <dm at lcs.mit.edu>. For information on the level of * compatibility for bcrypt hash prefixes other than "$2b$", please refer to * the comments in BF_set_key() below and to the included crypt(3) man page. * * There's a paper on the algorithm that explains its design decisions: * * http://www.usenix.org/events/usenix99/provos.html * * Some of the tricks in BF_ROUND might be inspired by Eric Young's * Blowfish library (I can't be sure if I would think of something if I * hadn't seen his code). */ #include <string.h> #include <errno.h> #ifndef __set_errno #define __set_errno(val) errno = (val) #endif /* Just to make sure the prototypes match the actual definitions */ #include "crypt_blowfish.h" #ifdef __i386__ #define BF_ASM 1 #define BF_SCALE 1 #elif defined(__x86_64__) || defined(__alpha__) || defined(__hppa__) #define BF_ASM 0 #define BF_SCALE 1 #else #define BF_ASM 0 #define BF_SCALE 0 #endif typedef unsigned int BF_word; typedef signed int BF_word_signed; /* Number of Blowfish rounds, this is also hardcoded into a few places */ #define BF_N 16 typedef BF_word BF_key[BF_N + 2]; typedef struct { BF_word S[4][0x100]; BF_key P; } BF_ctx; /* * Magic IV for 64 Blowfish encryptions that we do at the end. * The string is "OrpheanBeholderScryDoubt" on big-endian. */ static BF_word BF_magic_w[6] = { 0x4F727068, 0x65616E42, 0x65686F6C, 0x64657253, 0x63727944, 0x6F756274 }; /* * P-box and S-box tables initialized with digits of Pi. */ static BF_ctx BF_init_state = { { { 0xd1310ba6, 0x98dfb5ac, 0x2ffd72db, 0xd01adfb7, 0xb8e1afed, 0x6a267e96, 0xba7c9045, 0xf12c7f99, 0x24a19947, 0xb3916cf7, 0x0801f2e2, 0x858efc16, 0x636920d8, 0x71574e69, 0xa458fea3, 0xf4933d7e, 0x0d95748f, 0x728eb658, 0x718bcd58, 0x82154aee, 0x7b54a41d, 0xc25a59b5, 0x9c30d539, 0x2af26013, 0xc5d1b023, 0x286085f0, 0xca417918, 0xb8db38ef, 0x8e79dcb0, 0x603a180e, 0x6c9e0e8b, 0xb01e8a3e, 0xd71577c1, 0xbd314b27, 0x78af2fda, 0x55605c60, 0xe65525f3, 0xaa55ab94, 0x57489862, 0x63e81440, 0x55ca396a, 0x2aab10b6, 0xb4cc5c34, 0x1141e8ce, 0xa15486af, 0x7c72e993, 0xb3ee1411, 0x636fbc2a, 0x2ba9c55d, 0x741831f6, 0xce5c3e16, 0x9b87931e, 0xafd6ba33, 0x6c24cf5c, 0x7a325381, 0x28958677, 0x3b8f4898, 0x6b4bb9af, 0xc4bfe81b, 0x66282193, 0x61d809cc, 0xfb21a991, 0x487cac60, 0x5dec8032, 0xef845d5d, 0xe98575b1, 0xdc262302, 0xeb651b88, 0x23893e81, 0xd396acc5, 0x0f6d6ff3, 0x83f44239, 0x2e0b4482, 0xa4842004, 0x69c8f04a, 0x9e1f9b5e, 0x21c66842, 0xf6e96c9a, 0x670c9c61, 0xabd388f0, 0x6a51a0d2, 0xd8542f68, 0x960fa728, 0xab5133a3, 0x6eef0b6c, 0x137a3be4, 0xba3bf050, 0x7efb2a98, 0xa1f1651d, 0x39af0176, 0x66ca593e, 0x82430e88, 0x8cee8619, 0x456f9fb4, 0x7d84a5c3, 0x3b8b5ebe, 0xe06f75d8, 0x85c12073, 0x401a449f, 0x56c16aa6, 0x4ed3aa62, 0x363f7706, 0x1bfedf72, 0x429b023d, 0x37d0d724, 0xd00a1248, 0xdb0fead3, 0x49f1c09b, 0x075372c9, 0x80991b7b, 0x25d479d8, 0xf6e8def7, 0xe3fe501a, 0xb6794c3b, 0x976ce0bd, 0x04c006ba, 0xc1a94fb6, 0x409f60c4, 0x5e5c9ec2, 0x196a2463, 0x68fb6faf, 0x3e6c53b5, 0x1339b2eb, 0x3b52ec6f, 0x6dfc511f, 0x9b30952c, 0xcc814544, 0xaf5ebd09, 0xbee3d004, 0xde334afd, 0x660f2807, 0x192e4bb3, 0xc0cba857, 0x45c8740f, 0xd20b5f39, 0xb9d3fbdb, 0x5579c0bd, 0x1a60320a, 0xd6a100c6, 0x402c7279, 0x679f25fe, 0xfb1fa3cc, 0x8ea5e9f8, 0xdb3222f8, 0x3c7516df, 0xfd616b15, 0x2f501ec8, 0xad0552ab, 0x323db5fa, 0xfd238760, 0x53317b48, 0x3e00df82, 0x9e5c57bb, 0xca6f8ca0, 0x1a87562e, 0xdf1769db, 0xd542a8f6, 0x287effc3, 0xac6732c6, 0x8c4f5573, 0x695b27b0, 0xbbca58c8, 0xe1ffa35d, 0xb8f011a0, 0x10fa3d98, 0xfd2183b8, 0x4afcb56c, 0x2dd1d35b, 0x9a53e479, 0xb6f84565, 0xd28e49bc, 0x4bfb9790, 0xe1ddf2da, 0xa4cb7e33, 0x62fb1341, 0xcee4c6e8, 0xef20cada, 0x36774c01, 0xd07e9efe, 0x2bf11fb4, 0x95dbda4d, 0xae909198, 0xeaad8e71, 0x6b93d5a0, 0xd08ed1d0, 0xafc725e0, 0x8e3c5b2f, 0x8e7594b7, 0x8ff6e2fb, 0xf2122b64, 0x8888b812, 0x900df01c, 0x4fad5ea0, 0x688fc31c, 0xd1cff191, 0xb3a8c1ad, 0x2f2f2218, 0xbe0e1777, 0xea752dfe, 0x8b021fa1, 0xe5a0cc0f, 0xb56f74e8, 0x18acf3d6, 0xce89e299, 0xb4a84fe0, 0xfd13e0b7, 0x7cc43b81, 0xd2ada8d9, 0x165fa266, 0x80957705, 0x93cc7314, 0x211a1477, 0xe6ad2065, 0x77b5fa86, 0xc75442f5, 0xfb9d35cf, 0xebcdaf0c, 0x7b3e89a0, 0xd6411bd3, 0xae1e7e49, 0x00250e2d, 0x2071b35e, 0x226800bb, 0x57b8e0af, 0x2464369b, 0xf009b91e, 0x5563911d, 0x59dfa6aa, 0x78c14389, 0xd95a537f, 0x207d5ba2, 0x02e5b9c5, 0x83260376, 0x6295cfa9, 0x11c81968, 0x4e734a41, 0xb3472dca, 0x7b14a94a, 0x1b510052, 0x9a532915, 0xd60f573f, 0xbc9bc6e4, 0x2b60a476, 0x81e67400, 0x08ba6fb5, 0x571be91f, 0xf296ec6b, 0x2a0dd915, 0xb6636521, 0xe7b9f9b6, 0xff34052e, 0xc5855664, 0x53b02d5d, 0xa99f8fa1, 0x08ba4799, 0x6e85076a }, { 0x4b7a70e9, 0xb5b32944, 0xdb75092e, 0xc4192623, 0xad6ea6b0, 0x49a7df7d, 0x9cee60b8, 0x8fedb266, 0xecaa8c71, 0x699a17ff, 0x5664526c, 0xc2b19ee1, 0x193602a5, 0x75094c29, 0xa0591340, 0xe4183a3e, 0x3f54989a, 0x5b429d65, 0x6b8fe4d6, 0x99f73fd6, 0xa1d29c07, 0xefe830f5, 0x4d2d38e6, 0xf0255dc1, 0x4cdd2086, 0x8470eb26, 0x6382e9c6, 0x021ecc5e, 0x09686b3f, 0x3ebaefc9, 0x3c971814, 0x6b6a70a1, 0x687f3584, 0x52a0e286, 0xb79c5305, 0xaa500737, 0x3e07841c, 0x7fdeae5c, 0x8e7d44ec, 0x5716f2b8, 0xb03ada37, 0xf0500c0d, 0xf01c1f04, 0x0200b3ff, 0xae0cf51a, 0x3cb574b2, 0x25837a58, 0xdc0921bd, 0xd19113f9, 0x7ca92ff6, 0x94324773, 0x22f54701, 0x3ae5e581, 0x37c2dadc, 0xc8b57634, 0x9af3dda7, 0xa9446146, 0x0fd0030e, 0xecc8c73e, 0xa4751e41, 0xe238cd99, 0x3bea0e2f, 0x3280bba1, 0x183eb331, 0x4e548b38, 0x4f6db908, 0x6f420d03, 0xf60a04bf, 0x2cb81290, 0x24977c79, 0x5679b072, 0xbcaf89af, 0xde9a771f, 0xd9930810, 0xb38bae12, 0xdccf3f2e, 0x5512721f, 0x2e6b7124, 0x501adde6, 0x9f84cd87, 0x7a584718, 0x7408da17, 0xbc9f9abc, 0xe94b7d8c, 0xec7aec3a, 0xdb851dfa, 0x63094366, 0xc464c3d2, 0xef1c1847, 0x3215d908, 0xdd433b37, 0x24c2ba16, 0x12a14d43, 0x2a65c451, 0x50940002, 0x133ae4dd, 0x71dff89e, 0x10314e55, 0x81ac77d6, 0x5f11199b, 0x043556f1, 0xd7a3c76b, 0x3c11183b, 0x5924a509, 0xf28fe6ed, 0x97f1fbfa, 0x9ebabf2c, 0x1e153c6e, 0x86e34570, 0xeae96fb1, 0x860e5e0a, 0x5a3e2ab3, 0x771fe71c, 0x4e3d06fa, 0x2965dcb9, 0x99e71d0f, 0x803e89d6, 0x5266c825, 0x2e4cc978, 0x9c10b36a, 0xc6150eba, 0x94e2ea78, 0xa5fc3c53, 0x1e0a2df4, 0xf2f74ea7, 0x361d2b3d, 0x1939260f, 0x19c27960, 0x5223a708, 0xf71312b6, 0xebadfe6e, 0xeac31f66, 0xe3bc4595, 0xa67bc883, 0xb17f37d1, 0x018cff28, 0xc332ddef, 0xbe6c5aa5, 0x65582185, 0x68ab9802, 0xeecea50f, 0xdb2f953b, 0x2aef7dad, 0x5b6e2f84, 0x1521b628, 0x29076170, 0xecdd4775, 0x619f1510, 0x13cca830, 0xeb61bd96, 0x0334fe1e, 0xaa0363cf, 0xb5735c90, 0x4c70a239, 0xd59e9e0b, 0xcbaade14, 0xeecc86bc, 0x60622ca7, 0x9cab5cab, 0xb2f3846e, 0x648b1eaf, 0x19bdf0ca, 0xa02369b9, 0x655abb50, 0x40685a32, 0x3c2ab4b3, 0x319ee9d5, 0xc021b8f7, 0x9b540b19, 0x875fa099, 0x95f7997e, 0x623d7da8, 0xf837889a, 0x97e32d77, 0x11ed935f, 0x16681281, 0x0e358829, 0xc7e61fd6, 0x96dedfa1, 0x7858ba99, 0x57f584a5, 0x1b227263, 0x9b83c3ff, 0x1ac24696, 0xcdb30aeb, 0x532e3054, 0x8fd948e4, 0x6dbc3128, 0x58ebf2ef, 0x34c6ffea, 0xfe28ed61, 0xee7c3c73, 0x5d4a14d9, 0xe864b7e3, 0x42105d14, 0x203e13e0, 0x45eee2b6, 0xa3aaabea, 0xdb6c4f15, 0xfacb4fd0, 0xc742f442, 0xef6abbb5, 0x654f3b1d, 0x41cd2105, 0xd81e799e, 0x86854dc7, 0xe44b476a, 0x3d816250, 0xcf62a1f2, 0x5b8d2646, 0xfc8883a0, 0xc1c7b6a3, 0x7f1524c3, 0x69cb7492, 0x47848a0b, 0x5692b285, 0x095bbf00, 0xad19489d, 0x1462b174, 0x23820e00, 0x58428d2a, 0x0c55f5ea, 0x1dadf43e, 0x233f7061, 0x3372f092, 0x8d937e41, 0xd65fecf1, 0x6c223bdb, 0x7cde3759, 0xcbee7460, 0x4085f2a7, 0xce77326e, 0xa6078084, 0x19f8509e, 0xe8efd855, 0x61d99735, 0xa969a7aa, 0xc50c06c2, 0x5a04abfc, 0x800bcadc, 0x9e447a2e, 0xc3453484, 0xfdd56705, 0x0e1e9ec9, 0xdb73dbd3, 0x105588cd, 0x675fda79, 0xe3674340, 0xc5c43465, 0x713e38d8, 0x3d28f89e, 0xf16dff20, 0x153e21e7, 0x8fb03d4a, 0xe6e39f2b, 0xdb83adf7 }, { 0xe93d5a68, 0x948140f7, 0xf64c261c, 0x94692934, 0x411520f7, 0x7602d4f7, 0xbcf46b2e, 0xd4a20068, 0xd4082471, 0x3320f46a, 0x43b7d4b7, 0x500061af, 0x1e39f62e, 0x97244546, 0x14214f74, 0xbf8b8840, 0x4d95fc1d, 0x96b591af, 0x70f4ddd3, 0x66a02f45, 0xbfbc09ec, 0x03bd9785, 0x7fac6dd0, 0x31cb8504, 0x96eb27b3, 0x55fd3941, 0xda2547e6, 0xabca0a9a, 0x28507825, 0x530429f4, 0x0a2c86da, 0xe9b66dfb, 0x68dc1462, 0xd7486900, 0x680ec0a4, 0x27a18dee, 0x4f3ffea2, 0xe887ad8c, 0xb58ce006, 0x7af4d6b6, 0xaace1e7c, 0xd3375fec, 0xce78a399, 0x406b2a42, 0x20fe9e35, 0xd9f385b9, 0xee39d7ab, 0x3b124e8b, 0x1dc9faf7, 0x4b6d1856, 0x26a36631, 0xeae397b2, 0x3a6efa74, 0xdd5b4332, 0x6841e7f7, 0xca7820fb, 0xfb0af54e, 0xd8feb397, 0x454056ac, 0xba489527, 0x55533a3a, 0x20838d87, 0xfe6ba9b7, 0xd096954b, 0x55a867bc, 0xa1159a58, 0xcca92963, 0x99e1db33, 0xa62a4a56, 0x3f3125f9, 0x5ef47e1c, 0x9029317c, 0xfdf8e802, 0x04272f70, 0x80bb155c, 0x05282ce3, 0x95c11548, 0xe4c66d22, 0x48c1133f, 0xc70f86dc, 0x07f9c9ee, 0x41041f0f, 0x404779a4, 0x5d886e17, 0x325f51eb, 0xd59bc0d1, 0xf2bcc18f, 0x41113564, 0x257b7834, 0x602a9c60, 0xdff8e8a3, 0x1f636c1b, 0x0e12b4c2, 0x02e1329e, 0xaf664fd1, 0xcad18115, 0x6b2395e0, 0x333e92e1, 0x3b240b62, 0xeebeb922, 0x85b2a20e, 0xe6ba0d99, 0xde720c8c, 0x2da2f728, 0xd0127845, 0x95b794fd, 0x647d0862, 0xe7ccf5f0, 0x5449a36f, 0x877d48fa, 0xc39dfd27, 0xf33e8d1e, 0x0a476341, 0x992eff74, 0x3a6f6eab, 0xf4f8fd37, 0xa812dc60, 0xa1ebddf8, 0x991be14c, 0xdb6e6b0d, 0xc67b5510, 0x6d672c37, 0x2765d43b, 0xdcd0e804, 0xf1290dc7, 0xcc00ffa3, 0xb5390f92, 0x690fed0b, 0x667b9ffb, 0xcedb7d9c, 0xa091cf0b, 0xd9155ea3, 0xbb132f88, 0x515bad24, 0x7b9479bf, 0x763bd6eb, 0x37392eb3, 0xcc115979, 0x8026e297, 0xf42e312d, 0x6842ada7, 0xc66a2b3b, 0x12754ccc, 0x782ef11c, 0x6a124237, 0xb79251e7, 0x06a1bbe6, 0x4bfb6350, 0x1a6b1018, 0x11caedfa, 0x3d25bdd8, 0xe2e1c3c9, 0x44421659, 0x0a121386, 0xd90cec6e, 0xd5abea2a, 0x64af674e, 0xda86a85f, 0xbebfe988, 0x64e4c3fe, 0x9dbc8057, 0xf0f7c086, 0x60787bf8, 0x6003604d, 0xd1fd8346, 0xf6381fb0, 0x7745ae04, 0xd736fccc, 0x83426b33, 0xf01eab71, 0xb0804187, 0x3c005e5f, 0x77a057be, 0xbde8ae24, 0x55464299, 0xbf582e61, 0x4e58f48f, 0xf2ddfda2, 0xf474ef38, 0x8789bdc2, 0x5366f9c3, 0xc8b38e74, 0xb475f255, 0x46fcd9b9, 0x7aeb2661, 0x8b1ddf84, 0x846a0e79, 0x915f95e2, 0x466e598e, 0x20b45770, 0x8cd55591, 0xc902de4c, 0xb90bace1, 0xbb8205d0, 0x11a86248, 0x7574a99e, 0xb77f19b6, 0xe0a9dc09, 0x662d09a1, 0xc4324633, 0xe85a1f02, 0x09f0be8c, 0x4a99a025, 0x1d6efe10, 0x1ab93d1d, 0x0ba5a4df, 0xa186f20f, 0x2868f169, 0xdcb7da83, 0x573906fe, 0xa1e2ce9b, 0x4fcd7f52, 0x50115e01, 0xa70683fa, 0xa002b5c4, 0x0de6d027, 0x9af88c27, 0x773f8641, 0xc3604c06, 0x61a806b5, 0xf0177a28, 0xc0f586e0, 0x006058aa, 0x30dc7d62, 0x11e69ed7, 0x2338ea63, 0x53c2dd94, 0xc2c21634, 0xbbcbee56, 0x90bcb6de, 0xebfc7da1, 0xce591d76, 0x6f05e409, 0x4b7c0188, 0x39720a3d, 0x7c927c24, 0x86e3725f, 0x724d9db9, 0x1ac15bb4, 0xd39eb8fc, 0xed545578, 0x08fca5b5, 0xd83d7cd3, 0x4dad0fc4, 0x1e50ef5e, 0xb161e6f8, 0xa28514d9, 0x6c51133c, 0x6fd5c7e7, 0x56e14ec4, 0x362abfce, 0xddc6c837, 0xd79a3234, 0x92638212, 0x670efa8e, 0x406000e0 }, { 0x3a39ce37, 0xd3faf5cf, 0xabc27737, 0x5ac52d1b, 0x5cb0679e, 0x4fa33742, 0xd3822740, 0x99bc9bbe, 0xd5118e9d, 0xbf0f7315, 0xd62d1c7e, 0xc700c47b, 0xb78c1b6b, 0x21a19045, 0xb26eb1be, 0x6a366eb4, 0x5748ab2f, 0xbc946e79, 0xc6a376d2, 0x6549c2c8, 0x530ff8ee, 0x468dde7d, 0xd5730a1d, 0x4cd04dc6, 0x2939bbdb, 0xa9ba4650, 0xac9526e8, 0xbe5ee304, 0xa1fad5f0, 0x6a2d519a, 0x63ef8ce2, 0x9a86ee22, 0xc089c2b8, 0x43242ef6, 0xa51e03aa, 0x9cf2d0a4, 0x83c061ba, 0x9be96a4d, 0x8fe51550, 0xba645bd6, 0x2826a2f9, 0xa73a3ae1, 0x4ba99586, 0xef5562e9, 0xc72fefd3, 0xf752f7da, 0x3f046f69, 0x77fa0a59, 0x80e4a915, 0x87b08601, 0x9b09e6ad, 0x3b3ee593, 0xe990fd5a, 0x9e34d797, 0x2cf0b7d9, 0x022b8b51, 0x96d5ac3a, 0x017da67d, 0xd1cf3ed6, 0x7c7d2d28, 0x1f9f25cf, 0xadf2b89b, 0x5ad6b472, 0x5a88f54c, 0xe029ac71, 0xe019a5e6, 0x47b0acfd, 0xed93fa9b, 0xe8d3c48d, 0x283b57cc, 0xf8d56629, 0x79132e28, 0x785f0191, 0xed756055, 0xf7960e44, 0xe3d35e8c, 0x15056dd4, 0x88f46dba, 0x03a16125, 0x0564f0bd, 0xc3eb9e15, 0x3c9057a2, 0x97271aec, 0xa93a072a, 0x1b3f6d9b, 0x1e6321f5, 0xf59c66fb, 0x26dcf319, 0x7533d928, 0xb155fdf5, 0x03563482, 0x8aba3cbb, 0x28517711, 0xc20ad9f8, 0xabcc5167, 0xccad925f, 0x4de81751, 0x3830dc8e, 0x379d5862, 0x9320f991, 0xea7a90c2, 0xfb3e7bce, 0x5121ce64, 0x774fbe32, 0xa8b6e37e, 0xc3293d46, 0x48de5369, 0x6413e680, 0xa2ae0810, 0xdd6db224, 0x69852dfd, 0x09072166, 0xb39a460a, 0x6445c0dd, 0x586cdecf, 0x1c20c8ae, 0x5bbef7dd, 0x1b588d40, 0xccd2017f, 0x6bb4e3bb, 0xdda26a7e, 0x3a59ff45, 0x3e350a44, 0xbcb4cdd5, 0x72eacea8, 0xfa6484bb, 0x8d6612ae, 0xbf3c6f47, 0xd29be463, 0x542f5d9e, 0xaec2771b, 0xf64e6370, 0x740e0d8d, 0xe75b1357, 0xf8721671, 0xaf537d5d, 0x4040cb08, 0x4eb4e2cc, 0x34d2466a, 0x0115af84, 0xe1b00428, 0x95983a1d, 0x06b89fb4, 0xce6ea048, 0x6f3f3b82, 0x3520ab82, 0x011a1d4b, 0x277227f8, 0x611560b1, 0xe7933fdc, 0xbb3a792b, 0x344525bd, 0xa08839e1, 0x51ce794b, 0x2f32c9b7, 0xa01fbac9, 0xe01cc87e, 0xbcc7d1f6, 0xcf0111c3, 0xa1e8aac7, 0x1a908749, 0xd44fbd9a, 0xd0dadecb, 0xd50ada38, 0x0339c32a, 0xc6913667, 0x8df9317c, 0xe0b12b4f, 0xf79e59b7, 0x43f5bb3a, 0xf2d519ff, 0x27d9459c, 0xbf97222c, 0x15e6fc2a, 0x0f91fc71, 0x9b941525, 0xfae59361, 0xceb69ceb, 0xc2a86459, 0x12baa8d1, 0xb6c1075e, 0xe3056a0c, 0x10d25065, 0xcb03a442, 0xe0ec6e0e, 0x1698db3b, 0x4c98a0be, 0x3278e964, 0x9f1f9532, 0xe0d392df, 0xd3a0342b, 0x8971f21e, 0x1b0a7441, 0x4ba3348c, 0xc5be7120, 0xc37632d8, 0xdf359f8d, 0x9b992f2e, 0xe60b6f47, 0x0fe3f11d, 0xe54cda54, 0x1edad891, 0xce6279cf, 0xcd3e7e6f, 0x1618b166, 0xfd2c1d05, 0x848fd2c5, 0xf6fb2299, 0xf523f357, 0xa6327623, 0x93a83531, 0x56cccd02, 0xacf08162, 0x5a75ebb5, 0x6e163697, 0x88d273cc, 0xde966292, 0x81b949d0, 0x4c50901b, 0x71c65614, 0xe6c6c7bd, 0x327a140a, 0x45e1d006, 0xc3f27b9a, 0xc9aa53fd, 0x62a80f00, 0xbb25bfe2, 0x35bdd2f6, 0x71126905, 0xb2040222, 0xb6cbcf7c, 0xcd769c2b, 0x53113ec0, 0x1640e3d3, 0x38abbd60, 0x2547adf0, 0xba38209c, 0xf746ce76, 0x77afa1c5, 0x20756060, 0x85cbfe4e, 0x8ae88dd8, 0x7aaaf9b0, 0x4cf9aa7e, 0x1948c25c, 0x02fb8a8c, 0x01c36ae4, 0xd6ebe1f9, 0x90d4f869, 0xa65cdea0, 0x3f09252d, 0xc208e69f, 0xb74e6132, 0xce77e25b, 0x578fdfe3, 0x3ac372e6 } }, { 0x243f6a88, 0x85a308d3, 0x13198a2e, 0x03707344, 0xa4093822, 0x299f31d0, 0x082efa98, 0xec4e6c89, 0x452821e6, 0x38d01377, 0xbe5466cf, 0x34e90c6c, 0xc0ac29b7, 0xc97c50dd, 0x3f84d5b5, 0xb5470917, 0x9216d5d9, 0x8979fb1b } }; static unsigned char BF_itoa64[64 + 1] = "./ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789"; static unsigned char BF_atoi64[0x60] = { 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 0, 1, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 64, 64, 64, 64, 64, 64, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 64, 64, 64, 64, 64, 64, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 64, 64, 64, 64, 64 }; #define BF_safe_atoi64(dst, src) \ { \ tmp = (unsigned char)(src); \ if ((unsigned int)(tmp -= 0x20) >= 0x60) return -1; \ tmp = BF_atoi64[tmp]; \ if (tmp > 63) return -1; \ (dst) = tmp; \ } static int BF_decode(BF_word *dst, const char *src, int size) { unsigned char *dptr = (unsigned char *)dst; unsigned char *end = dptr + size; const unsigned char *sptr = (const unsigned char *)src; unsigned int tmp, c1, c2, c3, c4; do { BF_safe_atoi64(c1, *sptr++); BF_safe_atoi64(c2, *sptr++); *dptr++ = (c1 << 2) | ((c2 & 0x30) >> 4); if (dptr >= end) break; BF_safe_atoi64(c3, *sptr++); *dptr++ = ((c2 & 0x0F) << 4) | ((c3 & 0x3C) >> 2); if (dptr >= end) break; BF_safe_atoi64(c4, *sptr++); *dptr++ = ((c3 & 0x03) << 6) | c4; } while (dptr < end); return 0; } static void BF_encode(char *dst, const BF_word *src, int size) { const unsigned char *sptr = (const unsigned char *)src; const unsigned char *end = sptr + size; unsigned char *dptr = (unsigned char *)dst; unsigned int c1, c2; do { c1 = *sptr++; *dptr++ = BF_itoa64[c1 >> 2]; c1 = (c1 & 0x03) << 4; if (sptr >= end) { *dptr++ = BF_itoa64[c1]; break; } c2 = *sptr++; c1 |= c2 >> 4; *dptr++ = BF_itoa64[c1]; c1 = (c2 & 0x0f) << 2; if (sptr >= end) { *dptr++ = BF_itoa64[c1]; break; } c2 = *sptr++; c1 |= c2 >> 6; *dptr++ = BF_itoa64[c1]; *dptr++ = BF_itoa64[c2 & 0x3f]; } while (sptr < end); } static void BF_swap(BF_word *x, int count) { static int endianness_check = 1; char *is_little_endian = (char *)&endianness_check; BF_word tmp; if (*is_little_endian) do { tmp = *x; tmp = (tmp << 16) | (tmp >> 16); *x++ = ((tmp & 0x00FF00FF) << 8) | ((tmp >> 8) & 0x00FF00FF); } while (--count); } #if BF_SCALE /* Architectures which can shift addresses left by 2 bits with no extra cost */ #define BF_ROUND(L, R, N) \ tmp1 = L & 0xFF; \ tmp2 = L >> 8; \ tmp2 &= 0xFF; \ tmp3 = L >> 16; \ tmp3 &= 0xFF; \ tmp4 = L >> 24; \ tmp1 = data.ctx.S[3][tmp1]; \ tmp2 = data.ctx.S[2][tmp2]; \ tmp3 = data.ctx.S[1][tmp3]; \ tmp3 += data.ctx.S[0][tmp4]; \ tmp3 ^= tmp2; \ R ^= data.ctx.P[N + 1]; \ tmp3 += tmp1; \ R ^= tmp3; #else /* Architectures with no complicated addressing modes supported */ #define BF_INDEX(S, i) \ (*((BF_word *)(((unsigned char *)S) + (i)))) #define BF_ROUND(L, R, N) \ tmp1 = L & 0xFF; \ tmp1 <<= 2; \ tmp2 = L >> 6; \ tmp2 &= 0x3FC; \ tmp3 = L >> 14; \ tmp3 &= 0x3FC; \ tmp4 = L >> 22; \ tmp4 &= 0x3FC; \ tmp1 = BF_INDEX(data.ctx.S[3], tmp1); \ tmp2 = BF_INDEX(data.ctx.S[2], tmp2); \ tmp3 = BF_INDEX(data.ctx.S[1], tmp3); \ tmp3 += BF_INDEX(data.ctx.S[0], tmp4); \ tmp3 ^= tmp2; \ R ^= data.ctx.P[N + 1]; \ tmp3 += tmp1; \ R ^= tmp3; #endif /* * Encrypt one block, BF_N is hardcoded here. */ #define BF_ENCRYPT \ L ^= data.ctx.P[0]; \ BF_ROUND(L, R, 0); \ BF_ROUND(R, L, 1); \ BF_ROUND(L, R, 2); \ BF_ROUND(R, L, 3); \ BF_ROUND(L, R, 4); \ BF_ROUND(R, L, 5); \ BF_ROUND(L, R, 6); \ BF_ROUND(R, L, 7); \ BF_ROUND(L, R, 8); \ BF_ROUND(R, L, 9); \ BF_ROUND(L, R, 10); \ BF_ROUND(R, L, 11); \ BF_ROUND(L, R, 12); \ BF_ROUND(R, L, 13); \ BF_ROUND(L, R, 14); \ BF_ROUND(R, L, 15); \ tmp4 = R; \ R = L; \ L = tmp4 ^ data.ctx.P[BF_N + 1]; #if BF_ASM #define BF_body() \ _BF_body_r(&data.ctx); #else #define BF_body() \ L = R = 0; \ ptr = data.ctx.P; \ do { \ ptr += 2; \ BF_ENCRYPT; \ *(ptr - 2) = L; \ *(ptr - 1) = R; \ } while (ptr < &data.ctx.P[BF_N + 2]); \ \ ptr = data.ctx.S[0]; \ do { \ ptr += 2; \ BF_ENCRYPT; \ *(ptr - 2) = L; \ *(ptr - 1) = R; \ } while (ptr < &data.ctx.S[3][0xFF]); #endif static void BF_set_key(const char *key, BF_key expanded, BF_key initial, unsigned char flags) { const char *ptr = key; unsigned int bug, i, j; BF_word safety, sign, diff, tmp[2]; /* * There was a sign extension bug in older revisions of this function. While * we would have liked to simply fix the bug and move on, we have to provide * a backwards compatibility feature (essentially the bug) for some systems and * a safety measure for some others. The latter is needed because for certain * multiple inputs to the buggy algorithm there exist easily found inputs to * the correct algorithm that produce the same hash. Thus, we optionally * deviate from the correct algorithm just enough to avoid such collisions. * While the bug itself affected the majority of passwords containing * characters with the 8th bit set (although only a percentage of those in a * collision-producing way), the anti-collision safety measure affects * only a subset of passwords containing the '\xff' character (not even all of * those passwords, just some of them). This character is not found in valid * UTF-8 sequences and is rarely used in popular 8-bit character encodings. * Thus, the safety measure is unlikely to cause much annoyance, and is a * reasonable tradeoff to use when authenticating against existing hashes that * are not reliably known to have been computed with the correct algorithm. * * We use an approach that tries to minimize side-channel leaks of password * information - that is, we mostly use fixed-cost bitwise operations instead * of branches or table lookups. (One conditional branch based on password * length remains. It is not part of the bug aftermath, though, and is * difficult and possibly unreasonable to avoid given the use of C strings by * the caller, which results in similar timing leaks anyway.) * * For actual implementation, we set an array index in the variable "bug" * (0 means no bug, 1 means sign extension bug emulation) and a flag in the * variable "safety" (bit 16 is set when the safety measure is requested). * Valid combinations of settings are: * * Prefix "$2a$": bug = 0, safety = 0x10000 * Prefix "$2b$": bug = 0, safety = 0 * Prefix "$2x$": bug = 1, safety = 0 * Prefix "$2y$": bug = 0, safety = 0 */ bug = (unsigned int)flags & 1; safety = ((BF_word)flags & 2) << 15; sign = diff = 0; for (i = 0; i < BF_N + 2; i++) { tmp[0] = tmp[1] = 0; for (j = 0; j < 4; j++) { tmp[0] <<= 8; tmp[0] |= (unsigned char)*ptr; /* correct */ tmp[1] <<= 8; tmp[1] |= (BF_word_signed)(signed char)*ptr; /* bug */ /* * Sign extension in the first char has no effect - nothing to overwrite yet, * and those extra 24 bits will be fully shifted out of the 32-bit word. For * chars 2, 3, 4 in each four-char block, we set bit 7 of "sign" if sign * extension in tmp[1] occurs. Once this flag is set, it remains set. */ if (j) sign |= tmp[1] & 0x80; if (!*ptr) ptr = key; else ptr++; } diff |= tmp[0] ^ tmp[1]; /* Non-zero on any differences */ expanded[i] = tmp[bug]; initial[i] = BF_init_state.P[i] ^ tmp[bug]; } /* * At this point, "diff" is zero iff the correct and buggy algorithms produced * exactly the same result. If so and if "sign" is non-zero, which indicates * that there was a non-benign sign extension, this means that we have a * collision between the correctly computed hash for this password and a set of * passwords that could be supplied to the buggy algorithm. Our safety measure * is meant to protect from such many-buggy to one-correct collisions, by * deviating from the correct algorithm in such cases. Let's check for this. */ diff |= diff >> 16; /* still zero iff exact match */ diff &= 0xffff; /* ditto */ diff += 0xffff; /* bit 16 set iff "diff" was non-zero (on non-match) */ sign <<= 9; /* move the non-benign sign extension flag to bit 16 */ sign &= ~diff & safety; /* action needed? */ /* * If we have determined that we need to deviate from the correct algorithm, * flip bit 16 in initial expanded key. (The choice of 16 is arbitrary, but * let's stick to it now. It came out of the approach we used above, and it's * not any worse than any other choice we could make.) * * It is crucial that we don't do the same to the expanded key used in the main * Eksblowfish loop. By doing it to only one of these two, we deviate from a * state that could be directly specified by a password to the buggy algorithm * (and to the fully correct one as well, but that's a side-effect). */ initial[0] ^= sign; } static const unsigned char flags_by_subtype[26] = {2, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 4, 0}; static char *BF_crypt(const char *key, const char *setting, char *output, int size, BF_word min) { #if BF_ASM extern void _BF_body_r(BF_ctx *ctx); #endif struct { BF_ctx ctx; BF_key expanded_key; union { BF_word salt[4]; BF_word output[6]; } binary; } data; BF_word L, R; BF_word tmp1, tmp2, tmp3, tmp4; BF_word *ptr; BF_word count; int i; if (size < 7 + 22 + 31 + 1) { __set_errno(ERANGE); return NULL; } if (setting[0] != '$' || setting[1] != '2' || setting[2] < 'a' || setting[2] > 'z' || !flags_by_subtype[(unsigned int)(unsigned char)setting[2] - 'a'] || setting[3] != '$' || setting[4] < '0' || setting[4] > '3' || setting[5] < '0' || setting[5] > '9' || (setting[4] == '3' && setting[5] > '1') || setting[6] != '$') { __set_errno(EINVAL); return NULL; } count = (BF_word)1 << ((setting[4] - '0') * 10 + (setting[5] - '0')); if (count < min || BF_decode(data.binary.salt, &setting[7], 16)) { __set_errno(EINVAL); return NULL; } BF_swap(data.binary.salt, 4); BF_set_key(key, data.expanded_key, data.ctx.P, flags_by_subtype[(unsigned int)(unsigned char)setting[2] - 'a']); memcpy(data.ctx.S, BF_init_state.S, sizeof(data.ctx.S)); L = R = 0; for (i = 0; i < BF_N + 2; i += 2) { L ^= data.binary.salt[i & 2]; R ^= data.binary.salt[(i & 2) + 1]; BF_ENCRYPT; data.ctx.P[i] = L; data.ctx.P[i + 1] = R; } ptr = data.ctx.S[0]; do { ptr += 4; L ^= data.binary.salt[(BF_N + 2) & 3]; R ^= data.binary.salt[(BF_N + 3) & 3]; BF_ENCRYPT; *(ptr - 4) = L; *(ptr - 3) = R; L ^= data.binary.salt[(BF_N + 4) & 3]; R ^= data.binary.salt[(BF_N + 5) & 3]; BF_ENCRYPT; *(ptr - 2) = L; *(ptr - 1) = R; } while (ptr < &data.ctx.S[3][0xFF]); do { int done; for (i = 0; i < BF_N + 2; i += 2) { data.ctx.P[i] ^= data.expanded_key[i]; data.ctx.P[i + 1] ^= data.expanded_key[i + 1]; } done = 0; do { BF_body(); if (done) break; done = 1; tmp1 = data.binary.salt[0]; tmp2 = data.binary.salt[1]; tmp3 = data.binary.salt[2]; tmp4 = data.binary.salt[3]; for (i = 0; i < BF_N; i += 4) { data.ctx.P[i] ^= tmp1; data.ctx.P[i + 1] ^= tmp2; data.ctx.P[i + 2] ^= tmp3; data.ctx.P[i + 3] ^= tmp4; } data.ctx.P[16] ^= tmp1; data.ctx.P[17] ^= tmp2; } while (1); } while (--count); for (i = 0; i < 6; i += 2) { L = BF_magic_w[i]; R = BF_magic_w[i + 1]; count = 64; do { BF_ENCRYPT; } while (--count); data.binary.output[i] = L; data.binary.output[i + 1] = R; } memcpy(output, setting, 7 + 22 - 1); output[7 + 22 - 1] = BF_itoa64[(int) BF_atoi64[(int)setting[7 + 22 - 1] - 0x20] & 0x30]; /* This has to be bug-compatible with the original implementation, so * only encode 23 of the 24 bytes. :-) */ BF_swap(data.binary.output, 6); BF_encode(&output[7 + 22], data.binary.output, 23); output[7 + 22 + 31] = '\0'; return output; } int _crypt_output_magic(const char *setting, char *output, int size) { if (size < 3) return -1; output[0] = '*'; output[1] = '0'; output[2] = '\0'; if (setting[0] == '*' && setting[1] == '0') output[1] = '1'; return 0; } /* * Please preserve the runtime self-test. It serves two purposes at once: * * 1. We really can't afford the risk of producing incompatible hashes e.g. * when there's something like gcc bug 26587 again, whereas an application or * library integrating this code might not also integrate our external tests or * it might not run them after every build. Even if it does, the miscompile * might only occur on the production build, but not on a testing build (such * as because of different optimization settings). It is painful to recover * from incorrectly-computed hashes - merely fixing whatever broke is not * enough. Thus, a proactive measure like this self-test is needed. * * 2. We don't want to leave sensitive data from our actual password hash * computation on the stack or in registers. Previous revisions of the code * would do explicit cleanups, but simply running the self-test after hash * computation is more reliable. * * The performance cost of this quick self-test is around 0.6% at the "$2a$08" * setting. */ char *_crypt_blowfish_rn(const char *key, const char *setting, char *output, int size) { const char *test_key = "8b \xd0\xc1\xd2\xcf\xcc\xd8"; const char *test_setting = "$2a$00$abcdefghijklmnopqrstuu"; static const char * const test_hashes[2] = {"i1D709vfamulimlGcq0qq3UvuUasvEa\0\x55", /* 'a', 'b', 'y' */ "VUrPmXD6q/nVSSp7pNDhCR9071IfIRe\0\x55"}; /* 'x' */ const char *test_hash = test_hashes[0]; char *retval; const char *p; int save_errno, ok; struct { char s[7 + 22 + 1]; char o[7 + 22 + 31 + 1 + 1 + 1]; } buf; /* Hash the supplied password */ _crypt_output_magic(setting, output, size); retval = BF_crypt(key, setting, output, size, 16); save_errno = errno; /* * Do a quick self-test. It is important that we make both calls to BF_crypt() * from the same scope such that they likely use the same stack locations, * which makes the second call overwrite the first call's sensitive data on the * stack and makes it more likely that any alignment related issues would be * detected by the self-test. */ memcpy(buf.s, test_setting, sizeof(buf.s)); if (retval) { unsigned int flags = flags_by_subtype[ (unsigned int)(unsigned char)setting[2] - 'a']; test_hash = test_hashes[flags & 1]; buf.s[2] = setting[2]; } memset(buf.o, 0x55, sizeof(buf.o)); buf.o[sizeof(buf.o) - 1] = 0; p = BF_crypt(test_key, buf.s, buf.o, sizeof(buf.o) - (1 + 1), 1); ok = (p == buf.o && !memcmp(p, buf.s, 7 + 22) && !memcmp(p + (7 + 22), test_hash, 31 + 1 + 1 + 1)); { const char *k = "\xff\xa3" "34" "\xff\xff\xff\xa3" "345"; BF_key ae, ai, ye, yi; BF_set_key(k, ae, ai, 2); /* $2a$ */ BF_set_key(k, ye, yi, 4); /* $2y$ */ ai[0] ^= 0x10000; /* undo the safety (for comparison) */ ok = ok && ai[0] == 0xdb9c59bc && ye[17] == 0x33343500 && !memcmp(ae, ye, sizeof(ae)) && !memcmp(ai, yi, sizeof(ai)); } __set_errno(save_errno); if (ok) return retval; /* Should not happen */ _crypt_output_magic(setting, output, size); __set_errno(EINVAL); /* pretend we don't support this hash type */ return NULL; } char *_crypt_gensalt_blowfish_rn(const char *prefix, unsigned long count, const char *input, int size, char *output, int output_size) { if (size < 16 || output_size < 7 + 22 + 1 || (count && (count < 4 || count > 31)) || prefix[0] != '$' || prefix[1] != '2' || (prefix[2] != 'a' && prefix[2] != 'b' && prefix[2] != 'y')) { if (output_size > 0) output[0] = '\0'; __set_errno((output_size < 7 + 22 + 1) ? ERANGE : EINVAL); return NULL; } if (!count) count = 5; output[0] = '$'; output[1] = '2'; output[2] = prefix[2]; output[3] = '$'; output[4] = '0' + count / 10; output[5] = '0' + count % 10; output[6] = '$'; BF_encode(&output[7], (const BF_word *)input, 16); output[7 + 22] = '\0'; return output; } ���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/vendor/bcrypt/crypt_blowfish.h�������������������������������������������������������0000664�0000000�0000000�00000001761�14771603147�0021363�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * Written by Solar Designer <solar at openwall.com> in 2000-2011. * No copyright is claimed, and the software is hereby placed in the public * domain. In case this attempt to disclaim copyright and place the software * in the public domain is deemed null and void, then the software is * Copyright (c) 2000-2011 Solar Designer and it is hereby released to the * general public under the following terms: * * Redistribution and use in source and binary forms, with or without * modification, are permitted. * * There's ABSOLUTELY NO WARRANTY, express or implied. * * See crypt_blowfish.c for more information. */ #ifndef _CRYPT_BLOWFISH_H #define _CRYPT_BLOWFISH_H extern int _crypt_output_magic(const char *setting, char *output, int size); extern char *_crypt_blowfish_rn(const char *key, const char *setting, char *output, int size); extern char *_crypt_gensalt_blowfish_rn(const char *prefix, unsigned long count, const char *input, int size, char *output, int output_size); #endif ���������������inspircd-4.7.0/vendor/fmt/��������������������������������������������������������������������������0000775�0000000�0000000�00000000000�14771603147�0015432�5����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/vendor/fmt/LICENSE.rst���������������������������������������������������������������0000664�0000000�0000000�00000002627�14771603147�0017255�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������Copyright (c) 2012 - present, Victor Zverovich and {fmt} contributors Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. --- Optional exception to the license --- As an exception, if, as a result of your compiling your source code, portions of this Software are embedded into a machine-executable object form of such source code, you may redistribute such embedded portions in such object form without including the above copyright and permission notices. ���������������������������������������������������������������������������������������������������������inspircd-4.7.0/vendor/fmt/args.h��������������������������������������������������������������������0000664�0000000�0000000�00000016014�14771603147�0016541�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������// Formatting library for C++ - dynamic argument lists // // Copyright (c) 2012 - present, Victor Zverovich // All rights reserved. // // For the license information refer to format.h. #ifndef FMT_ARGS_H_ #define FMT_ARGS_H_ #ifndef FMT_MODULE # include <functional> // std::reference_wrapper # include <memory> // std::unique_ptr # include <vector> #endif #include "format.h" // std_string_view FMT_BEGIN_NAMESPACE namespace detail { template <typename T> struct is_reference_wrapper : std::false_type {}; template <typename T> struct is_reference_wrapper<std::reference_wrapper<T>> : std::true_type {}; template <typename T> auto unwrap(const T& v) -> const T& { return v; } template <typename T> auto unwrap(const std::reference_wrapper<T>& v) -> const T& { return static_cast<const T&>(v); } // node is defined outside dynamic_arg_list to workaround a C2504 bug in MSVC // 2022 (v17.10.0). // // Workaround for clang's -Wweak-vtables. Unlike for regular classes, for // templates it doesn't complain about inability to deduce single translation // unit for placing vtable. So node is made a fake template. template <typename = void> struct node { virtual ~node() = default; std::unique_ptr<node<>> next; }; class dynamic_arg_list { template <typename T> struct typed_node : node<> { T value; template <typename Arg> FMT_CONSTEXPR typed_node(const Arg& arg) : value(arg) {} template <typename Char> FMT_CONSTEXPR typed_node(const basic_string_view<Char>& arg) : value(arg.data(), arg.size()) {} }; std::unique_ptr<node<>> head_; public: template <typename T, typename Arg> auto push(const Arg& arg) -> const T& { auto new_node = std::unique_ptr<typed_node<T>>(new typed_node<T>(arg)); auto& value = new_node->value; new_node->next = std::move(head_); head_ = std::move(new_node); return value; } }; } // namespace detail /** * A dynamic list of formatting arguments with storage. * * It can be implicitly converted into `fmt::basic_format_args` for passing * into type-erased formatting functions such as `fmt::vformat`. */ template <typename Context> class dynamic_format_arg_store { private: using char_type = typename Context::char_type; template <typename T> struct need_copy { static constexpr detail::type mapped_type = detail::mapped_type_constant<T, char_type>::value; enum { value = !(detail::is_reference_wrapper<T>::value || std::is_same<T, basic_string_view<char_type>>::value || std::is_same<T, detail::std_string_view<char_type>>::value || (mapped_type != detail::type::cstring_type && mapped_type != detail::type::string_type && mapped_type != detail::type::custom_type)) }; }; template <typename T> using stored_t = conditional_t< std::is_convertible<T, std::basic_string<char_type>>::value && !detail::is_reference_wrapper<T>::value, std::basic_string<char_type>, T>; // Storage of basic_format_arg must be contiguous. std::vector<basic_format_arg<Context>> data_; std::vector<detail::named_arg_info<char_type>> named_info_; // Storage of arguments not fitting into basic_format_arg must grow // without relocation because items in data_ refer to it. detail::dynamic_arg_list dynamic_args_; friend class basic_format_args<Context>; auto data() const -> const basic_format_arg<Context>* { return named_info_.empty() ? data_.data() : data_.data() + 1; } template <typename T> void emplace_arg(const T& arg) { data_.emplace_back(arg); } template <typename T> void emplace_arg(const detail::named_arg<char_type, T>& arg) { if (named_info_.empty()) data_.insert(data_.begin(), basic_format_arg<Context>(nullptr, 0)); data_.emplace_back(detail::unwrap(arg.value)); auto pop_one = [](std::vector<basic_format_arg<Context>>* data) { data->pop_back(); }; std::unique_ptr<std::vector<basic_format_arg<Context>>, decltype(pop_one)> guard{&data_, pop_one}; named_info_.push_back({arg.name, static_cast<int>(data_.size() - 2u)}); data_[0] = {named_info_.data(), named_info_.size()}; guard.release(); } public: constexpr dynamic_format_arg_store() = default; operator basic_format_args<Context>() const { return basic_format_args<Context>(data(), static_cast<int>(data_.size()), !named_info_.empty()); } /** * Adds an argument into the dynamic store for later passing to a formatting * function. * * Note that custom types and string types (but not string views) are copied * into the store dynamically allocating memory if necessary. * * **Example**: * * fmt::dynamic_format_arg_store<fmt::format_context> store; * store.push_back(42); * store.push_back("abc"); * store.push_back(1.5f); * std::string result = fmt::vformat("{} and {} and {}", store); */ template <typename T> void push_back(const T& arg) { if (detail::const_check(need_copy<T>::value)) emplace_arg(dynamic_args_.push<stored_t<T>>(arg)); else emplace_arg(detail::unwrap(arg)); } /** * Adds a reference to the argument into the dynamic store for later passing * to a formatting function. * * **Example**: * * fmt::dynamic_format_arg_store<fmt::format_context> store; * char band[] = "Rolling Stones"; * store.push_back(std::cref(band)); * band[9] = 'c'; // Changing str affects the output. * std::string result = fmt::vformat("{}", store); * // result == "Rolling Scones" */ template <typename T> void push_back(std::reference_wrapper<T> arg) { static_assert( need_copy<T>::value, "objects of built-in types and string views are always copied"); emplace_arg(arg.get()); } /** * Adds named argument into the dynamic store for later passing to a * formatting function. `std::reference_wrapper` is supported to avoid * copying of the argument. The name is always copied into the store. */ template <typename T> void push_back(const detail::named_arg<char_type, T>& arg) { const char_type* arg_name = dynamic_args_.push<std::basic_string<char_type>>(arg.name).c_str(); if (detail::const_check(need_copy<T>::value)) { emplace_arg( fmt::arg(arg_name, dynamic_args_.push<stored_t<T>>(arg.value))); } else { emplace_arg(fmt::arg(arg_name, arg.value)); } } /// Erase all elements from the store. void clear() { data_.clear(); named_info_.clear(); dynamic_args_ = {}; } /// Reserves space to store at least `new_cap` arguments including /// `new_cap_named` named arguments. void reserve(size_t new_cap, size_t new_cap_named) { FMT_ASSERT(new_cap >= new_cap_named, "set of arguments includes set of named arguments"); data_.reserve(new_cap); named_info_.reserve(new_cap_named); } /// Returns the number of elements in the store. size_t size() const noexcept { return data_.size(); } }; FMT_END_NAMESPACE #endif // FMT_ARGS_H_ ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/vendor/fmt/base.h��������������������������������������������������������������������0000664�0000000�0000000�00000310574�14771603147�0016527�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������// Formatting library for C++ - the base API for char/UTF-8 // // Copyright (c) 2012 - present, Victor Zverovich // All rights reserved. // // For the license information refer to format.h. #ifndef FMT_BASE_H_ #define FMT_BASE_H_ #if defined(FMT_IMPORT_STD) && !defined(FMT_MODULE) # define FMT_MODULE #endif #ifndef FMT_MODULE # include <limits.h> // CHAR_BIT # include <stdio.h> // FILE # include <string.h> // memcmp # include <type_traits> // std::enable_if #endif // The fmt library version in the form major * 10000 + minor * 100 + patch. #define FMT_VERSION 110104 // Detect compiler versions. #if defined(__clang__) && !defined(__ibmxl__) # define FMT_CLANG_VERSION (__clang_major__ * 100 + __clang_minor__) #else # define FMT_CLANG_VERSION 0 #endif #if defined(__GNUC__) && !defined(__clang__) && !defined(__INTEL_COMPILER) # define FMT_GCC_VERSION (__GNUC__ * 100 + __GNUC_MINOR__) #else # define FMT_GCC_VERSION 0 #endif #if defined(__ICL) # define FMT_ICC_VERSION __ICL #elif defined(__INTEL_COMPILER) # define FMT_ICC_VERSION __INTEL_COMPILER #else # define FMT_ICC_VERSION 0 #endif #if defined(_MSC_VER) # define FMT_MSC_VERSION _MSC_VER #else # define FMT_MSC_VERSION 0 #endif // Detect standard library versions. #ifdef _GLIBCXX_RELEASE # define FMT_GLIBCXX_RELEASE _GLIBCXX_RELEASE #else # define FMT_GLIBCXX_RELEASE 0 #endif #ifdef _LIBCPP_VERSION # define FMT_LIBCPP_VERSION _LIBCPP_VERSION #else # define FMT_LIBCPP_VERSION 0 #endif #ifdef _MSVC_LANG # define FMT_CPLUSPLUS _MSVC_LANG #else # define FMT_CPLUSPLUS __cplusplus #endif // Detect __has_*. #ifdef __has_feature # define FMT_HAS_FEATURE(x) __has_feature(x) #else # define FMT_HAS_FEATURE(x) 0 #endif #ifdef __has_include # define FMT_HAS_INCLUDE(x) __has_include(x) #else # define FMT_HAS_INCLUDE(x) 0 #endif #ifdef __has_builtin # define FMT_HAS_BUILTIN(x) __has_builtin(x) #else # define FMT_HAS_BUILTIN(x) 0 #endif #ifdef __has_cpp_attribute # define FMT_HAS_CPP_ATTRIBUTE(x) __has_cpp_attribute(x) #else # define FMT_HAS_CPP_ATTRIBUTE(x) 0 #endif #define FMT_HAS_CPP14_ATTRIBUTE(attribute) \ (FMT_CPLUSPLUS >= 201402L && FMT_HAS_CPP_ATTRIBUTE(attribute)) #define FMT_HAS_CPP17_ATTRIBUTE(attribute) \ (FMT_CPLUSPLUS >= 201703L && FMT_HAS_CPP_ATTRIBUTE(attribute)) // Detect C++14 relaxed constexpr. #ifdef FMT_USE_CONSTEXPR // Use the provided definition. #elif FMT_GCC_VERSION >= 702 && FMT_CPLUSPLUS >= 201402L // GCC only allows constexpr member functions in non-literal types since 7.2: // https://gcc.gnu.org/bugzilla/show_bug.cgi?id=66297. # define FMT_USE_CONSTEXPR 1 #elif FMT_ICC_VERSION # define FMT_USE_CONSTEXPR 0 // https://github.com/fmtlib/fmt/issues/1628 #elif FMT_HAS_FEATURE(cxx_relaxed_constexpr) || FMT_MSC_VERSION >= 1912 # define FMT_USE_CONSTEXPR 1 #else # define FMT_USE_CONSTEXPR 0 #endif #if FMT_USE_CONSTEXPR # define FMT_CONSTEXPR constexpr #else # define FMT_CONSTEXPR #endif // Detect consteval, C++20 constexpr extensions and std::is_constant_evaluated. #if !defined(__cpp_lib_is_constant_evaluated) # define FMT_USE_CONSTEVAL 0 #elif FMT_CPLUSPLUS < 201709L # define FMT_USE_CONSTEVAL 0 #elif FMT_GLIBCXX_RELEASE && FMT_GLIBCXX_RELEASE < 10 # define FMT_USE_CONSTEVAL 0 #elif FMT_LIBCPP_VERSION && FMT_LIBCPP_VERSION < 10000 # define FMT_USE_CONSTEVAL 0 #elif defined(__apple_build_version__) && __apple_build_version__ < 14000029L # define FMT_USE_CONSTEVAL 0 // consteval is broken in Apple clang < 14. #elif FMT_MSC_VERSION && FMT_MSC_VERSION < 1929 # define FMT_USE_CONSTEVAL 0 // consteval is broken in MSVC VS2019 < 16.10. #elif defined(__cpp_consteval) # define FMT_USE_CONSTEVAL 1 #elif FMT_GCC_VERSION >= 1002 || FMT_CLANG_VERSION >= 1101 # define FMT_USE_CONSTEVAL 1 #else # define FMT_USE_CONSTEVAL 0 #endif #if FMT_USE_CONSTEVAL # define FMT_CONSTEVAL consteval # define FMT_CONSTEXPR20 constexpr #else # define FMT_CONSTEVAL # define FMT_CONSTEXPR20 #endif // Check if exceptions are disabled. #ifdef FMT_USE_EXCEPTIONS // Use the provided definition. #elif defined(__GNUC__) && !defined(__EXCEPTIONS) # define FMT_USE_EXCEPTIONS 0 #elif defined(__clang__) && !defined(__cpp_exceptions) # define FMT_USE_EXCEPTIONS 0 #elif FMT_MSC_VERSION && !_HAS_EXCEPTIONS # define FMT_USE_EXCEPTIONS 0 #else # define FMT_USE_EXCEPTIONS 1 #endif #if FMT_USE_EXCEPTIONS # define FMT_TRY try # define FMT_CATCH(x) catch (x) #else # define FMT_TRY if (true) # define FMT_CATCH(x) if (false) #endif #ifdef FMT_NO_UNIQUE_ADDRESS // Use the provided definition. #elif FMT_CPLUSPLUS < 202002L // Not supported. #elif FMT_HAS_CPP_ATTRIBUTE(no_unique_address) # define FMT_NO_UNIQUE_ADDRESS [[no_unique_address]] // VS2019 v16.10 and later except clang-cl (https://reviews.llvm.org/D110485). #elif FMT_MSC_VERSION >= 1929 && !FMT_CLANG_VERSION # define FMT_NO_UNIQUE_ADDRESS [[msvc::no_unique_address]] #endif #ifndef FMT_NO_UNIQUE_ADDRESS # define FMT_NO_UNIQUE_ADDRESS #endif #if FMT_HAS_CPP17_ATTRIBUTE(fallthrough) # define FMT_FALLTHROUGH [[fallthrough]] #elif defined(__clang__) # define FMT_FALLTHROUGH [[clang::fallthrough]] #elif FMT_GCC_VERSION >= 700 && \ (!defined(__EDG_VERSION__) || __EDG_VERSION__ >= 520) # define FMT_FALLTHROUGH [[gnu::fallthrough]] #else # define FMT_FALLTHROUGH #endif // Disable [[noreturn]] on MSVC/NVCC because of bogus unreachable code warnings. #if FMT_HAS_CPP_ATTRIBUTE(noreturn) && !FMT_MSC_VERSION && !defined(__NVCC__) # define FMT_NORETURN [[noreturn]] #else # define FMT_NORETURN #endif #ifdef FMT_NODISCARD // Use the provided definition. #elif FMT_HAS_CPP17_ATTRIBUTE(nodiscard) # define FMT_NODISCARD [[nodiscard]] #else # define FMT_NODISCARD #endif #ifdef FMT_DEPRECATED // Use the provided definition. #elif FMT_HAS_CPP14_ATTRIBUTE(deprecated) # define FMT_DEPRECATED [[deprecated]] #else # define FMT_DEPRECATED /* deprecated */ #endif #ifdef FMT_ALWAYS_INLINE // Use the provided definition. #elif FMT_GCC_VERSION || FMT_CLANG_VERSION # define FMT_ALWAYS_INLINE inline __attribute__((always_inline)) #else # define FMT_ALWAYS_INLINE inline #endif // A version of FMT_ALWAYS_INLINE to prevent code bloat in debug mode. #ifdef NDEBUG # define FMT_INLINE FMT_ALWAYS_INLINE #else # define FMT_INLINE inline #endif #if FMT_GCC_VERSION || FMT_CLANG_VERSION # define FMT_VISIBILITY(value) __attribute__((visibility(value))) #else # define FMT_VISIBILITY(value) #endif // Detect pragmas. #define FMT_PRAGMA_IMPL(x) _Pragma(#x) #if FMT_GCC_VERSION >= 504 && !defined(__NVCOMPILER) // Workaround a _Pragma bug https://gcc.gnu.org/bugzilla/show_bug.cgi?id=59884 // and an nvhpc warning: https://github.com/fmtlib/fmt/pull/2582. # define FMT_PRAGMA_GCC(x) FMT_PRAGMA_IMPL(GCC x) #else # define FMT_PRAGMA_GCC(x) #endif #if FMT_CLANG_VERSION # define FMT_PRAGMA_CLANG(x) FMT_PRAGMA_IMPL(clang x) #else # define FMT_PRAGMA_CLANG(x) #endif #if FMT_MSC_VERSION # define FMT_MSC_WARNING(...) __pragma(warning(__VA_ARGS__)) #else # define FMT_MSC_WARNING(...) #endif #ifndef FMT_BEGIN_NAMESPACE # define FMT_BEGIN_NAMESPACE \ namespace fmt { \ inline namespace v11 { # define FMT_END_NAMESPACE \ } \ } #endif #ifndef FMT_EXPORT # define FMT_EXPORT # define FMT_BEGIN_EXPORT # define FMT_END_EXPORT #endif #ifdef _WIN32 # define FMT_WIN32 1 #else # define FMT_WIN32 0 #endif #if !defined(FMT_HEADER_ONLY) && FMT_WIN32 # if defined(FMT_LIB_EXPORT) # define FMT_API __declspec(dllexport) # elif defined(FMT_SHARED) # define FMT_API __declspec(dllimport) # endif #elif defined(FMT_LIB_EXPORT) || defined(FMT_SHARED) # define FMT_API FMT_VISIBILITY("default") #endif #ifndef FMT_API # define FMT_API #endif #ifndef FMT_OPTIMIZE_SIZE # define FMT_OPTIMIZE_SIZE 0 #endif // FMT_BUILTIN_TYPE=0 may result in smaller library size at the cost of higher // per-call binary size by passing built-in types through the extension API. #ifndef FMT_BUILTIN_TYPES # define FMT_BUILTIN_TYPES 1 #endif #define FMT_APPLY_VARIADIC(expr) \ using unused = int[]; \ (void)unused { 0, (expr, 0)... } // Enable minimal optimizations for more compact code in debug mode. FMT_PRAGMA_GCC(push_options) #if !defined(__OPTIMIZE__) && !defined(__CUDACC__) && !defined(FMT_MODULE) FMT_PRAGMA_GCC(optimize("Og")) #endif FMT_PRAGMA_CLANG(diagnostic push) FMT_BEGIN_NAMESPACE // Implementations of enable_if_t and other metafunctions for older systems. template <bool B, typename T = void> using enable_if_t = typename std::enable_if<B, T>::type; template <bool B, typename T, typename F> using conditional_t = typename std::conditional<B, T, F>::type; template <bool B> using bool_constant = std::integral_constant<bool, B>; template <typename T> using remove_reference_t = typename std::remove_reference<T>::type; template <typename T> using remove_const_t = typename std::remove_const<T>::type; template <typename T> using remove_cvref_t = typename std::remove_cv<remove_reference_t<T>>::type; template <typename T> using make_unsigned_t = typename std::make_unsigned<T>::type; template <typename T> using underlying_t = typename std::underlying_type<T>::type; template <typename T> using decay_t = typename std::decay<T>::type; using nullptr_t = decltype(nullptr); #if FMT_GCC_VERSION && FMT_GCC_VERSION < 500 // A workaround for gcc 4.9 to make void_t work in a SFINAE context. template <typename...> struct void_t_impl { using type = void; }; template <typename... T> using void_t = typename void_t_impl<T...>::type; #else template <typename...> using void_t = void; #endif struct monostate { constexpr monostate() {} }; // An enable_if helper to be used in template parameters which results in much // shorter symbols: https://godbolt.org/z/sWw4vP. Extra parentheses are needed // to workaround a bug in MSVC 2019 (see #1140 and #1186). #ifdef FMT_DOC # define FMT_ENABLE_IF(...) #else # define FMT_ENABLE_IF(...) fmt::enable_if_t<(__VA_ARGS__), int> = 0 #endif template <typename T> constexpr auto min_of(T a, T b) -> T { return a < b ? a : b; } template <typename T> constexpr auto max_of(T a, T b) -> T { return a > b ? a : b; } namespace detail { // Suppresses "unused variable" warnings with the method described in // https://herbsutter.com/2009/10/18/mailbag-shutting-up-compiler-warnings/. // (void)var does not work on many Intel compilers. template <typename... T> FMT_CONSTEXPR void ignore_unused(const T&...) {} constexpr auto is_constant_evaluated(bool default_value = false) noexcept -> bool { // Workaround for incompatibility between clang 14 and libstdc++ consteval-based // std::is_constant_evaluated: https://github.com/fmtlib/fmt/issues/3247. #if FMT_CPLUSPLUS >= 202002L && FMT_GLIBCXX_RELEASE >= 12 && \ (FMT_CLANG_VERSION >= 1400 && FMT_CLANG_VERSION < 1500) ignore_unused(default_value); return __builtin_is_constant_evaluated(); #elif defined(__cpp_lib_is_constant_evaluated) ignore_unused(default_value); return std::is_constant_evaluated(); #else return default_value; #endif } // Suppresses "conditional expression is constant" warnings. template <typename T> FMT_ALWAYS_INLINE constexpr auto const_check(T val) -> T { return val; } FMT_NORETURN FMT_API void assert_fail(const char* file, int line, const char* message); #if defined(FMT_ASSERT) // Use the provided definition. #elif defined(NDEBUG) // FMT_ASSERT is not empty to avoid -Wempty-body. # define FMT_ASSERT(condition, message) \ fmt::detail::ignore_unused((condition), (message)) #else # define FMT_ASSERT(condition, message) \ ((condition) /* void() fails with -Winvalid-constexpr on clang 4.0.1 */ \ ? (void)0 \ : fmt::detail::assert_fail(__FILE__, __LINE__, (message))) #endif #ifdef FMT_USE_INT128 // Use the provided definition. #elif defined(__SIZEOF_INT128__) && !defined(__NVCC__) && \ !(FMT_CLANG_VERSION && FMT_MSC_VERSION) # define FMT_USE_INT128 1 using int128_opt = __int128_t; // An optional native 128-bit integer. using uint128_opt = __uint128_t; inline auto map(int128_opt x) -> int128_opt { return x; } inline auto map(uint128_opt x) -> uint128_opt { return x; } #else # define FMT_USE_INT128 0 #endif #if !FMT_USE_INT128 enum class int128_opt {}; enum class uint128_opt {}; // Reduce template instantiations. inline auto map(int128_opt) -> monostate { return {}; } inline auto map(uint128_opt) -> monostate { return {}; } #endif #ifndef FMT_USE_BITINT # define FMT_USE_BITINT (FMT_CLANG_VERSION >= 1500) #endif #if FMT_USE_BITINT FMT_PRAGMA_CLANG(diagnostic ignored "-Wbit-int-extension") template <int N> using bitint = _BitInt(N); template <int N> using ubitint = unsigned _BitInt(N); #else template <int N> struct bitint {}; template <int N> struct ubitint {}; #endif // FMT_USE_BITINT // Casts a nonnegative integer to unsigned. template <typename Int> FMT_CONSTEXPR auto to_unsigned(Int value) -> make_unsigned_t<Int> { FMT_ASSERT(std::is_unsigned<Int>::value || value >= 0, "negative value"); return static_cast<make_unsigned_t<Int>>(value); } template <typename Char> using unsigned_char = conditional_t<sizeof(Char) == 1, unsigned char, unsigned>; // A heuristic to detect std::string and std::[experimental::]string_view. // It is mainly used to avoid dependency on <[experimental/]string_view>. template <typename T, typename Enable = void> struct is_std_string_like : std::false_type {}; template <typename T> struct is_std_string_like<T, void_t<decltype(std::declval<T>().find_first_of( typename T::value_type(), 0))>> : std::is_convertible<decltype(std::declval<T>().data()), const typename T::value_type*> {}; // Check if the literal encoding is UTF-8. enum { is_utf8_enabled = "\u00A7"[1] == '\xA7' }; enum { use_utf8 = !FMT_WIN32 || is_utf8_enabled }; #ifndef FMT_UNICODE # define FMT_UNICODE 1 #endif static_assert(!FMT_UNICODE || use_utf8, "Unicode support requires compiling with /utf-8"); template <typename T> constexpr const char* narrow(const T*) { return nullptr; } constexpr FMT_ALWAYS_INLINE const char* narrow(const char* s) { return s; } template <typename Char> FMT_CONSTEXPR auto compare(const Char* s1, const Char* s2, std::size_t n) -> int { if (!is_constant_evaluated() && sizeof(Char) == 1) return memcmp(s1, s2, n); for (; n != 0; ++s1, ++s2, --n) { if (*s1 < *s2) return -1; if (*s1 > *s2) return 1; } return 0; } namespace adl { using namespace std; template <typename Container> auto invoke_back_inserter() -> decltype(back_inserter(std::declval<Container&>())); } // namespace adl template <typename It, typename Enable = std::true_type> struct is_back_insert_iterator : std::false_type {}; template <typename It> struct is_back_insert_iterator< It, bool_constant<std::is_same< decltype(adl::invoke_back_inserter<typename It::container_type>()), It>::value>> : std::true_type {}; // Extracts a reference to the container from *insert_iterator. template <typename OutputIt> inline FMT_CONSTEXPR20 auto get_container(OutputIt it) -> typename OutputIt::container_type& { struct accessor : OutputIt { FMT_CONSTEXPR20 accessor(OutputIt base) : OutputIt(base) {} using OutputIt::container; }; return *accessor(it).container; } } // namespace detail // Parsing-related public API and forward declarations. FMT_BEGIN_EXPORT /** * An implementation of `std::basic_string_view` for pre-C++17. It provides a * subset of the API. `fmt::basic_string_view` is used for format strings even * if `std::basic_string_view` is available to prevent issues when a library is * compiled with a different `-std` option than the client code (which is not * recommended). */ template <typename Char> class basic_string_view { private: const Char* data_; size_t size_; public: using value_type = Char; using iterator = const Char*; constexpr basic_string_view() noexcept : data_(nullptr), size_(0) {} /// Constructs a string reference object from a C string and a size. constexpr basic_string_view(const Char* s, size_t count) noexcept : data_(s), size_(count) {} constexpr basic_string_view(nullptr_t) = delete; /// Constructs a string reference object from a C string. #if FMT_GCC_VERSION FMT_ALWAYS_INLINE #endif FMT_CONSTEXPR20 basic_string_view(const Char* s) : data_(s) { #if FMT_HAS_BUILTIN(__builtin_strlen) || FMT_GCC_VERSION || FMT_CLANG_VERSION if (std::is_same<Char, char>::value) { size_ = __builtin_strlen(detail::narrow(s)); return; } #endif size_t len = 0; while (*s++) ++len; size_ = len; } /// Constructs a string reference from a `std::basic_string` or a /// `std::basic_string_view` object. template <typename S, FMT_ENABLE_IF(detail::is_std_string_like<S>::value&& std::is_same< typename S::value_type, Char>::value)> FMT_CONSTEXPR basic_string_view(const S& s) noexcept : data_(s.data()), size_(s.size()) {} /// Returns a pointer to the string data. constexpr auto data() const noexcept -> const Char* { return data_; } /// Returns the string size. constexpr auto size() const noexcept -> size_t { return size_; } constexpr auto begin() const noexcept -> iterator { return data_; } constexpr auto end() const noexcept -> iterator { return data_ + size_; } constexpr auto operator[](size_t pos) const noexcept -> const Char& { return data_[pos]; } FMT_CONSTEXPR void remove_prefix(size_t n) noexcept { data_ += n; size_ -= n; } FMT_CONSTEXPR auto starts_with(basic_string_view<Char> sv) const noexcept -> bool { return size_ >= sv.size_ && detail::compare(data_, sv.data_, sv.size_) == 0; } FMT_CONSTEXPR auto starts_with(Char c) const noexcept -> bool { return size_ >= 1 && *data_ == c; } FMT_CONSTEXPR auto starts_with(const Char* s) const -> bool { return starts_with(basic_string_view<Char>(s)); } // Lexicographically compare this string reference to other. FMT_CONSTEXPR auto compare(basic_string_view other) const -> int { int result = detail::compare(data_, other.data_, min_of(size_, other.size_)); if (result != 0) return result; return size_ == other.size_ ? 0 : (size_ < other.size_ ? -1 : 1); } FMT_CONSTEXPR friend auto operator==(basic_string_view lhs, basic_string_view rhs) -> bool { return lhs.compare(rhs) == 0; } friend auto operator!=(basic_string_view lhs, basic_string_view rhs) -> bool { return lhs.compare(rhs) != 0; } friend auto operator<(basic_string_view lhs, basic_string_view rhs) -> bool { return lhs.compare(rhs) < 0; } friend auto operator<=(basic_string_view lhs, basic_string_view rhs) -> bool { return lhs.compare(rhs) <= 0; } friend auto operator>(basic_string_view lhs, basic_string_view rhs) -> bool { return lhs.compare(rhs) > 0; } friend auto operator>=(basic_string_view lhs, basic_string_view rhs) -> bool { return lhs.compare(rhs) >= 0; } }; using string_view = basic_string_view<char>; /// Specifies if `T` is an extended character type. Can be specialized by users. template <typename T> struct is_xchar : std::false_type {}; template <> struct is_xchar<wchar_t> : std::true_type {}; template <> struct is_xchar<char16_t> : std::true_type {}; template <> struct is_xchar<char32_t> : std::true_type {}; #ifdef __cpp_char8_t template <> struct is_xchar<char8_t> : std::true_type {}; #endif // DEPRECATED! Will be replaced with an alias to prevent specializations. template <typename T> struct is_char : is_xchar<T> {}; template <> struct is_char<char> : std::true_type {}; template <typename T> class basic_appender; using appender = basic_appender<char>; // Checks whether T is a container with contiguous storage. template <typename T> struct is_contiguous : std::false_type {}; class context; template <typename OutputIt, typename Char> class generic_context; template <typename Char> class parse_context; // Longer aliases for C++20 compatibility. template <typename Char> using basic_format_parse_context = parse_context<Char>; using format_parse_context = parse_context<char>; template <typename OutputIt, typename Char> using basic_format_context = conditional_t<std::is_same<OutputIt, appender>::value, context, generic_context<OutputIt, Char>>; using format_context = context; template <typename Char> using buffered_context = conditional_t<std::is_same<Char, char>::value, context, generic_context<basic_appender<Char>, Char>>; template <typename Context> class basic_format_arg; template <typename Context> class basic_format_args; // A separate type would result in shorter symbols but break ABI compatibility // between clang and gcc on ARM (#1919). using format_args = basic_format_args<context>; // A formatter for objects of type T. template <typename T, typename Char = char, typename Enable = void> struct formatter { // A deleted default constructor indicates a disabled formatter. formatter() = delete; }; /// Reports a format error at compile time or, via a `format_error` exception, /// at runtime. // This function is intentionally not constexpr to give a compile-time error. FMT_NORETURN FMT_API void report_error(const char* message); enum class presentation_type : unsigned char { // Common specifiers: none = 0, debug = 1, // '?' string = 2, // 's' (string, bool) // Integral, bool and character specifiers: dec = 3, // 'd' hex, // 'x' or 'X' oct, // 'o' bin, // 'b' or 'B' chr, // 'c' // String and pointer specifiers: pointer = 3, // 'p' // Floating-point specifiers: exp = 1, // 'e' or 'E' (1 since there is no FP debug presentation) fixed, // 'f' or 'F' general, // 'g' or 'G' hexfloat // 'a' or 'A' }; enum class align { none, left, right, center, numeric }; enum class sign { none, minus, plus, space }; enum class arg_id_kind { none, index, name }; // Basic format specifiers for built-in and string types. class basic_specs { private: // Data is arranged as follows: // // 0 1 2 3 // 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 // +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ // |type |align| w | p | s |u|#|L| f | unused | // +-----+-----+---+---+---+-+-+-+-----+---------------------------+ // // w - dynamic width info // p - dynamic precision info // s - sign // u - uppercase (e.g. 'X' for 'x') // # - alternate form ('#') // L - localized // f - fill size // // Bitfields are not used because of compiler bugs such as gcc bug 61414. enum : unsigned { type_mask = 0x00007, align_mask = 0x00038, width_mask = 0x000C0, precision_mask = 0x00300, sign_mask = 0x00C00, uppercase_mask = 0x01000, alternate_mask = 0x02000, localized_mask = 0x04000, fill_size_mask = 0x38000, align_shift = 3, width_shift = 6, precision_shift = 8, sign_shift = 10, fill_size_shift = 15, max_fill_size = 4 }; unsigned data_ = 1 << fill_size_shift; static_assert(sizeof(basic_specs::data_) * CHAR_BIT >= 18, ""); // Character (code unit) type is erased to prevent template bloat. char fill_data_[max_fill_size] = {' '}; FMT_CONSTEXPR void set_fill_size(size_t size) { data_ = (data_ & ~fill_size_mask) | (static_cast<unsigned>(size) << fill_size_shift); } public: constexpr auto type() const -> presentation_type { return static_cast<presentation_type>(data_ & type_mask); } FMT_CONSTEXPR void set_type(presentation_type t) { data_ = (data_ & ~type_mask) | static_cast<unsigned>(t); } constexpr auto align() const -> align { return static_cast<fmt::align>((data_ & align_mask) >> align_shift); } FMT_CONSTEXPR void set_align(fmt::align a) { data_ = (data_ & ~align_mask) | (static_cast<unsigned>(a) << align_shift); } constexpr auto dynamic_width() const -> arg_id_kind { return static_cast<arg_id_kind>((data_ & width_mask) >> width_shift); } FMT_CONSTEXPR void set_dynamic_width(arg_id_kind w) { data_ = (data_ & ~width_mask) | (static_cast<unsigned>(w) << width_shift); } FMT_CONSTEXPR auto dynamic_precision() const -> arg_id_kind { return static_cast<arg_id_kind>((data_ & precision_mask) >> precision_shift); } FMT_CONSTEXPR void set_dynamic_precision(arg_id_kind p) { data_ = (data_ & ~precision_mask) | (static_cast<unsigned>(p) << precision_shift); } constexpr bool dynamic() const { return (data_ & (width_mask | precision_mask)) != 0; } constexpr auto sign() const -> sign { return static_cast<fmt::sign>((data_ & sign_mask) >> sign_shift); } FMT_CONSTEXPR void set_sign(fmt::sign s) { data_ = (data_ & ~sign_mask) | (static_cast<unsigned>(s) << sign_shift); } constexpr auto upper() const -> bool { return (data_ & uppercase_mask) != 0; } FMT_CONSTEXPR void set_upper() { data_ |= uppercase_mask; } constexpr auto alt() const -> bool { return (data_ & alternate_mask) != 0; } FMT_CONSTEXPR void set_alt() { data_ |= alternate_mask; } FMT_CONSTEXPR void clear_alt() { data_ &= ~alternate_mask; } constexpr auto localized() const -> bool { return (data_ & localized_mask) != 0; } FMT_CONSTEXPR void set_localized() { data_ |= localized_mask; } constexpr auto fill_size() const -> size_t { return (data_ & fill_size_mask) >> fill_size_shift; } template <typename Char, FMT_ENABLE_IF(std::is_same<Char, char>::value)> constexpr auto fill() const -> const Char* { return fill_data_; } template <typename Char, FMT_ENABLE_IF(!std::is_same<Char, char>::value)> constexpr auto fill() const -> const Char* { return nullptr; } template <typename Char> constexpr auto fill_unit() const -> Char { using uchar = unsigned char; return static_cast<Char>(static_cast<uchar>(fill_data_[0]) | (static_cast<uchar>(fill_data_[1]) << 8) | (static_cast<uchar>(fill_data_[2]) << 16)); } FMT_CONSTEXPR void set_fill(char c) { fill_data_[0] = c; set_fill_size(1); } template <typename Char> FMT_CONSTEXPR void set_fill(basic_string_view<Char> s) { auto size = s.size(); set_fill_size(size); if (size == 1) { unsigned uchar = static_cast<detail::unsigned_char<Char>>(s[0]); fill_data_[0] = static_cast<char>(uchar); fill_data_[1] = static_cast<char>(uchar >> 8); fill_data_[2] = static_cast<char>(uchar >> 16); return; } FMT_ASSERT(size <= max_fill_size, "invalid fill"); for (size_t i = 0; i < size; ++i) fill_data_[i & 3] = static_cast<char>(s[i]); } FMT_CONSTEXPR void copy_fill_from(const basic_specs& specs) { set_fill_size(specs.fill_size()); for (size_t i = 0; i < max_fill_size; ++i) fill_data_[i] = specs.fill_data_[i]; } }; // Format specifiers for built-in and string types. struct format_specs : basic_specs { int width; int precision; constexpr format_specs() : width(0), precision(-1) {} }; /** * Parsing context consisting of a format string range being parsed and an * argument counter for automatic indexing. */ template <typename Char = char> class parse_context { private: basic_string_view<Char> fmt_; int next_arg_id_; enum { use_constexpr_cast = !FMT_GCC_VERSION || FMT_GCC_VERSION >= 1200 }; FMT_CONSTEXPR void do_check_arg_id(int arg_id); public: using char_type = Char; using iterator = const Char*; constexpr explicit parse_context(basic_string_view<Char> fmt, int next_arg_id = 0) : fmt_(fmt), next_arg_id_(next_arg_id) {} /// Returns an iterator to the beginning of the format string range being /// parsed. constexpr auto begin() const noexcept -> iterator { return fmt_.begin(); } /// Returns an iterator past the end of the format string range being parsed. constexpr auto end() const noexcept -> iterator { return fmt_.end(); } /// Advances the begin iterator to `it`. FMT_CONSTEXPR void advance_to(iterator it) { fmt_.remove_prefix(detail::to_unsigned(it - begin())); } /// Reports an error if using the manual argument indexing; otherwise returns /// the next argument index and switches to the automatic indexing. FMT_CONSTEXPR auto next_arg_id() -> int { if (next_arg_id_ < 0) { report_error("cannot switch from manual to automatic argument indexing"); return 0; } int id = next_arg_id_++; do_check_arg_id(id); return id; } /// Reports an error if using the automatic argument indexing; otherwise /// switches to the manual indexing. FMT_CONSTEXPR void check_arg_id(int id) { if (next_arg_id_ > 0) { report_error("cannot switch from automatic to manual argument indexing"); return; } next_arg_id_ = -1; do_check_arg_id(id); } FMT_CONSTEXPR void check_arg_id(basic_string_view<Char>) { next_arg_id_ = -1; } FMT_CONSTEXPR void check_dynamic_spec(int arg_id); }; FMT_END_EXPORT namespace detail { // Constructs fmt::basic_string_view<Char> from types implicitly convertible // to it, deducing Char. Explicitly convertible types such as the ones returned // from FMT_STRING are intentionally excluded. template <typename Char, FMT_ENABLE_IF(is_char<Char>::value)> constexpr auto to_string_view(const Char* s) -> basic_string_view<Char> { return s; } template <typename T, FMT_ENABLE_IF(is_std_string_like<T>::value)> constexpr auto to_string_view(const T& s) -> basic_string_view<typename T::value_type> { return s; } template <typename Char> constexpr auto to_string_view(basic_string_view<Char> s) -> basic_string_view<Char> { return s; } template <typename T, typename Enable = void> struct has_to_string_view : std::false_type {}; // detail:: is intentional since to_string_view is not an extension point. template <typename T> struct has_to_string_view< T, void_t<decltype(detail::to_string_view(std::declval<T>()))>> : std::true_type {}; /// String's character (code unit) type. detail:: is intentional to prevent ADL. template <typename S, typename V = decltype(detail::to_string_view(std::declval<S>()))> using char_t = typename V::value_type; enum class type { none_type, // Integer types should go first, int_type, uint_type, long_long_type, ulong_long_type, int128_type, uint128_type, bool_type, char_type, last_integer_type = char_type, // followed by floating-point types. float_type, double_type, long_double_type, last_numeric_type = long_double_type, cstring_type, string_type, pointer_type, custom_type }; // Maps core type T to the corresponding type enum constant. template <typename T, typename Char> struct type_constant : std::integral_constant<type, type::custom_type> {}; #define FMT_TYPE_CONSTANT(Type, constant) \ template <typename Char> \ struct type_constant<Type, Char> \ : std::integral_constant<type, type::constant> {} FMT_TYPE_CONSTANT(int, int_type); FMT_TYPE_CONSTANT(unsigned, uint_type); FMT_TYPE_CONSTANT(long long, long_long_type); FMT_TYPE_CONSTANT(unsigned long long, ulong_long_type); FMT_TYPE_CONSTANT(int128_opt, int128_type); FMT_TYPE_CONSTANT(uint128_opt, uint128_type); FMT_TYPE_CONSTANT(bool, bool_type); FMT_TYPE_CONSTANT(Char, char_type); FMT_TYPE_CONSTANT(float, float_type); FMT_TYPE_CONSTANT(double, double_type); FMT_TYPE_CONSTANT(long double, long_double_type); FMT_TYPE_CONSTANT(const Char*, cstring_type); FMT_TYPE_CONSTANT(basic_string_view<Char>, string_type); FMT_TYPE_CONSTANT(const void*, pointer_type); constexpr auto is_integral_type(type t) -> bool { return t > type::none_type && t <= type::last_integer_type; } constexpr auto is_arithmetic_type(type t) -> bool { return t > type::none_type && t <= type::last_numeric_type; } constexpr auto set(type rhs) -> int { return 1 << static_cast<int>(rhs); } constexpr auto in(type t, int set) -> bool { return ((set >> static_cast<int>(t)) & 1) != 0; } // Bitsets of types. enum { sint_set = set(type::int_type) | set(type::long_long_type) | set(type::int128_type), uint_set = set(type::uint_type) | set(type::ulong_long_type) | set(type::uint128_type), bool_set = set(type::bool_type), char_set = set(type::char_type), float_set = set(type::float_type) | set(type::double_type) | set(type::long_double_type), string_set = set(type::string_type), cstring_set = set(type::cstring_type), pointer_set = set(type::pointer_type) }; struct view {}; template <typename Char, typename T> struct named_arg; template <typename T> struct is_named_arg : std::false_type {}; template <typename T> struct is_static_named_arg : std::false_type {}; template <typename Char, typename T> struct is_named_arg<named_arg<Char, T>> : std::true_type {}; template <typename Char, typename T> struct named_arg : view { const Char* name; const T& value; named_arg(const Char* n, const T& v) : name(n), value(v) {} static_assert(!is_named_arg<T>::value, "nested named arguments"); }; template <bool B = false> constexpr auto count() -> int { return B ? 1 : 0; } template <bool B1, bool B2, bool... Tail> constexpr auto count() -> int { return (B1 ? 1 : 0) + count<B2, Tail...>(); } template <typename... Args> constexpr auto count_named_args() -> int { return count<is_named_arg<Args>::value...>(); } template <typename... Args> constexpr auto count_static_named_args() -> int { return count<is_static_named_arg<Args>::value...>(); } template <typename Char> struct named_arg_info { const Char* name; int id; }; template <typename Char, typename T, FMT_ENABLE_IF(!is_named_arg<T>::value)> void init_named_arg(named_arg_info<Char>*, int& arg_index, int&, const T&) { ++arg_index; } template <typename Char, typename T, FMT_ENABLE_IF(is_named_arg<T>::value)> void init_named_arg(named_arg_info<Char>* named_args, int& arg_index, int& named_arg_index, const T& arg) { named_args[named_arg_index++] = {arg.name, arg_index++}; } template <typename T, typename Char, FMT_ENABLE_IF(!is_static_named_arg<T>::value)> FMT_CONSTEXPR void init_static_named_arg(named_arg_info<Char>*, int& arg_index, int&) { ++arg_index; } template <typename T, typename Char, FMT_ENABLE_IF(is_static_named_arg<T>::value)> FMT_CONSTEXPR void init_static_named_arg(named_arg_info<Char>* named_args, int& arg_index, int& named_arg_index) { named_args[named_arg_index++] = {T::name, arg_index++}; } // To minimize the number of types we need to deal with, long is translated // either to int or to long long depending on its size. enum { long_short = sizeof(long) == sizeof(int) }; using long_type = conditional_t<long_short, int, long long>; using ulong_type = conditional_t<long_short, unsigned, unsigned long long>; template <typename T> using format_as_result = remove_cvref_t<decltype(format_as(std::declval<const T&>()))>; template <typename T> using format_as_member_result = remove_cvref_t<decltype(formatter<T>::format_as(std::declval<const T&>()))>; template <typename T, typename Enable = std::true_type> struct use_format_as : std::false_type {}; // format_as member is only used to avoid injection into the std namespace. template <typename T, typename Enable = std::true_type> struct use_format_as_member : std::false_type {}; // Only map owning types because mapping views can be unsafe. template <typename T> struct use_format_as< T, bool_constant<std::is_arithmetic<format_as_result<T>>::value>> : std::true_type {}; template <typename T> struct use_format_as_member< T, bool_constant<std::is_arithmetic<format_as_member_result<T>>::value>> : std::true_type {}; template <typename T, typename U = remove_const_t<T>> using use_formatter = bool_constant<(std::is_class<T>::value || std::is_enum<T>::value || std::is_union<T>::value || std::is_array<T>::value) && !has_to_string_view<T>::value && !is_named_arg<T>::value && !use_format_as<T>::value && !use_format_as_member<U>::value>; template <typename Char, typename T, typename U = remove_const_t<T>> auto has_formatter_impl(T* p, buffered_context<Char>* ctx = nullptr) -> decltype(formatter<U, Char>().format(*p, *ctx), std::true_type()); template <typename Char> auto has_formatter_impl(...) -> std::false_type; // T can be const-qualified to check if it is const-formattable. template <typename T, typename Char> constexpr auto has_formatter() -> bool { return decltype(has_formatter_impl<Char>(static_cast<T*>(nullptr)))::value; } // Maps formatting argument types to natively supported types or user-defined // types with formatters. Returns void on errors to be SFINAE-friendly. template <typename Char> struct type_mapper { static auto map(signed char) -> int; static auto map(unsigned char) -> unsigned; static auto map(short) -> int; static auto map(unsigned short) -> unsigned; static auto map(int) -> int; static auto map(unsigned) -> unsigned; static auto map(long) -> long_type; static auto map(unsigned long) -> ulong_type; static auto map(long long) -> long long; static auto map(unsigned long long) -> unsigned long long; static auto map(int128_opt) -> int128_opt; static auto map(uint128_opt) -> uint128_opt; static auto map(bool) -> bool; template <int N> static auto map(bitint<N>) -> conditional_t<N <= 64, long long, void>; template <int N> static auto map(ubitint<N>) -> conditional_t<N <= 64, unsigned long long, void>; template <typename T, FMT_ENABLE_IF(is_char<T>::value)> static auto map(T) -> conditional_t< std::is_same<T, char>::value || std::is_same<T, Char>::value, Char, void>; static auto map(float) -> float; static auto map(double) -> double; static auto map(long double) -> long double; static auto map(Char*) -> const Char*; static auto map(const Char*) -> const Char*; template <typename T, typename C = char_t<T>, FMT_ENABLE_IF(!std::is_pointer<T>::value)> static auto map(const T&) -> conditional_t<std::is_same<C, Char>::value, basic_string_view<C>, void>; static auto map(void*) -> const void*; static auto map(const void*) -> const void*; static auto map(volatile void*) -> const void*; static auto map(const volatile void*) -> const void*; static auto map(nullptr_t) -> const void*; template <typename T, FMT_ENABLE_IF(std::is_pointer<T>::value || std::is_member_pointer<T>::value)> static auto map(const T&) -> void; template <typename T, FMT_ENABLE_IF(use_format_as<T>::value)> static auto map(const T& x) -> decltype(map(format_as(x))); template <typename T, FMT_ENABLE_IF(use_format_as_member<T>::value)> static auto map(const T& x) -> decltype(map(formatter<T>::format_as(x))); template <typename T, FMT_ENABLE_IF(use_formatter<T>::value)> static auto map(T&) -> conditional_t<has_formatter<T, Char>(), T&, void>; template <typename T, FMT_ENABLE_IF(is_named_arg<T>::value)> static auto map(const T& named_arg) -> decltype(map(named_arg.value)); }; // detail:: is used to workaround a bug in MSVC 2017. template <typename T, typename Char> using mapped_t = decltype(detail::type_mapper<Char>::map(std::declval<T&>())); // A type constant after applying type_mapper. template <typename T, typename Char = char> using mapped_type_constant = type_constant<mapped_t<T, Char>, Char>; template <typename T, typename Context, type TYPE = mapped_type_constant<T, typename Context::char_type>::value> using stored_type_constant = std::integral_constant< type, Context::builtin_types || TYPE == type::int_type ? TYPE : type::custom_type>; // A parse context with extra data used only in compile-time checks. template <typename Char> class compile_parse_context : public parse_context<Char> { private: int num_args_; const type* types_; using base = parse_context<Char>; public: FMT_CONSTEXPR explicit compile_parse_context(basic_string_view<Char> fmt, int num_args, const type* types, int next_arg_id = 0) : base(fmt, next_arg_id), num_args_(num_args), types_(types) {} constexpr auto num_args() const -> int { return num_args_; } constexpr auto arg_type(int id) const -> type { return types_[id]; } FMT_CONSTEXPR auto next_arg_id() -> int { int id = base::next_arg_id(); if (id >= num_args_) report_error("argument not found"); return id; } FMT_CONSTEXPR void check_arg_id(int id) { base::check_arg_id(id); if (id >= num_args_) report_error("argument not found"); } using base::check_arg_id; FMT_CONSTEXPR void check_dynamic_spec(int arg_id) { ignore_unused(arg_id); if (arg_id < num_args_ && types_ && !is_integral_type(types_[arg_id])) report_error("width/precision is not integer"); } }; // An argument reference. template <typename Char> union arg_ref { FMT_CONSTEXPR arg_ref(int idx = 0) : index(idx) {} FMT_CONSTEXPR arg_ref(basic_string_view<Char> n) : name(n) {} int index; basic_string_view<Char> name; }; // Format specifiers with width and precision resolved at formatting rather // than parsing time to allow reusing the same parsed specifiers with // different sets of arguments (precompilation of format strings). template <typename Char = char> struct dynamic_format_specs : format_specs { arg_ref<Char> width_ref; arg_ref<Char> precision_ref; }; // Converts a character to ASCII. Returns '\0' on conversion failure. template <typename Char, FMT_ENABLE_IF(std::is_integral<Char>::value)> constexpr auto to_ascii(Char c) -> char { return c <= 0xff ? static_cast<char>(c) : '\0'; } // Returns the number of code units in a code point or 1 on error. template <typename Char> FMT_CONSTEXPR auto code_point_length(const Char* begin) -> int { if (const_check(sizeof(Char) != 1)) return 1; auto c = static_cast<unsigned char>(*begin); return static_cast<int>((0x3a55000000000000ull >> (2 * (c >> 3))) & 3) + 1; } // Parses the range [begin, end) as an unsigned integer. This function assumes // that the range is non-empty and the first character is a digit. template <typename Char> FMT_CONSTEXPR auto parse_nonnegative_int(const Char*& begin, const Char* end, int error_value) noexcept -> int { FMT_ASSERT(begin != end && '0' <= *begin && *begin <= '9', ""); unsigned value = 0, prev = 0; auto p = begin; do { prev = value; value = value * 10 + unsigned(*p - '0'); ++p; } while (p != end && '0' <= *p && *p <= '9'); auto num_digits = p - begin; begin = p; int digits10 = static_cast<int>(sizeof(int) * CHAR_BIT * 3 / 10); if (num_digits <= digits10) return static_cast<int>(value); // Check for overflow. unsigned max = INT_MAX; return num_digits == digits10 + 1 && prev * 10ull + unsigned(p[-1] - '0') <= max ? static_cast<int>(value) : error_value; } FMT_CONSTEXPR inline auto parse_align(char c) -> align { switch (c) { case '<': return align::left; case '>': return align::right; case '^': return align::center; } return align::none; } template <typename Char> constexpr auto is_name_start(Char c) -> bool { return ('a' <= c && c <= 'z') || ('A' <= c && c <= 'Z') || c == '_'; } template <typename Char, typename Handler> FMT_CONSTEXPR auto parse_arg_id(const Char* begin, const Char* end, Handler&& handler) -> const Char* { Char c = *begin; if (c >= '0' && c <= '9') { int index = 0; if (c != '0') index = parse_nonnegative_int(begin, end, INT_MAX); else ++begin; if (begin == end || (*begin != '}' && *begin != ':')) report_error("invalid format string"); else handler.on_index(index); return begin; } if (FMT_OPTIMIZE_SIZE > 1 || !is_name_start(c)) { report_error("invalid format string"); return begin; } auto it = begin; do { ++it; } while (it != end && (is_name_start(*it) || ('0' <= *it && *it <= '9'))); handler.on_name({begin, to_unsigned(it - begin)}); return it; } template <typename Char> struct dynamic_spec_handler { parse_context<Char>& ctx; arg_ref<Char>& ref; arg_id_kind& kind; FMT_CONSTEXPR void on_index(int id) { ref = id; kind = arg_id_kind::index; ctx.check_arg_id(id); ctx.check_dynamic_spec(id); } FMT_CONSTEXPR void on_name(basic_string_view<Char> id) { ref = id; kind = arg_id_kind::name; ctx.check_arg_id(id); } }; template <typename Char> struct parse_dynamic_spec_result { const Char* end; arg_id_kind kind; }; // Parses integer | "{" [arg_id] "}". template <typename Char> FMT_CONSTEXPR auto parse_dynamic_spec(const Char* begin, const Char* end, int& value, arg_ref<Char>& ref, parse_context<Char>& ctx) -> parse_dynamic_spec_result<Char> { FMT_ASSERT(begin != end, ""); auto kind = arg_id_kind::none; if ('0' <= *begin && *begin <= '9') { int val = parse_nonnegative_int(begin, end, -1); if (val == -1) report_error("number is too big"); value = val; } else { if (*begin == '{') { ++begin; if (begin != end) { Char c = *begin; if (c == '}' || c == ':') { int id = ctx.next_arg_id(); ref = id; kind = arg_id_kind::index; ctx.check_dynamic_spec(id); } else { begin = parse_arg_id(begin, end, dynamic_spec_handler<Char>{ctx, ref, kind}); } } if (begin != end && *begin == '}') return {++begin, kind}; } report_error("invalid format string"); } return {begin, kind}; } template <typename Char> FMT_CONSTEXPR auto parse_width(const Char* begin, const Char* end, format_specs& specs, arg_ref<Char>& width_ref, parse_context<Char>& ctx) -> const Char* { auto result = parse_dynamic_spec(begin, end, specs.width, width_ref, ctx); specs.set_dynamic_width(result.kind); return result.end; } template <typename Char> FMT_CONSTEXPR auto parse_precision(const Char* begin, const Char* end, format_specs& specs, arg_ref<Char>& precision_ref, parse_context<Char>& ctx) -> const Char* { ++begin; if (begin == end) { report_error("invalid precision"); return begin; } auto result = parse_dynamic_spec(begin, end, specs.precision, precision_ref, ctx); specs.set_dynamic_precision(result.kind); return result.end; } enum class state { start, align, sign, hash, zero, width, precision, locale }; // Parses standard format specifiers. template <typename Char> FMT_CONSTEXPR auto parse_format_specs(const Char* begin, const Char* end, dynamic_format_specs<Char>& specs, parse_context<Char>& ctx, type arg_type) -> const Char* { auto c = '\0'; if (end - begin > 1) { auto next = to_ascii(begin[1]); c = parse_align(next) == align::none ? to_ascii(*begin) : '\0'; } else { if (begin == end) return begin; c = to_ascii(*begin); } struct { state current_state = state::start; FMT_CONSTEXPR void operator()(state s, bool valid = true) { if (current_state >= s || !valid) report_error("invalid format specifier"); current_state = s; } } enter_state; using pres = presentation_type; constexpr auto integral_set = sint_set | uint_set | bool_set | char_set; struct { const Char*& begin; format_specs& specs; type arg_type; FMT_CONSTEXPR auto operator()(pres pres_type, int set) -> const Char* { if (!in(arg_type, set)) report_error("invalid format specifier"); specs.set_type(pres_type); return begin + 1; } } parse_presentation_type{begin, specs, arg_type}; for (;;) { switch (c) { case '<': case '>': case '^': enter_state(state::align); specs.set_align(parse_align(c)); ++begin; break; case '+': case ' ': specs.set_sign(c == ' ' ? sign::space : sign::plus); FMT_FALLTHROUGH; case '-': enter_state(state::sign, in(arg_type, sint_set | float_set)); ++begin; break; case '#': enter_state(state::hash, is_arithmetic_type(arg_type)); specs.set_alt(); ++begin; break; case '0': enter_state(state::zero); if (!is_arithmetic_type(arg_type)) report_error("format specifier requires numeric argument"); if (specs.align() == align::none) { // Ignore 0 if align is specified for compatibility with std::format. specs.set_align(align::numeric); specs.set_fill('0'); } ++begin; break; // clang-format off case '1': case '2': case '3': case '4': case '5': case '6': case '7': case '8': case '9': case '{': // clang-format on enter_state(state::width); begin = parse_width(begin, end, specs, specs.width_ref, ctx); break; case '.': enter_state(state::precision, in(arg_type, float_set | string_set | cstring_set)); begin = parse_precision(begin, end, specs, specs.precision_ref, ctx); break; case 'L': enter_state(state::locale, is_arithmetic_type(arg_type)); specs.set_localized(); ++begin; break; case 'd': return parse_presentation_type(pres::dec, integral_set); case 'X': specs.set_upper(); FMT_FALLTHROUGH; case 'x': return parse_presentation_type(pres::hex, integral_set); case 'o': return parse_presentation_type(pres::oct, integral_set); case 'B': specs.set_upper(); FMT_FALLTHROUGH; case 'b': return parse_presentation_type(pres::bin, integral_set); case 'E': specs.set_upper(); FMT_FALLTHROUGH; case 'e': return parse_presentation_type(pres::exp, float_set); case 'F': specs.set_upper(); FMT_FALLTHROUGH; case 'f': return parse_presentation_type(pres::fixed, float_set); case 'G': specs.set_upper(); FMT_FALLTHROUGH; case 'g': return parse_presentation_type(pres::general, float_set); case 'A': specs.set_upper(); FMT_FALLTHROUGH; case 'a': return parse_presentation_type(pres::hexfloat, float_set); case 'c': if (arg_type == type::bool_type) report_error("invalid format specifier"); return parse_presentation_type(pres::chr, integral_set); case 's': return parse_presentation_type(pres::string, bool_set | string_set | cstring_set); case 'p': return parse_presentation_type(pres::pointer, pointer_set | cstring_set); case '?': return parse_presentation_type(pres::debug, char_set | string_set | cstring_set); case '}': return begin; default: { if (*begin == '}') return begin; // Parse fill and alignment. auto fill_end = begin + code_point_length(begin); if (end - fill_end <= 0) { report_error("invalid format specifier"); return begin; } if (*begin == '{') { report_error("invalid fill character '{'"); return begin; } auto alignment = parse_align(to_ascii(*fill_end)); enter_state(state::align, alignment != align::none); specs.set_fill( basic_string_view<Char>(begin, to_unsigned(fill_end - begin))); specs.set_align(alignment); begin = fill_end + 1; } } if (begin == end) return begin; c = to_ascii(*begin); } } template <typename Char, typename Handler> FMT_CONSTEXPR FMT_INLINE auto parse_replacement_field(const Char* begin, const Char* end, Handler&& handler) -> const Char* { ++begin; if (begin == end) { handler.on_error("invalid format string"); return end; } int arg_id = 0; switch (*begin) { case '}': handler.on_replacement_field(handler.on_arg_id(), begin); return begin + 1; case '{': handler.on_text(begin, begin + 1); return begin + 1; case ':': arg_id = handler.on_arg_id(); break; default: { struct id_adapter { Handler& handler; int arg_id; FMT_CONSTEXPR void on_index(int id) { arg_id = handler.on_arg_id(id); } FMT_CONSTEXPR void on_name(basic_string_view<Char> id) { arg_id = handler.on_arg_id(id); } } adapter = {handler, 0}; begin = parse_arg_id(begin, end, adapter); arg_id = adapter.arg_id; Char c = begin != end ? *begin : Char(); if (c == '}') { handler.on_replacement_field(arg_id, begin); return begin + 1; } if (c != ':') { handler.on_error("missing '}' in format string"); return end; } break; } } begin = handler.on_format_specs(arg_id, begin + 1, end); if (begin == end || *begin != '}') return handler.on_error("unknown format specifier"), end; return begin + 1; } template <typename Char, typename Handler> FMT_CONSTEXPR void parse_format_string(basic_string_view<Char> fmt, Handler&& handler) { auto begin = fmt.data(), end = begin + fmt.size(); auto p = begin; while (p != end) { auto c = *p++; if (c == '{') { handler.on_text(begin, p - 1); begin = p = parse_replacement_field(p - 1, end, handler); } else if (c == '}') { if (p == end || *p != '}') return handler.on_error("unmatched '}' in format string"); handler.on_text(begin, p); begin = ++p; } } handler.on_text(begin, end); } // Checks char specs and returns true iff the presentation type is char-like. FMT_CONSTEXPR inline auto check_char_specs(const format_specs& specs) -> bool { auto type = specs.type(); if (type != presentation_type::none && type != presentation_type::chr && type != presentation_type::debug) { return false; } if (specs.align() == align::numeric || specs.sign() != sign::none || specs.alt()) { report_error("invalid format specifier for char"); } return true; } // A base class for compile-time strings. struct compile_string {}; template <typename T, typename Char> FMT_VISIBILITY("hidden") // Suppress an ld warning on macOS (#3769). FMT_CONSTEXPR auto invoke_parse(parse_context<Char>& ctx) -> const Char* { using mapped_type = remove_cvref_t<mapped_t<T, Char>>; constexpr bool formattable = std::is_constructible<formatter<mapped_type, Char>>::value; if (!formattable) return ctx.begin(); // Error is reported in the value ctor. using formatted_type = conditional_t<formattable, mapped_type, int>; return formatter<formatted_type, Char>().parse(ctx); } template <typename... T> struct arg_pack {}; template <typename Char, int NUM_ARGS, int NUM_NAMED_ARGS, bool DYNAMIC_NAMES> class format_string_checker { private: type types_[max_of(1, NUM_ARGS)]; named_arg_info<Char> named_args_[max_of(1, NUM_NAMED_ARGS)]; compile_parse_context<Char> context_; using parse_func = auto (*)(parse_context<Char>&) -> const Char*; parse_func parse_funcs_[max_of(1, NUM_ARGS)]; public: template <typename... T> FMT_CONSTEXPR explicit format_string_checker(basic_string_view<Char> fmt, arg_pack<T...>) : types_{mapped_type_constant<T, Char>::value...}, named_args_{}, context_(fmt, NUM_ARGS, types_), parse_funcs_{&invoke_parse<T, Char>...} { int arg_index = 0, named_arg_index = 0; FMT_APPLY_VARIADIC( init_static_named_arg<T>(named_args_, arg_index, named_arg_index)); ignore_unused(arg_index, named_arg_index); } FMT_CONSTEXPR void on_text(const Char*, const Char*) {} FMT_CONSTEXPR auto on_arg_id() -> int { return context_.next_arg_id(); } FMT_CONSTEXPR auto on_arg_id(int id) -> int { context_.check_arg_id(id); return id; } FMT_CONSTEXPR auto on_arg_id(basic_string_view<Char> id) -> int { for (int i = 0; i < NUM_NAMED_ARGS; ++i) { if (named_args_[i].name == id) return named_args_[i].id; } if (!DYNAMIC_NAMES) on_error("argument not found"); return -1; } FMT_CONSTEXPR void on_replacement_field(int id, const Char* begin) { on_format_specs(id, begin, begin); // Call parse() on empty specs. } FMT_CONSTEXPR auto on_format_specs(int id, const Char* begin, const Char* end) -> const Char* { context_.advance_to(begin); if (id >= 0 && id < NUM_ARGS) return parse_funcs_[id](context_); while (begin != end && *begin != '}') ++begin; return begin; } FMT_NORETURN FMT_CONSTEXPR void on_error(const char* message) { report_error(message); } }; /// A contiguous memory buffer with an optional growing ability. It is an /// internal class and shouldn't be used directly, only via `memory_buffer`. template <typename T> class buffer { private: T* ptr_; size_t size_; size_t capacity_; using grow_fun = void (*)(buffer& buf, size_t capacity); grow_fun grow_; protected: // Don't initialize ptr_ since it is not accessed to save a few cycles. FMT_MSC_WARNING(suppress : 26495) FMT_CONSTEXPR buffer(grow_fun grow, size_t sz) noexcept : size_(sz), capacity_(sz), grow_(grow) {} constexpr buffer(grow_fun grow, T* p = nullptr, size_t sz = 0, size_t cap = 0) noexcept : ptr_(p), size_(sz), capacity_(cap), grow_(grow) {} FMT_CONSTEXPR20 ~buffer() = default; buffer(buffer&&) = default; /// Sets the buffer data and capacity. FMT_CONSTEXPR void set(T* buf_data, size_t buf_capacity) noexcept { ptr_ = buf_data; capacity_ = buf_capacity; } public: using value_type = T; using const_reference = const T&; buffer(const buffer&) = delete; void operator=(const buffer&) = delete; auto begin() noexcept -> T* { return ptr_; } auto end() noexcept -> T* { return ptr_ + size_; } auto begin() const noexcept -> const T* { return ptr_; } auto end() const noexcept -> const T* { return ptr_ + size_; } /// Returns the size of this buffer. constexpr auto size() const noexcept -> size_t { return size_; } /// Returns the capacity of this buffer. constexpr auto capacity() const noexcept -> size_t { return capacity_; } /// Returns a pointer to the buffer data (not null-terminated). FMT_CONSTEXPR auto data() noexcept -> T* { return ptr_; } FMT_CONSTEXPR auto data() const noexcept -> const T* { return ptr_; } /// Clears this buffer. FMT_CONSTEXPR void clear() { size_ = 0; } // Tries resizing the buffer to contain `count` elements. If T is a POD type // the new elements may not be initialized. FMT_CONSTEXPR void try_resize(size_t count) { try_reserve(count); size_ = min_of(count, capacity_); } // Tries increasing the buffer capacity to `new_capacity`. It can increase the // capacity by a smaller amount than requested but guarantees there is space // for at least one additional element either by increasing the capacity or by // flushing the buffer if it is full. FMT_CONSTEXPR void try_reserve(size_t new_capacity) { if (new_capacity > capacity_) grow_(*this, new_capacity); } FMT_CONSTEXPR void push_back(const T& value) { try_reserve(size_ + 1); ptr_[size_++] = value; } /// Appends data to the end of the buffer. template <typename U> // Workaround for MSVC2019 to fix error C2893: Failed to specialize function // template 'void fmt::v11::detail::buffer<T>::append(const U *,const U *)'. #if !FMT_MSC_VERSION || FMT_MSC_VERSION >= 1940 FMT_CONSTEXPR20 #endif void append(const U* begin, const U* end) { while (begin != end) { auto count = to_unsigned(end - begin); try_reserve(size_ + count); auto free_cap = capacity_ - size_; if (free_cap < count) count = free_cap; // A loop is faster than memcpy on small sizes. T* out = ptr_ + size_; for (size_t i = 0; i < count; ++i) out[i] = begin[i]; size_ += count; begin += count; } } template <typename Idx> FMT_CONSTEXPR auto operator[](Idx index) -> T& { return ptr_[index]; } template <typename Idx> FMT_CONSTEXPR auto operator[](Idx index) const -> const T& { return ptr_[index]; } }; struct buffer_traits { constexpr explicit buffer_traits(size_t) {} constexpr auto count() const -> size_t { return 0; } constexpr auto limit(size_t size) const -> size_t { return size; } }; class fixed_buffer_traits { private: size_t count_ = 0; size_t limit_; public: constexpr explicit fixed_buffer_traits(size_t limit) : limit_(limit) {} constexpr auto count() const -> size_t { return count_; } FMT_CONSTEXPR auto limit(size_t size) -> size_t { size_t n = limit_ > count_ ? limit_ - count_ : 0; count_ += size; return min_of(size, n); } }; // A buffer that writes to an output iterator when flushed. template <typename OutputIt, typename T, typename Traits = buffer_traits> class iterator_buffer : public Traits, public buffer<T> { private: OutputIt out_; enum { buffer_size = 256 }; T data_[buffer_size]; static FMT_CONSTEXPR void grow(buffer<T>& buf, size_t) { if (buf.size() == buffer_size) static_cast<iterator_buffer&>(buf).flush(); } void flush() { auto size = this->size(); this->clear(); const T* begin = data_; const T* end = begin + this->limit(size); while (begin != end) *out_++ = *begin++; } public: explicit iterator_buffer(OutputIt out, size_t n = buffer_size) : Traits(n), buffer<T>(grow, data_, 0, buffer_size), out_(out) {} iterator_buffer(iterator_buffer&& other) noexcept : Traits(other), buffer<T>(grow, data_, 0, buffer_size), out_(other.out_) {} ~iterator_buffer() { // Don't crash if flush fails during unwinding. FMT_TRY { flush(); } FMT_CATCH(...) {} } auto out() -> OutputIt { flush(); return out_; } auto count() const -> size_t { return Traits::count() + this->size(); } }; template <typename T> class iterator_buffer<T*, T, fixed_buffer_traits> : public fixed_buffer_traits, public buffer<T> { private: T* out_; enum { buffer_size = 256 }; T data_[buffer_size]; static FMT_CONSTEXPR void grow(buffer<T>& buf, size_t) { if (buf.size() == buf.capacity()) static_cast<iterator_buffer&>(buf).flush(); } void flush() { size_t n = this->limit(this->size()); if (this->data() == out_) { out_ += n; this->set(data_, buffer_size); } this->clear(); } public: explicit iterator_buffer(T* out, size_t n = buffer_size) : fixed_buffer_traits(n), buffer<T>(grow, out, 0, n), out_(out) {} iterator_buffer(iterator_buffer&& other) noexcept : fixed_buffer_traits(other), buffer<T>(static_cast<iterator_buffer&&>(other)), out_(other.out_) { if (this->data() != out_) { this->set(data_, buffer_size); this->clear(); } } ~iterator_buffer() { flush(); } auto out() -> T* { flush(); return out_; } auto count() const -> size_t { return fixed_buffer_traits::count() + this->size(); } }; template <typename T> class iterator_buffer<T*, T> : public buffer<T> { public: explicit iterator_buffer(T* out, size_t = 0) : buffer<T>([](buffer<T>&, size_t) {}, out, 0, ~size_t()) {} auto out() -> T* { return &*this->end(); } }; template <typename Container> class container_buffer : public buffer<typename Container::value_type> { private: using value_type = typename Container::value_type; static FMT_CONSTEXPR void grow(buffer<value_type>& buf, size_t capacity) { auto& self = static_cast<container_buffer&>(buf); self.container.resize(capacity); self.set(&self.container[0], capacity); } public: Container& container; explicit container_buffer(Container& c) : buffer<value_type>(grow, c.size()), container(c) {} }; // A buffer that writes to a container with the contiguous storage. template <typename OutputIt> class iterator_buffer< OutputIt, enable_if_t<is_back_insert_iterator<OutputIt>::value && is_contiguous<typename OutputIt::container_type>::value, typename OutputIt::container_type::value_type>> : public container_buffer<typename OutputIt::container_type> { private: using base = container_buffer<typename OutputIt::container_type>; public: explicit iterator_buffer(typename OutputIt::container_type& c) : base(c) {} explicit iterator_buffer(OutputIt out, size_t = 0) : base(get_container(out)) {} auto out() -> OutputIt { return OutputIt(this->container); } }; // A buffer that counts the number of code units written discarding the output. template <typename T = char> class counting_buffer : public buffer<T> { private: enum { buffer_size = 256 }; T data_[buffer_size]; size_t count_ = 0; static FMT_CONSTEXPR void grow(buffer<T>& buf, size_t) { if (buf.size() != buffer_size) return; static_cast<counting_buffer&>(buf).count_ += buf.size(); buf.clear(); } public: FMT_CONSTEXPR counting_buffer() : buffer<T>(grow, data_, 0, buffer_size) {} constexpr auto count() const noexcept -> size_t { return count_ + this->size(); } }; template <typename T> struct is_back_insert_iterator<basic_appender<T>> : std::true_type {}; template <typename OutputIt, typename InputIt, typename = void> struct has_back_insert_iterator_container_append : std::false_type {}; template <typename OutputIt, typename InputIt> struct has_back_insert_iterator_container_append< OutputIt, InputIt, void_t<decltype(get_container(std::declval<OutputIt>()) .append(std::declval<InputIt>(), std::declval<InputIt>()))>> : std::true_type {}; // An optimized version of std::copy with the output value type (T). template <typename T, typename InputIt, typename OutputIt, FMT_ENABLE_IF(is_back_insert_iterator<OutputIt>::value&& has_back_insert_iterator_container_append< OutputIt, InputIt>::value)> FMT_CONSTEXPR20 auto copy(InputIt begin, InputIt end, OutputIt out) -> OutputIt { get_container(out).append(begin, end); return out; } template <typename T, typename InputIt, typename OutputIt, FMT_ENABLE_IF(is_back_insert_iterator<OutputIt>::value && !has_back_insert_iterator_container_append< OutputIt, InputIt>::value)> FMT_CONSTEXPR20 auto copy(InputIt begin, InputIt end, OutputIt out) -> OutputIt { auto& c = get_container(out); c.insert(c.end(), begin, end); return out; } template <typename T, typename InputIt, typename OutputIt, FMT_ENABLE_IF(!is_back_insert_iterator<OutputIt>::value)> FMT_CONSTEXPR auto copy(InputIt begin, InputIt end, OutputIt out) -> OutputIt { while (begin != end) *out++ = static_cast<T>(*begin++); return out; } template <typename T, typename V, typename OutputIt> FMT_CONSTEXPR auto copy(basic_string_view<V> s, OutputIt out) -> OutputIt { return copy<T>(s.begin(), s.end(), out); } template <typename It, typename Enable = std::true_type> struct is_buffer_appender : std::false_type {}; template <typename It> struct is_buffer_appender< It, bool_constant< is_back_insert_iterator<It>::value && std::is_base_of<buffer<typename It::container_type::value_type>, typename It::container_type>::value>> : std::true_type {}; // Maps an output iterator to a buffer. template <typename T, typename OutputIt, FMT_ENABLE_IF(!is_buffer_appender<OutputIt>::value)> auto get_buffer(OutputIt out) -> iterator_buffer<OutputIt, T> { return iterator_buffer<OutputIt, T>(out); } template <typename T, typename OutputIt, FMT_ENABLE_IF(is_buffer_appender<OutputIt>::value)> auto get_buffer(OutputIt out) -> buffer<T>& { return get_container(out); } template <typename Buf, typename OutputIt> auto get_iterator(Buf& buf, OutputIt) -> decltype(buf.out()) { return buf.out(); } template <typename T, typename OutputIt> auto get_iterator(buffer<T>&, OutputIt out) -> OutputIt { return out; } // This type is intentionally undefined, only used for errors. template <typename T, typename Char> struct type_is_unformattable_for; template <typename Char> struct string_value { const Char* data; size_t size; auto str() const -> basic_string_view<Char> { return {data, size}; } }; template <typename Context> struct custom_value { using char_type = typename Context::char_type; void* value; void (*format)(void* arg, parse_context<char_type>& parse_ctx, Context& ctx); }; template <typename Char> struct named_arg_value { const named_arg_info<Char>* data; size_t size; }; struct custom_tag {}; #if !FMT_BUILTIN_TYPES # define FMT_BUILTIN , monostate #else # define FMT_BUILTIN #endif // A formatting argument value. template <typename Context> class value { public: using char_type = typename Context::char_type; union { monostate no_value; int int_value; unsigned uint_value; long long long_long_value; unsigned long long ulong_long_value; int128_opt int128_value; uint128_opt uint128_value; bool bool_value; char_type char_value; float float_value; double double_value; long double long_double_value; const void* pointer; string_value<char_type> string; custom_value<Context> custom; named_arg_value<char_type> named_args; }; constexpr FMT_INLINE value() : no_value() {} constexpr FMT_INLINE value(signed char x) : int_value(x) {} constexpr FMT_INLINE value(unsigned char x FMT_BUILTIN) : uint_value(x) {} constexpr FMT_INLINE value(signed short x) : int_value(x) {} constexpr FMT_INLINE value(unsigned short x FMT_BUILTIN) : uint_value(x) {} constexpr FMT_INLINE value(int x) : int_value(x) {} constexpr FMT_INLINE value(unsigned x FMT_BUILTIN) : uint_value(x) {} FMT_CONSTEXPR FMT_INLINE value(long x FMT_BUILTIN) : value(long_type(x)) {} FMT_CONSTEXPR FMT_INLINE value(unsigned long x FMT_BUILTIN) : value(ulong_type(x)) {} constexpr FMT_INLINE value(long long x FMT_BUILTIN) : long_long_value(x) {} constexpr FMT_INLINE value(unsigned long long x FMT_BUILTIN) : ulong_long_value(x) {} FMT_INLINE value(int128_opt x FMT_BUILTIN) : int128_value(x) {} FMT_INLINE value(uint128_opt x FMT_BUILTIN) : uint128_value(x) {} constexpr FMT_INLINE value(bool x FMT_BUILTIN) : bool_value(x) {} template <int N> constexpr FMT_INLINE value(bitint<N> x FMT_BUILTIN) : long_long_value(x) { static_assert(N <= 64, "unsupported _BitInt"); } template <int N> constexpr FMT_INLINE value(ubitint<N> x FMT_BUILTIN) : ulong_long_value(x) { static_assert(N <= 64, "unsupported _BitInt"); } template <typename T, FMT_ENABLE_IF(is_char<T>::value)> constexpr FMT_INLINE value(T x FMT_BUILTIN) : char_value(x) { static_assert( std::is_same<T, char>::value || std::is_same<T, char_type>::value, "mixing character types is disallowed"); } constexpr FMT_INLINE value(float x FMT_BUILTIN) : float_value(x) {} constexpr FMT_INLINE value(double x FMT_BUILTIN) : double_value(x) {} FMT_INLINE value(long double x FMT_BUILTIN) : long_double_value(x) {} FMT_CONSTEXPR FMT_INLINE value(char_type* x FMT_BUILTIN) { string.data = x; if (is_constant_evaluated()) string.size = 0; } FMT_CONSTEXPR FMT_INLINE value(const char_type* x FMT_BUILTIN) { string.data = x; if (is_constant_evaluated()) string.size = 0; } template <typename T, typename C = char_t<T>, FMT_ENABLE_IF(!std::is_pointer<T>::value)> FMT_CONSTEXPR value(const T& x FMT_BUILTIN) { static_assert(std::is_same<C, char_type>::value, "mixing character types is disallowed"); auto sv = to_string_view(x); string.data = sv.data(); string.size = sv.size(); } FMT_INLINE value(void* x FMT_BUILTIN) : pointer(x) {} FMT_INLINE value(const void* x FMT_BUILTIN) : pointer(x) {} FMT_INLINE value(volatile void* x FMT_BUILTIN) : pointer(const_cast<const void*>(x)) {} FMT_INLINE value(const volatile void* x FMT_BUILTIN) : pointer(const_cast<const void*>(x)) {} FMT_INLINE value(nullptr_t) : pointer(nullptr) {} template <typename T, FMT_ENABLE_IF(std::is_pointer<T>::value || std::is_member_pointer<T>::value)> value(const T&) { // Formatting of arbitrary pointers is disallowed. If you want to format a // pointer cast it to `void*` or `const void*`. In particular, this forbids // formatting of `[const] volatile char*` printed as bool by iostreams. static_assert(sizeof(T) == 0, "formatting of non-void pointers is disallowed"); } template <typename T, FMT_ENABLE_IF(use_format_as<T>::value)> value(const T& x) : value(format_as(x)) {} template <typename T, FMT_ENABLE_IF(use_format_as_member<T>::value)> value(const T& x) : value(formatter<T>::format_as(x)) {} template <typename T, FMT_ENABLE_IF(is_named_arg<T>::value)> value(const T& named_arg) : value(named_arg.value) {} template <typename T, FMT_ENABLE_IF(use_formatter<T>::value || !FMT_BUILTIN_TYPES)> FMT_CONSTEXPR20 FMT_INLINE value(T& x) : value(x, custom_tag()) {} FMT_ALWAYS_INLINE value(const named_arg_info<char_type>* args, size_t size) : named_args{args, size} {} private: template <typename T, FMT_ENABLE_IF(has_formatter<T, char_type>())> FMT_CONSTEXPR value(T& x, custom_tag) { using value_type = remove_const_t<T>; // T may overload operator& e.g. std::vector<bool>::reference in libc++. if (!is_constant_evaluated()) { custom.value = const_cast<char*>(&reinterpret_cast<const volatile char&>(x)); } else { custom.value = nullptr; #if defined(__cpp_if_constexpr) if constexpr (std::is_same<decltype(&x), remove_reference_t<T>*>::value) custom.value = const_cast<value_type*>(&x); #endif } custom.format = format_custom<value_type, formatter<value_type, char_type>>; } template <typename T, FMT_ENABLE_IF(!has_formatter<T, char_type>())> FMT_CONSTEXPR value(const T&, custom_tag) { // Cannot format an argument; to make type T formattable provide a // formatter<T> specialization: https://fmt.dev/latest/api.html#udt. type_is_unformattable_for<T, char_type> _; } // Formats an argument of a custom type, such as a user-defined class. template <typename T, typename Formatter> static void format_custom(void* arg, parse_context<char_type>& parse_ctx, Context& ctx) { auto f = Formatter(); parse_ctx.advance_to(f.parse(parse_ctx)); using qualified_type = conditional_t<has_formatter<const T, char_type>(), const T, T>; // format must be const for compatibility with std::format and compilation. const auto& cf = f; ctx.advance_to(cf.format(*static_cast<qualified_type*>(arg), ctx)); } }; enum { packed_arg_bits = 4 }; // Maximum number of arguments with packed types. enum { max_packed_args = 62 / packed_arg_bits }; enum : unsigned long long { is_unpacked_bit = 1ULL << 63 }; enum : unsigned long long { has_named_args_bit = 1ULL << 62 }; template <typename It, typename T, typename Enable = void> struct is_output_iterator : std::false_type {}; template <> struct is_output_iterator<appender, char> : std::true_type {}; template <typename It, typename T> struct is_output_iterator< It, T, enable_if_t<std::is_assignable<decltype(*std::declval<decay_t<It>&>()++), T>::value>> : std::true_type {}; #ifndef FMT_USE_LOCALE # define FMT_USE_LOCALE (FMT_OPTIMIZE_SIZE <= 1) #endif // A type-erased reference to an std::locale to avoid a heavy <locale> include. class locale_ref { #if FMT_USE_LOCALE private: const void* locale_; // A type-erased pointer to std::locale. public: constexpr locale_ref() : locale_(nullptr) {} template <typename Locale> locale_ref(const Locale& loc); inline explicit operator bool() const noexcept { return locale_ != nullptr; } #endif // FMT_USE_LOCALE public: template <typename Locale> auto get() const -> Locale; }; template <typename> constexpr auto encode_types() -> unsigned long long { return 0; } template <typename Context, typename Arg, typename... Args> constexpr auto encode_types() -> unsigned long long { return static_cast<unsigned>(stored_type_constant<Arg, Context>::value) | (encode_types<Context, Args...>() << packed_arg_bits); } template <typename Context, typename... T, size_t NUM_ARGS = sizeof...(T)> constexpr auto make_descriptor() -> unsigned long long { return NUM_ARGS <= max_packed_args ? encode_types<Context, T...>() : is_unpacked_bit | NUM_ARGS; } template <typename Context, int NUM_ARGS> using arg_t = conditional_t<NUM_ARGS <= max_packed_args, value<Context>, basic_format_arg<Context>>; template <typename Context, int NUM_ARGS, int NUM_NAMED_ARGS, unsigned long long DESC> struct named_arg_store { // args_[0].named_args points to named_args to avoid bloating format_args. arg_t<Context, NUM_ARGS> args[1 + NUM_ARGS]; named_arg_info<typename Context::char_type> named_args[NUM_NAMED_ARGS]; template <typename... T> FMT_CONSTEXPR FMT_ALWAYS_INLINE named_arg_store(T&... values) : args{{named_args, NUM_NAMED_ARGS}, values...} { int arg_index = 0, named_arg_index = 0; FMT_APPLY_VARIADIC( init_named_arg(named_args, arg_index, named_arg_index, values)); } named_arg_store(named_arg_store&& rhs) { args[0] = {named_args, NUM_NAMED_ARGS}; for (size_t i = 1; i < sizeof(args) / sizeof(*args); ++i) args[i] = rhs.args[i]; for (size_t i = 0; i < NUM_NAMED_ARGS; ++i) named_args[i] = rhs.named_args[i]; } named_arg_store(const named_arg_store& rhs) = delete; named_arg_store& operator=(const named_arg_store& rhs) = delete; named_arg_store& operator=(named_arg_store&& rhs) = delete; operator const arg_t<Context, NUM_ARGS>*() const { return args + 1; } }; // An array of references to arguments. It can be implicitly converted to // `basic_format_args` for passing into type-erased formatting functions // such as `vformat`. It is a plain struct to reduce binary size in debug mode. template <typename Context, int NUM_ARGS, int NUM_NAMED_ARGS, unsigned long long DESC> struct format_arg_store { // +1 to workaround a bug in gcc 7.5 that causes duplicated-branches warning. using type = conditional_t<NUM_NAMED_ARGS == 0, arg_t<Context, NUM_ARGS>[max_of(1, NUM_ARGS)], named_arg_store<Context, NUM_ARGS, NUM_NAMED_ARGS, DESC>>; type args; }; // TYPE can be different from type_constant<T>, e.g. for __float128. template <typename T, typename Char, type TYPE> struct native_formatter { private: dynamic_format_specs<Char> specs_; public: using nonlocking = void; FMT_CONSTEXPR auto parse(parse_context<Char>& ctx) -> const Char* { if (ctx.begin() == ctx.end() || *ctx.begin() == '}') return ctx.begin(); auto end = parse_format_specs(ctx.begin(), ctx.end(), specs_, ctx, TYPE); if (const_check(TYPE == type::char_type)) check_char_specs(specs_); return end; } template <type U = TYPE, FMT_ENABLE_IF(U == type::string_type || U == type::cstring_type || U == type::char_type)> FMT_CONSTEXPR void set_debug_format(bool set = true) { specs_.set_type(set ? presentation_type::debug : presentation_type::none); } FMT_PRAGMA_CLANG(diagnostic ignored "-Wundefined-inline") template <typename FormatContext> FMT_CONSTEXPR auto format(const T& val, FormatContext& ctx) const -> decltype(ctx.out()); }; template <typename T, typename Enable = void> struct locking : bool_constant<mapped_type_constant<T>::value == type::custom_type> {}; template <typename T> struct locking<T, void_t<typename formatter<remove_cvref_t<T>>::nonlocking>> : std::false_type {}; template <typename T = int> FMT_CONSTEXPR inline auto is_locking() -> bool { return locking<T>::value; } template <typename T1, typename T2, typename... Tail> FMT_CONSTEXPR inline auto is_locking() -> bool { return locking<T1>::value || is_locking<T2, Tail...>(); } FMT_API void vformat_to(buffer<char>& buf, string_view fmt, format_args args, locale_ref loc = {}); #if FMT_WIN32 FMT_API void vprint_mojibake(FILE*, string_view, format_args, bool); #else // format_args is passed by reference since it is defined later. inline void vprint_mojibake(FILE*, string_view, const format_args&, bool) {} #endif } // namespace detail // The main public API. template <typename Char> FMT_CONSTEXPR void parse_context<Char>::do_check_arg_id(int arg_id) { // Argument id is only checked at compile time during parsing because // formatting has its own validation. if (detail::is_constant_evaluated() && use_constexpr_cast) { auto ctx = static_cast<detail::compile_parse_context<Char>*>(this); if (arg_id >= ctx->num_args()) report_error("argument not found"); } } template <typename Char> FMT_CONSTEXPR void parse_context<Char>::check_dynamic_spec(int arg_id) { using detail::compile_parse_context; if (detail::is_constant_evaluated() && use_constexpr_cast) static_cast<compile_parse_context<Char>*>(this)->check_dynamic_spec(arg_id); } FMT_BEGIN_EXPORT // An output iterator that appends to a buffer. It is used instead of // back_insert_iterator to reduce symbol sizes and avoid <iterator> dependency. template <typename T> class basic_appender { protected: detail::buffer<T>* container; public: using container_type = detail::buffer<T>; FMT_CONSTEXPR basic_appender(detail::buffer<T>& buf) : container(&buf) {} FMT_CONSTEXPR20 auto operator=(T c) -> basic_appender& { container->push_back(c); return *this; } FMT_CONSTEXPR20 auto operator*() -> basic_appender& { return *this; } FMT_CONSTEXPR20 auto operator++() -> basic_appender& { return *this; } FMT_CONSTEXPR20 auto operator++(int) -> basic_appender { return *this; } }; // A formatting argument. Context is a template parameter for the compiled API // where output can be unbuffered. template <typename Context> class basic_format_arg { private: detail::value<Context> value_; detail::type type_; friend class basic_format_args<Context>; using char_type = typename Context::char_type; public: class handle { private: detail::custom_value<Context> custom_; public: explicit handle(detail::custom_value<Context> custom) : custom_(custom) {} void format(parse_context<char_type>& parse_ctx, Context& ctx) const { custom_.format(custom_.value, parse_ctx, ctx); } }; constexpr basic_format_arg() : type_(detail::type::none_type) {} basic_format_arg(const detail::named_arg_info<char_type>* args, size_t size) : value_(args, size) {} template <typename T> basic_format_arg(T&& val) : value_(val), type_(detail::stored_type_constant<T, Context>::value) {} constexpr explicit operator bool() const noexcept { return type_ != detail::type::none_type; } auto type() const -> detail::type { return type_; } /** * Visits an argument dispatching to the appropriate visit method based on * the argument type. For example, if the argument type is `double` then * `vis(value)` will be called with the value of type `double`. */ template <typename Visitor> FMT_CONSTEXPR FMT_INLINE auto visit(Visitor&& vis) const -> decltype(vis(0)) { using detail::map; switch (type_) { case detail::type::none_type: break; case detail::type::int_type: return vis(value_.int_value); case detail::type::uint_type: return vis(value_.uint_value); case detail::type::long_long_type: return vis(value_.long_long_value); case detail::type::ulong_long_type: return vis(value_.ulong_long_value); case detail::type::int128_type: return vis(map(value_.int128_value)); case detail::type::uint128_type: return vis(map(value_.uint128_value)); case detail::type::bool_type: return vis(value_.bool_value); case detail::type::char_type: return vis(value_.char_value); case detail::type::float_type: return vis(value_.float_value); case detail::type::double_type: return vis(value_.double_value); case detail::type::long_double_type: return vis(value_.long_double_value); case detail::type::cstring_type: return vis(value_.string.data); case detail::type::string_type: return vis(value_.string.str()); case detail::type::pointer_type: return vis(value_.pointer); case detail::type::custom_type: return vis(handle(value_.custom)); } return vis(monostate()); } auto format_custom(const char_type* parse_begin, parse_context<char_type>& parse_ctx, Context& ctx) -> bool { if (type_ != detail::type::custom_type) return false; parse_ctx.advance_to(parse_begin); value_.custom.format(value_.custom.value, parse_ctx, ctx); return true; } }; /** * A view of a collection of formatting arguments. To avoid lifetime issues it * should only be used as a parameter type in type-erased functions such as * `vformat`: * * void vlog(fmt::string_view fmt, fmt::format_args args); // OK * fmt::format_args args = fmt::make_format_args(); // Dangling reference */ template <typename Context> class basic_format_args { private: // A descriptor that contains information about formatting arguments. // If the number of arguments is less or equal to max_packed_args then // argument types are passed in the descriptor. This reduces binary code size // per formatting function call. unsigned long long desc_; union { // If is_packed() returns true then argument values are stored in values_; // otherwise they are stored in args_. This is done to improve cache // locality and reduce compiled code size since storing larger objects // may require more code (at least on x86-64) even if the same amount of // data is actually copied to stack. It saves ~10% on the bloat test. const detail::value<Context>* values_; const basic_format_arg<Context>* args_; }; constexpr auto is_packed() const -> bool { return (desc_ & detail::is_unpacked_bit) == 0; } constexpr auto has_named_args() const -> bool { return (desc_ & detail::has_named_args_bit) != 0; } FMT_CONSTEXPR auto type(int index) const -> detail::type { int shift = index * detail::packed_arg_bits; unsigned mask = (1 << detail::packed_arg_bits) - 1; return static_cast<detail::type>((desc_ >> shift) & mask); } template <int NUM_ARGS, int NUM_NAMED_ARGS, unsigned long long DESC> using store = detail::format_arg_store<Context, NUM_ARGS, NUM_NAMED_ARGS, DESC>; public: using format_arg = basic_format_arg<Context>; constexpr basic_format_args() : desc_(0), args_(nullptr) {} /// Constructs a `basic_format_args` object from `format_arg_store`. template <int NUM_ARGS, int NUM_NAMED_ARGS, unsigned long long DESC, FMT_ENABLE_IF(NUM_ARGS <= detail::max_packed_args)> constexpr FMT_ALWAYS_INLINE basic_format_args( const store<NUM_ARGS, NUM_NAMED_ARGS, DESC>& s) : desc_(DESC | (NUM_NAMED_ARGS != 0 ? +detail::has_named_args_bit : 0)), values_(s.args) {} template <int NUM_ARGS, int NUM_NAMED_ARGS, unsigned long long DESC, FMT_ENABLE_IF(NUM_ARGS > detail::max_packed_args)> constexpr basic_format_args(const store<NUM_ARGS, NUM_NAMED_ARGS, DESC>& s) : desc_(DESC | (NUM_NAMED_ARGS != 0 ? +detail::has_named_args_bit : 0)), args_(s.args) {} /// Constructs a `basic_format_args` object from a dynamic list of arguments. constexpr basic_format_args(const format_arg* args, int count, bool has_named = false) : desc_(detail::is_unpacked_bit | detail::to_unsigned(count) | (has_named ? +detail::has_named_args_bit : 0)), args_(args) {} /// Returns the argument with the specified id. FMT_CONSTEXPR auto get(int id) const -> format_arg { auto arg = format_arg(); if (!is_packed()) { if (id < max_size()) arg = args_[id]; return arg; } if (static_cast<unsigned>(id) >= detail::max_packed_args) return arg; arg.type_ = type(id); if (arg.type_ != detail::type::none_type) arg.value_ = values_[id]; return arg; } template <typename Char> auto get(basic_string_view<Char> name) const -> format_arg { int id = get_id(name); return id >= 0 ? get(id) : format_arg(); } template <typename Char> FMT_CONSTEXPR auto get_id(basic_string_view<Char> name) const -> int { if (!has_named_args()) return -1; const auto& named_args = (is_packed() ? values_[-1] : args_[-1].value_).named_args; for (size_t i = 0; i < named_args.size; ++i) { if (named_args.data[i].name == name) return named_args.data[i].id; } return -1; } auto max_size() const -> int { unsigned long long max_packed = detail::max_packed_args; return static_cast<int>(is_packed() ? max_packed : desc_ & ~detail::is_unpacked_bit); } }; // A formatting context. class context { private: appender out_; format_args args_; FMT_NO_UNIQUE_ADDRESS detail::locale_ref loc_; public: /// The character type for the output. using char_type = char; using iterator = appender; using format_arg = basic_format_arg<context>; using parse_context_type FMT_DEPRECATED = parse_context<>; template <typename T> using formatter_type FMT_DEPRECATED = formatter<T>; enum { builtin_types = FMT_BUILTIN_TYPES }; /// Constructs a `context` object. References to the arguments are stored /// in the object so make sure they have appropriate lifetimes. FMT_CONSTEXPR context(iterator out, format_args args, detail::locale_ref loc = {}) : out_(out), args_(args), loc_(loc) {} context(context&&) = default; context(const context&) = delete; void operator=(const context&) = delete; FMT_CONSTEXPR auto arg(int id) const -> format_arg { return args_.get(id); } inline auto arg(string_view name) const -> format_arg { return args_.get(name); } FMT_CONSTEXPR auto arg_id(string_view name) const -> int { return args_.get_id(name); } auto args() const -> const format_args& { return args_; } // Returns an iterator to the beginning of the output range. FMT_CONSTEXPR auto out() const -> iterator { return out_; } // Advances the begin iterator to `it`. FMT_CONSTEXPR void advance_to(iterator) {} FMT_CONSTEXPR auto locale() const -> detail::locale_ref { return loc_; } }; template <typename Char = char> struct runtime_format_string { basic_string_view<Char> str; }; /** * Creates a runtime format string. * * **Example**: * * // Check format string at runtime instead of compile-time. * fmt::print(fmt::runtime("{:d}"), "I am not a number"); */ inline auto runtime(string_view s) -> runtime_format_string<> { return {{s}}; } /// A compile-time format string. Use `format_string` in the public API to /// prevent type deduction. template <typename... T> struct fstring { private: static constexpr int num_static_named_args = detail::count_static_named_args<T...>(); using checker = detail::format_string_checker< char, static_cast<int>(sizeof...(T)), num_static_named_args, num_static_named_args != detail::count_named_args<T...>()>; using arg_pack = detail::arg_pack<T...>; public: string_view str; using t = fstring; // Reports a compile-time error if S is not a valid format string for T. template <size_t N> FMT_CONSTEVAL FMT_ALWAYS_INLINE fstring(const char (&s)[N]) : str(s, N - 1) { using namespace detail; static_assert(count<(std::is_base_of<view, remove_reference_t<T>>::value && std::is_reference<T>::value)...>() == 0, "passing views as lvalues is disallowed"); if (FMT_USE_CONSTEVAL) parse_format_string<char>(s, checker(s, arg_pack())); #ifdef FMT_ENFORCE_COMPILE_STRING static_assert( FMT_USE_CONSTEVAL && sizeof(s) != 0, "FMT_ENFORCE_COMPILE_STRING requires format strings to use FMT_STRING"); #endif } template <typename S, FMT_ENABLE_IF(std::is_convertible<const S&, string_view>::value)> FMT_CONSTEVAL FMT_ALWAYS_INLINE fstring(const S& s) : str(s) { auto sv = string_view(str); if (FMT_USE_CONSTEVAL) detail::parse_format_string<char>(sv, checker(sv, arg_pack())); #ifdef FMT_ENFORCE_COMPILE_STRING static_assert( FMT_USE_CONSTEVAL && sizeof(s) != 0, "FMT_ENFORCE_COMPILE_STRING requires format strings to use FMT_STRING"); #endif } template <typename S, FMT_ENABLE_IF(std::is_base_of<detail::compile_string, S>::value&& std::is_same<typename S::char_type, char>::value)> FMT_ALWAYS_INLINE fstring(const S&) : str(S()) { FMT_CONSTEXPR auto sv = string_view(S()); FMT_CONSTEXPR int unused = (parse_format_string(sv, checker(sv, arg_pack())), 0); detail::ignore_unused(unused); } fstring(runtime_format_string<> fmt) : str(fmt.str) {} // Returning by reference generates better code in debug mode. FMT_ALWAYS_INLINE operator const string_view&() const { return str; } auto get() const -> string_view { return str; } }; template <typename... T> using format_string = typename fstring<T...>::t; template <typename T, typename Char = char> using is_formattable = bool_constant<!std::is_same< detail::mapped_t<conditional_t<std::is_void<T>::value, int*, T>, Char>, void>::value>; #ifdef __cpp_concepts template <typename T, typename Char = char> concept formattable = is_formattable<remove_reference_t<T>, Char>::value; #endif template <typename T, typename Char> using has_formatter FMT_DEPRECATED = std::is_constructible<formatter<T, Char>>; // A formatter specialization for natively supported types. template <typename T, typename Char> struct formatter<T, Char, enable_if_t<detail::type_constant<T, Char>::value != detail::type::custom_type>> : detail::native_formatter<T, Char, detail::type_constant<T, Char>::value> { }; /** * Constructs an object that stores references to arguments and can be * implicitly converted to `format_args`. `Context` can be omitted in which case * it defaults to `context`. See `arg` for lifetime considerations. */ // Take arguments by lvalue references to avoid some lifetime issues, e.g. // auto args = make_format_args(std::string()); template <typename Context = context, typename... T, int NUM_ARGS = sizeof...(T), int NUM_NAMED_ARGS = detail::count_named_args<T...>(), unsigned long long DESC = detail::make_descriptor<Context, T...>()> constexpr FMT_ALWAYS_INLINE auto make_format_args(T&... args) -> detail::format_arg_store<Context, NUM_ARGS, NUM_NAMED_ARGS, DESC> { // Suppress warnings for pathological types convertible to detail::value. FMT_PRAGMA_GCC(diagnostic ignored "-Wconversion") return {{args...}}; } template <typename... T> using vargs = detail::format_arg_store<context, sizeof...(T), detail::count_named_args<T...>(), detail::make_descriptor<context, T...>()>; /** * Returns a named argument to be used in a formatting function. * It should only be used in a call to a formatting function. * * **Example**: * * fmt::print("The answer is {answer}.", fmt::arg("answer", 42)); */ template <typename Char, typename T> inline auto arg(const Char* name, const T& arg) -> detail::named_arg<Char, T> { return {name, arg}; } /// Formats a string and writes the output to `out`. template <typename OutputIt, FMT_ENABLE_IF(detail::is_output_iterator<remove_cvref_t<OutputIt>, char>::value)> auto vformat_to(OutputIt&& out, string_view fmt, format_args args) -> remove_cvref_t<OutputIt> { auto&& buf = detail::get_buffer<char>(out); detail::vformat_to(buf, fmt, args, {}); return detail::get_iterator(buf, out); } /** * Formats `args` according to specifications in `fmt`, writes the result to * the output iterator `out` and returns the iterator past the end of the output * range. `format_to` does not append a terminating null character. * * **Example**: * * auto out = std::vector<char>(); * fmt::format_to(std::back_inserter(out), "{}", 42); */ template <typename OutputIt, typename... T, FMT_ENABLE_IF(detail::is_output_iterator<remove_cvref_t<OutputIt>, char>::value)> FMT_INLINE auto format_to(OutputIt&& out, format_string<T...> fmt, T&&... args) -> remove_cvref_t<OutputIt> { return vformat_to(out, fmt.str, vargs<T...>{{args...}}); } template <typename OutputIt> struct format_to_n_result { /// Iterator past the end of the output range. OutputIt out; /// Total (not truncated) output size. size_t size; }; template <typename OutputIt, typename... T, FMT_ENABLE_IF(detail::is_output_iterator<OutputIt, char>::value)> auto vformat_to_n(OutputIt out, size_t n, string_view fmt, format_args args) -> format_to_n_result<OutputIt> { using traits = detail::fixed_buffer_traits; auto buf = detail::iterator_buffer<OutputIt, char, traits>(out, n); detail::vformat_to(buf, fmt, args, {}); return {buf.out(), buf.count()}; } /** * Formats `args` according to specifications in `fmt`, writes up to `n` * characters of the result to the output iterator `out` and returns the total * (not truncated) output size and the iterator past the end of the output * range. `format_to_n` does not append a terminating null character. */ template <typename OutputIt, typename... T, FMT_ENABLE_IF(detail::is_output_iterator<OutputIt, char>::value)> FMT_INLINE auto format_to_n(OutputIt out, size_t n, format_string<T...> fmt, T&&... args) -> format_to_n_result<OutputIt> { return vformat_to_n(out, n, fmt.str, vargs<T...>{{args...}}); } struct format_to_result { /// Pointer to just after the last successful write in the array. char* out; /// Specifies if the output was truncated. bool truncated; FMT_CONSTEXPR operator char*() const { // Report truncation to prevent silent data loss. if (truncated) report_error("output is truncated"); return out; } }; template <size_t N> auto vformat_to(char (&out)[N], string_view fmt, format_args args) -> format_to_result { auto result = vformat_to_n(out, N, fmt, args); return {result.out, result.size > N}; } template <size_t N, typename... T> FMT_INLINE auto format_to(char (&out)[N], format_string<T...> fmt, T&&... args) -> format_to_result { auto result = vformat_to_n(out, N, fmt.str, vargs<T...>{{args...}}); return {result.out, result.size > N}; } /// Returns the number of chars in the output of `format(fmt, args...)`. template <typename... T> FMT_NODISCARD FMT_INLINE auto formatted_size(format_string<T...> fmt, T&&... args) -> size_t { auto buf = detail::counting_buffer<>(); detail::vformat_to(buf, fmt.str, vargs<T...>{{args...}}, {}); return buf.count(); } FMT_API void vprint(string_view fmt, format_args args); FMT_API void vprint(FILE* f, string_view fmt, format_args args); FMT_API void vprintln(FILE* f, string_view fmt, format_args args); FMT_API void vprint_buffered(FILE* f, string_view fmt, format_args args); /** * Formats `args` according to specifications in `fmt` and writes the output * to `stdout`. * * **Example**: * * fmt::print("The answer is {}.", 42); */ template <typename... T> FMT_INLINE void print(format_string<T...> fmt, T&&... args) { vargs<T...> va = {{args...}}; if (detail::const_check(!detail::use_utf8)) return detail::vprint_mojibake(stdout, fmt.str, va, false); return detail::is_locking<T...>() ? vprint_buffered(stdout, fmt.str, va) : vprint(fmt.str, va); } /** * Formats `args` according to specifications in `fmt` and writes the * output to the file `f`. * * **Example**: * * fmt::print(stderr, "Don't {}!", "panic"); */ template <typename... T> FMT_INLINE void print(FILE* f, format_string<T...> fmt, T&&... args) { vargs<T...> va = {{args...}}; if (detail::const_check(!detail::use_utf8)) return detail::vprint_mojibake(f, fmt.str, va, false); return detail::is_locking<T...>() ? vprint_buffered(f, fmt.str, va) : vprint(f, fmt.str, va); } /// Formats `args` according to specifications in `fmt` and writes the output /// to the file `f` followed by a newline. template <typename... T> FMT_INLINE void println(FILE* f, format_string<T...> fmt, T&&... args) { vargs<T...> va = {{args...}}; return detail::const_check(detail::use_utf8) ? vprintln(f, fmt.str, va) : detail::vprint_mojibake(f, fmt.str, va, true); } /// Formats `args` according to specifications in `fmt` and writes the output /// to `stdout` followed by a newline. template <typename... T> FMT_INLINE void println(format_string<T...> fmt, T&&... args) { return fmt::println(stdout, fmt, static_cast<T&&>(args)...); } FMT_END_EXPORT FMT_PRAGMA_CLANG(diagnostic pop) FMT_PRAGMA_GCC(pop_options) FMT_END_NAMESPACE #ifdef FMT_HEADER_ONLY # include "format.h" #endif #endif // FMT_BASE_H_ ������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/vendor/fmt/chrono.h������������������������������������������������������������������0000664�0000000�0000000�00000234246�14771603147�0017106�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������// Formatting library for C++ - chrono support // // Copyright (c) 2012 - present, Victor Zverovich // All rights reserved. // // For the license information refer to format.h. #ifndef FMT_CHRONO_H_ #define FMT_CHRONO_H_ #ifndef FMT_MODULE # include <algorithm> # include <chrono> # include <cmath> // std::isfinite # include <cstring> // std::memcpy # include <ctime> # include <iterator> # include <locale> # include <ostream> # include <type_traits> #endif #include "format.h" namespace fmt_detail { struct time_zone { template <typename Duration, typename T> auto to_sys(T) -> std::chrono::time_point<std::chrono::system_clock, Duration> { return {}; } }; template <typename... T> inline auto current_zone(T...) -> time_zone* { return nullptr; } template <typename... T> inline void _tzset(T...) {} } // namespace fmt_detail FMT_BEGIN_NAMESPACE // Enable safe chrono durations, unless explicitly disabled. #ifndef FMT_SAFE_DURATION_CAST # define FMT_SAFE_DURATION_CAST 1 #endif #if FMT_SAFE_DURATION_CAST // For conversion between std::chrono::durations without undefined // behaviour or erroneous results. // This is a stripped down version of duration_cast, for inclusion in fmt. // See https://github.com/pauldreik/safe_duration_cast // // Copyright Paul Dreik 2019 namespace safe_duration_cast { template <typename To, typename From, FMT_ENABLE_IF(!std::is_same<From, To>::value && std::numeric_limits<From>::is_signed == std::numeric_limits<To>::is_signed)> FMT_CONSTEXPR auto lossless_integral_conversion(const From from, int& ec) -> To { ec = 0; using F = std::numeric_limits<From>; using T = std::numeric_limits<To>; static_assert(F::is_integer, "From must be integral"); static_assert(T::is_integer, "To must be integral"); // A and B are both signed, or both unsigned. if (detail::const_check(F::digits <= T::digits)) { // From fits in To without any problem. } else { // From does not always fit in To, resort to a dynamic check. if (from < (T::min)() || from > (T::max)()) { // outside range. ec = 1; return {}; } } return static_cast<To>(from); } /// Converts From to To, without loss. If the dynamic value of from /// can't be converted to To without loss, ec is set. template <typename To, typename From, FMT_ENABLE_IF(!std::is_same<From, To>::value && std::numeric_limits<From>::is_signed != std::numeric_limits<To>::is_signed)> FMT_CONSTEXPR auto lossless_integral_conversion(const From from, int& ec) -> To { ec = 0; using F = std::numeric_limits<From>; using T = std::numeric_limits<To>; static_assert(F::is_integer, "From must be integral"); static_assert(T::is_integer, "To must be integral"); if (detail::const_check(F::is_signed && !T::is_signed)) { // From may be negative, not allowed! if (fmt::detail::is_negative(from)) { ec = 1; return {}; } // From is positive. Can it always fit in To? if (detail::const_check(F::digits > T::digits) && from > static_cast<From>(detail::max_value<To>())) { ec = 1; return {}; } } if (detail::const_check(!F::is_signed && T::is_signed && F::digits >= T::digits) && from > static_cast<From>(detail::max_value<To>())) { ec = 1; return {}; } return static_cast<To>(from); // Lossless conversion. } template <typename To, typename From, FMT_ENABLE_IF(std::is_same<From, To>::value)> FMT_CONSTEXPR auto lossless_integral_conversion(const From from, int& ec) -> To { ec = 0; return from; } // function // clang-format off /** * converts From to To if possible, otherwise ec is set. * * input | output * ---------------------------------|--------------- * NaN | NaN * Inf | Inf * normal, fits in output | converted (possibly lossy) * normal, does not fit in output | ec is set * subnormal | best effort * -Inf | -Inf */ // clang-format on template <typename To, typename From, FMT_ENABLE_IF(!std::is_same<From, To>::value)> FMT_CONSTEXPR auto safe_float_conversion(const From from, int& ec) -> To { ec = 0; using T = std::numeric_limits<To>; static_assert(std::is_floating_point<From>::value, "From must be floating"); static_assert(std::is_floating_point<To>::value, "To must be floating"); // catch the only happy case if (std::isfinite(from)) { if (from >= T::lowest() && from <= (T::max)()) { return static_cast<To>(from); } // not within range. ec = 1; return {}; } // nan and inf will be preserved return static_cast<To>(from); } // function template <typename To, typename From, FMT_ENABLE_IF(std::is_same<From, To>::value)> FMT_CONSTEXPR auto safe_float_conversion(const From from, int& ec) -> To { ec = 0; static_assert(std::is_floating_point<From>::value, "From must be floating"); return from; } /// Safe duration_cast between floating point durations template <typename To, typename FromRep, typename FromPeriod, FMT_ENABLE_IF(std::is_floating_point<FromRep>::value), FMT_ENABLE_IF(std::is_floating_point<typename To::rep>::value)> auto safe_duration_cast(std::chrono::duration<FromRep, FromPeriod> from, int& ec) -> To { using From = std::chrono::duration<FromRep, FromPeriod>; ec = 0; if (std::isnan(from.count())) { // nan in, gives nan out. easy. return To{std::numeric_limits<typename To::rep>::quiet_NaN()}; } // maybe we should also check if from is denormal, and decide what to do about // it. // +-inf should be preserved. if (std::isinf(from.count())) { return To{from.count()}; } // the basic idea is that we need to convert from count() in the from type // to count() in the To type, by multiplying it with this: struct Factor : std::ratio_divide<typename From::period, typename To::period> {}; static_assert(Factor::num > 0, "num must be positive"); static_assert(Factor::den > 0, "den must be positive"); // the conversion is like this: multiply from.count() with Factor::num // /Factor::den and convert it to To::rep, all this without // overflow/underflow. let's start by finding a suitable type that can hold // both To, From and Factor::num using IntermediateRep = typename std::common_type<typename From::rep, typename To::rep, decltype(Factor::num)>::type; // force conversion of From::rep -> IntermediateRep to be safe, // even if it will never happen be narrowing in this context. IntermediateRep count = safe_float_conversion<IntermediateRep>(from.count(), ec); if (ec) { return {}; } // multiply with Factor::num without overflow or underflow if (detail::const_check(Factor::num != 1)) { constexpr auto max1 = detail::max_value<IntermediateRep>() / static_cast<IntermediateRep>(Factor::num); if (count > max1) { ec = 1; return {}; } constexpr auto min1 = std::numeric_limits<IntermediateRep>::lowest() / static_cast<IntermediateRep>(Factor::num); if (count < min1) { ec = 1; return {}; } count *= static_cast<IntermediateRep>(Factor::num); } // this can't go wrong, right? den>0 is checked earlier. if (detail::const_check(Factor::den != 1)) { using common_t = typename std::common_type<IntermediateRep, intmax_t>::type; count /= static_cast<common_t>(Factor::den); } // convert to the to type, safely using ToRep = typename To::rep; const ToRep tocount = safe_float_conversion<ToRep>(count, ec); if (ec) { return {}; } return To{tocount}; } } // namespace safe_duration_cast #endif namespace detail { // Check if std::chrono::utc_time is available. #ifdef FMT_USE_UTC_TIME // Use the provided definition. #elif defined(__cpp_lib_chrono) # define FMT_USE_UTC_TIME (__cpp_lib_chrono >= 201907L) #else # define FMT_USE_UTC_TIME 0 #endif #if FMT_USE_UTC_TIME using utc_clock = std::chrono::utc_clock; #else struct utc_clock { template <typename T> void to_sys(T); }; #endif // Check if std::chrono::local_time is available. #ifdef FMT_USE_LOCAL_TIME // Use the provided definition. #elif defined(__cpp_lib_chrono) # define FMT_USE_LOCAL_TIME (__cpp_lib_chrono >= 201907L) #else # define FMT_USE_LOCAL_TIME 0 #endif #if FMT_USE_LOCAL_TIME using local_t = std::chrono::local_t; #else struct local_t {}; #endif } // namespace detail template <typename Duration> using sys_time = std::chrono::time_point<std::chrono::system_clock, Duration>; template <typename Duration> using utc_time = std::chrono::time_point<detail::utc_clock, Duration>; template <class Duration> using local_time = std::chrono::time_point<detail::local_t, Duration>; namespace detail { // Prevents expansion of a preceding token as a function-style macro. // Usage: f FMT_NOMACRO() #define FMT_NOMACRO template <typename T = void> struct null {}; inline auto localtime_r FMT_NOMACRO(...) -> null<> { return null<>(); } inline auto localtime_s(...) -> null<> { return null<>(); } inline auto gmtime_r(...) -> null<> { return null<>(); } inline auto gmtime_s(...) -> null<> { return null<>(); } // It is defined here and not in ostream.h because the latter has expensive // includes. template <typename StreamBuf> class formatbuf : public StreamBuf { private: using char_type = typename StreamBuf::char_type; using streamsize = decltype(std::declval<StreamBuf>().sputn(nullptr, 0)); using int_type = typename StreamBuf::int_type; using traits_type = typename StreamBuf::traits_type; buffer<char_type>& buffer_; public: explicit formatbuf(buffer<char_type>& buf) : buffer_(buf) {} protected: // The put area is always empty. This makes the implementation simpler and has // the advantage that the streambuf and the buffer are always in sync and // sputc never writes into uninitialized memory. A disadvantage is that each // call to sputc always results in a (virtual) call to overflow. There is no // disadvantage here for sputn since this always results in a call to xsputn. auto overflow(int_type ch) -> int_type override { if (!traits_type::eq_int_type(ch, traits_type::eof())) buffer_.push_back(static_cast<char_type>(ch)); return ch; } auto xsputn(const char_type* s, streamsize count) -> streamsize override { buffer_.append(s, s + count); return count; } }; inline auto get_classic_locale() -> const std::locale& { static const auto& locale = std::locale::classic(); return locale; } template <typename CodeUnit> struct codecvt_result { static constexpr const size_t max_size = 32; CodeUnit buf[max_size]; CodeUnit* end; }; template <typename CodeUnit> void write_codecvt(codecvt_result<CodeUnit>& out, string_view in, const std::locale& loc) { FMT_PRAGMA_CLANG(diagnostic push) FMT_PRAGMA_CLANG(diagnostic ignored "-Wdeprecated") auto& f = std::use_facet<std::codecvt<CodeUnit, char, std::mbstate_t>>(loc); FMT_PRAGMA_CLANG(diagnostic pop) auto mb = std::mbstate_t(); const char* from_next = nullptr; auto result = f.in(mb, in.begin(), in.end(), from_next, std::begin(out.buf), std::end(out.buf), out.end); if (result != std::codecvt_base::ok) FMT_THROW(format_error("failed to format time")); } template <typename OutputIt> auto write_encoded_tm_str(OutputIt out, string_view in, const std::locale& loc) -> OutputIt { if (const_check(detail::use_utf8) && loc != get_classic_locale()) { // char16_t and char32_t codecvts are broken in MSVC (linkage errors) and // gcc-4. #if FMT_MSC_VERSION != 0 || \ (defined(__GLIBCXX__) && \ (!defined(_GLIBCXX_USE_DUAL_ABI) || _GLIBCXX_USE_DUAL_ABI == 0)) // The _GLIBCXX_USE_DUAL_ABI macro is always defined in libstdc++ from gcc-5 // and newer. using code_unit = wchar_t; #else using code_unit = char32_t; #endif using unit_t = codecvt_result<code_unit>; unit_t unit; write_codecvt(unit, in, loc); // In UTF-8 is used one to four one-byte code units. auto u = to_utf8<code_unit, basic_memory_buffer<char, unit_t::max_size * 4>>(); if (!u.convert({unit.buf, to_unsigned(unit.end - unit.buf)})) FMT_THROW(format_error("failed to format time")); return copy<char>(u.c_str(), u.c_str() + u.size(), out); } return copy<char>(in.data(), in.data() + in.size(), out); } template <typename Char, typename OutputIt, FMT_ENABLE_IF(!std::is_same<Char, char>::value)> auto write_tm_str(OutputIt out, string_view sv, const std::locale& loc) -> OutputIt { codecvt_result<Char> unit; write_codecvt(unit, sv, loc); return copy<Char>(unit.buf, unit.end, out); } template <typename Char, typename OutputIt, FMT_ENABLE_IF(std::is_same<Char, char>::value)> auto write_tm_str(OutputIt out, string_view sv, const std::locale& loc) -> OutputIt { return write_encoded_tm_str(out, sv, loc); } template <typename Char> inline void do_write(buffer<Char>& buf, const std::tm& time, const std::locale& loc, char format, char modifier) { auto&& format_buf = formatbuf<std::basic_streambuf<Char>>(buf); auto&& os = std::basic_ostream<Char>(&format_buf); os.imbue(loc); const auto& facet = std::use_facet<std::time_put<Char>>(loc); auto end = facet.put(os, os, Char(' '), &time, format, modifier); if (end.failed()) FMT_THROW(format_error("failed to format time")); } template <typename Char, typename OutputIt, FMT_ENABLE_IF(!std::is_same<Char, char>::value)> auto write(OutputIt out, const std::tm& time, const std::locale& loc, char format, char modifier = 0) -> OutputIt { auto&& buf = get_buffer<Char>(out); do_write<Char>(buf, time, loc, format, modifier); return get_iterator(buf, out); } template <typename Char, typename OutputIt, FMT_ENABLE_IF(std::is_same<Char, char>::value)> auto write(OutputIt out, const std::tm& time, const std::locale& loc, char format, char modifier = 0) -> OutputIt { auto&& buf = basic_memory_buffer<Char>(); do_write<char>(buf, time, loc, format, modifier); return write_encoded_tm_str(out, string_view(buf.data(), buf.size()), loc); } template <typename Rep1, typename Rep2> struct is_same_arithmetic_type : public std::integral_constant<bool, (std::is_integral<Rep1>::value && std::is_integral<Rep2>::value) || (std::is_floating_point<Rep1>::value && std::is_floating_point<Rep2>::value)> { }; FMT_NORETURN inline void throw_duration_error() { FMT_THROW(format_error("cannot format duration")); } // Cast one integral duration to another with an overflow check. template <typename To, typename FromRep, typename FromPeriod, FMT_ENABLE_IF(std::is_integral<FromRep>::value&& std::is_integral<typename To::rep>::value)> auto duration_cast(std::chrono::duration<FromRep, FromPeriod> from) -> To { #if !FMT_SAFE_DURATION_CAST return std::chrono::duration_cast<To>(from); #else // The conversion factor: to.count() == factor * from.count(). using factor = std::ratio_divide<FromPeriod, typename To::period>; using common_rep = typename std::common_type<FromRep, typename To::rep, decltype(factor::num)>::type; int ec = 0; auto count = safe_duration_cast::lossless_integral_conversion<common_rep>( from.count(), ec); if (ec) throw_duration_error(); // Multiply from.count() by factor and check for overflow. if (const_check(factor::num != 1)) { if (count > max_value<common_rep>() / factor::num) throw_duration_error(); const auto min = (std::numeric_limits<common_rep>::min)() / factor::num; if (const_check(!std::is_unsigned<common_rep>::value) && count < min) throw_duration_error(); count *= factor::num; } if (const_check(factor::den != 1)) count /= factor::den; auto to = To(safe_duration_cast::lossless_integral_conversion<typename To::rep>( count, ec)); if (ec) throw_duration_error(); return to; #endif } template <typename To, typename FromRep, typename FromPeriod, FMT_ENABLE_IF(std::is_floating_point<FromRep>::value&& std::is_floating_point<typename To::rep>::value)> auto duration_cast(std::chrono::duration<FromRep, FromPeriod> from) -> To { #if FMT_SAFE_DURATION_CAST // Throwing version of safe_duration_cast is only available for // integer to integer or float to float casts. int ec; To to = safe_duration_cast::safe_duration_cast<To>(from, ec); if (ec) throw_duration_error(); return to; #else // Standard duration cast, may overflow. return std::chrono::duration_cast<To>(from); #endif } template < typename To, typename FromRep, typename FromPeriod, FMT_ENABLE_IF(!is_same_arithmetic_type<FromRep, typename To::rep>::value)> auto duration_cast(std::chrono::duration<FromRep, FromPeriod> from) -> To { // Mixed integer <-> float cast is not supported by safe_duration_cast. return std::chrono::duration_cast<To>(from); } template <typename Duration> auto to_time_t(sys_time<Duration> time_point) -> std::time_t { // Cannot use std::chrono::system_clock::to_time_t since this would first // require a cast to std::chrono::system_clock::time_point, which could // overflow. return detail::duration_cast<std::chrono::duration<std::time_t>>( time_point.time_since_epoch()) .count(); } // Workaround a bug in libstdc++ which sets __cpp_lib_chrono to 201907 without // providing current_zone(): https://github.com/fmtlib/fmt/issues/4160. template <typename T> FMT_CONSTEXPR auto has_current_zone() -> bool { using namespace std::chrono; using namespace fmt_detail; return !std::is_same<decltype(current_zone()), fmt_detail::time_zone*>::value; } } // namespace detail FMT_BEGIN_EXPORT /** * Converts given time since epoch as `std::time_t` value into calendar time, * expressed in local time. Unlike `std::localtime`, this function is * thread-safe on most platforms. */ inline auto localtime(std::time_t time) -> std::tm { struct dispatcher { std::time_t time_; std::tm tm_; inline dispatcher(std::time_t t) : time_(t) {} inline auto run() -> bool { using namespace fmt::detail; return handle(localtime_r(&time_, &tm_)); } inline auto handle(std::tm* tm) -> bool { return tm != nullptr; } inline auto handle(detail::null<>) -> bool { using namespace fmt::detail; return fallback(localtime_s(&tm_, &time_)); } inline auto fallback(int res) -> bool { return res == 0; } #if !FMT_MSC_VERSION inline auto fallback(detail::null<>) -> bool { using namespace fmt::detail; std::tm* tm = std::localtime(&time_); if (tm) tm_ = *tm; return tm != nullptr; } #endif }; dispatcher lt(time); // Too big time values may be unsupported. if (!lt.run()) FMT_THROW(format_error("time_t value out of range")); return lt.tm_; } #if FMT_USE_LOCAL_TIME template <typename Duration, FMT_ENABLE_IF(detail::has_current_zone<Duration>())> inline auto localtime(std::chrono::local_time<Duration> time) -> std::tm { using namespace std::chrono; using namespace fmt_detail; return localtime(detail::to_time_t(current_zone()->to_sys<Duration>(time))); } #endif /** * Converts given time since epoch as `std::time_t` value into calendar time, * expressed in Coordinated Universal Time (UTC). Unlike `std::gmtime`, this * function is thread-safe on most platforms. */ inline auto gmtime(std::time_t time) -> std::tm { struct dispatcher { std::time_t time_; std::tm tm_; inline dispatcher(std::time_t t) : time_(t) {} inline auto run() -> bool { using namespace fmt::detail; return handle(gmtime_r(&time_, &tm_)); } inline auto handle(std::tm* tm) -> bool { return tm != nullptr; } inline auto handle(detail::null<>) -> bool { using namespace fmt::detail; return fallback(gmtime_s(&tm_, &time_)); } inline auto fallback(int res) -> bool { return res == 0; } #if !FMT_MSC_VERSION inline auto fallback(detail::null<>) -> bool { std::tm* tm = std::gmtime(&time_); if (tm) tm_ = *tm; return tm != nullptr; } #endif }; auto gt = dispatcher(time); // Too big time values may be unsupported. if (!gt.run()) FMT_THROW(format_error("time_t value out of range")); return gt.tm_; } template <typename Duration> inline auto gmtime(sys_time<Duration> time_point) -> std::tm { return gmtime(detail::to_time_t(time_point)); } namespace detail { // Writes two-digit numbers a, b and c separated by sep to buf. // The method by Pavel Novikov based on // https://johnnylee-sde.github.io/Fast-unsigned-integer-to-time-string/. inline void write_digit2_separated(char* buf, unsigned a, unsigned b, unsigned c, char sep) { unsigned long long digits = a | (b << 24) | (static_cast<unsigned long long>(c) << 48); // Convert each value to BCD. // We have x = a * 10 + b and we want to convert it to BCD y = a * 16 + b. // The difference is // y - x = a * 6 // a can be found from x: // a = floor(x / 10) // then // y = x + a * 6 = x + floor(x / 10) * 6 // floor(x / 10) is (x * 205) >> 11 (needs 16 bits). digits += (((digits * 205) >> 11) & 0x000f00000f00000f) * 6; // Put low nibbles to high bytes and high nibbles to low bytes. digits = ((digits & 0x00f00000f00000f0) >> 4) | ((digits & 0x000f00000f00000f) << 8); auto usep = static_cast<unsigned long long>(sep); // Add ASCII '0' to each digit byte and insert separators. digits |= 0x3030003030003030 | (usep << 16) | (usep << 40); constexpr const size_t len = 8; if (const_check(is_big_endian())) { char tmp[len]; std::memcpy(tmp, &digits, len); std::reverse_copy(tmp, tmp + len, buf); } else { std::memcpy(buf, &digits, len); } } template <typename Period> FMT_CONSTEXPR inline auto get_units() -> const char* { if (std::is_same<Period, std::atto>::value) return "as"; if (std::is_same<Period, std::femto>::value) return "fs"; if (std::is_same<Period, std::pico>::value) return "ps"; if (std::is_same<Period, std::nano>::value) return "ns"; if (std::is_same<Period, std::micro>::value) return detail::use_utf8 ? "ТЕs" : "us"; if (std::is_same<Period, std::milli>::value) return "ms"; if (std::is_same<Period, std::centi>::value) return "cs"; if (std::is_same<Period, std::deci>::value) return "ds"; if (std::is_same<Period, std::ratio<1>>::value) return "s"; if (std::is_same<Period, std::deca>::value) return "das"; if (std::is_same<Period, std::hecto>::value) return "hs"; if (std::is_same<Period, std::kilo>::value) return "ks"; if (std::is_same<Period, std::mega>::value) return "Ms"; if (std::is_same<Period, std::giga>::value) return "Gs"; if (std::is_same<Period, std::tera>::value) return "Ts"; if (std::is_same<Period, std::peta>::value) return "Ps"; if (std::is_same<Period, std::exa>::value) return "Es"; if (std::is_same<Period, std::ratio<60>>::value) return "min"; if (std::is_same<Period, std::ratio<3600>>::value) return "h"; if (std::is_same<Period, std::ratio<86400>>::value) return "d"; return nullptr; } enum class numeric_system { standard, // Alternative numeric system, e.g. хфКŒ instead of 12 in ja_JP locale. alternative }; // Glibc extensions for formatting numeric values. enum class pad_type { // Pad a numeric result string with zeros (the default). zero, // Do not pad a numeric result string. none, // Pad a numeric result string with spaces. space, }; template <typename OutputIt> auto write_padding(OutputIt out, pad_type pad, int width) -> OutputIt { if (pad == pad_type::none) return out; return detail::fill_n(out, width, pad == pad_type::space ? ' ' : '0'); } template <typename OutputIt> auto write_padding(OutputIt out, pad_type pad) -> OutputIt { if (pad != pad_type::none) *out++ = pad == pad_type::space ? ' ' : '0'; return out; } // Parses a put_time-like format string and invokes handler actions. template <typename Char, typename Handler> FMT_CONSTEXPR auto parse_chrono_format(const Char* begin, const Char* end, Handler&& handler) -> const Char* { if (begin == end || *begin == '}') return begin; if (*begin != '%') FMT_THROW(format_error("invalid format")); auto ptr = begin; while (ptr != end) { pad_type pad = pad_type::zero; auto c = *ptr; if (c == '}') break; if (c != '%') { ++ptr; continue; } if (begin != ptr) handler.on_text(begin, ptr); ++ptr; // consume '%' if (ptr == end) FMT_THROW(format_error("invalid format")); c = *ptr; switch (c) { case '_': pad = pad_type::space; ++ptr; break; case '-': pad = pad_type::none; ++ptr; break; } if (ptr == end) FMT_THROW(format_error("invalid format")); c = *ptr++; switch (c) { case '%': handler.on_text(ptr - 1, ptr); break; case 'n': { const Char newline[] = {'\n'}; handler.on_text(newline, newline + 1); break; } case 't': { const Char tab[] = {'\t'}; handler.on_text(tab, tab + 1); break; } // Year: case 'Y': handler.on_year(numeric_system::standard, pad); break; case 'y': handler.on_short_year(numeric_system::standard); break; case 'C': handler.on_century(numeric_system::standard); break; case 'G': handler.on_iso_week_based_year(); break; case 'g': handler.on_iso_week_based_short_year(); break; // Day of the week: case 'a': handler.on_abbr_weekday(); break; case 'A': handler.on_full_weekday(); break; case 'w': handler.on_dec0_weekday(numeric_system::standard); break; case 'u': handler.on_dec1_weekday(numeric_system::standard); break; // Month: case 'b': case 'h': handler.on_abbr_month(); break; case 'B': handler.on_full_month(); break; case 'm': handler.on_dec_month(numeric_system::standard, pad); break; // Day of the year/month: case 'U': handler.on_dec0_week_of_year(numeric_system::standard, pad); break; case 'W': handler.on_dec1_week_of_year(numeric_system::standard, pad); break; case 'V': handler.on_iso_week_of_year(numeric_system::standard, pad); break; case 'j': handler.on_day_of_year(pad); break; case 'd': handler.on_day_of_month(numeric_system::standard, pad); break; case 'e': handler.on_day_of_month(numeric_system::standard, pad_type::space); break; // Hour, minute, second: case 'H': handler.on_24_hour(numeric_system::standard, pad); break; case 'I': handler.on_12_hour(numeric_system::standard, pad); break; case 'M': handler.on_minute(numeric_system::standard, pad); break; case 'S': handler.on_second(numeric_system::standard, pad); break; // Other: case 'c': handler.on_datetime(numeric_system::standard); break; case 'x': handler.on_loc_date(numeric_system::standard); break; case 'X': handler.on_loc_time(numeric_system::standard); break; case 'D': handler.on_us_date(); break; case 'F': handler.on_iso_date(); break; case 'r': handler.on_12_hour_time(); break; case 'R': handler.on_24_hour_time(); break; case 'T': handler.on_iso_time(); break; case 'p': handler.on_am_pm(); break; case 'Q': handler.on_duration_value(); break; case 'q': handler.on_duration_unit(); break; case 'z': handler.on_utc_offset(numeric_system::standard); break; case 'Z': handler.on_tz_name(); break; // Alternative representation: case 'E': { if (ptr == end) FMT_THROW(format_error("invalid format")); c = *ptr++; switch (c) { case 'Y': handler.on_year(numeric_system::alternative, pad); break; case 'y': handler.on_offset_year(); break; case 'C': handler.on_century(numeric_system::alternative); break; case 'c': handler.on_datetime(numeric_system::alternative); break; case 'x': handler.on_loc_date(numeric_system::alternative); break; case 'X': handler.on_loc_time(numeric_system::alternative); break; case 'z': handler.on_utc_offset(numeric_system::alternative); break; default: FMT_THROW(format_error("invalid format")); } break; } case 'O': if (ptr == end) FMT_THROW(format_error("invalid format")); c = *ptr++; switch (c) { case 'y': handler.on_short_year(numeric_system::alternative); break; case 'm': handler.on_dec_month(numeric_system::alternative, pad); break; case 'U': handler.on_dec0_week_of_year(numeric_system::alternative, pad); break; case 'W': handler.on_dec1_week_of_year(numeric_system::alternative, pad); break; case 'V': handler.on_iso_week_of_year(numeric_system::alternative, pad); break; case 'd': handler.on_day_of_month(numeric_system::alternative, pad); break; case 'e': handler.on_day_of_month(numeric_system::alternative, pad_type::space); break; case 'w': handler.on_dec0_weekday(numeric_system::alternative); break; case 'u': handler.on_dec1_weekday(numeric_system::alternative); break; case 'H': handler.on_24_hour(numeric_system::alternative, pad); break; case 'I': handler.on_12_hour(numeric_system::alternative, pad); break; case 'M': handler.on_minute(numeric_system::alternative, pad); break; case 'S': handler.on_second(numeric_system::alternative, pad); break; case 'z': handler.on_utc_offset(numeric_system::alternative); break; default: FMT_THROW(format_error("invalid format")); } break; default: FMT_THROW(format_error("invalid format")); } begin = ptr; } if (begin != ptr) handler.on_text(begin, ptr); return ptr; } template <typename Derived> struct null_chrono_spec_handler { FMT_CONSTEXPR void unsupported() { static_cast<Derived*>(this)->unsupported(); } FMT_CONSTEXPR void on_year(numeric_system, pad_type) { unsupported(); } FMT_CONSTEXPR void on_short_year(numeric_system) { unsupported(); } FMT_CONSTEXPR void on_offset_year() { unsupported(); } FMT_CONSTEXPR void on_century(numeric_system) { unsupported(); } FMT_CONSTEXPR void on_iso_week_based_year() { unsupported(); } FMT_CONSTEXPR void on_iso_week_based_short_year() { unsupported(); } FMT_CONSTEXPR void on_abbr_weekday() { unsupported(); } FMT_CONSTEXPR void on_full_weekday() { unsupported(); } FMT_CONSTEXPR void on_dec0_weekday(numeric_system) { unsupported(); } FMT_CONSTEXPR void on_dec1_weekday(numeric_system) { unsupported(); } FMT_CONSTEXPR void on_abbr_month() { unsupported(); } FMT_CONSTEXPR void on_full_month() { unsupported(); } FMT_CONSTEXPR void on_dec_month(numeric_system, pad_type) { unsupported(); } FMT_CONSTEXPR void on_dec0_week_of_year(numeric_system, pad_type) { unsupported(); } FMT_CONSTEXPR void on_dec1_week_of_year(numeric_system, pad_type) { unsupported(); } FMT_CONSTEXPR void on_iso_week_of_year(numeric_system, pad_type) { unsupported(); } FMT_CONSTEXPR void on_day_of_year(pad_type) { unsupported(); } FMT_CONSTEXPR void on_day_of_month(numeric_system, pad_type) { unsupported(); } FMT_CONSTEXPR void on_24_hour(numeric_system) { unsupported(); } FMT_CONSTEXPR void on_12_hour(numeric_system) { unsupported(); } FMT_CONSTEXPR void on_minute(numeric_system) { unsupported(); } FMT_CONSTEXPR void on_second(numeric_system) { unsupported(); } FMT_CONSTEXPR void on_datetime(numeric_system) { unsupported(); } FMT_CONSTEXPR void on_loc_date(numeric_system) { unsupported(); } FMT_CONSTEXPR void on_loc_time(numeric_system) { unsupported(); } FMT_CONSTEXPR void on_us_date() { unsupported(); } FMT_CONSTEXPR void on_iso_date() { unsupported(); } FMT_CONSTEXPR void on_12_hour_time() { unsupported(); } FMT_CONSTEXPR void on_24_hour_time() { unsupported(); } FMT_CONSTEXPR void on_iso_time() { unsupported(); } FMT_CONSTEXPR void on_am_pm() { unsupported(); } FMT_CONSTEXPR void on_duration_value() { unsupported(); } FMT_CONSTEXPR void on_duration_unit() { unsupported(); } FMT_CONSTEXPR void on_utc_offset(numeric_system) { unsupported(); } FMT_CONSTEXPR void on_tz_name() { unsupported(); } }; struct tm_format_checker : null_chrono_spec_handler<tm_format_checker> { FMT_NORETURN inline void unsupported() { FMT_THROW(format_error("no format")); } template <typename Char> FMT_CONSTEXPR void on_text(const Char*, const Char*) {} FMT_CONSTEXPR void on_year(numeric_system, pad_type) {} FMT_CONSTEXPR void on_short_year(numeric_system) {} FMT_CONSTEXPR void on_offset_year() {} FMT_CONSTEXPR void on_century(numeric_system) {} FMT_CONSTEXPR void on_iso_week_based_year() {} FMT_CONSTEXPR void on_iso_week_based_short_year() {} FMT_CONSTEXPR void on_abbr_weekday() {} FMT_CONSTEXPR void on_full_weekday() {} FMT_CONSTEXPR void on_dec0_weekday(numeric_system) {} FMT_CONSTEXPR void on_dec1_weekday(numeric_system) {} FMT_CONSTEXPR void on_abbr_month() {} FMT_CONSTEXPR void on_full_month() {} FMT_CONSTEXPR void on_dec_month(numeric_system, pad_type) {} FMT_CONSTEXPR void on_dec0_week_of_year(numeric_system, pad_type) {} FMT_CONSTEXPR void on_dec1_week_of_year(numeric_system, pad_type) {} FMT_CONSTEXPR void on_iso_week_of_year(numeric_system, pad_type) {} FMT_CONSTEXPR void on_day_of_year(pad_type) {} FMT_CONSTEXPR void on_day_of_month(numeric_system, pad_type) {} FMT_CONSTEXPR void on_24_hour(numeric_system, pad_type) {} FMT_CONSTEXPR void on_12_hour(numeric_system, pad_type) {} FMT_CONSTEXPR void on_minute(numeric_system, pad_type) {} FMT_CONSTEXPR void on_second(numeric_system, pad_type) {} FMT_CONSTEXPR void on_datetime(numeric_system) {} FMT_CONSTEXPR void on_loc_date(numeric_system) {} FMT_CONSTEXPR void on_loc_time(numeric_system) {} FMT_CONSTEXPR void on_us_date() {} FMT_CONSTEXPR void on_iso_date() {} FMT_CONSTEXPR void on_12_hour_time() {} FMT_CONSTEXPR void on_24_hour_time() {} FMT_CONSTEXPR void on_iso_time() {} FMT_CONSTEXPR void on_am_pm() {} FMT_CONSTEXPR void on_utc_offset(numeric_system) {} FMT_CONSTEXPR void on_tz_name() {} }; inline auto tm_wday_full_name(int wday) -> const char* { static constexpr const char* full_name_list[] = { "Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"}; return wday >= 0 && wday <= 6 ? full_name_list[wday] : "?"; } inline auto tm_wday_short_name(int wday) -> const char* { static constexpr const char* short_name_list[] = {"Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"}; return wday >= 0 && wday <= 6 ? short_name_list[wday] : "???"; } inline auto tm_mon_full_name(int mon) -> const char* { static constexpr const char* full_name_list[] = { "January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December"}; return mon >= 0 && mon <= 11 ? full_name_list[mon] : "?"; } inline auto tm_mon_short_name(int mon) -> const char* { static constexpr const char* short_name_list[] = { "Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec", }; return mon >= 0 && mon <= 11 ? short_name_list[mon] : "???"; } template <typename T, typename = void> struct has_member_data_tm_gmtoff : std::false_type {}; template <typename T> struct has_member_data_tm_gmtoff<T, void_t<decltype(T::tm_gmtoff)>> : std::true_type {}; template <typename T, typename = void> struct has_member_data_tm_zone : std::false_type {}; template <typename T> struct has_member_data_tm_zone<T, void_t<decltype(T::tm_zone)>> : std::true_type {}; inline void tzset_once() { static bool init = []() { using namespace fmt_detail; _tzset(); return false; }(); ignore_unused(init); } // Converts value to Int and checks that it's in the range [0, upper). template <typename T, typename Int, FMT_ENABLE_IF(std::is_integral<T>::value)> inline auto to_nonnegative_int(T value, Int upper) -> Int { if (!std::is_unsigned<Int>::value && (value < 0 || to_unsigned(value) > to_unsigned(upper))) { FMT_THROW(fmt::format_error("chrono value is out of range")); } return static_cast<Int>(value); } template <typename T, typename Int, FMT_ENABLE_IF(!std::is_integral<T>::value)> inline auto to_nonnegative_int(T value, Int upper) -> Int { auto int_value = static_cast<Int>(value); if (int_value < 0 || value > static_cast<T>(upper)) FMT_THROW(format_error("invalid value")); return int_value; } constexpr auto pow10(std::uint32_t n) -> long long { return n == 0 ? 1 : 10 * pow10(n - 1); } // Counts the number of fractional digits in the range [0, 18] according to the // C++20 spec. If more than 18 fractional digits are required then returns 6 for // microseconds precision. template <long long Num, long long Den, int N = 0, bool Enabled = (N < 19) && (Num <= max_value<long long>() / 10)> struct count_fractional_digits { static constexpr int value = Num % Den == 0 ? N : count_fractional_digits<Num * 10, Den, N + 1>::value; }; // Base case that doesn't instantiate any more templates // in order to avoid overflow. template <long long Num, long long Den, int N> struct count_fractional_digits<Num, Den, N, false> { static constexpr int value = (Num % Den == 0) ? N : 6; }; // Format subseconds which are given as an integer type with an appropriate // number of digits. template <typename Char, typename OutputIt, typename Duration> void write_fractional_seconds(OutputIt& out, Duration d, int precision = -1) { constexpr auto num_fractional_digits = count_fractional_digits<Duration::period::num, Duration::period::den>::value; using subsecond_precision = std::chrono::duration< typename std::common_type<typename Duration::rep, std::chrono::seconds::rep>::type, std::ratio<1, pow10(num_fractional_digits)>>; const auto fractional = d - detail::duration_cast<std::chrono::seconds>(d); const auto subseconds = std::chrono::treat_as_floating_point< typename subsecond_precision::rep>::value ? fractional.count() : detail::duration_cast<subsecond_precision>(fractional).count(); auto n = static_cast<uint32_or_64_or_128_t<long long>>(subseconds); const int num_digits = count_digits(n); int leading_zeroes = (std::max)(0, num_fractional_digits - num_digits); if (precision < 0) { FMT_ASSERT(!std::is_floating_point<typename Duration::rep>::value, ""); if (std::ratio_less<typename subsecond_precision::period, std::chrono::seconds::period>::value) { *out++ = '.'; out = detail::fill_n(out, leading_zeroes, '0'); out = format_decimal<Char>(out, n, num_digits); } } else if (precision > 0) { *out++ = '.'; leading_zeroes = min_of(leading_zeroes, precision); int remaining = precision - leading_zeroes; out = detail::fill_n(out, leading_zeroes, '0'); if (remaining < num_digits) { int num_truncated_digits = num_digits - remaining; n /= to_unsigned(pow10(to_unsigned(num_truncated_digits))); if (n != 0) out = format_decimal<Char>(out, n, remaining); return; } if (n != 0) { out = format_decimal<Char>(out, n, num_digits); remaining -= num_digits; } out = detail::fill_n(out, remaining, '0'); } } // Format subseconds which are given as a floating point type with an // appropriate number of digits. We cannot pass the Duration here, as we // explicitly need to pass the Rep value in the chrono_formatter. template <typename Duration> void write_floating_seconds(memory_buffer& buf, Duration duration, int num_fractional_digits = -1) { using rep = typename Duration::rep; FMT_ASSERT(std::is_floating_point<rep>::value, ""); auto val = duration.count(); if (num_fractional_digits < 0) { // For `std::round` with fallback to `round`: // On some toolchains `std::round` is not available (e.g. GCC 6). using namespace std; num_fractional_digits = count_fractional_digits<Duration::period::num, Duration::period::den>::value; if (num_fractional_digits < 6 && static_cast<rep>(round(val)) != val) num_fractional_digits = 6; } fmt::format_to(std::back_inserter(buf), FMT_STRING("{:.{}f}"), std::fmod(val * static_cast<rep>(Duration::period::num) / static_cast<rep>(Duration::period::den), static_cast<rep>(60)), num_fractional_digits); } template <typename OutputIt, typename Char, typename Duration = std::chrono::seconds> class tm_writer { private: static constexpr int days_per_week = 7; const std::locale& loc_; const bool is_classic_; OutputIt out_; const Duration* subsecs_; const std::tm& tm_; auto tm_sec() const noexcept -> int { FMT_ASSERT(tm_.tm_sec >= 0 && tm_.tm_sec <= 61, ""); return tm_.tm_sec; } auto tm_min() const noexcept -> int { FMT_ASSERT(tm_.tm_min >= 0 && tm_.tm_min <= 59, ""); return tm_.tm_min; } auto tm_hour() const noexcept -> int { FMT_ASSERT(tm_.tm_hour >= 0 && tm_.tm_hour <= 23, ""); return tm_.tm_hour; } auto tm_mday() const noexcept -> int { FMT_ASSERT(tm_.tm_mday >= 1 && tm_.tm_mday <= 31, ""); return tm_.tm_mday; } auto tm_mon() const noexcept -> int { FMT_ASSERT(tm_.tm_mon >= 0 && tm_.tm_mon <= 11, ""); return tm_.tm_mon; } auto tm_year() const noexcept -> long long { return 1900ll + tm_.tm_year; } auto tm_wday() const noexcept -> int { FMT_ASSERT(tm_.tm_wday >= 0 && tm_.tm_wday <= 6, ""); return tm_.tm_wday; } auto tm_yday() const noexcept -> int { FMT_ASSERT(tm_.tm_yday >= 0 && tm_.tm_yday <= 365, ""); return tm_.tm_yday; } auto tm_hour12() const noexcept -> int { const auto h = tm_hour(); const auto z = h < 12 ? h : h - 12; return z == 0 ? 12 : z; } // POSIX and the C Standard are unclear or inconsistent about what %C and %y // do if the year is negative or exceeds 9999. Use the convention that %C // concatenated with %y yields the same output as %Y, and that %Y contains at // least 4 characters, with more only if necessary. auto split_year_lower(long long year) const noexcept -> int { auto l = year % 100; if (l < 0) l = -l; // l in [0, 99] return static_cast<int>(l); } // Algorithm: https://en.wikipedia.org/wiki/ISO_week_date. auto iso_year_weeks(long long curr_year) const noexcept -> int { const auto prev_year = curr_year - 1; const auto curr_p = (curr_year + curr_year / 4 - curr_year / 100 + curr_year / 400) % days_per_week; const auto prev_p = (prev_year + prev_year / 4 - prev_year / 100 + prev_year / 400) % days_per_week; return 52 + ((curr_p == 4 || prev_p == 3) ? 1 : 0); } auto iso_week_num(int tm_yday, int tm_wday) const noexcept -> int { return (tm_yday + 11 - (tm_wday == 0 ? days_per_week : tm_wday)) / days_per_week; } auto tm_iso_week_year() const noexcept -> long long { const auto year = tm_year(); const auto w = iso_week_num(tm_yday(), tm_wday()); if (w < 1) return year - 1; if (w > iso_year_weeks(year)) return year + 1; return year; } auto tm_iso_week_of_year() const noexcept -> int { const auto year = tm_year(); const auto w = iso_week_num(tm_yday(), tm_wday()); if (w < 1) return iso_year_weeks(year - 1); if (w > iso_year_weeks(year)) return 1; return w; } void write1(int value) { *out_++ = static_cast<char>('0' + to_unsigned(value) % 10); } void write2(int value) { const char* d = digits2(to_unsigned(value) % 100); *out_++ = *d++; *out_++ = *d; } void write2(int value, pad_type pad) { unsigned int v = to_unsigned(value) % 100; if (v >= 10) { const char* d = digits2(v); *out_++ = *d++; *out_++ = *d; } else { out_ = detail::write_padding(out_, pad); *out_++ = static_cast<char>('0' + v); } } void write_year_extended(long long year, pad_type pad) { // At least 4 characters. int width = 4; bool negative = year < 0; if (negative) { year = 0 - year; --width; } uint32_or_64_or_128_t<long long> n = to_unsigned(year); const int num_digits = count_digits(n); if (negative && pad == pad_type::zero) *out_++ = '-'; if (width > num_digits) { out_ = detail::write_padding(out_, pad, width - num_digits); } if (negative && pad != pad_type::zero) *out_++ = '-'; out_ = format_decimal<Char>(out_, n, num_digits); } void write_year(long long year, pad_type pad) { write_year_extended(year, pad); } void write_utc_offset(long long offset, numeric_system ns) { if (offset < 0) { *out_++ = '-'; offset = -offset; } else { *out_++ = '+'; } offset /= 60; write2(static_cast<int>(offset / 60)); if (ns != numeric_system::standard) *out_++ = ':'; write2(static_cast<int>(offset % 60)); } template <typename T, FMT_ENABLE_IF(has_member_data_tm_gmtoff<T>::value)> void format_utc_offset_impl(const T& tm, numeric_system ns) { write_utc_offset(tm.tm_gmtoff, ns); } template <typename T, FMT_ENABLE_IF(!has_member_data_tm_gmtoff<T>::value)> void format_utc_offset_impl(const T& tm, numeric_system ns) { #if defined(_WIN32) && defined(_UCRT) tzset_once(); long offset = 0; _get_timezone(&offset); if (tm.tm_isdst) { long dstbias = 0; _get_dstbias(&dstbias); offset += dstbias; } write_utc_offset(-offset, ns); #else if (ns == numeric_system::standard) return format_localized('z'); // Extract timezone offset from timezone conversion functions. std::tm gtm = tm; std::time_t gt = std::mktime(&gtm); std::tm ltm = gmtime(gt); std::time_t lt = std::mktime(&ltm); long long offset = gt - lt; write_utc_offset(offset, ns); #endif } template <typename T, FMT_ENABLE_IF(has_member_data_tm_zone<T>::value)> void format_tz_name_impl(const T& tm) { if (is_classic_) out_ = write_tm_str<Char>(out_, tm.tm_zone, loc_); else format_localized('Z'); } template <typename T, FMT_ENABLE_IF(!has_member_data_tm_zone<T>::value)> void format_tz_name_impl(const T&) { format_localized('Z'); } void format_localized(char format, char modifier = 0) { out_ = write<Char>(out_, tm_, loc_, format, modifier); } public: tm_writer(const std::locale& loc, OutputIt out, const std::tm& tm, const Duration* subsecs = nullptr) : loc_(loc), is_classic_(loc_ == get_classic_locale()), out_(out), subsecs_(subsecs), tm_(tm) {} auto out() const -> OutputIt { return out_; } FMT_CONSTEXPR void on_text(const Char* begin, const Char* end) { out_ = copy<Char>(begin, end, out_); } void on_abbr_weekday() { if (is_classic_) out_ = write(out_, tm_wday_short_name(tm_wday())); else format_localized('a'); } void on_full_weekday() { if (is_classic_) out_ = write(out_, tm_wday_full_name(tm_wday())); else format_localized('A'); } void on_dec0_weekday(numeric_system ns) { if (is_classic_ || ns == numeric_system::standard) return write1(tm_wday()); format_localized('w', 'O'); } void on_dec1_weekday(numeric_system ns) { if (is_classic_ || ns == numeric_system::standard) { auto wday = tm_wday(); write1(wday == 0 ? days_per_week : wday); } else { format_localized('u', 'O'); } } void on_abbr_month() { if (is_classic_) out_ = write(out_, tm_mon_short_name(tm_mon())); else format_localized('b'); } void on_full_month() { if (is_classic_) out_ = write(out_, tm_mon_full_name(tm_mon())); else format_localized('B'); } void on_datetime(numeric_system ns) { if (is_classic_) { on_abbr_weekday(); *out_++ = ' '; on_abbr_month(); *out_++ = ' '; on_day_of_month(numeric_system::standard, pad_type::space); *out_++ = ' '; on_iso_time(); *out_++ = ' '; on_year(numeric_system::standard, pad_type::space); } else { format_localized('c', ns == numeric_system::standard ? '\0' : 'E'); } } void on_loc_date(numeric_system ns) { if (is_classic_) on_us_date(); else format_localized('x', ns == numeric_system::standard ? '\0' : 'E'); } void on_loc_time(numeric_system ns) { if (is_classic_) on_iso_time(); else format_localized('X', ns == numeric_system::standard ? '\0' : 'E'); } void on_us_date() { char buf[8]; write_digit2_separated(buf, to_unsigned(tm_mon() + 1), to_unsigned(tm_mday()), to_unsigned(split_year_lower(tm_year())), '/'); out_ = copy<Char>(std::begin(buf), std::end(buf), out_); } void on_iso_date() { auto year = tm_year(); char buf[10]; size_t offset = 0; if (year >= 0 && year < 10000) { write2digits(buf, static_cast<size_t>(year / 100)); } else { offset = 4; write_year_extended(year, pad_type::zero); year = 0; } write_digit2_separated(buf + 2, static_cast<unsigned>(year % 100), to_unsigned(tm_mon() + 1), to_unsigned(tm_mday()), '-'); out_ = copy<Char>(std::begin(buf) + offset, std::end(buf), out_); } void on_utc_offset(numeric_system ns) { format_utc_offset_impl(tm_, ns); } void on_tz_name() { format_tz_name_impl(tm_); } void on_year(numeric_system ns, pad_type pad) { if (is_classic_ || ns == numeric_system::standard) return write_year(tm_year(), pad); format_localized('Y', 'E'); } void on_short_year(numeric_system ns) { if (is_classic_ || ns == numeric_system::standard) return write2(split_year_lower(tm_year())); format_localized('y', 'O'); } void on_offset_year() { if (is_classic_) return write2(split_year_lower(tm_year())); format_localized('y', 'E'); } void on_century(numeric_system ns) { if (is_classic_ || ns == numeric_system::standard) { auto year = tm_year(); auto upper = year / 100; if (year >= -99 && year < 0) { // Zero upper on negative year. *out_++ = '-'; *out_++ = '0'; } else if (upper >= 0 && upper < 100) { write2(static_cast<int>(upper)); } else { out_ = write<Char>(out_, upper); } } else { format_localized('C', 'E'); } } void on_dec_month(numeric_system ns, pad_type pad) { if (is_classic_ || ns == numeric_system::standard) return write2(tm_mon() + 1, pad); format_localized('m', 'O'); } void on_dec0_week_of_year(numeric_system ns, pad_type pad) { if (is_classic_ || ns == numeric_system::standard) return write2((tm_yday() + days_per_week - tm_wday()) / days_per_week, pad); format_localized('U', 'O'); } void on_dec1_week_of_year(numeric_system ns, pad_type pad) { if (is_classic_ || ns == numeric_system::standard) { auto wday = tm_wday(); write2((tm_yday() + days_per_week - (wday == 0 ? (days_per_week - 1) : (wday - 1))) / days_per_week, pad); } else { format_localized('W', 'O'); } } void on_iso_week_of_year(numeric_system ns, pad_type pad) { if (is_classic_ || ns == numeric_system::standard) return write2(tm_iso_week_of_year(), pad); format_localized('V', 'O'); } void on_iso_week_based_year() { write_year(tm_iso_week_year(), pad_type::zero); } void on_iso_week_based_short_year() { write2(split_year_lower(tm_iso_week_year())); } void on_day_of_year(pad_type pad) { auto yday = tm_yday() + 1; auto digit1 = yday / 100; if (digit1 != 0) { write1(digit1); } else { out_ = detail::write_padding(out_, pad); } write2(yday % 100, pad); } void on_day_of_month(numeric_system ns, pad_type pad) { if (is_classic_ || ns == numeric_system::standard) return write2(tm_mday(), pad); format_localized('d', 'O'); } void on_24_hour(numeric_system ns, pad_type pad) { if (is_classic_ || ns == numeric_system::standard) return write2(tm_hour(), pad); format_localized('H', 'O'); } void on_12_hour(numeric_system ns, pad_type pad) { if (is_classic_ || ns == numeric_system::standard) return write2(tm_hour12(), pad); format_localized('I', 'O'); } void on_minute(numeric_system ns, pad_type pad) { if (is_classic_ || ns == numeric_system::standard) return write2(tm_min(), pad); format_localized('M', 'O'); } void on_second(numeric_system ns, pad_type pad) { if (is_classic_ || ns == numeric_system::standard) { write2(tm_sec(), pad); if (subsecs_) { if (std::is_floating_point<typename Duration::rep>::value) { auto buf = memory_buffer(); write_floating_seconds(buf, *subsecs_); if (buf.size() > 1) { // Remove the leading "0", write something like ".123". out_ = copy<Char>(buf.begin() + 1, buf.end(), out_); } } else { write_fractional_seconds<Char>(out_, *subsecs_); } } } else { // Currently no formatting of subseconds when a locale is set. format_localized('S', 'O'); } } void on_12_hour_time() { if (is_classic_) { char buf[8]; write_digit2_separated(buf, to_unsigned(tm_hour12()), to_unsigned(tm_min()), to_unsigned(tm_sec()), ':'); out_ = copy<Char>(std::begin(buf), std::end(buf), out_); *out_++ = ' '; on_am_pm(); } else { format_localized('r'); } } void on_24_hour_time() { write2(tm_hour()); *out_++ = ':'; write2(tm_min()); } void on_iso_time() { on_24_hour_time(); *out_++ = ':'; on_second(numeric_system::standard, pad_type::zero); } void on_am_pm() { if (is_classic_) { *out_++ = tm_hour() < 12 ? 'A' : 'P'; *out_++ = 'M'; } else { format_localized('p'); } } // These apply to chrono durations but not tm. void on_duration_value() {} void on_duration_unit() {} }; struct chrono_format_checker : null_chrono_spec_handler<chrono_format_checker> { bool has_precision_integral = false; FMT_NORETURN inline void unsupported() { FMT_THROW(format_error("no date")); } template <typename Char> FMT_CONSTEXPR void on_text(const Char*, const Char*) {} FMT_CONSTEXPR void on_day_of_year(pad_type) {} FMT_CONSTEXPR void on_24_hour(numeric_system, pad_type) {} FMT_CONSTEXPR void on_12_hour(numeric_system, pad_type) {} FMT_CONSTEXPR void on_minute(numeric_system, pad_type) {} FMT_CONSTEXPR void on_second(numeric_system, pad_type) {} FMT_CONSTEXPR void on_12_hour_time() {} FMT_CONSTEXPR void on_24_hour_time() {} FMT_CONSTEXPR void on_iso_time() {} FMT_CONSTEXPR void on_am_pm() {} FMT_CONSTEXPR void on_duration_value() const { if (has_precision_integral) FMT_THROW(format_error("precision not allowed for this argument type")); } FMT_CONSTEXPR void on_duration_unit() {} }; template <typename T, FMT_ENABLE_IF(std::is_integral<T>::value&& has_isfinite<T>::value)> inline auto isfinite(T) -> bool { return true; } template <typename T, FMT_ENABLE_IF(std::is_integral<T>::value)> inline auto mod(T x, int y) -> T { return x % static_cast<T>(y); } template <typename T, FMT_ENABLE_IF(std::is_floating_point<T>::value)> inline auto mod(T x, int y) -> T { return std::fmod(x, static_cast<T>(y)); } // If T is an integral type, maps T to its unsigned counterpart, otherwise // leaves it unchanged (unlike std::make_unsigned). template <typename T, bool INTEGRAL = std::is_integral<T>::value> struct make_unsigned_or_unchanged { using type = T; }; template <typename T> struct make_unsigned_or_unchanged<T, true> { using type = typename std::make_unsigned<T>::type; }; template <typename Rep, typename Period, FMT_ENABLE_IF(std::is_integral<Rep>::value)> inline auto get_milliseconds(std::chrono::duration<Rep, Period> d) -> std::chrono::duration<Rep, std::milli> { // this may overflow and/or the result may not fit in the // target type. #if FMT_SAFE_DURATION_CAST using CommonSecondsType = typename std::common_type<decltype(d), std::chrono::seconds>::type; const auto d_as_common = detail::duration_cast<CommonSecondsType>(d); const auto d_as_whole_seconds = detail::duration_cast<std::chrono::seconds>(d_as_common); // this conversion should be nonproblematic const auto diff = d_as_common - d_as_whole_seconds; const auto ms = detail::duration_cast<std::chrono::duration<Rep, std::milli>>(diff); return ms; #else auto s = detail::duration_cast<std::chrono::seconds>(d); return detail::duration_cast<std::chrono::milliseconds>(d - s); #endif } template <typename Char, typename Rep, typename OutputIt, FMT_ENABLE_IF(std::is_integral<Rep>::value)> auto format_duration_value(OutputIt out, Rep val, int) -> OutputIt { return write<Char>(out, val); } template <typename Char, typename Rep, typename OutputIt, FMT_ENABLE_IF(std::is_floating_point<Rep>::value)> auto format_duration_value(OutputIt out, Rep val, int precision) -> OutputIt { auto specs = format_specs(); specs.precision = precision; specs.set_type(precision >= 0 ? presentation_type::fixed : presentation_type::general); return write<Char>(out, val, specs); } template <typename Char, typename OutputIt> auto copy_unit(string_view unit, OutputIt out, Char) -> OutputIt { return copy<Char>(unit.begin(), unit.end(), out); } template <typename OutputIt> auto copy_unit(string_view unit, OutputIt out, wchar_t) -> OutputIt { // This works when wchar_t is UTF-32 because units only contain characters // that have the same representation in UTF-16 and UTF-32. utf8_to_utf16 u(unit); return copy<wchar_t>(u.c_str(), u.c_str() + u.size(), out); } template <typename Char, typename Period, typename OutputIt> auto format_duration_unit(OutputIt out) -> OutputIt { if (const char* unit = get_units<Period>()) return copy_unit(string_view(unit), out, Char()); *out++ = '['; out = write<Char>(out, Period::num); if (const_check(Period::den != 1)) { *out++ = '/'; out = write<Char>(out, Period::den); } *out++ = ']'; *out++ = 's'; return out; } class get_locale { private: union { std::locale locale_; }; bool has_locale_ = false; public: inline get_locale(bool localized, locale_ref loc) : has_locale_(localized) { if (localized) ::new (&locale_) std::locale(loc.template get<std::locale>()); } inline ~get_locale() { if (has_locale_) locale_.~locale(); } inline operator const std::locale&() const { return has_locale_ ? locale_ : get_classic_locale(); } }; template <typename FormatContext, typename OutputIt, typename Rep, typename Period> struct chrono_formatter { FormatContext& context; OutputIt out; int precision; bool localized = false; // rep is unsigned to avoid overflow. using rep = conditional_t<std::is_integral<Rep>::value && sizeof(Rep) < sizeof(int), unsigned, typename make_unsigned_or_unchanged<Rep>::type>; rep val; using seconds = std::chrono::duration<rep>; seconds s; using milliseconds = std::chrono::duration<rep, std::milli>; bool negative; using char_type = typename FormatContext::char_type; using tm_writer_type = tm_writer<OutputIt, char_type>; chrono_formatter(FormatContext& ctx, OutputIt o, std::chrono::duration<Rep, Period> d) : context(ctx), out(o), val(static_cast<rep>(d.count())), negative(false) { if (d.count() < 0) { val = 0 - val; negative = true; } // this may overflow and/or the result may not fit in the // target type. // might need checked conversion (rep!=Rep) s = detail::duration_cast<seconds>(std::chrono::duration<rep, Period>(val)); } // returns true if nan or inf, writes to out. auto handle_nan_inf() -> bool { if (isfinite(val)) { return false; } if (isnan(val)) { write_nan(); return true; } // must be +-inf if (val > 0) { write_pinf(); } else { write_ninf(); } return true; } auto days() const -> Rep { return static_cast<Rep>(s.count() / 86400); } auto hour() const -> Rep { return static_cast<Rep>(mod((s.count() / 3600), 24)); } auto hour12() const -> Rep { Rep hour = static_cast<Rep>(mod((s.count() / 3600), 12)); return hour <= 0 ? 12 : hour; } auto minute() const -> Rep { return static_cast<Rep>(mod((s.count() / 60), 60)); } auto second() const -> Rep { return static_cast<Rep>(mod(s.count(), 60)); } auto time() const -> std::tm { auto time = std::tm(); time.tm_hour = to_nonnegative_int(hour(), 24); time.tm_min = to_nonnegative_int(minute(), 60); time.tm_sec = to_nonnegative_int(second(), 60); return time; } void write_sign() { if (negative) { *out++ = '-'; negative = false; } } void write(Rep value, int width, pad_type pad = pad_type::zero) { write_sign(); if (isnan(value)) return write_nan(); uint32_or_64_or_128_t<int> n = to_unsigned(to_nonnegative_int(value, max_value<int>())); int num_digits = detail::count_digits(n); if (width > num_digits) { out = detail::write_padding(out, pad, width - num_digits); } out = format_decimal<char_type>(out, n, num_digits); } void write_nan() { std::copy_n("nan", 3, out); } void write_pinf() { std::copy_n("inf", 3, out); } void write_ninf() { std::copy_n("-inf", 4, out); } template <typename Callback, typename... Args> void format_tm(const tm& time, Callback cb, Args... args) { if (isnan(val)) return write_nan(); get_locale loc(localized, context.locale()); auto w = tm_writer_type(loc, out, time); (w.*cb)(args...); out = w.out(); } void on_text(const char_type* begin, const char_type* end) { copy<char_type>(begin, end, out); } // These are not implemented because durations don't have date information. void on_abbr_weekday() {} void on_full_weekday() {} void on_dec0_weekday(numeric_system) {} void on_dec1_weekday(numeric_system) {} void on_abbr_month() {} void on_full_month() {} void on_datetime(numeric_system) {} void on_loc_date(numeric_system) {} void on_loc_time(numeric_system) {} void on_us_date() {} void on_iso_date() {} void on_utc_offset(numeric_system) {} void on_tz_name() {} void on_year(numeric_system, pad_type) {} void on_short_year(numeric_system) {} void on_offset_year() {} void on_century(numeric_system) {} void on_iso_week_based_year() {} void on_iso_week_based_short_year() {} void on_dec_month(numeric_system, pad_type) {} void on_dec0_week_of_year(numeric_system, pad_type) {} void on_dec1_week_of_year(numeric_system, pad_type) {} void on_iso_week_of_year(numeric_system, pad_type) {} void on_day_of_month(numeric_system, pad_type) {} void on_day_of_year(pad_type) { if (handle_nan_inf()) return; write(days(), 0); } void on_24_hour(numeric_system ns, pad_type pad) { if (handle_nan_inf()) return; if (ns == numeric_system::standard) return write(hour(), 2, pad); auto time = tm(); time.tm_hour = to_nonnegative_int(hour(), 24); format_tm(time, &tm_writer_type::on_24_hour, ns, pad); } void on_12_hour(numeric_system ns, pad_type pad) { if (handle_nan_inf()) return; if (ns == numeric_system::standard) return write(hour12(), 2, pad); auto time = tm(); time.tm_hour = to_nonnegative_int(hour12(), 12); format_tm(time, &tm_writer_type::on_12_hour, ns, pad); } void on_minute(numeric_system ns, pad_type pad) { if (handle_nan_inf()) return; if (ns == numeric_system::standard) return write(minute(), 2, pad); auto time = tm(); time.tm_min = to_nonnegative_int(minute(), 60); format_tm(time, &tm_writer_type::on_minute, ns, pad); } void on_second(numeric_system ns, pad_type pad) { if (handle_nan_inf()) return; if (ns == numeric_system::standard) { if (std::is_floating_point<rep>::value) { auto buf = memory_buffer(); write_floating_seconds(buf, std::chrono::duration<rep, Period>(val), precision); if (negative) *out++ = '-'; if (buf.size() < 2 || buf[1] == '.') { out = detail::write_padding(out, pad); } out = copy<char_type>(buf.begin(), buf.end(), out); } else { write(second(), 2, pad); write_fractional_seconds<char_type>( out, std::chrono::duration<rep, Period>(val), precision); } return; } auto time = tm(); time.tm_sec = to_nonnegative_int(second(), 60); format_tm(time, &tm_writer_type::on_second, ns, pad); } void on_12_hour_time() { if (handle_nan_inf()) return; format_tm(time(), &tm_writer_type::on_12_hour_time); } void on_24_hour_time() { if (handle_nan_inf()) { *out++ = ':'; handle_nan_inf(); return; } write(hour(), 2); *out++ = ':'; write(minute(), 2); } void on_iso_time() { on_24_hour_time(); *out++ = ':'; if (handle_nan_inf()) return; on_second(numeric_system::standard, pad_type::zero); } void on_am_pm() { if (handle_nan_inf()) return; format_tm(time(), &tm_writer_type::on_am_pm); } void on_duration_value() { if (handle_nan_inf()) return; write_sign(); out = format_duration_value<char_type>(out, val, precision); } void on_duration_unit() { out = format_duration_unit<char_type, Period>(out); } }; } // namespace detail #if defined(__cpp_lib_chrono) && __cpp_lib_chrono >= 201907 using weekday = std::chrono::weekday; using day = std::chrono::day; using month = std::chrono::month; using year = std::chrono::year; using year_month_day = std::chrono::year_month_day; #else // A fallback version of weekday. class weekday { private: unsigned char value_; public: weekday() = default; constexpr explicit weekday(unsigned wd) noexcept : value_(static_cast<unsigned char>(wd != 7 ? wd : 0)) {} constexpr auto c_encoding() const noexcept -> unsigned { return value_; } }; class day { private: unsigned char value_; public: day() = default; constexpr explicit day(unsigned d) noexcept : value_(static_cast<unsigned char>(d)) {} constexpr explicit operator unsigned() const noexcept { return value_; } }; class month { private: unsigned char value_; public: month() = default; constexpr explicit month(unsigned m) noexcept : value_(static_cast<unsigned char>(m)) {} constexpr explicit operator unsigned() const noexcept { return value_; } }; class year { private: int value_; public: year() = default; constexpr explicit year(int y) noexcept : value_(y) {} constexpr explicit operator int() const noexcept { return value_; } }; class year_month_day { private: fmt::year year_; fmt::month month_; fmt::day day_; public: year_month_day() = default; constexpr year_month_day(const year& y, const month& m, const day& d) noexcept : year_(y), month_(m), day_(d) {} constexpr auto year() const noexcept -> fmt::year { return year_; } constexpr auto month() const noexcept -> fmt::month { return month_; } constexpr auto day() const noexcept -> fmt::day { return day_; } }; #endif template <typename Char> struct formatter<weekday, Char> : private formatter<std::tm, Char> { private: bool localized_ = false; bool use_tm_formatter_ = false; public: FMT_CONSTEXPR auto parse(parse_context<Char>& ctx) -> const Char* { auto it = ctx.begin(), end = ctx.end(); if (it != end && *it == 'L') { ++it; localized_ = true; return it; } use_tm_formatter_ = it != end && *it != '}'; return use_tm_formatter_ ? formatter<std::tm, Char>::parse(ctx) : it; } template <typename FormatContext> auto format(weekday wd, FormatContext& ctx) const -> decltype(ctx.out()) { auto time = std::tm(); time.tm_wday = static_cast<int>(wd.c_encoding()); if (use_tm_formatter_) return formatter<std::tm, Char>::format(time, ctx); detail::get_locale loc(localized_, ctx.locale()); auto w = detail::tm_writer<decltype(ctx.out()), Char>(loc, ctx.out(), time); w.on_abbr_weekday(); return w.out(); } }; template <typename Char> struct formatter<day, Char> : private formatter<std::tm, Char> { private: bool use_tm_formatter_ = false; public: FMT_CONSTEXPR auto parse(parse_context<Char>& ctx) -> const Char* { auto it = ctx.begin(), end = ctx.end(); use_tm_formatter_ = it != end && *it != '}'; return use_tm_formatter_ ? formatter<std::tm, Char>::parse(ctx) : it; } template <typename FormatContext> auto format(day d, FormatContext& ctx) const -> decltype(ctx.out()) { auto time = std::tm(); time.tm_mday = static_cast<int>(static_cast<unsigned>(d)); if (use_tm_formatter_) return formatter<std::tm, Char>::format(time, ctx); detail::get_locale loc(false, ctx.locale()); auto w = detail::tm_writer<decltype(ctx.out()), Char>(loc, ctx.out(), time); w.on_day_of_month(detail::numeric_system::standard, detail::pad_type::zero); return w.out(); } }; template <typename Char> struct formatter<month, Char> : private formatter<std::tm, Char> { private: bool localized_ = false; bool use_tm_formatter_ = false; public: FMT_CONSTEXPR auto parse(parse_context<Char>& ctx) -> const Char* { auto it = ctx.begin(), end = ctx.end(); if (it != end && *it == 'L') { ++it; localized_ = true; return it; } use_tm_formatter_ = it != end && *it != '}'; return use_tm_formatter_ ? formatter<std::tm, Char>::parse(ctx) : it; } template <typename FormatContext> auto format(month m, FormatContext& ctx) const -> decltype(ctx.out()) { auto time = std::tm(); time.tm_mon = static_cast<int>(static_cast<unsigned>(m)) - 1; if (use_tm_formatter_) return formatter<std::tm, Char>::format(time, ctx); detail::get_locale loc(localized_, ctx.locale()); auto w = detail::tm_writer<decltype(ctx.out()), Char>(loc, ctx.out(), time); w.on_abbr_month(); return w.out(); } }; template <typename Char> struct formatter<year, Char> : private formatter<std::tm, Char> { private: bool use_tm_formatter_ = false; public: FMT_CONSTEXPR auto parse(parse_context<Char>& ctx) -> const Char* { auto it = ctx.begin(), end = ctx.end(); use_tm_formatter_ = it != end && *it != '}'; return use_tm_formatter_ ? formatter<std::tm, Char>::parse(ctx) : it; } template <typename FormatContext> auto format(year y, FormatContext& ctx) const -> decltype(ctx.out()) { auto time = std::tm(); time.tm_year = static_cast<int>(y) - 1900; if (use_tm_formatter_) return formatter<std::tm, Char>::format(time, ctx); detail::get_locale loc(false, ctx.locale()); auto w = detail::tm_writer<decltype(ctx.out()), Char>(loc, ctx.out(), time); w.on_year(detail::numeric_system::standard, detail::pad_type::zero); return w.out(); } }; template <typename Char> struct formatter<year_month_day, Char> : private formatter<std::tm, Char> { private: bool use_tm_formatter_ = false; public: FMT_CONSTEXPR auto parse(parse_context<Char>& ctx) -> const Char* { auto it = ctx.begin(), end = ctx.end(); use_tm_formatter_ = it != end && *it != '}'; return use_tm_formatter_ ? formatter<std::tm, Char>::parse(ctx) : it; } template <typename FormatContext> auto format(year_month_day val, FormatContext& ctx) const -> decltype(ctx.out()) { auto time = std::tm(); time.tm_year = static_cast<int>(val.year()) - 1900; time.tm_mon = static_cast<int>(static_cast<unsigned>(val.month())) - 1; time.tm_mday = static_cast<int>(static_cast<unsigned>(val.day())); if (use_tm_formatter_) return formatter<std::tm, Char>::format(time, ctx); detail::get_locale loc(true, ctx.locale()); auto w = detail::tm_writer<decltype(ctx.out()), Char>(loc, ctx.out(), time); w.on_iso_date(); return w.out(); } }; template <typename Rep, typename Period, typename Char> struct formatter<std::chrono::duration<Rep, Period>, Char> { private: format_specs specs_; detail::arg_ref<Char> width_ref_; detail::arg_ref<Char> precision_ref_; bool localized_ = false; basic_string_view<Char> fmt_; public: FMT_CONSTEXPR auto parse(parse_context<Char>& ctx) -> const Char* { auto it = ctx.begin(), end = ctx.end(); if (it == end || *it == '}') return it; it = detail::parse_align(it, end, specs_); if (it == end) return it; Char c = *it; if ((c >= '0' && c <= '9') || c == '{') { it = detail::parse_width(it, end, specs_, width_ref_, ctx); if (it == end) return it; } auto checker = detail::chrono_format_checker(); if (*it == '.') { checker.has_precision_integral = !std::is_floating_point<Rep>::value; it = detail::parse_precision(it, end, specs_, precision_ref_, ctx); } if (it != end && *it == 'L') { localized_ = true; ++it; } end = detail::parse_chrono_format(it, end, checker); fmt_ = {it, detail::to_unsigned(end - it)}; return end; } template <typename FormatContext> auto format(std::chrono::duration<Rep, Period> d, FormatContext& ctx) const -> decltype(ctx.out()) { auto specs = specs_; auto precision = specs.precision; specs.precision = -1; auto begin = fmt_.begin(), end = fmt_.end(); // As a possible future optimization, we could avoid extra copying if width // is not specified. auto buf = basic_memory_buffer<Char>(); auto out = basic_appender<Char>(buf); detail::handle_dynamic_spec(specs.dynamic_width(), specs.width, width_ref_, ctx); detail::handle_dynamic_spec(specs.dynamic_precision(), precision, precision_ref_, ctx); if (begin == end || *begin == '}') { out = detail::format_duration_value<Char>(out, d.count(), precision); detail::format_duration_unit<Char, Period>(out); } else { using chrono_formatter = detail::chrono_formatter<FormatContext, decltype(out), Rep, Period>; auto f = chrono_formatter(ctx, out, d); f.precision = precision; f.localized = localized_; detail::parse_chrono_format(begin, end, f); } return detail::write( ctx.out(), basic_string_view<Char>(buf.data(), buf.size()), specs); } }; template <typename Char> struct formatter<std::tm, Char> { private: format_specs specs_; detail::arg_ref<Char> width_ref_; protected: basic_string_view<Char> fmt_; template <typename Duration, typename FormatContext> auto do_format(const std::tm& tm, FormatContext& ctx, const Duration* subsecs) const -> decltype(ctx.out()) { auto specs = specs_; auto buf = basic_memory_buffer<Char>(); auto out = basic_appender<Char>(buf); detail::handle_dynamic_spec(specs.dynamic_width(), specs.width, width_ref_, ctx); auto loc_ref = ctx.locale(); detail::get_locale loc(static_cast<bool>(loc_ref), loc_ref); auto w = detail::tm_writer<decltype(out), Char, Duration>(loc, out, tm, subsecs); detail::parse_chrono_format(fmt_.begin(), fmt_.end(), w); return detail::write( ctx.out(), basic_string_view<Char>(buf.data(), buf.size()), specs); } public: FMT_CONSTEXPR auto parse(parse_context<Char>& ctx) -> const Char* { auto it = ctx.begin(), end = ctx.end(); if (it == end || *it == '}') return it; it = detail::parse_align(it, end, specs_); if (it == end) return it; Char c = *it; if ((c >= '0' && c <= '9') || c == '{') { it = detail::parse_width(it, end, specs_, width_ref_, ctx); if (it == end) return it; } end = detail::parse_chrono_format(it, end, detail::tm_format_checker()); // Replace the default format string only if the new spec is not empty. if (end != it) fmt_ = {it, detail::to_unsigned(end - it)}; return end; } template <typename FormatContext> auto format(const std::tm& tm, FormatContext& ctx) const -> decltype(ctx.out()) { return do_format<std::chrono::seconds>(tm, ctx, nullptr); } }; template <typename Char, typename Duration> struct formatter<sys_time<Duration>, Char> : formatter<std::tm, Char> { FMT_CONSTEXPR formatter() { this->fmt_ = detail::string_literal<Char, '%', 'F', ' ', '%', 'T'>(); } template <typename FormatContext> auto format(sys_time<Duration> val, FormatContext& ctx) const -> decltype(ctx.out()) { std::tm tm = gmtime(val); using period = typename Duration::period; if (detail::const_check( period::num == 1 && period::den == 1 && !std::is_floating_point<typename Duration::rep>::value)) { return formatter<std::tm, Char>::format(tm, ctx); } Duration epoch = val.time_since_epoch(); Duration subsecs = detail::duration_cast<Duration>( epoch - detail::duration_cast<std::chrono::seconds>(epoch)); if (subsecs.count() < 0) { auto second = detail::duration_cast<Duration>(std::chrono::seconds(1)); if (tm.tm_sec != 0) --tm.tm_sec; else tm = gmtime(val - second); subsecs += detail::duration_cast<Duration>(std::chrono::seconds(1)); } return formatter<std::tm, Char>::do_format(tm, ctx, &subsecs); } }; template <typename Duration, typename Char> struct formatter<utc_time<Duration>, Char> : formatter<sys_time<Duration>, Char> { template <typename FormatContext> auto format(utc_time<Duration> val, FormatContext& ctx) const -> decltype(ctx.out()) { return formatter<sys_time<Duration>, Char>::format( detail::utc_clock::to_sys(val), ctx); } }; template <typename Duration, typename Char> struct formatter<local_time<Duration>, Char> : formatter<std::tm, Char> { FMT_CONSTEXPR formatter() { this->fmt_ = detail::string_literal<Char, '%', 'F', ' ', '%', 'T'>(); } template <typename FormatContext> auto format(local_time<Duration> val, FormatContext& ctx) const -> decltype(ctx.out()) { using period = typename Duration::period; if (period::num == 1 && period::den == 1 && !std::is_floating_point<typename Duration::rep>::value) { return formatter<std::tm, Char>::format(localtime(val), ctx); } auto epoch = val.time_since_epoch(); auto subsecs = detail::duration_cast<Duration>( epoch - detail::duration_cast<std::chrono::seconds>(epoch)); return formatter<std::tm, Char>::do_format(localtime(val), ctx, &subsecs); } }; FMT_END_EXPORT FMT_END_NAMESPACE #endif // FMT_CHRONO_H_ ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/vendor/fmt/color.h�������������������������������������������������������������������0000664�0000000�0000000�00000055452�14771603147�0016734�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������// Formatting library for C++ - color support // // Copyright (c) 2018 - present, Victor Zverovich and fmt contributors // All rights reserved. // // For the license information refer to format.h. #ifndef FMT_COLOR_H_ #define FMT_COLOR_H_ #include "format.h" FMT_BEGIN_NAMESPACE FMT_BEGIN_EXPORT enum class color : uint32_t { alice_blue = 0xF0F8FF, // rgb(240,248,255) antique_white = 0xFAEBD7, // rgb(250,235,215) aqua = 0x00FFFF, // rgb(0,255,255) aquamarine = 0x7FFFD4, // rgb(127,255,212) azure = 0xF0FFFF, // rgb(240,255,255) beige = 0xF5F5DC, // rgb(245,245,220) bisque = 0xFFE4C4, // rgb(255,228,196) black = 0x000000, // rgb(0,0,0) blanched_almond = 0xFFEBCD, // rgb(255,235,205) blue = 0x0000FF, // rgb(0,0,255) blue_violet = 0x8A2BE2, // rgb(138,43,226) brown = 0xA52A2A, // rgb(165,42,42) burly_wood = 0xDEB887, // rgb(222,184,135) cadet_blue = 0x5F9EA0, // rgb(95,158,160) chartreuse = 0x7FFF00, // rgb(127,255,0) chocolate = 0xD2691E, // rgb(210,105,30) coral = 0xFF7F50, // rgb(255,127,80) cornflower_blue = 0x6495ED, // rgb(100,149,237) cornsilk = 0xFFF8DC, // rgb(255,248,220) crimson = 0xDC143C, // rgb(220,20,60) cyan = 0x00FFFF, // rgb(0,255,255) dark_blue = 0x00008B, // rgb(0,0,139) dark_cyan = 0x008B8B, // rgb(0,139,139) dark_golden_rod = 0xB8860B, // rgb(184,134,11) dark_gray = 0xA9A9A9, // rgb(169,169,169) dark_green = 0x006400, // rgb(0,100,0) dark_khaki = 0xBDB76B, // rgb(189,183,107) dark_magenta = 0x8B008B, // rgb(139,0,139) dark_olive_green = 0x556B2F, // rgb(85,107,47) dark_orange = 0xFF8C00, // rgb(255,140,0) dark_orchid = 0x9932CC, // rgb(153,50,204) dark_red = 0x8B0000, // rgb(139,0,0) dark_salmon = 0xE9967A, // rgb(233,150,122) dark_sea_green = 0x8FBC8F, // rgb(143,188,143) dark_slate_blue = 0x483D8B, // rgb(72,61,139) dark_slate_gray = 0x2F4F4F, // rgb(47,79,79) dark_turquoise = 0x00CED1, // rgb(0,206,209) dark_violet = 0x9400D3, // rgb(148,0,211) deep_pink = 0xFF1493, // rgb(255,20,147) deep_sky_blue = 0x00BFFF, // rgb(0,191,255) dim_gray = 0x696969, // rgb(105,105,105) dodger_blue = 0x1E90FF, // rgb(30,144,255) fire_brick = 0xB22222, // rgb(178,34,34) floral_white = 0xFFFAF0, // rgb(255,250,240) forest_green = 0x228B22, // rgb(34,139,34) fuchsia = 0xFF00FF, // rgb(255,0,255) gainsboro = 0xDCDCDC, // rgb(220,220,220) ghost_white = 0xF8F8FF, // rgb(248,248,255) gold = 0xFFD700, // rgb(255,215,0) golden_rod = 0xDAA520, // rgb(218,165,32) gray = 0x808080, // rgb(128,128,128) green = 0x008000, // rgb(0,128,0) green_yellow = 0xADFF2F, // rgb(173,255,47) honey_dew = 0xF0FFF0, // rgb(240,255,240) hot_pink = 0xFF69B4, // rgb(255,105,180) indian_red = 0xCD5C5C, // rgb(205,92,92) indigo = 0x4B0082, // rgb(75,0,130) ivory = 0xFFFFF0, // rgb(255,255,240) khaki = 0xF0E68C, // rgb(240,230,140) lavender = 0xE6E6FA, // rgb(230,230,250) lavender_blush = 0xFFF0F5, // rgb(255,240,245) lawn_green = 0x7CFC00, // rgb(124,252,0) lemon_chiffon = 0xFFFACD, // rgb(255,250,205) light_blue = 0xADD8E6, // rgb(173,216,230) light_coral = 0xF08080, // rgb(240,128,128) light_cyan = 0xE0FFFF, // rgb(224,255,255) light_golden_rod_yellow = 0xFAFAD2, // rgb(250,250,210) light_gray = 0xD3D3D3, // rgb(211,211,211) light_green = 0x90EE90, // rgb(144,238,144) light_pink = 0xFFB6C1, // rgb(255,182,193) light_salmon = 0xFFA07A, // rgb(255,160,122) light_sea_green = 0x20B2AA, // rgb(32,178,170) light_sky_blue = 0x87CEFA, // rgb(135,206,250) light_slate_gray = 0x778899, // rgb(119,136,153) light_steel_blue = 0xB0C4DE, // rgb(176,196,222) light_yellow = 0xFFFFE0, // rgb(255,255,224) lime = 0x00FF00, // rgb(0,255,0) lime_green = 0x32CD32, // rgb(50,205,50) linen = 0xFAF0E6, // rgb(250,240,230) magenta = 0xFF00FF, // rgb(255,0,255) maroon = 0x800000, // rgb(128,0,0) medium_aquamarine = 0x66CDAA, // rgb(102,205,170) medium_blue = 0x0000CD, // rgb(0,0,205) medium_orchid = 0xBA55D3, // rgb(186,85,211) medium_purple = 0x9370DB, // rgb(147,112,219) medium_sea_green = 0x3CB371, // rgb(60,179,113) medium_slate_blue = 0x7B68EE, // rgb(123,104,238) medium_spring_green = 0x00FA9A, // rgb(0,250,154) medium_turquoise = 0x48D1CC, // rgb(72,209,204) medium_violet_red = 0xC71585, // rgb(199,21,133) midnight_blue = 0x191970, // rgb(25,25,112) mint_cream = 0xF5FFFA, // rgb(245,255,250) misty_rose = 0xFFE4E1, // rgb(255,228,225) moccasin = 0xFFE4B5, // rgb(255,228,181) navajo_white = 0xFFDEAD, // rgb(255,222,173) navy = 0x000080, // rgb(0,0,128) old_lace = 0xFDF5E6, // rgb(253,245,230) olive = 0x808000, // rgb(128,128,0) olive_drab = 0x6B8E23, // rgb(107,142,35) orange = 0xFFA500, // rgb(255,165,0) orange_red = 0xFF4500, // rgb(255,69,0) orchid = 0xDA70D6, // rgb(218,112,214) pale_golden_rod = 0xEEE8AA, // rgb(238,232,170) pale_green = 0x98FB98, // rgb(152,251,152) pale_turquoise = 0xAFEEEE, // rgb(175,238,238) pale_violet_red = 0xDB7093, // rgb(219,112,147) papaya_whip = 0xFFEFD5, // rgb(255,239,213) peach_puff = 0xFFDAB9, // rgb(255,218,185) peru = 0xCD853F, // rgb(205,133,63) pink = 0xFFC0CB, // rgb(255,192,203) plum = 0xDDA0DD, // rgb(221,160,221) powder_blue = 0xB0E0E6, // rgb(176,224,230) purple = 0x800080, // rgb(128,0,128) rebecca_purple = 0x663399, // rgb(102,51,153) red = 0xFF0000, // rgb(255,0,0) rosy_brown = 0xBC8F8F, // rgb(188,143,143) royal_blue = 0x4169E1, // rgb(65,105,225) saddle_brown = 0x8B4513, // rgb(139,69,19) salmon = 0xFA8072, // rgb(250,128,114) sandy_brown = 0xF4A460, // rgb(244,164,96) sea_green = 0x2E8B57, // rgb(46,139,87) sea_shell = 0xFFF5EE, // rgb(255,245,238) sienna = 0xA0522D, // rgb(160,82,45) silver = 0xC0C0C0, // rgb(192,192,192) sky_blue = 0x87CEEB, // rgb(135,206,235) slate_blue = 0x6A5ACD, // rgb(106,90,205) slate_gray = 0x708090, // rgb(112,128,144) snow = 0xFFFAFA, // rgb(255,250,250) spring_green = 0x00FF7F, // rgb(0,255,127) steel_blue = 0x4682B4, // rgb(70,130,180) tan = 0xD2B48C, // rgb(210,180,140) teal = 0x008080, // rgb(0,128,128) thistle = 0xD8BFD8, // rgb(216,191,216) tomato = 0xFF6347, // rgb(255,99,71) turquoise = 0x40E0D0, // rgb(64,224,208) violet = 0xEE82EE, // rgb(238,130,238) wheat = 0xF5DEB3, // rgb(245,222,179) white = 0xFFFFFF, // rgb(255,255,255) white_smoke = 0xF5F5F5, // rgb(245,245,245) yellow = 0xFFFF00, // rgb(255,255,0) yellow_green = 0x9ACD32 // rgb(154,205,50) }; // enum class color enum class terminal_color : uint8_t { black = 30, red, green, yellow, blue, magenta, cyan, white, bright_black = 90, bright_red, bright_green, bright_yellow, bright_blue, bright_magenta, bright_cyan, bright_white }; enum class emphasis : uint8_t { bold = 1, faint = 1 << 1, italic = 1 << 2, underline = 1 << 3, blink = 1 << 4, reverse = 1 << 5, conceal = 1 << 6, strikethrough = 1 << 7, }; // rgb is a struct for red, green and blue colors. // Using the name "rgb" makes some editors show the color in a tooltip. struct rgb { FMT_CONSTEXPR rgb() : r(0), g(0), b(0) {} FMT_CONSTEXPR rgb(uint8_t r_, uint8_t g_, uint8_t b_) : r(r_), g(g_), b(b_) {} FMT_CONSTEXPR rgb(uint32_t hex) : r((hex >> 16) & 0xFF), g((hex >> 8) & 0xFF), b(hex & 0xFF) {} FMT_CONSTEXPR rgb(color hex) : r((uint32_t(hex) >> 16) & 0xFF), g((uint32_t(hex) >> 8) & 0xFF), b(uint32_t(hex) & 0xFF) {} uint8_t r; uint8_t g; uint8_t b; }; namespace detail { // color is a struct of either a rgb color or a terminal color. struct color_type { FMT_CONSTEXPR color_type() noexcept : is_rgb(), value{} {} FMT_CONSTEXPR color_type(color rgb_color) noexcept : is_rgb(true), value{} { value.rgb_color = static_cast<uint32_t>(rgb_color); } FMT_CONSTEXPR color_type(rgb rgb_color) noexcept : is_rgb(true), value{} { value.rgb_color = (static_cast<uint32_t>(rgb_color.r) << 16) | (static_cast<uint32_t>(rgb_color.g) << 8) | rgb_color.b; } FMT_CONSTEXPR color_type(terminal_color term_color) noexcept : is_rgb(), value{} { value.term_color = static_cast<uint8_t>(term_color); } bool is_rgb; union color_union { uint8_t term_color; uint32_t rgb_color; } value; }; } // namespace detail /// A text style consisting of foreground and background colors and emphasis. class text_style { public: FMT_CONSTEXPR text_style(emphasis em = emphasis()) noexcept : set_foreground_color(), set_background_color(), ems(em) {} FMT_CONSTEXPR auto operator|=(const text_style& rhs) -> text_style& { if (!set_foreground_color) { set_foreground_color = rhs.set_foreground_color; foreground_color = rhs.foreground_color; } else if (rhs.set_foreground_color) { if (!foreground_color.is_rgb || !rhs.foreground_color.is_rgb) report_error("can't OR a terminal color"); foreground_color.value.rgb_color |= rhs.foreground_color.value.rgb_color; } if (!set_background_color) { set_background_color = rhs.set_background_color; background_color = rhs.background_color; } else if (rhs.set_background_color) { if (!background_color.is_rgb || !rhs.background_color.is_rgb) report_error("can't OR a terminal color"); background_color.value.rgb_color |= rhs.background_color.value.rgb_color; } ems = static_cast<emphasis>(static_cast<uint8_t>(ems) | static_cast<uint8_t>(rhs.ems)); return *this; } friend FMT_CONSTEXPR auto operator|(text_style lhs, const text_style& rhs) -> text_style { return lhs |= rhs; } FMT_CONSTEXPR auto has_foreground() const noexcept -> bool { return set_foreground_color; } FMT_CONSTEXPR auto has_background() const noexcept -> bool { return set_background_color; } FMT_CONSTEXPR auto has_emphasis() const noexcept -> bool { return static_cast<uint8_t>(ems) != 0; } FMT_CONSTEXPR auto get_foreground() const noexcept -> detail::color_type { FMT_ASSERT(has_foreground(), "no foreground specified for this style"); return foreground_color; } FMT_CONSTEXPR auto get_background() const noexcept -> detail::color_type { FMT_ASSERT(has_background(), "no background specified for this style"); return background_color; } FMT_CONSTEXPR auto get_emphasis() const noexcept -> emphasis { FMT_ASSERT(has_emphasis(), "no emphasis specified for this style"); return ems; } private: FMT_CONSTEXPR text_style(bool is_foreground, detail::color_type text_color) noexcept : set_foreground_color(), set_background_color(), ems() { if (is_foreground) { foreground_color = text_color; set_foreground_color = true; } else { background_color = text_color; set_background_color = true; } } friend FMT_CONSTEXPR auto fg(detail::color_type foreground) noexcept -> text_style; friend FMT_CONSTEXPR auto bg(detail::color_type background) noexcept -> text_style; detail::color_type foreground_color; detail::color_type background_color; bool set_foreground_color; bool set_background_color; emphasis ems; }; /// Creates a text style from the foreground (text) color. FMT_CONSTEXPR inline auto fg(detail::color_type foreground) noexcept -> text_style { return text_style(true, foreground); } /// Creates a text style from the background color. FMT_CONSTEXPR inline auto bg(detail::color_type background) noexcept -> text_style { return text_style(false, background); } FMT_CONSTEXPR inline auto operator|(emphasis lhs, emphasis rhs) noexcept -> text_style { return text_style(lhs) | rhs; } namespace detail { template <typename Char> struct ansi_color_escape { FMT_CONSTEXPR ansi_color_escape(color_type text_color, const char* esc) noexcept { // If we have a terminal color, we need to output another escape code // sequence. if (!text_color.is_rgb) { bool is_background = esc == string_view("\x1b[48;2;"); uint32_t value = text_color.value.term_color; // Background ASCII codes are the same as the foreground ones but with // 10 more. if (is_background) value += 10u; size_t index = 0; buffer[index++] = static_cast<Char>('\x1b'); buffer[index++] = static_cast<Char>('['); if (value >= 100u) { buffer[index++] = static_cast<Char>('1'); value %= 100u; } buffer[index++] = static_cast<Char>('0' + value / 10u); buffer[index++] = static_cast<Char>('0' + value % 10u); buffer[index++] = static_cast<Char>('m'); buffer[index++] = static_cast<Char>('\0'); return; } for (int i = 0; i < 7; i++) { buffer[i] = static_cast<Char>(esc[i]); } rgb color(text_color.value.rgb_color); to_esc(color.r, buffer + 7, ';'); to_esc(color.g, buffer + 11, ';'); to_esc(color.b, buffer + 15, 'm'); buffer[19] = static_cast<Char>(0); } FMT_CONSTEXPR ansi_color_escape(emphasis em) noexcept { uint8_t em_codes[num_emphases] = {}; if (has_emphasis(em, emphasis::bold)) em_codes[0] = 1; if (has_emphasis(em, emphasis::faint)) em_codes[1] = 2; if (has_emphasis(em, emphasis::italic)) em_codes[2] = 3; if (has_emphasis(em, emphasis::underline)) em_codes[3] = 4; if (has_emphasis(em, emphasis::blink)) em_codes[4] = 5; if (has_emphasis(em, emphasis::reverse)) em_codes[5] = 7; if (has_emphasis(em, emphasis::conceal)) em_codes[6] = 8; if (has_emphasis(em, emphasis::strikethrough)) em_codes[7] = 9; size_t index = 0; for (size_t i = 0; i < num_emphases; ++i) { if (!em_codes[i]) continue; buffer[index++] = static_cast<Char>('\x1b'); buffer[index++] = static_cast<Char>('['); buffer[index++] = static_cast<Char>('0' + em_codes[i]); buffer[index++] = static_cast<Char>('m'); } buffer[index++] = static_cast<Char>(0); } FMT_CONSTEXPR operator const Char*() const noexcept { return buffer; } FMT_CONSTEXPR auto begin() const noexcept -> const Char* { return buffer; } FMT_CONSTEXPR20 auto end() const noexcept -> const Char* { return buffer + basic_string_view<Char>(buffer).size(); } private: static constexpr size_t num_emphases = 8; Char buffer[7u + 3u * num_emphases + 1u]; static FMT_CONSTEXPR void to_esc(uint8_t c, Char* out, char delimiter) noexcept { out[0] = static_cast<Char>('0' + c / 100); out[1] = static_cast<Char>('0' + c / 10 % 10); out[2] = static_cast<Char>('0' + c % 10); out[3] = static_cast<Char>(delimiter); } static FMT_CONSTEXPR auto has_emphasis(emphasis em, emphasis mask) noexcept -> bool { return static_cast<uint8_t>(em) & static_cast<uint8_t>(mask); } }; template <typename Char> FMT_CONSTEXPR auto make_foreground_color(color_type foreground) noexcept -> ansi_color_escape<Char> { return ansi_color_escape<Char>(foreground, "\x1b[38;2;"); } template <typename Char> FMT_CONSTEXPR auto make_background_color(color_type background) noexcept -> ansi_color_escape<Char> { return ansi_color_escape<Char>(background, "\x1b[48;2;"); } template <typename Char> FMT_CONSTEXPR auto make_emphasis(emphasis em) noexcept -> ansi_color_escape<Char> { return ansi_color_escape<Char>(em); } template <typename Char> inline void reset_color(buffer<Char>& buffer) { auto reset_color = string_view("\x1b[0m"); buffer.append(reset_color.begin(), reset_color.end()); } template <typename T> struct styled_arg : view { const T& value; text_style style; styled_arg(const T& v, text_style s) : value(v), style(s) {} }; template <typename Char> void vformat_to(buffer<Char>& buf, const text_style& ts, basic_string_view<Char> fmt, basic_format_args<buffered_context<Char>> args) { bool has_style = false; if (ts.has_emphasis()) { has_style = true; auto emphasis = make_emphasis<Char>(ts.get_emphasis()); buf.append(emphasis.begin(), emphasis.end()); } if (ts.has_foreground()) { has_style = true; auto foreground = make_foreground_color<Char>(ts.get_foreground()); buf.append(foreground.begin(), foreground.end()); } if (ts.has_background()) { has_style = true; auto background = make_background_color<Char>(ts.get_background()); buf.append(background.begin(), background.end()); } vformat_to(buf, fmt, args); if (has_style) reset_color<Char>(buf); } } // namespace detail inline void vprint(FILE* f, const text_style& ts, string_view fmt, format_args args) { auto buf = memory_buffer(); detail::vformat_to(buf, ts, fmt, args); print(f, FMT_STRING("{}"), string_view(buf.begin(), buf.size())); } /** * Formats a string and prints it to the specified file stream using ANSI * escape sequences to specify text formatting. * * **Example**: * * fmt::print(fmt::emphasis::bold | fg(fmt::color::red), * "Elapsed time: {0:.2f} seconds", 1.23); */ template <typename... T> void print(FILE* f, const text_style& ts, format_string<T...> fmt, T&&... args) { vprint(f, ts, fmt.str, vargs<T...>{{args...}}); } /** * Formats a string and prints it to stdout using ANSI escape sequences to * specify text formatting. * * **Example**: * * fmt::print(fmt::emphasis::bold | fg(fmt::color::red), * "Elapsed time: {0:.2f} seconds", 1.23); */ template <typename... T> void print(const text_style& ts, format_string<T...> fmt, T&&... args) { return print(stdout, ts, fmt, std::forward<T>(args)...); } inline auto vformat(const text_style& ts, string_view fmt, format_args args) -> std::string { auto buf = memory_buffer(); detail::vformat_to(buf, ts, fmt, args); return fmt::to_string(buf); } /** * Formats arguments and returns the result as a string using ANSI escape * sequences to specify text formatting. * * **Example**: * * ``` * #include <fmt/color.h> * std::string message = fmt::format(fmt::emphasis::bold | fg(fmt::color::red), * "The answer is {}", 42); * ``` */ template <typename... T> inline auto format(const text_style& ts, format_string<T...> fmt, T&&... args) -> std::string { return fmt::vformat(ts, fmt.str, vargs<T...>{{args...}}); } /// Formats a string with the given text_style and writes the output to `out`. template <typename OutputIt, FMT_ENABLE_IF(detail::is_output_iterator<OutputIt, char>::value)> auto vformat_to(OutputIt out, const text_style& ts, string_view fmt, format_args args) -> OutputIt { auto&& buf = detail::get_buffer<char>(out); detail::vformat_to(buf, ts, fmt, args); return detail::get_iterator(buf, out); } /** * Formats arguments with the given text style, writes the result to the output * iterator `out` and returns the iterator past the end of the output range. * * **Example**: * * std::vector<char> out; * fmt::format_to(std::back_inserter(out), * fmt::emphasis::bold | fg(fmt::color::red), "{}", 42); */ template <typename OutputIt, typename... T, FMT_ENABLE_IF(detail::is_output_iterator<OutputIt, char>::value)> inline auto format_to(OutputIt out, const text_style& ts, format_string<T...> fmt, T&&... args) -> OutputIt { return vformat_to(out, ts, fmt.str, vargs<T...>{{args...}}); } template <typename T, typename Char> struct formatter<detail::styled_arg<T>, Char> : formatter<T, Char> { template <typename FormatContext> auto format(const detail::styled_arg<T>& arg, FormatContext& ctx) const -> decltype(ctx.out()) { const auto& ts = arg.style; auto out = ctx.out(); bool has_style = false; if (ts.has_emphasis()) { has_style = true; auto emphasis = detail::make_emphasis<Char>(ts.get_emphasis()); out = detail::copy<Char>(emphasis.begin(), emphasis.end(), out); } if (ts.has_foreground()) { has_style = true; auto foreground = detail::make_foreground_color<Char>(ts.get_foreground()); out = detail::copy<Char>(foreground.begin(), foreground.end(), out); } if (ts.has_background()) { has_style = true; auto background = detail::make_background_color<Char>(ts.get_background()); out = detail::copy<Char>(background.begin(), background.end(), out); } out = formatter<T, Char>::format(arg.value, ctx); if (has_style) { auto reset_color = string_view("\x1b[0m"); out = detail::copy<Char>(reset_color.begin(), reset_color.end(), out); } return out; } }; /** * Returns an argument that will be formatted using ANSI escape sequences, * to be used in a formatting function. * * **Example**: * * fmt::print("Elapsed time: {0:.2f} seconds", * fmt::styled(1.23, fmt::fg(fmt::color::green) | * fmt::bg(fmt::color::blue))); */ template <typename T> FMT_CONSTEXPR auto styled(const T& value, text_style ts) -> detail::styled_arg<remove_cvref_t<T>> { return detail::styled_arg<remove_cvref_t<T>>{value, ts}; } FMT_END_EXPORT FMT_END_NAMESPACE #endif // FMT_COLOR_H_ ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/vendor/fmt/compile.h�����������������������������������������������������������������0000664�0000000�0000000�00000044550�14771603147�0017243�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������// Formatting library for C++ - experimental format string compilation // // Copyright (c) 2012 - present, Victor Zverovich and fmt contributors // All rights reserved. // // For the license information refer to format.h. #ifndef FMT_COMPILE_H_ #define FMT_COMPILE_H_ #ifndef FMT_MODULE # include <iterator> // std::back_inserter #endif #include "format.h" FMT_BEGIN_NAMESPACE // A compile-time string which is compiled into fast formatting code. FMT_EXPORT class compiled_string {}; template <typename S> struct is_compiled_string : std::is_base_of<compiled_string, S> {}; namespace detail { /** * Converts a string literal `s` into a format string that will be parsed at * compile time and converted into efficient formatting code. Requires C++17 * `constexpr if` compiler support. * * **Example**: * * // Converts 42 into std::string using the most efficient method and no * // runtime format string processing. * std::string s = fmt::format(FMT_COMPILE("{}"), 42); */ #if defined(__cpp_if_constexpr) && defined(__cpp_return_type_deduction) # define FMT_COMPILE(s) FMT_STRING_IMPL(s, fmt::compiled_string) #else # define FMT_COMPILE(s) FMT_STRING(s) #endif template <typename T, typename... Tail> auto first(const T& value, const Tail&...) -> const T& { return value; } #if defined(__cpp_if_constexpr) && defined(__cpp_return_type_deduction) template <typename... Args> struct type_list {}; // Returns a reference to the argument at index N from [first, rest...]. template <int N, typename T, typename... Args> constexpr const auto& get([[maybe_unused]] const T& first, [[maybe_unused]] const Args&... rest) { static_assert(N < 1 + sizeof...(Args), "index is out of bounds"); if constexpr (N == 0) return first; else return detail::get<N - 1>(rest...); } # if FMT_USE_NONTYPE_TEMPLATE_ARGS template <int N, typename T, typename... Args, typename Char> constexpr auto get_arg_index_by_name(basic_string_view<Char> name) -> int { if constexpr (is_static_named_arg<T>()) { if (name == T::name) return N; } if constexpr (sizeof...(Args) > 0) return get_arg_index_by_name<N + 1, Args...>(name); (void)name; // Workaround an MSVC bug about "unused" parameter. return -1; } # endif template <typename... Args, typename Char> FMT_CONSTEXPR auto get_arg_index_by_name(basic_string_view<Char> name) -> int { # if FMT_USE_NONTYPE_TEMPLATE_ARGS if constexpr (sizeof...(Args) > 0) return get_arg_index_by_name<0, Args...>(name); # endif (void)name; return -1; } template <typename Char, typename... Args> constexpr int get_arg_index_by_name(basic_string_view<Char> name, type_list<Args...>) { return get_arg_index_by_name<Args...>(name); } template <int N, typename> struct get_type_impl; template <int N, typename... Args> struct get_type_impl<N, type_list<Args...>> { using type = remove_cvref_t<decltype(detail::get<N>(std::declval<Args>()...))>; }; template <int N, typename T> using get_type = typename get_type_impl<N, T>::type; template <typename T> struct is_compiled_format : std::false_type {}; template <typename Char> struct text { basic_string_view<Char> data; using char_type = Char; template <typename OutputIt, typename... Args> constexpr OutputIt format(OutputIt out, const Args&...) const { return write<Char>(out, data); } }; template <typename Char> struct is_compiled_format<text<Char>> : std::true_type {}; template <typename Char> constexpr text<Char> make_text(basic_string_view<Char> s, size_t pos, size_t size) { return {{&s[pos], size}}; } template <typename Char> struct code_unit { Char value; using char_type = Char; template <typename OutputIt, typename... Args> constexpr OutputIt format(OutputIt out, const Args&...) const { *out++ = value; return out; } }; // This ensures that the argument type is convertible to `const T&`. template <typename T, int N, typename... Args> constexpr const T& get_arg_checked(const Args&... args) { const auto& arg = detail::get<N>(args...); if constexpr (detail::is_named_arg<remove_cvref_t<decltype(arg)>>()) { return arg.value; } else { return arg; } } template <typename Char> struct is_compiled_format<code_unit<Char>> : std::true_type {}; // A replacement field that refers to argument N. template <typename Char, typename T, int N> struct field { using char_type = Char; template <typename OutputIt, typename... Args> constexpr OutputIt format(OutputIt out, const Args&... args) const { const T& arg = get_arg_checked<T, N>(args...); if constexpr (std::is_convertible<T, basic_string_view<Char>>::value) { auto s = basic_string_view<Char>(arg); return copy<Char>(s.begin(), s.end(), out); } else { return write<Char>(out, arg); } } }; template <typename Char, typename T, int N> struct is_compiled_format<field<Char, T, N>> : std::true_type {}; // A replacement field that refers to argument with name. template <typename Char> struct runtime_named_field { using char_type = Char; basic_string_view<Char> name; template <typename OutputIt, typename T> constexpr static bool try_format_argument( OutputIt& out, // [[maybe_unused]] due to unused-but-set-parameter warning in GCC 7,8,9 [[maybe_unused]] basic_string_view<Char> arg_name, const T& arg) { if constexpr (is_named_arg<typename std::remove_cv<T>::type>::value) { if (arg_name == arg.name) { out = write<Char>(out, arg.value); return true; } } return false; } template <typename OutputIt, typename... Args> constexpr OutputIt format(OutputIt out, const Args&... args) const { bool found = (try_format_argument(out, name, args) || ...); if (!found) { FMT_THROW(format_error("argument with specified name is not found")); } return out; } }; template <typename Char> struct is_compiled_format<runtime_named_field<Char>> : std::true_type {}; // A replacement field that refers to argument N and has format specifiers. template <typename Char, typename T, int N> struct spec_field { using char_type = Char; formatter<T, Char> fmt; template <typename OutputIt, typename... Args> constexpr FMT_INLINE OutputIt format(OutputIt out, const Args&... args) const { const auto& vargs = fmt::make_format_args<basic_format_context<OutputIt, Char>>(args...); basic_format_context<OutputIt, Char> ctx(out, vargs); return fmt.format(get_arg_checked<T, N>(args...), ctx); } }; template <typename Char, typename T, int N> struct is_compiled_format<spec_field<Char, T, N>> : std::true_type {}; template <typename L, typename R> struct concat { L lhs; R rhs; using char_type = typename L::char_type; template <typename OutputIt, typename... Args> constexpr OutputIt format(OutputIt out, const Args&... args) const { out = lhs.format(out, args...); return rhs.format(out, args...); } }; template <typename L, typename R> struct is_compiled_format<concat<L, R>> : std::true_type {}; template <typename L, typename R> constexpr concat<L, R> make_concat(L lhs, R rhs) { return {lhs, rhs}; } struct unknown_format {}; template <typename Char> constexpr size_t parse_text(basic_string_view<Char> str, size_t pos) { for (size_t size = str.size(); pos != size; ++pos) { if (str[pos] == '{' || str[pos] == '}') break; } return pos; } template <typename Args, size_t POS, int ID, typename S> constexpr auto compile_format_string(S fmt); template <typename Args, size_t POS, int ID, typename T, typename S> constexpr auto parse_tail(T head, S fmt) { if constexpr (POS != basic_string_view<typename S::char_type>(fmt).size()) { constexpr auto tail = compile_format_string<Args, POS, ID>(fmt); if constexpr (std::is_same<remove_cvref_t<decltype(tail)>, unknown_format>()) return tail; else return make_concat(head, tail); } else { return head; } } template <typename T, typename Char> struct parse_specs_result { formatter<T, Char> fmt; size_t end; int next_arg_id; }; enum { manual_indexing_id = -1 }; template <typename T, typename Char> constexpr parse_specs_result<T, Char> parse_specs(basic_string_view<Char> str, size_t pos, int next_arg_id) { str.remove_prefix(pos); auto ctx = compile_parse_context<Char>(str, max_value<int>(), nullptr, next_arg_id); auto f = formatter<T, Char>(); auto end = f.parse(ctx); return {f, pos + fmt::detail::to_unsigned(end - str.data()), next_arg_id == 0 ? manual_indexing_id : ctx.next_arg_id()}; } template <typename Char> struct arg_id_handler { arg_id_kind kind; arg_ref<Char> arg_id; constexpr int on_auto() { FMT_ASSERT(false, "handler cannot be used with automatic indexing"); return 0; } constexpr int on_index(int id) { kind = arg_id_kind::index; arg_id = arg_ref<Char>(id); return 0; } constexpr int on_name(basic_string_view<Char> id) { kind = arg_id_kind::name; arg_id = arg_ref<Char>(id); return 0; } }; template <typename Char> struct parse_arg_id_result { arg_id_kind kind; arg_ref<Char> arg_id; const Char* arg_id_end; }; template <int ID, typename Char> constexpr auto parse_arg_id(const Char* begin, const Char* end) { auto handler = arg_id_handler<Char>{arg_id_kind::none, arg_ref<Char>{}}; auto arg_id_end = parse_arg_id(begin, end, handler); return parse_arg_id_result<Char>{handler.kind, handler.arg_id, arg_id_end}; } template <typename T, typename Enable = void> struct field_type { using type = remove_cvref_t<T>; }; template <typename T> struct field_type<T, enable_if_t<detail::is_named_arg<T>::value>> { using type = remove_cvref_t<decltype(T::value)>; }; template <typename T, typename Args, size_t END_POS, int ARG_INDEX, int NEXT_ID, typename S> constexpr auto parse_replacement_field_then_tail(S fmt) { using char_type = typename S::char_type; constexpr auto str = basic_string_view<char_type>(fmt); constexpr char_type c = END_POS != str.size() ? str[END_POS] : char_type(); if constexpr (c == '}') { return parse_tail<Args, END_POS + 1, NEXT_ID>( field<char_type, typename field_type<T>::type, ARG_INDEX>(), fmt); } else if constexpr (c != ':') { FMT_THROW(format_error("expected ':'")); } else { constexpr auto result = parse_specs<typename field_type<T>::type>( str, END_POS + 1, NEXT_ID == manual_indexing_id ? 0 : NEXT_ID); if constexpr (result.end >= str.size() || str[result.end] != '}') { FMT_THROW(format_error("expected '}'")); return 0; } else { return parse_tail<Args, result.end + 1, result.next_arg_id>( spec_field<char_type, typename field_type<T>::type, ARG_INDEX>{ result.fmt}, fmt); } } } // Compiles a non-empty format string and returns the compiled representation // or unknown_format() on unrecognized input. template <typename Args, size_t POS, int ID, typename S> constexpr auto compile_format_string(S fmt) { using char_type = typename S::char_type; constexpr auto str = basic_string_view<char_type>(fmt); if constexpr (str[POS] == '{') { if constexpr (POS + 1 == str.size()) FMT_THROW(format_error("unmatched '{' in format string")); if constexpr (str[POS + 1] == '{') { return parse_tail<Args, POS + 2, ID>(make_text(str, POS, 1), fmt); } else if constexpr (str[POS + 1] == '}' || str[POS + 1] == ':') { static_assert(ID != manual_indexing_id, "cannot switch from manual to automatic argument indexing"); constexpr auto next_id = ID != manual_indexing_id ? ID + 1 : manual_indexing_id; return parse_replacement_field_then_tail<get_type<ID, Args>, Args, POS + 1, ID, next_id>(fmt); } else { constexpr auto arg_id_result = parse_arg_id<ID>(str.data() + POS + 1, str.data() + str.size()); constexpr auto arg_id_end_pos = arg_id_result.arg_id_end - str.data(); constexpr char_type c = arg_id_end_pos != str.size() ? str[arg_id_end_pos] : char_type(); static_assert(c == '}' || c == ':', "missing '}' in format string"); if constexpr (arg_id_result.kind == arg_id_kind::index) { static_assert( ID == manual_indexing_id || ID == 0, "cannot switch from automatic to manual argument indexing"); constexpr auto arg_index = arg_id_result.arg_id.index; return parse_replacement_field_then_tail<get_type<arg_index, Args>, Args, arg_id_end_pos, arg_index, manual_indexing_id>( fmt); } else if constexpr (arg_id_result.kind == arg_id_kind::name) { constexpr auto arg_index = get_arg_index_by_name(arg_id_result.arg_id.name, Args{}); if constexpr (arg_index >= 0) { constexpr auto next_id = ID != manual_indexing_id ? ID + 1 : manual_indexing_id; return parse_replacement_field_then_tail< decltype(get_type<arg_index, Args>::value), Args, arg_id_end_pos, arg_index, next_id>(fmt); } else if constexpr (c == '}') { return parse_tail<Args, arg_id_end_pos + 1, ID>( runtime_named_field<char_type>{arg_id_result.arg_id.name}, fmt); } else if constexpr (c == ':') { return unknown_format(); // no type info for specs parsing } } } } else if constexpr (str[POS] == '}') { if constexpr (POS + 1 == str.size()) FMT_THROW(format_error("unmatched '}' in format string")); return parse_tail<Args, POS + 2, ID>(make_text(str, POS, 1), fmt); } else { constexpr auto end = parse_text(str, POS + 1); if constexpr (end - POS > 1) { return parse_tail<Args, end, ID>(make_text(str, POS, end - POS), fmt); } else { return parse_tail<Args, end, ID>(code_unit<char_type>{str[POS]}, fmt); } } } template <typename... Args, typename S, FMT_ENABLE_IF(is_compiled_string<S>::value)> constexpr auto compile(S fmt) { constexpr auto str = basic_string_view<typename S::char_type>(fmt); if constexpr (str.size() == 0) { return detail::make_text(str, 0, 0); } else { constexpr auto result = detail::compile_format_string<detail::type_list<Args...>, 0, 0>(fmt); return result; } } #endif // defined(__cpp_if_constexpr) && defined(__cpp_return_type_deduction) } // namespace detail FMT_BEGIN_EXPORT #if defined(__cpp_if_constexpr) && defined(__cpp_return_type_deduction) template <typename CompiledFormat, typename... Args, typename Char = typename CompiledFormat::char_type, FMT_ENABLE_IF(detail::is_compiled_format<CompiledFormat>::value)> FMT_INLINE std::basic_string<Char> format(const CompiledFormat& cf, const Args&... args) { auto s = std::basic_string<Char>(); cf.format(std::back_inserter(s), args...); return s; } template <typename OutputIt, typename CompiledFormat, typename... Args, FMT_ENABLE_IF(detail::is_compiled_format<CompiledFormat>::value)> constexpr FMT_INLINE OutputIt format_to(OutputIt out, const CompiledFormat& cf, const Args&... args) { return cf.format(out, args...); } template <typename S, typename... Args, FMT_ENABLE_IF(is_compiled_string<S>::value)> FMT_INLINE std::basic_string<typename S::char_type> format(const S&, Args&&... args) { if constexpr (std::is_same<typename S::char_type, char>::value) { constexpr auto str = basic_string_view<typename S::char_type>(S()); if constexpr (str.size() == 2 && str[0] == '{' && str[1] == '}') { const auto& first = detail::first(args...); if constexpr (detail::is_named_arg< remove_cvref_t<decltype(first)>>::value) { return fmt::to_string(first.value); } else { return fmt::to_string(first); } } } constexpr auto compiled = detail::compile<Args...>(S()); if constexpr (std::is_same<remove_cvref_t<decltype(compiled)>, detail::unknown_format>()) { return fmt::format( static_cast<basic_string_view<typename S::char_type>>(S()), std::forward<Args>(args)...); } else { return fmt::format(compiled, std::forward<Args>(args)...); } } template <typename OutputIt, typename S, typename... Args, FMT_ENABLE_IF(is_compiled_string<S>::value)> FMT_CONSTEXPR OutputIt format_to(OutputIt out, const S&, Args&&... args) { constexpr auto compiled = detail::compile<Args...>(S()); if constexpr (std::is_same<remove_cvref_t<decltype(compiled)>, detail::unknown_format>()) { return fmt::format_to( out, static_cast<basic_string_view<typename S::char_type>>(S()), std::forward<Args>(args)...); } else { return fmt::format_to(out, compiled, std::forward<Args>(args)...); } } #endif template <typename OutputIt, typename S, typename... Args, FMT_ENABLE_IF(is_compiled_string<S>::value)> auto format_to_n(OutputIt out, size_t n, const S& fmt, Args&&... args) -> format_to_n_result<OutputIt> { using traits = detail::fixed_buffer_traits; auto buf = detail::iterator_buffer<OutputIt, char, traits>(out, n); fmt::format_to(std::back_inserter(buf), fmt, std::forward<Args>(args)...); return {buf.out(), buf.count()}; } template <typename S, typename... Args, FMT_ENABLE_IF(is_compiled_string<S>::value)> FMT_CONSTEXPR20 auto formatted_size(const S& fmt, const Args&... args) -> size_t { auto buf = detail::counting_buffer<>(); fmt::format_to(appender(buf), fmt, args...); return buf.count(); } template <typename S, typename... Args, FMT_ENABLE_IF(is_compiled_string<S>::value)> void print(std::FILE* f, const S& fmt, const Args&... args) { auto buf = memory_buffer(); fmt::format_to(appender(buf), fmt, args...); detail::print(f, {buf.data(), buf.size()}); } template <typename S, typename... Args, FMT_ENABLE_IF(is_compiled_string<S>::value)> void print(const S& fmt, const Args&... args) { print(stdout, fmt, args...); } #if FMT_USE_NONTYPE_TEMPLATE_ARGS inline namespace literals { template <detail::fixed_string Str> constexpr auto operator""_cf() { return FMT_COMPILE(Str.data); } } // namespace literals #endif FMT_END_EXPORT FMT_END_NAMESPACE #endif // FMT_COMPILE_H_ ��������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/vendor/fmt/core.h��������������������������������������������������������������������0000664�0000000�0000000�00000000273�14771603147�0016535�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������// This file is only provided for compatibility and may be removed in future // versions. Use fmt/base.h if you don't need fmt::format and fmt/format.h // otherwise. #include "format.h" �������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/vendor/fmt/format-inl.h��������������������������������������������������������������0000664�0000000�0000000�00000236145�14771603147�0017666�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������// Formatting library for C++ - implementation // // Copyright (c) 2012 - 2016, Victor Zverovich // All rights reserved. // // For the license information refer to format.h. #ifndef FMT_FORMAT_INL_H_ #define FMT_FORMAT_INL_H_ #ifndef FMT_MODULE # include <algorithm> # include <cerrno> // errno # include <climits> # include <cmath> # include <exception> #endif #if defined(_WIN32) && !defined(FMT_USE_WRITE_CONSOLE) # include <io.h> // _isatty #endif #include "format.h" #if FMT_USE_LOCALE # include <locale> #endif #ifndef FMT_FUNC # define FMT_FUNC #endif FMT_BEGIN_NAMESPACE namespace detail { FMT_FUNC void assert_fail(const char* file, int line, const char* message) { // Use unchecked std::fprintf to avoid triggering another assertion when // writing to stderr fails. fprintf(stderr, "%s:%d: assertion failed: %s", file, line, message); abort(); } FMT_FUNC void format_error_code(detail::buffer<char>& out, int error_code, string_view message) noexcept { // Report error code making sure that the output fits into // inline_buffer_size to avoid dynamic memory allocation and potential // bad_alloc. out.try_resize(0); static const char SEP[] = ": "; static const char ERROR_STR[] = "error "; // Subtract 2 to account for terminating null characters in SEP and ERROR_STR. size_t error_code_size = sizeof(SEP) + sizeof(ERROR_STR) - 2; auto abs_value = static_cast<uint32_or_64_or_128_t<int>>(error_code); if (detail::is_negative(error_code)) { abs_value = 0 - abs_value; ++error_code_size; } error_code_size += detail::to_unsigned(detail::count_digits(abs_value)); auto it = appender(out); if (message.size() <= inline_buffer_size - error_code_size) fmt::format_to(it, FMT_STRING("{}{}"), message, SEP); fmt::format_to(it, FMT_STRING("{}{}"), ERROR_STR, error_code); FMT_ASSERT(out.size() <= inline_buffer_size, ""); } FMT_FUNC void do_report_error(format_func func, int error_code, const char* message) noexcept { memory_buffer full_message; func(full_message, error_code, message); // Don't use fwrite_all because the latter may throw. if (std::fwrite(full_message.data(), full_message.size(), 1, stderr) > 0) std::fputc('\n', stderr); } // A wrapper around fwrite that throws on error. inline void fwrite_all(const void* ptr, size_t count, FILE* stream) { size_t written = std::fwrite(ptr, 1, count, stream); if (written < count) FMT_THROW(system_error(errno, FMT_STRING("cannot write to file"))); } #if FMT_USE_LOCALE using std::locale; using std::numpunct; using std::use_facet; template <typename Locale> locale_ref::locale_ref(const Locale& loc) : locale_(&loc) { static_assert(std::is_same<Locale, locale>::value, ""); } #else struct locale {}; template <typename Char> struct numpunct { auto grouping() const -> std::string { return "\03"; } auto thousands_sep() const -> Char { return ','; } auto decimal_point() const -> Char { return '.'; } }; template <typename Facet> Facet use_facet(locale) { return {}; } #endif // FMT_USE_LOCALE template <typename Locale> auto locale_ref::get() const -> Locale { static_assert(std::is_same<Locale, locale>::value, ""); #if FMT_USE_LOCALE if (locale_) return *static_cast<const locale*>(locale_); #endif return locale(); } template <typename Char> FMT_FUNC auto thousands_sep_impl(locale_ref loc) -> thousands_sep_result<Char> { auto&& facet = use_facet<numpunct<Char>>(loc.get<locale>()); auto grouping = facet.grouping(); auto thousands_sep = grouping.empty() ? Char() : facet.thousands_sep(); return {std::move(grouping), thousands_sep}; } template <typename Char> FMT_FUNC auto decimal_point_impl(locale_ref loc) -> Char { return use_facet<numpunct<Char>>(loc.get<locale>()).decimal_point(); } #if FMT_USE_LOCALE FMT_FUNC auto write_loc(appender out, loc_value value, const format_specs& specs, locale_ref loc) -> bool { auto locale = loc.get<std::locale>(); // We cannot use the num_put<char> facet because it may produce output in // a wrong encoding. using facet = format_facet<std::locale>; if (std::has_facet<facet>(locale)) return use_facet<facet>(locale).put(out, value, specs); return facet(locale).put(out, value, specs); } #endif } // namespace detail FMT_FUNC void report_error(const char* message) { #if FMT_USE_EXCEPTIONS // Use FMT_THROW instead of throw to avoid bogus unreachable code warnings // from MSVC. FMT_THROW(format_error(message)); #else fputs(message, stderr); abort(); #endif } template <typename Locale> typename Locale::id format_facet<Locale>::id; template <typename Locale> format_facet<Locale>::format_facet(Locale& loc) { auto& np = detail::use_facet<detail::numpunct<char>>(loc); grouping_ = np.grouping(); if (!grouping_.empty()) separator_ = std::string(1, np.thousands_sep()); } #if FMT_USE_LOCALE template <> FMT_API FMT_FUNC auto format_facet<std::locale>::do_put( appender out, loc_value val, const format_specs& specs) const -> bool { return val.visit( detail::loc_writer<>{out, specs, separator_, grouping_, decimal_point_}); } #endif FMT_FUNC auto vsystem_error(int error_code, string_view fmt, format_args args) -> std::system_error { auto ec = std::error_code(error_code, std::generic_category()); return std::system_error(ec, vformat(fmt, args)); } namespace detail { template <typename F> inline auto operator==(basic_fp<F> x, basic_fp<F> y) -> bool { return x.f == y.f && x.e == y.e; } // Compilers should be able to optimize this into the ror instruction. FMT_CONSTEXPR inline auto rotr(uint32_t n, uint32_t r) noexcept -> uint32_t { r &= 31; return (n >> r) | (n << (32 - r)); } FMT_CONSTEXPR inline auto rotr(uint64_t n, uint32_t r) noexcept -> uint64_t { r &= 63; return (n >> r) | (n << (64 - r)); } // Implementation of Dragonbox algorithm: https://github.com/jk-jeon/dragonbox. namespace dragonbox { // Computes upper 64 bits of multiplication of a 32-bit unsigned integer and a // 64-bit unsigned integer. inline auto umul96_upper64(uint32_t x, uint64_t y) noexcept -> uint64_t { return umul128_upper64(static_cast<uint64_t>(x) << 32, y); } // Computes lower 128 bits of multiplication of a 64-bit unsigned integer and a // 128-bit unsigned integer. inline auto umul192_lower128(uint64_t x, uint128_fallback y) noexcept -> uint128_fallback { uint64_t high = x * y.high(); uint128_fallback high_low = umul128(x, y.low()); return {high + high_low.high(), high_low.low()}; } // Computes lower 64 bits of multiplication of a 32-bit unsigned integer and a // 64-bit unsigned integer. inline auto umul96_lower64(uint32_t x, uint64_t y) noexcept -> uint64_t { return x * y; } // Various fast log computations. inline auto floor_log10_pow2_minus_log10_4_over_3(int e) noexcept -> int { FMT_ASSERT(e <= 2936 && e >= -2985, "too large exponent"); return (e * 631305 - 261663) >> 21; } FMT_INLINE_VARIABLE constexpr struct { uint32_t divisor; int shift_amount; } div_small_pow10_infos[] = {{10, 16}, {100, 16}}; // Replaces n by floor(n / pow(10, N)) returning true if and only if n is // divisible by pow(10, N). // Precondition: n <= pow(10, N + 1). template <int N> auto check_divisibility_and_divide_by_pow10(uint32_t& n) noexcept -> bool { // The numbers below are chosen such that: // 1. floor(n/d) = floor(nm / 2^k) where d=10 or d=100, // 2. nm mod 2^k < m if and only if n is divisible by d, // where m is magic_number, k is shift_amount // and d is divisor. // // Item 1 is a common technique of replacing division by a constant with // multiplication, see e.g. "Division by Invariant Integers Using // Multiplication" by Granlund and Montgomery (1994). magic_number (m) is set // to ceil(2^k/d) for large enough k. // The idea for item 2 originates from Schubfach. constexpr auto info = div_small_pow10_infos[N - 1]; FMT_ASSERT(n <= info.divisor * 10, "n is too large"); constexpr uint32_t magic_number = (1u << info.shift_amount) / info.divisor + 1; n *= magic_number; const uint32_t comparison_mask = (1u << info.shift_amount) - 1; bool result = (n & comparison_mask) < magic_number; n >>= info.shift_amount; return result; } // Computes floor(n / pow(10, N)) for small n and N. // Precondition: n <= pow(10, N + 1). template <int N> auto small_division_by_pow10(uint32_t n) noexcept -> uint32_t { constexpr auto info = div_small_pow10_infos[N - 1]; FMT_ASSERT(n <= info.divisor * 10, "n is too large"); constexpr uint32_t magic_number = (1u << info.shift_amount) / info.divisor + 1; return (n * magic_number) >> info.shift_amount; } // Computes floor(n / 10^(kappa + 1)) (float) inline auto divide_by_10_to_kappa_plus_1(uint32_t n) noexcept -> uint32_t { // 1374389535 = ceil(2^37/100) return static_cast<uint32_t>((static_cast<uint64_t>(n) * 1374389535) >> 37); } // Computes floor(n / 10^(kappa + 1)) (double) inline auto divide_by_10_to_kappa_plus_1(uint64_t n) noexcept -> uint64_t { // 2361183241434822607 = ceil(2^(64+7)/1000) return umul128_upper64(n, 2361183241434822607ull) >> 7; } // Various subroutines using pow10 cache template <typename T> struct cache_accessor; template <> struct cache_accessor<float> { using carrier_uint = float_info<float>::carrier_uint; using cache_entry_type = uint64_t; static auto get_cached_power(int k) noexcept -> uint64_t { FMT_ASSERT(k >= float_info<float>::min_k && k <= float_info<float>::max_k, "k is out of range"); static constexpr const uint64_t pow10_significands[] = { 0x81ceb32c4b43fcf5, 0xa2425ff75e14fc32, 0xcad2f7f5359a3b3f, 0xfd87b5f28300ca0e, 0x9e74d1b791e07e49, 0xc612062576589ddb, 0xf79687aed3eec552, 0x9abe14cd44753b53, 0xc16d9a0095928a28, 0xf1c90080baf72cb2, 0x971da05074da7bef, 0xbce5086492111aeb, 0xec1e4a7db69561a6, 0x9392ee8e921d5d08, 0xb877aa3236a4b44a, 0xe69594bec44de15c, 0x901d7cf73ab0acda, 0xb424dc35095cd810, 0xe12e13424bb40e14, 0x8cbccc096f5088cc, 0xafebff0bcb24aaff, 0xdbe6fecebdedd5bf, 0x89705f4136b4a598, 0xabcc77118461cefd, 0xd6bf94d5e57a42bd, 0x8637bd05af6c69b6, 0xa7c5ac471b478424, 0xd1b71758e219652c, 0x83126e978d4fdf3c, 0xa3d70a3d70a3d70b, 0xcccccccccccccccd, 0x8000000000000000, 0xa000000000000000, 0xc800000000000000, 0xfa00000000000000, 0x9c40000000000000, 0xc350000000000000, 0xf424000000000000, 0x9896800000000000, 0xbebc200000000000, 0xee6b280000000000, 0x9502f90000000000, 0xba43b74000000000, 0xe8d4a51000000000, 0x9184e72a00000000, 0xb5e620f480000000, 0xe35fa931a0000000, 0x8e1bc9bf04000000, 0xb1a2bc2ec5000000, 0xde0b6b3a76400000, 0x8ac7230489e80000, 0xad78ebc5ac620000, 0xd8d726b7177a8000, 0x878678326eac9000, 0xa968163f0a57b400, 0xd3c21bcecceda100, 0x84595161401484a0, 0xa56fa5b99019a5c8, 0xcecb8f27f4200f3a, 0x813f3978f8940985, 0xa18f07d736b90be6, 0xc9f2c9cd04674edf, 0xfc6f7c4045812297, 0x9dc5ada82b70b59e, 0xc5371912364ce306, 0xf684df56c3e01bc7, 0x9a130b963a6c115d, 0xc097ce7bc90715b4, 0xf0bdc21abb48db21, 0x96769950b50d88f5, 0xbc143fa4e250eb32, 0xeb194f8e1ae525fe, 0x92efd1b8d0cf37bf, 0xb7abc627050305ae, 0xe596b7b0c643c71a, 0x8f7e32ce7bea5c70, 0xb35dbf821ae4f38c, 0xe0352f62a19e306f}; return pow10_significands[k - float_info<float>::min_k]; } struct compute_mul_result { carrier_uint result; bool is_integer; }; struct compute_mul_parity_result { bool parity; bool is_integer; }; static auto compute_mul(carrier_uint u, const cache_entry_type& cache) noexcept -> compute_mul_result { auto r = umul96_upper64(u, cache); return {static_cast<carrier_uint>(r >> 32), static_cast<carrier_uint>(r) == 0}; } static auto compute_delta(const cache_entry_type& cache, int beta) noexcept -> uint32_t { return static_cast<uint32_t>(cache >> (64 - 1 - beta)); } static auto compute_mul_parity(carrier_uint two_f, const cache_entry_type& cache, int beta) noexcept -> compute_mul_parity_result { FMT_ASSERT(beta >= 1, ""); FMT_ASSERT(beta < 64, ""); auto r = umul96_lower64(two_f, cache); return {((r >> (64 - beta)) & 1) != 0, static_cast<uint32_t>(r >> (32 - beta)) == 0}; } static auto compute_left_endpoint_for_shorter_interval_case( const cache_entry_type& cache, int beta) noexcept -> carrier_uint { return static_cast<carrier_uint>( (cache - (cache >> (num_significand_bits<float>() + 2))) >> (64 - num_significand_bits<float>() - 1 - beta)); } static auto compute_right_endpoint_for_shorter_interval_case( const cache_entry_type& cache, int beta) noexcept -> carrier_uint { return static_cast<carrier_uint>( (cache + (cache >> (num_significand_bits<float>() + 1))) >> (64 - num_significand_bits<float>() - 1 - beta)); } static auto compute_round_up_for_shorter_interval_case( const cache_entry_type& cache, int beta) noexcept -> carrier_uint { return (static_cast<carrier_uint>( cache >> (64 - num_significand_bits<float>() - 2 - beta)) + 1) / 2; } }; template <> struct cache_accessor<double> { using carrier_uint = float_info<double>::carrier_uint; using cache_entry_type = uint128_fallback; static auto get_cached_power(int k) noexcept -> uint128_fallback { FMT_ASSERT(k >= float_info<double>::min_k && k <= float_info<double>::max_k, "k is out of range"); static constexpr const uint128_fallback pow10_significands[] = { #if FMT_USE_FULL_CACHE_DRAGONBOX {0xff77b1fcbebcdc4f, 0x25e8e89c13bb0f7b}, {0x9faacf3df73609b1, 0x77b191618c54e9ad}, {0xc795830d75038c1d, 0xd59df5b9ef6a2418}, {0xf97ae3d0d2446f25, 0x4b0573286b44ad1e}, {0x9becce62836ac577, 0x4ee367f9430aec33}, {0xc2e801fb244576d5, 0x229c41f793cda740}, {0xf3a20279ed56d48a, 0x6b43527578c11110}, {0x9845418c345644d6, 0x830a13896b78aaaa}, {0xbe5691ef416bd60c, 0x23cc986bc656d554}, {0xedec366b11c6cb8f, 0x2cbfbe86b7ec8aa9}, {0x94b3a202eb1c3f39, 0x7bf7d71432f3d6aa}, {0xb9e08a83a5e34f07, 0xdaf5ccd93fb0cc54}, {0xe858ad248f5c22c9, 0xd1b3400f8f9cff69}, {0x91376c36d99995be, 0x23100809b9c21fa2}, {0xb58547448ffffb2d, 0xabd40a0c2832a78b}, {0xe2e69915b3fff9f9, 0x16c90c8f323f516d}, {0x8dd01fad907ffc3b, 0xae3da7d97f6792e4}, {0xb1442798f49ffb4a, 0x99cd11cfdf41779d}, {0xdd95317f31c7fa1d, 0x40405643d711d584}, {0x8a7d3eef7f1cfc52, 0x482835ea666b2573}, {0xad1c8eab5ee43b66, 0xda3243650005eed0}, {0xd863b256369d4a40, 0x90bed43e40076a83}, {0x873e4f75e2224e68, 0x5a7744a6e804a292}, {0xa90de3535aaae202, 0x711515d0a205cb37}, {0xd3515c2831559a83, 0x0d5a5b44ca873e04}, {0x8412d9991ed58091, 0xe858790afe9486c3}, {0xa5178fff668ae0b6, 0x626e974dbe39a873}, {0xce5d73ff402d98e3, 0xfb0a3d212dc81290}, {0x80fa687f881c7f8e, 0x7ce66634bc9d0b9a}, {0xa139029f6a239f72, 0x1c1fffc1ebc44e81}, {0xc987434744ac874e, 0xa327ffb266b56221}, {0xfbe9141915d7a922, 0x4bf1ff9f0062baa9}, {0x9d71ac8fada6c9b5, 0x6f773fc3603db4aa}, {0xc4ce17b399107c22, 0xcb550fb4384d21d4}, {0xf6019da07f549b2b, 0x7e2a53a146606a49}, {0x99c102844f94e0fb, 0x2eda7444cbfc426e}, {0xc0314325637a1939, 0xfa911155fefb5309}, {0xf03d93eebc589f88, 0x793555ab7eba27cb}, {0x96267c7535b763b5, 0x4bc1558b2f3458df}, {0xbbb01b9283253ca2, 0x9eb1aaedfb016f17}, {0xea9c227723ee8bcb, 0x465e15a979c1cadd}, {0x92a1958a7675175f, 0x0bfacd89ec191eca}, {0xb749faed14125d36, 0xcef980ec671f667c}, {0xe51c79a85916f484, 0x82b7e12780e7401b}, {0x8f31cc0937ae58d2, 0xd1b2ecb8b0908811}, {0xb2fe3f0b8599ef07, 0x861fa7e6dcb4aa16}, {0xdfbdcece67006ac9, 0x67a791e093e1d49b}, {0x8bd6a141006042bd, 0xe0c8bb2c5c6d24e1}, {0xaecc49914078536d, 0x58fae9f773886e19}, {0xda7f5bf590966848, 0xaf39a475506a899f}, {0x888f99797a5e012d, 0x6d8406c952429604}, {0xaab37fd7d8f58178, 0xc8e5087ba6d33b84}, {0xd5605fcdcf32e1d6, 0xfb1e4a9a90880a65}, {0x855c3be0a17fcd26, 0x5cf2eea09a550680}, {0xa6b34ad8c9dfc06f, 0xf42faa48c0ea481f}, {0xd0601d8efc57b08b, 0xf13b94daf124da27}, {0x823c12795db6ce57, 0x76c53d08d6b70859}, {0xa2cb1717b52481ed, 0x54768c4b0c64ca6f}, {0xcb7ddcdda26da268, 0xa9942f5dcf7dfd0a}, {0xfe5d54150b090b02, 0xd3f93b35435d7c4d}, {0x9efa548d26e5a6e1, 0xc47bc5014a1a6db0}, {0xc6b8e9b0709f109a, 0x359ab6419ca1091c}, {0xf867241c8cc6d4c0, 0xc30163d203c94b63}, {0x9b407691d7fc44f8, 0x79e0de63425dcf1e}, {0xc21094364dfb5636, 0x985915fc12f542e5}, {0xf294b943e17a2bc4, 0x3e6f5b7b17b2939e}, {0x979cf3ca6cec5b5a, 0xa705992ceecf9c43}, {0xbd8430bd08277231, 0x50c6ff782a838354}, {0xece53cec4a314ebd, 0xa4f8bf5635246429}, {0x940f4613ae5ed136, 0x871b7795e136be9a}, {0xb913179899f68584, 0x28e2557b59846e40}, {0xe757dd7ec07426e5, 0x331aeada2fe589d0}, {0x9096ea6f3848984f, 0x3ff0d2c85def7622}, {0xb4bca50b065abe63, 0x0fed077a756b53aa}, {0xe1ebce4dc7f16dfb, 0xd3e8495912c62895}, {0x8d3360f09cf6e4bd, 0x64712dd7abbbd95d}, {0xb080392cc4349dec, 0xbd8d794d96aacfb4}, {0xdca04777f541c567, 0xecf0d7a0fc5583a1}, {0x89e42caaf9491b60, 0xf41686c49db57245}, {0xac5d37d5b79b6239, 0x311c2875c522ced6}, {0xd77485cb25823ac7, 0x7d633293366b828c}, {0x86a8d39ef77164bc, 0xae5dff9c02033198}, {0xa8530886b54dbdeb, 0xd9f57f830283fdfd}, {0xd267caa862a12d66, 0xd072df63c324fd7c}, {0x8380dea93da4bc60, 0x4247cb9e59f71e6e}, {0xa46116538d0deb78, 0x52d9be85f074e609}, {0xcd795be870516656, 0x67902e276c921f8c}, {0x806bd9714632dff6, 0x00ba1cd8a3db53b7}, {0xa086cfcd97bf97f3, 0x80e8a40eccd228a5}, {0xc8a883c0fdaf7df0, 0x6122cd128006b2ce}, {0xfad2a4b13d1b5d6c, 0x796b805720085f82}, {0x9cc3a6eec6311a63, 0xcbe3303674053bb1}, {0xc3f490aa77bd60fc, 0xbedbfc4411068a9d}, {0xf4f1b4d515acb93b, 0xee92fb5515482d45}, {0x991711052d8bf3c5, 0x751bdd152d4d1c4b}, {0xbf5cd54678eef0b6, 0xd262d45a78a0635e}, {0xef340a98172aace4, 0x86fb897116c87c35}, {0x9580869f0e7aac0e, 0xd45d35e6ae3d4da1}, {0xbae0a846d2195712, 0x8974836059cca10a}, {0xe998d258869facd7, 0x2bd1a438703fc94c}, {0x91ff83775423cc06, 0x7b6306a34627ddd0}, {0xb67f6455292cbf08, 0x1a3bc84c17b1d543}, {0xe41f3d6a7377eeca, 0x20caba5f1d9e4a94}, {0x8e938662882af53e, 0x547eb47b7282ee9d}, {0xb23867fb2a35b28d, 0xe99e619a4f23aa44}, {0xdec681f9f4c31f31, 0x6405fa00e2ec94d5}, {0x8b3c113c38f9f37e, 0xde83bc408dd3dd05}, {0xae0b158b4738705e, 0x9624ab50b148d446}, {0xd98ddaee19068c76, 0x3badd624dd9b0958}, {0x87f8a8d4cfa417c9, 0xe54ca5d70a80e5d7}, {0xa9f6d30a038d1dbc, 0x5e9fcf4ccd211f4d}, {0xd47487cc8470652b, 0x7647c32000696720}, {0x84c8d4dfd2c63f3b, 0x29ecd9f40041e074}, {0xa5fb0a17c777cf09, 0xf468107100525891}, {0xcf79cc9db955c2cc, 0x7182148d4066eeb5}, {0x81ac1fe293d599bf, 0xc6f14cd848405531}, {0xa21727db38cb002f, 0xb8ada00e5a506a7d}, {0xca9cf1d206fdc03b, 0xa6d90811f0e4851d}, {0xfd442e4688bd304a, 0x908f4a166d1da664}, {0x9e4a9cec15763e2e, 0x9a598e4e043287ff}, {0xc5dd44271ad3cdba, 0x40eff1e1853f29fe}, {0xf7549530e188c128, 0xd12bee59e68ef47d}, {0x9a94dd3e8cf578b9, 0x82bb74f8301958cf}, {0xc13a148e3032d6e7, 0xe36a52363c1faf02}, {0xf18899b1bc3f8ca1, 0xdc44e6c3cb279ac2}, {0x96f5600f15a7b7e5, 0x29ab103a5ef8c0ba}, {0xbcb2b812db11a5de, 0x7415d448f6b6f0e8}, {0xebdf661791d60f56, 0x111b495b3464ad22}, {0x936b9fcebb25c995, 0xcab10dd900beec35}, {0xb84687c269ef3bfb, 0x3d5d514f40eea743}, {0xe65829b3046b0afa, 0x0cb4a5a3112a5113}, {0x8ff71a0fe2c2e6dc, 0x47f0e785eaba72ac}, {0xb3f4e093db73a093, 0x59ed216765690f57}, {0xe0f218b8d25088b8, 0x306869c13ec3532d}, {0x8c974f7383725573, 0x1e414218c73a13fc}, {0xafbd2350644eeacf, 0xe5d1929ef90898fb}, {0xdbac6c247d62a583, 0xdf45f746b74abf3a}, {0x894bc396ce5da772, 0x6b8bba8c328eb784}, {0xab9eb47c81f5114f, 0x066ea92f3f326565}, {0xd686619ba27255a2, 0xc80a537b0efefebe}, {0x8613fd0145877585, 0xbd06742ce95f5f37}, {0xa798fc4196e952e7, 0x2c48113823b73705}, {0xd17f3b51fca3a7a0, 0xf75a15862ca504c6}, {0x82ef85133de648c4, 0x9a984d73dbe722fc}, {0xa3ab66580d5fdaf5, 0xc13e60d0d2e0ebbb}, {0xcc963fee10b7d1b3, 0x318df905079926a9}, {0xffbbcfe994e5c61f, 0xfdf17746497f7053}, {0x9fd561f1fd0f9bd3, 0xfeb6ea8bedefa634}, {0xc7caba6e7c5382c8, 0xfe64a52ee96b8fc1}, {0xf9bd690a1b68637b, 0x3dfdce7aa3c673b1}, {0x9c1661a651213e2d, 0x06bea10ca65c084f}, {0xc31bfa0fe5698db8, 0x486e494fcff30a63}, {0xf3e2f893dec3f126, 0x5a89dba3c3efccfb}, {0x986ddb5c6b3a76b7, 0xf89629465a75e01d}, {0xbe89523386091465, 0xf6bbb397f1135824}, {0xee2ba6c0678b597f, 0x746aa07ded582e2d}, {0x94db483840b717ef, 0xa8c2a44eb4571cdd}, {0xba121a4650e4ddeb, 0x92f34d62616ce414}, {0xe896a0d7e51e1566, 0x77b020baf9c81d18}, {0x915e2486ef32cd60, 0x0ace1474dc1d122f}, {0xb5b5ada8aaff80b8, 0x0d819992132456bb}, {0xe3231912d5bf60e6, 0x10e1fff697ed6c6a}, {0x8df5efabc5979c8f, 0xca8d3ffa1ef463c2}, {0xb1736b96b6fd83b3, 0xbd308ff8a6b17cb3}, {0xddd0467c64bce4a0, 0xac7cb3f6d05ddbdf}, {0x8aa22c0dbef60ee4, 0x6bcdf07a423aa96c}, {0xad4ab7112eb3929d, 0x86c16c98d2c953c7}, {0xd89d64d57a607744, 0xe871c7bf077ba8b8}, {0x87625f056c7c4a8b, 0x11471cd764ad4973}, {0xa93af6c6c79b5d2d, 0xd598e40d3dd89bd0}, {0xd389b47879823479, 0x4aff1d108d4ec2c4}, {0x843610cb4bf160cb, 0xcedf722a585139bb}, {0xa54394fe1eedb8fe, 0xc2974eb4ee658829}, {0xce947a3da6a9273e, 0x733d226229feea33}, {0x811ccc668829b887, 0x0806357d5a3f5260}, {0xa163ff802a3426a8, 0xca07c2dcb0cf26f8}, {0xc9bcff6034c13052, 0xfc89b393dd02f0b6}, {0xfc2c3f3841f17c67, 0xbbac2078d443ace3}, {0x9d9ba7832936edc0, 0xd54b944b84aa4c0e}, {0xc5029163f384a931, 0x0a9e795e65d4df12}, {0xf64335bcf065d37d, 0x4d4617b5ff4a16d6}, {0x99ea0196163fa42e, 0x504bced1bf8e4e46}, {0xc06481fb9bcf8d39, 0xe45ec2862f71e1d7}, {0xf07da27a82c37088, 0x5d767327bb4e5a4d}, {0x964e858c91ba2655, 0x3a6a07f8d510f870}, {0xbbe226efb628afea, 0x890489f70a55368c}, {0xeadab0aba3b2dbe5, 0x2b45ac74ccea842f}, {0x92c8ae6b464fc96f, 0x3b0b8bc90012929e}, {0xb77ada0617e3bbcb, 0x09ce6ebb40173745}, {0xe55990879ddcaabd, 0xcc420a6a101d0516}, {0x8f57fa54c2a9eab6, 0x9fa946824a12232e}, {0xb32df8e9f3546564, 0x47939822dc96abfa}, {0xdff9772470297ebd, 0x59787e2b93bc56f8}, {0x8bfbea76c619ef36, 0x57eb4edb3c55b65b}, {0xaefae51477a06b03, 0xede622920b6b23f2}, {0xdab99e59958885c4, 0xe95fab368e45ecee}, {0x88b402f7fd75539b, 0x11dbcb0218ebb415}, {0xaae103b5fcd2a881, 0xd652bdc29f26a11a}, {0xd59944a37c0752a2, 0x4be76d3346f04960}, {0x857fcae62d8493a5, 0x6f70a4400c562ddc}, {0xa6dfbd9fb8e5b88e, 0xcb4ccd500f6bb953}, {0xd097ad07a71f26b2, 0x7e2000a41346a7a8}, {0x825ecc24c873782f, 0x8ed400668c0c28c9}, {0xa2f67f2dfa90563b, 0x728900802f0f32fb}, {0xcbb41ef979346bca, 0x4f2b40a03ad2ffba}, {0xfea126b7d78186bc, 0xe2f610c84987bfa9}, {0x9f24b832e6b0f436, 0x0dd9ca7d2df4d7ca}, {0xc6ede63fa05d3143, 0x91503d1c79720dbc}, {0xf8a95fcf88747d94, 0x75a44c6397ce912b}, {0x9b69dbe1b548ce7c, 0xc986afbe3ee11abb}, {0xc24452da229b021b, 0xfbe85badce996169}, {0xf2d56790ab41c2a2, 0xfae27299423fb9c4}, {0x97c560ba6b0919a5, 0xdccd879fc967d41b}, {0xbdb6b8e905cb600f, 0x5400e987bbc1c921}, {0xed246723473e3813, 0x290123e9aab23b69}, {0x9436c0760c86e30b, 0xf9a0b6720aaf6522}, {0xb94470938fa89bce, 0xf808e40e8d5b3e6a}, {0xe7958cb87392c2c2, 0xb60b1d1230b20e05}, {0x90bd77f3483bb9b9, 0xb1c6f22b5e6f48c3}, {0xb4ecd5f01a4aa828, 0x1e38aeb6360b1af4}, {0xe2280b6c20dd5232, 0x25c6da63c38de1b1}, {0x8d590723948a535f, 0x579c487e5a38ad0f}, {0xb0af48ec79ace837, 0x2d835a9df0c6d852}, {0xdcdb1b2798182244, 0xf8e431456cf88e66}, {0x8a08f0f8bf0f156b, 0x1b8e9ecb641b5900}, {0xac8b2d36eed2dac5, 0xe272467e3d222f40}, {0xd7adf884aa879177, 0x5b0ed81dcc6abb10}, {0x86ccbb52ea94baea, 0x98e947129fc2b4ea}, {0xa87fea27a539e9a5, 0x3f2398d747b36225}, {0xd29fe4b18e88640e, 0x8eec7f0d19a03aae}, {0x83a3eeeef9153e89, 0x1953cf68300424ad}, {0xa48ceaaab75a8e2b, 0x5fa8c3423c052dd8}, {0xcdb02555653131b6, 0x3792f412cb06794e}, {0x808e17555f3ebf11, 0xe2bbd88bbee40bd1}, {0xa0b19d2ab70e6ed6, 0x5b6aceaeae9d0ec5}, {0xc8de047564d20a8b, 0xf245825a5a445276}, {0xfb158592be068d2e, 0xeed6e2f0f0d56713}, {0x9ced737bb6c4183d, 0x55464dd69685606c}, {0xc428d05aa4751e4c, 0xaa97e14c3c26b887}, {0xf53304714d9265df, 0xd53dd99f4b3066a9}, {0x993fe2c6d07b7fab, 0xe546a8038efe402a}, {0xbf8fdb78849a5f96, 0xde98520472bdd034}, {0xef73d256a5c0f77c, 0x963e66858f6d4441}, {0x95a8637627989aad, 0xdde7001379a44aa9}, {0xbb127c53b17ec159, 0x5560c018580d5d53}, {0xe9d71b689dde71af, 0xaab8f01e6e10b4a7}, {0x9226712162ab070d, 0xcab3961304ca70e9}, {0xb6b00d69bb55c8d1, 0x3d607b97c5fd0d23}, {0xe45c10c42a2b3b05, 0x8cb89a7db77c506b}, {0x8eb98a7a9a5b04e3, 0x77f3608e92adb243}, {0xb267ed1940f1c61c, 0x55f038b237591ed4}, {0xdf01e85f912e37a3, 0x6b6c46dec52f6689}, {0x8b61313bbabce2c6, 0x2323ac4b3b3da016}, {0xae397d8aa96c1b77, 0xabec975e0a0d081b}, {0xd9c7dced53c72255, 0x96e7bd358c904a22}, {0x881cea14545c7575, 0x7e50d64177da2e55}, {0xaa242499697392d2, 0xdde50bd1d5d0b9ea}, {0xd4ad2dbfc3d07787, 0x955e4ec64b44e865}, {0x84ec3c97da624ab4, 0xbd5af13bef0b113f}, {0xa6274bbdd0fadd61, 0xecb1ad8aeacdd58f}, {0xcfb11ead453994ba, 0x67de18eda5814af3}, {0x81ceb32c4b43fcf4, 0x80eacf948770ced8}, {0xa2425ff75e14fc31, 0xa1258379a94d028e}, {0xcad2f7f5359a3b3e, 0x096ee45813a04331}, {0xfd87b5f28300ca0d, 0x8bca9d6e188853fd}, {0x9e74d1b791e07e48, 0x775ea264cf55347e}, {0xc612062576589dda, 0x95364afe032a819e}, {0xf79687aed3eec551, 0x3a83ddbd83f52205}, {0x9abe14cd44753b52, 0xc4926a9672793543}, {0xc16d9a0095928a27, 0x75b7053c0f178294}, {0xf1c90080baf72cb1, 0x5324c68b12dd6339}, {0x971da05074da7bee, 0xd3f6fc16ebca5e04}, {0xbce5086492111aea, 0x88f4bb1ca6bcf585}, {0xec1e4a7db69561a5, 0x2b31e9e3d06c32e6}, {0x9392ee8e921d5d07, 0x3aff322e62439fd0}, {0xb877aa3236a4b449, 0x09befeb9fad487c3}, {0xe69594bec44de15b, 0x4c2ebe687989a9b4}, {0x901d7cf73ab0acd9, 0x0f9d37014bf60a11}, {0xb424dc35095cd80f, 0x538484c19ef38c95}, {0xe12e13424bb40e13, 0x2865a5f206b06fba}, {0x8cbccc096f5088cb, 0xf93f87b7442e45d4}, {0xafebff0bcb24aafe, 0xf78f69a51539d749}, {0xdbe6fecebdedd5be, 0xb573440e5a884d1c}, {0x89705f4136b4a597, 0x31680a88f8953031}, {0xabcc77118461cefc, 0xfdc20d2b36ba7c3e}, {0xd6bf94d5e57a42bc, 0x3d32907604691b4d}, {0x8637bd05af6c69b5, 0xa63f9a49c2c1b110}, {0xa7c5ac471b478423, 0x0fcf80dc33721d54}, {0xd1b71758e219652b, 0xd3c36113404ea4a9}, {0x83126e978d4fdf3b, 0x645a1cac083126ea}, {0xa3d70a3d70a3d70a, 0x3d70a3d70a3d70a4}, {0xcccccccccccccccc, 0xcccccccccccccccd}, {0x8000000000000000, 0x0000000000000000}, {0xa000000000000000, 0x0000000000000000}, {0xc800000000000000, 0x0000000000000000}, {0xfa00000000000000, 0x0000000000000000}, {0x9c40000000000000, 0x0000000000000000}, {0xc350000000000000, 0x0000000000000000}, {0xf424000000000000, 0x0000000000000000}, {0x9896800000000000, 0x0000000000000000}, {0xbebc200000000000, 0x0000000000000000}, {0xee6b280000000000, 0x0000000000000000}, {0x9502f90000000000, 0x0000000000000000}, {0xba43b74000000000, 0x0000000000000000}, {0xe8d4a51000000000, 0x0000000000000000}, {0x9184e72a00000000, 0x0000000000000000}, {0xb5e620f480000000, 0x0000000000000000}, {0xe35fa931a0000000, 0x0000000000000000}, {0x8e1bc9bf04000000, 0x0000000000000000}, {0xb1a2bc2ec5000000, 0x0000000000000000}, {0xde0b6b3a76400000, 0x0000000000000000}, {0x8ac7230489e80000, 0x0000000000000000}, {0xad78ebc5ac620000, 0x0000000000000000}, {0xd8d726b7177a8000, 0x0000000000000000}, {0x878678326eac9000, 0x0000000000000000}, {0xa968163f0a57b400, 0x0000000000000000}, {0xd3c21bcecceda100, 0x0000000000000000}, {0x84595161401484a0, 0x0000000000000000}, {0xa56fa5b99019a5c8, 0x0000000000000000}, {0xcecb8f27f4200f3a, 0x0000000000000000}, {0x813f3978f8940984, 0x4000000000000000}, {0xa18f07d736b90be5, 0x5000000000000000}, {0xc9f2c9cd04674ede, 0xa400000000000000}, {0xfc6f7c4045812296, 0x4d00000000000000}, {0x9dc5ada82b70b59d, 0xf020000000000000}, {0xc5371912364ce305, 0x6c28000000000000}, {0xf684df56c3e01bc6, 0xc732000000000000}, {0x9a130b963a6c115c, 0x3c7f400000000000}, {0xc097ce7bc90715b3, 0x4b9f100000000000}, {0xf0bdc21abb48db20, 0x1e86d40000000000}, {0x96769950b50d88f4, 0x1314448000000000}, {0xbc143fa4e250eb31, 0x17d955a000000000}, {0xeb194f8e1ae525fd, 0x5dcfab0800000000}, {0x92efd1b8d0cf37be, 0x5aa1cae500000000}, {0xb7abc627050305ad, 0xf14a3d9e40000000}, {0xe596b7b0c643c719, 0x6d9ccd05d0000000}, {0x8f7e32ce7bea5c6f, 0xe4820023a2000000}, {0xb35dbf821ae4f38b, 0xdda2802c8a800000}, {0xe0352f62a19e306e, 0xd50b2037ad200000}, {0x8c213d9da502de45, 0x4526f422cc340000}, {0xaf298d050e4395d6, 0x9670b12b7f410000}, {0xdaf3f04651d47b4c, 0x3c0cdd765f114000}, {0x88d8762bf324cd0f, 0xa5880a69fb6ac800}, {0xab0e93b6efee0053, 0x8eea0d047a457a00}, {0xd5d238a4abe98068, 0x72a4904598d6d880}, {0x85a36366eb71f041, 0x47a6da2b7f864750}, {0xa70c3c40a64e6c51, 0x999090b65f67d924}, {0xd0cf4b50cfe20765, 0xfff4b4e3f741cf6d}, {0x82818f1281ed449f, 0xbff8f10e7a8921a5}, {0xa321f2d7226895c7, 0xaff72d52192b6a0e}, {0xcbea6f8ceb02bb39, 0x9bf4f8a69f764491}, {0xfee50b7025c36a08, 0x02f236d04753d5b5}, {0x9f4f2726179a2245, 0x01d762422c946591}, {0xc722f0ef9d80aad6, 0x424d3ad2b7b97ef6}, {0xf8ebad2b84e0d58b, 0xd2e0898765a7deb3}, {0x9b934c3b330c8577, 0x63cc55f49f88eb30}, {0xc2781f49ffcfa6d5, 0x3cbf6b71c76b25fc}, {0xf316271c7fc3908a, 0x8bef464e3945ef7b}, {0x97edd871cfda3a56, 0x97758bf0e3cbb5ad}, {0xbde94e8e43d0c8ec, 0x3d52eeed1cbea318}, {0xed63a231d4c4fb27, 0x4ca7aaa863ee4bde}, {0x945e455f24fb1cf8, 0x8fe8caa93e74ef6b}, {0xb975d6b6ee39e436, 0xb3e2fd538e122b45}, {0xe7d34c64a9c85d44, 0x60dbbca87196b617}, {0x90e40fbeea1d3a4a, 0xbc8955e946fe31ce}, {0xb51d13aea4a488dd, 0x6babab6398bdbe42}, {0xe264589a4dcdab14, 0xc696963c7eed2dd2}, {0x8d7eb76070a08aec, 0xfc1e1de5cf543ca3}, {0xb0de65388cc8ada8, 0x3b25a55f43294bcc}, {0xdd15fe86affad912, 0x49ef0eb713f39ebf}, {0x8a2dbf142dfcc7ab, 0x6e3569326c784338}, {0xacb92ed9397bf996, 0x49c2c37f07965405}, {0xd7e77a8f87daf7fb, 0xdc33745ec97be907}, {0x86f0ac99b4e8dafd, 0x69a028bb3ded71a4}, {0xa8acd7c0222311bc, 0xc40832ea0d68ce0d}, {0xd2d80db02aabd62b, 0xf50a3fa490c30191}, {0x83c7088e1aab65db, 0x792667c6da79e0fb}, {0xa4b8cab1a1563f52, 0x577001b891185939}, {0xcde6fd5e09abcf26, 0xed4c0226b55e6f87}, {0x80b05e5ac60b6178, 0x544f8158315b05b5}, {0xa0dc75f1778e39d6, 0x696361ae3db1c722}, {0xc913936dd571c84c, 0x03bc3a19cd1e38ea}, {0xfb5878494ace3a5f, 0x04ab48a04065c724}, {0x9d174b2dcec0e47b, 0x62eb0d64283f9c77}, {0xc45d1df942711d9a, 0x3ba5d0bd324f8395}, {0xf5746577930d6500, 0xca8f44ec7ee3647a}, {0x9968bf6abbe85f20, 0x7e998b13cf4e1ecc}, {0xbfc2ef456ae276e8, 0x9e3fedd8c321a67f}, {0xefb3ab16c59b14a2, 0xc5cfe94ef3ea101f}, {0x95d04aee3b80ece5, 0xbba1f1d158724a13}, {0xbb445da9ca61281f, 0x2a8a6e45ae8edc98}, {0xea1575143cf97226, 0xf52d09d71a3293be}, {0x924d692ca61be758, 0x593c2626705f9c57}, {0xb6e0c377cfa2e12e, 0x6f8b2fb00c77836d}, {0xe498f455c38b997a, 0x0b6dfb9c0f956448}, {0x8edf98b59a373fec, 0x4724bd4189bd5ead}, {0xb2977ee300c50fe7, 0x58edec91ec2cb658}, {0xdf3d5e9bc0f653e1, 0x2f2967b66737e3ee}, {0x8b865b215899f46c, 0xbd79e0d20082ee75}, {0xae67f1e9aec07187, 0xecd8590680a3aa12}, {0xda01ee641a708de9, 0xe80e6f4820cc9496}, {0x884134fe908658b2, 0x3109058d147fdcde}, {0xaa51823e34a7eede, 0xbd4b46f0599fd416}, {0xd4e5e2cdc1d1ea96, 0x6c9e18ac7007c91b}, {0x850fadc09923329e, 0x03e2cf6bc604ddb1}, {0xa6539930bf6bff45, 0x84db8346b786151d}, {0xcfe87f7cef46ff16, 0xe612641865679a64}, {0x81f14fae158c5f6e, 0x4fcb7e8f3f60c07f}, {0xa26da3999aef7749, 0xe3be5e330f38f09e}, {0xcb090c8001ab551c, 0x5cadf5bfd3072cc6}, {0xfdcb4fa002162a63, 0x73d9732fc7c8f7f7}, {0x9e9f11c4014dda7e, 0x2867e7fddcdd9afb}, {0xc646d63501a1511d, 0xb281e1fd541501b9}, {0xf7d88bc24209a565, 0x1f225a7ca91a4227}, {0x9ae757596946075f, 0x3375788de9b06959}, {0xc1a12d2fc3978937, 0x0052d6b1641c83af}, {0xf209787bb47d6b84, 0xc0678c5dbd23a49b}, {0x9745eb4d50ce6332, 0xf840b7ba963646e1}, {0xbd176620a501fbff, 0xb650e5a93bc3d899}, {0xec5d3fa8ce427aff, 0xa3e51f138ab4cebf}, {0x93ba47c980e98cdf, 0xc66f336c36b10138}, {0xb8a8d9bbe123f017, 0xb80b0047445d4185}, {0xe6d3102ad96cec1d, 0xa60dc059157491e6}, {0x9043ea1ac7e41392, 0x87c89837ad68db30}, {0xb454e4a179dd1877, 0x29babe4598c311fc}, {0xe16a1dc9d8545e94, 0xf4296dd6fef3d67b}, {0x8ce2529e2734bb1d, 0x1899e4a65f58660d}, {0xb01ae745b101e9e4, 0x5ec05dcff72e7f90}, {0xdc21a1171d42645d, 0x76707543f4fa1f74}, {0x899504ae72497eba, 0x6a06494a791c53a9}, {0xabfa45da0edbde69, 0x0487db9d17636893}, {0xd6f8d7509292d603, 0x45a9d2845d3c42b7}, {0x865b86925b9bc5c2, 0x0b8a2392ba45a9b3}, {0xa7f26836f282b732, 0x8e6cac7768d7141f}, {0xd1ef0244af2364ff, 0x3207d795430cd927}, {0x8335616aed761f1f, 0x7f44e6bd49e807b9}, {0xa402b9c5a8d3a6e7, 0x5f16206c9c6209a7}, {0xcd036837130890a1, 0x36dba887c37a8c10}, {0x802221226be55a64, 0xc2494954da2c978a}, {0xa02aa96b06deb0fd, 0xf2db9baa10b7bd6d}, {0xc83553c5c8965d3d, 0x6f92829494e5acc8}, {0xfa42a8b73abbf48c, 0xcb772339ba1f17fa}, {0x9c69a97284b578d7, 0xff2a760414536efc}, {0xc38413cf25e2d70d, 0xfef5138519684abb}, {0xf46518c2ef5b8cd1, 0x7eb258665fc25d6a}, {0x98bf2f79d5993802, 0xef2f773ffbd97a62}, {0xbeeefb584aff8603, 0xaafb550ffacfd8fb}, {0xeeaaba2e5dbf6784, 0x95ba2a53f983cf39}, {0x952ab45cfa97a0b2, 0xdd945a747bf26184}, {0xba756174393d88df, 0x94f971119aeef9e5}, {0xe912b9d1478ceb17, 0x7a37cd5601aab85e}, {0x91abb422ccb812ee, 0xac62e055c10ab33b}, {0xb616a12b7fe617aa, 0x577b986b314d600a}, {0xe39c49765fdf9d94, 0xed5a7e85fda0b80c}, {0x8e41ade9fbebc27d, 0x14588f13be847308}, {0xb1d219647ae6b31c, 0x596eb2d8ae258fc9}, {0xde469fbd99a05fe3, 0x6fca5f8ed9aef3bc}, {0x8aec23d680043bee, 0x25de7bb9480d5855}, {0xada72ccc20054ae9, 0xaf561aa79a10ae6b}, {0xd910f7ff28069da4, 0x1b2ba1518094da05}, {0x87aa9aff79042286, 0x90fb44d2f05d0843}, {0xa99541bf57452b28, 0x353a1607ac744a54}, {0xd3fa922f2d1675f2, 0x42889b8997915ce9}, {0x847c9b5d7c2e09b7, 0x69956135febada12}, {0xa59bc234db398c25, 0x43fab9837e699096}, {0xcf02b2c21207ef2e, 0x94f967e45e03f4bc}, {0x8161afb94b44f57d, 0x1d1be0eebac278f6}, {0xa1ba1ba79e1632dc, 0x6462d92a69731733}, {0xca28a291859bbf93, 0x7d7b8f7503cfdcff}, {0xfcb2cb35e702af78, 0x5cda735244c3d43f}, {0x9defbf01b061adab, 0x3a0888136afa64a8}, {0xc56baec21c7a1916, 0x088aaa1845b8fdd1}, {0xf6c69a72a3989f5b, 0x8aad549e57273d46}, {0x9a3c2087a63f6399, 0x36ac54e2f678864c}, {0xc0cb28a98fcf3c7f, 0x84576a1bb416a7de}, {0xf0fdf2d3f3c30b9f, 0x656d44a2a11c51d6}, {0x969eb7c47859e743, 0x9f644ae5a4b1b326}, {0xbc4665b596706114, 0x873d5d9f0dde1fef}, {0xeb57ff22fc0c7959, 0xa90cb506d155a7eb}, {0x9316ff75dd87cbd8, 0x09a7f12442d588f3}, {0xb7dcbf5354e9bece, 0x0c11ed6d538aeb30}, {0xe5d3ef282a242e81, 0x8f1668c8a86da5fb}, {0x8fa475791a569d10, 0xf96e017d694487bd}, {0xb38d92d760ec4455, 0x37c981dcc395a9ad}, {0xe070f78d3927556a, 0x85bbe253f47b1418}, {0x8c469ab843b89562, 0x93956d7478ccec8f}, {0xaf58416654a6babb, 0x387ac8d1970027b3}, {0xdb2e51bfe9d0696a, 0x06997b05fcc0319f}, {0x88fcf317f22241e2, 0x441fece3bdf81f04}, {0xab3c2fddeeaad25a, 0xd527e81cad7626c4}, {0xd60b3bd56a5586f1, 0x8a71e223d8d3b075}, {0x85c7056562757456, 0xf6872d5667844e4a}, {0xa738c6bebb12d16c, 0xb428f8ac016561dc}, {0xd106f86e69d785c7, 0xe13336d701beba53}, {0x82a45b450226b39c, 0xecc0024661173474}, {0xa34d721642b06084, 0x27f002d7f95d0191}, {0xcc20ce9bd35c78a5, 0x31ec038df7b441f5}, {0xff290242c83396ce, 0x7e67047175a15272}, {0x9f79a169bd203e41, 0x0f0062c6e984d387}, {0xc75809c42c684dd1, 0x52c07b78a3e60869}, {0xf92e0c3537826145, 0xa7709a56ccdf8a83}, {0x9bbcc7a142b17ccb, 0x88a66076400bb692}, {0xc2abf989935ddbfe, 0x6acff893d00ea436}, {0xf356f7ebf83552fe, 0x0583f6b8c4124d44}, {0x98165af37b2153de, 0xc3727a337a8b704b}, {0xbe1bf1b059e9a8d6, 0x744f18c0592e4c5d}, {0xeda2ee1c7064130c, 0x1162def06f79df74}, {0x9485d4d1c63e8be7, 0x8addcb5645ac2ba9}, {0xb9a74a0637ce2ee1, 0x6d953e2bd7173693}, {0xe8111c87c5c1ba99, 0xc8fa8db6ccdd0438}, {0x910ab1d4db9914a0, 0x1d9c9892400a22a3}, {0xb54d5e4a127f59c8, 0x2503beb6d00cab4c}, {0xe2a0b5dc971f303a, 0x2e44ae64840fd61e}, {0x8da471a9de737e24, 0x5ceaecfed289e5d3}, {0xb10d8e1456105dad, 0x7425a83e872c5f48}, {0xdd50f1996b947518, 0xd12f124e28f7771a}, {0x8a5296ffe33cc92f, 0x82bd6b70d99aaa70}, {0xace73cbfdc0bfb7b, 0x636cc64d1001550c}, {0xd8210befd30efa5a, 0x3c47f7e05401aa4f}, {0x8714a775e3e95c78, 0x65acfaec34810a72}, {0xa8d9d1535ce3b396, 0x7f1839a741a14d0e}, {0xd31045a8341ca07c, 0x1ede48111209a051}, {0x83ea2b892091e44d, 0x934aed0aab460433}, {0xa4e4b66b68b65d60, 0xf81da84d56178540}, {0xce1de40642e3f4b9, 0x36251260ab9d668f}, {0x80d2ae83e9ce78f3, 0xc1d72b7c6b42601a}, {0xa1075a24e4421730, 0xb24cf65b8612f820}, {0xc94930ae1d529cfc, 0xdee033f26797b628}, {0xfb9b7cd9a4a7443c, 0x169840ef017da3b2}, {0x9d412e0806e88aa5, 0x8e1f289560ee864f}, {0xc491798a08a2ad4e, 0xf1a6f2bab92a27e3}, {0xf5b5d7ec8acb58a2, 0xae10af696774b1dc}, {0x9991a6f3d6bf1765, 0xacca6da1e0a8ef2a}, {0xbff610b0cc6edd3f, 0x17fd090a58d32af4}, {0xeff394dcff8a948e, 0xddfc4b4cef07f5b1}, {0x95f83d0a1fb69cd9, 0x4abdaf101564f98f}, {0xbb764c4ca7a4440f, 0x9d6d1ad41abe37f2}, {0xea53df5fd18d5513, 0x84c86189216dc5ee}, {0x92746b9be2f8552c, 0x32fd3cf5b4e49bb5}, {0xb7118682dbb66a77, 0x3fbc8c33221dc2a2}, {0xe4d5e82392a40515, 0x0fabaf3feaa5334b}, {0x8f05b1163ba6832d, 0x29cb4d87f2a7400f}, {0xb2c71d5bca9023f8, 0x743e20e9ef511013}, {0xdf78e4b2bd342cf6, 0x914da9246b255417}, {0x8bab8eefb6409c1a, 0x1ad089b6c2f7548f}, {0xae9672aba3d0c320, 0xa184ac2473b529b2}, {0xda3c0f568cc4f3e8, 0xc9e5d72d90a2741f}, {0x8865899617fb1871, 0x7e2fa67c7a658893}, {0xaa7eebfb9df9de8d, 0xddbb901b98feeab8}, {0xd51ea6fa85785631, 0x552a74227f3ea566}, {0x8533285c936b35de, 0xd53a88958f872760}, {0xa67ff273b8460356, 0x8a892abaf368f138}, {0xd01fef10a657842c, 0x2d2b7569b0432d86}, {0x8213f56a67f6b29b, 0x9c3b29620e29fc74}, {0xa298f2c501f45f42, 0x8349f3ba91b47b90}, {0xcb3f2f7642717713, 0x241c70a936219a74}, {0xfe0efb53d30dd4d7, 0xed238cd383aa0111}, {0x9ec95d1463e8a506, 0xf4363804324a40ab}, {0xc67bb4597ce2ce48, 0xb143c6053edcd0d6}, {0xf81aa16fdc1b81da, 0xdd94b7868e94050b}, {0x9b10a4e5e9913128, 0xca7cf2b4191c8327}, {0xc1d4ce1f63f57d72, 0xfd1c2f611f63a3f1}, {0xf24a01a73cf2dccf, 0xbc633b39673c8ced}, {0x976e41088617ca01, 0xd5be0503e085d814}, {0xbd49d14aa79dbc82, 0x4b2d8644d8a74e19}, {0xec9c459d51852ba2, 0xddf8e7d60ed1219f}, {0x93e1ab8252f33b45, 0xcabb90e5c942b504}, {0xb8da1662e7b00a17, 0x3d6a751f3b936244}, {0xe7109bfba19c0c9d, 0x0cc512670a783ad5}, {0x906a617d450187e2, 0x27fb2b80668b24c6}, {0xb484f9dc9641e9da, 0xb1f9f660802dedf7}, {0xe1a63853bbd26451, 0x5e7873f8a0396974}, {0x8d07e33455637eb2, 0xdb0b487b6423e1e9}, {0xb049dc016abc5e5f, 0x91ce1a9a3d2cda63}, {0xdc5c5301c56b75f7, 0x7641a140cc7810fc}, {0x89b9b3e11b6329ba, 0xa9e904c87fcb0a9e}, {0xac2820d9623bf429, 0x546345fa9fbdcd45}, {0xd732290fbacaf133, 0xa97c177947ad4096}, {0x867f59a9d4bed6c0, 0x49ed8eabcccc485e}, {0xa81f301449ee8c70, 0x5c68f256bfff5a75}, {0xd226fc195c6a2f8c, 0x73832eec6fff3112}, {0x83585d8fd9c25db7, 0xc831fd53c5ff7eac}, {0xa42e74f3d032f525, 0xba3e7ca8b77f5e56}, {0xcd3a1230c43fb26f, 0x28ce1bd2e55f35ec}, {0x80444b5e7aa7cf85, 0x7980d163cf5b81b4}, {0xa0555e361951c366, 0xd7e105bcc3326220}, {0xc86ab5c39fa63440, 0x8dd9472bf3fefaa8}, {0xfa856334878fc150, 0xb14f98f6f0feb952}, {0x9c935e00d4b9d8d2, 0x6ed1bf9a569f33d4}, {0xc3b8358109e84f07, 0x0a862f80ec4700c9}, {0xf4a642e14c6262c8, 0xcd27bb612758c0fb}, {0x98e7e9cccfbd7dbd, 0x8038d51cb897789d}, {0xbf21e44003acdd2c, 0xe0470a63e6bd56c4}, {0xeeea5d5004981478, 0x1858ccfce06cac75}, {0x95527a5202df0ccb, 0x0f37801e0c43ebc9}, {0xbaa718e68396cffd, 0xd30560258f54e6bb}, {0xe950df20247c83fd, 0x47c6b82ef32a206a}, {0x91d28b7416cdd27e, 0x4cdc331d57fa5442}, {0xb6472e511c81471d, 0xe0133fe4adf8e953}, {0xe3d8f9e563a198e5, 0x58180fddd97723a7}, {0x8e679c2f5e44ff8f, 0x570f09eaa7ea7649}, {0xb201833b35d63f73, 0x2cd2cc6551e513db}, {0xde81e40a034bcf4f, 0xf8077f7ea65e58d2}, {0x8b112e86420f6191, 0xfb04afaf27faf783}, {0xadd57a27d29339f6, 0x79c5db9af1f9b564}, {0xd94ad8b1c7380874, 0x18375281ae7822bd}, {0x87cec76f1c830548, 0x8f2293910d0b15b6}, {0xa9c2794ae3a3c69a, 0xb2eb3875504ddb23}, {0xd433179d9c8cb841, 0x5fa60692a46151ec}, {0x849feec281d7f328, 0xdbc7c41ba6bcd334}, {0xa5c7ea73224deff3, 0x12b9b522906c0801}, {0xcf39e50feae16bef, 0xd768226b34870a01}, {0x81842f29f2cce375, 0xe6a1158300d46641}, {0xa1e53af46f801c53, 0x60495ae3c1097fd1}, {0xca5e89b18b602368, 0x385bb19cb14bdfc5}, {0xfcf62c1dee382c42, 0x46729e03dd9ed7b6}, {0x9e19db92b4e31ba9, 0x6c07a2c26a8346d2}, {0xc5a05277621be293, 0xc7098b7305241886}, {0xf70867153aa2db38, 0xb8cbee4fc66d1ea8}, {0x9a65406d44a5c903, 0x737f74f1dc043329}, {0xc0fe908895cf3b44, 0x505f522e53053ff3}, {0xf13e34aabb430a15, 0x647726b9e7c68ff0}, {0x96c6e0eab509e64d, 0x5eca783430dc19f6}, {0xbc789925624c5fe0, 0xb67d16413d132073}, {0xeb96bf6ebadf77d8, 0xe41c5bd18c57e890}, {0x933e37a534cbaae7, 0x8e91b962f7b6f15a}, {0xb80dc58e81fe95a1, 0x723627bbb5a4adb1}, {0xe61136f2227e3b09, 0xcec3b1aaa30dd91d}, {0x8fcac257558ee4e6, 0x213a4f0aa5e8a7b2}, {0xb3bd72ed2af29e1f, 0xa988e2cd4f62d19e}, {0xe0accfa875af45a7, 0x93eb1b80a33b8606}, {0x8c6c01c9498d8b88, 0xbc72f130660533c4}, {0xaf87023b9bf0ee6a, 0xeb8fad7c7f8680b5}, {0xdb68c2ca82ed2a05, 0xa67398db9f6820e2}, #else {0xff77b1fcbebcdc4f, 0x25e8e89c13bb0f7b}, {0xce5d73ff402d98e3, 0xfb0a3d212dc81290}, {0xa6b34ad8c9dfc06f, 0xf42faa48c0ea481f}, {0x86a8d39ef77164bc, 0xae5dff9c02033198}, {0xd98ddaee19068c76, 0x3badd624dd9b0958}, {0xafbd2350644eeacf, 0xe5d1929ef90898fb}, {0x8df5efabc5979c8f, 0xca8d3ffa1ef463c2}, {0xe55990879ddcaabd, 0xcc420a6a101d0516}, {0xb94470938fa89bce, 0xf808e40e8d5b3e6a}, {0x95a8637627989aad, 0xdde7001379a44aa9}, {0xf1c90080baf72cb1, 0x5324c68b12dd6339}, {0xc350000000000000, 0x0000000000000000}, {0x9dc5ada82b70b59d, 0xf020000000000000}, {0xfee50b7025c36a08, 0x02f236d04753d5b5}, {0xcde6fd5e09abcf26, 0xed4c0226b55e6f87}, {0xa6539930bf6bff45, 0x84db8346b786151d}, {0x865b86925b9bc5c2, 0x0b8a2392ba45a9b3}, {0xd910f7ff28069da4, 0x1b2ba1518094da05}, {0xaf58416654a6babb, 0x387ac8d1970027b3}, {0x8da471a9de737e24, 0x5ceaecfed289e5d3}, {0xe4d5e82392a40515, 0x0fabaf3feaa5334b}, {0xb8da1662e7b00a17, 0x3d6a751f3b936244}, {0x95527a5202df0ccb, 0x0f37801e0c43ebc9}, {0xf13e34aabb430a15, 0x647726b9e7c68ff0} #endif }; #if FMT_USE_FULL_CACHE_DRAGONBOX return pow10_significands[k - float_info<double>::min_k]; #else static constexpr const uint64_t powers_of_5_64[] = { 0x0000000000000001, 0x0000000000000005, 0x0000000000000019, 0x000000000000007d, 0x0000000000000271, 0x0000000000000c35, 0x0000000000003d09, 0x000000000001312d, 0x000000000005f5e1, 0x00000000001dcd65, 0x00000000009502f9, 0x0000000002e90edd, 0x000000000e8d4a51, 0x0000000048c27395, 0x000000016bcc41e9, 0x000000071afd498d, 0x0000002386f26fc1, 0x000000b1a2bc2ec5, 0x000003782dace9d9, 0x00001158e460913d, 0x000056bc75e2d631, 0x0001b1ae4d6e2ef5, 0x000878678326eac9, 0x002a5a058fc295ed, 0x00d3c21bcecceda1, 0x0422ca8b0a00a425, 0x14adf4b7320334b9}; static const int compression_ratio = 27; // Compute base index. int cache_index = (k - float_info<double>::min_k) / compression_ratio; int kb = cache_index * compression_ratio + float_info<double>::min_k; int offset = k - kb; // Get base cache. uint128_fallback base_cache = pow10_significands[cache_index]; if (offset == 0) return base_cache; // Compute the required amount of bit-shift. int alpha = floor_log2_pow10(kb + offset) - floor_log2_pow10(kb) - offset; FMT_ASSERT(alpha > 0 && alpha < 64, "shifting error detected"); // Try to recover the real cache. uint64_t pow5 = powers_of_5_64[offset]; uint128_fallback recovered_cache = umul128(base_cache.high(), pow5); uint128_fallback middle_low = umul128(base_cache.low(), pow5); recovered_cache += middle_low.high(); uint64_t high_to_middle = recovered_cache.high() << (64 - alpha); uint64_t middle_to_low = recovered_cache.low() << (64 - alpha); recovered_cache = uint128_fallback{(recovered_cache.low() >> alpha) | high_to_middle, ((middle_low.low() >> alpha) | middle_to_low)}; FMT_ASSERT(recovered_cache.low() + 1 != 0, ""); return {recovered_cache.high(), recovered_cache.low() + 1}; #endif } struct compute_mul_result { carrier_uint result; bool is_integer; }; struct compute_mul_parity_result { bool parity; bool is_integer; }; static auto compute_mul(carrier_uint u, const cache_entry_type& cache) noexcept -> compute_mul_result { auto r = umul192_upper128(u, cache); return {r.high(), r.low() == 0}; } static auto compute_delta(cache_entry_type const& cache, int beta) noexcept -> uint32_t { return static_cast<uint32_t>(cache.high() >> (64 - 1 - beta)); } static auto compute_mul_parity(carrier_uint two_f, const cache_entry_type& cache, int beta) noexcept -> compute_mul_parity_result { FMT_ASSERT(beta >= 1, ""); FMT_ASSERT(beta < 64, ""); auto r = umul192_lower128(two_f, cache); return {((r.high() >> (64 - beta)) & 1) != 0, ((r.high() << beta) | (r.low() >> (64 - beta))) == 0}; } static auto compute_left_endpoint_for_shorter_interval_case( const cache_entry_type& cache, int beta) noexcept -> carrier_uint { return (cache.high() - (cache.high() >> (num_significand_bits<double>() + 2))) >> (64 - num_significand_bits<double>() - 1 - beta); } static auto compute_right_endpoint_for_shorter_interval_case( const cache_entry_type& cache, int beta) noexcept -> carrier_uint { return (cache.high() + (cache.high() >> (num_significand_bits<double>() + 1))) >> (64 - num_significand_bits<double>() - 1 - beta); } static auto compute_round_up_for_shorter_interval_case( const cache_entry_type& cache, int beta) noexcept -> carrier_uint { return ((cache.high() >> (64 - num_significand_bits<double>() - 2 - beta)) + 1) / 2; } }; FMT_FUNC auto get_cached_power(int k) noexcept -> uint128_fallback { return cache_accessor<double>::get_cached_power(k); } // Various integer checks template <typename T> auto is_left_endpoint_integer_shorter_interval(int exponent) noexcept -> bool { const int case_shorter_interval_left_endpoint_lower_threshold = 2; const int case_shorter_interval_left_endpoint_upper_threshold = 3; return exponent >= case_shorter_interval_left_endpoint_lower_threshold && exponent <= case_shorter_interval_left_endpoint_upper_threshold; } // Remove trailing zeros from n and return the number of zeros removed (float) FMT_INLINE int remove_trailing_zeros(uint32_t& n, int s = 0) noexcept { FMT_ASSERT(n != 0, ""); // Modular inverse of 5 (mod 2^32): (mod_inv_5 * 5) mod 2^32 = 1. constexpr uint32_t mod_inv_5 = 0xcccccccd; constexpr uint32_t mod_inv_25 = 0xc28f5c29; // = mod_inv_5 * mod_inv_5 while (true) { auto q = rotr(n * mod_inv_25, 2); if (q > max_value<uint32_t>() / 100) break; n = q; s += 2; } auto q = rotr(n * mod_inv_5, 1); if (q <= max_value<uint32_t>() / 10) { n = q; s |= 1; } return s; } // Removes trailing zeros and returns the number of zeros removed (double) FMT_INLINE int remove_trailing_zeros(uint64_t& n) noexcept { FMT_ASSERT(n != 0, ""); // This magic number is ceil(2^90 / 10^8). constexpr uint64_t magic_number = 12379400392853802749ull; auto nm = umul128(n, magic_number); // Is n is divisible by 10^8? if ((nm.high() & ((1ull << (90 - 64)) - 1)) == 0 && nm.low() < magic_number) { // If yes, work with the quotient... auto n32 = static_cast<uint32_t>(nm.high() >> (90 - 64)); // ... and use the 32 bit variant of the function int s = remove_trailing_zeros(n32, 8); n = n32; return s; } // If n is not divisible by 10^8, work with n itself. constexpr uint64_t mod_inv_5 = 0xcccccccccccccccd; constexpr uint64_t mod_inv_25 = 0x8f5c28f5c28f5c29; // mod_inv_5 * mod_inv_5 int s = 0; while (true) { auto q = rotr(n * mod_inv_25, 2); if (q > max_value<uint64_t>() / 100) break; n = q; s += 2; } auto q = rotr(n * mod_inv_5, 1); if (q <= max_value<uint64_t>() / 10) { n = q; s |= 1; } return s; } // The main algorithm for shorter interval case template <typename T> FMT_INLINE decimal_fp<T> shorter_interval_case(int exponent) noexcept { decimal_fp<T> ret_value; // Compute k and beta const int minus_k = floor_log10_pow2_minus_log10_4_over_3(exponent); const int beta = exponent + floor_log2_pow10(-minus_k); // Compute xi and zi using cache_entry_type = typename cache_accessor<T>::cache_entry_type; const cache_entry_type cache = cache_accessor<T>::get_cached_power(-minus_k); auto xi = cache_accessor<T>::compute_left_endpoint_for_shorter_interval_case( cache, beta); auto zi = cache_accessor<T>::compute_right_endpoint_for_shorter_interval_case( cache, beta); // If the left endpoint is not an integer, increase it if (!is_left_endpoint_integer_shorter_interval<T>(exponent)) ++xi; // Try bigger divisor ret_value.significand = zi / 10; // If succeed, remove trailing zeros if necessary and return if (ret_value.significand * 10 >= xi) { ret_value.exponent = minus_k + 1; ret_value.exponent += remove_trailing_zeros(ret_value.significand); return ret_value; } // Otherwise, compute the round-up of y ret_value.significand = cache_accessor<T>::compute_round_up_for_shorter_interval_case(cache, beta); ret_value.exponent = minus_k; // When tie occurs, choose one of them according to the rule if (exponent >= float_info<T>::shorter_interval_tie_lower_threshold && exponent <= float_info<T>::shorter_interval_tie_upper_threshold) { ret_value.significand = ret_value.significand % 2 == 0 ? ret_value.significand : ret_value.significand - 1; } else if (ret_value.significand < xi) { ++ret_value.significand; } return ret_value; } template <typename T> auto to_decimal(T x) noexcept -> decimal_fp<T> { // Step 1: integer promotion & Schubfach multiplier calculation. using carrier_uint = typename float_info<T>::carrier_uint; using cache_entry_type = typename cache_accessor<T>::cache_entry_type; auto br = bit_cast<carrier_uint>(x); // Extract significand bits and exponent bits. const carrier_uint significand_mask = (static_cast<carrier_uint>(1) << num_significand_bits<T>()) - 1; carrier_uint significand = (br & significand_mask); int exponent = static_cast<int>((br & exponent_mask<T>()) >> num_significand_bits<T>()); if (exponent != 0) { // Check if normal. exponent -= exponent_bias<T>() + num_significand_bits<T>(); // Shorter interval case; proceed like Schubfach. // In fact, when exponent == 1 and significand == 0, the interval is // regular. However, it can be shown that the end-results are anyway same. if (significand == 0) return shorter_interval_case<T>(exponent); significand |= (static_cast<carrier_uint>(1) << num_significand_bits<T>()); } else { // Subnormal case; the interval is always regular. if (significand == 0) return {0, 0}; exponent = std::numeric_limits<T>::min_exponent - num_significand_bits<T>() - 1; } const bool include_left_endpoint = (significand % 2 == 0); const bool include_right_endpoint = include_left_endpoint; // Compute k and beta. const int minus_k = floor_log10_pow2(exponent) - float_info<T>::kappa; const cache_entry_type cache = cache_accessor<T>::get_cached_power(-minus_k); const int beta = exponent + floor_log2_pow10(-minus_k); // Compute zi and deltai. // 10^kappa <= deltai < 10^(kappa + 1) const uint32_t deltai = cache_accessor<T>::compute_delta(cache, beta); const carrier_uint two_fc = significand << 1; // For the case of binary32, the result of integer check is not correct for // 29711844 * 2^-82 // = 6.1442653300000000008655037797566933477355632930994033813476... * 10^-18 // and 29711844 * 2^-81 // = 1.2288530660000000001731007559513386695471126586198806762695... * 10^-17, // and they are the unique counterexamples. However, since 29711844 is even, // this does not cause any problem for the endpoints calculations; it can only // cause a problem when we need to perform integer check for the center. // Fortunately, with these inputs, that branch is never executed, so we are // fine. const typename cache_accessor<T>::compute_mul_result z_mul = cache_accessor<T>::compute_mul((two_fc | 1) << beta, cache); // Step 2: Try larger divisor; remove trailing zeros if necessary. // Using an upper bound on zi, we might be able to optimize the division // better than the compiler; we are computing zi / big_divisor here. decimal_fp<T> ret_value; ret_value.significand = divide_by_10_to_kappa_plus_1(z_mul.result); uint32_t r = static_cast<uint32_t>(z_mul.result - float_info<T>::big_divisor * ret_value.significand); if (r < deltai) { // Exclude the right endpoint if necessary. if (r == 0 && (z_mul.is_integer & !include_right_endpoint)) { --ret_value.significand; r = float_info<T>::big_divisor; goto small_divisor_case_label; } } else if (r > deltai) { goto small_divisor_case_label; } else { // r == deltai; compare fractional parts. const typename cache_accessor<T>::compute_mul_parity_result x_mul = cache_accessor<T>::compute_mul_parity(two_fc - 1, cache, beta); if (!(x_mul.parity | (x_mul.is_integer & include_left_endpoint))) goto small_divisor_case_label; } ret_value.exponent = minus_k + float_info<T>::kappa + 1; // We may need to remove trailing zeros. ret_value.exponent += remove_trailing_zeros(ret_value.significand); return ret_value; // Step 3: Find the significand with the smaller divisor. small_divisor_case_label: ret_value.significand *= 10; ret_value.exponent = minus_k + float_info<T>::kappa; uint32_t dist = r - (deltai / 2) + (float_info<T>::small_divisor / 2); const bool approx_y_parity = ((dist ^ (float_info<T>::small_divisor / 2)) & 1) != 0; // Is dist divisible by 10^kappa? const bool divisible_by_small_divisor = check_divisibility_and_divide_by_pow10<float_info<T>::kappa>(dist); // Add dist / 10^kappa to the significand. ret_value.significand += dist; if (!divisible_by_small_divisor) return ret_value; // Check z^(f) >= epsilon^(f). // We have either yi == zi - epsiloni or yi == (zi - epsiloni) - 1, // where yi == zi - epsiloni if and only if z^(f) >= epsilon^(f). // Since there are only 2 possibilities, we only need to care about the // parity. Also, zi and r should have the same parity since the divisor // is an even number. const auto y_mul = cache_accessor<T>::compute_mul_parity(two_fc, cache, beta); // If z^(f) >= epsilon^(f), we might have a tie when z^(f) == epsilon^(f), // or equivalently, when y is an integer. if (y_mul.parity != approx_y_parity) --ret_value.significand; else if (y_mul.is_integer & (ret_value.significand % 2 != 0)) --ret_value.significand; return ret_value; } } // namespace dragonbox } // namespace detail template <> struct formatter<detail::bigint> { FMT_CONSTEXPR auto parse(format_parse_context& ctx) -> format_parse_context::iterator { return ctx.begin(); } auto format(const detail::bigint& n, format_context& ctx) const -> format_context::iterator { auto out = ctx.out(); bool first = true; for (auto i = n.bigits_.size(); i > 0; --i) { auto value = n.bigits_[i - 1u]; if (first) { out = fmt::format_to(out, FMT_STRING("{:x}"), value); first = false; continue; } out = fmt::format_to(out, FMT_STRING("{:08x}"), value); } if (n.exp_ > 0) out = fmt::format_to(out, FMT_STRING("p{}"), n.exp_ * detail::bigint::bigit_bits); return out; } }; FMT_FUNC detail::utf8_to_utf16::utf8_to_utf16(string_view s) { for_each_codepoint(s, [this](uint32_t cp, string_view) { if (cp == invalid_code_point) FMT_THROW(std::runtime_error("invalid utf8")); if (cp <= 0xFFFF) { buffer_.push_back(static_cast<wchar_t>(cp)); } else { cp -= 0x10000; buffer_.push_back(static_cast<wchar_t>(0xD800 + (cp >> 10))); buffer_.push_back(static_cast<wchar_t>(0xDC00 + (cp & 0x3FF))); } return true; }); buffer_.push_back(0); } FMT_FUNC void format_system_error(detail::buffer<char>& out, int error_code, const char* message) noexcept { FMT_TRY { auto ec = std::error_code(error_code, std::generic_category()); detail::write(appender(out), std::system_error(ec, message).what()); return; } FMT_CATCH(...) {} format_error_code(out, error_code, message); } FMT_FUNC void report_system_error(int error_code, const char* message) noexcept { do_report_error(format_system_error, error_code, message); } FMT_FUNC auto vformat(string_view fmt, format_args args) -> std::string { // Don't optimize the "{}" case to keep the binary size small and because it // can be better optimized in fmt::format anyway. auto buffer = memory_buffer(); detail::vformat_to(buffer, fmt, args); return to_string(buffer); } namespace detail { FMT_FUNC void vformat_to(buffer<char>& buf, string_view fmt, format_args args, locale_ref loc) { auto out = appender(buf); if (fmt.size() == 2 && equal2(fmt.data(), "{}")) return args.get(0).visit(default_arg_formatter<char>{out}); parse_format_string( fmt, format_handler<char>{parse_context<char>(fmt), {out, args, loc}}); } template <typename T> struct span { T* data; size_t size; }; template <typename F> auto flockfile(F* f) -> decltype(_lock_file(f)) { _lock_file(f); } template <typename F> auto funlockfile(F* f) -> decltype(_unlock_file(f)) { _unlock_file(f); } #ifndef getc_unlocked template <typename F> auto getc_unlocked(F* f) -> decltype(_fgetc_nolock(f)) { return _fgetc_nolock(f); } #endif template <typename F = FILE, typename Enable = void> struct has_flockfile : std::false_type {}; template <typename F> struct has_flockfile<F, void_t<decltype(flockfile(&std::declval<F&>()))>> : std::true_type {}; // A FILE wrapper. F is FILE defined as a template parameter to make system API // detection work. template <typename F> class file_base { public: F* file_; public: file_base(F* file) : file_(file) {} operator F*() const { return file_; } // Reads a code unit from the stream. auto get() -> int { int result = getc_unlocked(file_); if (result == EOF && ferror(file_) != 0) FMT_THROW(system_error(errno, FMT_STRING("getc failed"))); return result; } // Puts the code unit back into the stream buffer. void unget(char c) { if (ungetc(c, file_) == EOF) FMT_THROW(system_error(errno, FMT_STRING("ungetc failed"))); } void flush() { fflush(this->file_); } }; // A FILE wrapper for glibc. template <typename F> class glibc_file : public file_base<F> { private: enum { line_buffered = 0x200, // _IO_LINE_BUF unbuffered = 2 // _IO_UNBUFFERED }; public: using file_base<F>::file_base; auto is_buffered() const -> bool { return (this->file_->_flags & unbuffered) == 0; } void init_buffer() { if (this->file_->_IO_write_ptr) return; // Force buffer initialization by placing and removing a char in a buffer. assume(this->file_->_IO_write_ptr >= this->file_->_IO_write_end); putc_unlocked(0, this->file_); --this->file_->_IO_write_ptr; } // Returns the file's read buffer. auto get_read_buffer() const -> span<const char> { auto ptr = this->file_->_IO_read_ptr; return {ptr, to_unsigned(this->file_->_IO_read_end - ptr)}; } // Returns the file's write buffer. auto get_write_buffer() const -> span<char> { auto ptr = this->file_->_IO_write_ptr; return {ptr, to_unsigned(this->file_->_IO_buf_end - ptr)}; } void advance_write_buffer(size_t size) { this->file_->_IO_write_ptr += size; } bool needs_flush() const { if ((this->file_->_flags & line_buffered) == 0) return false; char* end = this->file_->_IO_write_end; return memchr(end, '\n', to_unsigned(this->file_->_IO_write_ptr - end)); } void flush() { fflush_unlocked(this->file_); } }; // A FILE wrapper for Apple's libc. template <typename F> class apple_file : public file_base<F> { private: enum { line_buffered = 1, // __SNBF unbuffered = 2 // __SLBF }; public: using file_base<F>::file_base; auto is_buffered() const -> bool { return (this->file_->_flags & unbuffered) == 0; } void init_buffer() { if (this->file_->_p) return; // Force buffer initialization by placing and removing a char in a buffer. putc_unlocked(0, this->file_); --this->file_->_p; ++this->file_->_w; } auto get_read_buffer() const -> span<const char> { return {reinterpret_cast<char*>(this->file_->_p), to_unsigned(this->file_->_r)}; } auto get_write_buffer() const -> span<char> { return {reinterpret_cast<char*>(this->file_->_p), to_unsigned(this->file_->_bf._base + this->file_->_bf._size - this->file_->_p)}; } void advance_write_buffer(size_t size) { this->file_->_p += size; this->file_->_w -= size; } bool needs_flush() const { if ((this->file_->_flags & line_buffered) == 0) return false; return memchr(this->file_->_p + this->file_->_w, '\n', to_unsigned(-this->file_->_w)); } }; // A fallback FILE wrapper. template <typename F> class fallback_file : public file_base<F> { private: char next_; // The next unconsumed character in the buffer. bool has_next_ = false; public: using file_base<F>::file_base; auto is_buffered() const -> bool { return false; } auto needs_flush() const -> bool { return false; } void init_buffer() {} auto get_read_buffer() const -> span<const char> { return {&next_, has_next_ ? 1u : 0u}; } auto get_write_buffer() const -> span<char> { return {nullptr, 0}; } void advance_write_buffer(size_t) {} auto get() -> int { has_next_ = false; return file_base<F>::get(); } void unget(char c) { file_base<F>::unget(c); next_ = c; has_next_ = true; } }; #ifndef FMT_USE_FALLBACK_FILE # define FMT_USE_FALLBACK_FILE 0 #endif template <typename F, FMT_ENABLE_IF(sizeof(F::_p) != 0 && !FMT_USE_FALLBACK_FILE)> auto get_file(F* f, int) -> apple_file<F> { return f; } template <typename F, FMT_ENABLE_IF(sizeof(F::_IO_read_ptr) != 0 && !FMT_USE_FALLBACK_FILE)> inline auto get_file(F* f, int) -> glibc_file<F> { return f; } inline auto get_file(FILE* f, ...) -> fallback_file<FILE> { return f; } using file_ref = decltype(get_file(static_cast<FILE*>(nullptr), 0)); template <typename F = FILE, typename Enable = void> class file_print_buffer : public buffer<char> { public: explicit file_print_buffer(F*) : buffer(nullptr, size_t()) {} }; template <typename F> class file_print_buffer<F, enable_if_t<has_flockfile<F>::value>> : public buffer<char> { private: file_ref file_; static void grow(buffer<char>& base, size_t) { auto& self = static_cast<file_print_buffer&>(base); self.file_.advance_write_buffer(self.size()); if (self.file_.get_write_buffer().size == 0) self.file_.flush(); auto buf = self.file_.get_write_buffer(); FMT_ASSERT(buf.size > 0, ""); self.set(buf.data, buf.size); self.clear(); } public: explicit file_print_buffer(F* f) : buffer(grow, size_t()), file_(f) { flockfile(f); file_.init_buffer(); auto buf = file_.get_write_buffer(); set(buf.data, buf.size); } ~file_print_buffer() { file_.advance_write_buffer(size()); bool flush = file_.needs_flush(); F* f = file_; // Make funlockfile depend on the template parameter F funlockfile(f); // for the system API detection to work. if (flush) fflush(file_); } }; #if !defined(_WIN32) || defined(FMT_USE_WRITE_CONSOLE) FMT_FUNC auto write_console(int, string_view) -> bool { return false; } #else using dword = conditional_t<sizeof(long) == 4, unsigned long, unsigned>; extern "C" __declspec(dllimport) int __stdcall WriteConsoleW( // void*, const void*, dword, dword*, void*); FMT_FUNC bool write_console(int fd, string_view text) { auto u16 = utf8_to_utf16(text); return WriteConsoleW(reinterpret_cast<void*>(_get_osfhandle(fd)), u16.c_str(), static_cast<dword>(u16.size()), nullptr, nullptr) != 0; } #endif #ifdef _WIN32 // Print assuming legacy (non-Unicode) encoding. FMT_FUNC void vprint_mojibake(std::FILE* f, string_view fmt, format_args args, bool newline) { auto buffer = memory_buffer(); detail::vformat_to(buffer, fmt, args); if (newline) buffer.push_back('\n'); fwrite_all(buffer.data(), buffer.size(), f); } #endif FMT_FUNC void print(std::FILE* f, string_view text) { #if defined(_WIN32) && !defined(FMT_USE_WRITE_CONSOLE) int fd = _fileno(f); if (_isatty(fd)) { std::fflush(f); if (write_console(fd, text)) return; } #endif fwrite_all(text.data(), text.size(), f); } } // namespace detail FMT_FUNC void vprint_buffered(std::FILE* f, string_view fmt, format_args args) { auto buffer = memory_buffer(); detail::vformat_to(buffer, fmt, args); detail::print(f, {buffer.data(), buffer.size()}); } FMT_FUNC void vprint(std::FILE* f, string_view fmt, format_args args) { if (!detail::file_ref(f).is_buffered() || !detail::has_flockfile<>()) return vprint_buffered(f, fmt, args); auto&& buffer = detail::file_print_buffer<>(f); return detail::vformat_to(buffer, fmt, args); } FMT_FUNC void vprintln(std::FILE* f, string_view fmt, format_args args) { auto buffer = memory_buffer(); detail::vformat_to(buffer, fmt, args); buffer.push_back('\n'); detail::print(f, {buffer.data(), buffer.size()}); } FMT_FUNC void vprint(string_view fmt, format_args args) { vprint(stdout, fmt, args); } namespace detail { struct singleton { unsigned char upper; unsigned char lower_count; }; inline auto is_printable(uint16_t x, const singleton* singletons, size_t singletons_size, const unsigned char* singleton_lowers, const unsigned char* normal, size_t normal_size) -> bool { auto upper = x >> 8; auto lower_start = 0; for (size_t i = 0; i < singletons_size; ++i) { auto s = singletons[i]; auto lower_end = lower_start + s.lower_count; if (upper < s.upper) break; if (upper == s.upper) { for (auto j = lower_start; j < lower_end; ++j) { if (singleton_lowers[j] == (x & 0xff)) return false; } } lower_start = lower_end; } auto xsigned = static_cast<int>(x); auto current = true; for (size_t i = 0; i < normal_size; ++i) { auto v = static_cast<int>(normal[i]); auto len = (v & 0x80) != 0 ? (v & 0x7f) << 8 | normal[++i] : v; xsigned -= len; if (xsigned < 0) break; current = !current; } return current; } // This code is generated by support/printable.py. FMT_FUNC auto is_printable(uint32_t cp) -> bool { static constexpr singleton singletons0[] = { {0x00, 1}, {0x03, 5}, {0x05, 6}, {0x06, 3}, {0x07, 6}, {0x08, 8}, {0x09, 17}, {0x0a, 28}, {0x0b, 25}, {0x0c, 20}, {0x0d, 16}, {0x0e, 13}, {0x0f, 4}, {0x10, 3}, {0x12, 18}, {0x13, 9}, {0x16, 1}, {0x17, 5}, {0x18, 2}, {0x19, 3}, {0x1a, 7}, {0x1c, 2}, {0x1d, 1}, {0x1f, 22}, {0x20, 3}, {0x2b, 3}, {0x2c, 2}, {0x2d, 11}, {0x2e, 1}, {0x30, 3}, {0x31, 2}, {0x32, 1}, {0xa7, 2}, {0xa9, 2}, {0xaa, 4}, {0xab, 8}, {0xfa, 2}, {0xfb, 5}, {0xfd, 4}, {0xfe, 3}, {0xff, 9}, }; static constexpr unsigned char singletons0_lower[] = { 0xad, 0x78, 0x79, 0x8b, 0x8d, 0xa2, 0x30, 0x57, 0x58, 0x8b, 0x8c, 0x90, 0x1c, 0x1d, 0xdd, 0x0e, 0x0f, 0x4b, 0x4c, 0xfb, 0xfc, 0x2e, 0x2f, 0x3f, 0x5c, 0x5d, 0x5f, 0xb5, 0xe2, 0x84, 0x8d, 0x8e, 0x91, 0x92, 0xa9, 0xb1, 0xba, 0xbb, 0xc5, 0xc6, 0xc9, 0xca, 0xde, 0xe4, 0xe5, 0xff, 0x00, 0x04, 0x11, 0x12, 0x29, 0x31, 0x34, 0x37, 0x3a, 0x3b, 0x3d, 0x49, 0x4a, 0x5d, 0x84, 0x8e, 0x92, 0xa9, 0xb1, 0xb4, 0xba, 0xbb, 0xc6, 0xca, 0xce, 0xcf, 0xe4, 0xe5, 0x00, 0x04, 0x0d, 0x0e, 0x11, 0x12, 0x29, 0x31, 0x34, 0x3a, 0x3b, 0x45, 0x46, 0x49, 0x4a, 0x5e, 0x64, 0x65, 0x84, 0x91, 0x9b, 0x9d, 0xc9, 0xce, 0xcf, 0x0d, 0x11, 0x29, 0x45, 0x49, 0x57, 0x64, 0x65, 0x8d, 0x91, 0xa9, 0xb4, 0xba, 0xbb, 0xc5, 0xc9, 0xdf, 0xe4, 0xe5, 0xf0, 0x0d, 0x11, 0x45, 0x49, 0x64, 0x65, 0x80, 0x84, 0xb2, 0xbc, 0xbe, 0xbf, 0xd5, 0xd7, 0xf0, 0xf1, 0x83, 0x85, 0x8b, 0xa4, 0xa6, 0xbe, 0xbf, 0xc5, 0xc7, 0xce, 0xcf, 0xda, 0xdb, 0x48, 0x98, 0xbd, 0xcd, 0xc6, 0xce, 0xcf, 0x49, 0x4e, 0x4f, 0x57, 0x59, 0x5e, 0x5f, 0x89, 0x8e, 0x8f, 0xb1, 0xb6, 0xb7, 0xbf, 0xc1, 0xc6, 0xc7, 0xd7, 0x11, 0x16, 0x17, 0x5b, 0x5c, 0xf6, 0xf7, 0xfe, 0xff, 0x80, 0x0d, 0x6d, 0x71, 0xde, 0xdf, 0x0e, 0x0f, 0x1f, 0x6e, 0x6f, 0x1c, 0x1d, 0x5f, 0x7d, 0x7e, 0xae, 0xaf, 0xbb, 0xbc, 0xfa, 0x16, 0x17, 0x1e, 0x1f, 0x46, 0x47, 0x4e, 0x4f, 0x58, 0x5a, 0x5c, 0x5e, 0x7e, 0x7f, 0xb5, 0xc5, 0xd4, 0xd5, 0xdc, 0xf0, 0xf1, 0xf5, 0x72, 0x73, 0x8f, 0x74, 0x75, 0x96, 0x2f, 0x5f, 0x26, 0x2e, 0x2f, 0xa7, 0xaf, 0xb7, 0xbf, 0xc7, 0xcf, 0xd7, 0xdf, 0x9a, 0x40, 0x97, 0x98, 0x30, 0x8f, 0x1f, 0xc0, 0xc1, 0xce, 0xff, 0x4e, 0x4f, 0x5a, 0x5b, 0x07, 0x08, 0x0f, 0x10, 0x27, 0x2f, 0xee, 0xef, 0x6e, 0x6f, 0x37, 0x3d, 0x3f, 0x42, 0x45, 0x90, 0x91, 0xfe, 0xff, 0x53, 0x67, 0x75, 0xc8, 0xc9, 0xd0, 0xd1, 0xd8, 0xd9, 0xe7, 0xfe, 0xff, }; static constexpr singleton singletons1[] = { {0x00, 6}, {0x01, 1}, {0x03, 1}, {0x04, 2}, {0x08, 8}, {0x09, 2}, {0x0a, 5}, {0x0b, 2}, {0x0e, 4}, {0x10, 1}, {0x11, 2}, {0x12, 5}, {0x13, 17}, {0x14, 1}, {0x15, 2}, {0x17, 2}, {0x19, 13}, {0x1c, 5}, {0x1d, 8}, {0x24, 1}, {0x6a, 3}, {0x6b, 2}, {0xbc, 2}, {0xd1, 2}, {0xd4, 12}, {0xd5, 9}, {0xd6, 2}, {0xd7, 2}, {0xda, 1}, {0xe0, 5}, {0xe1, 2}, {0xe8, 2}, {0xee, 32}, {0xf0, 4}, {0xf8, 2}, {0xf9, 2}, {0xfa, 2}, {0xfb, 1}, }; static constexpr unsigned char singletons1_lower[] = { 0x0c, 0x27, 0x3b, 0x3e, 0x4e, 0x4f, 0x8f, 0x9e, 0x9e, 0x9f, 0x06, 0x07, 0x09, 0x36, 0x3d, 0x3e, 0x56, 0xf3, 0xd0, 0xd1, 0x04, 0x14, 0x18, 0x36, 0x37, 0x56, 0x57, 0x7f, 0xaa, 0xae, 0xaf, 0xbd, 0x35, 0xe0, 0x12, 0x87, 0x89, 0x8e, 0x9e, 0x04, 0x0d, 0x0e, 0x11, 0x12, 0x29, 0x31, 0x34, 0x3a, 0x45, 0x46, 0x49, 0x4a, 0x4e, 0x4f, 0x64, 0x65, 0x5c, 0xb6, 0xb7, 0x1b, 0x1c, 0x07, 0x08, 0x0a, 0x0b, 0x14, 0x17, 0x36, 0x39, 0x3a, 0xa8, 0xa9, 0xd8, 0xd9, 0x09, 0x37, 0x90, 0x91, 0xa8, 0x07, 0x0a, 0x3b, 0x3e, 0x66, 0x69, 0x8f, 0x92, 0x6f, 0x5f, 0xee, 0xef, 0x5a, 0x62, 0x9a, 0x9b, 0x27, 0x28, 0x55, 0x9d, 0xa0, 0xa1, 0xa3, 0xa4, 0xa7, 0xa8, 0xad, 0xba, 0xbc, 0xc4, 0x06, 0x0b, 0x0c, 0x15, 0x1d, 0x3a, 0x3f, 0x45, 0x51, 0xa6, 0xa7, 0xcc, 0xcd, 0xa0, 0x07, 0x19, 0x1a, 0x22, 0x25, 0x3e, 0x3f, 0xc5, 0xc6, 0x04, 0x20, 0x23, 0x25, 0x26, 0x28, 0x33, 0x38, 0x3a, 0x48, 0x4a, 0x4c, 0x50, 0x53, 0x55, 0x56, 0x58, 0x5a, 0x5c, 0x5e, 0x60, 0x63, 0x65, 0x66, 0x6b, 0x73, 0x78, 0x7d, 0x7f, 0x8a, 0xa4, 0xaa, 0xaf, 0xb0, 0xc0, 0xd0, 0xae, 0xaf, 0x79, 0xcc, 0x6e, 0x6f, 0x93, }; static constexpr unsigned char normal0[] = { 0x00, 0x20, 0x5f, 0x22, 0x82, 0xdf, 0x04, 0x82, 0x44, 0x08, 0x1b, 0x04, 0x06, 0x11, 0x81, 0xac, 0x0e, 0x80, 0xab, 0x35, 0x28, 0x0b, 0x80, 0xe0, 0x03, 0x19, 0x08, 0x01, 0x04, 0x2f, 0x04, 0x34, 0x04, 0x07, 0x03, 0x01, 0x07, 0x06, 0x07, 0x11, 0x0a, 0x50, 0x0f, 0x12, 0x07, 0x55, 0x07, 0x03, 0x04, 0x1c, 0x0a, 0x09, 0x03, 0x08, 0x03, 0x07, 0x03, 0x02, 0x03, 0x03, 0x03, 0x0c, 0x04, 0x05, 0x03, 0x0b, 0x06, 0x01, 0x0e, 0x15, 0x05, 0x3a, 0x03, 0x11, 0x07, 0x06, 0x05, 0x10, 0x07, 0x57, 0x07, 0x02, 0x07, 0x15, 0x0d, 0x50, 0x04, 0x43, 0x03, 0x2d, 0x03, 0x01, 0x04, 0x11, 0x06, 0x0f, 0x0c, 0x3a, 0x04, 0x1d, 0x25, 0x5f, 0x20, 0x6d, 0x04, 0x6a, 0x25, 0x80, 0xc8, 0x05, 0x82, 0xb0, 0x03, 0x1a, 0x06, 0x82, 0xfd, 0x03, 0x59, 0x07, 0x15, 0x0b, 0x17, 0x09, 0x14, 0x0c, 0x14, 0x0c, 0x6a, 0x06, 0x0a, 0x06, 0x1a, 0x06, 0x59, 0x07, 0x2b, 0x05, 0x46, 0x0a, 0x2c, 0x04, 0x0c, 0x04, 0x01, 0x03, 0x31, 0x0b, 0x2c, 0x04, 0x1a, 0x06, 0x0b, 0x03, 0x80, 0xac, 0x06, 0x0a, 0x06, 0x21, 0x3f, 0x4c, 0x04, 0x2d, 0x03, 0x74, 0x08, 0x3c, 0x03, 0x0f, 0x03, 0x3c, 0x07, 0x38, 0x08, 0x2b, 0x05, 0x82, 0xff, 0x11, 0x18, 0x08, 0x2f, 0x11, 0x2d, 0x03, 0x20, 0x10, 0x21, 0x0f, 0x80, 0x8c, 0x04, 0x82, 0x97, 0x19, 0x0b, 0x15, 0x88, 0x94, 0x05, 0x2f, 0x05, 0x3b, 0x07, 0x02, 0x0e, 0x18, 0x09, 0x80, 0xb3, 0x2d, 0x74, 0x0c, 0x80, 0xd6, 0x1a, 0x0c, 0x05, 0x80, 0xff, 0x05, 0x80, 0xdf, 0x0c, 0xee, 0x0d, 0x03, 0x84, 0x8d, 0x03, 0x37, 0x09, 0x81, 0x5c, 0x14, 0x80, 0xb8, 0x08, 0x80, 0xcb, 0x2a, 0x38, 0x03, 0x0a, 0x06, 0x38, 0x08, 0x46, 0x08, 0x0c, 0x06, 0x74, 0x0b, 0x1e, 0x03, 0x5a, 0x04, 0x59, 0x09, 0x80, 0x83, 0x18, 0x1c, 0x0a, 0x16, 0x09, 0x4c, 0x04, 0x80, 0x8a, 0x06, 0xab, 0xa4, 0x0c, 0x17, 0x04, 0x31, 0xa1, 0x04, 0x81, 0xda, 0x26, 0x07, 0x0c, 0x05, 0x05, 0x80, 0xa5, 0x11, 0x81, 0x6d, 0x10, 0x78, 0x28, 0x2a, 0x06, 0x4c, 0x04, 0x80, 0x8d, 0x04, 0x80, 0xbe, 0x03, 0x1b, 0x03, 0x0f, 0x0d, }; static constexpr unsigned char normal1[] = { 0x5e, 0x22, 0x7b, 0x05, 0x03, 0x04, 0x2d, 0x03, 0x66, 0x03, 0x01, 0x2f, 0x2e, 0x80, 0x82, 0x1d, 0x03, 0x31, 0x0f, 0x1c, 0x04, 0x24, 0x09, 0x1e, 0x05, 0x2b, 0x05, 0x44, 0x04, 0x0e, 0x2a, 0x80, 0xaa, 0x06, 0x24, 0x04, 0x24, 0x04, 0x28, 0x08, 0x34, 0x0b, 0x01, 0x80, 0x90, 0x81, 0x37, 0x09, 0x16, 0x0a, 0x08, 0x80, 0x98, 0x39, 0x03, 0x63, 0x08, 0x09, 0x30, 0x16, 0x05, 0x21, 0x03, 0x1b, 0x05, 0x01, 0x40, 0x38, 0x04, 0x4b, 0x05, 0x2f, 0x04, 0x0a, 0x07, 0x09, 0x07, 0x40, 0x20, 0x27, 0x04, 0x0c, 0x09, 0x36, 0x03, 0x3a, 0x05, 0x1a, 0x07, 0x04, 0x0c, 0x07, 0x50, 0x49, 0x37, 0x33, 0x0d, 0x33, 0x07, 0x2e, 0x08, 0x0a, 0x81, 0x26, 0x52, 0x4e, 0x28, 0x08, 0x2a, 0x56, 0x1c, 0x14, 0x17, 0x09, 0x4e, 0x04, 0x1e, 0x0f, 0x43, 0x0e, 0x19, 0x07, 0x0a, 0x06, 0x48, 0x08, 0x27, 0x09, 0x75, 0x0b, 0x3f, 0x41, 0x2a, 0x06, 0x3b, 0x05, 0x0a, 0x06, 0x51, 0x06, 0x01, 0x05, 0x10, 0x03, 0x05, 0x80, 0x8b, 0x62, 0x1e, 0x48, 0x08, 0x0a, 0x80, 0xa6, 0x5e, 0x22, 0x45, 0x0b, 0x0a, 0x06, 0x0d, 0x13, 0x39, 0x07, 0x0a, 0x36, 0x2c, 0x04, 0x10, 0x80, 0xc0, 0x3c, 0x64, 0x53, 0x0c, 0x48, 0x09, 0x0a, 0x46, 0x45, 0x1b, 0x48, 0x08, 0x53, 0x1d, 0x39, 0x81, 0x07, 0x46, 0x0a, 0x1d, 0x03, 0x47, 0x49, 0x37, 0x03, 0x0e, 0x08, 0x0a, 0x06, 0x39, 0x07, 0x0a, 0x81, 0x36, 0x19, 0x80, 0xb7, 0x01, 0x0f, 0x32, 0x0d, 0x83, 0x9b, 0x66, 0x75, 0x0b, 0x80, 0xc4, 0x8a, 0xbc, 0x84, 0x2f, 0x8f, 0xd1, 0x82, 0x47, 0xa1, 0xb9, 0x82, 0x39, 0x07, 0x2a, 0x04, 0x02, 0x60, 0x26, 0x0a, 0x46, 0x0a, 0x28, 0x05, 0x13, 0x82, 0xb0, 0x5b, 0x65, 0x4b, 0x04, 0x39, 0x07, 0x11, 0x40, 0x05, 0x0b, 0x02, 0x0e, 0x97, 0xf8, 0x08, 0x84, 0xd6, 0x2a, 0x09, 0xa2, 0xf7, 0x81, 0x1f, 0x31, 0x03, 0x11, 0x04, 0x08, 0x81, 0x8c, 0x89, 0x04, 0x6b, 0x05, 0x0d, 0x03, 0x09, 0x07, 0x10, 0x93, 0x60, 0x80, 0xf6, 0x0a, 0x73, 0x08, 0x6e, 0x17, 0x46, 0x80, 0x9a, 0x14, 0x0c, 0x57, 0x09, 0x19, 0x80, 0x87, 0x81, 0x47, 0x03, 0x85, 0x42, 0x0f, 0x15, 0x85, 0x50, 0x2b, 0x80, 0xd5, 0x2d, 0x03, 0x1a, 0x04, 0x02, 0x81, 0x70, 0x3a, 0x05, 0x01, 0x85, 0x00, 0x80, 0xd7, 0x29, 0x4c, 0x04, 0x0a, 0x04, 0x02, 0x83, 0x11, 0x44, 0x4c, 0x3d, 0x80, 0xc2, 0x3c, 0x06, 0x01, 0x04, 0x55, 0x05, 0x1b, 0x34, 0x02, 0x81, 0x0e, 0x2c, 0x04, 0x64, 0x0c, 0x56, 0x0a, 0x80, 0xae, 0x38, 0x1d, 0x0d, 0x2c, 0x04, 0x09, 0x07, 0x02, 0x0e, 0x06, 0x80, 0x9a, 0x83, 0xd8, 0x08, 0x0d, 0x03, 0x0d, 0x03, 0x74, 0x0c, 0x59, 0x07, 0x0c, 0x14, 0x0c, 0x04, 0x38, 0x08, 0x0a, 0x06, 0x28, 0x08, 0x22, 0x4e, 0x81, 0x54, 0x0c, 0x15, 0x03, 0x03, 0x05, 0x07, 0x09, 0x19, 0x07, 0x07, 0x09, 0x03, 0x0d, 0x07, 0x29, 0x80, 0xcb, 0x25, 0x0a, 0x84, 0x06, }; auto lower = static_cast<uint16_t>(cp); if (cp < 0x10000) { return is_printable(lower, singletons0, sizeof(singletons0) / sizeof(*singletons0), singletons0_lower, normal0, sizeof(normal0)); } if (cp < 0x20000) { return is_printable(lower, singletons1, sizeof(singletons1) / sizeof(*singletons1), singletons1_lower, normal1, sizeof(normal1)); } if (0x2a6de <= cp && cp < 0x2a700) return false; if (0x2b735 <= cp && cp < 0x2b740) return false; if (0x2b81e <= cp && cp < 0x2b820) return false; if (0x2cea2 <= cp && cp < 0x2ceb0) return false; if (0x2ebe1 <= cp && cp < 0x2f800) return false; if (0x2fa1e <= cp && cp < 0x30000) return false; if (0x3134b <= cp && cp < 0xe0100) return false; if (0xe01f0 <= cp && cp < 0x110000) return false; return cp < 0x110000; } } // namespace detail FMT_END_NAMESPACE #endif // FMT_FORMAT_INL_H_ ���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/vendor/fmt/format.cc�����������������������������������������������������������������0000664�0000000�0000000�00000002561�14771603147�0017235�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������// Formatting library for C++ // // Copyright (c) 2012 - 2016, Victor Zverovich // All rights reserved. // // For the license information refer to format.h. #include "fmt/format-inl.h" FMT_BEGIN_NAMESPACE namespace detail { template FMT_API auto dragonbox::to_decimal(float x) noexcept -> dragonbox::decimal_fp<float>; template FMT_API auto dragonbox::to_decimal(double x) noexcept -> dragonbox::decimal_fp<double>; #if FMT_USE_LOCALE // DEPRECATED! locale_ref in the detail namespace template FMT_API locale_ref::locale_ref(const std::locale& loc); template FMT_API auto locale_ref::get<std::locale>() const -> std::locale; #endif // Explicit instantiations for char. template FMT_API auto thousands_sep_impl(locale_ref) -> thousands_sep_result<char>; template FMT_API auto decimal_point_impl(locale_ref) -> char; // DEPRECATED! template FMT_API void buffer<char>::append(const char*, const char*); // DEPRECATED! template FMT_API void vformat_to(buffer<char>&, string_view, typename vformat_args<>::type, locale_ref); // Explicit instantiations for wchar_t. template FMT_API auto thousands_sep_impl(locale_ref) -> thousands_sep_result<wchar_t>; template FMT_API auto decimal_point_impl(locale_ref) -> wchar_t; template FMT_API void buffer<wchar_t>::append(const wchar_t*, const wchar_t*); } // namespace detail FMT_END_NAMESPACE �����������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/vendor/fmt/format.h������������������������������������������������������������������0000664�0000000�0000000�00000464056�14771603147�0017112�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* Formatting library for C++ Copyright (c) 2012 - present, Victor Zverovich Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. --- Optional exception to the license --- As an exception, if, as a result of your compiling your source code, portions of this Software are embedded into a machine-executable object form of such source code, you may redistribute such embedded portions in such object form without including the above copyright and permission notices. */ #ifndef FMT_FORMAT_H_ #define FMT_FORMAT_H_ #ifndef _LIBCPP_REMOVE_TRANSITIVE_INCLUDES # define _LIBCPP_REMOVE_TRANSITIVE_INCLUDES # define FMT_REMOVE_TRANSITIVE_INCLUDES #endif #include "base.h" #ifndef FMT_MODULE # include <cmath> // std::signbit # include <cstddef> // std::byte # include <cstdint> // uint32_t # include <cstring> // std::memcpy # include <limits> // std::numeric_limits # include <new> // std::bad_alloc # if defined(__GLIBCXX__) && !defined(_GLIBCXX_USE_DUAL_ABI) // Workaround for pre gcc 5 libstdc++. # include <memory> // std::allocator_traits # endif # include <stdexcept> // std::runtime_error # include <string> // std::string # include <system_error> // std::system_error // Check FMT_CPLUSPLUS to avoid a warning in MSVC. # if FMT_HAS_INCLUDE(<bit>) && FMT_CPLUSPLUS > 201703L # include <bit> // std::bit_cast # endif // libc++ supports string_view in pre-c++17. # if FMT_HAS_INCLUDE(<string_view>) && \ (FMT_CPLUSPLUS >= 201703L || defined(_LIBCPP_VERSION)) # include <string_view> # define FMT_USE_STRING_VIEW # endif # if FMT_MSC_VERSION # include <intrin.h> // _BitScanReverse[64], _umul128 # endif #endif // FMT_MODULE #if defined(FMT_USE_NONTYPE_TEMPLATE_ARGS) // Use the provided definition. #elif defined(__NVCOMPILER) # define FMT_USE_NONTYPE_TEMPLATE_ARGS 0 #elif FMT_GCC_VERSION >= 903 && FMT_CPLUSPLUS >= 201709L # define FMT_USE_NONTYPE_TEMPLATE_ARGS 1 #elif defined(__cpp_nontype_template_args) && \ __cpp_nontype_template_args >= 201911L # define FMT_USE_NONTYPE_TEMPLATE_ARGS 1 #elif FMT_CLANG_VERSION >= 1200 && FMT_CPLUSPLUS >= 202002L # define FMT_USE_NONTYPE_TEMPLATE_ARGS 1 #else # define FMT_USE_NONTYPE_TEMPLATE_ARGS 0 #endif #if defined __cpp_inline_variables && __cpp_inline_variables >= 201606L # define FMT_INLINE_VARIABLE inline #else # define FMT_INLINE_VARIABLE #endif // Check if RTTI is disabled. #ifdef FMT_USE_RTTI // Use the provided definition. #elif defined(__GXX_RTTI) || FMT_HAS_FEATURE(cxx_rtti) || defined(_CPPRTTI) || \ defined(__INTEL_RTTI__) || defined(__RTTI) // __RTTI is for EDG compilers. _CPPRTTI is for MSVC. # define FMT_USE_RTTI 1 #else # define FMT_USE_RTTI 0 #endif // Visibility when compiled as a shared library/object. #if defined(FMT_LIB_EXPORT) || defined(FMT_SHARED) # define FMT_SO_VISIBILITY(value) FMT_VISIBILITY(value) #else # define FMT_SO_VISIBILITY(value) #endif #if FMT_GCC_VERSION || FMT_CLANG_VERSION # define FMT_NOINLINE __attribute__((noinline)) #else # define FMT_NOINLINE #endif namespace std { template <typename T> struct iterator_traits<fmt::basic_appender<T>> { using iterator_category = output_iterator_tag; using value_type = T; using difference_type = decltype(static_cast<int*>(nullptr) - static_cast<int*>(nullptr)); using pointer = void; using reference = void; }; } // namespace std #ifndef FMT_THROW # if FMT_USE_EXCEPTIONS # if FMT_MSC_VERSION || defined(__NVCC__) FMT_BEGIN_NAMESPACE namespace detail { template <typename Exception> inline void do_throw(const Exception& x) { // Silence unreachable code warnings in MSVC and NVCC because these // are nearly impossible to fix in a generic code. volatile bool b = true; if (b) throw x; } } // namespace detail FMT_END_NAMESPACE # define FMT_THROW(x) detail::do_throw(x) # else # define FMT_THROW(x) throw x # endif # else # define FMT_THROW(x) \ ::fmt::detail::assert_fail(__FILE__, __LINE__, (x).what()) # endif // FMT_USE_EXCEPTIONS #endif // FMT_THROW // Defining FMT_REDUCE_INT_INSTANTIATIONS to 1, will reduce the number of // integer formatter template instantiations to just one by only using the // largest integer type. This results in a reduction in binary size but will // cause a decrease in integer formatting performance. #if !defined(FMT_REDUCE_INT_INSTANTIATIONS) # define FMT_REDUCE_INT_INSTANTIATIONS 0 #endif FMT_BEGIN_NAMESPACE template <typename Char, typename Traits, typename Allocator> struct is_contiguous<std::basic_string<Char, Traits, Allocator>> : std::true_type {}; namespace detail { // __builtin_clz is broken in clang with Microsoft codegen: // https://github.com/fmtlib/fmt/issues/519. #if !FMT_MSC_VERSION # if FMT_HAS_BUILTIN(__builtin_clz) || FMT_GCC_VERSION || FMT_ICC_VERSION # define FMT_BUILTIN_CLZ(n) __builtin_clz(n) # endif # if FMT_HAS_BUILTIN(__builtin_clzll) || FMT_GCC_VERSION || FMT_ICC_VERSION # define FMT_BUILTIN_CLZLL(n) __builtin_clzll(n) # endif #endif // Some compilers masquerade as both MSVC and GCC but otherwise support // __builtin_clz and __builtin_clzll, so only define FMT_BUILTIN_CLZ using the // MSVC intrinsics if the clz and clzll builtins are not available. #if FMT_MSC_VERSION && !defined(FMT_BUILTIN_CLZLL) // Avoid Clang with Microsoft CodeGen's -Wunknown-pragmas warning. # ifndef __clang__ # pragma intrinsic(_BitScanReverse) # ifdef _WIN64 # pragma intrinsic(_BitScanReverse64) # endif # endif inline auto clz(uint32_t x) -> int { FMT_ASSERT(x != 0, ""); FMT_MSC_WARNING(suppress : 6102) // Suppress a bogus static analysis warning. unsigned long r = 0; _BitScanReverse(&r, x); return 31 ^ static_cast<int>(r); } # define FMT_BUILTIN_CLZ(n) detail::clz(n) inline auto clzll(uint64_t x) -> int { FMT_ASSERT(x != 0, ""); FMT_MSC_WARNING(suppress : 6102) // Suppress a bogus static analysis warning. unsigned long r = 0; # ifdef _WIN64 _BitScanReverse64(&r, x); # else // Scan the high 32 bits. if (_BitScanReverse(&r, static_cast<uint32_t>(x >> 32))) return 63 ^ static_cast<int>(r + 32); // Scan the low 32 bits. _BitScanReverse(&r, static_cast<uint32_t>(x)); # endif return 63 ^ static_cast<int>(r); } # define FMT_BUILTIN_CLZLL(n) detail::clzll(n) #endif // FMT_MSC_VERSION && !defined(FMT_BUILTIN_CLZLL) FMT_CONSTEXPR inline void abort_fuzzing_if(bool condition) { ignore_unused(condition); #ifdef FMT_FUZZ if (condition) throw std::runtime_error("fuzzing limit reached"); #endif } #if defined(FMT_USE_STRING_VIEW) template <typename Char> using std_string_view = std::basic_string_view<Char>; #else template <typename Char> struct std_string_view { operator basic_string_view<Char>() const; }; #endif template <typename Char, Char... C> struct string_literal { static constexpr Char value[sizeof...(C)] = {C...}; constexpr operator basic_string_view<Char>() const { return {value, sizeof...(C)}; } }; #if FMT_CPLUSPLUS < 201703L template <typename Char, Char... C> constexpr Char string_literal<Char, C...>::value[sizeof...(C)]; #endif // Implementation of std::bit_cast for pre-C++20. template <typename To, typename From, FMT_ENABLE_IF(sizeof(To) == sizeof(From))> FMT_CONSTEXPR20 auto bit_cast(const From& from) -> To { #ifdef __cpp_lib_bit_cast if (is_constant_evaluated()) return std::bit_cast<To>(from); #endif auto to = To(); // The cast suppresses a bogus -Wclass-memaccess on GCC. std::memcpy(static_cast<void*>(&to), &from, sizeof(to)); return to; } inline auto is_big_endian() -> bool { #ifdef _WIN32 return false; #elif defined(__BIG_ENDIAN__) return true; #elif defined(__BYTE_ORDER__) && defined(__ORDER_BIG_ENDIAN__) return __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__; #else struct bytes { char data[sizeof(int)]; }; return bit_cast<bytes>(1).data[0] == 0; #endif } class uint128_fallback { private: uint64_t lo_, hi_; public: constexpr uint128_fallback(uint64_t hi, uint64_t lo) : lo_(lo), hi_(hi) {} constexpr uint128_fallback(uint64_t value = 0) : lo_(value), hi_(0) {} constexpr auto high() const noexcept -> uint64_t { return hi_; } constexpr auto low() const noexcept -> uint64_t { return lo_; } template <typename T, FMT_ENABLE_IF(std::is_integral<T>::value)> constexpr explicit operator T() const { return static_cast<T>(lo_); } friend constexpr auto operator==(const uint128_fallback& lhs, const uint128_fallback& rhs) -> bool { return lhs.hi_ == rhs.hi_ && lhs.lo_ == rhs.lo_; } friend constexpr auto operator!=(const uint128_fallback& lhs, const uint128_fallback& rhs) -> bool { return !(lhs == rhs); } friend constexpr auto operator>(const uint128_fallback& lhs, const uint128_fallback& rhs) -> bool { return lhs.hi_ != rhs.hi_ ? lhs.hi_ > rhs.hi_ : lhs.lo_ > rhs.lo_; } friend constexpr auto operator|(const uint128_fallback& lhs, const uint128_fallback& rhs) -> uint128_fallback { return {lhs.hi_ | rhs.hi_, lhs.lo_ | rhs.lo_}; } friend constexpr auto operator&(const uint128_fallback& lhs, const uint128_fallback& rhs) -> uint128_fallback { return {lhs.hi_ & rhs.hi_, lhs.lo_ & rhs.lo_}; } friend constexpr auto operator~(const uint128_fallback& n) -> uint128_fallback { return {~n.hi_, ~n.lo_}; } friend FMT_CONSTEXPR auto operator+(const uint128_fallback& lhs, const uint128_fallback& rhs) -> uint128_fallback { auto result = uint128_fallback(lhs); result += rhs; return result; } friend FMT_CONSTEXPR auto operator*(const uint128_fallback& lhs, uint32_t rhs) -> uint128_fallback { FMT_ASSERT(lhs.hi_ == 0, ""); uint64_t hi = (lhs.lo_ >> 32) * rhs; uint64_t lo = (lhs.lo_ & ~uint32_t()) * rhs; uint64_t new_lo = (hi << 32) + lo; return {(hi >> 32) + (new_lo < lo ? 1 : 0), new_lo}; } friend constexpr auto operator-(const uint128_fallback& lhs, uint64_t rhs) -> uint128_fallback { return {lhs.hi_ - (lhs.lo_ < rhs ? 1 : 0), lhs.lo_ - rhs}; } FMT_CONSTEXPR auto operator>>(int shift) const -> uint128_fallback { if (shift == 64) return {0, hi_}; if (shift > 64) return uint128_fallback(0, hi_) >> (shift - 64); return {hi_ >> shift, (hi_ << (64 - shift)) | (lo_ >> shift)}; } FMT_CONSTEXPR auto operator<<(int shift) const -> uint128_fallback { if (shift == 64) return {lo_, 0}; if (shift > 64) return uint128_fallback(lo_, 0) << (shift - 64); return {hi_ << shift | (lo_ >> (64 - shift)), (lo_ << shift)}; } FMT_CONSTEXPR auto operator>>=(int shift) -> uint128_fallback& { return *this = *this >> shift; } FMT_CONSTEXPR void operator+=(uint128_fallback n) { uint64_t new_lo = lo_ + n.lo_; uint64_t new_hi = hi_ + n.hi_ + (new_lo < lo_ ? 1 : 0); FMT_ASSERT(new_hi >= hi_, ""); lo_ = new_lo; hi_ = new_hi; } FMT_CONSTEXPR void operator&=(uint128_fallback n) { lo_ &= n.lo_; hi_ &= n.hi_; } FMT_CONSTEXPR20 auto operator+=(uint64_t n) noexcept -> uint128_fallback& { if (is_constant_evaluated()) { lo_ += n; hi_ += (lo_ < n ? 1 : 0); return *this; } #if FMT_HAS_BUILTIN(__builtin_addcll) && !defined(__ibmxl__) unsigned long long carry; lo_ = __builtin_addcll(lo_, n, 0, &carry); hi_ += carry; #elif FMT_HAS_BUILTIN(__builtin_ia32_addcarryx_u64) && !defined(__ibmxl__) unsigned long long result; auto carry = __builtin_ia32_addcarryx_u64(0, lo_, n, &result); lo_ = result; hi_ += carry; #elif defined(_MSC_VER) && defined(_M_X64) auto carry = _addcarry_u64(0, lo_, n, &lo_); _addcarry_u64(carry, hi_, 0, &hi_); #else lo_ += n; hi_ += (lo_ < n ? 1 : 0); #endif return *this; } }; using uint128_t = conditional_t<FMT_USE_INT128, uint128_opt, uint128_fallback>; #ifdef UINTPTR_MAX using uintptr_t = ::uintptr_t; #else using uintptr_t = uint128_t; #endif // Returns the largest possible value for type T. Same as // std::numeric_limits<T>::max() but shorter and not affected by the max macro. template <typename T> constexpr auto max_value() -> T { return (std::numeric_limits<T>::max)(); } template <typename T> constexpr auto num_bits() -> int { return std::numeric_limits<T>::digits; } // std::numeric_limits<T>::digits may return 0 for 128-bit ints. template <> constexpr auto num_bits<int128_opt>() -> int { return 128; } template <> constexpr auto num_bits<uint128_opt>() -> int { return 128; } template <> constexpr auto num_bits<uint128_fallback>() -> int { return 128; } // A heterogeneous bit_cast used for converting 96-bit long double to uint128_t // and 128-bit pointers to uint128_fallback. template <typename To, typename From, FMT_ENABLE_IF(sizeof(To) > sizeof(From))> inline auto bit_cast(const From& from) -> To { constexpr auto size = static_cast<int>(sizeof(From) / sizeof(unsigned short)); struct data_t { unsigned short value[static_cast<unsigned>(size)]; } data = bit_cast<data_t>(from); auto result = To(); if (const_check(is_big_endian())) { for (int i = 0; i < size; ++i) result = (result << num_bits<unsigned short>()) | data.value[i]; } else { for (int i = size - 1; i >= 0; --i) result = (result << num_bits<unsigned short>()) | data.value[i]; } return result; } template <typename UInt> FMT_CONSTEXPR20 inline auto countl_zero_fallback(UInt n) -> int { int lz = 0; constexpr UInt msb_mask = static_cast<UInt>(1) << (num_bits<UInt>() - 1); for (; (n & msb_mask) == 0; n <<= 1) lz++; return lz; } FMT_CONSTEXPR20 inline auto countl_zero(uint32_t n) -> int { #ifdef FMT_BUILTIN_CLZ if (!is_constant_evaluated()) return FMT_BUILTIN_CLZ(n); #endif return countl_zero_fallback(n); } FMT_CONSTEXPR20 inline auto countl_zero(uint64_t n) -> int { #ifdef FMT_BUILTIN_CLZLL if (!is_constant_evaluated()) return FMT_BUILTIN_CLZLL(n); #endif return countl_zero_fallback(n); } FMT_INLINE void assume(bool condition) { (void)condition; #if FMT_HAS_BUILTIN(__builtin_assume) && !FMT_ICC_VERSION __builtin_assume(condition); #elif FMT_GCC_VERSION if (!condition) __builtin_unreachable(); #endif } // Attempts to reserve space for n extra characters in the output range. // Returns a pointer to the reserved range or a reference to it. template <typename OutputIt, FMT_ENABLE_IF(is_back_insert_iterator<OutputIt>::value&& is_contiguous<typename OutputIt::container>::value)> #if FMT_CLANG_VERSION >= 307 && !FMT_ICC_VERSION __attribute__((no_sanitize("undefined"))) #endif FMT_CONSTEXPR20 inline auto reserve(OutputIt it, size_t n) -> typename OutputIt::value_type* { auto& c = get_container(it); size_t size = c.size(); c.resize(size + n); return &c[size]; } template <typename T> FMT_CONSTEXPR20 inline auto reserve(basic_appender<T> it, size_t n) -> basic_appender<T> { buffer<T>& buf = get_container(it); buf.try_reserve(buf.size() + n); return it; } template <typename Iterator> constexpr auto reserve(Iterator& it, size_t) -> Iterator& { return it; } template <typename OutputIt> using reserve_iterator = remove_reference_t<decltype(reserve(std::declval<OutputIt&>(), 0))>; template <typename T, typename OutputIt> constexpr auto to_pointer(OutputIt, size_t) -> T* { return nullptr; } template <typename T> FMT_CONSTEXPR20 auto to_pointer(basic_appender<T> it, size_t n) -> T* { buffer<T>& buf = get_container(it); buf.try_reserve(buf.size() + n); auto size = buf.size(); if (buf.capacity() < size + n) return nullptr; buf.try_resize(size + n); return buf.data() + size; } template <typename OutputIt, FMT_ENABLE_IF(is_back_insert_iterator<OutputIt>::value&& is_contiguous<typename OutputIt::container>::value)> inline auto base_iterator(OutputIt it, typename OutputIt::container_type::value_type*) -> OutputIt { return it; } template <typename Iterator> constexpr auto base_iterator(Iterator, Iterator it) -> Iterator { return it; } // <algorithm> is spectacularly slow to compile in C++20 so use a simple fill_n // instead (#1998). template <typename OutputIt, typename Size, typename T> FMT_CONSTEXPR auto fill_n(OutputIt out, Size count, const T& value) -> OutputIt { for (Size i = 0; i < count; ++i) *out++ = value; return out; } template <typename T, typename Size> FMT_CONSTEXPR20 auto fill_n(T* out, Size count, char value) -> T* { if (is_constant_evaluated()) return fill_n<T*, Size, T>(out, count, value); std::memset(out, value, to_unsigned(count)); return out + count; } template <typename OutChar, typename InputIt, typename OutputIt> FMT_CONSTEXPR FMT_NOINLINE auto copy_noinline(InputIt begin, InputIt end, OutputIt out) -> OutputIt { return copy<OutChar>(begin, end, out); } // A public domain branchless UTF-8 decoder by Christopher Wellons: // https://github.com/skeeto/branchless-utf8 /* Decode the next character, c, from s, reporting errors in e. * * Since this is a branchless decoder, four bytes will be read from the * buffer regardless of the actual length of the next character. This * means the buffer _must_ have at least three bytes of zero padding * following the end of the data stream. * * Errors are reported in e, which will be non-zero if the parsed * character was somehow invalid: invalid byte sequence, non-canonical * encoding, or a surrogate half. * * The function returns a pointer to the next character. When an error * occurs, this pointer will be a guess that depends on the particular * error, but it will always advance at least one byte. */ FMT_CONSTEXPR inline auto utf8_decode(const char* s, uint32_t* c, int* e) -> const char* { constexpr const int masks[] = {0x00, 0x7f, 0x1f, 0x0f, 0x07}; constexpr const uint32_t mins[] = {4194304, 0, 128, 2048, 65536}; constexpr const int shiftc[] = {0, 18, 12, 6, 0}; constexpr const int shifte[] = {0, 6, 4, 2, 0}; int len = "\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\0\0\0\0\0\0\0\0\2\2\2\2\3\3\4" [static_cast<unsigned char>(*s) >> 3]; // Compute the pointer to the next character early so that the next // iteration can start working on the next character. Neither Clang // nor GCC figure out this reordering on their own. const char* next = s + len + !len; using uchar = unsigned char; // Assume a four-byte character and load four bytes. Unused bits are // shifted out. *c = uint32_t(uchar(s[0]) & masks[len]) << 18; *c |= uint32_t(uchar(s[1]) & 0x3f) << 12; *c |= uint32_t(uchar(s[2]) & 0x3f) << 6; *c |= uint32_t(uchar(s[3]) & 0x3f) << 0; *c >>= shiftc[len]; // Accumulate the various error conditions. *e = (*c < mins[len]) << 6; // non-canonical encoding *e |= ((*c >> 11) == 0x1b) << 7; // surrogate half? *e |= (*c > 0x10FFFF) << 8; // out of range? *e |= (uchar(s[1]) & 0xc0) >> 2; *e |= (uchar(s[2]) & 0xc0) >> 4; *e |= uchar(s[3]) >> 6; *e ^= 0x2a; // top two bits of each tail byte correct? *e >>= shifte[len]; return next; } constexpr FMT_INLINE_VARIABLE uint32_t invalid_code_point = ~uint32_t(); // Invokes f(cp, sv) for every code point cp in s with sv being the string view // corresponding to the code point. cp is invalid_code_point on error. template <typename F> FMT_CONSTEXPR void for_each_codepoint(string_view s, F f) { auto decode = [f](const char* buf_ptr, const char* ptr) { auto cp = uint32_t(); auto error = 0; auto end = utf8_decode(buf_ptr, &cp, &error); bool result = f(error ? invalid_code_point : cp, string_view(ptr, error ? 1 : to_unsigned(end - buf_ptr))); return result ? (error ? buf_ptr + 1 : end) : nullptr; }; auto p = s.data(); const size_t block_size = 4; // utf8_decode always reads blocks of 4 chars. if (s.size() >= block_size) { for (auto end = p + s.size() - block_size + 1; p < end;) { p = decode(p, p); if (!p) return; } } auto num_chars_left = to_unsigned(s.data() + s.size() - p); if (num_chars_left == 0) return; // Suppress bogus -Wstringop-overflow. if (FMT_GCC_VERSION) num_chars_left &= 3; char buf[2 * block_size - 1] = {}; copy<char>(p, p + num_chars_left, buf); const char* buf_ptr = buf; do { auto end = decode(buf_ptr, p); if (!end) return; p += end - buf_ptr; buf_ptr = end; } while (buf_ptr < buf + num_chars_left); } template <typename Char> inline auto compute_width(basic_string_view<Char> s) -> size_t { return s.size(); } // Computes approximate display width of a UTF-8 string. FMT_CONSTEXPR inline auto compute_width(string_view s) -> size_t { size_t num_code_points = 0; // It is not a lambda for compatibility with C++14. struct count_code_points { size_t* count; FMT_CONSTEXPR auto operator()(uint32_t cp, string_view) const -> bool { *count += to_unsigned( 1 + (cp >= 0x1100 && (cp <= 0x115f || // Hangul Jamo init. consonants cp == 0x2329 || // LEFT-POINTING ANGLE BRACKET cp == 0x232a || // RIGHT-POINTING ANGLE BRACKET // CJK ... Yi except IDEOGRAPHIC HALF FILL SPACE: (cp >= 0x2e80 && cp <= 0xa4cf && cp != 0x303f) || (cp >= 0xac00 && cp <= 0xd7a3) || // Hangul Syllables (cp >= 0xf900 && cp <= 0xfaff) || // CJK Compatibility Ideographs (cp >= 0xfe10 && cp <= 0xfe19) || // Vertical Forms (cp >= 0xfe30 && cp <= 0xfe6f) || // CJK Compatibility Forms (cp >= 0xff00 && cp <= 0xff60) || // Fullwidth Forms (cp >= 0xffe0 && cp <= 0xffe6) || // Fullwidth Forms (cp >= 0x20000 && cp <= 0x2fffd) || // CJK (cp >= 0x30000 && cp <= 0x3fffd) || // Miscellaneous Symbols and Pictographs + Emoticons: (cp >= 0x1f300 && cp <= 0x1f64f) || // Supplemental Symbols and Pictographs: (cp >= 0x1f900 && cp <= 0x1f9ff)))); return true; } }; // We could avoid branches by using utf8_decode directly. for_each_codepoint(s, count_code_points{&num_code_points}); return num_code_points; } template <typename Char> inline auto code_point_index(basic_string_view<Char> s, size_t n) -> size_t { return min_of(n, s.size()); } // Calculates the index of the nth code point in a UTF-8 string. inline auto code_point_index(string_view s, size_t n) -> size_t { size_t result = s.size(); const char* begin = s.begin(); for_each_codepoint(s, [begin, &n, &result](uint32_t, string_view sv) { if (n != 0) { --n; return true; } result = to_unsigned(sv.begin() - begin); return false; }); return result; } template <typename T> struct is_integral : std::is_integral<T> {}; template <> struct is_integral<int128_opt> : std::true_type {}; template <> struct is_integral<uint128_t> : std::true_type {}; template <typename T> using is_signed = std::integral_constant<bool, std::numeric_limits<T>::is_signed || std::is_same<T, int128_opt>::value>; template <typename T> using is_integer = bool_constant<is_integral<T>::value && !std::is_same<T, bool>::value && !std::is_same<T, char>::value && !std::is_same<T, wchar_t>::value>; #if defined(FMT_USE_FLOAT128) // Use the provided definition. #elif FMT_CLANG_VERSION && FMT_HAS_INCLUDE(<quadmath.h>) # define FMT_USE_FLOAT128 1 #elif FMT_GCC_VERSION && defined(_GLIBCXX_USE_FLOAT128) && \ !defined(__STRICT_ANSI__) # define FMT_USE_FLOAT128 1 #else # define FMT_USE_FLOAT128 0 #endif #if FMT_USE_FLOAT128 using float128 = __float128; #else struct float128 {}; #endif template <typename T> using is_float128 = std::is_same<T, float128>; template <typename T> using is_floating_point = bool_constant<std::is_floating_point<T>::value || is_float128<T>::value>; template <typename T, bool = std::is_floating_point<T>::value> struct is_fast_float : bool_constant<std::numeric_limits<T>::is_iec559 && sizeof(T) <= sizeof(double)> {}; template <typename T> struct is_fast_float<T, false> : std::false_type {}; template <typename T> using is_double_double = bool_constant<std::numeric_limits<T>::digits == 106>; #ifndef FMT_USE_FULL_CACHE_DRAGONBOX # define FMT_USE_FULL_CACHE_DRAGONBOX 0 #endif // An allocator that uses malloc/free to allow removing dependency on the C++ // standard libary runtime. template <typename T> struct allocator { using value_type = T; T* allocate(size_t n) { FMT_ASSERT(n <= max_value<size_t>() / sizeof(T), ""); T* p = static_cast<T*>(malloc(n * sizeof(T))); if (!p) FMT_THROW(std::bad_alloc()); return p; } void deallocate(T* p, size_t) { free(p); } }; } // namespace detail FMT_BEGIN_EXPORT // The number of characters to store in the basic_memory_buffer object itself // to avoid dynamic memory allocation. enum { inline_buffer_size = 500 }; /** * A dynamically growing memory buffer for trivially copyable/constructible * types with the first `SIZE` elements stored in the object itself. Most * commonly used via the `memory_buffer` alias for `char`. * * **Example**: * * auto out = fmt::memory_buffer(); * fmt::format_to(std::back_inserter(out), "The answer is {}.", 42); * * This will append "The answer is 42." to `out`. The buffer content can be * converted to `std::string` with `to_string(out)`. */ template <typename T, size_t SIZE = inline_buffer_size, typename Allocator = detail::allocator<T>> class basic_memory_buffer : public detail::buffer<T> { private: T store_[SIZE]; // Don't inherit from Allocator to avoid generating type_info for it. FMT_NO_UNIQUE_ADDRESS Allocator alloc_; // Deallocate memory allocated by the buffer. FMT_CONSTEXPR20 void deallocate() { T* data = this->data(); if (data != store_) alloc_.deallocate(data, this->capacity()); } static FMT_CONSTEXPR20 void grow(detail::buffer<T>& buf, size_t size) { detail::abort_fuzzing_if(size > 5000); auto& self = static_cast<basic_memory_buffer&>(buf); const size_t max_size = std::allocator_traits<Allocator>::max_size(self.alloc_); size_t old_capacity = buf.capacity(); size_t new_capacity = old_capacity + old_capacity / 2; if (size > new_capacity) new_capacity = size; else if (new_capacity > max_size) new_capacity = max_of(size, max_size); T* old_data = buf.data(); T* new_data = self.alloc_.allocate(new_capacity); // Suppress a bogus -Wstringop-overflow in gcc 13.1 (#3481). detail::assume(buf.size() <= new_capacity); // The following code doesn't throw, so the raw pointer above doesn't leak. memcpy(new_data, old_data, buf.size() * sizeof(T)); self.set(new_data, new_capacity); // deallocate must not throw according to the standard, but even if it does, // the buffer already uses the new storage and will deallocate it in // destructor. if (old_data != self.store_) self.alloc_.deallocate(old_data, old_capacity); } public: using value_type = T; using const_reference = const T&; FMT_CONSTEXPR explicit basic_memory_buffer( const Allocator& alloc = Allocator()) : detail::buffer<T>(grow), alloc_(alloc) { this->set(store_, SIZE); if (detail::is_constant_evaluated()) detail::fill_n(store_, SIZE, T()); } FMT_CONSTEXPR20 ~basic_memory_buffer() { deallocate(); } private: // Move data from other to this buffer. FMT_CONSTEXPR20 void move(basic_memory_buffer& other) { alloc_ = std::move(other.alloc_); T* data = other.data(); size_t size = other.size(), capacity = other.capacity(); if (data == other.store_) { this->set(store_, capacity); detail::copy<T>(other.store_, other.store_ + size, store_); } else { this->set(data, capacity); // Set pointer to the inline array so that delete is not called // when deallocating. other.set(other.store_, 0); other.clear(); } this->resize(size); } public: /// Constructs a `basic_memory_buffer` object moving the content of the other /// object to it. FMT_CONSTEXPR20 basic_memory_buffer(basic_memory_buffer&& other) noexcept : detail::buffer<T>(grow) { move(other); } /// Moves the content of the other `basic_memory_buffer` object to this one. auto operator=(basic_memory_buffer&& other) noexcept -> basic_memory_buffer& { FMT_ASSERT(this != &other, ""); deallocate(); move(other); return *this; } // Returns a copy of the allocator associated with this buffer. auto get_allocator() const -> Allocator { return alloc_; } /// Resizes the buffer to contain `count` elements. If T is a POD type new /// elements may not be initialized. FMT_CONSTEXPR void resize(size_t count) { this->try_resize(count); } /// Increases the buffer capacity to `new_capacity`. void reserve(size_t new_capacity) { this->try_reserve(new_capacity); } using detail::buffer<T>::append; template <typename ContiguousRange> FMT_CONSTEXPR20 void append(const ContiguousRange& range) { append(range.data(), range.data() + range.size()); } }; using memory_buffer = basic_memory_buffer<char>; template <size_t SIZE> FMT_NODISCARD auto to_string(const basic_memory_buffer<char, SIZE>& buf) -> std::string { auto size = buf.size(); detail::assume(size < std::string().max_size()); return {buf.data(), size}; } // A writer to a buffered stream. It doesn't own the underlying stream. class writer { private: detail::buffer<char>* buf_; // We cannot create a file buffer in advance because any write to a FILE may // invalidate it. FILE* file_; public: inline writer(FILE* f) : buf_(nullptr), file_(f) {} inline writer(detail::buffer<char>& buf) : buf_(&buf) {} /// Formats `args` according to specifications in `fmt` and writes the /// output to the file. template <typename... T> void print(format_string<T...> fmt, T&&... args) { if (buf_) fmt::format_to(appender(*buf_), fmt, std::forward<T>(args)...); else fmt::print(file_, fmt, std::forward<T>(args)...); } }; class string_buffer { private: std::string str_; detail::container_buffer<std::string> buf_; public: inline string_buffer() : buf_(str_) {} inline operator writer() { return buf_; } inline std::string& str() { return str_; } }; template <typename T, size_t SIZE, typename Allocator> struct is_contiguous<basic_memory_buffer<T, SIZE, Allocator>> : std::true_type { }; // Suppress a misleading warning in older versions of clang. FMT_PRAGMA_CLANG(diagnostic ignored "-Wweak-vtables") /// An error reported from a formatting function. class FMT_SO_VISIBILITY("default") format_error : public std::runtime_error { public: using std::runtime_error::runtime_error; }; class loc_value; FMT_END_EXPORT namespace detail { FMT_API auto write_console(int fd, string_view text) -> bool; FMT_API void print(FILE*, string_view); } // namespace detail namespace detail { template <typename Char, size_t N> struct fixed_string { FMT_CONSTEXPR20 fixed_string(const Char (&s)[N]) { detail::copy<Char, const Char*, Char*>(static_cast<const Char*>(s), s + N, data); } Char data[N] = {}; }; // Converts a compile-time string to basic_string_view. FMT_EXPORT template <typename Char, size_t N> constexpr auto compile_string_to_view(const Char (&s)[N]) -> basic_string_view<Char> { // Remove trailing NUL character if needed. Won't be present if this is used // with a raw character array (i.e. not defined as a string). return {s, N - (std::char_traits<Char>::to_int_type(s[N - 1]) == 0 ? 1 : 0)}; } FMT_EXPORT template <typename Char> constexpr auto compile_string_to_view(basic_string_view<Char> s) -> basic_string_view<Char> { return s; } // Returns true if value is negative, false otherwise. // Same as `value < 0` but doesn't produce warnings if T is an unsigned type. template <typename T, FMT_ENABLE_IF(is_signed<T>::value)> constexpr auto is_negative(T value) -> bool { return value < 0; } template <typename T, FMT_ENABLE_IF(!is_signed<T>::value)> constexpr auto is_negative(T) -> bool { return false; } // Smallest of uint32_t, uint64_t, uint128_t that is large enough to // represent all values of an integral type T. template <typename T> using uint32_or_64_or_128_t = conditional_t<num_bits<T>() <= 32 && !FMT_REDUCE_INT_INSTANTIATIONS, uint32_t, conditional_t<num_bits<T>() <= 64, uint64_t, uint128_t>>; template <typename T> using uint64_or_128_t = conditional_t<num_bits<T>() <= 64, uint64_t, uint128_t>; #define FMT_POWERS_OF_10(factor) \ factor * 10, (factor) * 100, (factor) * 1000, (factor) * 10000, \ (factor) * 100000, (factor) * 1000000, (factor) * 10000000, \ (factor) * 100000000, (factor) * 1000000000 // Converts value in the range [0, 100) to a string. // GCC generates slightly better code when value is pointer-size. inline auto digits2(size_t value) -> const char* { // Align data since unaligned access may be slower when crossing a // hardware-specific boundary. alignas(2) static const char data[] = "0001020304050607080910111213141516171819" "2021222324252627282930313233343536373839" "4041424344454647484950515253545556575859" "6061626364656667686970717273747576777879" "8081828384858687888990919293949596979899"; return &data[value * 2]; } template <typename Char> constexpr auto getsign(sign s) -> Char { return static_cast<char>(((' ' << 24) | ('+' << 16) | ('-' << 8)) >> (static_cast<int>(s) * 8)); } template <typename T> FMT_CONSTEXPR auto count_digits_fallback(T n) -> int { int count = 1; for (;;) { // Integer division is slow so do it for a group of four digits instead // of for every digit. The idea comes from the talk by Alexandrescu // "Three Optimization Tips for C++". See speed-test for a comparison. if (n < 10) return count; if (n < 100) return count + 1; if (n < 1000) return count + 2; if (n < 10000) return count + 3; n /= 10000u; count += 4; } } #if FMT_USE_INT128 FMT_CONSTEXPR inline auto count_digits(uint128_opt n) -> int { return count_digits_fallback(n); } #endif #ifdef FMT_BUILTIN_CLZLL // It is a separate function rather than a part of count_digits to workaround // the lack of static constexpr in constexpr functions. inline auto do_count_digits(uint64_t n) -> int { // This has comparable performance to the version by Kendall Willets // (https://github.com/fmtlib/format-benchmark/blob/master/digits10) // but uses smaller tables. // Maps bsr(n) to ceil(log10(pow(2, bsr(n) + 1) - 1)). static constexpr uint8_t bsr2log10[] = { 1, 1, 1, 2, 2, 2, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 6, 6, 6, 7, 7, 7, 7, 8, 8, 8, 9, 9, 9, 10, 10, 10, 10, 11, 11, 11, 12, 12, 12, 13, 13, 13, 13, 14, 14, 14, 15, 15, 15, 16, 16, 16, 16, 17, 17, 17, 18, 18, 18, 19, 19, 19, 19, 20}; auto t = bsr2log10[FMT_BUILTIN_CLZLL(n | 1) ^ 63]; static constexpr const uint64_t zero_or_powers_of_10[] = { 0, 0, FMT_POWERS_OF_10(1U), FMT_POWERS_OF_10(1000000000ULL), 10000000000000000000ULL}; return t - (n < zero_or_powers_of_10[t]); } #endif // Returns the number of decimal digits in n. Leading zeros are not counted // except for n == 0 in which case count_digits returns 1. FMT_CONSTEXPR20 inline auto count_digits(uint64_t n) -> int { #ifdef FMT_BUILTIN_CLZLL if (!is_constant_evaluated() && !FMT_OPTIMIZE_SIZE) return do_count_digits(n); #endif return count_digits_fallback(n); } // Counts the number of digits in n. BITS = log2(radix). template <int BITS, typename UInt> FMT_CONSTEXPR auto count_digits(UInt n) -> int { #ifdef FMT_BUILTIN_CLZ if (!is_constant_evaluated() && num_bits<UInt>() == 32) return (FMT_BUILTIN_CLZ(static_cast<uint32_t>(n) | 1) ^ 31) / BITS + 1; #endif // Lambda avoids unreachable code warnings from NVHPC. return [](UInt m) { int num_digits = 0; do { ++num_digits; } while ((m >>= BITS) != 0); return num_digits; }(n); } #ifdef FMT_BUILTIN_CLZ // It is a separate function rather than a part of count_digits to workaround // the lack of static constexpr in constexpr functions. FMT_INLINE auto do_count_digits(uint32_t n) -> int { // An optimization by Kendall Willets from https://bit.ly/3uOIQrB. // This increments the upper 32 bits (log10(T) - 1) when >= T is added. # define FMT_INC(T) (((sizeof(#T) - 1ull) << 32) - T) static constexpr uint64_t table[] = { FMT_INC(0), FMT_INC(0), FMT_INC(0), // 8 FMT_INC(10), FMT_INC(10), FMT_INC(10), // 64 FMT_INC(100), FMT_INC(100), FMT_INC(100), // 512 FMT_INC(1000), FMT_INC(1000), FMT_INC(1000), // 4096 FMT_INC(10000), FMT_INC(10000), FMT_INC(10000), // 32k FMT_INC(100000), FMT_INC(100000), FMT_INC(100000), // 256k FMT_INC(1000000), FMT_INC(1000000), FMT_INC(1000000), // 2048k FMT_INC(10000000), FMT_INC(10000000), FMT_INC(10000000), // 16M FMT_INC(100000000), FMT_INC(100000000), FMT_INC(100000000), // 128M FMT_INC(1000000000), FMT_INC(1000000000), FMT_INC(1000000000), // 1024M FMT_INC(1000000000), FMT_INC(1000000000) // 4B }; auto inc = table[FMT_BUILTIN_CLZ(n | 1) ^ 31]; return static_cast<int>((n + inc) >> 32); } #endif // Optional version of count_digits for better performance on 32-bit platforms. FMT_CONSTEXPR20 inline auto count_digits(uint32_t n) -> int { #ifdef FMT_BUILTIN_CLZ if (!is_constant_evaluated() && !FMT_OPTIMIZE_SIZE) return do_count_digits(n); #endif return count_digits_fallback(n); } template <typename Int> constexpr auto digits10() noexcept -> int { return std::numeric_limits<Int>::digits10; } template <> constexpr auto digits10<int128_opt>() noexcept -> int { return 38; } template <> constexpr auto digits10<uint128_t>() noexcept -> int { return 38; } template <typename Char> struct thousands_sep_result { std::string grouping; Char thousands_sep; }; template <typename Char> FMT_API auto thousands_sep_impl(locale_ref loc) -> thousands_sep_result<Char>; template <typename Char> inline auto thousands_sep(locale_ref loc) -> thousands_sep_result<Char> { auto result = thousands_sep_impl<char>(loc); return {result.grouping, Char(result.thousands_sep)}; } template <> inline auto thousands_sep(locale_ref loc) -> thousands_sep_result<wchar_t> { return thousands_sep_impl<wchar_t>(loc); } template <typename Char> FMT_API auto decimal_point_impl(locale_ref loc) -> Char; template <typename Char> inline auto decimal_point(locale_ref loc) -> Char { return Char(decimal_point_impl<char>(loc)); } template <> inline auto decimal_point(locale_ref loc) -> wchar_t { return decimal_point_impl<wchar_t>(loc); } #ifndef FMT_HEADER_ONLY FMT_BEGIN_EXPORT extern template FMT_API auto thousands_sep_impl<char>(locale_ref) -> thousands_sep_result<char>; extern template FMT_API auto thousands_sep_impl<wchar_t>(locale_ref) -> thousands_sep_result<wchar_t>; extern template FMT_API auto decimal_point_impl(locale_ref) -> char; extern template FMT_API auto decimal_point_impl(locale_ref) -> wchar_t; FMT_END_EXPORT #endif // FMT_HEADER_ONLY // Compares two characters for equality. template <typename Char> auto equal2(const Char* lhs, const char* rhs) -> bool { return lhs[0] == Char(rhs[0]) && lhs[1] == Char(rhs[1]); } inline auto equal2(const char* lhs, const char* rhs) -> bool { return memcmp(lhs, rhs, 2) == 0; } // Writes a two-digit value to out. template <typename Char> FMT_CONSTEXPR20 FMT_INLINE void write2digits(Char* out, size_t value) { if (!is_constant_evaluated() && std::is_same<Char, char>::value && !FMT_OPTIMIZE_SIZE) { memcpy(out, digits2(value), 2); return; } *out++ = static_cast<Char>('0' + value / 10); *out = static_cast<Char>('0' + value % 10); } // Formats a decimal unsigned integer value writing to out pointing to a buffer // of specified size. The caller must ensure that the buffer is large enough. template <typename Char, typename UInt> FMT_CONSTEXPR20 auto do_format_decimal(Char* out, UInt value, int size) -> Char* { FMT_ASSERT(size >= count_digits(value), "invalid digit count"); unsigned n = to_unsigned(size); while (value >= 100) { // Integer division is slow so do it for a group of two digits instead // of for every digit. The idea comes from the talk by Alexandrescu // "Three Optimization Tips for C++". See speed-test for a comparison. n -= 2; write2digits(out + n, static_cast<unsigned>(value % 100)); value /= 100; } if (value >= 10) { n -= 2; write2digits(out + n, static_cast<unsigned>(value)); } else { out[--n] = static_cast<Char>('0' + value); } return out + n; } template <typename Char, typename UInt> FMT_CONSTEXPR FMT_INLINE auto format_decimal(Char* out, UInt value, int num_digits) -> Char* { do_format_decimal(out, value, num_digits); return out + num_digits; } template <typename Char, typename UInt, typename OutputIt, FMT_ENABLE_IF(!std::is_pointer<remove_cvref_t<OutputIt>>::value)> FMT_CONSTEXPR auto format_decimal(OutputIt out, UInt value, int num_digits) -> OutputIt { if (auto ptr = to_pointer<Char>(out, to_unsigned(num_digits))) { do_format_decimal(ptr, value, num_digits); return out; } // Buffer is large enough to hold all digits (digits10 + 1). char buffer[digits10<UInt>() + 1]; if (is_constant_evaluated()) fill_n(buffer, sizeof(buffer), '\0'); do_format_decimal(buffer, value, num_digits); return copy_noinline<Char>(buffer, buffer + num_digits, out); } template <typename Char, typename UInt> FMT_CONSTEXPR auto do_format_base2e(int base_bits, Char* out, UInt value, int size, bool upper = false) -> Char* { out += size; do { const char* digits = upper ? "0123456789ABCDEF" : "0123456789abcdef"; unsigned digit = static_cast<unsigned>(value & ((1 << base_bits) - 1)); *--out = static_cast<Char>(base_bits < 4 ? static_cast<char>('0' + digit) : digits[digit]); } while ((value >>= base_bits) != 0); return out; } // Formats an unsigned integer in the power of two base (binary, octal, hex). template <typename Char, typename UInt> FMT_CONSTEXPR auto format_base2e(int base_bits, Char* out, UInt value, int num_digits, bool upper = false) -> Char* { do_format_base2e(base_bits, out, value, num_digits, upper); return out + num_digits; } template <typename Char, typename OutputIt, typename UInt, FMT_ENABLE_IF(is_back_insert_iterator<OutputIt>::value)> FMT_CONSTEXPR inline auto format_base2e(int base_bits, OutputIt out, UInt value, int num_digits, bool upper = false) -> OutputIt { if (auto ptr = to_pointer<Char>(out, to_unsigned(num_digits))) { format_base2e(base_bits, ptr, value, num_digits, upper); return out; } // Make buffer large enough for any base. char buffer[num_bits<UInt>()]; if (is_constant_evaluated()) fill_n(buffer, sizeof(buffer), '\0'); format_base2e(base_bits, buffer, value, num_digits, upper); return detail::copy_noinline<Char>(buffer, buffer + num_digits, out); } // A converter from UTF-8 to UTF-16. class utf8_to_utf16 { private: basic_memory_buffer<wchar_t> buffer_; public: FMT_API explicit utf8_to_utf16(string_view s); inline operator basic_string_view<wchar_t>() const { return {&buffer_[0], size()}; } inline auto size() const -> size_t { return buffer_.size() - 1; } inline auto c_str() const -> const wchar_t* { return &buffer_[0]; } inline auto str() const -> std::wstring { return {&buffer_[0], size()}; } }; enum class to_utf8_error_policy { abort, replace }; // A converter from UTF-16/UTF-32 (host endian) to UTF-8. template <typename WChar, typename Buffer = memory_buffer> class to_utf8 { private: Buffer buffer_; public: to_utf8() {} explicit to_utf8(basic_string_view<WChar> s, to_utf8_error_policy policy = to_utf8_error_policy::abort) { static_assert(sizeof(WChar) == 2 || sizeof(WChar) == 4, "Expect utf16 or utf32"); if (!convert(s, policy)) FMT_THROW(std::runtime_error(sizeof(WChar) == 2 ? "invalid utf16" : "invalid utf32")); } operator string_view() const { return string_view(&buffer_[0], size()); } auto size() const -> size_t { return buffer_.size() - 1; } auto c_str() const -> const char* { return &buffer_[0]; } auto str() const -> std::string { return std::string(&buffer_[0], size()); } // Performs conversion returning a bool instead of throwing exception on // conversion error. This method may still throw in case of memory allocation // error. auto convert(basic_string_view<WChar> s, to_utf8_error_policy policy = to_utf8_error_policy::abort) -> bool { if (!convert(buffer_, s, policy)) return false; buffer_.push_back(0); return true; } static auto convert(Buffer& buf, basic_string_view<WChar> s, to_utf8_error_policy policy = to_utf8_error_policy::abort) -> bool { for (auto p = s.begin(); p != s.end(); ++p) { uint32_t c = static_cast<uint32_t>(*p); if (sizeof(WChar) == 2 && c >= 0xd800 && c <= 0xdfff) { // Handle a surrogate pair. ++p; if (p == s.end() || (c & 0xfc00) != 0xd800 || (*p & 0xfc00) != 0xdc00) { if (policy == to_utf8_error_policy::abort) return false; buf.append(string_view("\xEF\xBF\xBD")); --p; continue; } else { c = (c << 10) + static_cast<uint32_t>(*p) - 0x35fdc00; } } if (c < 0x80) { buf.push_back(static_cast<char>(c)); } else if (c < 0x800) { buf.push_back(static_cast<char>(0xc0 | (c >> 6))); buf.push_back(static_cast<char>(0x80 | (c & 0x3f))); } else if ((c >= 0x800 && c <= 0xd7ff) || (c >= 0xe000 && c <= 0xffff)) { buf.push_back(static_cast<char>(0xe0 | (c >> 12))); buf.push_back(static_cast<char>(0x80 | ((c & 0xfff) >> 6))); buf.push_back(static_cast<char>(0x80 | (c & 0x3f))); } else if (c >= 0x10000 && c <= 0x10ffff) { buf.push_back(static_cast<char>(0xf0 | (c >> 18))); buf.push_back(static_cast<char>(0x80 | ((c & 0x3ffff) >> 12))); buf.push_back(static_cast<char>(0x80 | ((c & 0xfff) >> 6))); buf.push_back(static_cast<char>(0x80 | (c & 0x3f))); } else { return false; } } return true; } }; // Computes 128-bit result of multiplication of two 64-bit unsigned integers. inline auto umul128(uint64_t x, uint64_t y) noexcept -> uint128_fallback { #if FMT_USE_INT128 auto p = static_cast<uint128_opt>(x) * static_cast<uint128_opt>(y); return {static_cast<uint64_t>(p >> 64), static_cast<uint64_t>(p)}; #elif defined(_MSC_VER) && defined(_M_X64) auto hi = uint64_t(); auto lo = _umul128(x, y, &hi); return {hi, lo}; #else const uint64_t mask = static_cast<uint64_t>(max_value<uint32_t>()); uint64_t a = x >> 32; uint64_t b = x & mask; uint64_t c = y >> 32; uint64_t d = y & mask; uint64_t ac = a * c; uint64_t bc = b * c; uint64_t ad = a * d; uint64_t bd = b * d; uint64_t intermediate = (bd >> 32) + (ad & mask) + (bc & mask); return {ac + (intermediate >> 32) + (ad >> 32) + (bc >> 32), (intermediate << 32) + (bd & mask)}; #endif } namespace dragonbox { // Computes floor(log10(pow(2, e))) for e in [-2620, 2620] using the method from // https://fmt.dev/papers/Dragonbox.pdf#page=28, section 6.1. inline auto floor_log10_pow2(int e) noexcept -> int { FMT_ASSERT(e <= 2620 && e >= -2620, "too large exponent"); static_assert((-1 >> 1) == -1, "right shift is not arithmetic"); return (e * 315653) >> 20; } inline auto floor_log2_pow10(int e) noexcept -> int { FMT_ASSERT(e <= 1233 && e >= -1233, "too large exponent"); return (e * 1741647) >> 19; } // Computes upper 64 bits of multiplication of two 64-bit unsigned integers. inline auto umul128_upper64(uint64_t x, uint64_t y) noexcept -> uint64_t { #if FMT_USE_INT128 auto p = static_cast<uint128_opt>(x) * static_cast<uint128_opt>(y); return static_cast<uint64_t>(p >> 64); #elif defined(_MSC_VER) && defined(_M_X64) return __umulh(x, y); #else return umul128(x, y).high(); #endif } // Computes upper 128 bits of multiplication of a 64-bit unsigned integer and a // 128-bit unsigned integer. inline auto umul192_upper128(uint64_t x, uint128_fallback y) noexcept -> uint128_fallback { uint128_fallback r = umul128(x, y.high()); r += umul128_upper64(x, y.low()); return r; } FMT_API auto get_cached_power(int k) noexcept -> uint128_fallback; // Type-specific information that Dragonbox uses. template <typename T, typename Enable = void> struct float_info; template <> struct float_info<float> { using carrier_uint = uint32_t; static const int exponent_bits = 8; static const int kappa = 1; static const int big_divisor = 100; static const int small_divisor = 10; static const int min_k = -31; static const int max_k = 46; static const int shorter_interval_tie_lower_threshold = -35; static const int shorter_interval_tie_upper_threshold = -35; }; template <> struct float_info<double> { using carrier_uint = uint64_t; static const int exponent_bits = 11; static const int kappa = 2; static const int big_divisor = 1000; static const int small_divisor = 100; static const int min_k = -292; static const int max_k = 341; static const int shorter_interval_tie_lower_threshold = -77; static const int shorter_interval_tie_upper_threshold = -77; }; // An 80- or 128-bit floating point number. template <typename T> struct float_info<T, enable_if_t<std::numeric_limits<T>::digits == 64 || std::numeric_limits<T>::digits == 113 || is_float128<T>::value>> { using carrier_uint = detail::uint128_t; static const int exponent_bits = 15; }; // A double-double floating point number. template <typename T> struct float_info<T, enable_if_t<is_double_double<T>::value>> { using carrier_uint = detail::uint128_t; }; template <typename T> struct decimal_fp { using significand_type = typename float_info<T>::carrier_uint; significand_type significand; int exponent; }; template <typename T> FMT_API auto to_decimal(T x) noexcept -> decimal_fp<T>; } // namespace dragonbox // Returns true iff Float has the implicit bit which is not stored. template <typename Float> constexpr auto has_implicit_bit() -> bool { // An 80-bit FP number has a 64-bit significand an no implicit bit. return std::numeric_limits<Float>::digits != 64; } // Returns the number of significand bits stored in Float. The implicit bit is // not counted since it is not stored. template <typename Float> constexpr auto num_significand_bits() -> int { // std::numeric_limits may not support __float128. return is_float128<Float>() ? 112 : (std::numeric_limits<Float>::digits - (has_implicit_bit<Float>() ? 1 : 0)); } template <typename Float> constexpr auto exponent_mask() -> typename dragonbox::float_info<Float>::carrier_uint { using float_uint = typename dragonbox::float_info<Float>::carrier_uint; return ((float_uint(1) << dragonbox::float_info<Float>::exponent_bits) - 1) << num_significand_bits<Float>(); } template <typename Float> constexpr auto exponent_bias() -> int { // std::numeric_limits may not support __float128. return is_float128<Float>() ? 16383 : std::numeric_limits<Float>::max_exponent - 1; } // Writes the exponent exp in the form "[+-]d{2,3}" to buffer. template <typename Char, typename OutputIt> FMT_CONSTEXPR auto write_exponent(int exp, OutputIt out) -> OutputIt { FMT_ASSERT(-10000 < exp && exp < 10000, "exponent out of range"); if (exp < 0) { *out++ = static_cast<Char>('-'); exp = -exp; } else { *out++ = static_cast<Char>('+'); } auto uexp = static_cast<uint32_t>(exp); if (is_constant_evaluated()) { if (uexp < 10) *out++ = '0'; return format_decimal<Char>(out, uexp, count_digits(uexp)); } if (uexp >= 100u) { const char* top = digits2(uexp / 100); if (uexp >= 1000u) *out++ = static_cast<Char>(top[0]); *out++ = static_cast<Char>(top[1]); uexp %= 100; } const char* d = digits2(uexp); *out++ = static_cast<Char>(d[0]); *out++ = static_cast<Char>(d[1]); return out; } // A floating-point number f * pow(2, e) where F is an unsigned type. template <typename F> struct basic_fp { F f; int e; static constexpr const int num_significand_bits = static_cast<int>(sizeof(F) * num_bits<unsigned char>()); constexpr basic_fp() : f(0), e(0) {} constexpr basic_fp(uint64_t f_val, int e_val) : f(f_val), e(e_val) {} // Constructs fp from an IEEE754 floating-point number. template <typename Float> FMT_CONSTEXPR basic_fp(Float n) { assign(n); } // Assigns n to this and return true iff predecessor is closer than successor. template <typename Float, FMT_ENABLE_IF(!is_double_double<Float>::value)> FMT_CONSTEXPR auto assign(Float n) -> bool { static_assert(std::numeric_limits<Float>::digits <= 113, "unsupported FP"); // Assume Float is in the format [sign][exponent][significand]. using carrier_uint = typename dragonbox::float_info<Float>::carrier_uint; const auto num_float_significand_bits = detail::num_significand_bits<Float>(); const auto implicit_bit = carrier_uint(1) << num_float_significand_bits; const auto significand_mask = implicit_bit - 1; auto u = bit_cast<carrier_uint>(n); f = static_cast<F>(u & significand_mask); auto biased_e = static_cast<int>((u & exponent_mask<Float>()) >> num_float_significand_bits); // The predecessor is closer if n is a normalized power of 2 (f == 0) // other than the smallest normalized number (biased_e > 1). auto is_predecessor_closer = f == 0 && biased_e > 1; if (biased_e == 0) biased_e = 1; // Subnormals use biased exponent 1 (min exponent). else if (has_implicit_bit<Float>()) f += static_cast<F>(implicit_bit); e = biased_e - exponent_bias<Float>() - num_float_significand_bits; if (!has_implicit_bit<Float>()) ++e; return is_predecessor_closer; } template <typename Float, FMT_ENABLE_IF(is_double_double<Float>::value)> FMT_CONSTEXPR auto assign(Float n) -> bool { static_assert(std::numeric_limits<double>::is_iec559, "unsupported FP"); return assign(static_cast<double>(n)); } }; using fp = basic_fp<unsigned long long>; // Normalizes the value converted from double and multiplied by (1 << SHIFT). template <int SHIFT = 0, typename F> FMT_CONSTEXPR auto normalize(basic_fp<F> value) -> basic_fp<F> { // Handle subnormals. const auto implicit_bit = F(1) << num_significand_bits<double>(); const auto shifted_implicit_bit = implicit_bit << SHIFT; while ((value.f & shifted_implicit_bit) == 0) { value.f <<= 1; --value.e; } // Subtract 1 to account for hidden bit. const auto offset = basic_fp<F>::num_significand_bits - num_significand_bits<double>() - SHIFT - 1; value.f <<= offset; value.e -= offset; return value; } // Computes lhs * rhs / pow(2, 64) rounded to nearest with half-up tie breaking. FMT_CONSTEXPR inline auto multiply(uint64_t lhs, uint64_t rhs) -> uint64_t { #if FMT_USE_INT128 auto product = static_cast<__uint128_t>(lhs) * rhs; auto f = static_cast<uint64_t>(product >> 64); return (static_cast<uint64_t>(product) & (1ULL << 63)) != 0 ? f + 1 : f; #else // Multiply 32-bit parts of significands. uint64_t mask = (1ULL << 32) - 1; uint64_t a = lhs >> 32, b = lhs & mask; uint64_t c = rhs >> 32, d = rhs & mask; uint64_t ac = a * c, bc = b * c, ad = a * d, bd = b * d; // Compute mid 64-bit of result and round. uint64_t mid = (bd >> 32) + (ad & mask) + (bc & mask) + (1U << 31); return ac + (ad >> 32) + (bc >> 32) + (mid >> 32); #endif } FMT_CONSTEXPR inline auto operator*(fp x, fp y) -> fp { return {multiply(x.f, y.f), x.e + y.e + 64}; } template <typename T, bool doublish = num_bits<T>() == num_bits<double>()> using convert_float_result = conditional_t<std::is_same<T, float>::value || doublish, double, T>; template <typename T> constexpr auto convert_float(T value) -> convert_float_result<T> { return static_cast<convert_float_result<T>>(value); } template <typename Char, typename OutputIt> FMT_NOINLINE FMT_CONSTEXPR auto fill(OutputIt it, size_t n, const basic_specs& specs) -> OutputIt { auto fill_size = specs.fill_size(); if (fill_size == 1) return detail::fill_n(it, n, specs.fill_unit<Char>()); if (const Char* data = specs.fill<Char>()) { for (size_t i = 0; i < n; ++i) it = copy<Char>(data, data + fill_size, it); } return it; } // Writes the output of f, padded according to format specifications in specs. // size: output size in code units. // width: output display width in (terminal) column positions. template <typename Char, align default_align = align::left, typename OutputIt, typename F> FMT_CONSTEXPR auto write_padded(OutputIt out, const format_specs& specs, size_t size, size_t width, F&& f) -> OutputIt { static_assert(default_align == align::left || default_align == align::right, ""); unsigned spec_width = to_unsigned(specs.width); size_t padding = spec_width > width ? spec_width - width : 0; // Shifts are encoded as string literals because static constexpr is not // supported in constexpr functions. auto* shifts = default_align == align::left ? "\x1f\x1f\x00\x01" : "\x00\x1f\x00\x01"; size_t left_padding = padding >> shifts[static_cast<int>(specs.align())]; size_t right_padding = padding - left_padding; auto it = reserve(out, size + padding * specs.fill_size()); if (left_padding != 0) it = fill<Char>(it, left_padding, specs); it = f(it); if (right_padding != 0) it = fill<Char>(it, right_padding, specs); return base_iterator(out, it); } template <typename Char, align default_align = align::left, typename OutputIt, typename F> constexpr auto write_padded(OutputIt out, const format_specs& specs, size_t size, F&& f) -> OutputIt { return write_padded<Char, default_align>(out, specs, size, size, f); } template <typename Char, align default_align = align::left, typename OutputIt> FMT_CONSTEXPR auto write_bytes(OutputIt out, string_view bytes, const format_specs& specs = {}) -> OutputIt { return write_padded<Char, default_align>( out, specs, bytes.size(), [bytes](reserve_iterator<OutputIt> it) { const char* data = bytes.data(); return copy<Char>(data, data + bytes.size(), it); }); } template <typename Char, typename OutputIt, typename UIntPtr> auto write_ptr(OutputIt out, UIntPtr value, const format_specs* specs) -> OutputIt { int num_digits = count_digits<4>(value); auto size = to_unsigned(num_digits) + size_t(2); auto write = [=](reserve_iterator<OutputIt> it) { *it++ = static_cast<Char>('0'); *it++ = static_cast<Char>('x'); return format_base2e<Char>(4, it, value, num_digits); }; return specs ? write_padded<Char, align::right>(out, *specs, size, write) : base_iterator(out, write(reserve(out, size))); } // Returns true iff the code point cp is printable. FMT_API auto is_printable(uint32_t cp) -> bool; inline auto needs_escape(uint32_t cp) -> bool { if (cp < 0x20 || cp == 0x7f || cp == '"' || cp == '\\') return true; if (const_check(FMT_OPTIMIZE_SIZE > 1)) return false; return !is_printable(cp); } template <typename Char> struct find_escape_result { const Char* begin; const Char* end; uint32_t cp; }; template <typename Char> auto find_escape(const Char* begin, const Char* end) -> find_escape_result<Char> { for (; begin != end; ++begin) { uint32_t cp = static_cast<unsigned_char<Char>>(*begin); if (const_check(sizeof(Char) == 1) && cp >= 0x80) continue; if (needs_escape(cp)) return {begin, begin + 1, cp}; } return {begin, nullptr, 0}; } inline auto find_escape(const char* begin, const char* end) -> find_escape_result<char> { if (const_check(!use_utf8)) return find_escape<char>(begin, end); auto result = find_escape_result<char>{end, nullptr, 0}; for_each_codepoint(string_view(begin, to_unsigned(end - begin)), [&](uint32_t cp, string_view sv) { if (needs_escape(cp)) { result = {sv.begin(), sv.end(), cp}; return false; } return true; }); return result; } template <size_t width, typename Char, typename OutputIt> auto write_codepoint(OutputIt out, char prefix, uint32_t cp) -> OutputIt { *out++ = static_cast<Char>('\\'); *out++ = static_cast<Char>(prefix); Char buf[width]; fill_n(buf, width, static_cast<Char>('0')); format_base2e(4, buf, cp, width); return copy<Char>(buf, buf + width, out); } template <typename OutputIt, typename Char> auto write_escaped_cp(OutputIt out, const find_escape_result<Char>& escape) -> OutputIt { auto c = static_cast<Char>(escape.cp); switch (escape.cp) { case '\n': *out++ = static_cast<Char>('\\'); c = static_cast<Char>('n'); break; case '\r': *out++ = static_cast<Char>('\\'); c = static_cast<Char>('r'); break; case '\t': *out++ = static_cast<Char>('\\'); c = static_cast<Char>('t'); break; case '"': FMT_FALLTHROUGH; case '\'': FMT_FALLTHROUGH; case '\\': *out++ = static_cast<Char>('\\'); break; default: if (escape.cp < 0x100) return write_codepoint<2, Char>(out, 'x', escape.cp); if (escape.cp < 0x10000) return write_codepoint<4, Char>(out, 'u', escape.cp); if (escape.cp < 0x110000) return write_codepoint<8, Char>(out, 'U', escape.cp); for (Char escape_char : basic_string_view<Char>( escape.begin, to_unsigned(escape.end - escape.begin))) { out = write_codepoint<2, Char>(out, 'x', static_cast<uint32_t>(escape_char) & 0xFF); } return out; } *out++ = c; return out; } template <typename Char, typename OutputIt> auto write_escaped_string(OutputIt out, basic_string_view<Char> str) -> OutputIt { *out++ = static_cast<Char>('"'); auto begin = str.begin(), end = str.end(); do { auto escape = find_escape(begin, end); out = copy<Char>(begin, escape.begin, out); begin = escape.end; if (!begin) break; out = write_escaped_cp<OutputIt, Char>(out, escape); } while (begin != end); *out++ = static_cast<Char>('"'); return out; } template <typename Char, typename OutputIt> auto write_escaped_char(OutputIt out, Char v) -> OutputIt { Char v_array[1] = {v}; *out++ = static_cast<Char>('\''); if ((needs_escape(static_cast<uint32_t>(v)) && v != static_cast<Char>('"')) || v == static_cast<Char>('\'')) { out = write_escaped_cp(out, find_escape_result<Char>{v_array, v_array + 1, static_cast<uint32_t>(v)}); } else { *out++ = v; } *out++ = static_cast<Char>('\''); return out; } template <typename Char, typename OutputIt> FMT_CONSTEXPR auto write_char(OutputIt out, Char value, const format_specs& specs) -> OutputIt { bool is_debug = specs.type() == presentation_type::debug; return write_padded<Char>(out, specs, 1, [=](reserve_iterator<OutputIt> it) { if (is_debug) return write_escaped_char(it, value); *it++ = value; return it; }); } template <typename Char, typename OutputIt> FMT_CONSTEXPR auto write(OutputIt out, Char value, const format_specs& specs, locale_ref loc = {}) -> OutputIt { // char is formatted as unsigned char for consistency across platforms. using unsigned_type = conditional_t<std::is_same<Char, char>::value, unsigned char, unsigned>; return check_char_specs(specs) ? write_char<Char>(out, value, specs) : write<Char>(out, static_cast<unsigned_type>(value), specs, loc); } template <typename Char> class digit_grouping { private: std::string grouping_; std::basic_string<Char> thousands_sep_; struct next_state { std::string::const_iterator group; int pos; }; auto initial_state() const -> next_state { return {grouping_.begin(), 0}; } // Returns the next digit group separator position. auto next(next_state& state) const -> int { if (thousands_sep_.empty()) return max_value<int>(); if (state.group == grouping_.end()) return state.pos += grouping_.back(); if (*state.group <= 0 || *state.group == max_value<char>()) return max_value<int>(); state.pos += *state.group++; return state.pos; } public: template <typename Locale, FMT_ENABLE_IF(std::is_same<Locale, locale_ref>::value)> explicit digit_grouping(Locale loc, bool localized = true) { if (!localized) return; auto sep = thousands_sep<Char>(loc); grouping_ = sep.grouping; if (sep.thousands_sep) thousands_sep_.assign(1, sep.thousands_sep); } digit_grouping(std::string grouping, std::basic_string<Char> sep) : grouping_(std::move(grouping)), thousands_sep_(std::move(sep)) {} auto has_separator() const -> bool { return !thousands_sep_.empty(); } auto count_separators(int num_digits) const -> int { int count = 0; auto state = initial_state(); while (num_digits > next(state)) ++count; return count; } // Applies grouping to digits and write the output to out. template <typename Out, typename C> auto apply(Out out, basic_string_view<C> digits) const -> Out { auto num_digits = static_cast<int>(digits.size()); auto separators = basic_memory_buffer<int>(); separators.push_back(0); auto state = initial_state(); while (int i = next(state)) { if (i >= num_digits) break; separators.push_back(i); } for (int i = 0, sep_index = static_cast<int>(separators.size() - 1); i < num_digits; ++i) { if (num_digits - i == separators[sep_index]) { out = copy<Char>(thousands_sep_.data(), thousands_sep_.data() + thousands_sep_.size(), out); --sep_index; } *out++ = static_cast<Char>(digits[to_unsigned(i)]); } return out; } }; FMT_CONSTEXPR inline void prefix_append(unsigned& prefix, unsigned value) { prefix |= prefix != 0 ? value << 8 : value; prefix += (1u + (value > 0xff ? 1 : 0)) << 24; } // Writes a decimal integer with digit grouping. template <typename OutputIt, typename UInt, typename Char> auto write_int(OutputIt out, UInt value, unsigned prefix, const format_specs& specs, const digit_grouping<Char>& grouping) -> OutputIt { static_assert(std::is_same<uint64_or_128_t<UInt>, UInt>::value, ""); int num_digits = 0; auto buffer = memory_buffer(); switch (specs.type()) { default: FMT_ASSERT(false, ""); FMT_FALLTHROUGH; case presentation_type::none: case presentation_type::dec: num_digits = count_digits(value); format_decimal<char>(appender(buffer), value, num_digits); break; case presentation_type::hex: if (specs.alt()) prefix_append(prefix, unsigned(specs.upper() ? 'X' : 'x') << 8 | '0'); num_digits = count_digits<4>(value); format_base2e<char>(4, appender(buffer), value, num_digits, specs.upper()); break; case presentation_type::oct: num_digits = count_digits<3>(value); // Octal prefix '0' is counted as a digit, so only add it if precision // is not greater than the number of digits. if (specs.alt() && specs.precision <= num_digits && value != 0) prefix_append(prefix, '0'); format_base2e<char>(3, appender(buffer), value, num_digits); break; case presentation_type::bin: if (specs.alt()) prefix_append(prefix, unsigned(specs.upper() ? 'B' : 'b') << 8 | '0'); num_digits = count_digits<1>(value); format_base2e<char>(1, appender(buffer), value, num_digits); break; case presentation_type::chr: return write_char<Char>(out, static_cast<Char>(value), specs); } unsigned size = (prefix != 0 ? prefix >> 24 : 0) + to_unsigned(num_digits) + to_unsigned(grouping.count_separators(num_digits)); return write_padded<Char, align::right>( out, specs, size, size, [&](reserve_iterator<OutputIt> it) { for (unsigned p = prefix & 0xffffff; p != 0; p >>= 8) *it++ = static_cast<Char>(p & 0xff); return grouping.apply(it, string_view(buffer.data(), buffer.size())); }); } #if FMT_USE_LOCALE // Writes a localized value. FMT_API auto write_loc(appender out, loc_value value, const format_specs& specs, locale_ref loc) -> bool; #endif template <typename OutputIt> inline auto write_loc(OutputIt, const loc_value&, const format_specs&, locale_ref) -> bool { return false; } template <typename UInt> struct write_int_arg { UInt abs_value; unsigned prefix; }; template <typename T> FMT_CONSTEXPR auto make_write_int_arg(T value, sign s) -> write_int_arg<uint32_or_64_or_128_t<T>> { auto prefix = 0u; auto abs_value = static_cast<uint32_or_64_or_128_t<T>>(value); if (is_negative(value)) { prefix = 0x01000000 | '-'; abs_value = 0 - abs_value; } else { constexpr const unsigned prefixes[4] = {0, 0, 0x1000000u | '+', 0x1000000u | ' '}; prefix = prefixes[static_cast<int>(s)]; } return {abs_value, prefix}; } template <typename Char = char> struct loc_writer { basic_appender<Char> out; const format_specs& specs; std::basic_string<Char> sep; std::string grouping; std::basic_string<Char> decimal_point; template <typename T, FMT_ENABLE_IF(is_integer<T>::value)> auto operator()(T value) -> bool { auto arg = make_write_int_arg(value, specs.sign()); write_int(out, static_cast<uint64_or_128_t<T>>(arg.abs_value), arg.prefix, specs, digit_grouping<Char>(grouping, sep)); return true; } template <typename T, FMT_ENABLE_IF(!is_integer<T>::value)> auto operator()(T) -> bool { return false; } }; // Size and padding computation separate from write_int to avoid template bloat. struct size_padding { unsigned size; unsigned padding; FMT_CONSTEXPR size_padding(int num_digits, unsigned prefix, const format_specs& specs) : size((prefix >> 24) + to_unsigned(num_digits)), padding(0) { if (specs.align() == align::numeric) { auto width = to_unsigned(specs.width); if (width > size) { padding = width - size; size = width; } } else if (specs.precision > num_digits) { size = (prefix >> 24) + to_unsigned(specs.precision); padding = to_unsigned(specs.precision - num_digits); } } }; template <typename Char, typename OutputIt, typename T> FMT_CONSTEXPR FMT_INLINE auto write_int(OutputIt out, write_int_arg<T> arg, const format_specs& specs) -> OutputIt { static_assert(std::is_same<T, uint32_or_64_or_128_t<T>>::value, ""); constexpr int buffer_size = num_bits<T>(); char buffer[buffer_size]; if (is_constant_evaluated()) fill_n(buffer, buffer_size, '\0'); const char* begin = nullptr; const char* end = buffer + buffer_size; auto abs_value = arg.abs_value; auto prefix = arg.prefix; switch (specs.type()) { default: FMT_ASSERT(false, ""); FMT_FALLTHROUGH; case presentation_type::none: case presentation_type::dec: begin = do_format_decimal(buffer, abs_value, buffer_size); break; case presentation_type::hex: begin = do_format_base2e(4, buffer, abs_value, buffer_size, specs.upper()); if (specs.alt()) prefix_append(prefix, unsigned(specs.upper() ? 'X' : 'x') << 8 | '0'); break; case presentation_type::oct: { begin = do_format_base2e(3, buffer, abs_value, buffer_size); // Octal prefix '0' is counted as a digit, so only add it if precision // is not greater than the number of digits. auto num_digits = end - begin; if (specs.alt() && specs.precision <= num_digits && abs_value != 0) prefix_append(prefix, '0'); break; } case presentation_type::bin: begin = do_format_base2e(1, buffer, abs_value, buffer_size); if (specs.alt()) prefix_append(prefix, unsigned(specs.upper() ? 'B' : 'b') << 8 | '0'); break; case presentation_type::chr: return write_char<Char>(out, static_cast<Char>(abs_value), specs); } // Write an integer in the format // <left-padding><prefix><numeric-padding><digits><right-padding> // prefix contains chars in three lower bytes and the size in the fourth byte. int num_digits = static_cast<int>(end - begin); // Slightly faster check for specs.width == 0 && specs.precision == -1. if ((specs.width | (specs.precision + 1)) == 0) { auto it = reserve(out, to_unsigned(num_digits) + (prefix >> 24)); for (unsigned p = prefix & 0xffffff; p != 0; p >>= 8) *it++ = static_cast<Char>(p & 0xff); return base_iterator(out, copy<Char>(begin, end, it)); } auto sp = size_padding(num_digits, prefix, specs); unsigned padding = sp.padding; return write_padded<Char, align::right>( out, specs, sp.size, [=](reserve_iterator<OutputIt> it) { for (unsigned p = prefix & 0xffffff; p != 0; p >>= 8) *it++ = static_cast<Char>(p & 0xff); it = detail::fill_n(it, padding, static_cast<Char>('0')); return copy<Char>(begin, end, it); }); } template <typename Char, typename OutputIt, typename T> FMT_CONSTEXPR FMT_NOINLINE auto write_int_noinline(OutputIt out, write_int_arg<T> arg, const format_specs& specs) -> OutputIt { return write_int<Char>(out, arg, specs); } template <typename Char, typename T, FMT_ENABLE_IF(is_integral<T>::value && !std::is_same<T, bool>::value && !std::is_same<T, Char>::value)> FMT_CONSTEXPR FMT_INLINE auto write(basic_appender<Char> out, T value, const format_specs& specs, locale_ref loc) -> basic_appender<Char> { if (specs.localized() && write_loc(out, value, specs, loc)) return out; return write_int_noinline<Char>(out, make_write_int_arg(value, specs.sign()), specs); } // An inlined version of write used in format string compilation. template <typename Char, typename OutputIt, typename T, FMT_ENABLE_IF(is_integral<T>::value && !std::is_same<T, bool>::value && !std::is_same<T, Char>::value && !std::is_same<OutputIt, basic_appender<Char>>::value)> FMT_CONSTEXPR FMT_INLINE auto write(OutputIt out, T value, const format_specs& specs, locale_ref loc) -> OutputIt { if (specs.localized() && write_loc(out, value, specs, loc)) return out; return write_int<Char>(out, make_write_int_arg(value, specs.sign()), specs); } template <typename Char, typename OutputIt> FMT_CONSTEXPR auto write(OutputIt out, basic_string_view<Char> s, const format_specs& specs) -> OutputIt { auto data = s.data(); auto size = s.size(); if (specs.precision >= 0 && to_unsigned(specs.precision) < size) size = code_point_index(s, to_unsigned(specs.precision)); bool is_debug = specs.type() == presentation_type::debug; if (is_debug) { auto buf = counting_buffer<Char>(); write_escaped_string(basic_appender<Char>(buf), s); size = buf.count(); } size_t width = 0; if (specs.width != 0) { width = is_debug ? size : compute_width(basic_string_view<Char>(data, size)); } return write_padded<Char>( out, specs, size, width, [=](reserve_iterator<OutputIt> it) { return is_debug ? write_escaped_string(it, s) : copy<Char>(data, data + size, it); }); } template <typename Char, typename OutputIt> FMT_CONSTEXPR auto write(OutputIt out, basic_string_view<Char> s, const format_specs& specs, locale_ref) -> OutputIt { return write<Char>(out, s, specs); } template <typename Char, typename OutputIt> FMT_CONSTEXPR auto write(OutputIt out, const Char* s, const format_specs& specs, locale_ref) -> OutputIt { if (specs.type() == presentation_type::pointer) return write_ptr<Char>(out, bit_cast<uintptr_t>(s), &specs); if (!s) report_error("string pointer is null"); return write<Char>(out, basic_string_view<Char>(s), specs, {}); } template <typename Char, typename OutputIt, typename T, FMT_ENABLE_IF(is_integral<T>::value && !std::is_same<T, bool>::value && !std::is_same<T, Char>::value)> FMT_CONSTEXPR auto write(OutputIt out, T value) -> OutputIt { auto abs_value = static_cast<uint32_or_64_or_128_t<T>>(value); bool negative = is_negative(value); // Don't do -abs_value since it trips unsigned-integer-overflow sanitizer. if (negative) abs_value = ~abs_value + 1; int num_digits = count_digits(abs_value); auto size = (negative ? 1 : 0) + static_cast<size_t>(num_digits); if (auto ptr = to_pointer<Char>(out, size)) { if (negative) *ptr++ = static_cast<Char>('-'); format_decimal<Char>(ptr, abs_value, num_digits); return out; } if (negative) *out++ = static_cast<Char>('-'); return format_decimal<Char>(out, abs_value, num_digits); } template <typename Char> FMT_CONSTEXPR auto parse_align(const Char* begin, const Char* end, format_specs& specs) -> const Char* { FMT_ASSERT(begin != end, ""); auto alignment = align::none; auto p = begin + code_point_length(begin); if (end - p <= 0) p = begin; for (;;) { switch (to_ascii(*p)) { case '<': alignment = align::left; break; case '>': alignment = align::right; break; case '^': alignment = align::center; break; } if (alignment != align::none) { if (p != begin) { auto c = *begin; if (c == '}') return begin; if (c == '{') { report_error("invalid fill character '{'"); return begin; } specs.set_fill(basic_string_view<Char>(begin, to_unsigned(p - begin))); begin = p + 1; } else { ++begin; } break; } else if (p == begin) { break; } p = begin; } specs.set_align(alignment); return begin; } template <typename Char, typename OutputIt> FMT_CONSTEXPR20 auto write_nonfinite(OutputIt out, bool isnan, format_specs specs, sign s) -> OutputIt { auto str = isnan ? (specs.upper() ? "NAN" : "nan") : (specs.upper() ? "INF" : "inf"); constexpr size_t str_size = 3; auto size = str_size + (s != sign::none ? 1 : 0); // Replace '0'-padding with space for non-finite values. const bool is_zero_fill = specs.fill_size() == 1 && specs.fill_unit<Char>() == '0'; if (is_zero_fill) specs.set_fill(' '); return write_padded<Char>(out, specs, size, [=](reserve_iterator<OutputIt> it) { if (s != sign::none) *it++ = detail::getsign<Char>(s); return copy<Char>(str, str + str_size, it); }); } // A decimal floating-point number significand * pow(10, exp). struct big_decimal_fp { const char* significand; int significand_size; int exponent; }; constexpr auto get_significand_size(const big_decimal_fp& f) -> int { return f.significand_size; } template <typename T> inline auto get_significand_size(const dragonbox::decimal_fp<T>& f) -> int { return count_digits(f.significand); } template <typename Char, typename OutputIt> constexpr auto write_significand(OutputIt out, const char* significand, int significand_size) -> OutputIt { return copy<Char>(significand, significand + significand_size, out); } template <typename Char, typename OutputIt, typename UInt> inline auto write_significand(OutputIt out, UInt significand, int significand_size) -> OutputIt { return format_decimal<Char>(out, significand, significand_size); } template <typename Char, typename OutputIt, typename T, typename Grouping> FMT_CONSTEXPR20 auto write_significand(OutputIt out, T significand, int significand_size, int exponent, const Grouping& grouping) -> OutputIt { if (!grouping.has_separator()) { out = write_significand<Char>(out, significand, significand_size); return detail::fill_n(out, exponent, static_cast<Char>('0')); } auto buffer = memory_buffer(); write_significand<char>(appender(buffer), significand, significand_size); detail::fill_n(appender(buffer), exponent, '0'); return grouping.apply(out, string_view(buffer.data(), buffer.size())); } template <typename Char, typename UInt, FMT_ENABLE_IF(std::is_integral<UInt>::value)> inline auto write_significand(Char* out, UInt significand, int significand_size, int integral_size, Char decimal_point) -> Char* { if (!decimal_point) return format_decimal(out, significand, significand_size); out += significand_size + 1; Char* end = out; int floating_size = significand_size - integral_size; for (int i = floating_size / 2; i > 0; --i) { out -= 2; write2digits(out, static_cast<std::size_t>(significand % 100)); significand /= 100; } if (floating_size % 2 != 0) { *--out = static_cast<Char>('0' + significand % 10); significand /= 10; } *--out = decimal_point; format_decimal(out - integral_size, significand, integral_size); return end; } template <typename OutputIt, typename UInt, typename Char, FMT_ENABLE_IF(!std::is_pointer<remove_cvref_t<OutputIt>>::value)> inline auto write_significand(OutputIt out, UInt significand, int significand_size, int integral_size, Char decimal_point) -> OutputIt { // Buffer is large enough to hold digits (digits10 + 1) and a decimal point. Char buffer[digits10<UInt>() + 2]; auto end = write_significand(buffer, significand, significand_size, integral_size, decimal_point); return detail::copy_noinline<Char>(buffer, end, out); } template <typename OutputIt, typename Char> FMT_CONSTEXPR auto write_significand(OutputIt out, const char* significand, int significand_size, int integral_size, Char decimal_point) -> OutputIt { out = detail::copy_noinline<Char>(significand, significand + integral_size, out); if (!decimal_point) return out; *out++ = decimal_point; return detail::copy_noinline<Char>(significand + integral_size, significand + significand_size, out); } template <typename OutputIt, typename Char, typename T, typename Grouping> FMT_CONSTEXPR20 auto write_significand(OutputIt out, T significand, int significand_size, int integral_size, Char decimal_point, const Grouping& grouping) -> OutputIt { if (!grouping.has_separator()) { return write_significand(out, significand, significand_size, integral_size, decimal_point); } auto buffer = basic_memory_buffer<Char>(); write_significand(basic_appender<Char>(buffer), significand, significand_size, integral_size, decimal_point); grouping.apply( out, basic_string_view<Char>(buffer.data(), to_unsigned(integral_size))); return detail::copy_noinline<Char>(buffer.data() + integral_size, buffer.end(), out); } template <typename Char, typename OutputIt, typename DecimalFP, typename Grouping = digit_grouping<Char>> FMT_CONSTEXPR20 auto do_write_float(OutputIt out, const DecimalFP& f, const format_specs& specs, sign s, int exp_upper, locale_ref loc) -> OutputIt { auto significand = f.significand; int significand_size = get_significand_size(f); const Char zero = static_cast<Char>('0'); size_t size = to_unsigned(significand_size) + (s != sign::none ? 1 : 0); using iterator = reserve_iterator<OutputIt>; Char decimal_point = specs.localized() ? detail::decimal_point<Char>(loc) : static_cast<Char>('.'); int output_exp = f.exponent + significand_size - 1; auto use_exp_format = [=]() { if (specs.type() == presentation_type::exp) return true; if (specs.type() == presentation_type::fixed) return false; // Use the fixed notation if the exponent is in [exp_lower, exp_upper), // e.g. 0.0001 instead of 1e-04. Otherwise use the exponent notation. const int exp_lower = -4; return output_exp < exp_lower || output_exp >= (specs.precision > 0 ? specs.precision : exp_upper); }; if (use_exp_format()) { int num_zeros = 0; if (specs.alt()) { num_zeros = specs.precision - significand_size; if (num_zeros < 0) num_zeros = 0; size += to_unsigned(num_zeros); } else if (significand_size == 1) { decimal_point = Char(); } auto abs_output_exp = output_exp >= 0 ? output_exp : -output_exp; int exp_digits = 2; if (abs_output_exp >= 100) exp_digits = abs_output_exp >= 1000 ? 4 : 3; size += to_unsigned((decimal_point ? 1 : 0) + 2 + exp_digits); char exp_char = specs.upper() ? 'E' : 'e'; auto write = [=](iterator it) { if (s != sign::none) *it++ = detail::getsign<Char>(s); // Insert a decimal point after the first digit and add an exponent. it = write_significand(it, significand, significand_size, 1, decimal_point); if (num_zeros > 0) it = detail::fill_n(it, num_zeros, zero); *it++ = static_cast<Char>(exp_char); return write_exponent<Char>(output_exp, it); }; return specs.width > 0 ? write_padded<Char, align::right>(out, specs, size, write) : base_iterator(out, write(reserve(out, size))); } int exp = f.exponent + significand_size; if (f.exponent >= 0) { // 1234e5 -> 123400000[.0+] size += to_unsigned(f.exponent); int num_zeros = specs.precision - exp; abort_fuzzing_if(num_zeros > 5000); if (specs.alt()) { ++size; if (num_zeros <= 0 && specs.type() != presentation_type::fixed) num_zeros = 0; if (num_zeros > 0) size += to_unsigned(num_zeros); } auto grouping = Grouping(loc, specs.localized()); size += to_unsigned(grouping.count_separators(exp)); return write_padded<Char, align::right>(out, specs, size, [&](iterator it) { if (s != sign::none) *it++ = detail::getsign<Char>(s); it = write_significand<Char>(it, significand, significand_size, f.exponent, grouping); if (!specs.alt()) return it; *it++ = decimal_point; return num_zeros > 0 ? detail::fill_n(it, num_zeros, zero) : it; }); } else if (exp > 0) { // 1234e-2 -> 12.34[0+] int num_zeros = specs.alt() ? specs.precision - significand_size : 0; size += 1 + static_cast<unsigned>(max_of(num_zeros, 0)); auto grouping = Grouping(loc, specs.localized()); size += to_unsigned(grouping.count_separators(exp)); return write_padded<Char, align::right>(out, specs, size, [&](iterator it) { if (s != sign::none) *it++ = detail::getsign<Char>(s); it = write_significand(it, significand, significand_size, exp, decimal_point, grouping); return num_zeros > 0 ? detail::fill_n(it, num_zeros, zero) : it; }); } // 1234e-6 -> 0.001234 int num_zeros = -exp; if (significand_size == 0 && specs.precision >= 0 && specs.precision < num_zeros) { num_zeros = specs.precision; } bool pointy = num_zeros != 0 || significand_size != 0 || specs.alt(); size += 1 + (pointy ? 1 : 0) + to_unsigned(num_zeros); return write_padded<Char, align::right>(out, specs, size, [&](iterator it) { if (s != sign::none) *it++ = detail::getsign<Char>(s); *it++ = zero; if (!pointy) return it; *it++ = decimal_point; it = detail::fill_n(it, num_zeros, zero); return write_significand<Char>(it, significand, significand_size); }); } template <typename Char> class fallback_digit_grouping { public: constexpr fallback_digit_grouping(locale_ref, bool) {} constexpr auto has_separator() const -> bool { return false; } constexpr auto count_separators(int) const -> int { return 0; } template <typename Out, typename C> constexpr auto apply(Out out, basic_string_view<C>) const -> Out { return out; } }; template <typename Char, typename OutputIt, typename DecimalFP> FMT_CONSTEXPR20 auto write_float(OutputIt out, const DecimalFP& f, const format_specs& specs, sign s, int exp_upper, locale_ref loc) -> OutputIt { if (is_constant_evaluated()) { return do_write_float<Char, OutputIt, DecimalFP, fallback_digit_grouping<Char>>(out, f, specs, s, exp_upper, loc); } else { return do_write_float<Char>(out, f, specs, s, exp_upper, loc); } } template <typename T> constexpr auto isnan(T value) -> bool { return value != value; // std::isnan doesn't support __float128. } template <typename T, typename Enable = void> struct has_isfinite : std::false_type {}; template <typename T> struct has_isfinite<T, enable_if_t<sizeof(std::isfinite(T())) != 0>> : std::true_type {}; template <typename T, FMT_ENABLE_IF(std::is_floating_point<T>::value&& has_isfinite<T>::value)> FMT_CONSTEXPR20 auto isfinite(T value) -> bool { constexpr T inf = T(std::numeric_limits<double>::infinity()); if (is_constant_evaluated()) return !detail::isnan(value) && value < inf && value > -inf; return std::isfinite(value); } template <typename T, FMT_ENABLE_IF(!has_isfinite<T>::value)> FMT_CONSTEXPR auto isfinite(T value) -> bool { T inf = T(std::numeric_limits<double>::infinity()); // std::isfinite doesn't support __float128. return !detail::isnan(value) && value < inf && value > -inf; } template <typename T, FMT_ENABLE_IF(is_floating_point<T>::value)> FMT_INLINE FMT_CONSTEXPR bool signbit(T value) { if (is_constant_evaluated()) { #ifdef __cpp_if_constexpr if constexpr (std::numeric_limits<double>::is_iec559) { auto bits = detail::bit_cast<uint64_t>(static_cast<double>(value)); return (bits >> (num_bits<uint64_t>() - 1)) != 0; } #endif } return std::signbit(static_cast<double>(value)); } inline FMT_CONSTEXPR20 void adjust_precision(int& precision, int exp10) { // Adjust fixed precision by exponent because it is relative to decimal // point. if (exp10 > 0 && precision > max_value<int>() - exp10) FMT_THROW(format_error("number is too big")); precision += exp10; } class bigint { private: // A bigint is a number in the form bigit_[N - 1] ... bigit_[0] * 32^exp_. using bigit = uint32_t; // A big digit. using double_bigit = uint64_t; enum { bigit_bits = num_bits<bigit>() }; enum { bigits_capacity = 32 }; basic_memory_buffer<bigit, bigits_capacity> bigits_; int exp_; friend struct formatter<bigint>; FMT_CONSTEXPR auto get_bigit(int i) const -> bigit { return i >= exp_ && i < num_bigits() ? bigits_[i - exp_] : 0; } FMT_CONSTEXPR void subtract_bigits(int index, bigit other, bigit& borrow) { auto result = double_bigit(bigits_[index]) - other - borrow; bigits_[index] = static_cast<bigit>(result); borrow = static_cast<bigit>(result >> (bigit_bits * 2 - 1)); } FMT_CONSTEXPR void remove_leading_zeros() { int num_bigits = static_cast<int>(bigits_.size()) - 1; while (num_bigits > 0 && bigits_[num_bigits] == 0) --num_bigits; bigits_.resize(to_unsigned(num_bigits + 1)); } // Computes *this -= other assuming aligned bigints and *this >= other. FMT_CONSTEXPR void subtract_aligned(const bigint& other) { FMT_ASSERT(other.exp_ >= exp_, "unaligned bigints"); FMT_ASSERT(compare(*this, other) >= 0, ""); bigit borrow = 0; int i = other.exp_ - exp_; for (size_t j = 0, n = other.bigits_.size(); j != n; ++i, ++j) subtract_bigits(i, other.bigits_[j], borrow); if (borrow != 0) subtract_bigits(i, 0, borrow); FMT_ASSERT(borrow == 0, ""); remove_leading_zeros(); } FMT_CONSTEXPR void multiply(uint32_t value) { bigit carry = 0; const double_bigit wide_value = value; for (size_t i = 0, n = bigits_.size(); i < n; ++i) { double_bigit result = bigits_[i] * wide_value + carry; bigits_[i] = static_cast<bigit>(result); carry = static_cast<bigit>(result >> bigit_bits); } if (carry != 0) bigits_.push_back(carry); } template <typename UInt, FMT_ENABLE_IF(std::is_same<UInt, uint64_t>::value || std::is_same<UInt, uint128_t>::value)> FMT_CONSTEXPR void multiply(UInt value) { using half_uint = conditional_t<std::is_same<UInt, uint128_t>::value, uint64_t, uint32_t>; const int shift = num_bits<half_uint>() - bigit_bits; const UInt lower = static_cast<half_uint>(value); const UInt upper = value >> num_bits<half_uint>(); UInt carry = 0; for (size_t i = 0, n = bigits_.size(); i < n; ++i) { UInt result = lower * bigits_[i] + static_cast<bigit>(carry); carry = (upper * bigits_[i] << shift) + (result >> bigit_bits) + (carry >> bigit_bits); bigits_[i] = static_cast<bigit>(result); } while (carry != 0) { bigits_.push_back(static_cast<bigit>(carry)); carry >>= bigit_bits; } } template <typename UInt, FMT_ENABLE_IF(std::is_same<UInt, uint64_t>::value || std::is_same<UInt, uint128_t>::value)> FMT_CONSTEXPR void assign(UInt n) { size_t num_bigits = 0; do { bigits_[num_bigits++] = static_cast<bigit>(n); n >>= bigit_bits; } while (n != 0); bigits_.resize(num_bigits); exp_ = 0; } public: FMT_CONSTEXPR bigint() : exp_(0) {} explicit bigint(uint64_t n) { assign(n); } bigint(const bigint&) = delete; void operator=(const bigint&) = delete; FMT_CONSTEXPR void assign(const bigint& other) { auto size = other.bigits_.size(); bigits_.resize(size); auto data = other.bigits_.data(); copy<bigit>(data, data + size, bigits_.data()); exp_ = other.exp_; } template <typename Int> FMT_CONSTEXPR void operator=(Int n) { FMT_ASSERT(n > 0, ""); assign(uint64_or_128_t<Int>(n)); } FMT_CONSTEXPR auto num_bigits() const -> int { return static_cast<int>(bigits_.size()) + exp_; } FMT_CONSTEXPR auto operator<<=(int shift) -> bigint& { FMT_ASSERT(shift >= 0, ""); exp_ += shift / bigit_bits; shift %= bigit_bits; if (shift == 0) return *this; bigit carry = 0; for (size_t i = 0, n = bigits_.size(); i < n; ++i) { bigit c = bigits_[i] >> (bigit_bits - shift); bigits_[i] = (bigits_[i] << shift) + carry; carry = c; } if (carry != 0) bigits_.push_back(carry); return *this; } template <typename Int> FMT_CONSTEXPR auto operator*=(Int value) -> bigint& { FMT_ASSERT(value > 0, ""); multiply(uint32_or_64_or_128_t<Int>(value)); return *this; } friend FMT_CONSTEXPR auto compare(const bigint& b1, const bigint& b2) -> int { int num_bigits1 = b1.num_bigits(), num_bigits2 = b2.num_bigits(); if (num_bigits1 != num_bigits2) return num_bigits1 > num_bigits2 ? 1 : -1; int i = static_cast<int>(b1.bigits_.size()) - 1; int j = static_cast<int>(b2.bigits_.size()) - 1; int end = i - j; if (end < 0) end = 0; for (; i >= end; --i, --j) { bigit b1_bigit = b1.bigits_[i], b2_bigit = b2.bigits_[j]; if (b1_bigit != b2_bigit) return b1_bigit > b2_bigit ? 1 : -1; } if (i != j) return i > j ? 1 : -1; return 0; } // Returns compare(lhs1 + lhs2, rhs). friend FMT_CONSTEXPR auto add_compare(const bigint& lhs1, const bigint& lhs2, const bigint& rhs) -> int { int max_lhs_bigits = max_of(lhs1.num_bigits(), lhs2.num_bigits()); int num_rhs_bigits = rhs.num_bigits(); if (max_lhs_bigits + 1 < num_rhs_bigits) return -1; if (max_lhs_bigits > num_rhs_bigits) return 1; double_bigit borrow = 0; int min_exp = min_of(min_of(lhs1.exp_, lhs2.exp_), rhs.exp_); for (int i = num_rhs_bigits - 1; i >= min_exp; --i) { double_bigit sum = double_bigit(lhs1.get_bigit(i)) + lhs2.get_bigit(i); bigit rhs_bigit = rhs.get_bigit(i); if (sum > rhs_bigit + borrow) return 1; borrow = rhs_bigit + borrow - sum; if (borrow > 1) return -1; borrow <<= bigit_bits; } return borrow != 0 ? -1 : 0; } // Assigns pow(10, exp) to this bigint. FMT_CONSTEXPR20 void assign_pow10(int exp) { FMT_ASSERT(exp >= 0, ""); if (exp == 0) return *this = 1; int bitmask = 1 << (num_bits<unsigned>() - countl_zero(static_cast<uint32_t>(exp)) - 1); // pow(10, exp) = pow(5, exp) * pow(2, exp). First compute pow(5, exp) by // repeated squaring and multiplication. *this = 5; bitmask >>= 1; while (bitmask != 0) { square(); if ((exp & bitmask) != 0) *this *= 5; bitmask >>= 1; } *this <<= exp; // Multiply by pow(2, exp) by shifting. } FMT_CONSTEXPR20 void square() { int num_bigits = static_cast<int>(bigits_.size()); int num_result_bigits = 2 * num_bigits; basic_memory_buffer<bigit, bigits_capacity> n(std::move(bigits_)); bigits_.resize(to_unsigned(num_result_bigits)); auto sum = uint128_t(); for (int bigit_index = 0; bigit_index < num_bigits; ++bigit_index) { // Compute bigit at position bigit_index of the result by adding // cross-product terms n[i] * n[j] such that i + j == bigit_index. for (int i = 0, j = bigit_index; j >= 0; ++i, --j) { // Most terms are multiplied twice which can be optimized in the future. sum += double_bigit(n[i]) * n[j]; } bigits_[bigit_index] = static_cast<bigit>(sum); sum >>= num_bits<bigit>(); // Compute the carry. } // Do the same for the top half. for (int bigit_index = num_bigits; bigit_index < num_result_bigits; ++bigit_index) { for (int j = num_bigits - 1, i = bigit_index - j; i < num_bigits;) sum += double_bigit(n[i++]) * n[j--]; bigits_[bigit_index] = static_cast<bigit>(sum); sum >>= num_bits<bigit>(); } remove_leading_zeros(); exp_ *= 2; } // If this bigint has a bigger exponent than other, adds trailing zero to make // exponents equal. This simplifies some operations such as subtraction. FMT_CONSTEXPR void align(const bigint& other) { int exp_difference = exp_ - other.exp_; if (exp_difference <= 0) return; int num_bigits = static_cast<int>(bigits_.size()); bigits_.resize(to_unsigned(num_bigits + exp_difference)); for (int i = num_bigits - 1, j = i + exp_difference; i >= 0; --i, --j) bigits_[j] = bigits_[i]; memset(bigits_.data(), 0, to_unsigned(exp_difference) * sizeof(bigit)); exp_ -= exp_difference; } // Divides this bignum by divisor, assigning the remainder to this and // returning the quotient. FMT_CONSTEXPR auto divmod_assign(const bigint& divisor) -> int { FMT_ASSERT(this != &divisor, ""); if (compare(*this, divisor) < 0) return 0; FMT_ASSERT(divisor.bigits_[divisor.bigits_.size() - 1u] != 0, ""); align(divisor); int quotient = 0; do { subtract_aligned(divisor); ++quotient; } while (compare(*this, divisor) >= 0); return quotient; } }; // format_dragon flags. enum dragon { predecessor_closer = 1, fixup = 2, // Run fixup to correct exp10 which can be off by one. fixed = 4, }; // Formats a floating-point number using a variation of the Fixed-Precision // Positive Floating-Point Printout ((FPP)^2) algorithm by Steele & White: // https://fmt.dev/papers/p372-steele.pdf. FMT_CONSTEXPR20 inline void format_dragon(basic_fp<uint128_t> value, unsigned flags, int num_digits, buffer<char>& buf, int& exp10) { bigint numerator; // 2 * R in (FPP)^2. bigint denominator; // 2 * S in (FPP)^2. // lower and upper are differences between value and corresponding boundaries. bigint lower; // (M^- in (FPP)^2). bigint upper_store; // upper's value if different from lower. bigint* upper = nullptr; // (M^+ in (FPP)^2). // Shift numerator and denominator by an extra bit or two (if lower boundary // is closer) to make lower and upper integers. This eliminates multiplication // by 2 during later computations. bool is_predecessor_closer = (flags & dragon::predecessor_closer) != 0; int shift = is_predecessor_closer ? 2 : 1; if (value.e >= 0) { numerator = value.f; numerator <<= value.e + shift; lower = 1; lower <<= value.e; if (is_predecessor_closer) { upper_store = 1; upper_store <<= value.e + 1; upper = &upper_store; } denominator.assign_pow10(exp10); denominator <<= shift; } else if (exp10 < 0) { numerator.assign_pow10(-exp10); lower.assign(numerator); if (is_predecessor_closer) { upper_store.assign(numerator); upper_store <<= 1; upper = &upper_store; } numerator *= value.f; numerator <<= shift; denominator = 1; denominator <<= shift - value.e; } else { numerator = value.f; numerator <<= shift; denominator.assign_pow10(exp10); denominator <<= shift - value.e; lower = 1; if (is_predecessor_closer) { upper_store = 1ULL << 1; upper = &upper_store; } } int even = static_cast<int>((value.f & 1) == 0); if (!upper) upper = &lower; bool shortest = num_digits < 0; if ((flags & dragon::fixup) != 0) { if (add_compare(numerator, *upper, denominator) + even <= 0) { --exp10; numerator *= 10; if (num_digits < 0) { lower *= 10; if (upper != &lower) *upper *= 10; } } if ((flags & dragon::fixed) != 0) adjust_precision(num_digits, exp10 + 1); } // Invariant: value == (numerator / denominator) * pow(10, exp10). if (shortest) { // Generate the shortest representation. num_digits = 0; char* data = buf.data(); for (;;) { int digit = numerator.divmod_assign(denominator); bool low = compare(numerator, lower) - even < 0; // numerator <[=] lower. // numerator + upper >[=] pow10: bool high = add_compare(numerator, *upper, denominator) + even > 0; data[num_digits++] = static_cast<char>('0' + digit); if (low || high) { if (!low) { ++data[num_digits - 1]; } else if (high) { int result = add_compare(numerator, numerator, denominator); // Round half to even. if (result > 0 || (result == 0 && (digit % 2) != 0)) ++data[num_digits - 1]; } buf.try_resize(to_unsigned(num_digits)); exp10 -= num_digits - 1; return; } numerator *= 10; lower *= 10; if (upper != &lower) *upper *= 10; } } // Generate the given number of digits. exp10 -= num_digits - 1; if (num_digits <= 0) { auto digit = '0'; if (num_digits == 0) { denominator *= 10; digit = add_compare(numerator, numerator, denominator) > 0 ? '1' : '0'; } buf.push_back(digit); return; } buf.try_resize(to_unsigned(num_digits)); for (int i = 0; i < num_digits - 1; ++i) { int digit = numerator.divmod_assign(denominator); buf[i] = static_cast<char>('0' + digit); numerator *= 10; } int digit = numerator.divmod_assign(denominator); auto result = add_compare(numerator, numerator, denominator); if (result > 0 || (result == 0 && (digit % 2) != 0)) { if (digit == 9) { const auto overflow = '0' + 10; buf[num_digits - 1] = overflow; // Propagate the carry. for (int i = num_digits - 1; i > 0 && buf[i] == overflow; --i) { buf[i] = '0'; ++buf[i - 1]; } if (buf[0] == overflow) { buf[0] = '1'; if ((flags & dragon::fixed) != 0) buf.push_back('0'); else ++exp10; } return; } ++digit; } buf[num_digits - 1] = static_cast<char>('0' + digit); } // Formats a floating-point number using the hexfloat format. template <typename Float, FMT_ENABLE_IF(!is_double_double<Float>::value)> FMT_CONSTEXPR20 void format_hexfloat(Float value, format_specs specs, buffer<char>& buf) { // float is passed as double to reduce the number of instantiations and to // simplify implementation. static_assert(!std::is_same<Float, float>::value, ""); using info = dragonbox::float_info<Float>; // Assume Float is in the format [sign][exponent][significand]. using carrier_uint = typename info::carrier_uint; const auto num_float_significand_bits = detail::num_significand_bits<Float>(); basic_fp<carrier_uint> f(value); f.e += num_float_significand_bits; if (!has_implicit_bit<Float>()) --f.e; const auto num_fraction_bits = num_float_significand_bits + (has_implicit_bit<Float>() ? 1 : 0); const auto num_xdigits = (num_fraction_bits + 3) / 4; const auto leading_shift = ((num_xdigits - 1) * 4); const auto leading_mask = carrier_uint(0xF) << leading_shift; const auto leading_xdigit = static_cast<uint32_t>((f.f & leading_mask) >> leading_shift); if (leading_xdigit > 1) f.e -= (32 - countl_zero(leading_xdigit) - 1); int print_xdigits = num_xdigits - 1; if (specs.precision >= 0 && print_xdigits > specs.precision) { const int shift = ((print_xdigits - specs.precision - 1) * 4); const auto mask = carrier_uint(0xF) << shift; const auto v = static_cast<uint32_t>((f.f & mask) >> shift); if (v >= 8) { const auto inc = carrier_uint(1) << (shift + 4); f.f += inc; f.f &= ~(inc - 1); } // Check long double overflow if (!has_implicit_bit<Float>()) { const auto implicit_bit = carrier_uint(1) << num_float_significand_bits; if ((f.f & implicit_bit) == implicit_bit) { f.f >>= 4; f.e += 4; } } print_xdigits = specs.precision; } char xdigits[num_bits<carrier_uint>() / 4]; detail::fill_n(xdigits, sizeof(xdigits), '0'); format_base2e(4, xdigits, f.f, num_xdigits, specs.upper()); // Remove zero tail while (print_xdigits > 0 && xdigits[print_xdigits] == '0') --print_xdigits; buf.push_back('0'); buf.push_back(specs.upper() ? 'X' : 'x'); buf.push_back(xdigits[0]); if (specs.alt() || print_xdigits > 0 || print_xdigits < specs.precision) buf.push_back('.'); buf.append(xdigits + 1, xdigits + 1 + print_xdigits); for (; print_xdigits < specs.precision; ++print_xdigits) buf.push_back('0'); buf.push_back(specs.upper() ? 'P' : 'p'); uint32_t abs_e; if (f.e < 0) { buf.push_back('-'); abs_e = static_cast<uint32_t>(-f.e); } else { buf.push_back('+'); abs_e = static_cast<uint32_t>(f.e); } format_decimal<char>(appender(buf), abs_e, detail::count_digits(abs_e)); } template <typename Float, FMT_ENABLE_IF(is_double_double<Float>::value)> FMT_CONSTEXPR20 void format_hexfloat(Float value, format_specs specs, buffer<char>& buf) { format_hexfloat(static_cast<double>(value), specs, buf); } constexpr auto fractional_part_rounding_thresholds(int index) -> uint32_t { // For checking rounding thresholds. // The kth entry is chosen to be the smallest integer such that the // upper 32-bits of 10^(k+1) times it is strictly bigger than 5 * 10^k. // It is equal to ceil(2^31 + 2^32/10^(k + 1)). // These are stored in a string literal because we cannot have static arrays // in constexpr functions and non-static ones are poorly optimized. return U"\x9999999a\x828f5c29\x80418938\x80068db9\x8000a7c6\x800010c7" U"\x800001ae\x8000002b"[index]; } template <typename Float> FMT_CONSTEXPR20 auto format_float(Float value, int precision, const format_specs& specs, bool binary32, buffer<char>& buf) -> int { // float is passed as double to reduce the number of instantiations. static_assert(!std::is_same<Float, float>::value, ""); auto converted_value = convert_float(value); const bool fixed = specs.type() == presentation_type::fixed; if (value == 0) { if (precision <= 0 || !fixed) { buf.push_back('0'); return 0; } buf.try_resize(to_unsigned(precision)); fill_n(buf.data(), precision, '0'); return -precision; } int exp = 0; bool use_dragon = true; unsigned dragon_flags = 0; if (!is_fast_float<Float>() || is_constant_evaluated()) { const auto inv_log2_10 = 0.3010299956639812; // 1 / log2(10) using info = dragonbox::float_info<decltype(converted_value)>; const auto f = basic_fp<typename info::carrier_uint>(converted_value); // Compute exp, an approximate power of 10, such that // 10^(exp - 1) <= value < 10^exp or 10^exp <= value < 10^(exp + 1). // This is based on log10(value) == log2(value) / log2(10) and approximation // of log2(value) by e + num_fraction_bits idea from double-conversion. auto e = (f.e + count_digits<1>(f.f) - 1) * inv_log2_10 - 1e-10; exp = static_cast<int>(e); if (e > exp) ++exp; // Compute ceil. dragon_flags = dragon::fixup; } else { // Extract significand bits and exponent bits. using info = dragonbox::float_info<double>; auto br = bit_cast<uint64_t>(static_cast<double>(value)); const uint64_t significand_mask = (static_cast<uint64_t>(1) << num_significand_bits<double>()) - 1; uint64_t significand = (br & significand_mask); int exponent = static_cast<int>((br & exponent_mask<double>()) >> num_significand_bits<double>()); if (exponent != 0) { // Check if normal. exponent -= exponent_bias<double>() + num_significand_bits<double>(); significand |= (static_cast<uint64_t>(1) << num_significand_bits<double>()); significand <<= 1; } else { // Normalize subnormal inputs. FMT_ASSERT(significand != 0, "zeros should not appear here"); int shift = countl_zero(significand); FMT_ASSERT(shift >= num_bits<uint64_t>() - num_significand_bits<double>(), ""); shift -= (num_bits<uint64_t>() - num_significand_bits<double>() - 2); exponent = (std::numeric_limits<double>::min_exponent - num_significand_bits<double>()) - shift; significand <<= shift; } // Compute the first several nonzero decimal significand digits. // We call the number we get the first segment. const int k = info::kappa - dragonbox::floor_log10_pow2(exponent); exp = -k; const int beta = exponent + dragonbox::floor_log2_pow10(k); uint64_t first_segment; bool has_more_segments; int digits_in_the_first_segment; { const auto r = dragonbox::umul192_upper128( significand << beta, dragonbox::get_cached_power(k)); first_segment = r.high(); has_more_segments = r.low() != 0; // The first segment can have 18 ~ 19 digits. if (first_segment >= 1000000000000000000ULL) { digits_in_the_first_segment = 19; } else { // When it is of 18-digits, we align it to 19-digits by adding a bogus // zero at the end. digits_in_the_first_segment = 18; first_segment *= 10; } } // Compute the actual number of decimal digits to print. if (fixed) adjust_precision(precision, exp + digits_in_the_first_segment); // Use Dragon4 only when there might be not enough digits in the first // segment. if (digits_in_the_first_segment > precision) { use_dragon = false; if (precision <= 0) { exp += digits_in_the_first_segment; if (precision < 0) { // Nothing to do, since all we have are just leading zeros. buf.try_resize(0); } else { // We may need to round-up. buf.try_resize(1); if ((first_segment | static_cast<uint64_t>(has_more_segments)) > 5000000000000000000ULL) { buf[0] = '1'; } else { buf[0] = '0'; } } } // precision <= 0 else { exp += digits_in_the_first_segment - precision; // When precision > 0, we divide the first segment into three // subsegments, each with 9, 9, and 0 ~ 1 digits so that each fits // in 32-bits which usually allows faster calculation than in // 64-bits. Since some compiler (e.g. MSVC) doesn't know how to optimize // division-by-constant for large 64-bit divisors, we do it here // manually. The magic number 7922816251426433760 below is equal to // ceil(2^(64+32) / 10^10). const uint32_t first_subsegment = static_cast<uint32_t>( dragonbox::umul128_upper64(first_segment, 7922816251426433760ULL) >> 32); const uint64_t second_third_subsegments = first_segment - first_subsegment * 10000000000ULL; uint64_t prod; uint32_t digits; bool should_round_up; int number_of_digits_to_print = min_of(precision, 9); // Print a 9-digits subsegment, either the first or the second. auto print_subsegment = [&](uint32_t subsegment, char* buffer) { int number_of_digits_printed = 0; // If we want to print an odd number of digits from the subsegment, if ((number_of_digits_to_print & 1) != 0) { // Convert to 64-bit fixed-point fractional form with 1-digit // integer part. The magic number 720575941 is a good enough // approximation of 2^(32 + 24) / 10^8; see // https://jk-jeon.github.io/posts/2022/12/fixed-precision-formatting/#fixed-length-case // for details. prod = ((subsegment * static_cast<uint64_t>(720575941)) >> 24) + 1; digits = static_cast<uint32_t>(prod >> 32); *buffer = static_cast<char>('0' + digits); number_of_digits_printed++; } // If we want to print an even number of digits from the // first_subsegment, else { // Convert to 64-bit fixed-point fractional form with 2-digits // integer part. The magic number 450359963 is a good enough // approximation of 2^(32 + 20) / 10^7; see // https://jk-jeon.github.io/posts/2022/12/fixed-precision-formatting/#fixed-length-case // for details. prod = ((subsegment * static_cast<uint64_t>(450359963)) >> 20) + 1; digits = static_cast<uint32_t>(prod >> 32); write2digits(buffer, digits); number_of_digits_printed += 2; } // Print all digit pairs. while (number_of_digits_printed < number_of_digits_to_print) { prod = static_cast<uint32_t>(prod) * static_cast<uint64_t>(100); digits = static_cast<uint32_t>(prod >> 32); write2digits(buffer + number_of_digits_printed, digits); number_of_digits_printed += 2; } }; // Print first subsegment. print_subsegment(first_subsegment, buf.data()); // Perform rounding if the first subsegment is the last subsegment to // print. if (precision <= 9) { // Rounding inside the subsegment. // We round-up if: // - either the fractional part is strictly larger than 1/2, or // - the fractional part is exactly 1/2 and the last digit is odd. // We rely on the following observations: // - If fractional_part >= threshold, then the fractional part is // strictly larger than 1/2. // - If the MSB of fractional_part is set, then the fractional part // must be at least 1/2. // - When the MSB of fractional_part is set, either // second_third_subsegments being nonzero or has_more_segments // being true means there are further digits not printed, so the // fractional part is strictly larger than 1/2. if (precision < 9) { uint32_t fractional_part = static_cast<uint32_t>(prod); should_round_up = fractional_part >= fractional_part_rounding_thresholds( 8 - number_of_digits_to_print) || ((fractional_part >> 31) & ((digits & 1) | (second_third_subsegments != 0) | has_more_segments)) != 0; } // Rounding at the subsegment boundary. // In this case, the fractional part is at least 1/2 if and only if // second_third_subsegments >= 5000000000ULL, and is strictly larger // than 1/2 if we further have either second_third_subsegments > // 5000000000ULL or has_more_segments == true. else { should_round_up = second_third_subsegments > 5000000000ULL || (second_third_subsegments == 5000000000ULL && ((digits & 1) != 0 || has_more_segments)); } } // Otherwise, print the second subsegment. else { // Compilers are not aware of how to leverage the maximum value of // second_third_subsegments to find out a better magic number which // allows us to eliminate an additional shift. 1844674407370955162 = // ceil(2^64/10) < ceil(2^64*(10^9/(10^10 - 1))). const uint32_t second_subsegment = static_cast<uint32_t>(dragonbox::umul128_upper64( second_third_subsegments, 1844674407370955162ULL)); const uint32_t third_subsegment = static_cast<uint32_t>(second_third_subsegments) - second_subsegment * 10; number_of_digits_to_print = precision - 9; print_subsegment(second_subsegment, buf.data() + 9); // Rounding inside the subsegment. if (precision < 18) { // The condition third_subsegment != 0 implies that the segment was // of 19 digits, so in this case the third segment should be // consisting of a genuine digit from the input. uint32_t fractional_part = static_cast<uint32_t>(prod); should_round_up = fractional_part >= fractional_part_rounding_thresholds( 8 - number_of_digits_to_print) || ((fractional_part >> 31) & ((digits & 1) | (third_subsegment != 0) | has_more_segments)) != 0; } // Rounding at the subsegment boundary. else { // In this case, the segment must be of 19 digits, thus // the third subsegment should be consisting of a genuine digit from // the input. should_round_up = third_subsegment > 5 || (third_subsegment == 5 && ((digits & 1) != 0 || has_more_segments)); } } // Round-up if necessary. if (should_round_up) { ++buf[precision - 1]; for (int i = precision - 1; i > 0 && buf[i] > '9'; --i) { buf[i] = '0'; ++buf[i - 1]; } if (buf[0] > '9') { buf[0] = '1'; if (fixed) buf[precision++] = '0'; else ++exp; } } buf.try_resize(to_unsigned(precision)); } } // if (digits_in_the_first_segment > precision) else { // Adjust the exponent for its use in Dragon4. exp += digits_in_the_first_segment - 1; } } if (use_dragon) { auto f = basic_fp<uint128_t>(); bool is_predecessor_closer = binary32 ? f.assign(static_cast<float>(value)) : f.assign(converted_value); if (is_predecessor_closer) dragon_flags |= dragon::predecessor_closer; if (fixed) dragon_flags |= dragon::fixed; // Limit precision to the maximum possible number of significant digits in // an IEEE754 double because we don't need to generate zeros. const int max_double_digits = 767; if (precision > max_double_digits) precision = max_double_digits; format_dragon(f, dragon_flags, precision, buf, exp); } if (!fixed && !specs.alt()) { // Remove trailing zeros. auto num_digits = buf.size(); while (num_digits > 0 && buf[num_digits - 1] == '0') { --num_digits; ++exp; } buf.try_resize(num_digits); } return exp; } // Numbers with exponents greater or equal to the returned value will use // the exponential notation. template <typename T> constexpr auto exp_upper() -> int { return std::numeric_limits<T>::digits10 != 0 ? min_of(16, std::numeric_limits<T>::digits10 + 1) : 16; } template <typename Char, typename OutputIt, typename T> FMT_CONSTEXPR20 auto write_float(OutputIt out, T value, format_specs specs, locale_ref loc) -> OutputIt { // Use signbit because value < 0 is false for NaN. sign s = detail::signbit(value) ? sign::minus : specs.sign(); if (!detail::isfinite(value)) return write_nonfinite<Char>(out, detail::isnan(value), specs, s); if (specs.align() == align::numeric && s != sign::none) { *out++ = detail::getsign<Char>(s); s = sign::none; if (specs.width != 0) --specs.width; } constexpr int exp_upper = detail::exp_upper<T>(); int precision = specs.precision; if (precision < 0) { if (specs.type() != presentation_type::none) { precision = 6; } else if (is_fast_float<T>::value && !is_constant_evaluated()) { // Use Dragonbox for the shortest format. using floaty = conditional_t<sizeof(T) >= sizeof(double), double, float>; auto dec = dragonbox::to_decimal(static_cast<floaty>(value)); return write_float<Char>(out, dec, specs, s, exp_upper, loc); } } memory_buffer buffer; if (specs.type() == presentation_type::hexfloat) { if (s != sign::none) buffer.push_back(detail::getsign<char>(s)); format_hexfloat(convert_float(value), specs, buffer); return write_bytes<Char, align::right>(out, {buffer.data(), buffer.size()}, specs); } if (specs.type() == presentation_type::exp) { if (precision == max_value<int>()) report_error("number is too big"); else ++precision; if (specs.precision != 0) specs.set_alt(); } else if (specs.type() == presentation_type::fixed) { if (specs.precision != 0) specs.set_alt(); } else if (precision == 0) { precision = 1; } int exp = format_float(convert_float(value), precision, specs, std::is_same<T, float>(), buffer); specs.precision = precision; auto f = big_decimal_fp{buffer.data(), static_cast<int>(buffer.size()), exp}; return write_float<Char>(out, f, specs, s, exp_upper, loc); } template <typename Char, typename OutputIt, typename T, FMT_ENABLE_IF(is_floating_point<T>::value)> FMT_CONSTEXPR20 auto write(OutputIt out, T value, format_specs specs, locale_ref loc = {}) -> OutputIt { return specs.localized() && write_loc(out, value, specs, loc) ? out : write_float<Char>(out, value, specs, loc); } template <typename Char, typename OutputIt, typename T, FMT_ENABLE_IF(is_fast_float<T>::value)> FMT_CONSTEXPR20 auto write(OutputIt out, T value) -> OutputIt { if (is_constant_evaluated()) return write<Char>(out, value, format_specs()); auto s = detail::signbit(value) ? sign::minus : sign::none; constexpr auto specs = format_specs(); using floaty = conditional_t<sizeof(T) >= sizeof(double), double, float>; using floaty_uint = typename dragonbox::float_info<floaty>::carrier_uint; floaty_uint mask = exponent_mask<floaty>(); if ((bit_cast<floaty_uint>(value) & mask) == mask) return write_nonfinite<Char>(out, std::isnan(value), specs, s); auto dec = dragonbox::to_decimal(static_cast<floaty>(value)); return write_float<Char>(out, dec, specs, s, exp_upper<T>(), {}); } template <typename Char, typename OutputIt, typename T, FMT_ENABLE_IF(is_floating_point<T>::value && !is_fast_float<T>::value)> inline auto write(OutputIt out, T value) -> OutputIt { return write<Char>(out, value, format_specs()); } template <typename Char, typename OutputIt> auto write(OutputIt out, monostate, format_specs = {}, locale_ref = {}) -> OutputIt { FMT_ASSERT(false, ""); return out; } template <typename Char, typename OutputIt> FMT_CONSTEXPR auto write(OutputIt out, basic_string_view<Char> value) -> OutputIt { return copy_noinline<Char>(value.begin(), value.end(), out); } template <typename Char, typename OutputIt, typename T, FMT_ENABLE_IF(has_to_string_view<T>::value)> constexpr auto write(OutputIt out, const T& value) -> OutputIt { return write<Char>(out, to_string_view(value)); } // FMT_ENABLE_IF() condition separated to workaround an MSVC bug. template < typename Char, typename OutputIt, typename T, bool check = std::is_enum<T>::value && !std::is_same<T, Char>::value && mapped_type_constant<T, Char>::value != type::custom_type, FMT_ENABLE_IF(check)> FMT_CONSTEXPR auto write(OutputIt out, T value) -> OutputIt { return write<Char>(out, static_cast<underlying_t<T>>(value)); } template <typename Char, typename OutputIt, typename T, FMT_ENABLE_IF(std::is_same<T, bool>::value)> FMT_CONSTEXPR auto write(OutputIt out, T value, const format_specs& specs = {}, locale_ref = {}) -> OutputIt { return specs.type() != presentation_type::none && specs.type() != presentation_type::string ? write<Char>(out, value ? 1 : 0, specs, {}) : write_bytes<Char>(out, value ? "true" : "false", specs); } template <typename Char, typename OutputIt> FMT_CONSTEXPR auto write(OutputIt out, Char value) -> OutputIt { auto it = reserve(out, 1); *it++ = value; return base_iterator(out, it); } template <typename Char, typename OutputIt> FMT_CONSTEXPR20 auto write(OutputIt out, const Char* value) -> OutputIt { if (value) return write(out, basic_string_view<Char>(value)); report_error("string pointer is null"); return out; } template <typename Char, typename OutputIt, typename T, FMT_ENABLE_IF(std::is_same<T, void>::value)> auto write(OutputIt out, const T* value, const format_specs& specs = {}, locale_ref = {}) -> OutputIt { return write_ptr<Char>(out, bit_cast<uintptr_t>(value), &specs); } template <typename Char, typename OutputIt, typename T, FMT_ENABLE_IF(mapped_type_constant<T, Char>::value == type::custom_type && !std::is_fundamental<T>::value)> FMT_CONSTEXPR auto write(OutputIt out, const T& value) -> OutputIt { auto f = formatter<T, Char>(); auto parse_ctx = parse_context<Char>({}); f.parse(parse_ctx); auto ctx = basic_format_context<OutputIt, Char>(out, {}, {}); return f.format(value, ctx); } template <typename T> using is_builtin = bool_constant<std::is_same<T, int>::value || FMT_BUILTIN_TYPES>; // An argument visitor that formats the argument and writes it via the output // iterator. It's a class and not a generic lambda for compatibility with C++11. template <typename Char> struct default_arg_formatter { using context = buffered_context<Char>; basic_appender<Char> out; void operator()(monostate) { report_error("argument not found"); } template <typename T, FMT_ENABLE_IF(is_builtin<T>::value)> void operator()(T value) { write<Char>(out, value); } template <typename T, FMT_ENABLE_IF(!is_builtin<T>::value)> void operator()(T) { FMT_ASSERT(false, ""); } void operator()(typename basic_format_arg<context>::handle h) { // Use a null locale since the default format must be unlocalized. auto parse_ctx = parse_context<Char>({}); auto format_ctx = context(out, {}, {}); h.format(parse_ctx, format_ctx); } }; template <typename Char> struct arg_formatter { basic_appender<Char> out; const format_specs& specs; FMT_NO_UNIQUE_ADDRESS locale_ref locale; template <typename T, FMT_ENABLE_IF(is_builtin<T>::value)> FMT_CONSTEXPR FMT_INLINE void operator()(T value) { detail::write<Char>(out, value, specs, locale); } template <typename T, FMT_ENABLE_IF(!is_builtin<T>::value)> void operator()(T) { FMT_ASSERT(false, ""); } void operator()(typename basic_format_arg<buffered_context<Char>>::handle) { // User-defined types are handled separately because they require access // to the parse context. } }; struct dynamic_spec_getter { template <typename T, FMT_ENABLE_IF(is_integer<T>::value)> FMT_CONSTEXPR auto operator()(T value) -> unsigned long long { return is_negative(value) ? ~0ull : static_cast<unsigned long long>(value); } template <typename T, FMT_ENABLE_IF(!is_integer<T>::value)> FMT_CONSTEXPR auto operator()(T) -> unsigned long long { report_error("width/precision is not integer"); return 0; } }; template <typename Context, typename ID> FMT_CONSTEXPR auto get_arg(Context& ctx, ID id) -> basic_format_arg<Context> { auto arg = ctx.arg(id); if (!arg) report_error("argument not found"); return arg; } template <typename Context> FMT_CONSTEXPR int get_dynamic_spec( arg_id_kind kind, const arg_ref<typename Context::char_type>& ref, Context& ctx) { FMT_ASSERT(kind != arg_id_kind::none, ""); auto arg = kind == arg_id_kind::index ? ctx.arg(ref.index) : ctx.arg(ref.name); if (!arg) report_error("argument not found"); unsigned long long value = arg.visit(dynamic_spec_getter()); if (value > to_unsigned(max_value<int>())) report_error("width/precision is out of range"); return static_cast<int>(value); } template <typename Context> FMT_CONSTEXPR void handle_dynamic_spec( arg_id_kind kind, int& value, const arg_ref<typename Context::char_type>& ref, Context& ctx) { if (kind != arg_id_kind::none) value = get_dynamic_spec(kind, ref, ctx); } #if FMT_USE_NONTYPE_TEMPLATE_ARGS template <typename T, typename Char, size_t N, fmt::detail::fixed_string<Char, N> Str> struct static_named_arg : view { static constexpr auto name = Str.data; const T& value; static_named_arg(const T& v) : value(v) {} }; template <typename T, typename Char, size_t N, fmt::detail::fixed_string<Char, N> Str> struct is_named_arg<static_named_arg<T, Char, N, Str>> : std::true_type {}; template <typename T, typename Char, size_t N, fmt::detail::fixed_string<Char, N> Str> struct is_static_named_arg<static_named_arg<T, Char, N, Str>> : std::true_type { }; template <typename Char, size_t N, fmt::detail::fixed_string<Char, N> Str> struct udl_arg { template <typename T> auto operator=(T&& value) const { return static_named_arg<T, Char, N, Str>(std::forward<T>(value)); } }; #else template <typename Char> struct udl_arg { const Char* str; template <typename T> auto operator=(T&& value) const -> named_arg<Char, T> { return {str, std::forward<T>(value)}; } }; #endif // FMT_USE_NONTYPE_TEMPLATE_ARGS template <typename Char> struct format_handler { parse_context<Char> parse_ctx; buffered_context<Char> ctx; void on_text(const Char* begin, const Char* end) { copy_noinline<Char>(begin, end, ctx.out()); } FMT_CONSTEXPR auto on_arg_id() -> int { return parse_ctx.next_arg_id(); } FMT_CONSTEXPR auto on_arg_id(int id) -> int { parse_ctx.check_arg_id(id); return id; } FMT_CONSTEXPR auto on_arg_id(basic_string_view<Char> id) -> int { parse_ctx.check_arg_id(id); int arg_id = ctx.arg_id(id); if (arg_id < 0) report_error("argument not found"); return arg_id; } FMT_INLINE void on_replacement_field(int id, const Char*) { ctx.arg(id).visit(default_arg_formatter<Char>{ctx.out()}); } auto on_format_specs(int id, const Char* begin, const Char* end) -> const Char* { auto arg = get_arg(ctx, id); // Not using a visitor for custom types gives better codegen. if (arg.format_custom(begin, parse_ctx, ctx)) return parse_ctx.begin(); auto specs = dynamic_format_specs<Char>(); begin = parse_format_specs(begin, end, specs, parse_ctx, arg.type()); if (specs.dynamic()) { handle_dynamic_spec(specs.dynamic_width(), specs.width, specs.width_ref, ctx); handle_dynamic_spec(specs.dynamic_precision(), specs.precision, specs.precision_ref, ctx); } arg.visit(arg_formatter<Char>{ctx.out(), specs, ctx.locale()}); return begin; } FMT_NORETURN void on_error(const char* message) { report_error(message); } }; using format_func = void (*)(detail::buffer<char>&, int, const char*); FMT_API void do_report_error(format_func func, int error_code, const char* message) noexcept; FMT_API void format_error_code(buffer<char>& out, int error_code, string_view message) noexcept; template <typename T, typename Char, type TYPE> template <typename FormatContext> FMT_CONSTEXPR auto native_formatter<T, Char, TYPE>::format( const T& val, FormatContext& ctx) const -> decltype(ctx.out()) { if (!specs_.dynamic()) return write<Char>(ctx.out(), val, specs_, ctx.locale()); auto specs = format_specs(specs_); handle_dynamic_spec(specs.dynamic_width(), specs.width, specs_.width_ref, ctx); handle_dynamic_spec(specs.dynamic_precision(), specs.precision, specs_.precision_ref, ctx); return write<Char>(ctx.out(), val, specs, ctx.locale()); } // DEPRECATED! https://github.com/fmtlib/fmt/issues/4292. template <typename T, typename Enable = void> struct is_locale : std::false_type {}; template <typename T> struct is_locale<T, void_t<decltype(T::classic())>> : std::true_type {}; // DEPRECATED! template <typename Char = char> struct vformat_args { using type = basic_format_args<buffered_context<Char>>; }; template <> struct vformat_args<char> { using type = format_args; }; template <typename Char> void vformat_to(buffer<Char>& buf, basic_string_view<Char> fmt, typename vformat_args<Char>::type args, locale_ref loc = {}) { auto out = basic_appender<Char>(buf); parse_format_string( fmt, format_handler<Char>{parse_context<Char>(fmt), {out, args, loc}}); } } // namespace detail FMT_BEGIN_EXPORT // A generic formatting context with custom output iterator and character // (code unit) support. Char is the format string code unit type which can be // different from OutputIt::value_type. template <typename OutputIt, typename Char> class generic_context { private: OutputIt out_; basic_format_args<generic_context> args_; detail::locale_ref loc_; public: using char_type = Char; using iterator = OutputIt; using parse_context_type FMT_DEPRECATED = parse_context<Char>; template <typename T> using formatter_type FMT_DEPRECATED = formatter<T, Char>; enum { builtin_types = FMT_BUILTIN_TYPES }; constexpr generic_context(OutputIt out, basic_format_args<generic_context> args, detail::locale_ref loc = {}) : out_(out), args_(args), loc_(loc) {} generic_context(generic_context&&) = default; generic_context(const generic_context&) = delete; void operator=(const generic_context&) = delete; constexpr auto arg(int id) const -> basic_format_arg<generic_context> { return args_.get(id); } auto arg(basic_string_view<Char> name) const -> basic_format_arg<generic_context> { return args_.get(name); } constexpr auto arg_id(basic_string_view<Char> name) const -> int { return args_.get_id(name); } constexpr auto out() const -> iterator { return out_; } void advance_to(iterator it) { if (!detail::is_back_insert_iterator<iterator>()) out_ = it; } constexpr auto locale() const -> detail::locale_ref { return loc_; } }; class loc_value { private: basic_format_arg<context> value_; public: template <typename T, FMT_ENABLE_IF(!detail::is_float128<T>::value)> loc_value(T value) : value_(value) {} template <typename T, FMT_ENABLE_IF(detail::is_float128<T>::value)> loc_value(T) {} template <typename Visitor> auto visit(Visitor&& vis) -> decltype(vis(0)) { return value_.visit(vis); } }; // A locale facet that formats values in UTF-8. // It is parameterized on the locale to avoid the heavy <locale> include. template <typename Locale> class format_facet : public Locale::facet { private: std::string separator_; std::string grouping_; std::string decimal_point_; protected: virtual auto do_put(appender out, loc_value val, const format_specs& specs) const -> bool; public: static FMT_API typename Locale::id id; explicit format_facet(Locale& loc); explicit format_facet(string_view sep = "", std::string grouping = "\3", std::string decimal_point = ".") : separator_(sep.data(), sep.size()), grouping_(grouping), decimal_point_(decimal_point) {} auto put(appender out, loc_value val, const format_specs& specs) const -> bool { return do_put(out, val, specs); } }; #define FMT_FORMAT_AS(Type, Base) \ template <typename Char> \ struct formatter<Type, Char> : formatter<Base, Char> { \ template <typename FormatContext> \ FMT_CONSTEXPR auto format(Type value, FormatContext& ctx) const \ -> decltype(ctx.out()) { \ return formatter<Base, Char>::format(value, ctx); \ } \ } FMT_FORMAT_AS(signed char, int); FMT_FORMAT_AS(unsigned char, unsigned); FMT_FORMAT_AS(short, int); FMT_FORMAT_AS(unsigned short, unsigned); FMT_FORMAT_AS(long, detail::long_type); FMT_FORMAT_AS(unsigned long, detail::ulong_type); FMT_FORMAT_AS(Char*, const Char*); FMT_FORMAT_AS(detail::std_string_view<Char>, basic_string_view<Char>); FMT_FORMAT_AS(std::nullptr_t, const void*); FMT_FORMAT_AS(void*, const void*); template <typename Char, size_t N> struct formatter<Char[N], Char> : formatter<basic_string_view<Char>, Char> {}; template <typename Char, typename Traits, typename Allocator> class formatter<std::basic_string<Char, Traits, Allocator>, Char> : public formatter<basic_string_view<Char>, Char> {}; template <int N, typename Char> struct formatter<detail::bitint<N>, Char> : formatter<long long, Char> {}; template <int N, typename Char> struct formatter<detail::ubitint<N>, Char> : formatter<unsigned long long, Char> {}; template <typename Char> struct formatter<detail::float128, Char> : detail::native_formatter<detail::float128, Char, detail::type::float_type> {}; template <typename T, typename Char> struct formatter<T, Char, void_t<detail::format_as_result<T>>> : formatter<detail::format_as_result<T>, Char> { template <typename FormatContext> FMT_CONSTEXPR auto format(const T& value, FormatContext& ctx) const -> decltype(ctx.out()) { auto&& val = format_as(value); // Make an lvalue reference for format. return formatter<detail::format_as_result<T>, Char>::format(val, ctx); } }; /** * Converts `p` to `const void*` for pointer formatting. * * **Example**: * * auto s = fmt::format("{}", fmt::ptr(p)); */ template <typename T> auto ptr(T p) -> const void* { static_assert(std::is_pointer<T>::value, ""); return detail::bit_cast<const void*>(p); } /** * Converts `e` to the underlying type. * * **Example**: * * enum class color { red, green, blue }; * auto s = fmt::format("{}", fmt::underlying(color::red)); // s == "0" */ template <typename Enum> constexpr auto underlying(Enum e) noexcept -> underlying_t<Enum> { return static_cast<underlying_t<Enum>>(e); } namespace enums { template <typename Enum, FMT_ENABLE_IF(std::is_enum<Enum>::value)> constexpr auto format_as(Enum e) noexcept -> underlying_t<Enum> { return static_cast<underlying_t<Enum>>(e); } } // namespace enums #ifdef __cpp_lib_byte template <> struct formatter<std::byte> : formatter<unsigned> { static auto format_as(std::byte b) -> unsigned char { return static_cast<unsigned char>(b); } template <typename Context> auto format(std::byte b, Context& ctx) const -> decltype(ctx.out()) { return formatter<unsigned>::format(format_as(b), ctx); } }; #endif struct bytes { string_view data; inline explicit bytes(string_view s) : data(s) {} }; template <> struct formatter<bytes> { private: detail::dynamic_format_specs<> specs_; public: FMT_CONSTEXPR auto parse(parse_context<>& ctx) -> const char* { return parse_format_specs(ctx.begin(), ctx.end(), specs_, ctx, detail::type::string_type); } template <typename FormatContext> auto format(bytes b, FormatContext& ctx) const -> decltype(ctx.out()) { auto specs = specs_; detail::handle_dynamic_spec(specs.dynamic_width(), specs.width, specs.width_ref, ctx); detail::handle_dynamic_spec(specs.dynamic_precision(), specs.precision, specs.precision_ref, ctx); return detail::write_bytes<char>(ctx.out(), b.data, specs); } }; // group_digits_view is not derived from view because it copies the argument. template <typename T> struct group_digits_view { T value; }; /** * Returns a view that formats an integer value using ',' as a * locale-independent thousands separator. * * **Example**: * * fmt::print("{}", fmt::group_digits(12345)); * // Output: "12,345" */ template <typename T> auto group_digits(T value) -> group_digits_view<T> { return {value}; } template <typename T> struct formatter<group_digits_view<T>> : formatter<T> { private: detail::dynamic_format_specs<> specs_; public: FMT_CONSTEXPR auto parse(parse_context<>& ctx) -> const char* { return parse_format_specs(ctx.begin(), ctx.end(), specs_, ctx, detail::type::int_type); } template <typename FormatContext> auto format(group_digits_view<T> view, FormatContext& ctx) const -> decltype(ctx.out()) { auto specs = specs_; detail::handle_dynamic_spec(specs.dynamic_width(), specs.width, specs.width_ref, ctx); detail::handle_dynamic_spec(specs.dynamic_precision(), specs.precision, specs.precision_ref, ctx); auto arg = detail::make_write_int_arg(view.value, specs.sign()); return detail::write_int( ctx.out(), static_cast<detail::uint64_or_128_t<T>>(arg.abs_value), arg.prefix, specs, detail::digit_grouping<char>("\3", ",")); } }; template <typename T, typename Char> struct nested_view { const formatter<T, Char>* fmt; const T* value; }; template <typename T, typename Char> struct formatter<nested_view<T, Char>, Char> { FMT_CONSTEXPR auto parse(parse_context<Char>& ctx) -> const Char* { return ctx.begin(); } template <typename FormatContext> auto format(nested_view<T, Char> view, FormatContext& ctx) const -> decltype(ctx.out()) { return view.fmt->format(*view.value, ctx); } }; template <typename T, typename Char = char> struct nested_formatter { private: basic_specs specs_; int width_; formatter<T, Char> formatter_; public: constexpr nested_formatter() : width_(0) {} FMT_CONSTEXPR auto parse(parse_context<Char>& ctx) -> const Char* { auto it = ctx.begin(), end = ctx.end(); if (it == end) return it; auto specs = format_specs(); it = detail::parse_align(it, end, specs); specs_ = specs; Char c = *it; auto width_ref = detail::arg_ref<Char>(); if ((c >= '0' && c <= '9') || c == '{') { it = detail::parse_width(it, end, specs, width_ref, ctx); width_ = specs.width; } ctx.advance_to(it); return formatter_.parse(ctx); } template <typename FormatContext, typename F> auto write_padded(FormatContext& ctx, F write) const -> decltype(ctx.out()) { if (width_ == 0) return write(ctx.out()); auto buf = basic_memory_buffer<Char>(); write(basic_appender<Char>(buf)); auto specs = format_specs(); specs.width = width_; specs.copy_fill_from(specs_); specs.set_align(specs_.align()); return detail::write<Char>( ctx.out(), basic_string_view<Char>(buf.data(), buf.size()), specs); } auto nested(const T& value) const -> nested_view<T, Char> { return nested_view<T, Char>{&formatter_, &value}; } }; inline namespace literals { #if FMT_USE_NONTYPE_TEMPLATE_ARGS template <detail::fixed_string S> constexpr auto operator""_a() { using char_t = remove_cvref_t<decltype(*S.data)>; return detail::udl_arg<char_t, sizeof(S.data) / sizeof(char_t), S>(); } #else /** * User-defined literal equivalent of `fmt::arg`. * * **Example**: * * using namespace fmt::literals; * fmt::print("The answer is {answer}.", "answer"_a=42); */ constexpr auto operator""_a(const char* s, size_t) -> detail::udl_arg<char> { return {s}; } #endif // FMT_USE_NONTYPE_TEMPLATE_ARGS } // namespace literals /// A fast integer formatter. class format_int { private: // Buffer should be large enough to hold all digits (digits10 + 1), // a sign and a null character. enum { buffer_size = std::numeric_limits<unsigned long long>::digits10 + 3 }; mutable char buffer_[buffer_size]; char* str_; template <typename UInt> FMT_CONSTEXPR20 auto format_unsigned(UInt value) -> char* { auto n = static_cast<detail::uint32_or_64_or_128_t<UInt>>(value); return detail::do_format_decimal(buffer_, n, buffer_size - 1); } template <typename Int> FMT_CONSTEXPR20 auto format_signed(Int value) -> char* { auto abs_value = static_cast<detail::uint32_or_64_or_128_t<Int>>(value); bool negative = value < 0; if (negative) abs_value = 0 - abs_value; auto begin = format_unsigned(abs_value); if (negative) *--begin = '-'; return begin; } public: FMT_CONSTEXPR20 explicit format_int(int value) : str_(format_signed(value)) {} FMT_CONSTEXPR20 explicit format_int(long value) : str_(format_signed(value)) {} FMT_CONSTEXPR20 explicit format_int(long long value) : str_(format_signed(value)) {} FMT_CONSTEXPR20 explicit format_int(unsigned value) : str_(format_unsigned(value)) {} FMT_CONSTEXPR20 explicit format_int(unsigned long value) : str_(format_unsigned(value)) {} FMT_CONSTEXPR20 explicit format_int(unsigned long long value) : str_(format_unsigned(value)) {} /// Returns the number of characters written to the output buffer. FMT_CONSTEXPR20 auto size() const -> size_t { return detail::to_unsigned(buffer_ - str_ + buffer_size - 1); } /// Returns a pointer to the output buffer content. No terminating null /// character is appended. FMT_CONSTEXPR20 auto data() const -> const char* { return str_; } /// Returns a pointer to the output buffer content with terminating null /// character appended. FMT_CONSTEXPR20 auto c_str() const -> const char* { buffer_[buffer_size - 1] = '\0'; return str_; } /// Returns the content of the output buffer as an `std::string`. inline auto str() const -> std::string { return {str_, size()}; } }; #define FMT_STRING_IMPL(s, base) \ [] { \ /* Use the hidden visibility as a workaround for a GCC bug (#1973). */ \ /* Use a macro-like name to avoid shadowing warnings. */ \ struct FMT_VISIBILITY("hidden") FMT_COMPILE_STRING : base { \ using char_type = fmt::remove_cvref_t<decltype(s[0])>; \ constexpr explicit operator fmt::basic_string_view<char_type>() const { \ return fmt::detail::compile_string_to_view<char_type>(s); \ } \ }; \ using FMT_STRING_VIEW = \ fmt::basic_string_view<typename FMT_COMPILE_STRING::char_type>; \ fmt::detail::ignore_unused(FMT_STRING_VIEW(FMT_COMPILE_STRING())); \ return FMT_COMPILE_STRING(); \ }() /** * Constructs a legacy compile-time format string from a string literal `s`. * * **Example**: * * // A compile-time error because 'd' is an invalid specifier for strings. * std::string s = fmt::format(FMT_STRING("{:d}"), "foo"); */ #define FMT_STRING(s) FMT_STRING_IMPL(s, fmt::detail::compile_string) FMT_API auto vsystem_error(int error_code, string_view fmt, format_args args) -> std::system_error; /** * Constructs `std::system_error` with a message formatted with * `fmt::format(fmt, args...)`. * `error_code` is a system error code as given by `errno`. * * **Example**: * * // This throws std::system_error with the description * // cannot open file 'madeup': No such file or directory * // or similar (system message may vary). * const char* filename = "madeup"; * FILE* file = fopen(filename, "r"); * if (!file) * throw fmt::system_error(errno, "cannot open file '{}'", filename); */ template <typename... T> auto system_error(int error_code, format_string<T...> fmt, T&&... args) -> std::system_error { return vsystem_error(error_code, fmt.str, vargs<T...>{{args...}}); } /** * Formats an error message for an error returned by an operating system or a * language runtime, for example a file opening error, and writes it to `out`. * The format is the same as the one used by `std::system_error(ec, message)` * where `ec` is `std::error_code(error_code, std::generic_category())`. * It is implementation-defined but normally looks like: * * <message>: <system-message> * * where `<message>` is the passed message and `<system-message>` is the system * message corresponding to the error code. * `error_code` is a system error code as given by `errno`. */ FMT_API void format_system_error(detail::buffer<char>& out, int error_code, const char* message) noexcept; // Reports a system error without throwing an exception. // Can be used to report errors from destructors. FMT_API void report_system_error(int error_code, const char* message) noexcept; template <typename Locale, FMT_ENABLE_IF(detail::is_locale<Locale>::value)> inline auto vformat(const Locale& loc, string_view fmt, format_args args) -> std::string { auto buf = memory_buffer(); detail::vformat_to(buf, fmt, args, detail::locale_ref(loc)); return {buf.data(), buf.size()}; } template <typename Locale, typename... T, FMT_ENABLE_IF(detail::is_locale<Locale>::value)> FMT_INLINE auto format(const Locale& loc, format_string<T...> fmt, T&&... args) -> std::string { return vformat(loc, fmt.str, vargs<T...>{{args...}}); } template <typename OutputIt, typename Locale, FMT_ENABLE_IF(detail::is_output_iterator<OutputIt, char>::value)> auto vformat_to(OutputIt out, const Locale& loc, string_view fmt, format_args args) -> OutputIt { auto&& buf = detail::get_buffer<char>(out); detail::vformat_to(buf, fmt, args, detail::locale_ref(loc)); return detail::get_iterator(buf, out); } template <typename OutputIt, typename Locale, typename... T, FMT_ENABLE_IF(detail::is_output_iterator<OutputIt, char>::value&& detail::is_locale<Locale>::value)> FMT_INLINE auto format_to(OutputIt out, const Locale& loc, format_string<T...> fmt, T&&... args) -> OutputIt { return fmt::vformat_to(out, loc, fmt.str, vargs<T...>{{args...}}); } template <typename Locale, typename... T, FMT_ENABLE_IF(detail::is_locale<Locale>::value)> FMT_NODISCARD FMT_INLINE auto formatted_size(const Locale& loc, format_string<T...> fmt, T&&... args) -> size_t { auto buf = detail::counting_buffer<>(); detail::vformat_to(buf, fmt.str, vargs<T...>{{args...}}, detail::locale_ref(loc)); return buf.count(); } FMT_API auto vformat(string_view fmt, format_args args) -> std::string; /** * Formats `args` according to specifications in `fmt` and returns the result * as a string. * * **Example**: * * #include <fmt/format.h> * std::string message = fmt::format("The answer is {}.", 42); */ template <typename... T> FMT_NODISCARD FMT_INLINE auto format(format_string<T...> fmt, T&&... args) -> std::string { return vformat(fmt.str, vargs<T...>{{args...}}); } /** * Converts `value` to `std::string` using the default format for type `T`. * * **Example**: * * std::string answer = fmt::to_string(42); */ template <typename T, FMT_ENABLE_IF(std::is_integral<T>::value)> FMT_NODISCARD auto to_string(T value) -> std::string { // The buffer should be large enough to store the number including the sign // or "false" for bool. char buffer[max_of(detail::digits10<T>() + 2, 5)]; return {buffer, detail::write<char>(buffer, value)}; } template <typename T, FMT_ENABLE_IF(detail::use_format_as<T>::value)> FMT_NODISCARD auto to_string(const T& value) -> std::string { return to_string(format_as(value)); } template <typename T, FMT_ENABLE_IF(!std::is_integral<T>::value && !detail::use_format_as<T>::value)> FMT_NODISCARD auto to_string(const T& value) -> std::string { auto buffer = memory_buffer(); detail::write<char>(appender(buffer), value); return {buffer.data(), buffer.size()}; } FMT_END_EXPORT FMT_END_NAMESPACE #ifdef FMT_HEADER_ONLY # define FMT_FUNC inline # include "format-inl.h" #endif // Restore _LIBCPP_REMOVE_TRANSITIVE_INCLUDES. #ifdef FMT_REMOVE_TRANSITIVE_INCLUDES # undef _LIBCPP_REMOVE_TRANSITIVE_INCLUDES #endif #endif // FMT_FORMAT_H_ ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/vendor/fmt/os.h����������������������������������������������������������������������0000664�0000000�0000000�00000030762�14771603147�0016234�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������// Formatting library for C++ - optional OS-specific functionality // // Copyright (c) 2012 - present, Victor Zverovich // All rights reserved. // // For the license information refer to format.h. #ifndef FMT_OS_H_ #define FMT_OS_H_ #include "format.h" #ifndef FMT_MODULE # include <cerrno> # include <cstddef> # include <cstdio> # include <system_error> // std::system_error # if FMT_HAS_INCLUDE(<xlocale.h>) # include <xlocale.h> // LC_NUMERIC_MASK on macOS # endif #endif // FMT_MODULE #ifndef FMT_USE_FCNTL // UWP doesn't provide _pipe. # if FMT_HAS_INCLUDE("winapifamily.h") # include <winapifamily.h> # endif # if (FMT_HAS_INCLUDE(<fcntl.h>) || defined(__APPLE__) || \ defined(__linux__)) && \ (!defined(WINAPI_FAMILY) || \ (WINAPI_FAMILY == WINAPI_FAMILY_DESKTOP_APP)) # include <fcntl.h> // for O_RDONLY # define FMT_USE_FCNTL 1 # else # define FMT_USE_FCNTL 0 # endif #endif #ifndef FMT_POSIX # if defined(_WIN32) && !defined(__MINGW32__) // Fix warnings about deprecated symbols. # define FMT_POSIX(call) _##call # else # define FMT_POSIX(call) call # endif #endif // Calls to system functions are wrapped in FMT_SYSTEM for testability. #ifdef FMT_SYSTEM # define FMT_HAS_SYSTEM # define FMT_POSIX_CALL(call) FMT_SYSTEM(call) #else # define FMT_SYSTEM(call) ::call # ifdef _WIN32 // Fix warnings about deprecated symbols. # define FMT_POSIX_CALL(call) ::_##call # else # define FMT_POSIX_CALL(call) ::call # endif #endif // Retries the expression while it evaluates to error_result and errno // equals to EINTR. #ifndef _WIN32 # define FMT_RETRY_VAL(result, expression, error_result) \ do { \ (result) = (expression); \ } while ((result) == (error_result) && errno == EINTR) #else # define FMT_RETRY_VAL(result, expression, error_result) result = (expression) #endif #define FMT_RETRY(result, expression) FMT_RETRY_VAL(result, expression, -1) FMT_BEGIN_NAMESPACE FMT_BEGIN_EXPORT /** * A reference to a null-terminated string. It can be constructed from a C * string or `std::string`. * * You can use one of the following type aliases for common character types: * * +---------------+-----------------------------+ * | Type | Definition | * +===============+=============================+ * | cstring_view | basic_cstring_view<char> | * +---------------+-----------------------------+ * | wcstring_view | basic_cstring_view<wchar_t> | * +---------------+-----------------------------+ * * This class is most useful as a parameter type for functions that wrap C APIs. */ template <typename Char> class basic_cstring_view { private: const Char* data_; public: /// Constructs a string reference object from a C string. basic_cstring_view(const Char* s) : data_(s) {} /// Constructs a string reference from an `std::string` object. basic_cstring_view(const std::basic_string<Char>& s) : data_(s.c_str()) {} /// Returns the pointer to a C string. auto c_str() const -> const Char* { return data_; } }; using cstring_view = basic_cstring_view<char>; using wcstring_view = basic_cstring_view<wchar_t>; #ifdef _WIN32 FMT_API const std::error_category& system_category() noexcept; namespace detail { FMT_API void format_windows_error(buffer<char>& out, int error_code, const char* message) noexcept; } FMT_API std::system_error vwindows_error(int error_code, string_view fmt, format_args args); /** * Constructs a `std::system_error` object with the description of the form * * <message>: <system-message> * * where `<message>` is the formatted message and `<system-message>` is the * system message corresponding to the error code. * `error_code` is a Windows error code as given by `GetLastError`. * If `error_code` is not a valid error code such as -1, the system message * will look like "error -1". * * **Example**: * * // This throws a system_error with the description * // cannot open file 'madeup': The system cannot find the file * specified. * // or similar (system message may vary). * const char *filename = "madeup"; * LPOFSTRUCT of = LPOFSTRUCT(); * HFILE file = OpenFile(filename, &of, OF_READ); * if (file == HFILE_ERROR) { * throw fmt::windows_error(GetLastError(), * "cannot open file '{}'", filename); * } */ template <typename... T> auto windows_error(int error_code, string_view message, const T&... args) -> std::system_error { return vwindows_error(error_code, message, vargs<T...>{{args...}}); } // Reports a Windows error without throwing an exception. // Can be used to report errors from destructors. FMT_API void report_windows_error(int error_code, const char* message) noexcept; #else inline auto system_category() noexcept -> const std::error_category& { return std::system_category(); } #endif // _WIN32 // std::system is not available on some platforms such as iOS (#2248). #ifdef __OSX__ template <typename S, typename... Args, typename Char = char_t<S>> void say(const S& fmt, Args&&... args) { std::system(format("say \"{}\"", format(fmt, args...)).c_str()); } #endif // A buffered file. class buffered_file { private: FILE* file_; friend class file; inline explicit buffered_file(FILE* f) : file_(f) {} public: buffered_file(const buffered_file&) = delete; void operator=(const buffered_file&) = delete; // Constructs a buffered_file object which doesn't represent any file. inline buffered_file() noexcept : file_(nullptr) {} // Destroys the object closing the file it represents if any. FMT_API ~buffered_file() noexcept; public: inline buffered_file(buffered_file&& other) noexcept : file_(other.file_) { other.file_ = nullptr; } inline auto operator=(buffered_file&& other) -> buffered_file& { close(); file_ = other.file_; other.file_ = nullptr; return *this; } // Opens a file. FMT_API buffered_file(cstring_view filename, cstring_view mode); // Closes the file. FMT_API void close(); // Returns the pointer to a FILE object representing this file. inline auto get() const noexcept -> FILE* { return file_; } FMT_API auto descriptor() const -> int; template <typename... T> inline void print(string_view fmt, const T&... args) { fmt::vargs<T...> vargs = {{args...}}; detail::is_locking<T...>() ? fmt::vprint_buffered(file_, fmt, vargs) : fmt::vprint(file_, fmt, vargs); } }; #if FMT_USE_FCNTL // A file. Closed file is represented by a file object with descriptor -1. // Methods that are not declared with noexcept may throw // fmt::system_error in case of failure. Note that some errors such as // closing the file multiple times will cause a crash on Windows rather // than an exception. You can get standard behavior by overriding the // invalid parameter handler with _set_invalid_parameter_handler. class FMT_API file { private: int fd_; // File descriptor. // Constructs a file object with a given descriptor. explicit file(int fd) : fd_(fd) {} friend struct pipe; public: // Possible values for the oflag argument to the constructor. enum { RDONLY = FMT_POSIX(O_RDONLY), // Open for reading only. WRONLY = FMT_POSIX(O_WRONLY), // Open for writing only. RDWR = FMT_POSIX(O_RDWR), // Open for reading and writing. CREATE = FMT_POSIX(O_CREAT), // Create if the file doesn't exist. APPEND = FMT_POSIX(O_APPEND), // Open in append mode. TRUNC = FMT_POSIX(O_TRUNC) // Truncate the content of the file. }; // Constructs a file object which doesn't represent any file. inline file() noexcept : fd_(-1) {} // Opens a file and constructs a file object representing this file. file(cstring_view path, int oflag); public: file(const file&) = delete; void operator=(const file&) = delete; inline file(file&& other) noexcept : fd_(other.fd_) { other.fd_ = -1; } // Move assignment is not noexcept because close may throw. inline auto operator=(file&& other) -> file& { close(); fd_ = other.fd_; other.fd_ = -1; return *this; } // Destroys the object closing the file it represents if any. ~file() noexcept; // Returns the file descriptor. inline auto descriptor() const noexcept -> int { return fd_; } // Closes the file. void close(); // Returns the file size. The size has signed type for consistency with // stat::st_size. auto size() const -> long long; // Attempts to read count bytes from the file into the specified buffer. auto read(void* buffer, size_t count) -> size_t; // Attempts to write count bytes from the specified buffer to the file. auto write(const void* buffer, size_t count) -> size_t; // Duplicates a file descriptor with the dup function and returns // the duplicate as a file object. static auto dup(int fd) -> file; // Makes fd be the copy of this file descriptor, closing fd first if // necessary. void dup2(int fd); // Makes fd be the copy of this file descriptor, closing fd first if // necessary. void dup2(int fd, std::error_code& ec) noexcept; // Creates a buffered_file object associated with this file and detaches // this file object from the file. auto fdopen(const char* mode) -> buffered_file; # if defined(_WIN32) && !defined(__MINGW32__) // Opens a file and constructs a file object representing this file by // wcstring_view filename. Windows only. static file open_windows_file(wcstring_view path, int oflag); # endif }; struct FMT_API pipe { file read_end; file write_end; // Creates a pipe setting up read_end and write_end file objects for reading // and writing respectively. pipe(); }; // Returns the memory page size. auto getpagesize() -> long; namespace detail { struct buffer_size { constexpr buffer_size() = default; size_t value = 0; FMT_CONSTEXPR auto operator=(size_t val) const -> buffer_size { auto bs = buffer_size(); bs.value = val; return bs; } }; struct ostream_params { int oflag = file::WRONLY | file::CREATE | file::TRUNC; size_t buffer_size = BUFSIZ > 32768 ? BUFSIZ : 32768; constexpr ostream_params() {} template <typename... T> ostream_params(T... params, int new_oflag) : ostream_params(params...) { oflag = new_oflag; } template <typename... T> ostream_params(T... params, detail::buffer_size bs) : ostream_params(params...) { this->buffer_size = bs.value; } // Intel has a bug that results in failure to deduce a constructor // for empty parameter packs. # if defined(__INTEL_COMPILER) && __INTEL_COMPILER < 2000 ostream_params(int new_oflag) : oflag(new_oflag) {} ostream_params(detail::buffer_size bs) : buffer_size(bs.value) {} # endif }; } // namespace detail FMT_INLINE_VARIABLE constexpr auto buffer_size = detail::buffer_size(); /// A fast buffered output stream for writing from a single thread. Writing from /// multiple threads without external synchronization may result in a data race. class FMT_API ostream : private detail::buffer<char> { private: file file_; ostream(cstring_view path, const detail::ostream_params& params); static void grow(buffer<char>& buf, size_t); public: ostream(ostream&& other) noexcept; ~ostream(); operator writer() { detail::buffer<char>& buf = *this; return buf; } inline void flush() { if (size() == 0) return; file_.write(data(), size() * sizeof(data()[0])); clear(); } template <typename... T> friend auto output_file(cstring_view path, T... params) -> ostream; inline void close() { flush(); file_.close(); } /// Formats `args` according to specifications in `fmt` and writes the /// output to the file. template <typename... T> void print(format_string<T...> fmt, T&&... args) { vformat_to(appender(*this), fmt.str, vargs<T...>{{args...}}); } }; /** * Opens a file for writing. Supported parameters passed in `params`: * * - `<integer>`: Flags passed to [open]( * https://pubs.opengroup.org/onlinepubs/007904875/functions/open.html) * (`file::WRONLY | file::CREATE | file::TRUNC` by default) * - `buffer_size=<integer>`: Output buffer size * * **Example**: * * auto out = fmt::output_file("guide.txt"); * out.print("Don't {}", "Panic"); */ template <typename... T> inline auto output_file(cstring_view path, T... params) -> ostream { return {path, detail::ostream_params(params...)}; } #endif // FMT_USE_FCNTL FMT_END_EXPORT FMT_END_NAMESPACE #endif // FMT_OS_H_ ��������������inspircd-4.7.0/vendor/fmt/ostream.h�����������������������������������������������������������������0000664�0000000�0000000�00000011607�14771603147�0017262�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������// Formatting library for C++ - std::ostream support // // Copyright (c) 2012 - present, Victor Zverovich // All rights reserved. // // For the license information refer to format.h. #ifndef FMT_OSTREAM_H_ #define FMT_OSTREAM_H_ #ifndef FMT_MODULE # include <fstream> // std::filebuf #endif #ifdef _WIN32 # ifdef __GLIBCXX__ # include <ext/stdio_filebuf.h> # include <ext/stdio_sync_filebuf.h> # endif # include <io.h> #endif #include "chrono.h" // formatbuf #ifdef _MSVC_STL_UPDATE # define FMT_MSVC_STL_UPDATE _MSVC_STL_UPDATE #elif defined(_MSC_VER) && _MSC_VER < 1912 // VS 15.5 # define FMT_MSVC_STL_UPDATE _MSVC_LANG #else # define FMT_MSVC_STL_UPDATE 0 #endif FMT_BEGIN_NAMESPACE namespace detail { // Generate a unique explicit instantion in every translation unit using a tag // type in an anonymous namespace. namespace { struct file_access_tag {}; } // namespace template <typename Tag, typename BufType, FILE* BufType::*FileMemberPtr> class file_access { friend auto get_file(BufType& obj) -> FILE* { return obj.*FileMemberPtr; } }; #if FMT_MSVC_STL_UPDATE template class file_access<file_access_tag, std::filebuf, &std::filebuf::_Myfile>; auto get_file(std::filebuf&) -> FILE*; #endif // Write the content of buf to os. // It is a separate function rather than a part of vprint to simplify testing. template <typename Char> void write_buffer(std::basic_ostream<Char>& os, buffer<Char>& buf) { const Char* buf_data = buf.data(); using unsigned_streamsize = make_unsigned_t<std::streamsize>; unsigned_streamsize size = buf.size(); unsigned_streamsize max_size = to_unsigned(max_value<std::streamsize>()); do { unsigned_streamsize n = size <= max_size ? size : max_size; os.write(buf_data, static_cast<std::streamsize>(n)); buf_data += n; size -= n; } while (size != 0); } template <typename T> struct streamed_view { const T& value; }; } // namespace detail // Formats an object of type T that has an overloaded ostream operator<<. template <typename Char> struct basic_ostream_formatter : formatter<basic_string_view<Char>, Char> { void set_debug_format() = delete; template <typename T, typename Context> auto format(const T& value, Context& ctx) const -> decltype(ctx.out()) { auto buffer = basic_memory_buffer<Char>(); auto&& formatbuf = detail::formatbuf<std::basic_streambuf<Char>>(buffer); auto&& output = std::basic_ostream<Char>(&formatbuf); output.imbue(std::locale::classic()); // The default is always unlocalized. output << value; output.exceptions(std::ios_base::failbit | std::ios_base::badbit); return formatter<basic_string_view<Char>, Char>::format( {buffer.data(), buffer.size()}, ctx); } }; using ostream_formatter = basic_ostream_formatter<char>; template <typename T, typename Char> struct formatter<detail::streamed_view<T>, Char> : basic_ostream_formatter<Char> { template <typename Context> auto format(detail::streamed_view<T> view, Context& ctx) const -> decltype(ctx.out()) { return basic_ostream_formatter<Char>::format(view.value, ctx); } }; /** * Returns a view that formats `value` via an ostream `operator<<`. * * **Example**: * * fmt::print("Current thread id: {}\n", * fmt::streamed(std::this_thread::get_id())); */ template <typename T> constexpr auto streamed(const T& value) -> detail::streamed_view<T> { return {value}; } inline void vprint(std::ostream& os, string_view fmt, format_args args) { auto buffer = memory_buffer(); detail::vformat_to(buffer, fmt, args); FILE* f = nullptr; #if FMT_MSVC_STL_UPDATE && FMT_USE_RTTI if (auto* buf = dynamic_cast<std::filebuf*>(os.rdbuf())) f = detail::get_file(*buf); #elif defined(_WIN32) && defined(__GLIBCXX__) && FMT_USE_RTTI auto* rdbuf = os.rdbuf(); if (auto* sfbuf = dynamic_cast<__gnu_cxx::stdio_sync_filebuf<char>*>(rdbuf)) f = sfbuf->file(); else if (auto* fbuf = dynamic_cast<__gnu_cxx::stdio_filebuf<char>*>(rdbuf)) f = fbuf->file(); #endif #ifdef _WIN32 if (f) { int fd = _fileno(f); if (_isatty(fd)) { os.flush(); if (detail::write_console(fd, {buffer.data(), buffer.size()})) return; } } #endif detail::ignore_unused(f); detail::write_buffer(os, buffer); } /** * Prints formatted data to the stream `os`. * * **Example**: * * fmt::print(cerr, "Don't {}!", "panic"); */ FMT_EXPORT template <typename... T> void print(std::ostream& os, format_string<T...> fmt, T&&... args) { fmt::vargs<T...> vargs = {{args...}}; if (detail::const_check(detail::use_utf8)) return vprint(os, fmt.str, vargs); auto buffer = memory_buffer(); detail::vformat_to(buffer, fmt.str, vargs); detail::write_buffer(os, buffer); } FMT_EXPORT template <typename... T> void println(std::ostream& os, format_string<T...> fmt, T&&... args) { fmt::print(os, "{}\n", fmt::format(fmt, std::forward<T>(args)...)); } FMT_END_NAMESPACE #endif // FMT_OSTREAM_H_ �������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/vendor/fmt/printf.h������������������������������������������������������������������0000664�0000000�0000000�00000047730�14771603147�0017120�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������// Formatting library for C++ - legacy printf implementation // // Copyright (c) 2012 - 2016, Victor Zverovich // All rights reserved. // // For the license information refer to format.h. #ifndef FMT_PRINTF_H_ #define FMT_PRINTF_H_ #ifndef FMT_MODULE # include <algorithm> // std::max # include <limits> // std::numeric_limits #endif #include "format.h" FMT_BEGIN_NAMESPACE FMT_BEGIN_EXPORT template <typename T> struct printf_formatter { printf_formatter() = delete; }; template <typename Char> class basic_printf_context { private: basic_appender<Char> out_; basic_format_args<basic_printf_context> args_; static_assert(std::is_same<Char, char>::value || std::is_same<Char, wchar_t>::value, "Unsupported code unit type."); public: using char_type = Char; using parse_context_type = parse_context<Char>; template <typename T> using formatter_type = printf_formatter<T>; enum { builtin_types = 1 }; /// Constructs a `printf_context` object. References to the arguments are /// stored in the context object so make sure they have appropriate lifetimes. basic_printf_context(basic_appender<Char> out, basic_format_args<basic_printf_context> args) : out_(out), args_(args) {} auto out() -> basic_appender<Char> { return out_; } void advance_to(basic_appender<Char>) {} auto locale() -> detail::locale_ref { return {}; } auto arg(int id) const -> basic_format_arg<basic_printf_context> { return args_.get(id); } }; namespace detail { // Return the result via the out param to workaround gcc bug 77539. template <bool IS_CONSTEXPR, typename T, typename Ptr = const T*> FMT_CONSTEXPR auto find(Ptr first, Ptr last, T value, Ptr& out) -> bool { for (out = first; out != last; ++out) { if (*out == value) return true; } return false; } template <> inline auto find<false, char>(const char* first, const char* last, char value, const char*& out) -> bool { out = static_cast<const char*>(memchr(first, value, to_unsigned(last - first))); return out != nullptr; } // Checks if a value fits in int - used to avoid warnings about comparing // signed and unsigned integers. template <bool IsSigned> struct int_checker { template <typename T> static auto fits_in_int(T value) -> bool { unsigned max = to_unsigned(max_value<int>()); return value <= max; } inline static auto fits_in_int(bool) -> bool { return true; } }; template <> struct int_checker<true> { template <typename T> static auto fits_in_int(T value) -> bool { return value >= (std::numeric_limits<int>::min)() && value <= max_value<int>(); } inline static auto fits_in_int(int) -> bool { return true; } }; struct printf_precision_handler { template <typename T, FMT_ENABLE_IF(std::is_integral<T>::value)> auto operator()(T value) -> int { if (!int_checker<std::numeric_limits<T>::is_signed>::fits_in_int(value)) report_error("number is too big"); return (std::max)(static_cast<int>(value), 0); } template <typename T, FMT_ENABLE_IF(!std::is_integral<T>::value)> auto operator()(T) -> int { report_error("precision is not integer"); return 0; } }; // An argument visitor that returns true iff arg is a zero integer. struct is_zero_int { template <typename T, FMT_ENABLE_IF(std::is_integral<T>::value)> auto operator()(T value) -> bool { return value == 0; } template <typename T, FMT_ENABLE_IF(!std::is_integral<T>::value)> auto operator()(T) -> bool { return false; } }; template <typename T> struct make_unsigned_or_bool : std::make_unsigned<T> {}; template <> struct make_unsigned_or_bool<bool> { using type = bool; }; template <typename T, typename Context> class arg_converter { private: using char_type = typename Context::char_type; basic_format_arg<Context>& arg_; char_type type_; public: arg_converter(basic_format_arg<Context>& arg, char_type type) : arg_(arg), type_(type) {} void operator()(bool value) { if (type_ != 's') operator()<bool>(value); } template <typename U, FMT_ENABLE_IF(std::is_integral<U>::value)> void operator()(U value) { bool is_signed = type_ == 'd' || type_ == 'i'; using target_type = conditional_t<std::is_same<T, void>::value, U, T>; if (const_check(sizeof(target_type) <= sizeof(int))) { // Extra casts are used to silence warnings. using unsigned_type = typename make_unsigned_or_bool<target_type>::type; if (is_signed) arg_ = static_cast<int>(static_cast<target_type>(value)); else arg_ = static_cast<unsigned>(static_cast<unsigned_type>(value)); } else { // glibc's printf doesn't sign extend arguments of smaller types: // std::printf("%lld", -42); // prints "4294967254" // but we don't have to do the same because it's a UB. if (is_signed) arg_ = static_cast<long long>(value); else arg_ = static_cast<typename make_unsigned_or_bool<U>::type>(value); } } template <typename U, FMT_ENABLE_IF(!std::is_integral<U>::value)> void operator()(U) {} // No conversion needed for non-integral types. }; // Converts an integer argument to T for printf, if T is an integral type. // If T is void, the argument is converted to corresponding signed or unsigned // type depending on the type specifier: 'd' and 'i' - signed, other - // unsigned). template <typename T, typename Context, typename Char> void convert_arg(basic_format_arg<Context>& arg, Char type) { arg.visit(arg_converter<T, Context>(arg, type)); } // Converts an integer argument to char for printf. template <typename Context> class char_converter { private: basic_format_arg<Context>& arg_; public: explicit char_converter(basic_format_arg<Context>& arg) : arg_(arg) {} template <typename T, FMT_ENABLE_IF(std::is_integral<T>::value)> void operator()(T value) { arg_ = static_cast<typename Context::char_type>(value); } template <typename T, FMT_ENABLE_IF(!std::is_integral<T>::value)> void operator()(T) {} // No conversion needed for non-integral types. }; // An argument visitor that return a pointer to a C string if argument is a // string or null otherwise. template <typename Char> struct get_cstring { template <typename T> auto operator()(T) -> const Char* { return nullptr; } auto operator()(const Char* s) -> const Char* { return s; } }; // Checks if an argument is a valid printf width specifier and sets // left alignment if it is negative. class printf_width_handler { private: format_specs& specs_; public: inline explicit printf_width_handler(format_specs& specs) : specs_(specs) {} template <typename T, FMT_ENABLE_IF(std::is_integral<T>::value)> auto operator()(T value) -> unsigned { auto width = static_cast<uint32_or_64_or_128_t<T>>(value); if (detail::is_negative(value)) { specs_.set_align(align::left); width = 0 - width; } unsigned int_max = to_unsigned(max_value<int>()); if (width > int_max) report_error("number is too big"); return static_cast<unsigned>(width); } template <typename T, FMT_ENABLE_IF(!std::is_integral<T>::value)> auto operator()(T) -> unsigned { report_error("width is not integer"); return 0; } }; // Workaround for a bug with the XL compiler when initializing // printf_arg_formatter's base class. template <typename Char> auto make_arg_formatter(basic_appender<Char> iter, format_specs& s) -> arg_formatter<Char> { return {iter, s, locale_ref()}; } // The `printf` argument formatter. template <typename Char> class printf_arg_formatter : public arg_formatter<Char> { private: using base = arg_formatter<Char>; using context_type = basic_printf_context<Char>; context_type& context_; void write_null_pointer(bool is_string = false) { auto s = this->specs; s.set_type(presentation_type::none); write_bytes<Char>(this->out, is_string ? "(null)" : "(nil)", s); } template <typename T> void write(T value) { detail::write<Char>(this->out, value, this->specs, this->locale); } public: printf_arg_formatter(basic_appender<Char> iter, format_specs& s, context_type& ctx) : base(make_arg_formatter(iter, s)), context_(ctx) {} void operator()(monostate value) { write(value); } template <typename T, FMT_ENABLE_IF(detail::is_integral<T>::value)> void operator()(T value) { // MSVC2013 fails to compile separate overloads for bool and Char so use // std::is_same instead. if (!std::is_same<T, Char>::value) { write(value); return; } format_specs s = this->specs; if (s.type() != presentation_type::none && s.type() != presentation_type::chr) { return (*this)(static_cast<int>(value)); } s.set_sign(sign::none); s.clear_alt(); s.set_fill(' '); // Ignore '0' flag for char types. // align::numeric needs to be overwritten here since the '0' flag is // ignored for non-numeric types if (s.align() == align::none || s.align() == align::numeric) s.set_align(align::right); detail::write<Char>(this->out, static_cast<Char>(value), s); } template <typename T, FMT_ENABLE_IF(std::is_floating_point<T>::value)> void operator()(T value) { write(value); } void operator()(const char* value) { if (value) write(value); else write_null_pointer(this->specs.type() != presentation_type::pointer); } void operator()(const wchar_t* value) { if (value) write(value); else write_null_pointer(this->specs.type() != presentation_type::pointer); } void operator()(basic_string_view<Char> value) { write(value); } void operator()(const void* value) { if (value) write(value); else write_null_pointer(); } void operator()(typename basic_format_arg<context_type>::handle handle) { auto parse_ctx = parse_context<Char>({}); handle.format(parse_ctx, context_); } }; template <typename Char> void parse_flags(format_specs& specs, const Char*& it, const Char* end) { for (; it != end; ++it) { switch (*it) { case '-': specs.set_align(align::left); break; case '+': specs.set_sign(sign::plus); break; case '0': specs.set_fill('0'); break; case ' ': if (specs.sign() != sign::plus) specs.set_sign(sign::space); break; case '#': specs.set_alt(); break; default: return; } } } template <typename Char, typename GetArg> auto parse_header(const Char*& it, const Char* end, format_specs& specs, GetArg get_arg) -> int { int arg_index = -1; Char c = *it; if (c >= '0' && c <= '9') { // Parse an argument index (if followed by '$') or a width possibly // preceded with '0' flag(s). int value = parse_nonnegative_int(it, end, -1); if (it != end && *it == '$') { // value is an argument index ++it; arg_index = value != -1 ? value : max_value<int>(); } else { if (c == '0') specs.set_fill('0'); if (value != 0) { // Nonzero value means that we parsed width and don't need to // parse it or flags again, so return now. if (value == -1) report_error("number is too big"); specs.width = value; return arg_index; } } } parse_flags(specs, it, end); // Parse width. if (it != end) { if (*it >= '0' && *it <= '9') { specs.width = parse_nonnegative_int(it, end, -1); if (specs.width == -1) report_error("number is too big"); } else if (*it == '*') { ++it; specs.width = static_cast<int>( get_arg(-1).visit(detail::printf_width_handler(specs))); } } return arg_index; } inline auto parse_printf_presentation_type(char c, type t, bool& upper) -> presentation_type { using pt = presentation_type; constexpr auto integral_set = sint_set | uint_set | bool_set | char_set; switch (c) { case 'd': return in(t, integral_set) ? pt::dec : pt::none; case 'o': return in(t, integral_set) ? pt::oct : pt::none; case 'X': upper = true; FMT_FALLTHROUGH; case 'x': return in(t, integral_set) ? pt::hex : pt::none; case 'E': upper = true; FMT_FALLTHROUGH; case 'e': return in(t, float_set) ? pt::exp : pt::none; case 'F': upper = true; FMT_FALLTHROUGH; case 'f': return in(t, float_set) ? pt::fixed : pt::none; case 'G': upper = true; FMT_FALLTHROUGH; case 'g': return in(t, float_set) ? pt::general : pt::none; case 'A': upper = true; FMT_FALLTHROUGH; case 'a': return in(t, float_set) ? pt::hexfloat : pt::none; case 'c': return in(t, integral_set) ? pt::chr : pt::none; case 's': return in(t, string_set | cstring_set) ? pt::string : pt::none; case 'p': return in(t, pointer_set | cstring_set) ? pt::pointer : pt::none; default: return pt::none; } } template <typename Char, typename Context> void vprintf(buffer<Char>& buf, basic_string_view<Char> format, basic_format_args<Context> args) { using iterator = basic_appender<Char>; auto out = iterator(buf); auto context = basic_printf_context<Char>(out, args); auto parse_ctx = parse_context<Char>(format); // Returns the argument with specified index or, if arg_index is -1, the next // argument. auto get_arg = [&](int arg_index) { if (arg_index < 0) arg_index = parse_ctx.next_arg_id(); else parse_ctx.check_arg_id(--arg_index); return detail::get_arg(context, arg_index); }; const Char* start = parse_ctx.begin(); const Char* end = parse_ctx.end(); auto it = start; while (it != end) { if (!find<false, Char>(it, end, '%', it)) { it = end; // find leaves it == nullptr if it doesn't find '%'. break; } Char c = *it++; if (it != end && *it == c) { write(out, basic_string_view<Char>(start, to_unsigned(it - start))); start = ++it; continue; } write(out, basic_string_view<Char>(start, to_unsigned(it - 1 - start))); auto specs = format_specs(); specs.set_align(align::right); // Parse argument index, flags and width. int arg_index = parse_header(it, end, specs, get_arg); if (arg_index == 0) report_error("argument not found"); // Parse precision. if (it != end && *it == '.') { ++it; c = it != end ? *it : 0; if ('0' <= c && c <= '9') { specs.precision = parse_nonnegative_int(it, end, 0); } else if (c == '*') { ++it; specs.precision = static_cast<int>(get_arg(-1).visit(printf_precision_handler())); } else { specs.precision = 0; } } auto arg = get_arg(arg_index); // For d, i, o, u, x, and X conversion specifiers, if a precision is // specified, the '0' flag is ignored if (specs.precision >= 0 && is_integral_type(arg.type())) { // Ignore '0' for non-numeric types or if '-' present. specs.set_fill(' '); } if (specs.precision >= 0 && arg.type() == type::cstring_type) { auto str = arg.visit(get_cstring<Char>()); auto str_end = str + specs.precision; auto nul = std::find(str, str_end, Char()); auto sv = basic_string_view<Char>( str, to_unsigned(nul != str_end ? nul - str : specs.precision)); arg = sv; } if (specs.alt() && arg.visit(is_zero_int())) specs.clear_alt(); if (specs.fill_unit<Char>() == '0') { if (is_arithmetic_type(arg.type()) && specs.align() != align::left) { specs.set_align(align::numeric); } else { // Ignore '0' flag for non-numeric types or if '-' flag is also present. specs.set_fill(' '); } } // Parse length and convert the argument to the required type. c = it != end ? *it++ : 0; Char t = it != end ? *it : 0; switch (c) { case 'h': if (t == 'h') { ++it; t = it != end ? *it : 0; convert_arg<signed char>(arg, t); } else { convert_arg<short>(arg, t); } break; case 'l': if (t == 'l') { ++it; t = it != end ? *it : 0; convert_arg<long long>(arg, t); } else { convert_arg<long>(arg, t); } break; case 'j': convert_arg<intmax_t>(arg, t); break; case 'z': convert_arg<size_t>(arg, t); break; case 't': convert_arg<std::ptrdiff_t>(arg, t); break; case 'L': // printf produces garbage when 'L' is omitted for long double, no // need to do the same. break; default: --it; convert_arg<void>(arg, c); } // Parse type. if (it == end) report_error("invalid format string"); char type = static_cast<char>(*it++); if (is_integral_type(arg.type())) { // Normalize type. switch (type) { case 'i': case 'u': type = 'd'; break; case 'c': arg.visit(char_converter<basic_printf_context<Char>>(arg)); break; } } bool upper = false; specs.set_type(parse_printf_presentation_type(type, arg.type(), upper)); if (specs.type() == presentation_type::none) report_error("invalid format specifier"); if (upper) specs.set_upper(); start = it; // Format argument. arg.visit(printf_arg_formatter<Char>(out, specs, context)); } write(out, basic_string_view<Char>(start, to_unsigned(it - start))); } } // namespace detail using printf_context = basic_printf_context<char>; using wprintf_context = basic_printf_context<wchar_t>; using printf_args = basic_format_args<printf_context>; using wprintf_args = basic_format_args<wprintf_context>; /// Constructs an `format_arg_store` object that contains references to /// arguments and can be implicitly converted to `printf_args`. template <typename Char = char, typename... T> inline auto make_printf_args(T&... args) -> decltype(fmt::make_format_args<basic_printf_context<Char>>(args...)) { return fmt::make_format_args<basic_printf_context<Char>>(args...); } template <typename Char> struct vprintf_args { using type = basic_format_args<basic_printf_context<Char>>; }; template <typename Char> inline auto vsprintf(basic_string_view<Char> fmt, typename vprintf_args<Char>::type args) -> std::basic_string<Char> { auto buf = basic_memory_buffer<Char>(); detail::vprintf(buf, fmt, args); return {buf.data(), buf.size()}; } /** * Formats `args` according to specifications in `fmt` and returns the result * as as string. * * **Example**: * * std::string message = fmt::sprintf("The answer is %d", 42); */ template <typename S, typename... T, typename Char = detail::char_t<S>> inline auto sprintf(const S& fmt, const T&... args) -> std::basic_string<Char> { return vsprintf(detail::to_string_view(fmt), fmt::make_format_args<basic_printf_context<Char>>(args...)); } template <typename Char> inline auto vfprintf(std::FILE* f, basic_string_view<Char> fmt, typename vprintf_args<Char>::type args) -> int { auto buf = basic_memory_buffer<Char>(); detail::vprintf(buf, fmt, args); size_t size = buf.size(); return std::fwrite(buf.data(), sizeof(Char), size, f) < size ? -1 : static_cast<int>(size); } /** * Formats `args` according to specifications in `fmt` and writes the output * to `f`. * * **Example**: * * fmt::fprintf(stderr, "Don't %s!", "panic"); */ template <typename S, typename... T, typename Char = detail::char_t<S>> inline auto fprintf(std::FILE* f, const S& fmt, const T&... args) -> int { return vfprintf(f, detail::to_string_view(fmt), make_printf_args<Char>(args...)); } template <typename Char> FMT_DEPRECATED inline auto vprintf(basic_string_view<Char> fmt, typename vprintf_args<Char>::type args) -> int { return vfprintf(stdout, fmt, args); } /** * Formats `args` according to specifications in `fmt` and writes the output * to `stdout`. * * **Example**: * * fmt::printf("Elapsed time: %.2f seconds", 1.23); */ template <typename... T> inline auto printf(string_view fmt, const T&... args) -> int { return vfprintf(stdout, fmt, make_printf_args(args...)); } template <typename... T> FMT_DEPRECATED inline auto printf(basic_string_view<wchar_t> fmt, const T&... args) -> int { return vfprintf(stdout, fmt, make_printf_args<wchar_t>(args...)); } FMT_END_EXPORT FMT_END_NAMESPACE #endif // FMT_PRINTF_H_ ����������������������������������������inspircd-4.7.0/vendor/fmt/ranges.h������������������������������������������������������������������0000664�0000000�0000000�00000067053�14771603147�0017075�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������// Formatting library for C++ - range and tuple support // // Copyright (c) 2012 - present, Victor Zverovich and {fmt} contributors // All rights reserved. // // For the license information refer to format.h. #ifndef FMT_RANGES_H_ #define FMT_RANGES_H_ #ifndef FMT_MODULE # include <initializer_list> # include <iterator> # include <string> # include <tuple> # include <type_traits> # include <utility> #endif #include "format.h" FMT_BEGIN_NAMESPACE FMT_EXPORT enum class range_format { disabled, map, set, sequence, string, debug_string }; namespace detail { template <typename T> class is_map { template <typename U> static auto check(U*) -> typename U::mapped_type; template <typename> static void check(...); public: static constexpr const bool value = !std::is_void<decltype(check<T>(nullptr))>::value; }; template <typename T> class is_set { template <typename U> static auto check(U*) -> typename U::key_type; template <typename> static void check(...); public: static constexpr const bool value = !std::is_void<decltype(check<T>(nullptr))>::value && !is_map<T>::value; }; // C array overload template <typename T, std::size_t N> auto range_begin(const T (&arr)[N]) -> const T* { return arr; } template <typename T, std::size_t N> auto range_end(const T (&arr)[N]) -> const T* { return arr + N; } template <typename T, typename Enable = void> struct has_member_fn_begin_end_t : std::false_type {}; template <typename T> struct has_member_fn_begin_end_t<T, void_t<decltype(*std::declval<T>().begin()), decltype(std::declval<T>().end())>> : std::true_type {}; // Member function overloads. template <typename T> auto range_begin(T&& rng) -> decltype(static_cast<T&&>(rng).begin()) { return static_cast<T&&>(rng).begin(); } template <typename T> auto range_end(T&& rng) -> decltype(static_cast<T&&>(rng).end()) { return static_cast<T&&>(rng).end(); } // ADL overloads. Only participate in overload resolution if member functions // are not found. template <typename T> auto range_begin(T&& rng) -> enable_if_t<!has_member_fn_begin_end_t<T&&>::value, decltype(begin(static_cast<T&&>(rng)))> { return begin(static_cast<T&&>(rng)); } template <typename T> auto range_end(T&& rng) -> enable_if_t<!has_member_fn_begin_end_t<T&&>::value, decltype(end(static_cast<T&&>(rng)))> { return end(static_cast<T&&>(rng)); } template <typename T, typename Enable = void> struct has_const_begin_end : std::false_type {}; template <typename T, typename Enable = void> struct has_mutable_begin_end : std::false_type {}; template <typename T> struct has_const_begin_end< T, void_t<decltype(*detail::range_begin( std::declval<const remove_cvref_t<T>&>())), decltype(detail::range_end( std::declval<const remove_cvref_t<T>&>()))>> : std::true_type {}; template <typename T> struct has_mutable_begin_end< T, void_t<decltype(*detail::range_begin(std::declval<T&>())), decltype(detail::range_end(std::declval<T&>())), // the extra int here is because older versions of MSVC don't // SFINAE properly unless there are distinct types int>> : std::true_type {}; template <typename T, typename _ = void> struct is_range_ : std::false_type {}; template <typename T> struct is_range_<T, void> : std::integral_constant<bool, (has_const_begin_end<T>::value || has_mutable_begin_end<T>::value)> {}; // tuple_size and tuple_element check. template <typename T> class is_tuple_like_ { template <typename U, typename V = typename std::remove_cv<U>::type> static auto check(U* p) -> decltype(std::tuple_size<V>::value, 0); template <typename> static void check(...); public: static constexpr const bool value = !std::is_void<decltype(check<T>(nullptr))>::value; }; // Check for integer_sequence #if defined(__cpp_lib_integer_sequence) || FMT_MSC_VERSION >= 1900 template <typename T, T... N> using integer_sequence = std::integer_sequence<T, N...>; template <size_t... N> using index_sequence = std::index_sequence<N...>; template <size_t N> using make_index_sequence = std::make_index_sequence<N>; #else template <typename T, T... N> struct integer_sequence { using value_type = T; static FMT_CONSTEXPR auto size() -> size_t { return sizeof...(N); } }; template <size_t... N> using index_sequence = integer_sequence<size_t, N...>; template <typename T, size_t N, T... Ns> struct make_integer_sequence : make_integer_sequence<T, N - 1, N - 1, Ns...> {}; template <typename T, T... Ns> struct make_integer_sequence<T, 0, Ns...> : integer_sequence<T, Ns...> {}; template <size_t N> using make_index_sequence = make_integer_sequence<size_t, N>; #endif template <typename T> using tuple_index_sequence = make_index_sequence<std::tuple_size<T>::value>; template <typename T, typename C, bool = is_tuple_like_<T>::value> class is_tuple_formattable_ { public: static constexpr const bool value = false; }; template <typename T, typename C> class is_tuple_formattable_<T, C, true> { template <size_t... Is> static auto all_true(index_sequence<Is...>, integer_sequence<bool, (Is >= 0)...>) -> std::true_type; static auto all_true(...) -> std::false_type; template <size_t... Is> static auto check(index_sequence<Is...>) -> decltype(all_true( index_sequence<Is...>{}, integer_sequence<bool, (is_formattable<typename std::tuple_element<Is, T>::type, C>::value)...>{})); public: static constexpr const bool value = decltype(check(tuple_index_sequence<T>{}))::value; }; template <typename Tuple, typename F, size_t... Is> FMT_CONSTEXPR void for_each(index_sequence<Is...>, Tuple&& t, F&& f) { using std::get; // Using a free function get<Is>(Tuple) now. const int unused[] = {0, ((void)f(get<Is>(t)), 0)...}; ignore_unused(unused); } template <typename Tuple, typename F> FMT_CONSTEXPR void for_each(Tuple&& t, F&& f) { for_each(tuple_index_sequence<remove_cvref_t<Tuple>>(), std::forward<Tuple>(t), std::forward<F>(f)); } template <typename Tuple1, typename Tuple2, typename F, size_t... Is> void for_each2(index_sequence<Is...>, Tuple1&& t1, Tuple2&& t2, F&& f) { using std::get; const int unused[] = {0, ((void)f(get<Is>(t1), get<Is>(t2)), 0)...}; ignore_unused(unused); } template <typename Tuple1, typename Tuple2, typename F> void for_each2(Tuple1&& t1, Tuple2&& t2, F&& f) { for_each2(tuple_index_sequence<remove_cvref_t<Tuple1>>(), std::forward<Tuple1>(t1), std::forward<Tuple2>(t2), std::forward<F>(f)); } namespace tuple { // Workaround a bug in MSVC 2019 (v140). template <typename Char, typename... T> using result_t = std::tuple<formatter<remove_cvref_t<T>, Char>...>; using std::get; template <typename Tuple, typename Char, std::size_t... Is> auto get_formatters(index_sequence<Is...>) -> result_t<Char, decltype(get<Is>(std::declval<Tuple>()))...>; } // namespace tuple #if FMT_MSC_VERSION && FMT_MSC_VERSION < 1920 // Older MSVC doesn't get the reference type correctly for arrays. template <typename R> struct range_reference_type_impl { using type = decltype(*detail::range_begin(std::declval<R&>())); }; template <typename T, std::size_t N> struct range_reference_type_impl<T[N]> { using type = T&; }; template <typename T> using range_reference_type = typename range_reference_type_impl<T>::type; #else template <typename Range> using range_reference_type = decltype(*detail::range_begin(std::declval<Range&>())); #endif // We don't use the Range's value_type for anything, but we do need the Range's // reference type, with cv-ref stripped. template <typename Range> using uncvref_type = remove_cvref_t<range_reference_type<Range>>; template <typename Formatter> FMT_CONSTEXPR auto maybe_set_debug_format(Formatter& f, bool set) -> decltype(f.set_debug_format(set)) { f.set_debug_format(set); } template <typename Formatter> FMT_CONSTEXPR void maybe_set_debug_format(Formatter&, ...) {} template <typename T> struct range_format_kind_ : std::integral_constant<range_format, std::is_same<uncvref_type<T>, T>::value ? range_format::disabled : is_map<T>::value ? range_format::map : is_set<T>::value ? range_format::set : range_format::sequence> {}; template <range_format K> using range_format_constant = std::integral_constant<range_format, K>; // These are not generic lambdas for compatibility with C++11. template <typename Char> struct parse_empty_specs { template <typename Formatter> FMT_CONSTEXPR void operator()(Formatter& f) { f.parse(ctx); detail::maybe_set_debug_format(f, true); } parse_context<Char>& ctx; }; template <typename FormatContext> struct format_tuple_element { using char_type = typename FormatContext::char_type; template <typename T> void operator()(const formatter<T, char_type>& f, const T& v) { if (i > 0) ctx.advance_to(detail::copy<char_type>(separator, ctx.out())); ctx.advance_to(f.format(v, ctx)); ++i; } int i; FormatContext& ctx; basic_string_view<char_type> separator; }; } // namespace detail template <typename T> struct is_tuple_like { static constexpr const bool value = detail::is_tuple_like_<T>::value && !detail::is_range_<T>::value; }; template <typename T, typename C> struct is_tuple_formattable { static constexpr const bool value = detail::is_tuple_formattable_<T, C>::value; }; template <typename Tuple, typename Char> struct formatter<Tuple, Char, enable_if_t<fmt::is_tuple_like<Tuple>::value && fmt::is_tuple_formattable<Tuple, Char>::value>> { private: decltype(detail::tuple::get_formatters<Tuple, Char>( detail::tuple_index_sequence<Tuple>())) formatters_; basic_string_view<Char> separator_ = detail::string_literal<Char, ',', ' '>{}; basic_string_view<Char> opening_bracket_ = detail::string_literal<Char, '('>{}; basic_string_view<Char> closing_bracket_ = detail::string_literal<Char, ')'>{}; public: FMT_CONSTEXPR formatter() {} FMT_CONSTEXPR void set_separator(basic_string_view<Char> sep) { separator_ = sep; } FMT_CONSTEXPR void set_brackets(basic_string_view<Char> open, basic_string_view<Char> close) { opening_bracket_ = open; closing_bracket_ = close; } FMT_CONSTEXPR auto parse(parse_context<Char>& ctx) -> const Char* { auto it = ctx.begin(); auto end = ctx.end(); if (it != end && detail::to_ascii(*it) == 'n') { ++it; set_brackets({}, {}); set_separator({}); } if (it != end && *it != '}') report_error("invalid format specifier"); ctx.advance_to(it); detail::for_each(formatters_, detail::parse_empty_specs<Char>{ctx}); return it; } template <typename FormatContext> auto format(const Tuple& value, FormatContext& ctx) const -> decltype(ctx.out()) { ctx.advance_to(detail::copy<Char>(opening_bracket_, ctx.out())); detail::for_each2( formatters_, value, detail::format_tuple_element<FormatContext>{0, ctx, separator_}); return detail::copy<Char>(closing_bracket_, ctx.out()); } }; template <typename T, typename Char> struct is_range { static constexpr const bool value = detail::is_range_<T>::value && !detail::has_to_string_view<T>::value; }; namespace detail { template <typename Char, typename Element> using range_formatter_type = formatter<remove_cvref_t<Element>, Char>; template <typename R> using maybe_const_range = conditional_t<has_const_begin_end<R>::value, const R, R>; template <typename R, typename Char> struct is_formattable_delayed : is_formattable<uncvref_type<maybe_const_range<R>>, Char> {}; } // namespace detail template <typename...> struct conjunction : std::true_type {}; template <typename P> struct conjunction<P> : P {}; template <typename P1, typename... Pn> struct conjunction<P1, Pn...> : conditional_t<bool(P1::value), conjunction<Pn...>, P1> {}; template <typename T, typename Char, typename Enable = void> struct range_formatter; template <typename T, typename Char> struct range_formatter< T, Char, enable_if_t<conjunction<std::is_same<T, remove_cvref_t<T>>, is_formattable<T, Char>>::value>> { private: detail::range_formatter_type<Char, T> underlying_; basic_string_view<Char> separator_ = detail::string_literal<Char, ',', ' '>{}; basic_string_view<Char> opening_bracket_ = detail::string_literal<Char, '['>{}; basic_string_view<Char> closing_bracket_ = detail::string_literal<Char, ']'>{}; bool is_debug = false; template <typename Output, typename It, typename Sentinel, typename U = T, FMT_ENABLE_IF(std::is_same<U, Char>::value)> auto write_debug_string(Output& out, It it, Sentinel end) const -> Output { auto buf = basic_memory_buffer<Char>(); for (; it != end; ++it) buf.push_back(*it); auto specs = format_specs(); specs.set_type(presentation_type::debug); return detail::write<Char>( out, basic_string_view<Char>(buf.data(), buf.size()), specs); } template <typename Output, typename It, typename Sentinel, typename U = T, FMT_ENABLE_IF(!std::is_same<U, Char>::value)> auto write_debug_string(Output& out, It, Sentinel) const -> Output { return out; } public: FMT_CONSTEXPR range_formatter() {} FMT_CONSTEXPR auto underlying() -> detail::range_formatter_type<Char, T>& { return underlying_; } FMT_CONSTEXPR void set_separator(basic_string_view<Char> sep) { separator_ = sep; } FMT_CONSTEXPR void set_brackets(basic_string_view<Char> open, basic_string_view<Char> close) { opening_bracket_ = open; closing_bracket_ = close; } FMT_CONSTEXPR auto parse(parse_context<Char>& ctx) -> const Char* { auto it = ctx.begin(); auto end = ctx.end(); detail::maybe_set_debug_format(underlying_, true); if (it == end) return underlying_.parse(ctx); switch (detail::to_ascii(*it)) { case 'n': set_brackets({}, {}); ++it; break; case '?': is_debug = true; set_brackets({}, {}); ++it; if (it == end || *it != 's') report_error("invalid format specifier"); FMT_FALLTHROUGH; case 's': if (!std::is_same<T, Char>::value) report_error("invalid format specifier"); if (!is_debug) { set_brackets(detail::string_literal<Char, '"'>{}, detail::string_literal<Char, '"'>{}); set_separator({}); detail::maybe_set_debug_format(underlying_, false); } ++it; return it; } if (it != end && *it != '}') { if (*it != ':') report_error("invalid format specifier"); detail::maybe_set_debug_format(underlying_, false); ++it; } ctx.advance_to(it); return underlying_.parse(ctx); } template <typename R, typename FormatContext> auto format(R&& range, FormatContext& ctx) const -> decltype(ctx.out()) { auto out = ctx.out(); auto it = detail::range_begin(range); auto end = detail::range_end(range); if (is_debug) return write_debug_string(out, std::move(it), end); out = detail::copy<Char>(opening_bracket_, out); int i = 0; for (; it != end; ++it) { if (i > 0) out = detail::copy<Char>(separator_, out); ctx.advance_to(out); auto&& item = *it; // Need an lvalue out = underlying_.format(item, ctx); ++i; } out = detail::copy<Char>(closing_bracket_, out); return out; } }; FMT_EXPORT template <typename T, typename Char, typename Enable = void> struct range_format_kind : conditional_t< is_range<T, Char>::value, detail::range_format_kind_<T>, std::integral_constant<range_format, range_format::disabled>> {}; template <typename R, typename Char> struct formatter< R, Char, enable_if_t<conjunction< bool_constant< range_format_kind<R, Char>::value != range_format::disabled && range_format_kind<R, Char>::value != range_format::map && range_format_kind<R, Char>::value != range_format::string && range_format_kind<R, Char>::value != range_format::debug_string>, detail::is_formattable_delayed<R, Char>>::value>> { private: using range_type = detail::maybe_const_range<R>; range_formatter<detail::uncvref_type<range_type>, Char> range_formatter_; public: using nonlocking = void; FMT_CONSTEXPR formatter() { if (detail::const_check(range_format_kind<R, Char>::value != range_format::set)) return; range_formatter_.set_brackets(detail::string_literal<Char, '{'>{}, detail::string_literal<Char, '}'>{}); } FMT_CONSTEXPR auto parse(parse_context<Char>& ctx) -> const Char* { return range_formatter_.parse(ctx); } template <typename FormatContext> auto format(range_type& range, FormatContext& ctx) const -> decltype(ctx.out()) { return range_formatter_.format(range, ctx); } }; // A map formatter. template <typename R, typename Char> struct formatter< R, Char, enable_if_t<conjunction< bool_constant<range_format_kind<R, Char>::value == range_format::map>, detail::is_formattable_delayed<R, Char>>::value>> { private: using map_type = detail::maybe_const_range<R>; using element_type = detail::uncvref_type<map_type>; decltype(detail::tuple::get_formatters<element_type, Char>( detail::tuple_index_sequence<element_type>())) formatters_; bool no_delimiters_ = false; public: FMT_CONSTEXPR formatter() {} FMT_CONSTEXPR auto parse(parse_context<Char>& ctx) -> const Char* { auto it = ctx.begin(); auto end = ctx.end(); if (it != end) { if (detail::to_ascii(*it) == 'n') { no_delimiters_ = true; ++it; } if (it != end && *it != '}') { if (*it != ':') report_error("invalid format specifier"); ++it; } ctx.advance_to(it); } detail::for_each(formatters_, detail::parse_empty_specs<Char>{ctx}); return it; } template <typename FormatContext> auto format(map_type& map, FormatContext& ctx) const -> decltype(ctx.out()) { auto out = ctx.out(); basic_string_view<Char> open = detail::string_literal<Char, '{'>{}; if (!no_delimiters_) out = detail::copy<Char>(open, out); int i = 0; basic_string_view<Char> sep = detail::string_literal<Char, ',', ' '>{}; for (auto&& value : map) { if (i > 0) out = detail::copy<Char>(sep, out); ctx.advance_to(out); detail::for_each2(formatters_, value, detail::format_tuple_element<FormatContext>{ 0, ctx, detail::string_literal<Char, ':', ' '>{}}); ++i; } basic_string_view<Char> close = detail::string_literal<Char, '}'>{}; if (!no_delimiters_) out = detail::copy<Char>(close, out); return out; } }; // A (debug_)string formatter. template <typename R, typename Char> struct formatter< R, Char, enable_if_t<range_format_kind<R, Char>::value == range_format::string || range_format_kind<R, Char>::value == range_format::debug_string>> { private: using range_type = detail::maybe_const_range<R>; using string_type = conditional_t<std::is_constructible< detail::std_string_view<Char>, decltype(detail::range_begin(std::declval<R>())), decltype(detail::range_end(std::declval<R>()))>::value, detail::std_string_view<Char>, std::basic_string<Char>>; formatter<string_type, Char> underlying_; public: FMT_CONSTEXPR auto parse(parse_context<Char>& ctx) -> const Char* { return underlying_.parse(ctx); } template <typename FormatContext> auto format(range_type& range, FormatContext& ctx) const -> decltype(ctx.out()) { auto out = ctx.out(); if (detail::const_check(range_format_kind<R, Char>::value == range_format::debug_string)) *out++ = '"'; out = underlying_.format( string_type{detail::range_begin(range), detail::range_end(range)}, ctx); if (detail::const_check(range_format_kind<R, Char>::value == range_format::debug_string)) *out++ = '"'; return out; } }; template <typename It, typename Sentinel, typename Char = char> struct join_view : detail::view { It begin; Sentinel end; basic_string_view<Char> sep; join_view(It b, Sentinel e, basic_string_view<Char> s) : begin(std::move(b)), end(e), sep(s) {} }; template <typename It, typename Sentinel, typename Char> struct formatter<join_view<It, Sentinel, Char>, Char> { private: using value_type = #ifdef __cpp_lib_ranges std::iter_value_t<It>; #else typename std::iterator_traits<It>::value_type; #endif formatter<remove_cvref_t<value_type>, Char> value_formatter_; using view = conditional_t<std::is_copy_constructible<It>::value, const join_view<It, Sentinel, Char>, join_view<It, Sentinel, Char>>; public: using nonlocking = void; FMT_CONSTEXPR auto parse(parse_context<Char>& ctx) -> const Char* { return value_formatter_.parse(ctx); } template <typename FormatContext> auto format(view& value, FormatContext& ctx) const -> decltype(ctx.out()) { using iter = conditional_t<std::is_copy_constructible<view>::value, It, It&>; iter it = value.begin; auto out = ctx.out(); if (it == value.end) return out; out = value_formatter_.format(*it, ctx); ++it; while (it != value.end) { out = detail::copy<Char>(value.sep.begin(), value.sep.end(), out); ctx.advance_to(out); out = value_formatter_.format(*it, ctx); ++it; } return out; } }; template <typename Char, typename Tuple> struct tuple_join_view : detail::view { const Tuple& tuple; basic_string_view<Char> sep; tuple_join_view(const Tuple& t, basic_string_view<Char> s) : tuple(t), sep{s} {} }; // Define FMT_TUPLE_JOIN_SPECIFIERS to enable experimental format specifiers // support in tuple_join. It is disabled by default because of issues with // the dynamic width and precision. #ifndef FMT_TUPLE_JOIN_SPECIFIERS # define FMT_TUPLE_JOIN_SPECIFIERS 0 #endif template <typename Char, typename Tuple> struct formatter<tuple_join_view<Char, Tuple>, Char, enable_if_t<is_tuple_like<Tuple>::value>> { FMT_CONSTEXPR auto parse(parse_context<Char>& ctx) -> const Char* { return do_parse(ctx, std::tuple_size<Tuple>()); } template <typename FormatContext> auto format(const tuple_join_view<Char, Tuple>& value, FormatContext& ctx) const -> typename FormatContext::iterator { return do_format(value, ctx, std::tuple_size<Tuple>()); } private: decltype(detail::tuple::get_formatters<Tuple, Char>( detail::tuple_index_sequence<Tuple>())) formatters_; FMT_CONSTEXPR auto do_parse(parse_context<Char>& ctx, std::integral_constant<size_t, 0>) -> const Char* { return ctx.begin(); } template <size_t N> FMT_CONSTEXPR auto do_parse(parse_context<Char>& ctx, std::integral_constant<size_t, N>) -> const Char* { auto end = ctx.begin(); #if FMT_TUPLE_JOIN_SPECIFIERS end = std::get<std::tuple_size<Tuple>::value - N>(formatters_).parse(ctx); if (N > 1) { auto end1 = do_parse(ctx, std::integral_constant<size_t, N - 1>()); if (end != end1) report_error("incompatible format specs for tuple elements"); } #endif return end; } template <typename FormatContext> auto do_format(const tuple_join_view<Char, Tuple>&, FormatContext& ctx, std::integral_constant<size_t, 0>) const -> typename FormatContext::iterator { return ctx.out(); } template <typename FormatContext, size_t N> auto do_format(const tuple_join_view<Char, Tuple>& value, FormatContext& ctx, std::integral_constant<size_t, N>) const -> typename FormatContext::iterator { using std::get; auto out = std::get<std::tuple_size<Tuple>::value - N>(formatters_) .format(get<std::tuple_size<Tuple>::value - N>(value.tuple), ctx); if (N <= 1) return out; out = detail::copy<Char>(value.sep, out); ctx.advance_to(out); return do_format(value, ctx, std::integral_constant<size_t, N - 1>()); } }; namespace detail { // Check if T has an interface like a container adaptor (e.g. std::stack, // std::queue, std::priority_queue). template <typename T> class is_container_adaptor_like { template <typename U> static auto check(U* p) -> typename U::container_type; template <typename> static void check(...); public: static constexpr const bool value = !std::is_void<decltype(check<T>(nullptr))>::value; }; template <typename Container> struct all { const Container& c; auto begin() const -> typename Container::const_iterator { return c.begin(); } auto end() const -> typename Container::const_iterator { return c.end(); } }; } // namespace detail template <typename T, typename Char> struct formatter< T, Char, enable_if_t<conjunction<detail::is_container_adaptor_like<T>, bool_constant<range_format_kind<T, Char>::value == range_format::disabled>>::value>> : formatter<detail::all<typename T::container_type>, Char> { using all = detail::all<typename T::container_type>; template <typename FormatContext> auto format(const T& t, FormatContext& ctx) const -> decltype(ctx.out()) { struct getter : T { static auto get(const T& t) -> all { return {t.*(&getter::c)}; // Access c through the derived class. } }; return formatter<all>::format(getter::get(t), ctx); } }; FMT_BEGIN_EXPORT /// Returns a view that formats the iterator range `[begin, end)` with elements /// separated by `sep`. template <typename It, typename Sentinel> auto join(It begin, Sentinel end, string_view sep) -> join_view<It, Sentinel> { return {std::move(begin), end, sep}; } /** * Returns a view that formats `range` with elements separated by `sep`. * * **Example**: * * auto v = std::vector<int>{1, 2, 3}; * fmt::print("{}", fmt::join(v, ", ")); * // Output: 1, 2, 3 * * `fmt::join` applies passed format specifiers to the range elements: * * fmt::print("{:02}", fmt::join(v, ", ")); * // Output: 01, 02, 03 */ template <typename Range, FMT_ENABLE_IF(!is_tuple_like<Range>::value)> auto join(Range&& r, string_view sep) -> join_view<decltype(detail::range_begin(r)), decltype(detail::range_end(r))> { return {detail::range_begin(r), detail::range_end(r), sep}; } /** * Returns an object that formats `std::tuple` with elements separated by `sep`. * * **Example**: * * auto t = std::tuple<int, char>{1, 'a'}; * fmt::print("{}", fmt::join(t, ", ")); * // Output: 1, a */ template <typename Tuple, FMT_ENABLE_IF(is_tuple_like<Tuple>::value)> FMT_CONSTEXPR auto join(const Tuple& tuple, string_view sep) -> tuple_join_view<char, Tuple> { return {tuple, sep}; } /** * Returns an object that formats `std::initializer_list` with elements * separated by `sep`. * * **Example**: * * fmt::print("{}", fmt::join({1, 2, 3}, ", ")); * // Output: "1, 2, 3" */ template <typename T> auto join(std::initializer_list<T> list, string_view sep) -> join_view<const T*, const T*> { return join(std::begin(list), std::end(list), sep); } FMT_END_EXPORT FMT_END_NAMESPACE #endif // FMT_RANGES_H_ �������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/vendor/fmt/std.h���������������������������������������������������������������������0000664�0000000�0000000�00000052721�14771603147�0016404�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������// Formatting library for C++ - formatters for standard library types // // Copyright (c) 2012 - present, Victor Zverovich // All rights reserved. // // For the license information refer to format.h. #ifndef FMT_STD_H_ #define FMT_STD_H_ #include "format.h" #include "ostream.h" #ifndef FMT_MODULE # include <atomic> # include <bitset> # include <complex> # include <cstdlib> # include <exception> # include <functional> # include <memory> # include <thread> # include <type_traits> # include <typeinfo> # include <utility> # include <vector> // Check FMT_CPLUSPLUS to suppress a bogus warning in MSVC. # if FMT_CPLUSPLUS >= 201703L # if FMT_HAS_INCLUDE(<filesystem>) && \ (!defined(FMT_CPP_LIB_FILESYSTEM) || FMT_CPP_LIB_FILESYSTEM != 0) # include <filesystem> # endif # if FMT_HAS_INCLUDE(<variant>) # include <variant> # endif # if FMT_HAS_INCLUDE(<optional>) # include <optional> # endif # endif // Use > instead of >= in the version check because <source_location> may be // available after C++17 but before C++20 is marked as implemented. # if FMT_CPLUSPLUS > 201703L && FMT_HAS_INCLUDE(<source_location>) # include <source_location> # endif # if FMT_CPLUSPLUS > 202002L && FMT_HAS_INCLUDE(<expected>) # include <expected> # endif #endif // FMT_MODULE #if FMT_HAS_INCLUDE(<version>) # include <version> #endif // GCC 4 does not support FMT_HAS_INCLUDE. #if FMT_HAS_INCLUDE(<cxxabi.h>) || defined(__GLIBCXX__) # include <cxxabi.h> // Android NDK with gabi++ library on some architectures does not implement // abi::__cxa_demangle(). # ifndef __GABIXX_CXXABI_H__ # define FMT_HAS_ABI_CXA_DEMANGLE # endif #endif // For older Xcode versions, __cpp_lib_xxx flags are inaccurately defined. #ifndef FMT_CPP_LIB_FILESYSTEM # ifdef __cpp_lib_filesystem # define FMT_CPP_LIB_FILESYSTEM __cpp_lib_filesystem # else # define FMT_CPP_LIB_FILESYSTEM 0 # endif #endif #ifndef FMT_CPP_LIB_VARIANT # ifdef __cpp_lib_variant # define FMT_CPP_LIB_VARIANT __cpp_lib_variant # else # define FMT_CPP_LIB_VARIANT 0 # endif #endif #if FMT_CPP_LIB_FILESYSTEM FMT_BEGIN_NAMESPACE namespace detail { template <typename Char, typename PathChar> auto get_path_string(const std::filesystem::path& p, const std::basic_string<PathChar>& native) { if constexpr (std::is_same_v<Char, char> && std::is_same_v<PathChar, wchar_t>) return to_utf8<wchar_t>(native, to_utf8_error_policy::replace); else return p.string<Char>(); } template <typename Char, typename PathChar> void write_escaped_path(basic_memory_buffer<Char>& quoted, const std::filesystem::path& p, const std::basic_string<PathChar>& native) { if constexpr (std::is_same_v<Char, char> && std::is_same_v<PathChar, wchar_t>) { auto buf = basic_memory_buffer<wchar_t>(); write_escaped_string<wchar_t>(std::back_inserter(buf), native); bool valid = to_utf8<wchar_t>::convert(quoted, {buf.data(), buf.size()}); FMT_ASSERT(valid, "invalid utf16"); } else if constexpr (std::is_same_v<Char, PathChar>) { write_escaped_string<std::filesystem::path::value_type>( std::back_inserter(quoted), native); } else { write_escaped_string<Char>(std::back_inserter(quoted), p.string<Char>()); } } } // namespace detail FMT_EXPORT template <typename Char> struct formatter<std::filesystem::path, Char> { private: format_specs specs_; detail::arg_ref<Char> width_ref_; bool debug_ = false; char path_type_ = 0; public: FMT_CONSTEXPR void set_debug_format(bool set = true) { debug_ = set; } FMT_CONSTEXPR auto parse(parse_context<Char>& ctx) { auto it = ctx.begin(), end = ctx.end(); if (it == end) return it; it = detail::parse_align(it, end, specs_); if (it == end) return it; Char c = *it; if ((c >= '0' && c <= '9') || c == '{') it = detail::parse_width(it, end, specs_, width_ref_, ctx); if (it != end && *it == '?') { debug_ = true; ++it; } if (it != end && (*it == 'g')) path_type_ = detail::to_ascii(*it++); return it; } template <typename FormatContext> auto format(const std::filesystem::path& p, FormatContext& ctx) const { auto specs = specs_; auto path_string = !path_type_ ? p.native() : p.generic_string<std::filesystem::path::value_type>(); detail::handle_dynamic_spec(specs.dynamic_width(), specs.width, width_ref_, ctx); if (!debug_) { auto s = detail::get_path_string<Char>(p, path_string); return detail::write(ctx.out(), basic_string_view<Char>(s), specs); } auto quoted = basic_memory_buffer<Char>(); detail::write_escaped_path(quoted, p, path_string); return detail::write(ctx.out(), basic_string_view<Char>(quoted.data(), quoted.size()), specs); } }; class path : public std::filesystem::path { public: auto display_string() const -> std::string { const std::filesystem::path& base = *this; return fmt::format(FMT_STRING("{}"), base); } auto system_string() const -> std::string { return string(); } auto generic_display_string() const -> std::string { const std::filesystem::path& base = *this; return fmt::format(FMT_STRING("{:g}"), base); } auto generic_system_string() const -> std::string { return generic_string(); } }; FMT_END_NAMESPACE #endif // FMT_CPP_LIB_FILESYSTEM FMT_BEGIN_NAMESPACE FMT_EXPORT template <std::size_t N, typename Char> struct formatter<std::bitset<N>, Char> : nested_formatter<basic_string_view<Char>, Char> { private: // Functor because C++11 doesn't support generic lambdas. struct writer { const std::bitset<N>& bs; template <typename OutputIt> FMT_CONSTEXPR auto operator()(OutputIt out) -> OutputIt { for (auto pos = N; pos > 0; --pos) { out = detail::write<Char>(out, bs[pos - 1] ? Char('1') : Char('0')); } return out; } }; public: template <typename FormatContext> auto format(const std::bitset<N>& bs, FormatContext& ctx) const -> decltype(ctx.out()) { return this->write_padded(ctx, writer{bs}); } }; FMT_EXPORT template <typename Char> struct formatter<std::thread::id, Char> : basic_ostream_formatter<Char> {}; FMT_END_NAMESPACE #ifdef __cpp_lib_optional FMT_BEGIN_NAMESPACE FMT_EXPORT template <typename T, typename Char> struct formatter<std::optional<T>, Char, std::enable_if_t<is_formattable<T, Char>::value>> { private: formatter<T, Char> underlying_; static constexpr basic_string_view<Char> optional = detail::string_literal<Char, 'o', 'p', 't', 'i', 'o', 'n', 'a', 'l', '('>{}; static constexpr basic_string_view<Char> none = detail::string_literal<Char, 'n', 'o', 'n', 'e'>{}; template <class U> FMT_CONSTEXPR static auto maybe_set_debug_format(U& u, bool set) -> decltype(u.set_debug_format(set)) { u.set_debug_format(set); } template <class U> FMT_CONSTEXPR static void maybe_set_debug_format(U&, ...) {} public: FMT_CONSTEXPR auto parse(parse_context<Char>& ctx) { maybe_set_debug_format(underlying_, true); return underlying_.parse(ctx); } template <typename FormatContext> auto format(const std::optional<T>& opt, FormatContext& ctx) const -> decltype(ctx.out()) { if (!opt) return detail::write<Char>(ctx.out(), none); auto out = ctx.out(); out = detail::write<Char>(out, optional); ctx.advance_to(out); out = underlying_.format(*opt, ctx); return detail::write(out, ')'); } }; FMT_END_NAMESPACE #endif // __cpp_lib_optional #if defined(__cpp_lib_expected) || FMT_CPP_LIB_VARIANT FMT_BEGIN_NAMESPACE namespace detail { template <typename Char, typename OutputIt, typename T> auto write_escaped_alternative(OutputIt out, const T& v) -> OutputIt { if constexpr (has_to_string_view<T>::value) return write_escaped_string<Char>(out, detail::to_string_view(v)); if constexpr (std::is_same_v<T, Char>) return write_escaped_char(out, v); return write<Char>(out, v); } } // namespace detail FMT_END_NAMESPACE #endif #ifdef __cpp_lib_expected FMT_BEGIN_NAMESPACE FMT_EXPORT template <typename T, typename E, typename Char> struct formatter<std::expected<T, E>, Char, std::enable_if_t<(std::is_void<T>::value || is_formattable<T, Char>::value) && is_formattable<E, Char>::value>> { FMT_CONSTEXPR auto parse(parse_context<Char>& ctx) -> const Char* { return ctx.begin(); } template <typename FormatContext> auto format(const std::expected<T, E>& value, FormatContext& ctx) const -> decltype(ctx.out()) { auto out = ctx.out(); if (value.has_value()) { out = detail::write<Char>(out, "expected("); if constexpr (!std::is_void<T>::value) out = detail::write_escaped_alternative<Char>(out, *value); } else { out = detail::write<Char>(out, "unexpected("); out = detail::write_escaped_alternative<Char>(out, value.error()); } *out++ = ')'; return out; } }; FMT_END_NAMESPACE #endif // __cpp_lib_expected #ifdef __cpp_lib_source_location FMT_BEGIN_NAMESPACE FMT_EXPORT template <> struct formatter<std::source_location> { FMT_CONSTEXPR auto parse(parse_context<>& ctx) { return ctx.begin(); } template <typename FormatContext> auto format(const std::source_location& loc, FormatContext& ctx) const -> decltype(ctx.out()) { auto out = ctx.out(); out = detail::write(out, loc.file_name()); out = detail::write(out, ':'); out = detail::write<char>(out, loc.line()); out = detail::write(out, ':'); out = detail::write<char>(out, loc.column()); out = detail::write(out, ": "); out = detail::write(out, loc.function_name()); return out; } }; FMT_END_NAMESPACE #endif #if FMT_CPP_LIB_VARIANT FMT_BEGIN_NAMESPACE namespace detail { template <typename T> using variant_index_sequence = std::make_index_sequence<std::variant_size<T>::value>; template <typename> struct is_variant_like_ : std::false_type {}; template <typename... Types> struct is_variant_like_<std::variant<Types...>> : std::true_type {}; // formattable element check. template <typename T, typename C> class is_variant_formattable_ { template <std::size_t... Is> static std::conjunction< is_formattable<std::variant_alternative_t<Is, T>, C>...> check(std::index_sequence<Is...>); public: static constexpr const bool value = decltype(check(variant_index_sequence<T>{}))::value; }; } // namespace detail template <typename T> struct is_variant_like { static constexpr const bool value = detail::is_variant_like_<T>::value; }; template <typename T, typename C> struct is_variant_formattable { static constexpr const bool value = detail::is_variant_formattable_<T, C>::value; }; FMT_EXPORT template <typename Char> struct formatter<std::monostate, Char> { FMT_CONSTEXPR auto parse(parse_context<Char>& ctx) -> const Char* { return ctx.begin(); } template <typename FormatContext> auto format(const std::monostate&, FormatContext& ctx) const -> decltype(ctx.out()) { return detail::write<Char>(ctx.out(), "monostate"); } }; FMT_EXPORT template <typename Variant, typename Char> struct formatter< Variant, Char, std::enable_if_t<std::conjunction_v< is_variant_like<Variant>, is_variant_formattable<Variant, Char>>>> { FMT_CONSTEXPR auto parse(parse_context<Char>& ctx) -> const Char* { return ctx.begin(); } template <typename FormatContext> auto format(const Variant& value, FormatContext& ctx) const -> decltype(ctx.out()) { auto out = ctx.out(); out = detail::write<Char>(out, "variant("); FMT_TRY { std::visit( [&](const auto& v) { out = detail::write_escaped_alternative<Char>(out, v); }, value); } FMT_CATCH(const std::bad_variant_access&) { detail::write<Char>(out, "valueless by exception"); } *out++ = ')'; return out; } }; FMT_END_NAMESPACE #endif // FMT_CPP_LIB_VARIANT FMT_BEGIN_NAMESPACE FMT_EXPORT template <> struct formatter<std::error_code> { private: format_specs specs_; detail::arg_ref<char> width_ref_; public: FMT_CONSTEXPR auto parse(parse_context<>& ctx) -> const char* { auto it = ctx.begin(), end = ctx.end(); if (it == end) return it; it = detail::parse_align(it, end, specs_); if (it == end) return it; char c = *it; if ((c >= '0' && c <= '9') || c == '{') it = detail::parse_width(it, end, specs_, width_ref_, ctx); return it; } template <typename FormatContext> FMT_CONSTEXPR20 auto format(const std::error_code& ec, FormatContext& ctx) const -> decltype(ctx.out()) { auto specs = specs_; detail::handle_dynamic_spec(specs.dynamic_width(), specs.width, width_ref_, ctx); memory_buffer buf; buf.append(string_view(ec.category().name())); buf.push_back(':'); detail::write<char>(appender(buf), ec.value()); return detail::write<char>(ctx.out(), string_view(buf.data(), buf.size()), specs); } }; #if FMT_USE_RTTI namespace detail { template <typename Char, typename OutputIt> auto write_demangled_name(OutputIt out, const std::type_info& ti) -> OutputIt { # ifdef FMT_HAS_ABI_CXA_DEMANGLE int status = 0; std::size_t size = 0; std::unique_ptr<char, void (*)(void*)> demangled_name_ptr( abi::__cxa_demangle(ti.name(), nullptr, &size, &status), &std::free); string_view demangled_name_view; if (demangled_name_ptr) { demangled_name_view = demangled_name_ptr.get(); // Normalization of stdlib inline namespace names. // libc++ inline namespaces. // std::__1::* -> std::* // std::__1::__fs::* -> std::* // libstdc++ inline namespaces. // std::__cxx11::* -> std::* // std::filesystem::__cxx11::* -> std::filesystem::* if (demangled_name_view.starts_with("std::")) { char* begin = demangled_name_ptr.get(); char* to = begin + 5; // std:: for (char *from = to, *end = begin + demangled_name_view.size(); from < end;) { // This is safe, because demangled_name is NUL-terminated. if (from[0] == '_' && from[1] == '_') { char* next = from + 1; while (next < end && *next != ':') next++; if (next[0] == ':' && next[1] == ':') { from = next + 2; continue; } } *to++ = *from++; } demangled_name_view = {begin, detail::to_unsigned(to - begin)}; } } else { demangled_name_view = string_view(ti.name()); } return detail::write_bytes<Char>(out, demangled_name_view); # elif FMT_MSC_VERSION const string_view demangled_name(ti.name()); for (std::size_t i = 0; i < demangled_name.size(); ++i) { auto sub = demangled_name; sub.remove_prefix(i); if (sub.starts_with("enum ")) { i += 4; continue; } if (sub.starts_with("class ") || sub.starts_with("union ")) { i += 5; continue; } if (sub.starts_with("struct ")) { i += 6; continue; } if (*sub.begin() != ' ') *out++ = *sub.begin(); } return out; # else return detail::write_bytes<Char>(out, string_view(ti.name())); # endif } } // namespace detail FMT_EXPORT template <typename Char> struct formatter<std::type_info, Char // DEPRECATED! Mixing code unit types. > { public: FMT_CONSTEXPR auto parse(parse_context<Char>& ctx) -> const Char* { return ctx.begin(); } template <typename Context> auto format(const std::type_info& ti, Context& ctx) const -> decltype(ctx.out()) { return detail::write_demangled_name<Char>(ctx.out(), ti); } }; #endif FMT_EXPORT template <typename T, typename Char> struct formatter< T, Char, // DEPRECATED! Mixing code unit types. typename std::enable_if<std::is_base_of<std::exception, T>::value>::type> { private: bool with_typename_ = false; public: FMT_CONSTEXPR auto parse(parse_context<Char>& ctx) -> const Char* { auto it = ctx.begin(); auto end = ctx.end(); if (it == end || *it == '}') return it; if (*it == 't') { ++it; with_typename_ = FMT_USE_RTTI != 0; } return it; } template <typename Context> auto format(const std::exception& ex, Context& ctx) const -> decltype(ctx.out()) { auto out = ctx.out(); #if FMT_USE_RTTI if (with_typename_) { out = detail::write_demangled_name<Char>(out, typeid(ex)); *out++ = ':'; *out++ = ' '; } #endif return detail::write_bytes<Char>(out, string_view(ex.what())); } }; namespace detail { template <typename T, typename Enable = void> struct has_flip : std::false_type {}; template <typename T> struct has_flip<T, void_t<decltype(std::declval<T>().flip())>> : std::true_type {}; template <typename T> struct is_bit_reference_like { static constexpr const bool value = std::is_convertible<T, bool>::value && std::is_nothrow_assignable<T, bool>::value && has_flip<T>::value; }; #ifdef _LIBCPP_VERSION // Workaround for libc++ incompatibility with C++ standard. // According to the Standard, `bitset::operator[] const` returns bool. template <typename C> struct is_bit_reference_like<std::__bit_const_reference<C>> { static constexpr const bool value = true; }; #endif } // namespace detail // We can't use std::vector<bool, Allocator>::reference and // std::bitset<N>::reference because the compiler can't deduce Allocator and N // in partial specialization. FMT_EXPORT template <typename BitRef, typename Char> struct formatter<BitRef, Char, enable_if_t<detail::is_bit_reference_like<BitRef>::value>> : formatter<bool, Char> { template <typename FormatContext> FMT_CONSTEXPR auto format(const BitRef& v, FormatContext& ctx) const -> decltype(ctx.out()) { return formatter<bool, Char>::format(v, ctx); } }; template <typename T, typename Deleter> auto ptr(const std::unique_ptr<T, Deleter>& p) -> const void* { return p.get(); } template <typename T> auto ptr(const std::shared_ptr<T>& p) -> const void* { return p.get(); } FMT_EXPORT template <typename T, typename Char> struct formatter<std::atomic<T>, Char, enable_if_t<is_formattable<T, Char>::value>> : formatter<T, Char> { template <typename FormatContext> auto format(const std::atomic<T>& v, FormatContext& ctx) const -> decltype(ctx.out()) { return formatter<T, Char>::format(v.load(), ctx); } }; #ifdef __cpp_lib_atomic_flag_test FMT_EXPORT template <typename Char> struct formatter<std::atomic_flag, Char> : formatter<bool, Char> { template <typename FormatContext> auto format(const std::atomic_flag& v, FormatContext& ctx) const -> decltype(ctx.out()) { return formatter<bool, Char>::format(v.test(), ctx); } }; #endif // __cpp_lib_atomic_flag_test FMT_EXPORT template <typename T, typename Char> struct formatter<std::complex<T>, Char> { private: detail::dynamic_format_specs<Char> specs_; template <typename FormatContext, typename OutputIt> FMT_CONSTEXPR auto do_format(const std::complex<T>& c, detail::dynamic_format_specs<Char>& specs, FormatContext& ctx, OutputIt out) const -> OutputIt { if (c.real() != 0) { *out++ = Char('('); out = detail::write<Char>(out, c.real(), specs, ctx.locale()); specs.set_sign(sign::plus); out = detail::write<Char>(out, c.imag(), specs, ctx.locale()); if (!detail::isfinite(c.imag())) *out++ = Char(' '); *out++ = Char('i'); *out++ = Char(')'); return out; } out = detail::write<Char>(out, c.imag(), specs, ctx.locale()); if (!detail::isfinite(c.imag())) *out++ = Char(' '); *out++ = Char('i'); return out; } public: FMT_CONSTEXPR auto parse(parse_context<Char>& ctx) -> const Char* { if (ctx.begin() == ctx.end() || *ctx.begin() == '}') return ctx.begin(); return parse_format_specs(ctx.begin(), ctx.end(), specs_, ctx, detail::type_constant<T, Char>::value); } template <typename FormatContext> auto format(const std::complex<T>& c, FormatContext& ctx) const -> decltype(ctx.out()) { auto specs = specs_; if (specs.dynamic()) { detail::handle_dynamic_spec(specs.dynamic_width(), specs.width, specs.width_ref, ctx); detail::handle_dynamic_spec(specs.dynamic_precision(), specs.precision, specs.precision_ref, ctx); } if (specs.width == 0) return do_format(c, specs, ctx, ctx.out()); auto buf = basic_memory_buffer<Char>(); auto outer_specs = format_specs(); outer_specs.width = specs.width; outer_specs.copy_fill_from(specs); outer_specs.set_align(specs.align()); specs.width = 0; specs.set_fill({}); specs.set_align(align::none); do_format(c, specs, ctx, basic_appender<Char>(buf)); return detail::write<Char>(ctx.out(), basic_string_view<Char>(buf.data(), buf.size()), outer_specs); } }; FMT_EXPORT template <typename T, typename Char> struct formatter<std::reference_wrapper<T>, Char, enable_if_t<is_formattable<remove_cvref_t<T>, Char>::value>> : formatter<remove_cvref_t<T>, Char> { template <typename FormatContext> auto format(std::reference_wrapper<T> ref, FormatContext& ctx) const -> decltype(ctx.out()) { return formatter<remove_cvref_t<T>, Char>::format(ref.get(), ctx); } }; FMT_END_NAMESPACE #endif // FMT_STD_H_ �����������������������������������������������inspircd-4.7.0/vendor/fmt/xchar.h�������������������������������������������������������������������0000664�0000000�0000000�00000033016�14771603147�0016713�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������// Formatting library for C++ - optional wchar_t and exotic character support // // Copyright (c) 2012 - present, Victor Zverovich // All rights reserved. // // For the license information refer to format.h. #ifndef FMT_XCHAR_H_ #define FMT_XCHAR_H_ #include "color.h" #include "format.h" #include "ostream.h" #include "ranges.h" #ifndef FMT_MODULE # include <cwchar> # if FMT_USE_LOCALE # include <locale> # endif #endif FMT_BEGIN_NAMESPACE namespace detail { template <typename T> using is_exotic_char = bool_constant<!std::is_same<T, char>::value>; template <typename S, typename = void> struct format_string_char {}; template <typename S> struct format_string_char< S, void_t<decltype(sizeof(detail::to_string_view(std::declval<S>())))>> { using type = char_t<S>; }; template <typename S> struct format_string_char< S, enable_if_t<std::is_base_of<detail::compile_string, S>::value>> { using type = typename S::char_type; }; template <typename S> using format_string_char_t = typename format_string_char<S>::type; inline auto write_loc(basic_appender<wchar_t> out, loc_value value, const format_specs& specs, locale_ref loc) -> bool { #if FMT_USE_LOCALE auto& numpunct = std::use_facet<std::numpunct<wchar_t>>(loc.get<std::locale>()); auto separator = std::wstring(); auto grouping = numpunct.grouping(); if (!grouping.empty()) separator = std::wstring(1, numpunct.thousands_sep()); return value.visit(loc_writer<wchar_t>{out, specs, separator, grouping, {}}); #endif return false; } } // namespace detail FMT_BEGIN_EXPORT using wstring_view = basic_string_view<wchar_t>; using wformat_parse_context = parse_context<wchar_t>; using wformat_context = buffered_context<wchar_t>; using wformat_args = basic_format_args<wformat_context>; using wmemory_buffer = basic_memory_buffer<wchar_t>; template <typename Char, typename... T> struct basic_fstring { private: basic_string_view<Char> str_; static constexpr int num_static_named_args = detail::count_static_named_args<T...>(); using checker = detail::format_string_checker< Char, static_cast<int>(sizeof...(T)), num_static_named_args, num_static_named_args != detail::count_named_args<T...>()>; using arg_pack = detail::arg_pack<T...>; public: using t = basic_fstring; template <typename S, FMT_ENABLE_IF( std::is_convertible<const S&, basic_string_view<Char>>::value)> FMT_CONSTEVAL FMT_ALWAYS_INLINE basic_fstring(const S& s) : str_(s) { if (FMT_USE_CONSTEVAL) detail::parse_format_string<Char>(s, checker(s, arg_pack())); } template <typename S, FMT_ENABLE_IF(std::is_base_of<detail::compile_string, S>::value&& std::is_same<typename S::char_type, Char>::value)> FMT_ALWAYS_INLINE basic_fstring(const S&) : str_(S()) { FMT_CONSTEXPR auto sv = basic_string_view<Char>(S()); FMT_CONSTEXPR int ignore = (parse_format_string(sv, checker(sv, arg_pack())), 0); detail::ignore_unused(ignore); } basic_fstring(runtime_format_string<Char> fmt) : str_(fmt.str) {} operator basic_string_view<Char>() const { return str_; } auto get() const -> basic_string_view<Char> { return str_; } }; template <typename Char, typename... T> using basic_format_string = basic_fstring<Char, T...>; template <typename... T> using wformat_string = typename basic_format_string<wchar_t, T...>::t; inline auto runtime(wstring_view s) -> runtime_format_string<wchar_t> { return {{s}}; } template <> struct is_char<wchar_t> : std::true_type {}; template <> struct is_char<char16_t> : std::true_type {}; template <> struct is_char<char32_t> : std::true_type {}; #ifdef __cpp_char8_t template <> struct is_char<char8_t> : bool_constant<detail::is_utf8_enabled> {}; #endif template <typename... T> constexpr auto make_wformat_args(T&... args) -> decltype(fmt::make_format_args<wformat_context>(args...)) { return fmt::make_format_args<wformat_context>(args...); } #if !FMT_USE_NONTYPE_TEMPLATE_ARGS inline namespace literals { inline auto operator""_a(const wchar_t* s, size_t) -> detail::udl_arg<wchar_t> { return {s}; } } // namespace literals #endif template <typename It, typename Sentinel> auto join(It begin, Sentinel end, wstring_view sep) -> join_view<It, Sentinel, wchar_t> { return {begin, end, sep}; } template <typename Range, FMT_ENABLE_IF(!is_tuple_like<Range>::value)> auto join(Range&& range, wstring_view sep) -> join_view<decltype(std::begin(range)), decltype(std::end(range)), wchar_t> { return join(std::begin(range), std::end(range), sep); } template <typename T> auto join(std::initializer_list<T> list, wstring_view sep) -> join_view<const T*, const T*, wchar_t> { return join(std::begin(list), std::end(list), sep); } template <typename Tuple, FMT_ENABLE_IF(is_tuple_like<Tuple>::value)> auto join(const Tuple& tuple, basic_string_view<wchar_t> sep) -> tuple_join_view<wchar_t, Tuple> { return {tuple, sep}; } template <typename Char, FMT_ENABLE_IF(!std::is_same<Char, char>::value)> auto vformat(basic_string_view<Char> fmt, typename detail::vformat_args<Char>::type args) -> std::basic_string<Char> { auto buf = basic_memory_buffer<Char>(); detail::vformat_to(buf, fmt, args); return {buf.data(), buf.size()}; } template <typename... T> auto format(wformat_string<T...> fmt, T&&... args) -> std::wstring { return vformat(fmt::wstring_view(fmt), fmt::make_wformat_args(args...)); } template <typename OutputIt, typename... T> auto format_to(OutputIt out, wformat_string<T...> fmt, T&&... args) -> OutputIt { return vformat_to(out, fmt::wstring_view(fmt), fmt::make_wformat_args(args...)); } // Pass char_t as a default template parameter instead of using // std::basic_string<char_t<S>> to reduce the symbol size. template <typename S, typename... T, typename Char = detail::format_string_char_t<S>, FMT_ENABLE_IF(!std::is_same<Char, char>::value && !std::is_same<Char, wchar_t>::value)> auto format(const S& fmt, T&&... args) -> std::basic_string<Char> { return vformat(detail::to_string_view(fmt), fmt::make_format_args<buffered_context<Char>>(args...)); } template <typename Locale, typename S, typename Char = detail::format_string_char_t<S>, FMT_ENABLE_IF(detail::is_locale<Locale>::value&& detail::is_exotic_char<Char>::value)> inline auto vformat(const Locale& loc, const S& fmt, typename detail::vformat_args<Char>::type args) -> std::basic_string<Char> { auto buf = basic_memory_buffer<Char>(); detail::vformat_to(buf, detail::to_string_view(fmt), args, detail::locale_ref(loc)); return {buf.data(), buf.size()}; } template <typename Locale, typename S, typename... T, typename Char = detail::format_string_char_t<S>, FMT_ENABLE_IF(detail::is_locale<Locale>::value&& detail::is_exotic_char<Char>::value)> inline auto format(const Locale& loc, const S& fmt, T&&... args) -> std::basic_string<Char> { return vformat(loc, detail::to_string_view(fmt), fmt::make_format_args<buffered_context<Char>>(args...)); } template <typename OutputIt, typename S, typename Char = detail::format_string_char_t<S>, FMT_ENABLE_IF(detail::is_output_iterator<OutputIt, Char>::value&& detail::is_exotic_char<Char>::value)> auto vformat_to(OutputIt out, const S& fmt, typename detail::vformat_args<Char>::type args) -> OutputIt { auto&& buf = detail::get_buffer<Char>(out); detail::vformat_to(buf, detail::to_string_view(fmt), args); return detail::get_iterator(buf, out); } template <typename OutputIt, typename S, typename... T, typename Char = detail::format_string_char_t<S>, FMT_ENABLE_IF(detail::is_output_iterator<OutputIt, Char>::value && !std::is_same<Char, char>::value && !std::is_same<Char, wchar_t>::value)> inline auto format_to(OutputIt out, const S& fmt, T&&... args) -> OutputIt { return vformat_to(out, detail::to_string_view(fmt), fmt::make_format_args<buffered_context<Char>>(args...)); } template <typename Locale, typename S, typename OutputIt, typename... Args, typename Char = detail::format_string_char_t<S>, FMT_ENABLE_IF(detail::is_output_iterator<OutputIt, Char>::value&& detail::is_locale<Locale>::value&& detail::is_exotic_char<Char>::value)> inline auto vformat_to(OutputIt out, const Locale& loc, const S& fmt, typename detail::vformat_args<Char>::type args) -> OutputIt { auto&& buf = detail::get_buffer<Char>(out); vformat_to(buf, detail::to_string_view(fmt), args, detail::locale_ref(loc)); return detail::get_iterator(buf, out); } template <typename Locale, typename OutputIt, typename S, typename... T, typename Char = detail::format_string_char_t<S>, bool enable = detail::is_output_iterator<OutputIt, Char>::value && detail::is_locale<Locale>::value && detail::is_exotic_char<Char>::value> inline auto format_to(OutputIt out, const Locale& loc, const S& fmt, T&&... args) -> typename std::enable_if<enable, OutputIt>::type { return vformat_to(out, loc, detail::to_string_view(fmt), fmt::make_format_args<buffered_context<Char>>(args...)); } template <typename OutputIt, typename Char, typename... Args, FMT_ENABLE_IF(detail::is_output_iterator<OutputIt, Char>::value&& detail::is_exotic_char<Char>::value)> inline auto vformat_to_n(OutputIt out, size_t n, basic_string_view<Char> fmt, typename detail::vformat_args<Char>::type args) -> format_to_n_result<OutputIt> { using traits = detail::fixed_buffer_traits; auto buf = detail::iterator_buffer<OutputIt, Char, traits>(out, n); detail::vformat_to(buf, fmt, args); return {buf.out(), buf.count()}; } template <typename OutputIt, typename S, typename... T, typename Char = detail::format_string_char_t<S>, FMT_ENABLE_IF(detail::is_output_iterator<OutputIt, Char>::value&& detail::is_exotic_char<Char>::value)> inline auto format_to_n(OutputIt out, size_t n, const S& fmt, T&&... args) -> format_to_n_result<OutputIt> { return vformat_to_n(out, n, fmt::basic_string_view<Char>(fmt), fmt::make_format_args<buffered_context<Char>>(args...)); } template <typename S, typename... T, typename Char = detail::format_string_char_t<S>, FMT_ENABLE_IF(detail::is_exotic_char<Char>::value)> inline auto formatted_size(const S& fmt, T&&... args) -> size_t { auto buf = detail::counting_buffer<Char>(); detail::vformat_to(buf, detail::to_string_view(fmt), fmt::make_format_args<buffered_context<Char>>(args...)); return buf.count(); } inline void vprint(std::FILE* f, wstring_view fmt, wformat_args args) { auto buf = wmemory_buffer(); detail::vformat_to(buf, fmt, args); buf.push_back(L'\0'); if (std::fputws(buf.data(), f) == -1) FMT_THROW(system_error(errno, FMT_STRING("cannot write to file"))); } inline void vprint(wstring_view fmt, wformat_args args) { vprint(stdout, fmt, args); } template <typename... T> void print(std::FILE* f, wformat_string<T...> fmt, T&&... args) { return vprint(f, wstring_view(fmt), fmt::make_wformat_args(args...)); } template <typename... T> void print(wformat_string<T...> fmt, T&&... args) { return vprint(wstring_view(fmt), fmt::make_wformat_args(args...)); } template <typename... T> void println(std::FILE* f, wformat_string<T...> fmt, T&&... args) { return print(f, L"{}\n", fmt::format(fmt, std::forward<T>(args)...)); } template <typename... T> void println(wformat_string<T...> fmt, T&&... args) { return print(L"{}\n", fmt::format(fmt, std::forward<T>(args)...)); } inline auto vformat(const text_style& ts, wstring_view fmt, wformat_args args) -> std::wstring { auto buf = wmemory_buffer(); detail::vformat_to(buf, ts, fmt, args); return {buf.data(), buf.size()}; } template <typename... T> inline auto format(const text_style& ts, wformat_string<T...> fmt, T&&... args) -> std::wstring { return fmt::vformat(ts, fmt, fmt::make_wformat_args(args...)); } template <typename... T> FMT_DEPRECATED void print(std::FILE* f, const text_style& ts, wformat_string<T...> fmt, const T&... args) { vprint(f, ts, fmt, fmt::make_wformat_args(args...)); } template <typename... T> FMT_DEPRECATED void print(const text_style& ts, wformat_string<T...> fmt, const T&... args) { return print(stdout, ts, fmt, args...); } inline void vprint(std::wostream& os, wstring_view fmt, wformat_args args) { auto buffer = basic_memory_buffer<wchar_t>(); detail::vformat_to(buffer, fmt, args); detail::write_buffer(os, buffer); } template <typename... T> void print(std::wostream& os, wformat_string<T...> fmt, T&&... args) { vprint(os, fmt, fmt::make_format_args<buffered_context<wchar_t>>(args...)); } template <typename... T> void println(std::wostream& os, wformat_string<T...> fmt, T&&... args) { print(os, L"{}\n", fmt::format(fmt, std::forward<T>(args)...)); } /// Converts `value` to `std::wstring` using the default format for type `T`. template <typename T> inline auto to_wstring(const T& value) -> std::wstring { return format(FMT_STRING(L"{}"), value); } FMT_END_EXPORT FMT_END_NAMESPACE #endif // FMT_XCHAR_H_ ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/vendor/http_parser/������������������������������������������������������������������0000775�0000000�0000000�00000000000�14771603147�0017177�5����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/vendor/http_parser/LICENSE-MIT�������������������������������������������������������0000664�0000000�0000000�00000002065�14771603147�0020636�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������Copyright Joyent, Inc. and other Node contributors. Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. ���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/vendor/http_parser/http_parser.c�����������������������������������������������������0000664�0000000�0000000�00000224246�14771603147�0021710�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* Copyright Joyent, Inc. and other Node contributors. * * Permission is hereby granted, free of charge, to any person obtaining a copy * of this software and associated documentation files (the "Software"), to * deal in the Software without restriction, including without limitation the * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or * sell copies of the Software, and to permit persons to whom the Software is * furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be included in * all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS * IN THE SOFTWARE. */ #include "http_parser.h" #include <assert.h> #include <stddef.h> #include <ctype.h> #include <string.h> #include <limits.h> static uint32_t max_header_size = HTTP_MAX_HEADER_SIZE; #ifndef ULLONG_MAX # define ULLONG_MAX ((uint64_t) -1) /* 2^64-1 */ #endif #ifndef MIN # define MIN(a,b) ((a) < (b) ? (a) : (b)) #endif #ifndef ARRAY_SIZE # define ARRAY_SIZE(a) (sizeof(a) / sizeof((a)[0])) #endif #ifndef BIT_AT # define BIT_AT(a, i) \ (!!((unsigned int) (a)[(unsigned int) (i) >> 3] & \ (1 << ((unsigned int) (i) & 7)))) #endif #ifndef ELEM_AT # define ELEM_AT(a, i, v) ((unsigned int) (i) < ARRAY_SIZE(a) ? (a)[(i)] : (v)) #endif #define SET_ERRNO(e) \ do { \ parser->nread = nread; \ parser->http_errno = (e); \ } while(0) #define CURRENT_STATE() p_state #define UPDATE_STATE(V) p_state = (enum state) (V); #define RETURN(V) \ do { \ parser->nread = nread; \ parser->state = CURRENT_STATE(); \ return (V); \ } while (0); #define REEXECUTE() \ goto reexecute; \ #ifdef __GNUC__ # define LIKELY(X) __builtin_expect(!!(X), 1) # define UNLIKELY(X) __builtin_expect(!!(X), 0) #else # define LIKELY(X) (X) # define UNLIKELY(X) (X) #endif /* Run the notify callback FOR, returning ER if it fails */ #define CALLBACK_NOTIFY_(FOR, ER) \ do { \ assert(HTTP_PARSER_ERRNO(parser) == HPE_OK); \ \ if (LIKELY(settings->on_##FOR)) { \ parser->state = CURRENT_STATE(); \ if (UNLIKELY(0 != settings->on_##FOR(parser))) { \ SET_ERRNO(HPE_CB_##FOR); \ } \ UPDATE_STATE(parser->state); \ \ /* We either errored above or got paused; get out */ \ if (UNLIKELY(HTTP_PARSER_ERRNO(parser) != HPE_OK)) { \ return (ER); \ } \ } \ } while (0) /* Run the notify callback FOR and consume the current byte */ #define CALLBACK_NOTIFY(FOR) CALLBACK_NOTIFY_(FOR, p - data + 1) /* Run the notify callback FOR and don't consume the current byte */ #define CALLBACK_NOTIFY_NOADVANCE(FOR) CALLBACK_NOTIFY_(FOR, p - data) /* Run data callback FOR with LEN bytes, returning ER if it fails */ #define CALLBACK_DATA_(FOR, LEN, ER) \ do { \ assert(HTTP_PARSER_ERRNO(parser) == HPE_OK); \ \ if (FOR##_mark) { \ if (LIKELY(settings->on_##FOR)) { \ parser->state = CURRENT_STATE(); \ if (UNLIKELY(0 != \ settings->on_##FOR(parser, FOR##_mark, (LEN)))) { \ SET_ERRNO(HPE_CB_##FOR); \ } \ UPDATE_STATE(parser->state); \ \ /* We either errored above or got paused; get out */ \ if (UNLIKELY(HTTP_PARSER_ERRNO(parser) != HPE_OK)) { \ return (ER); \ } \ } \ FOR##_mark = NULL; \ } \ } while (0) /* Run the data callback FOR and consume the current byte */ #define CALLBACK_DATA(FOR) \ CALLBACK_DATA_(FOR, p - FOR##_mark, p - data + 1) /* Run the data callback FOR and don't consume the current byte */ #define CALLBACK_DATA_NOADVANCE(FOR) \ CALLBACK_DATA_(FOR, p - FOR##_mark, p - data) /* Set the mark FOR; non-destructive if mark is already set */ #define MARK(FOR) \ do { \ if (!FOR##_mark) { \ FOR##_mark = p; \ } \ } while (0) /* Don't allow the total size of the HTTP headers (including the status * line) to exceed max_header_size. This check is here to protect * embedders against denial-of-service attacks where the attacker feeds * us a never-ending header that the embedder keeps buffering. * * This check is arguably the responsibility of embedders but we're doing * it on the embedder's behalf because most won't bother and this way we * make the web a little safer. max_header_size is still far bigger * than any reasonable request or response so this should never affect * day-to-day operation. */ #define COUNT_HEADER_SIZE(V) \ do { \ nread += (uint32_t)(V); \ if (UNLIKELY(nread > max_header_size)) { \ SET_ERRNO(HPE_HEADER_OVERFLOW); \ goto error; \ } \ } while (0) #define PROXY_CONNECTION "proxy-connection" #define CONNECTION "connection" #define CONTENT_LENGTH "content-length" #define TRANSFER_ENCODING "transfer-encoding" #define UPGRADE "upgrade" #define CHUNKED "chunked" #define KEEP_ALIVE "keep-alive" #define CLOSE "close" static const char *method_strings[] = { #define XX(num, name, string) #string, HTTP_METHOD_MAP(XX) #undef XX }; /* Tokens as defined by rfc 2616. Also lowercases them. * token = 1*<any CHAR except CTLs or separators> * separators = "(" | ")" | "<" | ">" | "@" * | "," | ";" | ":" | "\" | <"> * | "/" | "[" | "]" | "?" | "=" * | "{" | "}" | SP | HT */ static const char tokens[256] = { /* 0 nul 1 soh 2 stx 3 etx 4 eot 5 enq 6 ack 7 bel */ 0, 0, 0, 0, 0, 0, 0, 0, /* 8 bs 9 ht 10 nl 11 vt 12 np 13 cr 14 so 15 si */ 0, 0, 0, 0, 0, 0, 0, 0, /* 16 dle 17 dc1 18 dc2 19 dc3 20 dc4 21 nak 22 syn 23 etb */ 0, 0, 0, 0, 0, 0, 0, 0, /* 24 can 25 em 26 sub 27 esc 28 fs 29 gs 30 rs 31 us */ 0, 0, 0, 0, 0, 0, 0, 0, /* 32 sp 33 ! 34 " 35 # 36 $ 37 % 38 & 39 ' */ ' ', '!', 0, '#', '$', '%', '&', '\'', /* 40 ( 41 ) 42 * 43 + 44 , 45 - 46 . 47 / */ 0, 0, '*', '+', 0, '-', '.', 0, /* 48 0 49 1 50 2 51 3 52 4 53 5 54 6 55 7 */ '0', '1', '2', '3', '4', '5', '6', '7', /* 56 8 57 9 58 : 59 ; 60 < 61 = 62 > 63 ? */ '8', '9', 0, 0, 0, 0, 0, 0, /* 64 @ 65 A 66 B 67 C 68 D 69 E 70 F 71 G */ 0, 'a', 'b', 'c', 'd', 'e', 'f', 'g', /* 72 H 73 I 74 J 75 K 76 L 77 M 78 N 79 O */ 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', /* 80 P 81 Q 82 R 83 S 84 T 85 U 86 V 87 W */ 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', /* 88 X 89 Y 90 Z 91 [ 92 \ 93 ] 94 ^ 95 _ */ 'x', 'y', 'z', 0, 0, 0, '^', '_', /* 96 ` 97 a 98 b 99 c 100 d 101 e 102 f 103 g */ '`', 'a', 'b', 'c', 'd', 'e', 'f', 'g', /* 104 h 105 i 106 j 107 k 108 l 109 m 110 n 111 o */ 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', /* 112 p 113 q 114 r 115 s 116 t 117 u 118 v 119 w */ 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', /* 120 x 121 y 122 z 123 { 124 | 125 } 126 ~ 127 del */ 'x', 'y', 'z', 0, '|', 0, '~', 0 }; static const int8_t unhex[256] = {-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1 ,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1 ,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1 , 0, 1, 2, 3, 4, 5, 6, 7, 8, 9,-1,-1,-1,-1,-1,-1 ,-1,10,11,12,13,14,15,-1,-1,-1,-1,-1,-1,-1,-1,-1 ,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1 ,-1,10,11,12,13,14,15,-1,-1,-1,-1,-1,-1,-1,-1,-1 ,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1 }; #if HTTP_PARSER_STRICT # define T(v) 0 #else # define T(v) v #endif static const uint8_t normal_url_char[32] = { /* 0 nul 1 soh 2 stx 3 etx 4 eot 5 enq 6 ack 7 bel */ 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0, /* 8 bs 9 ht 10 nl 11 vt 12 np 13 cr 14 so 15 si */ 0 | T(2) | 0 | 0 | T(16) | 0 | 0 | 0, /* 16 dle 17 dc1 18 dc2 19 dc3 20 dc4 21 nak 22 syn 23 etb */ 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0, /* 24 can 25 em 26 sub 27 esc 28 fs 29 gs 30 rs 31 us */ 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0, /* 32 sp 33 ! 34 " 35 # 36 $ 37 % 38 & 39 ' */ 0 | 2 | 4 | 0 | 16 | 32 | 64 | 128, /* 40 ( 41 ) 42 * 43 + 44 , 45 - 46 . 47 / */ 1 | 2 | 4 | 8 | 16 | 32 | 64 | 128, /* 48 0 49 1 50 2 51 3 52 4 53 5 54 6 55 7 */ 1 | 2 | 4 | 8 | 16 | 32 | 64 | 128, /* 56 8 57 9 58 : 59 ; 60 < 61 = 62 > 63 ? */ 1 | 2 | 4 | 8 | 16 | 32 | 64 | 0, /* 64 @ 65 A 66 B 67 C 68 D 69 E 70 F 71 G */ 1 | 2 | 4 | 8 | 16 | 32 | 64 | 128, /* 72 H 73 I 74 J 75 K 76 L 77 M 78 N 79 O */ 1 | 2 | 4 | 8 | 16 | 32 | 64 | 128, /* 80 P 81 Q 82 R 83 S 84 T 85 U 86 V 87 W */ 1 | 2 | 4 | 8 | 16 | 32 | 64 | 128, /* 88 X 89 Y 90 Z 91 [ 92 \ 93 ] 94 ^ 95 _ */ 1 | 2 | 4 | 8 | 16 | 32 | 64 | 128, /* 96 ` 97 a 98 b 99 c 100 d 101 e 102 f 103 g */ 1 | 2 | 4 | 8 | 16 | 32 | 64 | 128, /* 104 h 105 i 106 j 107 k 108 l 109 m 110 n 111 o */ 1 | 2 | 4 | 8 | 16 | 32 | 64 | 128, /* 112 p 113 q 114 r 115 s 116 t 117 u 118 v 119 w */ 1 | 2 | 4 | 8 | 16 | 32 | 64 | 128, /* 120 x 121 y 122 z 123 { 124 | 125 } 126 ~ 127 del */ 1 | 2 | 4 | 8 | 16 | 32 | 64 | 0, }; #undef T enum state { s_dead = 1 /* important that this is > 0 */ , s_start_req_or_res , s_res_or_resp_H , s_start_res , s_res_H , s_res_HT , s_res_HTT , s_res_HTTP , s_res_http_major , s_res_http_dot , s_res_http_minor , s_res_http_end , s_res_first_status_code , s_res_status_code , s_res_status_start , s_res_status , s_res_line_almost_done , s_start_req , s_req_method , s_req_spaces_before_url , s_req_schema , s_req_schema_slash , s_req_schema_slash_slash , s_req_server_start , s_req_server , s_req_server_with_at , s_req_path , s_req_query_string_start , s_req_query_string , s_req_fragment_start , s_req_fragment , s_req_http_start , s_req_http_H , s_req_http_HT , s_req_http_HTT , s_req_http_HTTP , s_req_http_I , s_req_http_IC , s_req_http_major , s_req_http_dot , s_req_http_minor , s_req_http_end , s_req_line_almost_done , s_header_field_start , s_header_field , s_header_value_discard_ws , s_header_value_discard_ws_almost_done , s_header_value_discard_lws , s_header_value_start , s_header_value , s_header_value_lws , s_header_almost_done , s_chunk_size_start , s_chunk_size , s_chunk_parameters , s_chunk_size_almost_done , s_headers_almost_done , s_headers_done /* Important: 's_headers_done' must be the last 'header' state. All * states beyond this must be 'body' states. It is used for overflow * checking. See the PARSING_HEADER() macro. */ , s_chunk_data , s_chunk_data_almost_done , s_chunk_data_done , s_body_identity , s_body_identity_eof , s_message_done }; #define PARSING_HEADER(state) (state <= s_headers_done) enum header_states { h_general = 0 , h_C , h_CO , h_CON , h_matching_connection , h_matching_proxy_connection , h_matching_content_length , h_matching_transfer_encoding , h_matching_upgrade , h_connection , h_content_length , h_content_length_num , h_content_length_ws , h_transfer_encoding , h_upgrade , h_matching_transfer_encoding_token_start , h_matching_transfer_encoding_chunked , h_matching_transfer_encoding_token , h_matching_connection_token_start , h_matching_connection_keep_alive , h_matching_connection_close , h_matching_connection_upgrade , h_matching_connection_token , h_transfer_encoding_chunked , h_connection_keep_alive , h_connection_close , h_connection_upgrade }; enum http_host_state { s_http_host_dead = 1 , s_http_userinfo_start , s_http_userinfo , s_http_host_start , s_http_host_v6_start , s_http_host , s_http_host_v6 , s_http_host_v6_end , s_http_host_v6_zone_start , s_http_host_v6_zone , s_http_host_port_start , s_http_host_port }; /* Macros for character classes; depends on strict-mode */ #define CR '\r' #define LF '\n' #define LOWER(c) (unsigned char)(c | 0x20) #define IS_ALPHA(c) (LOWER(c) >= 'a' && LOWER(c) <= 'z') #define IS_NUM(c) ((c) >= '0' && (c) <= '9') #define IS_ALPHANUM(c) (IS_ALPHA(c) || IS_NUM(c)) #define IS_HEX(c) (IS_NUM(c) || (LOWER(c) >= 'a' && LOWER(c) <= 'f')) #define IS_MARK(c) ((c) == '-' || (c) == '_' || (c) == '.' || \ (c) == '!' || (c) == '~' || (c) == '*' || (c) == '\'' || (c) == '(' || \ (c) == ')') #define IS_USERINFO_CHAR(c) (IS_ALPHANUM(c) || IS_MARK(c) || (c) == '%' || \ (c) == ';' || (c) == ':' || (c) == '&' || (c) == '=' || (c) == '+' || \ (c) == '$' || (c) == ',') #define STRICT_TOKEN(c) ((c == ' ') ? 0 : tokens[(unsigned char)c]) #if HTTP_PARSER_STRICT #define TOKEN(c) STRICT_TOKEN(c) #define IS_URL_CHAR(c) (BIT_AT(normal_url_char, (unsigned char)c)) #define IS_HOST_CHAR(c) (IS_ALPHANUM(c) || (c) == '.' || (c) == '-') #else #define TOKEN(c) tokens[(unsigned char)c] #define IS_URL_CHAR(c) \ (BIT_AT(normal_url_char, (unsigned char)c) || ((c) & 0x80)) #define IS_HOST_CHAR(c) \ (IS_ALPHANUM(c) || (c) == '.' || (c) == '-' || (c) == '_') #endif /** * Verify that a char is a valid visible (printable) US-ASCII * character or %x80-FF **/ #define IS_HEADER_CHAR(ch) \ (ch == CR || ch == LF || ch == 9 || ((unsigned char)ch > 31 && ch != 127)) #define start_state (parser->type == HTTP_REQUEST ? s_start_req : s_start_res) #if HTTP_PARSER_STRICT # define STRICT_CHECK(cond) \ do { \ if (cond) { \ SET_ERRNO(HPE_STRICT); \ goto error; \ } \ } while (0) # define NEW_MESSAGE() (http_should_keep_alive(parser) ? start_state : s_dead) #else # define STRICT_CHECK(cond) # define NEW_MESSAGE() start_state #endif /* Map errno values to strings for human-readable output */ #define HTTP_STRERROR_GEN(n, s) { "HPE_" #n, s }, static struct { const char *name; const char *description; } http_strerror_tab[] = { HTTP_ERRNO_MAP(HTTP_STRERROR_GEN) }; #undef HTTP_STRERROR_GEN int http_message_needs_eof(const http_parser *parser); /* Our URL parser. * * This is designed to be shared by http_parser_execute() for URL validation, * hence it has a state transition + byte-for-byte interface. In addition, it * is meant to be embedded in http_parser_parse_url(), which does the dirty * work of turning state transitions URL components for its API. * * This function should only be invoked with non-space characters. It is * assumed that the caller cares about (and can detect) the transition between * URL and non-URL states by looking for these. */ static enum state parse_url_char(enum state s, const char ch) { if (ch == ' ' || ch == '\r' || ch == '\n') { return s_dead; } #if HTTP_PARSER_STRICT if (ch == '\t' || ch == '\f') { return s_dead; } #endif switch (s) { case s_req_spaces_before_url: /* Proxied requests are followed by scheme of an absolute URI (alpha). * All methods except CONNECT are followed by '/' or '*'. */ if (ch == '/' || ch == '*') { return s_req_path; } if (IS_ALPHA(ch)) { return s_req_schema; } break; case s_req_schema: if (IS_ALPHA(ch)) { return s; } if (ch == ':') { return s_req_schema_slash; } break; case s_req_schema_slash: if (ch == '/') { return s_req_schema_slash_slash; } break; case s_req_schema_slash_slash: if (ch == '/') { return s_req_server_start; } break; case s_req_server_with_at: if (ch == '@') { return s_dead; } /* fall through */ case s_req_server_start: case s_req_server: if (ch == '/') { return s_req_path; } if (ch == '?') { return s_req_query_string_start; } if (ch == '@') { return s_req_server_with_at; } if (IS_USERINFO_CHAR(ch) || ch == '[' || ch == ']') { return s_req_server; } break; case s_req_path: if (IS_URL_CHAR(ch)) { return s; } switch (ch) { case '?': return s_req_query_string_start; case '#': return s_req_fragment_start; } break; case s_req_query_string_start: case s_req_query_string: if (IS_URL_CHAR(ch)) { return s_req_query_string; } switch (ch) { case '?': /* allow extra '?' in query string */ return s_req_query_string; case '#': return s_req_fragment_start; } break; case s_req_fragment_start: if (IS_URL_CHAR(ch)) { return s_req_fragment; } switch (ch) { case '?': return s_req_fragment; case '#': return s; } break; case s_req_fragment: if (IS_URL_CHAR(ch)) { return s; } switch (ch) { case '?': case '#': return s; } break; default: break; } /* We should never fall out of the switch above unless there's an error */ return s_dead; } size_t http_parser_execute (http_parser *parser, const http_parser_settings *settings, const char *data, size_t len) { char c, ch; int8_t unhex_val; const char *p = data; const char *header_field_mark = 0; const char *header_value_mark = 0; const char *url_mark = 0; const char *body_mark = 0; const char *status_mark = 0; enum state p_state = (enum state) parser->state; const unsigned int lenient = parser->lenient_http_headers; const unsigned int allow_chunked_length = parser->allow_chunked_length; uint32_t nread = parser->nread; /* We're in an error state. Don't bother doing anything. */ if (HTTP_PARSER_ERRNO(parser) != HPE_OK) { return 0; } if (len == 0) { switch (CURRENT_STATE()) { case s_body_identity_eof: /* Use of CALLBACK_NOTIFY() here would erroneously return 1 byte read if * we got paused. */ CALLBACK_NOTIFY_NOADVANCE(message_complete); return 0; case s_dead: case s_start_req_or_res: case s_start_res: case s_start_req: return 0; default: SET_ERRNO(HPE_INVALID_EOF_STATE); return 1; } } if (CURRENT_STATE() == s_header_field) header_field_mark = data; if (CURRENT_STATE() == s_header_value) header_value_mark = data; switch (CURRENT_STATE()) { case s_req_path: case s_req_schema: case s_req_schema_slash: case s_req_schema_slash_slash: case s_req_server_start: case s_req_server: case s_req_server_with_at: case s_req_query_string_start: case s_req_query_string: case s_req_fragment_start: case s_req_fragment: url_mark = data; break; case s_res_status: status_mark = data; break; default: break; } for (p=data; p != data + len; p++) { ch = *p; if (PARSING_HEADER(CURRENT_STATE())) COUNT_HEADER_SIZE(1); reexecute: switch (CURRENT_STATE()) { case s_dead: /* this state is used after a 'Connection: close' message * the parser will error out if it reads another message */ if (LIKELY(ch == CR || ch == LF)) break; SET_ERRNO(HPE_CLOSED_CONNECTION); goto error; case s_start_req_or_res: { if (ch == CR || ch == LF) break; parser->flags = 0; parser->uses_transfer_encoding = 0; parser->content_length = ULLONG_MAX; if (ch == 'H') { UPDATE_STATE(s_res_or_resp_H); CALLBACK_NOTIFY(message_begin); } else { parser->type = HTTP_REQUEST; UPDATE_STATE(s_start_req); REEXECUTE(); } break; } case s_res_or_resp_H: if (ch == 'T') { parser->type = HTTP_RESPONSE; UPDATE_STATE(s_res_HT); } else { if (UNLIKELY(ch != 'E')) { SET_ERRNO(HPE_INVALID_CONSTANT); goto error; } parser->type = HTTP_REQUEST; parser->method = HTTP_HEAD; parser->index = 2; UPDATE_STATE(s_req_method); } break; case s_start_res: { if (ch == CR || ch == LF) break; parser->flags = 0; parser->uses_transfer_encoding = 0; parser->content_length = ULLONG_MAX; if (ch == 'H') { UPDATE_STATE(s_res_H); } else { SET_ERRNO(HPE_INVALID_CONSTANT); goto error; } CALLBACK_NOTIFY(message_begin); break; } case s_res_H: STRICT_CHECK(ch != 'T'); UPDATE_STATE(s_res_HT); break; case s_res_HT: STRICT_CHECK(ch != 'T'); UPDATE_STATE(s_res_HTT); break; case s_res_HTT: STRICT_CHECK(ch != 'P'); UPDATE_STATE(s_res_HTTP); break; case s_res_HTTP: STRICT_CHECK(ch != '/'); UPDATE_STATE(s_res_http_major); break; case s_res_http_major: if (UNLIKELY(!IS_NUM(ch))) { SET_ERRNO(HPE_INVALID_VERSION); goto error; } parser->http_major = ch - '0'; UPDATE_STATE(s_res_http_dot); break; case s_res_http_dot: { if (UNLIKELY(ch != '.')) { SET_ERRNO(HPE_INVALID_VERSION); goto error; } UPDATE_STATE(s_res_http_minor); break; } case s_res_http_minor: if (UNLIKELY(!IS_NUM(ch))) { SET_ERRNO(HPE_INVALID_VERSION); goto error; } parser->http_minor = ch - '0'; UPDATE_STATE(s_res_http_end); break; case s_res_http_end: { if (UNLIKELY(ch != ' ')) { SET_ERRNO(HPE_INVALID_VERSION); goto error; } UPDATE_STATE(s_res_first_status_code); break; } case s_res_first_status_code: { if (!IS_NUM(ch)) { if (ch == ' ') { break; } SET_ERRNO(HPE_INVALID_STATUS); goto error; } parser->status_code = ch - '0'; UPDATE_STATE(s_res_status_code); break; } case s_res_status_code: { if (!IS_NUM(ch)) { switch (ch) { case ' ': UPDATE_STATE(s_res_status_start); break; case CR: case LF: UPDATE_STATE(s_res_status_start); REEXECUTE(); break; default: SET_ERRNO(HPE_INVALID_STATUS); goto error; } break; } parser->status_code *= 10; parser->status_code += ch - '0'; if (UNLIKELY(parser->status_code > 999)) { SET_ERRNO(HPE_INVALID_STATUS); goto error; } break; } case s_res_status_start: { MARK(status); UPDATE_STATE(s_res_status); parser->index = 0; if (ch == CR || ch == LF) REEXECUTE(); break; } case s_res_status: if (ch == CR) { UPDATE_STATE(s_res_line_almost_done); CALLBACK_DATA(status); break; } if (ch == LF) { UPDATE_STATE(s_header_field_start); CALLBACK_DATA(status); break; } break; case s_res_line_almost_done: STRICT_CHECK(ch != LF); UPDATE_STATE(s_header_field_start); break; case s_start_req: { if (ch == CR || ch == LF) break; parser->flags = 0; parser->uses_transfer_encoding = 0; parser->content_length = ULLONG_MAX; if (UNLIKELY(!IS_ALPHA(ch))) { SET_ERRNO(HPE_INVALID_METHOD); goto error; } parser->method = (enum http_method) 0; parser->index = 1; switch (ch) { case 'A': parser->method = HTTP_ACL; break; case 'B': parser->method = HTTP_BIND; break; case 'C': parser->method = HTTP_CONNECT; /* or COPY, CHECKOUT */ break; case 'D': parser->method = HTTP_DELETE; break; case 'G': parser->method = HTTP_GET; break; case 'H': parser->method = HTTP_HEAD; break; case 'L': parser->method = HTTP_LOCK; /* or LINK */ break; case 'M': parser->method = HTTP_MKCOL; /* or MOVE, MKACTIVITY, MERGE, M-SEARCH, MKCALENDAR */ break; case 'N': parser->method = HTTP_NOTIFY; break; case 'O': parser->method = HTTP_OPTIONS; break; case 'P': parser->method = HTTP_POST; /* or PROPFIND|PROPPATCH|PUT|PATCH|PURGE */ break; case 'R': parser->method = HTTP_REPORT; /* or REBIND */ break; case 'S': parser->method = HTTP_SUBSCRIBE; /* or SEARCH, SOURCE */ break; case 'T': parser->method = HTTP_TRACE; break; case 'U': parser->method = HTTP_UNLOCK; /* or UNSUBSCRIBE, UNBIND, UNLINK */ break; default: SET_ERRNO(HPE_INVALID_METHOD); goto error; } UPDATE_STATE(s_req_method); CALLBACK_NOTIFY(message_begin); break; } case s_req_method: { const char *matcher; if (UNLIKELY(ch == '\0')) { SET_ERRNO(HPE_INVALID_METHOD); goto error; } matcher = method_strings[parser->method]; if (ch == ' ' && matcher[parser->index] == '\0') { UPDATE_STATE(s_req_spaces_before_url); } else if (ch == matcher[parser->index]) { ; /* nada */ } else if ((ch >= 'A' && ch <= 'Z') || ch == '-') { switch (parser->method << 16 | parser->index << 8 | ch) { #define XX(meth, pos, ch, new_meth) \ case (HTTP_##meth << 16 | pos << 8 | ch): \ parser->method = HTTP_##new_meth; break; XX(POST, 1, 'U', PUT) XX(POST, 1, 'A', PATCH) XX(POST, 1, 'R', PROPFIND) XX(PUT, 2, 'R', PURGE) XX(CONNECT, 1, 'H', CHECKOUT) XX(CONNECT, 2, 'P', COPY) XX(MKCOL, 1, 'O', MOVE) XX(MKCOL, 1, 'E', MERGE) XX(MKCOL, 1, '-', MSEARCH) XX(MKCOL, 2, 'A', MKACTIVITY) XX(MKCOL, 3, 'A', MKCALENDAR) XX(SUBSCRIBE, 1, 'E', SEARCH) XX(SUBSCRIBE, 1, 'O', SOURCE) XX(REPORT, 2, 'B', REBIND) XX(PROPFIND, 4, 'P', PROPPATCH) XX(LOCK, 1, 'I', LINK) XX(UNLOCK, 2, 'S', UNSUBSCRIBE) XX(UNLOCK, 2, 'B', UNBIND) XX(UNLOCK, 3, 'I', UNLINK) #undef XX default: SET_ERRNO(HPE_INVALID_METHOD); goto error; } } else { SET_ERRNO(HPE_INVALID_METHOD); goto error; } ++parser->index; break; } case s_req_spaces_before_url: { if (ch == ' ') break; MARK(url); if (parser->method == HTTP_CONNECT) { UPDATE_STATE(s_req_server_start); } UPDATE_STATE(parse_url_char(CURRENT_STATE(), ch)); if (UNLIKELY(CURRENT_STATE() == s_dead)) { SET_ERRNO(HPE_INVALID_URL); goto error; } break; } case s_req_schema: case s_req_schema_slash: case s_req_schema_slash_slash: case s_req_server_start: { switch (ch) { /* No whitespace allowed here */ case ' ': case CR: case LF: SET_ERRNO(HPE_INVALID_URL); goto error; default: UPDATE_STATE(parse_url_char(CURRENT_STATE(), ch)); if (UNLIKELY(CURRENT_STATE() == s_dead)) { SET_ERRNO(HPE_INVALID_URL); goto error; } } break; } case s_req_server: case s_req_server_with_at: case s_req_path: case s_req_query_string_start: case s_req_query_string: case s_req_fragment_start: case s_req_fragment: { switch (ch) { case ' ': UPDATE_STATE(s_req_http_start); CALLBACK_DATA(url); break; case CR: case LF: parser->http_major = 0; parser->http_minor = 9; UPDATE_STATE((ch == CR) ? s_req_line_almost_done : s_header_field_start); CALLBACK_DATA(url); break; default: UPDATE_STATE(parse_url_char(CURRENT_STATE(), ch)); if (UNLIKELY(CURRENT_STATE() == s_dead)) { SET_ERRNO(HPE_INVALID_URL); goto error; } } break; } case s_req_http_start: switch (ch) { case ' ': break; case 'H': UPDATE_STATE(s_req_http_H); break; case 'I': if (parser->method == HTTP_SOURCE) { UPDATE_STATE(s_req_http_I); break; } /* fall through */ default: SET_ERRNO(HPE_INVALID_CONSTANT); goto error; } break; case s_req_http_H: STRICT_CHECK(ch != 'T'); UPDATE_STATE(s_req_http_HT); break; case s_req_http_HT: STRICT_CHECK(ch != 'T'); UPDATE_STATE(s_req_http_HTT); break; case s_req_http_HTT: STRICT_CHECK(ch != 'P'); UPDATE_STATE(s_req_http_HTTP); break; case s_req_http_I: STRICT_CHECK(ch != 'C'); UPDATE_STATE(s_req_http_IC); break; case s_req_http_IC: STRICT_CHECK(ch != 'E'); UPDATE_STATE(s_req_http_HTTP); /* Treat "ICE" as "HTTP". */ break; case s_req_http_HTTP: STRICT_CHECK(ch != '/'); UPDATE_STATE(s_req_http_major); break; case s_req_http_major: if (UNLIKELY(!IS_NUM(ch))) { SET_ERRNO(HPE_INVALID_VERSION); goto error; } parser->http_major = ch - '0'; UPDATE_STATE(s_req_http_dot); break; case s_req_http_dot: { if (UNLIKELY(ch != '.')) { SET_ERRNO(HPE_INVALID_VERSION); goto error; } UPDATE_STATE(s_req_http_minor); break; } case s_req_http_minor: if (UNLIKELY(!IS_NUM(ch))) { SET_ERRNO(HPE_INVALID_VERSION); goto error; } parser->http_minor = ch - '0'; UPDATE_STATE(s_req_http_end); break; case s_req_http_end: { if (ch == CR) { UPDATE_STATE(s_req_line_almost_done); break; } if (ch == LF) { UPDATE_STATE(s_header_field_start); break; } SET_ERRNO(HPE_INVALID_VERSION); goto error; break; } /* end of request line */ case s_req_line_almost_done: { if (UNLIKELY(ch != LF)) { SET_ERRNO(HPE_LF_EXPECTED); goto error; } UPDATE_STATE(s_header_field_start); break; } case s_header_field_start: { if (ch == CR) { UPDATE_STATE(s_headers_almost_done); break; } if (ch == LF) { /* they might be just sending \n instead of \r\n so this would be * the second \n to denote the end of headers*/ UPDATE_STATE(s_headers_almost_done); REEXECUTE(); } c = TOKEN(ch); if (UNLIKELY(!c)) { SET_ERRNO(HPE_INVALID_HEADER_TOKEN); goto error; } MARK(header_field); parser->index = 0; UPDATE_STATE(s_header_field); switch (c) { case 'c': parser->header_state = h_C; break; case 'p': parser->header_state = h_matching_proxy_connection; break; case 't': parser->header_state = h_matching_transfer_encoding; break; case 'u': parser->header_state = h_matching_upgrade; break; default: parser->header_state = h_general; break; } break; } case s_header_field: { const char* start = p; for (; p != data + len; p++) { ch = *p; c = TOKEN(ch); if (!c) break; switch (parser->header_state) { case h_general: { size_t left = data + len - p; const char* pe = p + MIN(left, max_header_size); while (p+1 < pe && TOKEN(p[1])) { p++; } break; } case h_C: parser->index++; parser->header_state = (c == 'o' ? h_CO : h_general); break; case h_CO: parser->index++; parser->header_state = (c == 'n' ? h_CON : h_general); break; case h_CON: parser->index++; switch (c) { case 'n': parser->header_state = h_matching_connection; break; case 't': parser->header_state = h_matching_content_length; break; default: parser->header_state = h_general; break; } break; /* connection */ case h_matching_connection: parser->index++; if (parser->index > sizeof(CONNECTION)-1 || c != CONNECTION[parser->index]) { parser->header_state = h_general; } else if (parser->index == sizeof(CONNECTION)-2) { parser->header_state = h_connection; } break; /* proxy-connection */ case h_matching_proxy_connection: parser->index++; if (parser->index > sizeof(PROXY_CONNECTION)-1 || c != PROXY_CONNECTION[parser->index]) { parser->header_state = h_general; } else if (parser->index == sizeof(PROXY_CONNECTION)-2) { parser->header_state = h_connection; } break; /* content-length */ case h_matching_content_length: parser->index++; if (parser->index > sizeof(CONTENT_LENGTH)-1 || c != CONTENT_LENGTH[parser->index]) { parser->header_state = h_general; } else if (parser->index == sizeof(CONTENT_LENGTH)-2) { parser->header_state = h_content_length; } break; /* transfer-encoding */ case h_matching_transfer_encoding: parser->index++; if (parser->index > sizeof(TRANSFER_ENCODING)-1 || c != TRANSFER_ENCODING[parser->index]) { parser->header_state = h_general; } else if (parser->index == sizeof(TRANSFER_ENCODING)-2) { parser->header_state = h_transfer_encoding; parser->uses_transfer_encoding = 1; /* Multiple `Transfer-Encoding` headers should be treated as * one, but with values separate by a comma. * * See: https://tools.ietf.org/html/rfc7230#section-3.2.2 */ parser->flags &= ~F_CHUNKED; } break; /* upgrade */ case h_matching_upgrade: parser->index++; if (parser->index > sizeof(UPGRADE)-1 || c != UPGRADE[parser->index]) { parser->header_state = h_general; } else if (parser->index == sizeof(UPGRADE)-2) { parser->header_state = h_upgrade; } break; case h_connection: case h_content_length: case h_transfer_encoding: case h_upgrade: if (ch != ' ') parser->header_state = h_general; break; default: assert(0 && "Unknown header_state"); break; } } if (p == data + len) { --p; COUNT_HEADER_SIZE(p - start); break; } COUNT_HEADER_SIZE(p - start); if (ch == ':') { UPDATE_STATE(s_header_value_discard_ws); CALLBACK_DATA(header_field); break; } SET_ERRNO(HPE_INVALID_HEADER_TOKEN); goto error; } case s_header_value_discard_ws: if (ch == ' ' || ch == '\t') break; if (ch == CR) { UPDATE_STATE(s_header_value_discard_ws_almost_done); break; } if (ch == LF) { UPDATE_STATE(s_header_value_discard_lws); break; } /* fall through */ case s_header_value_start: { MARK(header_value); UPDATE_STATE(s_header_value); parser->index = 0; c = LOWER(ch); switch (parser->header_state) { case h_upgrade: parser->flags |= F_UPGRADE; parser->header_state = h_general; break; case h_transfer_encoding: /* looking for 'Transfer-Encoding: chunked' */ if ('c' == c) { parser->header_state = h_matching_transfer_encoding_chunked; } else { parser->header_state = h_matching_transfer_encoding_token; } break; /* Multi-value `Transfer-Encoding` header */ case h_matching_transfer_encoding_token_start: break; case h_content_length: if (UNLIKELY(!IS_NUM(ch))) { SET_ERRNO(HPE_INVALID_CONTENT_LENGTH); goto error; } if (parser->flags & F_CONTENTLENGTH) { SET_ERRNO(HPE_UNEXPECTED_CONTENT_LENGTH); goto error; } parser->flags |= F_CONTENTLENGTH; parser->content_length = ch - '0'; parser->header_state = h_content_length_num; break; /* when obsolete line folding is encountered for content length * continue to the s_header_value state */ case h_content_length_ws: break; case h_connection: /* looking for 'Connection: keep-alive' */ if (c == 'k') { parser->header_state = h_matching_connection_keep_alive; /* looking for 'Connection: close' */ } else if (c == 'c') { parser->header_state = h_matching_connection_close; } else if (c == 'u') { parser->header_state = h_matching_connection_upgrade; } else { parser->header_state = h_matching_connection_token; } break; /* Multi-value `Connection` header */ case h_matching_connection_token_start: break; default: parser->header_state = h_general; break; } break; } case s_header_value: { const char* start = p; enum header_states h_state = (enum header_states) parser->header_state; for (; p != data + len; p++) { ch = *p; if (ch == CR) { UPDATE_STATE(s_header_almost_done); parser->header_state = h_state; CALLBACK_DATA(header_value); break; } if (ch == LF) { UPDATE_STATE(s_header_almost_done); COUNT_HEADER_SIZE(p - start); parser->header_state = h_state; CALLBACK_DATA_NOADVANCE(header_value); REEXECUTE(); } if (!lenient && !IS_HEADER_CHAR(ch)) { SET_ERRNO(HPE_INVALID_HEADER_TOKEN); goto error; } c = LOWER(ch); switch (h_state) { case h_general: { size_t left = data + len - p; const char* pe = p + MIN(left, max_header_size); for (; p != pe; p++) { ch = *p; if (ch == CR || ch == LF) { --p; break; } if (!lenient && !IS_HEADER_CHAR(ch)) { SET_ERRNO(HPE_INVALID_HEADER_TOKEN); goto error; } } if (p == data + len) --p; break; } case h_connection: case h_transfer_encoding: assert(0 && "Shouldn't get here."); break; case h_content_length: if (ch == ' ') break; h_state = h_content_length_num; /* fall through */ case h_content_length_num: { uint64_t t; if (ch == ' ') { h_state = h_content_length_ws; break; } if (UNLIKELY(!IS_NUM(ch))) { SET_ERRNO(HPE_INVALID_CONTENT_LENGTH); parser->header_state = h_state; goto error; } t = parser->content_length; t *= 10; t += ch - '0'; /* Overflow? Test against a conservative limit for simplicity. */ if (UNLIKELY((ULLONG_MAX - 10) / 10 < parser->content_length)) { SET_ERRNO(HPE_INVALID_CONTENT_LENGTH); parser->header_state = h_state; goto error; } parser->content_length = t; break; } case h_content_length_ws: if (ch == ' ') break; SET_ERRNO(HPE_INVALID_CONTENT_LENGTH); parser->header_state = h_state; goto error; /* Transfer-Encoding: chunked */ case h_matching_transfer_encoding_token_start: /* looking for 'Transfer-Encoding: chunked' */ if ('c' == c) { h_state = h_matching_transfer_encoding_chunked; } else if (STRICT_TOKEN(c)) { /* TODO(indutny): similar code below does this, but why? * At the very least it seems to be inconsistent given that * h_matching_transfer_encoding_token does not check for * `STRICT_TOKEN` */ h_state = h_matching_transfer_encoding_token; } else if (c == ' ' || c == '\t') { /* Skip lws */ } else { h_state = h_general; } break; case h_matching_transfer_encoding_chunked: parser->index++; if (parser->index > sizeof(CHUNKED)-1 || c != CHUNKED[parser->index]) { h_state = h_matching_transfer_encoding_token; } else if (parser->index == sizeof(CHUNKED)-2) { h_state = h_transfer_encoding_chunked; } break; case h_matching_transfer_encoding_token: if (ch == ',') { h_state = h_matching_transfer_encoding_token_start; parser->index = 0; } break; case h_matching_connection_token_start: /* looking for 'Connection: keep-alive' */ if (c == 'k') { h_state = h_matching_connection_keep_alive; /* looking for 'Connection: close' */ } else if (c == 'c') { h_state = h_matching_connection_close; } else if (c == 'u') { h_state = h_matching_connection_upgrade; } else if (STRICT_TOKEN(c)) { h_state = h_matching_connection_token; } else if (c == ' ' || c == '\t') { /* Skip lws */ } else { h_state = h_general; } break; /* looking for 'Connection: keep-alive' */ case h_matching_connection_keep_alive: parser->index++; if (parser->index > sizeof(KEEP_ALIVE)-1 || c != KEEP_ALIVE[parser->index]) { h_state = h_matching_connection_token; } else if (parser->index == sizeof(KEEP_ALIVE)-2) { h_state = h_connection_keep_alive; } break; /* looking for 'Connection: close' */ case h_matching_connection_close: parser->index++; if (parser->index > sizeof(CLOSE)-1 || c != CLOSE[parser->index]) { h_state = h_matching_connection_token; } else if (parser->index == sizeof(CLOSE)-2) { h_state = h_connection_close; } break; /* looking for 'Connection: upgrade' */ case h_matching_connection_upgrade: parser->index++; if (parser->index > sizeof(UPGRADE) - 1 || c != UPGRADE[parser->index]) { h_state = h_matching_connection_token; } else if (parser->index == sizeof(UPGRADE)-2) { h_state = h_connection_upgrade; } break; case h_matching_connection_token: if (ch == ',') { h_state = h_matching_connection_token_start; parser->index = 0; } break; case h_transfer_encoding_chunked: if (ch != ' ') h_state = h_matching_transfer_encoding_token; break; case h_connection_keep_alive: case h_connection_close: case h_connection_upgrade: if (ch == ',') { if (h_state == h_connection_keep_alive) { parser->flags |= F_CONNECTION_KEEP_ALIVE; } else if (h_state == h_connection_close) { parser->flags |= F_CONNECTION_CLOSE; } else if (h_state == h_connection_upgrade) { parser->flags |= F_CONNECTION_UPGRADE; } h_state = h_matching_connection_token_start; parser->index = 0; } else if (ch != ' ') { h_state = h_matching_connection_token; } break; default: UPDATE_STATE(s_header_value); h_state = h_general; break; } } parser->header_state = h_state; if (p == data + len) --p; COUNT_HEADER_SIZE(p - start); break; } case s_header_almost_done: { if (UNLIKELY(ch != LF)) { SET_ERRNO(HPE_LF_EXPECTED); goto error; } UPDATE_STATE(s_header_value_lws); break; } case s_header_value_lws: { if (ch == ' ' || ch == '\t') { if (parser->header_state == h_content_length_num) { /* treat obsolete line folding as space */ parser->header_state = h_content_length_ws; } UPDATE_STATE(s_header_value_start); REEXECUTE(); } /* finished the header */ switch (parser->header_state) { case h_connection_keep_alive: parser->flags |= F_CONNECTION_KEEP_ALIVE; break; case h_connection_close: parser->flags |= F_CONNECTION_CLOSE; break; case h_transfer_encoding_chunked: parser->flags |= F_CHUNKED; break; case h_connection_upgrade: parser->flags |= F_CONNECTION_UPGRADE; break; default: break; } UPDATE_STATE(s_header_field_start); REEXECUTE(); } case s_header_value_discard_ws_almost_done: { STRICT_CHECK(ch != LF); UPDATE_STATE(s_header_value_discard_lws); break; } case s_header_value_discard_lws: { if (ch == ' ' || ch == '\t') { UPDATE_STATE(s_header_value_discard_ws); break; } else { switch (parser->header_state) { case h_connection_keep_alive: parser->flags |= F_CONNECTION_KEEP_ALIVE; break; case h_connection_close: parser->flags |= F_CONNECTION_CLOSE; break; case h_connection_upgrade: parser->flags |= F_CONNECTION_UPGRADE; break; case h_transfer_encoding_chunked: parser->flags |= F_CHUNKED; break; case h_content_length: /* do not allow empty content length */ SET_ERRNO(HPE_INVALID_CONTENT_LENGTH); goto error; break; default: break; } /* header value was empty */ MARK(header_value); UPDATE_STATE(s_header_field_start); CALLBACK_DATA_NOADVANCE(header_value); REEXECUTE(); } } case s_headers_almost_done: { STRICT_CHECK(ch != LF); if (parser->flags & F_TRAILING) { /* End of a chunked request */ UPDATE_STATE(s_message_done); CALLBACK_NOTIFY_NOADVANCE(chunk_complete); REEXECUTE(); } /* Cannot use transfer-encoding and a content-length header together per the HTTP specification. (RFC 7230 Section 3.3.3) */ if ((parser->uses_transfer_encoding == 1) && (parser->flags & F_CONTENTLENGTH)) { /* Allow it for lenient parsing as long as `Transfer-Encoding` is * not `chunked` or allow_length_with_encoding is set */ if (parser->flags & F_CHUNKED) { if (!allow_chunked_length) { SET_ERRNO(HPE_UNEXPECTED_CONTENT_LENGTH); goto error; } } else if (!lenient) { SET_ERRNO(HPE_UNEXPECTED_CONTENT_LENGTH); goto error; } } UPDATE_STATE(s_headers_done); /* Set this here so that on_headers_complete() callbacks can see it */ if ((parser->flags & F_UPGRADE) && (parser->flags & F_CONNECTION_UPGRADE)) { /* For responses, "Upgrade: foo" and "Connection: upgrade" are * mandatory only when it is a 101 Switching Protocols response, * otherwise it is purely informational, to announce support. */ parser->upgrade = (parser->type == HTTP_REQUEST || parser->status_code == 101); } else { parser->upgrade = (parser->method == HTTP_CONNECT); } /* Here we call the headers_complete callback. This is somewhat * different than other callbacks because if the user returns 1, we * will interpret that as saying that this message has no body. This * is needed for the annoying case of recieving a response to a HEAD * request. * * We'd like to use CALLBACK_NOTIFY_NOADVANCE() here but we cannot, so * we have to simulate it by handling a change in errno below. */ if (settings->on_headers_complete) { switch (settings->on_headers_complete(parser)) { case 0: break; case 2: parser->upgrade = 1; /* fall through */ case 1: parser->flags |= F_SKIPBODY; break; default: SET_ERRNO(HPE_CB_headers_complete); RETURN(p - data); /* Error */ } } if (HTTP_PARSER_ERRNO(parser) != HPE_OK) { RETURN(p - data); } REEXECUTE(); } case s_headers_done: { int hasBody; STRICT_CHECK(ch != LF); parser->nread = 0; nread = 0; hasBody = parser->flags & F_CHUNKED || (parser->content_length > 0 && parser->content_length != ULLONG_MAX); if (parser->upgrade && (parser->method == HTTP_CONNECT || (parser->flags & F_SKIPBODY) || !hasBody)) { /* Exit, the rest of the message is in a different protocol. */ UPDATE_STATE(NEW_MESSAGE()); CALLBACK_NOTIFY(message_complete); RETURN((p - data) + 1); } if (parser->flags & F_SKIPBODY) { UPDATE_STATE(NEW_MESSAGE()); CALLBACK_NOTIFY(message_complete); } else if (parser->flags & F_CHUNKED) { /* chunked encoding - ignore Content-Length header, * prepare for a chunk */ UPDATE_STATE(s_chunk_size_start); } else if (parser->uses_transfer_encoding == 1) { if (parser->type == HTTP_REQUEST && !lenient) { /* RFC 7230 3.3.3 */ /* If a Transfer-Encoding header field * is present in a request and the chunked transfer coding is not * the final encoding, the message body length cannot be determined * reliably; the server MUST respond with the 400 (Bad Request) * status code and then close the connection. */ SET_ERRNO(HPE_INVALID_TRANSFER_ENCODING); RETURN(p - data); /* Error */ } else { /* RFC 7230 3.3.3 */ /* If a Transfer-Encoding header field is present in a response and * the chunked transfer coding is not the final encoding, the * message body length is determined by reading the connection until * it is closed by the server. */ UPDATE_STATE(s_body_identity_eof); } } else { if (parser->content_length == 0) { /* Content-Length header given but zero: Content-Length: 0\r\n */ UPDATE_STATE(NEW_MESSAGE()); CALLBACK_NOTIFY(message_complete); } else if (parser->content_length != ULLONG_MAX) { /* Content-Length header given and non-zero */ UPDATE_STATE(s_body_identity); } else { if (!http_message_needs_eof(parser)) { /* Assume content-length 0 - read the next */ UPDATE_STATE(NEW_MESSAGE()); CALLBACK_NOTIFY(message_complete); } else { /* Read body until EOF */ UPDATE_STATE(s_body_identity_eof); } } } break; } case s_body_identity: { uint64_t to_read = MIN(parser->content_length, (uint64_t) ((data + len) - p)); assert(parser->content_length != 0 && parser->content_length != ULLONG_MAX); /* The difference between advancing content_length and p is because * the latter will automaticaly advance on the next loop iteration. * Further, if content_length ends up at 0, we want to see the last * byte again for our message complete callback. */ MARK(body); parser->content_length -= to_read; p += to_read - 1; if (parser->content_length == 0) { UPDATE_STATE(s_message_done); /* Mimic CALLBACK_DATA_NOADVANCE() but with one extra byte. * * The alternative to doing this is to wait for the next byte to * trigger the data callback, just as in every other case. The * problem with this is that this makes it difficult for the test * harness to distinguish between complete-on-EOF and * complete-on-length. It's not clear that this distinction is * important for applications, but let's keep it for now. */ CALLBACK_DATA_(body, p - body_mark + 1, p - data); REEXECUTE(); } break; } /* read until EOF */ case s_body_identity_eof: MARK(body); p = data + len - 1; break; case s_message_done: UPDATE_STATE(NEW_MESSAGE()); CALLBACK_NOTIFY(message_complete); if (parser->upgrade) { /* Exit, the rest of the message is in a different protocol. */ RETURN((p - data) + 1); } break; case s_chunk_size_start: { assert(nread == 1); assert(parser->flags & F_CHUNKED); unhex_val = unhex[(unsigned char)ch]; if (UNLIKELY(unhex_val == -1)) { SET_ERRNO(HPE_INVALID_CHUNK_SIZE); goto error; } parser->content_length = unhex_val; UPDATE_STATE(s_chunk_size); break; } case s_chunk_size: { uint64_t t; assert(parser->flags & F_CHUNKED); if (ch == CR) { UPDATE_STATE(s_chunk_size_almost_done); break; } unhex_val = unhex[(unsigned char)ch]; if (unhex_val == -1) { if (ch == ';' || ch == ' ') { UPDATE_STATE(s_chunk_parameters); break; } SET_ERRNO(HPE_INVALID_CHUNK_SIZE); goto error; } t = parser->content_length; t *= 16; t += unhex_val; /* Overflow? Test against a conservative limit for simplicity. */ if (UNLIKELY((ULLONG_MAX - 16) / 16 < parser->content_length)) { SET_ERRNO(HPE_INVALID_CONTENT_LENGTH); goto error; } parser->content_length = t; break; } case s_chunk_parameters: { assert(parser->flags & F_CHUNKED); /* just ignore this shit. TODO check for overflow */ if (ch == CR) { UPDATE_STATE(s_chunk_size_almost_done); break; } break; } case s_chunk_size_almost_done: { assert(parser->flags & F_CHUNKED); STRICT_CHECK(ch != LF); parser->nread = 0; nread = 0; if (parser->content_length == 0) { parser->flags |= F_TRAILING; UPDATE_STATE(s_header_field_start); } else { UPDATE_STATE(s_chunk_data); } CALLBACK_NOTIFY(chunk_header); break; } case s_chunk_data: { uint64_t to_read = MIN(parser->content_length, (uint64_t) ((data + len) - p)); assert(parser->flags & F_CHUNKED); assert(parser->content_length != 0 && parser->content_length != ULLONG_MAX); /* See the explanation in s_body_identity for why the content * length and data pointers are managed this way. */ MARK(body); parser->content_length -= to_read; p += to_read - 1; if (parser->content_length == 0) { UPDATE_STATE(s_chunk_data_almost_done); } break; } case s_chunk_data_almost_done: assert(parser->flags & F_CHUNKED); assert(parser->content_length == 0); STRICT_CHECK(ch != CR); UPDATE_STATE(s_chunk_data_done); CALLBACK_DATA(body); break; case s_chunk_data_done: assert(parser->flags & F_CHUNKED); STRICT_CHECK(ch != LF); parser->nread = 0; nread = 0; UPDATE_STATE(s_chunk_size_start); CALLBACK_NOTIFY(chunk_complete); break; default: assert(0 && "unhandled state"); SET_ERRNO(HPE_INVALID_INTERNAL_STATE); goto error; } } /* Run callbacks for any marks that we have leftover after we ran out of * bytes. There should be at most one of these set, so it's OK to invoke * them in series (unset marks will not result in callbacks). * * We use the NOADVANCE() variety of callbacks here because 'p' has already * overflowed 'data' and this allows us to correct for the off-by-one that * we'd otherwise have (since CALLBACK_DATA() is meant to be run with a 'p' * value that's in-bounds). */ assert(((header_field_mark ? 1 : 0) + (header_value_mark ? 1 : 0) + (url_mark ? 1 : 0) + (body_mark ? 1 : 0) + (status_mark ? 1 : 0)) <= 1); CALLBACK_DATA_NOADVANCE(header_field); CALLBACK_DATA_NOADVANCE(header_value); CALLBACK_DATA_NOADVANCE(url); CALLBACK_DATA_NOADVANCE(body); CALLBACK_DATA_NOADVANCE(status); RETURN(len); error: if (HTTP_PARSER_ERRNO(parser) == HPE_OK) { SET_ERRNO(HPE_UNKNOWN); } RETURN(p - data); } /* Does the parser need to see an EOF to find the end of the message? */ int http_message_needs_eof (const http_parser *parser) { if (parser->type == HTTP_REQUEST) { return 0; } /* See RFC 2616 section 4.4 */ if (parser->status_code / 100 == 1 || /* 1xx e.g. Continue */ parser->status_code == 204 || /* No Content */ parser->status_code == 304 || /* Not Modified */ parser->flags & F_SKIPBODY) { /* response to a HEAD request */ return 0; } /* RFC 7230 3.3.3, see `s_headers_almost_done` */ if ((parser->uses_transfer_encoding == 1) && (parser->flags & F_CHUNKED) == 0) { return 1; } if ((parser->flags & F_CHUNKED) || parser->content_length != ULLONG_MAX) { return 0; } return 1; } int http_should_keep_alive (const http_parser *parser) { if (parser->http_major > 0 && parser->http_minor > 0) { /* HTTP/1.1 */ if (parser->flags & F_CONNECTION_CLOSE) { return 0; } } else { /* HTTP/1.0 or earlier */ if (!(parser->flags & F_CONNECTION_KEEP_ALIVE)) { return 0; } } return !http_message_needs_eof(parser); } const char * http_method_str (enum http_method m) { return ELEM_AT(method_strings, m, "<unknown>"); } const char * http_status_str (enum http_status s) { switch (s) { #define XX(num, name, string) case HTTP_STATUS_##name: return #string; HTTP_STATUS_MAP(XX) #undef XX default: return "<unknown>"; } } void http_parser_init (http_parser *parser, enum http_parser_type t) { void *data = parser->data; /* preserve application data */ memset(parser, 0, sizeof(*parser)); parser->data = data; parser->type = t; parser->state = (t == HTTP_REQUEST ? s_start_req : (t == HTTP_RESPONSE ? s_start_res : s_start_req_or_res)); parser->http_errno = HPE_OK; } void http_parser_settings_init(http_parser_settings *settings) { memset(settings, 0, sizeof(*settings)); } const char * http_errno_name(enum http_errno err) { assert(((size_t) err) < ARRAY_SIZE(http_strerror_tab)); return http_strerror_tab[err].name; } const char * http_errno_description(enum http_errno err) { assert(((size_t) err) < ARRAY_SIZE(http_strerror_tab)); return http_strerror_tab[err].description; } static enum http_host_state http_parse_host_char(enum http_host_state s, const char ch) { switch(s) { case s_http_userinfo: case s_http_userinfo_start: if (ch == '@') { return s_http_host_start; } if (IS_USERINFO_CHAR(ch)) { return s_http_userinfo; } break; case s_http_host_start: if (ch == '[') { return s_http_host_v6_start; } if (IS_HOST_CHAR(ch)) { return s_http_host; } break; case s_http_host: if (IS_HOST_CHAR(ch)) { return s_http_host; } /* fall through */ case s_http_host_v6_end: if (ch == ':') { return s_http_host_port_start; } break; case s_http_host_v6: if (ch == ']') { return s_http_host_v6_end; } /* fall through */ case s_http_host_v6_start: if (IS_HEX(ch) || ch == ':' || ch == '.') { return s_http_host_v6; } if (s == s_http_host_v6 && ch == '%') { return s_http_host_v6_zone_start; } break; case s_http_host_v6_zone: if (ch == ']') { return s_http_host_v6_end; } /* fall through */ case s_http_host_v6_zone_start: /* RFC 6874 Zone ID consists of 1*( unreserved / pct-encoded) */ if (IS_ALPHANUM(ch) || ch == '%' || ch == '.' || ch == '-' || ch == '_' || ch == '~') { return s_http_host_v6_zone; } break; case s_http_host_port: case s_http_host_port_start: if (IS_NUM(ch)) { return s_http_host_port; } break; default: break; } return s_http_host_dead; } static int http_parse_host(const char * buf, struct http_parser_url *u, int found_at) { enum http_host_state s; const char *p; size_t buflen = u->field_data[UF_HOST].off + u->field_data[UF_HOST].len; assert(u->field_set & (1 << UF_HOST)); u->field_data[UF_HOST].len = 0; s = found_at ? s_http_userinfo_start : s_http_host_start; for (p = buf + u->field_data[UF_HOST].off; p < buf + buflen; p++) { enum http_host_state new_s = http_parse_host_char(s, *p); if (new_s == s_http_host_dead) { return 1; } switch(new_s) { case s_http_host: if (s != s_http_host) { u->field_data[UF_HOST].off = (uint16_t)(p - buf); } u->field_data[UF_HOST].len++; break; case s_http_host_v6: if (s != s_http_host_v6) { u->field_data[UF_HOST].off = (uint16_t)(p - buf); } u->field_data[UF_HOST].len++; break; case s_http_host_v6_zone_start: case s_http_host_v6_zone: u->field_data[UF_HOST].len++; break; case s_http_host_port: if (s != s_http_host_port) { u->field_data[UF_PORT].off = (uint16_t)(p - buf); u->field_data[UF_PORT].len = 0; u->field_set |= (1 << UF_PORT); } u->field_data[UF_PORT].len++; break; case s_http_userinfo: if (s != s_http_userinfo) { u->field_data[UF_USERINFO].off = (uint16_t)(p - buf); u->field_data[UF_USERINFO].len = 0; u->field_set |= (1 << UF_USERINFO); } u->field_data[UF_USERINFO].len++; break; default: break; } s = new_s; } /* Make sure we don't end somewhere unexpected */ switch (s) { case s_http_host_start: case s_http_host_v6_start: case s_http_host_v6: case s_http_host_v6_zone_start: case s_http_host_v6_zone: case s_http_host_port_start: case s_http_userinfo: case s_http_userinfo_start: return 1; default: break; } return 0; } void http_parser_url_init(struct http_parser_url *u) { memset(u, 0, sizeof(*u)); } int http_parser_parse_url(const char *buf, size_t buflen, int is_connect, struct http_parser_url *u) { enum state s; const char *p; enum http_parser_url_fields uf, old_uf; int found_at = 0; if (buflen == 0) { return 1; } u->port = u->field_set = 0; s = is_connect ? s_req_server_start : s_req_spaces_before_url; old_uf = UF_MAX; for (p = buf; p < buf + buflen; p++) { s = parse_url_char(s, *p); /* Figure out the next field that we're operating on */ switch (s) { case s_dead: return 1; /* Skip delimeters */ case s_req_schema_slash: case s_req_schema_slash_slash: case s_req_server_start: case s_req_query_string_start: case s_req_fragment_start: continue; case s_req_schema: uf = UF_SCHEMA; break; case s_req_server_with_at: found_at = 1; /* fall through */ case s_req_server: uf = UF_HOST; break; case s_req_path: uf = UF_PATH; break; case s_req_query_string: uf = UF_QUERY; break; case s_req_fragment: uf = UF_FRAGMENT; break; default: assert(!"Unexpected state"); return 1; } /* Nothing's changed; soldier on */ if (uf == old_uf) { u->field_data[uf].len++; continue; } u->field_data[uf].off = (uint16_t)(p - buf); u->field_data[uf].len = 1; u->field_set |= (1 << uf); old_uf = uf; } /* host must be present if there is a schema */ /* parsing http:///toto will fail */ if ((u->field_set & (1 << UF_SCHEMA)) && (u->field_set & (1 << UF_HOST)) == 0) { return 1; } if (u->field_set & (1 << UF_HOST)) { if (http_parse_host(buf, u, found_at) != 0) { return 1; } } /* CONNECT requests can only contain "hostname:port" */ if (is_connect && u->field_set != ((1 << UF_HOST)|(1 << UF_PORT))) { return 1; } if (u->field_set & (1 << UF_PORT)) { uint16_t off; uint16_t len; const char* p; const char* end; unsigned long v; off = u->field_data[UF_PORT].off; len = u->field_data[UF_PORT].len; end = buf + off + len; /* NOTE: The characters are already validated and are in the [0-9] range */ assert((size_t) (off + len) <= buflen && "Port number overflow"); v = 0; for (p = buf + off; p < end; p++) { v *= 10; v += *p - '0'; /* Ports have a max value of 2^16 */ if (v > 0xffff) { return 1; } } u->port = (uint16_t) v; } return 0; } void http_parser_pause(http_parser *parser, int paused) { /* Users should only be pausing/unpausing a parser that is not in an error * state. In non-debug builds, there's not much that we can do about this * other than ignore it. */ if (HTTP_PARSER_ERRNO(parser) == HPE_OK || HTTP_PARSER_ERRNO(parser) == HPE_PAUSED) { uint32_t nread = parser->nread; /* used by the SET_ERRNO macro */ SET_ERRNO((paused) ? HPE_PAUSED : HPE_OK); } else { assert(0 && "Attempting to pause parser in error state"); } } int http_body_is_final(const struct http_parser *parser) { return parser->state == s_message_done; } unsigned long http_parser_version(void) { return HTTP_PARSER_VERSION_MAJOR * 0x10000 | HTTP_PARSER_VERSION_MINOR * 0x00100 | HTTP_PARSER_VERSION_PATCH * 0x00001; } void http_parser_set_max_header_size(uint32_t size) { max_header_size = size; } ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/vendor/http_parser/http_parser.h�����������������������������������������������������0000664�0000000�0000000�00000045770�14771603147�0021720�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* Copyright Joyent, Inc. and other Node contributors. All rights reserved. * * Permission is hereby granted, free of charge, to any person obtaining a copy * of this software and associated documentation files (the "Software"), to * deal in the Software without restriction, including without limitation the * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or * sell copies of the Software, and to permit persons to whom the Software is * furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be included in * all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS * IN THE SOFTWARE. */ #ifndef http_parser_h #define http_parser_h #ifdef __cplusplus extern "C" { #endif /* Also update SONAME in the Makefile whenever you change these. */ #define HTTP_PARSER_VERSION_MAJOR 2 #define HTTP_PARSER_VERSION_MINOR 9 #define HTTP_PARSER_VERSION_PATCH 4 #include <stddef.h> #if defined(_WIN32) && !defined(__MINGW32__) && \ (!defined(_MSC_VER) || _MSC_VER<1600) && !defined(__WINE__) #include <BaseTsd.h> typedef __int8 int8_t; typedef unsigned __int8 uint8_t; typedef __int16 int16_t; typedef unsigned __int16 uint16_t; typedef __int32 int32_t; typedef unsigned __int32 uint32_t; typedef __int64 int64_t; typedef unsigned __int64 uint64_t; #else #include <stdint.h> #endif /* Compile with -DHTTP_PARSER_STRICT=0 to make less checks, but run * faster */ #ifndef HTTP_PARSER_STRICT # define HTTP_PARSER_STRICT 1 #endif /* Maximium header size allowed. If the macro is not defined * before including this header then the default is used. To * change the maximum header size, define the macro in the build * environment (e.g. -DHTTP_MAX_HEADER_SIZE=<value>). To remove * the effective limit on the size of the header, define the macro * to a very large number (e.g. -DHTTP_MAX_HEADER_SIZE=0x7fffffff) */ #ifndef HTTP_MAX_HEADER_SIZE # define HTTP_MAX_HEADER_SIZE (80*1024) #endif typedef struct http_parser http_parser; typedef struct http_parser_settings http_parser_settings; /* Callbacks should return non-zero to indicate an error. The parser will * then halt execution. * * The one exception is on_headers_complete. In a HTTP_RESPONSE parser * returning '1' from on_headers_complete will tell the parser that it * should not expect a body. This is used when receiving a response to a * HEAD request which may contain 'Content-Length' or 'Transfer-Encoding: * chunked' headers that indicate the presence of a body. * * Returning `2` from on_headers_complete will tell parser that it should not * expect neither a body nor any futher responses on this connection. This is * useful for handling responses to a CONNECT request which may not contain * `Upgrade` or `Connection: upgrade` headers. * * http_data_cb does not return data chunks. It will be called arbitrarily * many times for each string. E.G. you might get 10 callbacks for "on_url" * each providing just a few characters more data. */ typedef int (*http_data_cb) (http_parser*, const char *at, size_t length); typedef int (*http_cb) (http_parser*); /* Status Codes */ #define HTTP_STATUS_MAP(XX) \ XX(100, CONTINUE, Continue) \ XX(101, SWITCHING_PROTOCOLS, Switching Protocols) \ XX(102, PROCESSING, Processing) \ XX(200, OK, OK) \ XX(201, CREATED, Created) \ XX(202, ACCEPTED, Accepted) \ XX(203, NON_AUTHORITATIVE_INFORMATION, Non-Authoritative Information) \ XX(204, NO_CONTENT, No Content) \ XX(205, RESET_CONTENT, Reset Content) \ XX(206, PARTIAL_CONTENT, Partial Content) \ XX(207, MULTI_STATUS, Multi-Status) \ XX(208, ALREADY_REPORTED, Already Reported) \ XX(226, IM_USED, IM Used) \ XX(300, MULTIPLE_CHOICES, Multiple Choices) \ XX(301, MOVED_PERMANENTLY, Moved Permanently) \ XX(302, FOUND, Found) \ XX(303, SEE_OTHER, See Other) \ XX(304, NOT_MODIFIED, Not Modified) \ XX(305, USE_PROXY, Use Proxy) \ XX(307, TEMPORARY_REDIRECT, Temporary Redirect) \ XX(308, PERMANENT_REDIRECT, Permanent Redirect) \ XX(400, BAD_REQUEST, Bad Request) \ XX(401, UNAUTHORIZED, Unauthorized) \ XX(402, PAYMENT_REQUIRED, Payment Required) \ XX(403, FORBIDDEN, Forbidden) \ XX(404, NOT_FOUND, Not Found) \ XX(405, METHOD_NOT_ALLOWED, Method Not Allowed) \ XX(406, NOT_ACCEPTABLE, Not Acceptable) \ XX(407, PROXY_AUTHENTICATION_REQUIRED, Proxy Authentication Required) \ XX(408, REQUEST_TIMEOUT, Request Timeout) \ XX(409, CONFLICT, Conflict) \ XX(410, GONE, Gone) \ XX(411, LENGTH_REQUIRED, Length Required) \ XX(412, PRECONDITION_FAILED, Precondition Failed) \ XX(413, PAYLOAD_TOO_LARGE, Payload Too Large) \ XX(414, URI_TOO_LONG, URI Too Long) \ XX(415, UNSUPPORTED_MEDIA_TYPE, Unsupported Media Type) \ XX(416, RANGE_NOT_SATISFIABLE, Range Not Satisfiable) \ XX(417, EXPECTATION_FAILED, Expectation Failed) \ XX(421, MISDIRECTED_REQUEST, Misdirected Request) \ XX(422, UNPROCESSABLE_ENTITY, Unprocessable Entity) \ XX(423, LOCKED, Locked) \ XX(424, FAILED_DEPENDENCY, Failed Dependency) \ XX(426, UPGRADE_REQUIRED, Upgrade Required) \ XX(428, PRECONDITION_REQUIRED, Precondition Required) \ XX(429, TOO_MANY_REQUESTS, Too Many Requests) \ XX(431, REQUEST_HEADER_FIELDS_TOO_LARGE, Request Header Fields Too Large) \ XX(451, UNAVAILABLE_FOR_LEGAL_REASONS, Unavailable For Legal Reasons) \ XX(500, INTERNAL_SERVER_ERROR, Internal Server Error) \ XX(501, NOT_IMPLEMENTED, Not Implemented) \ XX(502, BAD_GATEWAY, Bad Gateway) \ XX(503, SERVICE_UNAVAILABLE, Service Unavailable) \ XX(504, GATEWAY_TIMEOUT, Gateway Timeout) \ XX(505, HTTP_VERSION_NOT_SUPPORTED, HTTP Version Not Supported) \ XX(506, VARIANT_ALSO_NEGOTIATES, Variant Also Negotiates) \ XX(507, INSUFFICIENT_STORAGE, Insufficient Storage) \ XX(508, LOOP_DETECTED, Loop Detected) \ XX(510, NOT_EXTENDED, Not Extended) \ XX(511, NETWORK_AUTHENTICATION_REQUIRED, Network Authentication Required) \ enum http_status { #define XX(num, name, string) HTTP_STATUS_##name = num, HTTP_STATUS_MAP(XX) #undef XX }; /* Request Methods */ #define HTTP_METHOD_MAP(XX) \ XX(0, DELETE, DELETE) \ XX(1, GET, GET) \ XX(2, HEAD, HEAD) \ XX(3, POST, POST) \ XX(4, PUT, PUT) \ /* pathological */ \ XX(5, CONNECT, CONNECT) \ XX(6, OPTIONS, OPTIONS) \ XX(7, TRACE, TRACE) \ /* WebDAV */ \ XX(8, COPY, COPY) \ XX(9, LOCK, LOCK) \ XX(10, MKCOL, MKCOL) \ XX(11, MOVE, MOVE) \ XX(12, PROPFIND, PROPFIND) \ XX(13, PROPPATCH, PROPPATCH) \ XX(14, SEARCH, SEARCH) \ XX(15, UNLOCK, UNLOCK) \ XX(16, BIND, BIND) \ XX(17, REBIND, REBIND) \ XX(18, UNBIND, UNBIND) \ XX(19, ACL, ACL) \ /* subversion */ \ XX(20, REPORT, REPORT) \ XX(21, MKACTIVITY, MKACTIVITY) \ XX(22, CHECKOUT, CHECKOUT) \ XX(23, MERGE, MERGE) \ /* upnp */ \ XX(24, MSEARCH, M-SEARCH) \ XX(25, NOTIFY, NOTIFY) \ XX(26, SUBSCRIBE, SUBSCRIBE) \ XX(27, UNSUBSCRIBE, UNSUBSCRIBE) \ /* RFC-5789 */ \ XX(28, PATCH, PATCH) \ XX(29, PURGE, PURGE) \ /* CalDAV */ \ XX(30, MKCALENDAR, MKCALENDAR) \ /* RFC-2068, section 19.6.1.2 */ \ XX(31, LINK, LINK) \ XX(32, UNLINK, UNLINK) \ /* icecast */ \ XX(33, SOURCE, SOURCE) \ enum http_method { #define XX(num, name, string) HTTP_##name = num, HTTP_METHOD_MAP(XX) #undef XX }; enum http_parser_type { HTTP_REQUEST, HTTP_RESPONSE, HTTP_BOTH }; /* Flag values for http_parser.flags field */ enum flags { F_CHUNKED = 1 << 0 , F_CONNECTION_KEEP_ALIVE = 1 << 1 , F_CONNECTION_CLOSE = 1 << 2 , F_CONNECTION_UPGRADE = 1 << 3 , F_TRAILING = 1 << 4 , F_UPGRADE = 1 << 5 , F_SKIPBODY = 1 << 6 , F_CONTENTLENGTH = 1 << 7 }; /* Map for errno-related constants * * The provided argument should be a macro that takes 2 arguments. */ #define HTTP_ERRNO_MAP(XX) \ /* No error */ \ XX(OK, "success") \ \ /* Callback-related errors */ \ XX(CB_message_begin, "the on_message_begin callback failed") \ XX(CB_url, "the on_url callback failed") \ XX(CB_header_field, "the on_header_field callback failed") \ XX(CB_header_value, "the on_header_value callback failed") \ XX(CB_headers_complete, "the on_headers_complete callback failed") \ XX(CB_body, "the on_body callback failed") \ XX(CB_message_complete, "the on_message_complete callback failed") \ XX(CB_status, "the on_status callback failed") \ XX(CB_chunk_header, "the on_chunk_header callback failed") \ XX(CB_chunk_complete, "the on_chunk_complete callback failed") \ \ /* Parsing-related errors */ \ XX(INVALID_EOF_STATE, "stream ended at an unexpected time") \ XX(HEADER_OVERFLOW, \ "too many header bytes seen; overflow detected") \ XX(CLOSED_CONNECTION, \ "data received after completed connection: close message") \ XX(INVALID_VERSION, "invalid HTTP version") \ XX(INVALID_STATUS, "invalid HTTP status code") \ XX(INVALID_METHOD, "invalid HTTP method") \ XX(INVALID_URL, "invalid URL") \ XX(INVALID_HOST, "invalid host") \ XX(INVALID_PORT, "invalid port") \ XX(INVALID_PATH, "invalid path") \ XX(INVALID_QUERY_STRING, "invalid query string") \ XX(INVALID_FRAGMENT, "invalid fragment") \ XX(LF_EXPECTED, "LF character expected") \ XX(INVALID_HEADER_TOKEN, "invalid character in header") \ XX(INVALID_CONTENT_LENGTH, \ "invalid character in content-length header") \ XX(UNEXPECTED_CONTENT_LENGTH, \ "unexpected content-length header") \ XX(INVALID_CHUNK_SIZE, \ "invalid character in chunk size header") \ XX(INVALID_CONSTANT, "invalid constant string") \ XX(INVALID_INTERNAL_STATE, "encountered unexpected internal state")\ XX(STRICT, "strict mode assertion failed") \ XX(PAUSED, "parser is paused") \ XX(UNKNOWN, "an unknown error occurred") \ XX(INVALID_TRANSFER_ENCODING, \ "request has invalid transfer-encoding") \ /* Define HPE_* values for each errno value above */ #define HTTP_ERRNO_GEN(n, s) HPE_##n, enum http_errno { HTTP_ERRNO_MAP(HTTP_ERRNO_GEN) }; #undef HTTP_ERRNO_GEN /* Get an http_errno value from an http_parser */ #define HTTP_PARSER_ERRNO(p) ((enum http_errno) (p)->http_errno) struct http_parser { /** PRIVATE **/ unsigned int type : 2; /* enum http_parser_type */ unsigned int flags : 8; /* F_* values from 'flags' enum; semi-public */ unsigned int state : 7; /* enum state from http_parser.c */ unsigned int header_state : 7; /* enum header_state from http_parser.c */ unsigned int index : 5; /* index into current matcher */ unsigned int uses_transfer_encoding : 1; /* Transfer-Encoding header is present */ unsigned int allow_chunked_length : 1; /* Allow headers with both * `Content-Length` and * `Transfer-Encoding: chunked` set */ unsigned int lenient_http_headers : 1; uint32_t nread; /* # bytes read in various scenarios */ uint64_t content_length; /* # bytes in body (0 if no Content-Length header) */ /** READ-ONLY **/ unsigned short http_major; unsigned short http_minor; unsigned int status_code : 16; /* responses only */ unsigned int method : 8; /* requests only */ unsigned int http_errno : 7; /* 1 = Upgrade header was present and the parser has exited because of that. * 0 = No upgrade header present. * Should be checked when http_parser_execute() returns in addition to * error checking. */ unsigned int upgrade : 1; /** PUBLIC **/ void *data; /* A pointer to get hook to the "connection" or "socket" object */ }; struct http_parser_settings { http_cb on_message_begin; http_data_cb on_url; http_data_cb on_status; http_data_cb on_header_field; http_data_cb on_header_value; http_cb on_headers_complete; http_data_cb on_body; http_cb on_message_complete; /* When on_chunk_header is called, the current chunk length is stored * in parser->content_length. */ http_cb on_chunk_header; http_cb on_chunk_complete; }; enum http_parser_url_fields { UF_SCHEMA = 0 , UF_HOST = 1 , UF_PORT = 2 , UF_PATH = 3 , UF_QUERY = 4 , UF_FRAGMENT = 5 , UF_USERINFO = 6 , UF_MAX = 7 }; /* Result structure for http_parser_parse_url(). * * Callers should index into field_data[] with UF_* values iff field_set * has the relevant (1 << UF_*) bit set. As a courtesy to clients (and * because we probably have padding left over), we convert any port to * a uint16_t. */ struct http_parser_url { uint16_t field_set; /* Bitmask of (1 << UF_*) values */ uint16_t port; /* Converted UF_PORT string */ struct { uint16_t off; /* Offset into buffer in which field starts */ uint16_t len; /* Length of run in buffer */ } field_data[UF_MAX]; }; /* Returns the library version. Bits 16-23 contain the major version number, * bits 8-15 the minor version number and bits 0-7 the patch level. * Usage example: * * unsigned long version = http_parser_version(); * unsigned major = (version >> 16) & 255; * unsigned minor = (version >> 8) & 255; * unsigned patch = version & 255; * printf("http_parser v%u.%u.%u\n", major, minor, patch); */ unsigned long http_parser_version(void); void http_parser_init(http_parser *parser, enum http_parser_type type); /* Initialize http_parser_settings members to 0 */ void http_parser_settings_init(http_parser_settings *settings); /* Executes the parser. Returns number of parsed bytes. Sets * `parser->http_errno` on error. */ size_t http_parser_execute(http_parser *parser, const http_parser_settings *settings, const char *data, size_t len); /* If http_should_keep_alive() in the on_headers_complete or * on_message_complete callback returns 0, then this should be * the last message on the connection. * If you are the server, respond with the "Connection: close" header. * If you are the client, close the connection. */ int http_should_keep_alive(const http_parser *parser); /* Returns a string version of the HTTP method. */ const char *http_method_str(enum http_method m); /* Returns a string version of the HTTP status code. */ const char *http_status_str(enum http_status s); /* Return a string name of the given error */ const char *http_errno_name(enum http_errno err); /* Return a string description of the given error */ const char *http_errno_description(enum http_errno err); /* Initialize all http_parser_url members to 0 */ void http_parser_url_init(struct http_parser_url *u); /* Parse a URL; return nonzero on failure */ int http_parser_parse_url(const char *buf, size_t buflen, int is_connect, struct http_parser_url *u); /* Pause or un-pause the parser; a nonzero value pauses */ void http_parser_pause(http_parser *parser, int paused); /* Checks if this is the final chunk of the body. */ int http_body_is_final(const http_parser *parser); /* Change the maximum header size provided at compile time. */ void http_parser_set_max_header_size(uint32_t size); #ifdef __cplusplus } #endif #endif ��������inspircd-4.7.0/vendor/lyra/�������������������������������������������������������������������������0000775�0000000�0000000�00000000000�14771603147�0015613�5����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/vendor/lyra/LICENSE.txt��������������������������������������������������������������0000664�0000000�0000000�00000002472�14771603147�0017443�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������Boost Software License - Version 1.0 - August 17th, 2003 Permission is hereby granted, free of charge, to any person or organization obtaining a copy of the software and accompanying documentation covered by this license (the "Software") to use, reproduce, display, distribute, execute, and transmit the Software, and to prepare derivative works of the Software, and to permit third-parties to whom the Software is furnished to do so, all subject to the following: The copyright notices in the Software and this entire statement, including the above license grant, this restriction and the following disclaimer, must be included in all copies of the Software, in whole or in part, and all derivative works of the Software, unless such copies or derivative works are solely in the form of machine-executable object code generated by a source language processor. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/vendor/lyra/lyra.hpp�����������������������������������������������������������������0000664�0000000�0000000�00000303663�14771603147�0017306�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������// Copyright 2018-2022 RenУЉ Ferdinand Rivera Morell // Copyright 2021 Max Ferger // Copyright 2017 Two Blue Cubes Ltd. All rights reserved. // // Distributed under the Boost Software License, Version 1.0. (See accompanying // file LICENSE.txt or copy at http://www.boost.org/LICENSE_1_0.txt) #ifndef LYRA_LYRA_HPP #define LYRA_LYRA_HPP #ifndef LYRA_VERSION_HPP #define LYRA_VERSION_HPP #define LYRA_VERSION_MAJOR 1 #define LYRA_VERSION_MINOR 6 #define LYRA_VERSION_PATCH 1 #define LYRA_VERSION \ (((LYRA_VERSION_MAJOR)*10000000) + ((LYRA_VERSION_MINOR)*100000) \ + (LYRA_VERSION_PATCH)) #endif // LYRA_VERSION_HPP #ifndef LYRA_ARG_HPP #define LYRA_ARG_HPP #ifndef LYRA_DETAIL_PRINT_HPP #define LYRA_DETAIL_PRINT_HPP #include <iostream> #include <string> #ifndef LYRA_DEBUG # define LYRA_DEBUG 0 #endif namespace lyra { namespace detail { constexpr bool is_debug = LYRA_DEBUG; template <typename T> std::string to_string(T && t) { return std::string(std::move(t)); } using std::to_string; struct print { print(const char * scope_name = nullptr) : scope(scope_name) { if (is_debug) print::depth() += 1; if (scope) debug(scope, "..."); } ~print() { if (scope) debug("...", scope); if (is_debug) print::depth() -= 1; } template <typename... A> void debug(A... arg) { if (is_debug) { std::cerr << "[DEBUG]" << std::string((print::depth() - 1) * 2, ' '); std::string args[] = { to_string(arg)... }; for (auto & arg_string : args) { std::cerr << " " << arg_string; } std::cerr << "\n"; } } private: const char * scope; static std::size_t & depth() { static std::size_t d = 0; return d; } }; }} // namespace lyra::detail #if LYRA_DEBUG # define LYRA_PRINT_SCOPE ::lyra::detail::print lyra_print_scope # define LYRA_PRINT_DEBUG lyra_print_scope.debug #else # define LYRA_PRINT_SCOPE(...) while (false) # define LYRA_PRINT_DEBUG(...) while (false) #endif #endif #ifndef LYRA_PARSER_HPP #define LYRA_PARSER_HPP #ifndef LYRA_ARGS_HPP #define LYRA_ARGS_HPP #include <initializer_list> #include <string> #include <vector> namespace lyra { /* tag::reference[] [#lyra_args] = `lyra::args` Transport for raw args (copied from main args, supplied via init list, or from a pair of iterators). */ // end::reference[] class args { public: args(int argc, char const * const * argv) : m_exeName(argv[0]) , m_args(argv + 1, argv + argc) {} args(std::initializer_list<std::string> args_list) : m_exeName(*args_list.begin()) , m_args(args_list.begin() + 1, args_list.end()) {} template <typename It> args(const It & start, const It & end) : m_exeName(*start) , m_args(start + 1, end) {} std::string exe_name() const { return m_exeName; } std::vector<std::string>::const_iterator begin() const { return m_args.begin(); } std::vector<std::string>::const_iterator end() const { return m_args.end(); } private: std::string m_exeName; std::vector<std::string> m_args; }; } // namespace lyra #endif #ifndef LYRA_DETAIL_BOUND_HPP #define LYRA_DETAIL_BOUND_HPP #ifndef LYRA_DETAIL_FROM_STRING_HPP #define LYRA_DETAIL_FROM_STRING_HPP #ifndef LYRA_DETAIL_TRAIT_UTILS_HPP #define LYRA_DETAIL_TRAIT_UTILS_HPP #include <type_traits> #include <utility> namespace lyra { namespace detail { template <class F, class... Args> struct is_callable { template <class U> static auto test(U * p) -> decltype((*p)(std::declval<Args>()...), void(), std::true_type()); template <class U> static auto test(...) -> decltype(std::false_type()); static constexpr bool value = decltype(test<F>(0))::value; }; template <class T> struct remove_cvref { typedef typename std::remove_cv<typename std::remove_reference<T>::type>::type type; }; template <class F> struct is_invocable { template <class U> static auto test(U * p) -> decltype((&U::operator()), void(), std::true_type()); template <class U> static auto test(...) -> decltype(std::false_type()); static constexpr bool value = decltype(test<typename remove_cvref<F>::type>(0))::value; }; template <typename... Ts> struct make_void { typedef void type; }; template <typename... Ts> using valid_t = typename make_void<Ts...>::type; template <class T, template <class...> class Primary> struct is_specialization_of : std::false_type {}; template <template <class...> class Primary, class... Args> struct is_specialization_of<Primary<Args...>, Primary> : std::true_type {}; }} // namespace lyra::detail #endif #include <algorithm> #include <sstream> #include <string> #include <type_traits> #ifndef LYRA_CONFIG_OPTIONAL_TYPE # ifdef __has_include # if __has_include(<optional>) && __cplusplus >= 201703L # include <optional> # define LYRA_CONFIG_OPTIONAL_TYPE std::optional # endif # endif #endif namespace lyra { namespace detail { template <typename T> bool to_string(const T & source, std::string & target) { std::stringstream ss; ss << source; ss >> target; return !ss.fail(); } inline bool to_string(const std::string & source, std::string & target) { target = source; return true; } inline bool to_string(const char * source, std::string & target) { target = source; return true; } inline bool to_string(bool source, std::string & target) { target = source ? "true" : "false"; return true; } #ifdef LYRA_CONFIG_OPTIONAL_TYPE template <typename T> inline bool to_string( LYRA_CONFIG_OPTIONAL_TYPE<T> & source, std::string & target) { if (source) return to_string(*source, target); else target = "<nullopt>"; return true; } #endif // LYRA_CONFIG_OPTIONAL_TYPE template <typename, typename = void> struct is_convertible_from_string : std::false_type {}; template <typename T> struct is_convertible_from_string<T, typename std::enable_if<std::is_arithmetic<T>::value>::type> : std::true_type {}; template <typename, typename = void> struct validate_from_string { static bool validate(const std::string &) { return true; } }; template <typename T> struct validate_from_string<T, typename std::enable_if< std::is_unsigned<typename detail::remove_cvref<T>::type>::value>::type> { static bool validate(const std::string & s) { return s.find_first_not_of("0123456789") == std::string::npos; } }; template <typename T> struct validate_from_string<T, typename std::enable_if< std::is_integral<typename detail::remove_cvref<T>::type>::value && std::is_signed<typename detail::remove_cvref<T>::type>::value>::type> { static bool validate(const std::string & s) { return s.find_first_not_of("-0123456789") == std::string::npos; } }; template <typename S, typename T> inline bool from_string(S const & source, T & target) { std::stringstream ss; ss << source; if (!validate_from_string<T>::validate(ss.str())) return false; T temp {}; ss >> temp; if (!ss.fail() && ss.eof()) { target = temp; return true; } return false; } template <typename S, typename... C> inline bool from_string(S const & source, std::basic_string<C...> & target) { to_string(source, target); return true; } template <typename T> struct is_convertible_from_string<T, typename std::enable_if<std::is_same<T, bool>::value>::type> : std::true_type {}; template <typename S> inline bool from_string(S const & source, bool & target) { std::string srcLC; to_string(source, srcLC); std::transform(srcLC.begin(), srcLC.end(), srcLC.begin(), [](char c) { return static_cast<char>(::tolower(c)); }); if (srcLC == "y" || srcLC == "1" || srcLC == "true" || srcLC == "yes" || srcLC == "on") target = true; else if (srcLC == "n" || srcLC == "0" || srcLC == "false" || srcLC == "no" || srcLC == "off") target = false; else return false; return true; } #ifdef LYRA_CONFIG_OPTIONAL_TYPE template <typename T> struct is_convertible_from_string<T, typename std::enable_if< is_specialization_of<T, LYRA_CONFIG_OPTIONAL_TYPE>::value>::type> : std::true_type {}; template <typename S, typename T> inline bool from_string(S const & source, LYRA_CONFIG_OPTIONAL_TYPE<T> & target) { std::string srcLC; to_string(source, srcLC); std::transform(srcLC.begin(), srcLC.end(), srcLC.begin(), [](char c) { return static_cast<char>(::tolower(c)); }); if (srcLC == "<nullopt>") { target.reset(); return true; } else { T temp; auto str_result = from_string(source, temp); if (str_result) target = std::move(temp); return str_result; } } #endif // LYRA_CONFIG_OPTIONAL_TYPE }} // namespace lyra::detail #endif #ifndef LYRA_DETAIL_INVOKE_LAMBDA_HPP #define LYRA_DETAIL_INVOKE_LAMBDA_HPP #ifndef LYRA_DETAIL_PARSE_HPP #define LYRA_DETAIL_PARSE_HPP #ifndef LYRA_PARSER_RESULT_HPP #define LYRA_PARSER_RESULT_HPP #ifndef LYRA_DETAIL_RESULT_HPP #define LYRA_DETAIL_RESULT_HPP #include <memory> #include <string> namespace lyra { namespace detail { class result_base { public: result_base const & base() const { return *this; } explicit operator bool() const { return is_ok(); } bool is_ok() const { return kind_ == result_kind::ok; } std::string message() const { return message_; } [[deprecated]] std::string errorMessage() const { return message(); } protected: enum class result_kind { ok, error }; explicit result_base(result_kind kind, const std::string & message = "") : kind_(kind) , message_(message) {} explicit result_base(const result_base & other) : kind_(other.kind_) , message_(other.message_) {} virtual ~result_base() = default; result_base & operator=(const result_base &) = default; private: result_kind kind_; std::string message_; }; template <typename T> class result_value_base : public result_base { public: using value_type = T; value_type const & value() const { return *value_; } bool has_value() const { return bool(value_); } protected: std::unique_ptr<value_type> value_; explicit result_value_base( result_kind kind, const std::string & message = "") : result_base(kind, message) {} explicit result_value_base(result_kind kind, const value_type & val, const std::string & message = "") : result_base(kind, message) { value_.reset(new value_type(val)); } explicit result_value_base(result_value_base const & other) : result_base(other) { if (other.value_) value_.reset(new value_type(*other.value_)); } explicit result_value_base(const result_base & other) : result_base(other) {} result_value_base & operator=(result_value_base const & other) { result_base::operator=(other); if (other.value_) value_.reset(new T(*other.value_)); return *this; } }; template <> class result_value_base<void> : public result_base { public: using value_type = void; protected: explicit result_value_base(const result_base & other) : result_base(other) {} explicit result_value_base( result_kind kind, const std::string & message = "") : result_base(kind, message) {} }; template <typename T> class basic_result : public result_value_base<T> { public: using value_type = typename result_value_base<T>::value_type; explicit basic_result(result_base const & other) : result_value_base<T>(other) {} static basic_result ok(value_type const & val) { return basic_result(result_base::result_kind::ok, val); } static basic_result error( value_type const & val, std::string const & message) { return basic_result(result_base::result_kind::error, val, message); } protected: using result_value_base<T>::result_value_base; }; template <> class basic_result<void> : public result_value_base<void> { public: using value_type = typename result_value_base<void>::value_type; explicit basic_result(result_base const & other) : result_value_base<void>(other) {} static basic_result ok() { return basic_result(result_base::result_kind::ok); } static basic_result error(std::string const & message) { return basic_result(result_base::result_kind::error, message); } protected: using result_value_base<void>::result_value_base; }; }} // namespace lyra::detail #endif #include <string> namespace lyra { enum class parser_result_type { matched, no_match, short_circuit_all }; inline std::string to_string(parser_result_type v) { switch (v) { case parser_result_type::matched: return "matched"; case parser_result_type::no_match: return "no_match"; case parser_result_type::short_circuit_all: return "short_circuit_all"; } return "?"; } using result = detail::basic_result<void>; using parser_result = detail::basic_result<parser_result_type>; } // namespace lyra #endif #include <string> namespace lyra { namespace detail { template <typename S, typename T> parser_result parse_string(S const & source, T & target) { if (from_string(source, target)) return parser_result::ok(parser_result_type::matched); else return parser_result::error(parser_result_type::no_match, "Unable to convert '" + source + "' to destination type"); } }} // namespace lyra::detail #endif #ifndef LYRA_DETAIL_UNARY_LAMBDA_TRAITS_HPP #define LYRA_DETAIL_UNARY_LAMBDA_TRAITS_HPP #include <type_traits> namespace lyra { namespace detail { template <typename L> struct unary_lambda_traits : unary_lambda_traits<decltype(&L::operator())> {}; template <typename ClassT, typename ReturnT, typename... Args> struct unary_lambda_traits<ReturnT (ClassT::*)(Args...) const> { static const bool isValid = false; }; template <typename ClassT, typename ReturnT, typename ArgT> struct unary_lambda_traits<ReturnT (ClassT::*)(ArgT) const> { static const bool isValid = true; using ArgType = typename std::remove_const< typename std::remove_reference<ArgT>::type>::type; using ReturnType = ReturnT; }; }} // namespace lyra::detail #endif namespace lyra { namespace detail { template <typename ReturnType> struct LambdaInvoker { template <typename L, typename ArgType> static parser_result invoke(L const & lambda, ArgType const & arg) { return lambda(arg); } }; template <> struct LambdaInvoker<void> { template <typename L, typename ArgType> static parser_result invoke(L const & lambda, ArgType const & arg) { lambda(arg); return parser_result::ok(parser_result_type::matched); } }; template <typename ArgType, typename L> inline parser_result invokeLambda(L const & lambda, std::string const & arg) { ArgType temp {}; auto p_result = parse_string(arg, temp); return !p_result ? p_result : LambdaInvoker<typename unary_lambda_traits<L>::ReturnType>::invoke( lambda, temp); } }} // namespace lyra::detail #endif #include <string> namespace lyra { namespace detail { struct NonCopyable { NonCopyable() = default; NonCopyable(NonCopyable const &) = delete; NonCopyable(NonCopyable &&) = delete; NonCopyable & operator=(NonCopyable const &) = delete; NonCopyable & operator=(NonCopyable &&) = delete; }; struct BoundRef : NonCopyable { virtual ~BoundRef() = default; virtual auto isContainer() const -> bool { return false; } virtual auto isFlag() const -> bool { return false; } virtual size_t get_value_count() const { return 0; } virtual std::string get_value(size_t) const { return ""; } }; struct BoundValueRefBase : BoundRef { virtual auto setValue(std::string const & arg) -> parser_result = 0; }; struct BoundFlagRefBase : BoundRef { virtual auto setFlag(bool flag) -> parser_result = 0; virtual auto isFlag() const -> bool { return true; } }; template <typename T> struct BoundValueRef : BoundValueRefBase { T & m_ref; explicit BoundValueRef(T & ref) : m_ref(ref) {} auto setValue(std::string const & arg) -> parser_result override { return parse_string(arg, m_ref); } virtual size_t get_value_count() const override { return 1; } virtual std::string get_value(size_t i) const override { if (i == 0) { std::string result; detail::to_string(m_ref, result); return result; } return ""; } }; template <typename T> struct BoundValueRef<std::vector<T>> : BoundValueRefBase { std::vector<T> & m_ref; explicit BoundValueRef(std::vector<T> & ref) : m_ref(ref) {} auto isContainer() const -> bool override { return true; } auto setValue(std::string const & arg) -> parser_result override { T temp; auto str_result = parse_string(arg, temp); if (str_result) m_ref.push_back(temp); return str_result; } virtual size_t get_value_count() const override { return m_ref.size(); } virtual std::string get_value(size_t i) const override { if (i < m_ref.size()) { std::string str_result; detail::to_string(m_ref[i], str_result); return str_result; } return ""; } }; struct BoundFlagRef : BoundFlagRefBase { bool & m_ref; explicit BoundFlagRef(bool & ref) : m_ref(ref) {} auto setFlag(bool flag) -> parser_result override { m_ref = flag; return parser_result::ok(parser_result_type::matched); } virtual size_t get_value_count() const override { return 1; } virtual std::string get_value(size_t i) const override { if (i == 0) return m_ref ? "true" : "false"; return ""; } }; template <typename L> struct BoundLambda : BoundValueRefBase { L m_lambda; static_assert(unary_lambda_traits<L>::isValid, "Supplied lambda must take exactly one argument"); explicit BoundLambda(L const & lambda) : m_lambda(lambda) {} auto setValue(std::string const & arg) -> parser_result override { return invokeLambda<typename unary_lambda_traits<L>::ArgType>( m_lambda, arg); } }; template <typename L> struct BoundFlagLambda : BoundFlagRefBase { L m_lambda; static_assert(unary_lambda_traits<L>::isValid, "Supplied lambda must take exactly one argument"); static_assert( std::is_same<typename unary_lambda_traits<L>::ArgType, bool>::value, "flags must be boolean"); explicit BoundFlagLambda(L const & lambda) : m_lambda(lambda) {} auto setFlag(bool flag) -> parser_result override { return LambdaInvoker< typename unary_lambda_traits<L>::ReturnType>::invoke(m_lambda, flag); } }; template <typename T> struct BoundVal : BoundValueRef<T> { T value; BoundVal(T && v) : BoundValueRef<T>(value) , value(v) {} BoundVal(BoundVal && other) : BoundValueRef<T>(value) , value(std::move(other.value)) {} std::shared_ptr<BoundRef> move_to_shared() { return std::shared_ptr<BoundRef>(new BoundVal<T>(std::move(*this))); } }; }} // namespace lyra::detail #endif #ifndef LYRA_DETAIL_CHOICES_HPP #define LYRA_DETAIL_CHOICES_HPP #include <algorithm> #include <initializer_list> #include <string> #include <type_traits> #include <vector> namespace lyra { namespace detail { /* Type erased base for set of choices. I.e. it's an "interface". */ struct choices_base { virtual ~choices_base() = default; virtual parser_result contains_value(std::string const & val) const = 0; }; /* Stores a set of choice values and provides checking if a given parsed string value is one of the choices. */ template <typename T> struct choices_set : choices_base { std::vector<T> values; template <typename... Vals> explicit choices_set(Vals... vals) : choices_set({ vals... }) {} explicit choices_set(const std::vector<T> & vals) : values(vals) {} parser_result contains_value(std::string const & val) const override { T value; auto parse = parse_string(val, value); if (!parse) { return parser_result::error( parser_result_type::no_match, parse.message()); } bool result = std::count(values.begin(), values.end(), value) > 0; if (result) { return parser_result::ok(parser_result_type::matched); } return parser_result::error(parser_result_type::no_match, "Value '" + val + "' not expected. Allowed values are: " + this->to_string()); } std::string to_string() const { std::string result; for (const T & val : values) { if (!result.empty()) result += ", "; std::string val_string; if (detail::to_string(val, val_string)) { result += val_string; } else { result += "<value error>"; } } return result; } protected: explicit choices_set(std::initializer_list<T> const & vals) : values(vals) {} }; template <> struct choices_set<const char *> : choices_set<std::string> { template <typename... Vals> explicit choices_set(Vals... vals) : choices_set<std::string>(vals...) {} }; /* Calls a designated function to check if the choice is valid. */ template <typename Lambda> struct choices_check : choices_base { static_assert(unary_lambda_traits<Lambda>::isValid, "Supplied lambda must take exactly one argument"); static_assert(std::is_same<bool, typename unary_lambda_traits<Lambda>::ReturnType>::value, "Supplied lambda must return bool"); Lambda checker; using value_type = typename unary_lambda_traits<Lambda>::ArgType; explicit choices_check(Lambda const & checker_function) : checker(checker_function) {} parser_result contains_value(std::string const & val) const override { value_type value; auto parse = parse_string(val, value); if (!parse) { return parser_result::error( parser_result_type::no_match, parse.message()); } if (checker(value)) { return parser_result::ok(parser_result_type::matched); } return parser_result::error( parser_result_type::no_match, "Value '" + val + "' not expected."); } }; }} // namespace lyra::detail #endif #ifndef LYRA_DETAIL_TOKENS_HPP #define LYRA_DETAIL_TOKENS_HPP #ifndef LYRA_OPTION_STYLE_HPP #define LYRA_OPTION_STYLE_HPP #include <string> namespace lyra { /* tag::reference[] [#lyra_option_style] = `lyra::option_style` Specify the syntax style for options to the parser. [source] ---- std::string value_delimiters; std::string long_option_prefix; std::size_t long_option_size = 0; std::string short_option_prefix; std::size_t short_option_size = 0; ---- * `value_delimiters` -- Specifies a set of characters that are accepted as a delimiter/separator between an option name and an option value when a single argument is used for the option+value (i.e. "--option=value"). * `long_option_prefix` -- Specifies a set of characters that are accepted as a prefix for long options (i.e. multi-char single option name). * `long_option_size` -- The number of prefix characters that indicates a long option. A value of zero (0) indicates that long options are not accepted. * `short_option_prefix` -- Specifies a set of characters that are accepted as a prefix for short options (i.e. single-char multi-options). * `short_option_size` -- The number of prefix characters that indicates a short option. A value of zero (0) indicates that short options are not accepted. end::reference[] */ struct option_style { std::string value_delimiters; std::string long_option_prefix; std::size_t long_option_size = 0; std::string short_option_prefix; std::size_t short_option_size = 0; option_style(std::string && value_delimiters_chars, std::string && long_option_prefix_chars = {}, std::size_t long_option_prefix_size = 0, std::string && short_option_prefix_chars = {}, std::size_t short_option_prefix_size = 0) : value_delimiters(std::move(value_delimiters_chars)) , long_option_prefix(std::move(long_option_prefix_chars)) , long_option_size(long_option_prefix_size) , short_option_prefix(std::move(short_option_prefix_chars)) , short_option_size(short_option_prefix_size) {} std::string long_option_string() const; std::string short_option_string() const; static const option_style & posix(); static const option_style & posix_brief(); static const option_style & windows(); }; /* tag::reference[] [#lyra_option_style_ctor] == Construction [source] ---- lyra::option_style::option_style( std::string && value_delimiters, std::string && long_option_prefix = {}, std::size_t long_option_size = 0, std::string && short_option_prefix = {}, std::size_t short_option_size = 0) ---- Utility constructor that defines all the settings. end::reference[] */ /* tag::reference[] [#lyra_option_style_def] == Definitions [source] ---- std::string lyra::option_style::long_option_string() const std::string lyra::option_style::short_option_string() const ---- Gives the default long or short option string, or prefix, for this option style. If the type of option is not available, i.e. size is zero, an empty string is returned. end::reference[] */ inline std::string option_style::long_option_string() const { return long_option_size > 0 ? std::string(long_option_size, long_option_prefix[0]) : ""; } inline std::string option_style::short_option_string() const { return short_option_size > 0 ? std::string(short_option_size, short_option_prefix[0]) : ""; } /* tag::reference[] [#lyra_option_style_styles] == Styles [source] ---- static const option_style & lyra::option_style::posix(); static const option_style & lyra::option_style::posix_brief(); static const option_style & lyra::option_style::windows(); ---- These provide definitions for common syntax of option styles: `posix`:: The overall _default_ that is two dashes (`--`) for long option names and one dash (`-`) for short option names. Values for long options use equal (`=`) between the option and value. `posix_brief`:: Variant that only allows for long option names with a single dash (`-`). `windows`:: The common option style on Windows `CMD.EXE` shell. It only allows long name options that start with slash (`/`) where the value is specified after a colon (`:`). Single character flag style options are only available as individual long options, for example `/A`. end::reference[] */ inline const option_style & option_style::posix() { static const option_style style("= ", "-", 2, "-", 1); return style; } inline const option_style & option_style::posix_brief() { static const option_style style("= ", "-", 1); return style; } inline const option_style & option_style::windows() { static const option_style style(":", "/", 1); return style; } } // namespace lyra #endif #include <string> #include <vector> namespace lyra { namespace detail { enum class token_type { unknown, option, argument }; template <typename Char, class Traits = std::char_traits<Char>> class basic_token_name { public: using traits_type = Traits; using value_type = Char; using pointer = value_type *; using const_pointer = const value_type *; using reference = value_type &; using const_reference = const value_type &; using size_type = std::size_t; using difference_type = std::ptrdiff_t; using const_iterator = const_pointer; using iterator = const_iterator; using const_reverse_iterator = std::reverse_iterator<const_iterator>; using reverse_iterator = const_reverse_iterator; using string_type = std::basic_string<value_type, traits_type>; basic_token_name() noexcept : str { nullptr } , len { 0 } {} basic_token_name(const basic_token_name &) noexcept = default; basic_token_name(const_pointer s) noexcept : str { s } , len { traits_type::length(s) } {} basic_token_name(const_pointer s, size_type count) noexcept : str { s } , len { count } {} basic_token_name & operator=(const basic_token_name &) noexcept = default; void swap(basic_token_name & other) noexcept { auto tmp = *this; *this = other; other = tmp; } const_iterator begin() const noexcept { return this->str; } const_iterator end() const noexcept { return this->str + this->len; } const_iterator cbegin() const noexcept { return this->str; } const_iterator cend() const noexcept { return this->str + this->len; } size_type size() const noexcept { return this->len; } size_type length() const noexcept { return this->len; } bool empty() const noexcept { return this->len == 0; } friend string_type to_string(const basic_token_name & t) { return { t.str, t.len }; } friend string_type operator+( const_pointer lhs, const basic_token_name & rhs) { return lhs + to_string(rhs); } private: const_pointer str; size_type len; }; using token_name = std::string; struct token { token_type type; token_name name; token() : type(token_type::unknown) {} token(const token & other) = default; token(token_type t, const token_name & n) : type(t) , name(n) {} explicit operator bool() const { return type != token_type::unknown; } }; class token_iterator { public: template <typename Span> explicit token_iterator(Span const & args, const option_style & opt_style) : style(opt_style) , args_i(args.begin()) , args_e(args.end()) , args_i_sub(opt_style.short_option_size) {} explicit operator bool() const noexcept { return args_i != args_e; } token_iterator & pop(const token & arg_or_opt) { if (arg_or_opt.type == token_type::option && has_short_option_prefix()) { if (++args_i_sub >= args_i->size()) { ++args_i; args_i_sub = style.short_option_size; } } else { ++args_i; args_i_sub = style.short_option_size; } return *this; } token_iterator & pop(const token & /* opt */, const token & /* val */) { if (has_short_option_prefix() && args_i->size() > 2) ++args_i; else if (!has_value_delimiter()) args_i += 2; else ++args_i; args_i_sub = style.short_option_size; return *this; } bool has_option_prefix() const noexcept { return has_long_option_prefix() || has_short_option_prefix(); } bool has_short_option_prefix() const noexcept { return (args_i != args_e) && is_prefixed( style.short_option_prefix, style.short_option_size, *args_i); } bool has_long_option_prefix() const noexcept { return (args_i != args_e) && is_prefixed( style.long_option_prefix, style.long_option_size, *args_i); } bool has_value_delimiter() const noexcept { return (args_i != args_e) && (args_i->find_first_of(style.value_delimiters) != std::string::npos); } token option() const { if (has_long_option_prefix()) { if (has_value_delimiter()) return token(token_type::option, args_i->substr( 0, args_i->find_first_of(style.value_delimiters))); else return token(token_type::option, *args_i); } else if (has_short_option_prefix()) { return { token_type::option, prefix_value(style.short_option_prefix, style.short_option_size) + (*args_i)[args_i_sub] }; } return token(); } token value() const { if (has_option_prefix() && has_value_delimiter()) return token(token_type::argument, args_i->substr( args_i->find_first_of(style.value_delimiters) + 1)); else if (has_long_option_prefix()) { if (args_i + 1 != args_e) return token(token_type::argument, *(args_i + 1)); } else if (has_short_option_prefix()) { if (args_i_sub + 1 < args_i->size()) return token( token_type::argument, args_i->substr(args_i_sub + 1)); else if (args_i + 1 != args_e) return token(token_type::argument, *(args_i + 1)); } return token(); } token argument() const { return token(token_type::argument, *args_i); } static bool is_prefixed( const std::string & prefix, std::size_t size, const std::string & s) { if (!prefix.empty() && size > 0 && s.size() > size) { for (auto c : prefix) { if (s[size] != c && s.find_last_not_of(c, size - 1) == std::string::npos) return true; } } return false; } private: const option_style & style; std::vector<std::string>::const_iterator args_i; std::vector<std::string>::const_iterator args_e; std::string::size_type args_i_sub; inline bool is_opt_prefix(char c) const noexcept { return is_prefix_char( style.long_option_prefix, style.long_option_size, c) || is_prefix_char( style.short_option_prefix, style.short_option_size, c); } inline bool is_prefix_char(const std::string & prefix, std::size_t size, std::string::value_type c) const noexcept { return !prefix.empty() && size > 0 && prefix.find(c) != std::string::npos; } inline std::string prefix_value( const std::string & prefix, std::size_t size) const { return std::string( static_cast<typename std::string::size_type>(size), prefix[0]); } }; }} // namespace lyra::detail #endif #ifndef LYRA_VAL_HPP #define LYRA_VAL_HPP #include <memory> namespace lyra { /* tag::reference[] [#lyra_val] = `lyra::val` [source] ---- auto val(T && v); auto val(const char * v); ---- Makes a bound self-contained value of the type of the given r-value. The created bound values can be used in place of the value references for arguments. And can be retrieved with the <<lyra_cli_array_ref>> call. */ // end::reference[] template <typename T> detail::BoundVal<T> val(T && v) { return detail::BoundVal<T>(std::forward<T>(v)); } inline detail::BoundVal<std::string> val(const char * v) { return detail::BoundVal<std::string>(v); } } // namespace lyra #endif #include <memory> #include <string> #include <type_traits> namespace lyra { namespace detail { class parse_state { public: parse_state(parser_result_type type, token_iterator const & remaining_tokens, size_t parsed_tokens = 0) : result_type(type) , tokens(remaining_tokens) { (void)parsed_tokens; } parser_result_type type() const { return result_type; } token_iterator remainingTokens() const { return tokens; } bool have_tokens() const { return bool(tokens); } private: parser_result_type result_type; token_iterator tokens; }; struct parser_cardinality { size_t minimum = 0; size_t maximum = 0; parser_cardinality() = default; parser_cardinality(size_t a, size_t b) : minimum(a) , maximum(b) {} bool is_optional() const { return (minimum == 0); } bool is_unbounded() const { return (maximum == 0); } bool is_bounded() const { return !is_unbounded(); } bool is_required() const { return (minimum > 0); } void optional() { minimum = 0; maximum = 1; } void required(size_t n = 1) { minimum = n; maximum = n; } void counted(size_t n) { minimum = n; maximum = n; } void bounded(size_t n, size_t m) { minimum = n; maximum = m; } }; } // namespace detail /* tag::reference[] [#lyra_parser_result] = `lyra::parser_result` The result of parsing arguments. end::reference[] */ class parse_result : public detail::basic_result<detail::parse_state> { public: using base = detail::basic_result<detail::parse_state>; using base::basic_result; using base::error; using base::ok; parse_result(const base & other) : base(other) {} }; /* tag::reference[] [#lyra_parser] = `lyra::parser` Base for all argument parser types. end::reference[] */ class parser { public: struct help_text_item { std::string option; std::string description; }; using help_text = std::vector<help_text_item>; [[deprecated]] help_text get_help_text() const { return {}; } [[deprecated]] std::string get_usage_text() const { return ""; } [[deprecated]] std::string get_description_text() const { return ""; } virtual help_text get_help_text(const option_style &) const { return {}; } virtual std::string get_usage_text(const option_style &) const { return ""; } virtual std::string get_description_text(const option_style &) const { return ""; } virtual ~parser() = default; virtual detail::parser_cardinality cardinality() const { return { 0, 1 }; } bool is_optional() const { return cardinality().is_optional(); } virtual bool is_group() const { return false; } virtual result validate() const { return result::ok(); } virtual std::unique_ptr<parser> clone() const { return nullptr; } virtual bool is_named(const std::string & n) const { (void)n; return false; } virtual const parser * get_named(const std::string & n) const { if (is_named(n)) return this; return nullptr; } virtual size_t get_value_count() const { return 0; } virtual std::string get_value(size_t i) const { (void)i; return ""; } virtual parse_result parse(detail::token_iterator const & tokens, const option_style & style) const = 0; protected: void print_help_text(std::ostream & os, const option_style & style) const { std::string usage_test = get_usage_text(style); if (!usage_test.empty()) os << "USAGE:\n" << " " << get_usage_text(style) << "\n\n"; std::string description_test = get_description_text(style); if (!description_test.empty()) os << get_description_text(style) << "\n"; os << "OPTIONS, ARGUMENTS:\n"; const std::string::size_type left_col_size = 26 - 3; const std::string left_pad(left_col_size, ' '); for (auto const & cols : get_help_text(style)) { if (cols.option.size() > left_pad.size()) os << " " << cols.option << "\n " << left_pad << " " << cols.description << "\n"; else os << " " << cols.option << left_pad.substr(0, left_pad.size() - cols.option.size()) << " " << cols.description << "\n"; } } }; /* tag::reference[] [#lyra_parser_specification] == Specification [#lyra_parser_help_text_item] === `lyra::parser::help_text_item` [source] ---- struct lyra::parser::help_text_item { std::string option; std::string description; }; ---- Holds the help information for a single argument option. The `option` member is the long name of the option. And the `description` is the text describing the option. A list of them is returned from the `lyra::parser::get_help_text` method. [#lyra_parser_help_text] === `lyra::parser::help_text` [source] ---- using help_text = std::vector<help_text_item>; ---- The set of help texts for any options in the sub-parsers to this one, if any. [#lyra_parser_get_help_text] === `lyra::parser::get_help_text` [source] ---- virtual help_text get_help_text(const option_style &) const; ---- Collects, and returns, the set of help items for the sub-parser arguments in this parser, if any. The default is to return an empty set. Which is what most parsers will return. Parsers like `arguments`, `group`, and `cli` will return a set for the arguments defined. This is called to print out the help text from the stream operator. [#lyra_parser_get_usage_text] === `lyra::parser::get_usage_text` [source] ---- virtual std::string get_usage_text(const option_style &) const; ---- Returns the formatted `USAGE` text for this parser, and any contained sub-parsers. This is called to print out the help text from the stream operator. [#lyra_parser_get_description_text] === `lyra::parser::get_description_text` [source] ---- virtual std::string get_description_text(const option_style &) const; ---- Returns the description text for this, and any contained sub-parsers. This is called to print out the help text from the stream operator. end::reference[] */ template <typename T, typename U> std::unique_ptr<parser> make_clone(const U * source) { return std::unique_ptr<parser>(new T(*static_cast<const T *>(source))); } /* tag::reference[] [#lyra_composable_parser] = `lyra::composable_parser` A parser that can be composed with other parsers using `operator|`. Composing two `composable_parser` instances generates a `cli` parser. end::reference[] */ template <typename Derived> class composable_parser : public parser {}; /* tag::reference[] [#lyra_bound_parser] = `lyra::bound_parser` Parser that binds a variable reference or callback to the value of an argument. end::reference[] */ template <typename Derived> class bound_parser : public composable_parser<Derived> { protected: std::shared_ptr<detail::BoundRef> m_ref; std::string m_hint; std::string m_description; detail::parser_cardinality m_cardinality; std::shared_ptr<detail::choices_base> value_choices; explicit bound_parser(std::shared_ptr<detail::BoundRef> const & ref) : m_ref(ref) { if (m_ref->isContainer()) m_cardinality = { 0, 0 }; else m_cardinality = { 0, 1 }; } bound_parser( std::shared_ptr<detail::BoundRef> const & ref, std::string const & hint) : m_ref(ref) , m_hint(hint) { if (m_ref->isContainer()) m_cardinality = { 0, 0 }; else m_cardinality = { 0, 1 }; } public: enum class ctor_lambda_e { val }; template <typename Reference> bound_parser(Reference & ref, std::string const & hint); template <typename Lambda> bound_parser(Lambda const & ref, std::string const & hint, typename std::enable_if<detail::is_invocable<Lambda>::value, ctor_lambda_e>::type = ctor_lambda_e::val); template <typename T> explicit bound_parser(detail::BoundVal<T> && val) : bound_parser(val.move_to_shared()) {} template <typename T> bound_parser(detail::BoundVal<T> && val, std::string const & hint) : bound_parser(val.move_to_shared(), hint) {} Derived & help(const std::string & text); Derived & operator()(std::string const & description); Derived & optional(); Derived & required(size_t n = 1); Derived & cardinality(size_t n); Derived & cardinality(size_t n, size_t m); detail::parser_cardinality cardinality() const override { return m_cardinality; } std::string hint() const; Derived & hint(std::string const & hint); template <typename T, typename... Rest, typename std::enable_if<!detail::is_invocable<T>::value, int>::type = 0> Derived & choices(T val0, Rest... rest); template <typename Lambda, typename std::enable_if<detail::is_invocable<Lambda>::value, int>::type = 1> Derived & choices(Lambda const & check_choice); template <typename T, std::size_t N> Derived & choices(const T (&choice_values)[N]); virtual std::unique_ptr<parser> clone() const override { return make_clone<Derived>(this); } virtual bool is_named(const std::string & n) const override { return n == m_hint; } virtual size_t get_value_count() const override { return m_ref->get_value_count(); } virtual std::string get_value(size_t i) const override { return m_ref->get_value(i); } }; /* tag::reference[] [#lyra_bound_parser_ctor] == Construction end::reference[] */ /* tag::reference[] [source] ---- template <typename Derived> template <typename Reference> bound_parser<Derived>::bound_parser(Reference& ref, std::string const& hint); template <typename Derived> template <typename Lambda> bound_parser<Derived>::bound_parser(Lambda const& ref, std::string const& hint); ---- Constructs a value option with a target typed variable or callback. These are options that take a value as in `--opt=value`. In the first form the given `ref` receives the value of the option after parsing. The second form the callback is called during the parse with the given value. Both take a `hint` that is used in the help text. When the option can be specified multiple times the callback will be called consecutively for each option value given. And if a container is given as a reference on the first form it will contain all the specified values. end::reference[] */ template <typename Derived> template <typename Reference> bound_parser<Derived>::bound_parser(Reference & ref, std::string const & hint) : bound_parser( std::make_shared<detail::BoundValueRef<Reference>>(ref), hint) {} template <typename Derived> template <typename Lambda> bound_parser<Derived>::bound_parser(Lambda const & ref, std::string const & hint, typename std::enable_if<detail::is_invocable<Lambda>::value, ctor_lambda_e>::type) : bound_parser(std::make_shared<detail::BoundLambda<Lambda>>(ref), hint) {} /* tag::reference[] [#lyra_bound_parser_specification] == Specification end::reference[] */ /* tag::reference[] [#lyra_bound_parser_help] === `lyra::bound_parser::help`, `lyra::bound_parser::operator(help)` [source] ---- template <typename Derived> Derived& bound_parser<Derived>::help(std::string const& help_description_text); template <typename Derived> Derived& bound_parser<Derived>::operator()(std::string const& help_description_text); ---- Defines the help description of an argument. end::reference[] */ template <typename Derived> Derived & bound_parser<Derived>::help(const std::string & help_description_text) { m_description = help_description_text; return static_cast<Derived &>(*this); } template <typename Derived> Derived & bound_parser<Derived>::operator()(std::string const & help_description_text) { return this->help(help_description_text); } /* tag::reference[] [#lyra_bound_parser_optional] === `lyra::bound_parser::optional` [source] ---- template <typename Derived> Derived& bound_parser<Derived>::optional(); ---- Indicates that the argument is optional. This is equivalent to specifying `cardinality(0, 1)`. end::reference[] */ template <typename Derived> Derived & bound_parser<Derived>::optional() { return this->cardinality(0, 1); } /* tag::reference[] [#lyra_bound_parser_required] === `lyra::bound_parser::required(n)` [source] ---- template <typename Derived> Derived& bound_parser<Derived>::required(size_t n); ---- Specifies that the argument needs to given the number of `n` times (defaults to *1*). end::reference[] */ template <typename Derived> Derived & bound_parser<Derived>::required(size_t n) { if (m_ref->isContainer()) return this->cardinality(1, 0); else return this->cardinality(n); } /* tag::reference[] [#lyra_bound_parser_cardinality] === `lyra::bound_parser::cardinality(n, m)` [source] ---- template <typename Derived> Derived& bound_parser<Derived>::cardinality(size_t n); template <typename Derived> Derived& bound_parser<Derived>::cardinality(size_t n, size_t m); ---- Specifies the number of times the argument can and needs to appear in the list of arguments. In the first form the argument can appear exactly `n` times. In the second form it specifies that the argument can appear from `n` to `m` times inclusive. end::reference[] */ template <typename Derived> Derived & bound_parser<Derived>::cardinality(size_t n) { m_cardinality = { n, n }; return static_cast<Derived &>(*this); } template <typename Derived> Derived & bound_parser<Derived>::cardinality(size_t n, size_t m) { m_cardinality = { n, m }; return static_cast<Derived &>(*this); } /* tag::reference[] [#lyra_bound_parser_choices] === `lyra::bound_parser::choices` [source] ---- template <typename Derived> template <typename T, typename... Rest> lyra::opt& lyra::bound_parser<Derived>::choices(T val0, Rest... rest) template <typename Derived> template <typename Lambda> lyra::opt& lyra::bound_parser<Derived>::choices(Lambda const &check_choice) ---- Limit the allowed values of an argument. In the first form the value is limited to the ones listed in the call (two or more values). In the second form the `check_choice` function is called with the parsed value and returns `true` if it's an allowed value. end::reference[] */ template <typename Derived> template <typename T, typename... Rest, typename std::enable_if<!detail::is_invocable<T>::value, int>::type> Derived & bound_parser<Derived>::choices(T val0, Rest... rest) { value_choices = std::make_shared<detail::choices_set<T>>(val0, rest...); return static_cast<Derived &>(*this); } template <typename Derived> template <typename Lambda, typename std::enable_if<detail::is_invocable<Lambda>::value, int>::type> Derived & bound_parser<Derived>::choices(Lambda const & check_choice) { value_choices = std::make_shared<detail::choices_check<Lambda>>(check_choice); return static_cast<Derived &>(*this); } template <typename Derived> template <typename T, std::size_t N> Derived & bound_parser<Derived>::choices(const T (&choice_values)[N]) { value_choices = std::make_shared<detail::choices_set<T>>( std::vector<T> { choice_values, choice_values + N }); return static_cast<Derived &>(*this); } /* tag::reference[] [#lyra_bound_parser_hint] === `lyra::bound_parser::hint` [source] ---- template <typename Derived> std::string lyra::bound_parser<Derived>::hint() const template <typename Derived> Derived & lyra::bound_parser<Derived>::hint(std::string const & hint) ---- Selectors to read and write the hint of a variable-bound parser. The hint should not be modified anymore, once the parser is applied to arguments or used in a `lyra::composable_parser`. end::reference[] */ template <typename Derived> std::string bound_parser<Derived>::hint() const { return m_hint; } template <typename Derived> Derived & bound_parser<Derived>::hint(std::string const & hint) { m_hint = hint; return static_cast<Derived &>(*this); } } // namespace lyra #endif namespace lyra { /* tag::reference[] [#lyra_arg] = `lyra::arg` A parser for regular arguments, i.e. not `--` or `-` prefixed. This is simply a way to get values of arguments directly specified in the cli. Is-a <<lyra_bound_parser>>. */ // end::reference[] class arg : public bound_parser<arg> { public: using bound_parser::bound_parser; virtual std::string get_usage_text(const option_style &) const override { std::ostringstream oss; if (!m_hint.empty()) { auto c = cardinality(); if (c.is_required()) { for (size_t i = 0; i < c.minimum; ++i) oss << (i > 0 ? " " : "") << "<" << m_hint << ">"; if (c.is_unbounded()) oss << (c.is_required() ? " " : "") << "[<" << m_hint << ">...]"; } else if (c.is_unbounded()) { oss << "[<" << m_hint << ">...]"; } else { oss << "<" << m_hint << ">"; } } return oss.str(); } virtual help_text get_help_text(const option_style & style) const override { return { { get_usage_text(style), m_description } }; } using parser::parse; parse_result parse(detail::token_iterator const & tokens, const option_style & style) const override { (void)style; LYRA_PRINT_SCOPE("arg::parse"); auto validationResult = validate(); if (!validationResult) return parse_result(validationResult); if (!tokens) { return parse_result::ok( detail::parse_state(parser_result_type::no_match, tokens)); } auto const & token = tokens.argument(); auto valueRef = static_cast<detail::BoundValueRefBase *>(m_ref.get()); if (value_choices) { auto choice_result = value_choices->contains_value(token.name); if (!choice_result) { LYRA_PRINT_DEBUG( "(!)", get_usage_text(style), "!=", token.name); return parse_result(choice_result); } } auto set_result = valueRef->setValue(token.name); if (!set_result) { LYRA_PRINT_DEBUG("(!)", get_usage_text(style), "!=", token.name); return parse_result(set_result); } else { LYRA_PRINT_DEBUG("(=)", get_usage_text(style), "==", token.name); auto remainingTokens = tokens; remainingTokens.pop(token); return parse_result::ok(detail::parse_state( parser_result_type::matched, remainingTokens)); } } }; } // namespace lyra #endif #ifndef LYRA_ARGUMENTS_HPP #define LYRA_ARGUMENTS_HPP #ifndef LYRA_EXE_NAME_HPP #define LYRA_EXE_NAME_HPP namespace lyra { /* tag::reference[] [#lyra_exe_name] = `lyra::exe_name` Specifies the name of the executable. Is-a <<lyra_composable_parser>>. end::reference[] */ class exe_name : public composable_parser<exe_name> { public: exe_name() : m_name(std::make_shared<std::string>("<executable>")) {} explicit exe_name(std::string & ref); template <typename LambdaT> explicit exe_name(LambdaT const & lambda); std::string name() const; parser_result set(std::string const & newName); virtual parse_result parse(detail::token_iterator const & tokens, const option_style &) const override { return parse_result::ok( detail::parse_state(parser_result_type::no_match, tokens)); } virtual std::unique_ptr<parser> clone() const override { return make_clone<exe_name>(this); } private: std::shared_ptr<std::string> m_name; std::shared_ptr<detail::BoundValueRefBase> m_ref; }; /* tag::reference[] [#lyra_exe_name_ctor] == Construction end::reference[] */ /* tag::reference[] [source] ---- exe_name::exe_name(std::string& ref) ---- Constructs with a target string to receive the name of the executable. When the `cli` is run the target string will contain the exec name. end::reference[] */ inline exe_name::exe_name(std::string & ref) : exe_name() { m_ref = std::make_shared<detail::BoundValueRef<std::string>>(ref); } /* tag::reference[] [source] ---- template <typename LambdaT> exe_name::exe_name(LambdaT const& lambda) ---- Construct with a callback that is called with the value of the executable name when the `cli` runs. end::reference[] */ template <typename LambdaT> exe_name::exe_name(LambdaT const & lambda) : exe_name() { m_ref = std::make_shared<detail::BoundLambda<LambdaT>>(lambda); } /* tag::reference[] [#lyra_exe_name_accessors] == Accessors end::reference[] */ /* tag::reference[] [#lyra_exe_name_name] === `lyra::exe_name::name` [source] ---- std::string exe_name::name() const ---- Returns the executable name when available. Otherwise it returns a default value. end::reference[] */ inline std::string exe_name::name() const { return *m_name; } /* tag::reference[] [#lyra_exe_name_set] === `lyra::exe_name::set` [source] ---- parser_result exe_name::set(std::string const& newName) ---- Sets the executable name with the `newName` value. The new value is reflected in the bound string reference or callback. end::reference[] */ inline parser_result exe_name::set(std::string const & newName) { auto lastSlash = newName.find_last_of("\\/"); auto filename = (lastSlash == std::string::npos) ? newName : newName.substr(lastSlash + 1); *m_name = filename; if (m_ref) return m_ref->setValue(filename); else return parser_result::ok(parser_result_type::matched); } } // namespace lyra #endif #include <functional> #include <sstream> namespace lyra { /* tag::reference[] [#lyra_arguments] = `lyra::arguments` A Combined parser made up of any number of parsers. Creating and using one of these as a basis one can incrementally compose other parsers into this one. For example: [source] ---- auto p = lyra::arguments(); std::string what; float when = 0; std::string where; p |= lyra::opt(what, "what")["--make-it-so"]("Make it so.").required(); p |= lyra::opt(when. "when")["--time"]("When to do <what>.").optional(); p.add_argument(lyra::opt(where, "where").name("--where") .help("There you are.").optional()); ---- */ // end::reference[] class arguments : public parser { public: enum evaluation { any = 0, sequence = 1 }; arguments() = default; arguments(evaluation e) : eval_mode(e) {} arguments(const arguments & other); arguments & add_argument(parser const & p); arguments & operator|=(parser const & p); arguments & add_argument(arguments const & other); arguments & operator|=(arguments const & other); template <typename T> arguments operator|(T const & other) const { return arguments(*this) |= other; } arguments & sequential(); arguments & inclusive(); template <typename T> T & get(size_t i); virtual std::string get_usage_text( const option_style & style) const override { std::ostringstream os; for (auto const & p : parsers) { std::string usage_text = p->get_usage_text(style); if (usage_text.size() > 0) { if (os.tellp() != std::ostringstream::pos_type(0)) os << " "; if (p->is_group() && p->is_optional()) os << "[ " << usage_text << " ]"; else if (p->is_group()) os << "{ " << usage_text << " }"; else if (p->is_optional()) os << "[" << usage_text << "]"; else os << usage_text; } } return os.str(); } virtual std::string get_description_text( const option_style & style) const override { std::ostringstream os; for (auto const & p : parsers) { if (p->is_group()) continue; auto child_description = p->get_description_text(style); if (!child_description.empty()) os << child_description << "\n"; } return os.str(); } virtual help_text get_help_text(const option_style & style) const override { help_text text; for (auto const & p : parsers) { if (p->is_group()) text.push_back({ "", "" }); auto child_help = p->get_help_text(style); text.insert(text.end(), child_help.begin(), child_help.end()); } return text; } virtual detail::parser_cardinality cardinality() const override { return { 0, 0 }; } virtual result validate() const override { for (auto const & p : parsers) { auto parse_valid = p->validate(); if (!parse_valid) return parse_valid; } return result::ok(); } parse_result parse(detail::token_iterator const & tokens, const option_style & style) const override { switch (eval_mode) { case any: return parse_any(tokens, style); case sequence: return parse_sequence(tokens, style); } return parse_result::error( detail::parse_state(parser_result_type::no_match, tokens), "Unknown evaluation mode; not one of 'any', or 'sequence'."); } parse_result parse_any( detail::token_iterator const & tokens, const option_style & style) const { LYRA_PRINT_SCOPE("arguments::parse_any"); LYRA_PRINT_DEBUG("(?)", get_usage_text(style), "?=", tokens ? tokens.argument().name : "", ".."); struct ParserInfo { parser const * parser_p = nullptr; size_t count = 0; }; std::vector<ParserInfo> parser_info(parsers.size()); { size_t i = 0; for (auto const & p : parsers) parser_info[i++].parser_p = p.get(); } auto p_result = parse_result::ok( detail::parse_state(parser_result_type::matched, tokens)); auto error_result = parse_result::ok( detail::parse_state(parser_result_type::no_match, tokens)); while (p_result.value().remainingTokens()) { bool token_parsed = false; for (auto & parse_info : parser_info) { auto parser_cardinality = parse_info.parser_p->cardinality(); if (parser_cardinality.is_unbounded() || parse_info.count < parser_cardinality.maximum) { auto subparse_result = parse_info.parser_p->parse( p_result.value().remainingTokens(), style); if (!subparse_result) { LYRA_PRINT_DEBUG("(!)", get_usage_text(style), "!=", p_result.value().remainingTokens().argument().name); if (subparse_result.has_value() && subparse_result.value().type() == parser_result_type::short_circuit_all) return subparse_result; if (error_result) error_result = parse_result(subparse_result); } else if (subparse_result && subparse_result.value().type() != parser_result_type::no_match) { LYRA_PRINT_DEBUG("(=)", get_usage_text(style), "==", p_result.value().remainingTokens().argument().name, "==>", subparse_result.value().type()); p_result = parse_result(subparse_result); token_parsed = true; parse_info.count += 1; break; } } } if (p_result.value().type() == parser_result_type::short_circuit_all) return p_result; if (!token_parsed && !error_result) return error_result; if (!token_parsed) break; } for (auto & parseInfo : parser_info) { auto parser_cardinality = parseInfo.parser_p->cardinality(); if ((parser_cardinality.is_bounded() && (parseInfo.count < parser_cardinality.minimum || parser_cardinality.maximum < parseInfo.count)) || (parser_cardinality.is_required() && (parseInfo.count < parser_cardinality.minimum))) { return parse_result::error(p_result.value(), "Expected: " + parseInfo.parser_p->get_usage_text(style)); } } return p_result; } parse_result parse_sequence( detail::token_iterator const & tokens, const option_style & style) const { LYRA_PRINT_SCOPE("arguments::parse_sequence"); LYRA_PRINT_DEBUG("(?)", get_usage_text(style), "?=", tokens ? tokens.argument().name : "", ".."); struct ParserInfo { parser const * parser_p = nullptr; size_t count = 0; }; std::vector<ParserInfo> parser_info(parsers.size()); { size_t i = 0; for (auto const & p : parsers) parser_info[i++].parser_p = p.get(); } auto p_result = parse_result::ok( detail::parse_state(parser_result_type::matched, tokens)); for (std::size_t parser_i = 0; parser_i < parsers.size(); ++parser_i) { auto & parse_info = parser_info[parser_i]; auto parser_cardinality = parse_info.parser_p->cardinality(); do { auto subresult = parse_info.parser_p->parse( p_result.value().remainingTokens(), style); if (!subresult) { break; } if (subresult.value().type() == parser_result_type::short_circuit_all) { return subresult; } if (subresult.value().type() != parser_result_type::no_match) { LYRA_PRINT_DEBUG("(=)", get_usage_text(style), "==", p_result.value().remainingTokens() ? p_result.value().remainingTokens().argument().name : "", "==>", subresult.value().type()); p_result = subresult; parse_info.count += 1; } } while (p_result.value().have_tokens() && (parser_cardinality.is_unbounded() || parse_info.count < parser_cardinality.maximum)); if ((parser_cardinality.is_bounded() && (parse_info.count < parser_cardinality.minimum || parser_cardinality.maximum < parse_info.count)) || (parser_cardinality.is_required() && (parse_info.count < parser_cardinality.minimum))) { return parse_result::error(p_result.value(), "Expected: " + parse_info.parser_p->get_usage_text(style)); } } return p_result; } virtual std::unique_ptr<parser> clone() const override { return make_clone<arguments>(this); } friend std::ostream & operator<<( std::ostream & os, arguments const & parser) { const option_style & s = parser.opt_style ? *parser.opt_style : option_style::posix(); parser.print_help_text(os, s); return os; } virtual const parser * get_named(const std::string & n) const override { for (auto & p : parsers) { const parser * p_result = p->get_named(n); if (p_result) return p_result; } return nullptr; } protected: std::shared_ptr<option_style> opt_style; private: std::vector<std::unique_ptr<parser>> parsers; evaluation eval_mode = any; }; /* tag::reference[] [#lyra_arguments_ctor] == Construction end::reference[] */ /* tag::reference[] [#lyra_arguments_ctor_default] === Default [source] ---- arguments() = default; ---- Default constructing a `arguments` is the starting point to adding arguments and options for parsing a arguments line. end::reference[] */ /* tag::reference[] [#lyra_arguments_ctor_copy] === Copy [source] ---- arguments::arguments(const arguments& other); ---- end::reference[] */ inline arguments::arguments(const arguments & other) : parser(other) , opt_style(other.opt_style) , eval_mode(other.eval_mode) { for (auto & other_parser : other.parsers) { parsers.push_back(other_parser->clone()); } } /* tag::reference[] [#lyra_arguments_specification] == Specification end::reference[] */ /* tag::reference[] [#lyra_arguments_add_argument] === `lyra::arguments::add_argument` [source] ---- arguments& arguments::add_argument(parser const& p); arguments& arguments::operator|=(parser const& p); arguments& arguments::add_argument(arguments const& other); arguments& arguments::operator|=(arguments const& other); ---- Adds the given argument parser to the considered arguments for this `arguments`. Depending on the parser given it will be: directly added as an argument (for `parser`), or add the parsers from another `arguments` to this one. end::reference[] */ inline arguments & arguments::add_argument(parser const & p) { parsers.push_back(p.clone()); return *this; } inline arguments & arguments::operator|=(parser const & p) { return this->add_argument(p); } inline arguments & arguments::add_argument(arguments const & other) { if (other.is_group()) { parsers.push_back(other.clone()); } else { for (auto & p : other.parsers) { parsers.push_back(p->clone()); } } return *this; } inline arguments & arguments::operator|=(arguments const & other) { return this->add_argument(other); } /* tag::reference[] === `lyra::arguments::sequential` [source] ---- arguments & arguments::sequential(); ---- Sets the parsing mode for the arguments to "sequential". When parsing the arguments they will be, greedily, consumed in the order they where added. This is useful for sub-commands and structured command lines. end::reference[] */ inline arguments & arguments::sequential() { eval_mode = sequence; return *this; } /* tag::reference[] === `lyra::arguments::inclusive` [source] ---- arguments & arguments::inclusive(); ---- Sets the parsing mode for the arguments to "inclusively any". This is the default that attempts to match each parsed argument with all the available parsers. This means that there is no ordering enforced. end::reference[] */ inline arguments & arguments::inclusive() { eval_mode = any; return *this; } /* tag::reference[] === `lyra::arguments::get` [source] ---- template <typename T> T & arguments::get(size_t i); ---- Get a modifyable reference to one of the parsers specified. end::reference[] */ template <typename T> T & arguments::get(size_t i) { return static_cast<T &>(*parsers.at(i)); } } // namespace lyra #endif #ifndef LYRA_CLI_HPP #define LYRA_CLI_HPP #ifndef LYRA_DETAIL_DEPRECATED_PARSER_CUSTOMIZATION_HPP #define LYRA_DETAIL_DEPRECATED_PARSER_CUSTOMIZATION_HPP #include <string> namespace lyra { /* tag::reference[] [#lyra_parser_customization] = `lyra::parser_customization` Customization interface for parsing of options. [source] ---- virtual std::string token_delimiters() const = 0; ---- Specifies the characters to use for splitting a cli argument into the option and its value (if any). [source] ---- virtual std::string option_prefix() const = 0; ---- Specifies the characters to use as possible prefix, either single or double, for all options. end::reference[] */ struct parser_customization { virtual std::string token_delimiters() const = 0; virtual std::string option_prefix() const = 0; }; /* tag::reference[] [#lyra_default_parser_customization] = `lyra::default_parser_customization` Is-a `lyra::parser_customization` that defines token delimiters as space (" ") or equal (`=`). And specifies the option prefix character as dash (`-`) resulting in long options with `--` and short options with `-`. This customization is used as the default if none is given. end::reference[] */ struct default_parser_customization : parser_customization { std::string token_delimiters() const override { return " ="; } std::string option_prefix() const override { return "-"; } }; } // namespace lyra #endif #ifndef LYRA_GROUP_HPP #define LYRA_GROUP_HPP #include <functional> namespace lyra { /* tag::reference[] [#lyra_group] = `lyra::group` A group of arguments provides for parsing, optionally, a set of arguments together. The group itself is considered successfully parsed only when the arguments in the group are parsed without errors. A common use case for this are sub-commands. This implementation is recursive. And hence allows groups within groups for describing branching argument parsing. Is-a <<lyra_arguments>>. end::reference[] */ class group : public arguments { public: group(); group(const group & other); explicit group(const std::function<void(const group &)> & f); virtual bool is_group() const override { return true; } parse_result parse(detail::token_iterator const & tokens, const option_style & style) const override { LYRA_PRINT_SCOPE("group::parse"); LYRA_PRINT_DEBUG("(?)", get_usage_text(style), "?=", tokens ? tokens.argument().name : ""); parse_result p_result = arguments::parse(tokens, style); if (p_result && p_result.value().type() != parser_result_type::no_match && success_signal) { this->success_signal(*this); } if (!p_result) { LYRA_PRINT_DEBUG("(!)", get_usage_text(style), "!=", tokens ? tokens.argument().name : ""); } else { LYRA_PRINT_DEBUG("(=)", get_usage_text(style), "==", tokens ? tokens.argument().name : "", "==>", p_result.value().type()); } return p_result; } group & optional(); group & required(size_t n = 1); group & cardinality(size_t n); group & cardinality(size_t n, size_t m); detail::parser_cardinality cardinality() const override { return m_cardinality; } virtual std::unique_ptr<parser> clone() const override { return make_clone<group>(this); } private: std::function<void(const group &)> success_signal; detail::parser_cardinality m_cardinality = { 0, 1 }; }; /* tag::reference[] [#lyra_group_ctor] == Construction end::reference[] */ /* tag::reference[] [#lyra_group_ctor_default] === Default [source] ---- group(); ---- Default constructing a `group` does not register the success callback. end::reference[] */ inline group::group() : m_cardinality(0, 1) {} /* tag::reference[] [#lyra_group_ctor_copy] === Copy [source] ---- group::group(const group & other); ---- end::reference[] */ inline group::group(const group & other) : arguments(other) , success_signal(other.success_signal) , m_cardinality(other.m_cardinality) {} /* tag::reference[] [#lyra_group_ctor_success] === Success Handler [source] ---- group::group(const std::function<void(const group &)> & f) ---- Registers a function to call when the group is successfully parsed. The function is called with the group to facilitate customization. end::reference[] */ inline group::group(const std::function<void(const group &)> & f) : success_signal(f) {} /* tag::reference[] [#lyra_group_optional] === `lyra::group::optional` [source] ---- group & group::optional(); ---- Indicates that the argument is optional. This is equivalent to specifying `cardinality(0, 1)`. end::reference[] */ inline group & group::optional() { m_cardinality.optional(); return *this; } /* tag::reference[] [#lyra_group_required] === `lyra::group::required(n)` [source] ---- group & group::required(size_t n); ---- Specifies that the argument needs to given the number of `n` times (defaults to *1*). end::reference[] */ inline group & group::required(size_t n) { m_cardinality.required(n); return *this; } /* tag::reference[] [#lyra_group_cardinality] === `lyra::group::cardinality(n)` [source] ---- group & group::cardinality(size_t n); group & group::cardinality(size_t n, size_t m); ---- Specifies the number of times the argument can and needs to appear in the list of arguments. In the first form the argument can appear exactly `n` times. In the second form it specifies that the argument can appear from `n` to `m` times inclusive. end::reference[] */ inline group & group::cardinality(size_t n) { m_cardinality.counted(n); return *this; } inline group & group::cardinality(size_t n, size_t m) { m_cardinality.bounded(n, m); return *this; } } // namespace lyra #endif #include <type_traits> namespace lyra { /* tag::reference[] [#lyra_cli] = `lyra::cli` A Combined parser made up of any two or more other parsers. Creating and using one of these as a basis one can incrementally compose other parsers into this one. For example: [source] ---- auto cli = lyra::cli(); std::string what; float when = 0; std::string where; cli |= lyra::opt(what, "what")["--make-it-so"]("Make it so.").required(); cli |= lyra::opt(when. "when")["--time"]("When to do <what>.").optional(); cli.add_argument(lyra::opt(where, "where").name("--where") .help("There you are.").optional()); ---- */ // end::reference[] class cli : protected arguments { public: cli() = default; cli(const cli & other); cli & add_argument(exe_name const & exe_name); cli & operator|=(exe_name const & exe_name); cli & add_argument(parser const & p); cli & operator|=(parser const & p); cli & add_argument(group const & p); cli & operator|=(group const & p); cli & add_argument(cli const & other); cli & operator|=(cli const & other); template <typename T> cli operator|(T const & other) const; struct value_result { public: explicit value_result(const parser * p) : parser_ref(p) {} template <typename T, typename std::enable_if<detail::is_convertible_from_string< typename detail::remove_cvref<T>::type>::value>:: type * = nullptr> operator T() const { typename detail::remove_cvref<T>::type converted_value {}; if (parser_ref) detail::from_string<std::string, typename detail::remove_cvref<T>::type>( parser_ref->get_value(0), converted_value); return converted_value; } template <typename T> operator std::vector<T>() const { std::vector<T> converted_value; if (parser_ref) { for (size_t i = 0; i < parser_ref->get_value_count(); ++i) { T v; if (detail::from_string(parser_ref->get_value(i), v)) converted_value.push_back(v); } } return converted_value; } operator std::string() const { if (parser_ref) return parser_ref->get_value(0); return ""; } private: const parser * parser_ref = nullptr; }; value_result operator[](const std::string & n); cli & style(const option_style & style); cli & style(option_style && style); friend std::ostream & operator<<(std::ostream & os, cli const & parser) { return os << static_cast<const arguments &>(parser); } parse_result parse(args const & args) const { if (opt_style) return parse(args, *opt_style); else return parse(args, option_style::posix()); } parse_result parse(args const & args, const option_style & style) const; [[deprecated]] parse_result parse( args const & args, const parser_customization & customize) const { return this->parse(args, option_style(customize.token_delimiters(), customize.option_prefix(), 2, customize.option_prefix(), 1)); } using arguments::parse; using arguments::get_named; virtual std::unique_ptr<parser> clone() const override { return std::unique_ptr<parser>(new cli(*this)); } protected: mutable exe_name m_exeName; virtual std::string get_usage_text( const option_style & style) const override { if (!m_exeName.name().empty()) return m_exeName.name() + " " + arguments::get_usage_text(style); else return ""; } }; /* tag::reference[] [#lyra_cli_ctor] == Construction end::reference[] */ /* tag::reference[] [#lyra_cli_ctor_default] === Default [source] ---- cli() = default; ---- Default constructing a `cli` is the starting point to adding arguments and options for parsing a command line. end::reference[] */ /* tag::reference[] [#lyra_cli_ctor_copy] === Copy [source] ---- cli::cli(const cli& other); ---- end::reference[] */ inline cli::cli(const cli & other) : arguments(other) , m_exeName(other.m_exeName) {} /* tag::reference[] [#lyra_cli_specification] == Specification end::reference[] */ /* tag::reference[] [#lyra_cli_add_argument] === `lyra::cli::add_argument` [source] ---- cli& cli::add_argument(exe_name const& exe_name); cli& cli::operator|=(exe_name const& exe_name); cli& cli::add_argument(parser const& p); cli& cli::operator|=(parser const& p); cli& cli::add_argument(group const& p); cli& cli::operator|=(group const& p); cli& cli::add_argument(cli const& other); cli& cli::operator|=(cli const& other); ---- Adds the given argument parser to the considered arguments for this `cli`. Depending on the parser given it will be: recorded as the exe name (for `exe_name` parser), directly added as an argument (for `parser`), or add the parsers from another `cli` to this one. end::reference[] */ inline cli & cli::add_argument(exe_name const & exe_name) { m_exeName = exe_name; return *this; } inline cli & cli::operator|=(exe_name const & exe_name) { return this->add_argument(exe_name); } inline cli & cli::add_argument(parser const & p) { arguments::add_argument(p); return *this; } inline cli & cli::operator|=(parser const & p) { arguments::add_argument(p); return *this; } inline cli & cli::add_argument(group const & other) { arguments::add_argument(static_cast<parser const &>(other)); return *this; } inline cli & cli::operator|=(group const & other) { return this->add_argument(other); } inline cli & cli::add_argument(cli const & other) { arguments::add_argument(static_cast<arguments const &>(other)); return *this; } inline cli & cli::operator|=(cli const & other) { return this->add_argument(other); } template <typename T> inline cli cli::operator|(T const & other) const { return cli(*this).add_argument(other); } template <typename DerivedT, typename T> cli operator|(composable_parser<DerivedT> const & thing, T const & other) { return cli() | static_cast<DerivedT const &>(thing) | other; } /* tag::reference[] [#lyra_cli_array_ref] === `lyra::cli::operator[]` [source] ---- cli::value_result cli::operator[](const std::string & n) ---- Finds the given argument by either option name or hint name and returns a convertible reference to the value, either the one provided by the user or the default. end::reference[] */ inline cli::value_result cli::operator[](const std::string & n) { return value_result(this->get_named(n)); } /* tag::reference[] [#lyra_cli_parse] === `lyra::cli::parse` [source] ---- parse_result cli::parse( args const& args, const option_style& customize) const; ---- Parses given arguments `args` and optional option style. The result indicates success or failure, and if failure what kind of failure it was. The state of variables bound to options is unspecified and any bound callbacks may have been called. end::reference[] */ inline parse_result cli::parse( args const & args, const option_style & style) const { LYRA_PRINT_SCOPE("cli::parse"); m_exeName.set(args.exe_name()); detail::token_iterator args_tokens(args, style); parse_result p_result = parse(args_tokens, style); if (p_result && (p_result.value().type() == parser_result_type::no_match || p_result.value().type() == parser_result_type::matched)) { if (p_result.value().have_tokens()) { return parse_result::error(p_result.value(), "Unrecognized token: " + p_result.value().remainingTokens().argument().name); } } return p_result; } /* tag::reference[] [#lyra_cli_style] === `lyra::cli::style` [source] ---- lyra::cli & lyra::cli::style(const lyra::option_style & style) lyra::cli & lyra::cli::style(lyra::option_style && style) ---- Specifies the <<lyra_option_style>> to accept for this instance. end::reference[] */ inline cli & cli::style(const option_style & style) { opt_style = std::make_shared<option_style>(style); return *this; } inline cli & cli::style(option_style && style) { opt_style = std::make_shared<option_style>(std::move(style)); return *this; } } // namespace lyra #endif #ifndef LYRA_CLI_PARSER_HPP #define LYRA_CLI_PARSER_HPP namespace lyra { using cli_parser = cli; } // namespace lyra #endif #ifndef LYRA_COMMAND_HPP #define LYRA_COMMAND_HPP #ifndef LYRA_LITERAL_HPP #define LYRA_LITERAL_HPP #include <string> namespace lyra { /* tag::reference[] [#lyra_literal] = `lyra::literal` A parser that matches a single fixed value. Is-a <<lyra_parser>>. end::reference[] */ class literal : public parser { public: literal(std::string const & n); literal & help(const std::string & help_description_text); literal & operator()(std::string const & help_description_text); virtual detail::parser_cardinality cardinality() const override { return { 1, 1 }; } virtual std::string get_usage_text(const option_style &) const override { return name; } virtual std::string get_description_text( const option_style &) const override { return description; } virtual help_text get_help_text(const option_style &) const override { return { { name, description } }; } using parser::parse; virtual parse_result parse(detail::token_iterator const & tokens, const option_style &) const override { auto validationResult = validate(); if (!validationResult) return parse_result(validationResult); auto const & token = tokens.argument(); if (name == token.name) { auto remainingTokens = tokens; remainingTokens.pop(token); return parse_result::ok(detail::parse_state( parser_result_type::matched, remainingTokens)); } else { return parse_result(parser_result::error( parser_result_type::no_match, "Expected '" + name + "'.")); } } virtual std::unique_ptr<parser> clone() const override { return make_clone<literal>(this); } protected: std::string name; std::string description; }; /* tag::reference[] [#lyra_literal_ctor] == Construction end::reference[] */ /* tag::reference[] === Token [#lyra_literal_ctor_token] [source] ---- inline literal::literal(std::string const& n) ---- Constructs the literal with the name of the token to match. end::reference[] */ inline literal::literal(std::string const & n) : name(n) {} /* tag::reference[] [#lyra_literal_specification] == Specification end::reference[] */ /* tag::reference[] [#lyra_literal_help] === `lyra:literal::help` [source] ---- literal& literal::help(const std::string& help_description_text) literal& literal::operator()(std::string const& help_description_text) ---- Specify a help description for the literal. end::reference[] */ inline literal & literal::help(const std::string & help_description_text) { description = help_description_text; return *this; } inline literal & literal::operator()(std::string const & help_description_text) { return this->help(help_description_text); } } // namespace lyra #endif #include <functional> #include <string> namespace lyra { /* tag::reference[] [#lyra_command] = `lyra::command` A parser that encapsulates the pattern of parsing sub-commands. It provides a quick wrapper for the equivalent arrangement of `group` and `literal` parsers. For example: [source] ---- lyra::command c = lyra::command("sub"); ---- Is equivalent to: [source] ---- lyra::command c = lyra::group() .sequential() .add_argument(literal("sub")) .add_argument(group()); lyra::group & g = c.get<lyra::group>(1); ---- I.e. it's conposed of a `literal` followed by the rest of the command arguments. Is-a <<lyra_group>>. */ // end::reference[] class command : public group { public: explicit command(const std::string & n); command( const std::string & n, const std::function<void(const group &)> & f); command & help(const std::string & text); command & operator()(std::string const & description); template <typename P> command & add_argument(P const & p); template <typename P> command & operator|=(P const & p); virtual std::unique_ptr<parser> clone() const override { return make_clone<command>(this); } }; /* tag::reference[] [#lyra_command_ctor] == Construction [source] ---- command::command(const std::string & n); command::command( const std::string & n, const std::function<void(const group &)>& f); ---- To construct an `command` we need a name (`n`) that matches, and triggers, that command. end::reference[] */ inline command::command(const std::string & n) { this->sequential() .add_argument(literal(n)) .add_argument(group().required()); } inline command::command( const std::string & n, const std::function<void(const group &)> & f) : group(f) { this->sequential() .add_argument(literal(n)) .add_argument(group().required()); } /* tag::reference[] [#lyra_command_specification] == Specification end::reference[] */ /* tag::reference[] [#lyra_command_help] === `lyra:command::help` [source] ---- command & command::help(const std::string& text) command & command::operator()(std::string const& description) ---- Specify a help description for the command. This sets the help for the underlying literal of the command. end::reference[] */ inline command & command::help(const std::string & text) { this->get<literal>(0).help(text); return *this; } inline command & command::operator()(std::string const & description) { return this->help(description); } /* tag::reference[] [#lyra_command_add_argument] === `lyra::command::add_argument` [source] ---- template <typename P> command & command::add_argument(P const & p); template <typename P> command & command::operator|=(P const & p); ---- Adds the given argument parser to the considered arguments for this `comand`. The argument is added to the sub-group argument instead of this one. Hence it has the effect of adding arguments *after* the command name. end::reference[] */ template <typename P> command & command::add_argument(P const & p) { this->get<group>(1).add_argument(p); return *this; } template <typename P> command & command::operator|=(P const & p) { return this->add_argument(p); } } // namespace lyra #endif #ifndef LYRA_HELP_HPP #define LYRA_HELP_HPP #ifndef LYRA_OPT_HPP #define LYRA_OPT_HPP #include <memory> namespace lyra { /* tag::reference[] [#lyra_opt] = `lyra::opt` A parser for one option with multiple possible names. The option value(s) are communicated through a reference to a variable, a container, or a callback. Is-a <<lyra_bound_parser>>. end::reference[] */ class opt : public bound_parser<opt> { public: enum class ctor_lambda_e { val }; enum class ctor_ref_e { val }; explicit opt(bool & ref); template <typename L> explicit opt(L const & ref, typename std::enable_if<detail::is_invocable<L>::value, ctor_lambda_e>::type = ctor_lambda_e::val); template <typename T> opt(T & ref, std::string const & hint, typename std::enable_if<!detail::is_invocable<T>::value, ctor_ref_e>::type = ctor_ref_e::val); template <typename L> opt(L const & ref, std::string const & hint, typename std::enable_if<detail::is_invocable<L>::value, ctor_lambda_e>::type = ctor_lambda_e::val); template <typename T> explicit opt(detail::BoundVal<T> && val) : bound_parser(val.move_to_shared()) {} template <typename T> explicit opt(detail::BoundVal<T> && val, std::string const & hint) : bound_parser(val.move_to_shared(), hint) {} opt & name(const std::string & opt_name); opt & operator[](std::string const & opt_name); virtual std::string get_usage_text( const option_style & style) const override { std::string usage; for (std::size_t o = 0; o < opt_names.size(); ++o) { if (o > 0) usage += "|"; usage += format_opt(opt_names[o], style); } if (!m_hint.empty()) usage += " <" + m_hint + ">"; return usage; } virtual help_text get_help_text(const option_style & style) const override { std::ostringstream oss; bool first = true; for (auto const & opt_name : opt_names) { if (first) first = false; else oss << ", "; oss << format_opt(opt_name, style); } if (!m_hint.empty()) oss << " <" << m_hint << ">"; return { { oss.str(), m_description } }; } virtual bool is_named(const std::string & n) const override { return bound_parser::is_named(n) || (std::find(opt_names.begin(), opt_names.end(), n) != opt_names.end()); } using parser::parse; parse_result parse(detail::token_iterator const & tokens, const option_style & style) const override { LYRA_PRINT_SCOPE("opt::parse"); auto validationResult = validate(); if (!validationResult) return parse_result(validationResult); auto remainingTokens = tokens; if (remainingTokens && remainingTokens.has_option_prefix()) { auto const & token = remainingTokens.option(); if (is_match(token.name, style)) { if (m_ref->isFlag()) { if (remainingTokens.has_value_delimiter()) { return parse_result::error( { parser_result_type::short_circuit_all, remainingTokens }, "Flag option '" + token.name + "' contains value '" + remainingTokens.value().name + "'."); } remainingTokens.pop(token); auto flagRef = static_cast<detail::BoundFlagRefBase *>(m_ref.get()); auto flag_result = flagRef->setFlag(true); if (!flag_result) return parse_result(flag_result); LYRA_PRINT_DEBUG( "(=)", get_usage_text(style), "==", token.name); if (flag_result.value() == parser_result_type::short_circuit_all) return parse_result::ok(detail::parse_state( flag_result.value(), remainingTokens)); } else { auto const & argToken = remainingTokens.value(); if (argToken.type == detail::token_type::unknown) return parse_result::error( { parser_result_type::no_match, remainingTokens }, "Expected argument following " + token.name); remainingTokens.pop(token, argToken); auto valueRef = static_cast<detail::BoundValueRefBase *>(m_ref.get()); if (value_choices) { auto choice_result = value_choices->contains_value(argToken.name); if (!choice_result) return parse_result(choice_result); } auto v_result = valueRef->setValue(argToken.name); if (!v_result) { return parse_result::error( { parser_result_type::short_circuit_all, remainingTokens }, v_result.message()); } LYRA_PRINT_DEBUG("(=)", get_usage_text(style), "==", token.name, argToken.name); if (v_result.value() == parser_result_type::short_circuit_all) return parse_result::ok(detail::parse_state( v_result.value(), remainingTokens)); } return parse_result::ok(detail::parse_state( parser_result_type::matched, remainingTokens)); } LYRA_PRINT_DEBUG("(!)", get_usage_text(style), "!= ", token.name); } else { LYRA_PRINT_DEBUG("(!)", get_usage_text(style), "!=", remainingTokens.argument().name); } return parse_result::ok( detail::parse_state(parser_result_type::no_match, remainingTokens)); } result validate() const override { if (opt_names.empty()) return result::error("No options supplied to opt"); if (m_ref->isFlag() && value_choices) return result::error("Flag options cannot contain choices."); for (auto const & name : opt_names) { if (name.empty()) return result::error("Option name cannot be empty"); if (name[0] != '-') return result::error("Option name must begin with '-'"); } return bound_parser::validate(); } virtual std::unique_ptr<parser> clone() const override { return make_clone<opt>(this); } protected: std::vector<std::string> opt_names; bool is_match( std::string const & opt_name, const option_style & style) const { auto opt_normalized = normalise_opt(opt_name, style); for (auto const & name : opt_names) { if (normalise_opt(name, style) == opt_normalized) return true; } return false; } std::string normalise_opt( std::string const & opt_name, const option_style & style) const { if (detail::token_iterator::is_prefixed( style.short_option_prefix, style.short_option_size, opt_name)) return std::string("-") + opt_name.substr(style.short_option_size); if (detail::token_iterator::is_prefixed( style.long_option_prefix, style.long_option_size, opt_name)) return std::string("--") + opt_name.substr(style.long_option_size); return opt_name; } std::string format_opt( std::string const & opt_name, const option_style & style) const { if (opt_name[0] == '-' && opt_name[1] == '-') return style.long_option_string() + opt_name.substr(2); else if (opt_name[0] == '-') return style.short_option_string() + opt_name.substr(1); else return opt_name; } }; /* tag::reference[] [#lyra_opt_ctor] == Construction end::reference[] */ /* tag::reference[] [#lyra_opt_ctor_flags] === Flags [source] ---- lyra::opt::opt(bool& ref); template <typename L> lyra::opt::opt(L const& ref); ---- Constructs a flag option with a target `bool` to indicate if the flag is present. The first form takes a reference to a variable to receive the `bool`. The second takes a callback that is called with `true` when the option is present. end::reference[] */ inline opt::opt(bool & ref) : bound_parser(std::make_shared<detail::BoundFlagRef>(ref)) {} template <typename L> opt::opt(L const & ref, typename std::enable_if<detail::is_invocable<L>::value, opt::ctor_lambda_e>::type) : bound_parser(std::make_shared<detail::BoundFlagLambda<L>>(ref)) {} /* tag::reference[] [#lyra_opt_ctor_values] === Values [source] ---- template <typename T> lyra::opt::opt(T& ref, std::string const& hint); template <typename L> lyra::opt::opt(L const& ref, std::string const& hint) ---- Constructs a value option with a target `ref`. The first form takes a reference to a variable to receive the value. The second takes a callback that is called with the value when the option is present. end::reference[] */ template <typename T> opt::opt(T & ref, std::string const & hint, typename std::enable_if<!detail::is_invocable<T>::value, opt::ctor_ref_e>::type) : bound_parser(ref, hint) {} template <typename L> opt::opt(L const & ref, std::string const & hint, typename std::enable_if<detail::is_invocable<L>::value, opt::ctor_lambda_e>::type) : bound_parser(ref, hint) {} /* tag::reference[] [#lyra_opt_specification] == Specification end::reference[] */ /* tag::reference[] [#lyra_opt_name] === `lyra::opt::name` [source] ---- lyra::opt& lyra::opt::name(const std::string &opt_name) lyra::opt& lyra::opt::operator[](const std::string &opt_name) ---- Add a spelling for the option of the form `--<name>` or `-n`. One can add multiple short spellings at once with `-abc`. end::reference[] */ inline opt & opt::name(const std::string & opt_name) { if (opt_name.size() > 2 && opt_name[0] == '-' && opt_name[1] != '-') for (auto o : opt_name.substr(1)) opt_names.push_back(std::string(1, opt_name[0]) + o); else opt_names.push_back(opt_name); return *this; } inline opt & opt::operator[](const std::string & opt_name) { return this->name(opt_name); } } // namespace lyra #endif namespace lyra { /* tag::reference[] [#lyra_help] = `lyra::help` Utility function that defines a default `--help` option. You can specify a `bool` flag to indicate if the help option was specified and that you could display a help message. The option accepts `-?`, `-h`, and `--help` as allowed option names. */ // end::reference[] class help : public opt { public: help(bool & showHelpFlag) : opt([&](bool flag) { showHelpFlag = flag; return parser_result::ok(parser_result_type::short_circuit_all); }) { this->description("Display usage information.") .optional() .name("-?") .name("-h") .name("--help"); } help & description(const std::string & text); virtual std::string get_description_text( const option_style &) const override { return description_text; } virtual std::unique_ptr<parser> clone() const override { return make_clone<help>(this); } private: std::string description_text; }; /* tag::reference[] [source] ---- help & help::description(const std::string &text) ---- Sets the given `text` as the general description to show with the help and usage output for CLI parser. This text is displayed between the "Usage" and "Options, arguments" sections. end::reference[] */ inline help & help::description(const std::string & text) { description_text = text; return *this; } } // namespace lyra #endif #ifndef LYRA_MAIN_HPP #define LYRA_MAIN_HPP #include <iostream> namespace lyra { /* tag::reference[] [#lyra_main] = `lyra::main` Encapsulates the common use case of a main program that has a help option and has a minimal way to specify and parse options. This provides for a way to specify options and arguments in a simple function form. It handles checking for errors and reporting problems. */ // end::reference[] class main final : protected cli { bool show_help = false; public: explicit main(const std::string & text = ""); template <typename T> main & operator()(const T & parser); template <typename T> main & add_argument(const T & parser); template <typename T> main & operator|=(const T & parser); template <typename V> main & operator()( std::initializer_list<std::string> arg_names, V && default_value); template <typename V> main & operator()(const std::string & arg_name, V && default_value); template <typename L> int operator()(const args & argv, L action); template <typename L> int operator()(int argc, const char ** argv, L action); using cli::operator[]; main & style(const option_style & style) { cli::style(style); return *this; } main & style(option_style && style) { cli::style(style); return *this; } }; /* tag::reference[] [#lyra_main_ctor] == Construction [source] ---- main::main(const std::string & text); ---- Construct with text for description, which defaults to an empty string. The description is specified for the help option that is added to the command line. end::reference[] */ inline main::main(const std::string & text) { this->add_argument(help(show_help).description(text)); } /* tag::reference[] [#lyra_main_add_argument] == Add Argument [source] ---- template <typename T> main & main::operator()(const T & arg_parser) template <typename T> main & main::add_argument(const T & arg_parser) template <typename T> main & main::operator|=(const T & arg_parser) ---- Adds a parser as an argument to the command line. These forward directly to the `lyra::cli` equivalents. The added parser can be any of the regular Lyra parsers like `lyra::opt` or `lyra::arg`. end::reference[] */ template <typename T> main & main::operator()(const T & arg_parser) { cli::add_argument(arg_parser); return *this; } template <typename T> main & main::add_argument(const T & arg_parser) { cli::add_argument(arg_parser); return *this; } template <typename T> main & main::operator|=(const T & arg_parser) { cli::operator|=(arg_parser); return *this; } /* tag::reference[] [#lyra_main_simple_args] == Simple Args [source] ---- template <typename V> main & main::operator()( std::initializer_list<std::string> arg_names, V && default_value) template <typename V> main & main::operator()(const std::string & arg_name, V && default_value) ---- Specifies, and adds, a new argument. Depending on the `arg_names` it can be either a `lyra::opt` or `lyra::arg`. The first item in `arg_names` indicates the type of argument created and added: Specify either `-<name>` or `--<name>` to add a `lyra::opt`. You can specify as many option names following the first name. A name that doesn't follow the option syntax is considered the as the help text for the option. Specify a non `-` prefixed name as the first item to signify a positional `lyra::arg`. The single `std::string` call is equivalent to specifying just the one option or argument. Example specifications: |=== | `("-o", 0)` | Short `-o` option as `int` value. | `("--opt", 0)` | Long `--opt` option as `int` value. | `({"-o", "--opt"}, 1.0f)` | Short and long option as `float` value. | `({"-o", "The option."}, 1.0f)` | Short option and help description as `float` value. | `("opt", 2)` | Positional, i.e. `lyra::arg`, argument as `int` value. | `({"opt", "The option."}, 2)` | Positional argument and help description as `int` value. | `("--opt", std::vector<float>())` | Long option with as multiple float values. |=== end::reference[] */ template <typename V> main & main::operator()( std::initializer_list<std::string> arg_names, V && default_value) { auto bound_val = val(std::forward<V>(default_value)); if ((*arg_names.begin())[0] == '-') { std::string hint = arg_names.begin()->substr(1); if (hint[0] == '-') hint = hint.substr(1); opt o(std::move(bound_val), hint); for (auto arg_name : arg_names) { if (arg_name[0] == '-') o.name(arg_name); else o.help(arg_name); } cli::add_argument(o); } else { arg a(std::move(bound_val), *arg_names.begin()); a.optional(); if (arg_names.size() > 2) a.help(*(arg_names.begin() + 1)); cli::add_argument(a); } return *this; } template <typename V> main & main::operator()(const std::string & arg_name, V && default_value) { return (*this)({ arg_name }, std::forward<V>(default_value)); } /* tag::reference[] [#lyra_main_execute] == Execute [source] ---- template <typename L> int main::operator()(const args & argv, L action) template <typename L> int main::operator()(int argc, const char ** argv, L action) ---- Executes the given action after parsing of the program input arguments. It returns either `0` or `1` if the execution was successful or failed respectively. The `action` is called with the `lyra::main` instance to provide access to the parsed argument values. end::reference[] */ template <typename L> int main::operator()(const args & argv, L action) { auto cli_result = cli::parse(argv); if (!cli_result) std::cerr << cli_result.message() << "\n\n"; if (show_help || !cli_result) std::cout << *this << "\n"; else return action(*this); return cli_result ? 0 : 1; } template <typename L> int main::operator()(int argc, const char ** argv, L action) { return (*this)({ argc, argv }, action); } } // namespace lyra #endif #endif // LYRA_HPP_INCLUDED �����������������������������������������������������������������������������inspircd-4.7.0/vendor/md5/��������������������������������������������������������������������������0000775�0000000�0000000�00000000000�14771603147�0015331�5����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/vendor/md5/LICENSE�������������������������������������������������������������������0000664�0000000�0000000�00000000501�14771603147�0016332�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������Copyright (c) 1998-2017 Solar Designer <solar at openwall.com> Copyright (c) 2008 Grigoriy Strokin <grg at openwall.com> Copyright (c) 2011-2017 ABC <abc at openwall.com> Redistribution and use in source and binary forms, with or without modification, are permitted. There's ABSOLUTELY NO WARRANTY, express or implied. �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/vendor/md5/md5.c���������������������������������������������������������������������0000664�0000000�0000000�00000021047�14771603147�0016166�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This is an OpenSSL-compatible implementation of the RSA Data Security, Inc. * MD5 Message-Digest Algorithm (RFC 1321). * * Homepage: * http://openwall.info/wiki/people/solar/software/public-domain-source-code/md5 * * Author: * Alexander Peslyak, better known as Solar Designer <solar at openwall.com> * * This software was written by Alexander Peslyak in 2001. No copyright is * claimed, and the software is hereby placed in the public domain. * In case this attempt to disclaim copyright and place the software in the * public domain is deemed null and void, then the software is * Copyright (c) 2001 Alexander Peslyak and it is hereby released to the * general public under the following terms: * * Redistribution and use in source and binary forms, with or without * modification, are permitted. * * There's ABSOLUTELY NO WARRANTY, express or implied. * * (This is a heavily cut-down "BSD license".) * * This differs from Colin Plumb's older public domain implementation in that * no exactly 32-bit integer data type is required (any 32-bit or wider * unsigned integer data type will do), there's no compile-time endianness * configuration, and the function prototypes match OpenSSL's. No code from * Colin Plumb's implementation has been reused; this comment merely compares * the properties of the two independent implementations. * * The primary goals of this implementation are portability and ease of use. * It is meant to be fast, but not as fast as possible. Some known * optimizations are not included to reduce source code size and avoid * compile-time configuration. */ #ifndef HAVE_OPENSSL #include <string.h> #include "md5.h" /* * The basic MD5 functions. * * F and G are optimized compared to their RFC 1321 definitions for * architectures that lack an AND-NOT instruction, just like in Colin Plumb's * implementation. */ #define F(x, y, z) ((z) ^ ((x) & ((y) ^ (z)))) #define G(x, y, z) ((y) ^ ((z) & ((x) ^ (y)))) #define H(x, y, z) (((x) ^ (y)) ^ (z)) #define H2(x, y, z) ((x) ^ ((y) ^ (z))) #define I(x, y, z) ((y) ^ ((x) | ~(z))) /* * The MD5 transformation for all four rounds. */ #define STEP(f, a, b, c, d, x, t, s) \ (a) += f((b), (c), (d)) + (x) + (t); \ (a) = (((a) << (s)) | (((a) & 0xffffffff) >> (32 - (s)))); \ (a) += (b); /* * SET reads 4 input bytes in little-endian byte order and stores them in a * properly aligned word in host byte order. * * The check for little-endian architectures that tolerate unaligned memory * accesses is just an optimization. Nothing will break if it fails to detect * a suitable architecture. * * Unfortunately, this optimization may be a C strict aliasing rules violation * if the caller's data buffer has effective type that cannot be aliased by * MD5_u32plus. In practice, this problem may occur if these MD5 routines are * inlined into a calling function, or with future and dangerously advanced * link-time optimizations. For the time being, keeping these MD5 routines in * their own translation unit avoids the problem. */ #if defined(__i386__) || defined(__x86_64__) || defined(__vax__) #define SET(n) \ (*(MD5_u32plus *)&ptr[(n) * 4]) #define GET(n) \ SET(n) #else #define SET(n) \ (ctx->block[(n)] = \ (MD5_u32plus)ptr[(n) * 4] | \ ((MD5_u32plus)ptr[(n) * 4 + 1] << 8) | \ ((MD5_u32plus)ptr[(n) * 4 + 2] << 16) | \ ((MD5_u32plus)ptr[(n) * 4 + 3] << 24)) #define GET(n) \ (ctx->block[(n)]) #endif /* * This processes one or more 64-byte data blocks, but does NOT update the bit * counters. There are no alignment requirements. */ static const void *body(MD5_CTX *ctx, const void *data, unsigned long size) { const unsigned char *ptr; MD5_u32plus a, b, c, d; MD5_u32plus saved_a, saved_b, saved_c, saved_d; ptr = (const unsigned char *)data; a = ctx->a; b = ctx->b; c = ctx->c; d = ctx->d; do { saved_a = a; saved_b = b; saved_c = c; saved_d = d; /* Round 1 */ STEP(F, a, b, c, d, SET(0), 0xd76aa478, 7) STEP(F, d, a, b, c, SET(1), 0xe8c7b756, 12) STEP(F, c, d, a, b, SET(2), 0x242070db, 17) STEP(F, b, c, d, a, SET(3), 0xc1bdceee, 22) STEP(F, a, b, c, d, SET(4), 0xf57c0faf, 7) STEP(F, d, a, b, c, SET(5), 0x4787c62a, 12) STEP(F, c, d, a, b, SET(6), 0xa8304613, 17) STEP(F, b, c, d, a, SET(7), 0xfd469501, 22) STEP(F, a, b, c, d, SET(8), 0x698098d8, 7) STEP(F, d, a, b, c, SET(9), 0x8b44f7af, 12) STEP(F, c, d, a, b, SET(10), 0xffff5bb1, 17) STEP(F, b, c, d, a, SET(11), 0x895cd7be, 22) STEP(F, a, b, c, d, SET(12), 0x6b901122, 7) STEP(F, d, a, b, c, SET(13), 0xfd987193, 12) STEP(F, c, d, a, b, SET(14), 0xa679438e, 17) STEP(F, b, c, d, a, SET(15), 0x49b40821, 22) /* Round 2 */ STEP(G, a, b, c, d, GET(1), 0xf61e2562, 5) STEP(G, d, a, b, c, GET(6), 0xc040b340, 9) STEP(G, c, d, a, b, GET(11), 0x265e5a51, 14) STEP(G, b, c, d, a, GET(0), 0xe9b6c7aa, 20) STEP(G, a, b, c, d, GET(5), 0xd62f105d, 5) STEP(G, d, a, b, c, GET(10), 0x02441453, 9) STEP(G, c, d, a, b, GET(15), 0xd8a1e681, 14) STEP(G, b, c, d, a, GET(4), 0xe7d3fbc8, 20) STEP(G, a, b, c, d, GET(9), 0x21e1cde6, 5) STEP(G, d, a, b, c, GET(14), 0xc33707d6, 9) STEP(G, c, d, a, b, GET(3), 0xf4d50d87, 14) STEP(G, b, c, d, a, GET(8), 0x455a14ed, 20) STEP(G, a, b, c, d, GET(13), 0xa9e3e905, 5) STEP(G, d, a, b, c, GET(2), 0xfcefa3f8, 9) STEP(G, c, d, a, b, GET(7), 0x676f02d9, 14) STEP(G, b, c, d, a, GET(12), 0x8d2a4c8a, 20) /* Round 3 */ STEP(H, a, b, c, d, GET(5), 0xfffa3942, 4) STEP(H2, d, a, b, c, GET(8), 0x8771f681, 11) STEP(H, c, d, a, b, GET(11), 0x6d9d6122, 16) STEP(H2, b, c, d, a, GET(14), 0xfde5380c, 23) STEP(H, a, b, c, d, GET(1), 0xa4beea44, 4) STEP(H2, d, a, b, c, GET(4), 0x4bdecfa9, 11) STEP(H, c, d, a, b, GET(7), 0xf6bb4b60, 16) STEP(H2, b, c, d, a, GET(10), 0xbebfbc70, 23) STEP(H, a, b, c, d, GET(13), 0x289b7ec6, 4) STEP(H2, d, a, b, c, GET(0), 0xeaa127fa, 11) STEP(H, c, d, a, b, GET(3), 0xd4ef3085, 16) STEP(H2, b, c, d, a, GET(6), 0x04881d05, 23) STEP(H, a, b, c, d, GET(9), 0xd9d4d039, 4) STEP(H2, d, a, b, c, GET(12), 0xe6db99e5, 11) STEP(H, c, d, a, b, GET(15), 0x1fa27cf8, 16) STEP(H2, b, c, d, a, GET(2), 0xc4ac5665, 23) /* Round 4 */ STEP(I, a, b, c, d, GET(0), 0xf4292244, 6) STEP(I, d, a, b, c, GET(7), 0x432aff97, 10) STEP(I, c, d, a, b, GET(14), 0xab9423a7, 15) STEP(I, b, c, d, a, GET(5), 0xfc93a039, 21) STEP(I, a, b, c, d, GET(12), 0x655b59c3, 6) STEP(I, d, a, b, c, GET(3), 0x8f0ccc92, 10) STEP(I, c, d, a, b, GET(10), 0xffeff47d, 15) STEP(I, b, c, d, a, GET(1), 0x85845dd1, 21) STEP(I, a, b, c, d, GET(8), 0x6fa87e4f, 6) STEP(I, d, a, b, c, GET(15), 0xfe2ce6e0, 10) STEP(I, c, d, a, b, GET(6), 0xa3014314, 15) STEP(I, b, c, d, a, GET(13), 0x4e0811a1, 21) STEP(I, a, b, c, d, GET(4), 0xf7537e82, 6) STEP(I, d, a, b, c, GET(11), 0xbd3af235, 10) STEP(I, c, d, a, b, GET(2), 0x2ad7d2bb, 15) STEP(I, b, c, d, a, GET(9), 0xeb86d391, 21) a += saved_a; b += saved_b; c += saved_c; d += saved_d; ptr += 64; } while (size -= 64); ctx->a = a; ctx->b = b; ctx->c = c; ctx->d = d; return ptr; } void MD5_Init(MD5_CTX *ctx) { ctx->a = 0x67452301; ctx->b = 0xefcdab89; ctx->c = 0x98badcfe; ctx->d = 0x10325476; ctx->lo = 0; ctx->hi = 0; } void MD5_Update(MD5_CTX *ctx, const void *data, unsigned long size) { MD5_u32plus saved_lo; unsigned long used, available; saved_lo = ctx->lo; if ((ctx->lo = (saved_lo + size) & 0x1fffffff) < saved_lo) ctx->hi++; ctx->hi += size >> 29; used = saved_lo & 0x3f; if (used) { available = 64 - used; if (size < available) { memcpy(&ctx->buffer[used], data, size); return; } memcpy(&ctx->buffer[used], data, available); data = (const unsigned char *)data + available; size -= available; body(ctx, ctx->buffer, 64); } if (size >= 64) { data = body(ctx, data, size & ~(unsigned long)0x3f); size &= 0x3f; } memcpy(ctx->buffer, data, size); } #define OUT(dst, src) \ (dst)[0] = (unsigned char)(src); \ (dst)[1] = (unsigned char)((src) >> 8); \ (dst)[2] = (unsigned char)((src) >> 16); \ (dst)[3] = (unsigned char)((src) >> 24); void MD5_Final(unsigned char *result, MD5_CTX *ctx) { unsigned long used, available; used = ctx->lo & 0x3f; ctx->buffer[used++] = 0x80; available = 64 - used; if (available < 8) { memset(&ctx->buffer[used], 0, available); body(ctx, ctx->buffer, 64); used = 0; available = 64; } memset(&ctx->buffer[used], 0, available - 8); ctx->lo <<= 3; OUT(&ctx->buffer[56], ctx->lo) OUT(&ctx->buffer[60], ctx->hi) body(ctx, ctx->buffer, 64); OUT(&result[0], ctx->a) OUT(&result[4], ctx->b) OUT(&result[8], ctx->c) OUT(&result[12], ctx->d) memset(ctx, 0, sizeof(*ctx)); } #endif �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/vendor/md5/md5.h���������������������������������������������������������������������0000664�0000000�0000000�00000002602�14771603147�0016167�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This is an OpenSSL-compatible implementation of the RSA Data Security, Inc. * MD5 Message-Digest Algorithm (RFC 1321). * * Homepage: * http://openwall.info/wiki/people/solar/software/public-domain-source-code/md5 * * Author: * Alexander Peslyak, better known as Solar Designer <solar at openwall.com> * * This software was written by Alexander Peslyak in 2001. No copyright is * claimed, and the software is hereby placed in the public domain. * In case this attempt to disclaim copyright and place the software in the * public domain is deemed null and void, then the software is * Copyright (c) 2001 Alexander Peslyak and it is hereby released to the * general public under the following terms: * * Redistribution and use in source and binary forms, with or without * modification, are permitted. * * There's ABSOLUTELY NO WARRANTY, express or implied. * * See md5.c for more information. */ #ifdef HAVE_OPENSSL #include <openssl/md5.h> #elif !defined(_MD5_H) #define _MD5_H /* Any 32-bit or wider unsigned integer data type will do */ typedef unsigned int MD5_u32plus; typedef struct { MD5_u32plus lo, hi; MD5_u32plus a, b, c, d; unsigned char buffer[64]; MD5_u32plus block[16]; } MD5_CTX; extern void MD5_Init(MD5_CTX *ctx); extern void MD5_Update(MD5_CTX *ctx, const void *data, unsigned long size); extern void MD5_Final(unsigned char *result, MD5_CTX *ctx); #endif ������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/vendor/sha2/�������������������������������������������������������������������������0000775�0000000�0000000�00000000000�14771603147�0015501�5����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/vendor/sha2/sha2.c�������������������������������������������������������������������0000664�0000000�0000000�00000100267�14771603147�0016510�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * FIPS 180-2 SHA-224/256/384/512 implementation * Last update: 02/02/2007 * Issue date: 04/30/2005 * * Copyright (C) 2005, 2007 Olivier Gay <olivier.gay@a3.epfl.ch> * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. 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. * 3. Neither the name of the project nor the names of its contributors * may be used to endorse or promote products derived from this software * without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE PROJECT 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 PROJECT 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. */ #if 0 #define UNROLL_LOOPS /* Enable loops unrolling */ #endif #include <string.h> #include "sha2.h" #define SHFR(x, n) (x >> n) #define ROTR(x, n) ((x >> n) | (x << ((sizeof(x) << 3) - n))) #define ROTL(x, n) ((x << n) | (x >> ((sizeof(x) << 3) - n))) #define CH(x, y, z) ((x & y) ^ (~x & z)) #define MAJ(x, y, z) ((x & y) ^ (x & z) ^ (y & z)) #define SHA256_F1(x) (ROTR(x, 2) ^ ROTR(x, 13) ^ ROTR(x, 22)) #define SHA256_F2(x) (ROTR(x, 6) ^ ROTR(x, 11) ^ ROTR(x, 25)) #define SHA256_F3(x) (ROTR(x, 7) ^ ROTR(x, 18) ^ SHFR(x, 3)) #define SHA256_F4(x) (ROTR(x, 17) ^ ROTR(x, 19) ^ SHFR(x, 10)) #define SHA512_F1(x) (ROTR(x, 28) ^ ROTR(x, 34) ^ ROTR(x, 39)) #define SHA512_F2(x) (ROTR(x, 14) ^ ROTR(x, 18) ^ ROTR(x, 41)) #define SHA512_F3(x) (ROTR(x, 1) ^ ROTR(x, 8) ^ SHFR(x, 7)) #define SHA512_F4(x) (ROTR(x, 19) ^ ROTR(x, 61) ^ SHFR(x, 6)) #define UNPACK32(x, str) \ { \ *((str) + 3) = (uint8) ((x) ); \ *((str) + 2) = (uint8) ((x) >> 8); \ *((str) + 1) = (uint8) ((x) >> 16); \ *((str) + 0) = (uint8) ((x) >> 24); \ } #define PACK32(str, x) \ { \ *(x) = ((uint32) *((str) + 3) ) \ | ((uint32) *((str) + 2) << 8) \ | ((uint32) *((str) + 1) << 16) \ | ((uint32) *((str) + 0) << 24); \ } #define UNPACK64(x, str) \ { \ *((str) + 7) = (uint8) ((x) ); \ *((str) + 6) = (uint8) ((x) >> 8); \ *((str) + 5) = (uint8) ((x) >> 16); \ *((str) + 4) = (uint8) ((x) >> 24); \ *((str) + 3) = (uint8) ((x) >> 32); \ *((str) + 2) = (uint8) ((x) >> 40); \ *((str) + 1) = (uint8) ((x) >> 48); \ *((str) + 0) = (uint8) ((x) >> 56); \ } #define PACK64(str, x) \ { \ *(x) = ((uint64) *((str) + 7) ) \ | ((uint64) *((str) + 6) << 8) \ | ((uint64) *((str) + 5) << 16) \ | ((uint64) *((str) + 4) << 24) \ | ((uint64) *((str) + 3) << 32) \ | ((uint64) *((str) + 2) << 40) \ | ((uint64) *((str) + 1) << 48) \ | ((uint64) *((str) + 0) << 56); \ } /* Macros used for loops unrolling */ #define SHA256_SCR(i) \ { \ w[i] = SHA256_F4(w[i - 2]) + w[i - 7] \ + SHA256_F3(w[i - 15]) + w[i - 16]; \ } #define SHA512_SCR(i) \ { \ w[i] = SHA512_F4(w[i - 2]) + w[i - 7] \ + SHA512_F3(w[i - 15]) + w[i - 16]; \ } #define SHA256_EXP(a, b, c, d, e, f, g, h, j) \ { \ t1 = wv[h] + SHA256_F2(wv[e]) + CH(wv[e], wv[f], wv[g]) \ + sha256_k[j] + w[j]; \ t2 = SHA256_F1(wv[a]) + MAJ(wv[a], wv[b], wv[c]); \ wv[d] += t1; \ wv[h] = t1 + t2; \ } #define SHA512_EXP(a, b, c, d, e, f, g ,h, j) \ { \ t1 = wv[h] + SHA512_F2(wv[e]) + CH(wv[e], wv[f], wv[g]) \ + sha512_k[j] + w[j]; \ t2 = SHA512_F1(wv[a]) + MAJ(wv[a], wv[b], wv[c]); \ wv[d] += t1; \ wv[h] = t1 + t2; \ } uint32 sha224_h0[8] = {0xc1059ed8, 0x367cd507, 0x3070dd17, 0xf70e5939, 0xffc00b31, 0x68581511, 0x64f98fa7, 0xbefa4fa4}; uint32 sha256_h0[8] = {0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a, 0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19}; uint64 sha384_h0[8] = {0xcbbb9d5dc1059ed8ULL, 0x629a292a367cd507ULL, 0x9159015a3070dd17ULL, 0x152fecd8f70e5939ULL, 0x67332667ffc00b31ULL, 0x8eb44a8768581511ULL, 0xdb0c2e0d64f98fa7ULL, 0x47b5481dbefa4fa4ULL}; uint64 sha512_h0[8] = {0x6a09e667f3bcc908ULL, 0xbb67ae8584caa73bULL, 0x3c6ef372fe94f82bULL, 0xa54ff53a5f1d36f1ULL, 0x510e527fade682d1ULL, 0x9b05688c2b3e6c1fULL, 0x1f83d9abfb41bd6bULL, 0x5be0cd19137e2179ULL}; uint32 sha256_k[64] = {0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5, 0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3, 0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174, 0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc, 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da, 0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7, 0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967, 0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13, 0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85, 0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3, 0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070, 0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3, 0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208, 0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2}; uint64 sha512_k[80] = {0x428a2f98d728ae22ULL, 0x7137449123ef65cdULL, 0xb5c0fbcfec4d3b2fULL, 0xe9b5dba58189dbbcULL, 0x3956c25bf348b538ULL, 0x59f111f1b605d019ULL, 0x923f82a4af194f9bULL, 0xab1c5ed5da6d8118ULL, 0xd807aa98a3030242ULL, 0x12835b0145706fbeULL, 0x243185be4ee4b28cULL, 0x550c7dc3d5ffb4e2ULL, 0x72be5d74f27b896fULL, 0x80deb1fe3b1696b1ULL, 0x9bdc06a725c71235ULL, 0xc19bf174cf692694ULL, 0xe49b69c19ef14ad2ULL, 0xefbe4786384f25e3ULL, 0x0fc19dc68b8cd5b5ULL, 0x240ca1cc77ac9c65ULL, 0x2de92c6f592b0275ULL, 0x4a7484aa6ea6e483ULL, 0x5cb0a9dcbd41fbd4ULL, 0x76f988da831153b5ULL, 0x983e5152ee66dfabULL, 0xa831c66d2db43210ULL, 0xb00327c898fb213fULL, 0xbf597fc7beef0ee4ULL, 0xc6e00bf33da88fc2ULL, 0xd5a79147930aa725ULL, 0x06ca6351e003826fULL, 0x142929670a0e6e70ULL, 0x27b70a8546d22ffcULL, 0x2e1b21385c26c926ULL, 0x4d2c6dfc5ac42aedULL, 0x53380d139d95b3dfULL, 0x650a73548baf63deULL, 0x766a0abb3c77b2a8ULL, 0x81c2c92e47edaee6ULL, 0x92722c851482353bULL, 0xa2bfe8a14cf10364ULL, 0xa81a664bbc423001ULL, 0xc24b8b70d0f89791ULL, 0xc76c51a30654be30ULL, 0xd192e819d6ef5218ULL, 0xd69906245565a910ULL, 0xf40e35855771202aULL, 0x106aa07032bbd1b8ULL, 0x19a4c116b8d2d0c8ULL, 0x1e376c085141ab53ULL, 0x2748774cdf8eeb99ULL, 0x34b0bcb5e19b48a8ULL, 0x391c0cb3c5c95a63ULL, 0x4ed8aa4ae3418acbULL, 0x5b9cca4f7763e373ULL, 0x682e6ff3d6b2b8a3ULL, 0x748f82ee5defb2fcULL, 0x78a5636f43172f60ULL, 0x84c87814a1f0ab72ULL, 0x8cc702081a6439ecULL, 0x90befffa23631e28ULL, 0xa4506cebde82bde9ULL, 0xbef9a3f7b2c67915ULL, 0xc67178f2e372532bULL, 0xca273eceea26619cULL, 0xd186b8c721c0c207ULL, 0xeada7dd6cde0eb1eULL, 0xf57d4f7fee6ed178ULL, 0x06f067aa72176fbaULL, 0x0a637dc5a2c898a6ULL, 0x113f9804bef90daeULL, 0x1b710b35131c471bULL, 0x28db77f523047d84ULL, 0x32caab7b40c72493ULL, 0x3c9ebe0a15c9bebcULL, 0x431d67c49c100d4cULL, 0x4cc5d4becb3e42b6ULL, 0x597f299cfc657e2aULL, 0x5fcb6fab3ad6faecULL, 0x6c44198c4a475817ULL}; /* SHA-256 functions */ void sha256_transf(sha256_ctx *ctx, const unsigned char *message, unsigned int block_nb) { uint32 w[64]; uint32 wv[8]; uint32 t1, t2; const unsigned char *sub_block; int i; #ifndef UNROLL_LOOPS int j; #endif for (i = 0; i < (int) block_nb; i++) { sub_block = message + (i << 6); #ifndef UNROLL_LOOPS for (j = 0; j < 16; j++) { PACK32(&sub_block[j << 2], &w[j]); } for (j = 16; j < 64; j++) { SHA256_SCR(j); } for (j = 0; j < 8; j++) { wv[j] = ctx->h[j]; } for (j = 0; j < 64; j++) { t1 = wv[7] + SHA256_F2(wv[4]) + CH(wv[4], wv[5], wv[6]) + sha256_k[j] + w[j]; t2 = SHA256_F1(wv[0]) + MAJ(wv[0], wv[1], wv[2]); wv[7] = wv[6]; wv[6] = wv[5]; wv[5] = wv[4]; wv[4] = wv[3] + t1; wv[3] = wv[2]; wv[2] = wv[1]; wv[1] = wv[0]; wv[0] = t1 + t2; } for (j = 0; j < 8; j++) { ctx->h[j] += wv[j]; } #else PACK32(&sub_block[ 0], &w[ 0]); PACK32(&sub_block[ 4], &w[ 1]); PACK32(&sub_block[ 8], &w[ 2]); PACK32(&sub_block[12], &w[ 3]); PACK32(&sub_block[16], &w[ 4]); PACK32(&sub_block[20], &w[ 5]); PACK32(&sub_block[24], &w[ 6]); PACK32(&sub_block[28], &w[ 7]); PACK32(&sub_block[32], &w[ 8]); PACK32(&sub_block[36], &w[ 9]); PACK32(&sub_block[40], &w[10]); PACK32(&sub_block[44], &w[11]); PACK32(&sub_block[48], &w[12]); PACK32(&sub_block[52], &w[13]); PACK32(&sub_block[56], &w[14]); PACK32(&sub_block[60], &w[15]); SHA256_SCR(16); SHA256_SCR(17); SHA256_SCR(18); SHA256_SCR(19); SHA256_SCR(20); SHA256_SCR(21); SHA256_SCR(22); SHA256_SCR(23); SHA256_SCR(24); SHA256_SCR(25); SHA256_SCR(26); SHA256_SCR(27); SHA256_SCR(28); SHA256_SCR(29); SHA256_SCR(30); SHA256_SCR(31); SHA256_SCR(32); SHA256_SCR(33); SHA256_SCR(34); SHA256_SCR(35); SHA256_SCR(36); SHA256_SCR(37); SHA256_SCR(38); SHA256_SCR(39); SHA256_SCR(40); SHA256_SCR(41); SHA256_SCR(42); SHA256_SCR(43); SHA256_SCR(44); SHA256_SCR(45); SHA256_SCR(46); SHA256_SCR(47); SHA256_SCR(48); SHA256_SCR(49); SHA256_SCR(50); SHA256_SCR(51); SHA256_SCR(52); SHA256_SCR(53); SHA256_SCR(54); SHA256_SCR(55); SHA256_SCR(56); SHA256_SCR(57); SHA256_SCR(58); SHA256_SCR(59); SHA256_SCR(60); SHA256_SCR(61); SHA256_SCR(62); SHA256_SCR(63); wv[0] = ctx->h[0]; wv[1] = ctx->h[1]; wv[2] = ctx->h[2]; wv[3] = ctx->h[3]; wv[4] = ctx->h[4]; wv[5] = ctx->h[5]; wv[6] = ctx->h[6]; wv[7] = ctx->h[7]; SHA256_EXP(0,1,2,3,4,5,6,7, 0); SHA256_EXP(7,0,1,2,3,4,5,6, 1); SHA256_EXP(6,7,0,1,2,3,4,5, 2); SHA256_EXP(5,6,7,0,1,2,3,4, 3); SHA256_EXP(4,5,6,7,0,1,2,3, 4); SHA256_EXP(3,4,5,6,7,0,1,2, 5); SHA256_EXP(2,3,4,5,6,7,0,1, 6); SHA256_EXP(1,2,3,4,5,6,7,0, 7); SHA256_EXP(0,1,2,3,4,5,6,7, 8); SHA256_EXP(7,0,1,2,3,4,5,6, 9); SHA256_EXP(6,7,0,1,2,3,4,5,10); SHA256_EXP(5,6,7,0,1,2,3,4,11); SHA256_EXP(4,5,6,7,0,1,2,3,12); SHA256_EXP(3,4,5,6,7,0,1,2,13); SHA256_EXP(2,3,4,5,6,7,0,1,14); SHA256_EXP(1,2,3,4,5,6,7,0,15); SHA256_EXP(0,1,2,3,4,5,6,7,16); SHA256_EXP(7,0,1,2,3,4,5,6,17); SHA256_EXP(6,7,0,1,2,3,4,5,18); SHA256_EXP(5,6,7,0,1,2,3,4,19); SHA256_EXP(4,5,6,7,0,1,2,3,20); SHA256_EXP(3,4,5,6,7,0,1,2,21); SHA256_EXP(2,3,4,5,6,7,0,1,22); SHA256_EXP(1,2,3,4,5,6,7,0,23); SHA256_EXP(0,1,2,3,4,5,6,7,24); SHA256_EXP(7,0,1,2,3,4,5,6,25); SHA256_EXP(6,7,0,1,2,3,4,5,26); SHA256_EXP(5,6,7,0,1,2,3,4,27); SHA256_EXP(4,5,6,7,0,1,2,3,28); SHA256_EXP(3,4,5,6,7,0,1,2,29); SHA256_EXP(2,3,4,5,6,7,0,1,30); SHA256_EXP(1,2,3,4,5,6,7,0,31); SHA256_EXP(0,1,2,3,4,5,6,7,32); SHA256_EXP(7,0,1,2,3,4,5,6,33); SHA256_EXP(6,7,0,1,2,3,4,5,34); SHA256_EXP(5,6,7,0,1,2,3,4,35); SHA256_EXP(4,5,6,7,0,1,2,3,36); SHA256_EXP(3,4,5,6,7,0,1,2,37); SHA256_EXP(2,3,4,5,6,7,0,1,38); SHA256_EXP(1,2,3,4,5,6,7,0,39); SHA256_EXP(0,1,2,3,4,5,6,7,40); SHA256_EXP(7,0,1,2,3,4,5,6,41); SHA256_EXP(6,7,0,1,2,3,4,5,42); SHA256_EXP(5,6,7,0,1,2,3,4,43); SHA256_EXP(4,5,6,7,0,1,2,3,44); SHA256_EXP(3,4,5,6,7,0,1,2,45); SHA256_EXP(2,3,4,5,6,7,0,1,46); SHA256_EXP(1,2,3,4,5,6,7,0,47); SHA256_EXP(0,1,2,3,4,5,6,7,48); SHA256_EXP(7,0,1,2,3,4,5,6,49); SHA256_EXP(6,7,0,1,2,3,4,5,50); SHA256_EXP(5,6,7,0,1,2,3,4,51); SHA256_EXP(4,5,6,7,0,1,2,3,52); SHA256_EXP(3,4,5,6,7,0,1,2,53); SHA256_EXP(2,3,4,5,6,7,0,1,54); SHA256_EXP(1,2,3,4,5,6,7,0,55); SHA256_EXP(0,1,2,3,4,5,6,7,56); SHA256_EXP(7,0,1,2,3,4,5,6,57); SHA256_EXP(6,7,0,1,2,3,4,5,58); SHA256_EXP(5,6,7,0,1,2,3,4,59); SHA256_EXP(4,5,6,7,0,1,2,3,60); SHA256_EXP(3,4,5,6,7,0,1,2,61); SHA256_EXP(2,3,4,5,6,7,0,1,62); SHA256_EXP(1,2,3,4,5,6,7,0,63); ctx->h[0] += wv[0]; ctx->h[1] += wv[1]; ctx->h[2] += wv[2]; ctx->h[3] += wv[3]; ctx->h[4] += wv[4]; ctx->h[5] += wv[5]; ctx->h[6] += wv[6]; ctx->h[7] += wv[7]; #endif /* !UNROLL_LOOPS */ } } void sha256(const unsigned char *message, unsigned int len, unsigned char *digest) { sha256_ctx ctx; sha256_init(&ctx); sha256_update(&ctx, message, len); sha256_final(&ctx, digest); } void sha256_init(sha256_ctx *ctx) { #ifndef UNROLL_LOOPS int i; for (i = 0; i < 8; i++) { ctx->h[i] = sha256_h0[i]; } #else ctx->h[0] = sha256_h0[0]; ctx->h[1] = sha256_h0[1]; ctx->h[2] = sha256_h0[2]; ctx->h[3] = sha256_h0[3]; ctx->h[4] = sha256_h0[4]; ctx->h[5] = sha256_h0[5]; ctx->h[6] = sha256_h0[6]; ctx->h[7] = sha256_h0[7]; #endif /* !UNROLL_LOOPS */ ctx->len = 0; ctx->tot_len = 0; } void sha256_update(sha256_ctx *ctx, const unsigned char *message, unsigned int len) { unsigned int block_nb; unsigned int new_len, rem_len, tmp_len; const unsigned char *shifted_message; tmp_len = SHA256_BLOCK_SIZE - ctx->len; rem_len = len < tmp_len ? len : tmp_len; memcpy(&ctx->block[ctx->len], message, rem_len); if (ctx->len + len < SHA256_BLOCK_SIZE) { ctx->len += len; return; } new_len = len - rem_len; block_nb = new_len / SHA256_BLOCK_SIZE; shifted_message = message + rem_len; sha256_transf(ctx, ctx->block, 1); sha256_transf(ctx, shifted_message, block_nb); rem_len = new_len % SHA256_BLOCK_SIZE; memcpy(ctx->block, &shifted_message[block_nb << 6], rem_len); ctx->len = rem_len; ctx->tot_len += (block_nb + 1) << 6; } void sha256_final(sha256_ctx *ctx, unsigned char *digest) { unsigned int block_nb; unsigned int pm_len; unsigned int len_b; #ifndef UNROLL_LOOPS int i; #endif block_nb = (1 + ((SHA256_BLOCK_SIZE - 9) < (ctx->len % SHA256_BLOCK_SIZE))); len_b = (ctx->tot_len + ctx->len) << 3; pm_len = block_nb << 6; memset(ctx->block + ctx->len, 0, pm_len - ctx->len); ctx->block[ctx->len] = 0x80; UNPACK32(len_b, ctx->block + pm_len - 4); sha256_transf(ctx, ctx->block, block_nb); #ifndef UNROLL_LOOPS for (i = 0 ; i < 8; i++) { UNPACK32(ctx->h[i], &digest[i << 2]); } #else UNPACK32(ctx->h[0], &digest[ 0]); UNPACK32(ctx->h[1], &digest[ 4]); UNPACK32(ctx->h[2], &digest[ 8]); UNPACK32(ctx->h[3], &digest[12]); UNPACK32(ctx->h[4], &digest[16]); UNPACK32(ctx->h[5], &digest[20]); UNPACK32(ctx->h[6], &digest[24]); UNPACK32(ctx->h[7], &digest[28]); #endif /* !UNROLL_LOOPS */ } /* SHA-512 functions */ void sha512_transf(sha512_ctx *ctx, const unsigned char *message, unsigned int block_nb) { uint64 w[80]; uint64 wv[8]; uint64 t1, t2; const unsigned char *sub_block; int i, j; for (i = 0; i < (int) block_nb; i++) { sub_block = message + (i << 7); #ifndef UNROLL_LOOPS for (j = 0; j < 16; j++) { PACK64(&sub_block[j << 3], &w[j]); } for (j = 16; j < 80; j++) { SHA512_SCR(j); } for (j = 0; j < 8; j++) { wv[j] = ctx->h[j]; } for (j = 0; j < 80; j++) { t1 = wv[7] + SHA512_F2(wv[4]) + CH(wv[4], wv[5], wv[6]) + sha512_k[j] + w[j]; t2 = SHA512_F1(wv[0]) + MAJ(wv[0], wv[1], wv[2]); wv[7] = wv[6]; wv[6] = wv[5]; wv[5] = wv[4]; wv[4] = wv[3] + t1; wv[3] = wv[2]; wv[2] = wv[1]; wv[1] = wv[0]; wv[0] = t1 + t2; } for (j = 0; j < 8; j++) { ctx->h[j] += wv[j]; } #else PACK64(&sub_block[ 0], &w[ 0]); PACK64(&sub_block[ 8], &w[ 1]); PACK64(&sub_block[ 16], &w[ 2]); PACK64(&sub_block[ 24], &w[ 3]); PACK64(&sub_block[ 32], &w[ 4]); PACK64(&sub_block[ 40], &w[ 5]); PACK64(&sub_block[ 48], &w[ 6]); PACK64(&sub_block[ 56], &w[ 7]); PACK64(&sub_block[ 64], &w[ 8]); PACK64(&sub_block[ 72], &w[ 9]); PACK64(&sub_block[ 80], &w[10]); PACK64(&sub_block[ 88], &w[11]); PACK64(&sub_block[ 96], &w[12]); PACK64(&sub_block[104], &w[13]); PACK64(&sub_block[112], &w[14]); PACK64(&sub_block[120], &w[15]); SHA512_SCR(16); SHA512_SCR(17); SHA512_SCR(18); SHA512_SCR(19); SHA512_SCR(20); SHA512_SCR(21); SHA512_SCR(22); SHA512_SCR(23); SHA512_SCR(24); SHA512_SCR(25); SHA512_SCR(26); SHA512_SCR(27); SHA512_SCR(28); SHA512_SCR(29); SHA512_SCR(30); SHA512_SCR(31); SHA512_SCR(32); SHA512_SCR(33); SHA512_SCR(34); SHA512_SCR(35); SHA512_SCR(36); SHA512_SCR(37); SHA512_SCR(38); SHA512_SCR(39); SHA512_SCR(40); SHA512_SCR(41); SHA512_SCR(42); SHA512_SCR(43); SHA512_SCR(44); SHA512_SCR(45); SHA512_SCR(46); SHA512_SCR(47); SHA512_SCR(48); SHA512_SCR(49); SHA512_SCR(50); SHA512_SCR(51); SHA512_SCR(52); SHA512_SCR(53); SHA512_SCR(54); SHA512_SCR(55); SHA512_SCR(56); SHA512_SCR(57); SHA512_SCR(58); SHA512_SCR(59); SHA512_SCR(60); SHA512_SCR(61); SHA512_SCR(62); SHA512_SCR(63); SHA512_SCR(64); SHA512_SCR(65); SHA512_SCR(66); SHA512_SCR(67); SHA512_SCR(68); SHA512_SCR(69); SHA512_SCR(70); SHA512_SCR(71); SHA512_SCR(72); SHA512_SCR(73); SHA512_SCR(74); SHA512_SCR(75); SHA512_SCR(76); SHA512_SCR(77); SHA512_SCR(78); SHA512_SCR(79); wv[0] = ctx->h[0]; wv[1] = ctx->h[1]; wv[2] = ctx->h[2]; wv[3] = ctx->h[3]; wv[4] = ctx->h[4]; wv[5] = ctx->h[5]; wv[6] = ctx->h[6]; wv[7] = ctx->h[7]; j = 0; do { SHA512_EXP(0,1,2,3,4,5,6,7,j); j++; SHA512_EXP(7,0,1,2,3,4,5,6,j); j++; SHA512_EXP(6,7,0,1,2,3,4,5,j); j++; SHA512_EXP(5,6,7,0,1,2,3,4,j); j++; SHA512_EXP(4,5,6,7,0,1,2,3,j); j++; SHA512_EXP(3,4,5,6,7,0,1,2,j); j++; SHA512_EXP(2,3,4,5,6,7,0,1,j); j++; SHA512_EXP(1,2,3,4,5,6,7,0,j); j++; } while (j < 80); ctx->h[0] += wv[0]; ctx->h[1] += wv[1]; ctx->h[2] += wv[2]; ctx->h[3] += wv[3]; ctx->h[4] += wv[4]; ctx->h[5] += wv[5]; ctx->h[6] += wv[6]; ctx->h[7] += wv[7]; #endif /* !UNROLL_LOOPS */ } } void sha512(const unsigned char *message, unsigned int len, unsigned char *digest) { sha512_ctx ctx; sha512_init(&ctx); sha512_update(&ctx, message, len); sha512_final(&ctx, digest); } void sha512_init(sha512_ctx *ctx) { #ifndef UNROLL_LOOPS int i; for (i = 0; i < 8; i++) { ctx->h[i] = sha512_h0[i]; } #else ctx->h[0] = sha512_h0[0]; ctx->h[1] = sha512_h0[1]; ctx->h[2] = sha512_h0[2]; ctx->h[3] = sha512_h0[3]; ctx->h[4] = sha512_h0[4]; ctx->h[5] = sha512_h0[5]; ctx->h[6] = sha512_h0[6]; ctx->h[7] = sha512_h0[7]; #endif /* !UNROLL_LOOPS */ ctx->len = 0; ctx->tot_len = 0; } void sha512_update(sha512_ctx *ctx, const unsigned char *message, unsigned int len) { unsigned int block_nb; unsigned int new_len, rem_len, tmp_len; const unsigned char *shifted_message; tmp_len = SHA512_BLOCK_SIZE - ctx->len; rem_len = len < tmp_len ? len : tmp_len; memcpy(&ctx->block[ctx->len], message, rem_len); if (ctx->len + len < SHA512_BLOCK_SIZE) { ctx->len += len; return; } new_len = len - rem_len; block_nb = new_len / SHA512_BLOCK_SIZE; shifted_message = message + rem_len; sha512_transf(ctx, ctx->block, 1); sha512_transf(ctx, shifted_message, block_nb); rem_len = new_len % SHA512_BLOCK_SIZE; memcpy(ctx->block, &shifted_message[block_nb << 7], rem_len); ctx->len = rem_len; ctx->tot_len += (block_nb + 1) << 7; } void sha512_final(sha512_ctx *ctx, unsigned char *digest) { unsigned int block_nb; unsigned int pm_len; unsigned int len_b; #ifndef UNROLL_LOOPS int i; #endif block_nb = 1 + ((SHA512_BLOCK_SIZE - 17) < (ctx->len % SHA512_BLOCK_SIZE)); len_b = (ctx->tot_len + ctx->len) << 3; pm_len = block_nb << 7; memset(ctx->block + ctx->len, 0, pm_len - ctx->len); ctx->block[ctx->len] = 0x80; UNPACK32(len_b, ctx->block + pm_len - 4); sha512_transf(ctx, ctx->block, block_nb); #ifndef UNROLL_LOOPS for (i = 0 ; i < 8; i++) { UNPACK64(ctx->h[i], &digest[i << 3]); } #else UNPACK64(ctx->h[0], &digest[ 0]); UNPACK64(ctx->h[1], &digest[ 8]); UNPACK64(ctx->h[2], &digest[16]); UNPACK64(ctx->h[3], &digest[24]); UNPACK64(ctx->h[4], &digest[32]); UNPACK64(ctx->h[5], &digest[40]); UNPACK64(ctx->h[6], &digest[48]); UNPACK64(ctx->h[7], &digest[56]); #endif /* !UNROLL_LOOPS */ } /* SHA-384 functions */ void sha384(const unsigned char *message, unsigned int len, unsigned char *digest) { sha384_ctx ctx; sha384_init(&ctx); sha384_update(&ctx, message, len); sha384_final(&ctx, digest); } void sha384_init(sha384_ctx *ctx) { #ifndef UNROLL_LOOPS int i; for (i = 0; i < 8; i++) { ctx->h[i] = sha384_h0[i]; } #else ctx->h[0] = sha384_h0[0]; ctx->h[1] = sha384_h0[1]; ctx->h[2] = sha384_h0[2]; ctx->h[3] = sha384_h0[3]; ctx->h[4] = sha384_h0[4]; ctx->h[5] = sha384_h0[5]; ctx->h[6] = sha384_h0[6]; ctx->h[7] = sha384_h0[7]; #endif /* !UNROLL_LOOPS */ ctx->len = 0; ctx->tot_len = 0; } void sha384_update(sha384_ctx *ctx, const unsigned char *message, unsigned int len) { unsigned int block_nb; unsigned int new_len, rem_len, tmp_len; const unsigned char *shifted_message; tmp_len = SHA384_BLOCK_SIZE - ctx->len; rem_len = len < tmp_len ? len : tmp_len; memcpy(&ctx->block[ctx->len], message, rem_len); if (ctx->len + len < SHA384_BLOCK_SIZE) { ctx->len += len; return; } new_len = len - rem_len; block_nb = new_len / SHA384_BLOCK_SIZE; shifted_message = message + rem_len; sha512_transf(ctx, ctx->block, 1); sha512_transf(ctx, shifted_message, block_nb); rem_len = new_len % SHA384_BLOCK_SIZE; memcpy(ctx->block, &shifted_message[block_nb << 7], rem_len); ctx->len = rem_len; ctx->tot_len += (block_nb + 1) << 7; } void sha384_final(sha384_ctx *ctx, unsigned char *digest) { unsigned int block_nb; unsigned int pm_len; unsigned int len_b; #ifndef UNROLL_LOOPS int i; #endif block_nb = (1 + ((SHA384_BLOCK_SIZE - 17) < (ctx->len % SHA384_BLOCK_SIZE))); len_b = (ctx->tot_len + ctx->len) << 3; pm_len = block_nb << 7; memset(ctx->block + ctx->len, 0, pm_len - ctx->len); ctx->block[ctx->len] = 0x80; UNPACK32(len_b, ctx->block + pm_len - 4); sha512_transf(ctx, ctx->block, block_nb); #ifndef UNROLL_LOOPS for (i = 0 ; i < 6; i++) { UNPACK64(ctx->h[i], &digest[i << 3]); } #else UNPACK64(ctx->h[0], &digest[ 0]); UNPACK64(ctx->h[1], &digest[ 8]); UNPACK64(ctx->h[2], &digest[16]); UNPACK64(ctx->h[3], &digest[24]); UNPACK64(ctx->h[4], &digest[32]); UNPACK64(ctx->h[5], &digest[40]); #endif /* !UNROLL_LOOPS */ } /* SHA-224 functions */ void sha224(const unsigned char *message, unsigned int len, unsigned char *digest) { sha224_ctx ctx; sha224_init(&ctx); sha224_update(&ctx, message, len); sha224_final(&ctx, digest); } void sha224_init(sha224_ctx *ctx) { #ifndef UNROLL_LOOPS int i; for (i = 0; i < 8; i++) { ctx->h[i] = sha224_h0[i]; } #else ctx->h[0] = sha224_h0[0]; ctx->h[1] = sha224_h0[1]; ctx->h[2] = sha224_h0[2]; ctx->h[3] = sha224_h0[3]; ctx->h[4] = sha224_h0[4]; ctx->h[5] = sha224_h0[5]; ctx->h[6] = sha224_h0[6]; ctx->h[7] = sha224_h0[7]; #endif /* !UNROLL_LOOPS */ ctx->len = 0; ctx->tot_len = 0; } void sha224_update(sha224_ctx *ctx, const unsigned char *message, unsigned int len) { unsigned int block_nb; unsigned int new_len, rem_len, tmp_len; const unsigned char *shifted_message; tmp_len = SHA224_BLOCK_SIZE - ctx->len; rem_len = len < tmp_len ? len : tmp_len; memcpy(&ctx->block[ctx->len], message, rem_len); if (ctx->len + len < SHA224_BLOCK_SIZE) { ctx->len += len; return; } new_len = len - rem_len; block_nb = new_len / SHA224_BLOCK_SIZE; shifted_message = message + rem_len; sha256_transf(ctx, ctx->block, 1); sha256_transf(ctx, shifted_message, block_nb); rem_len = new_len % SHA224_BLOCK_SIZE; memcpy(ctx->block, &shifted_message[block_nb << 6], rem_len); ctx->len = rem_len; ctx->tot_len += (block_nb + 1) << 6; } void sha224_final(sha224_ctx *ctx, unsigned char *digest) { unsigned int block_nb; unsigned int pm_len; unsigned int len_b; #ifndef UNROLL_LOOPS int i; #endif block_nb = (1 + ((SHA224_BLOCK_SIZE - 9) < (ctx->len % SHA224_BLOCK_SIZE))); len_b = (ctx->tot_len + ctx->len) << 3; pm_len = block_nb << 6; memset(ctx->block + ctx->len, 0, pm_len - ctx->len); ctx->block[ctx->len] = 0x80; UNPACK32(len_b, ctx->block + pm_len - 4); sha256_transf(ctx, ctx->block, block_nb); #ifndef UNROLL_LOOPS for (i = 0 ; i < 7; i++) { UNPACK32(ctx->h[i], &digest[i << 2]); } #else UNPACK32(ctx->h[0], &digest[ 0]); UNPACK32(ctx->h[1], &digest[ 4]); UNPACK32(ctx->h[2], &digest[ 8]); UNPACK32(ctx->h[3], &digest[12]); UNPACK32(ctx->h[4], &digest[16]); UNPACK32(ctx->h[5], &digest[20]); UNPACK32(ctx->h[6], &digest[24]); #endif /* !UNROLL_LOOPS */ } #ifdef TEST_VECTORS /* FIPS 180-2 Validation tests */ #include <stdio.h> #include <stdlib.h> void test(const char *vector, unsigned char *digest, unsigned int digest_size) { char output[2 * SHA512_DIGEST_SIZE + 1]; int i; output[2 * digest_size] = '\0'; for (i = 0; i < (int) digest_size ; i++) { sprintf(output + 2 * i, "%02x", digest[i]); } printf("H: %s\n", output); if (strcmp(vector, output)) { fprintf(stderr, "Test failed.\n"); exit(EXIT_FAILURE); } } int main(void) { static const char *vectors[4][3] = { /* SHA-224 */ { "23097d223405d8228642a477bda255b32aadbce4bda0b3f7e36c9da7", "75388b16512776cc5dba5da1fd890150b0c6455cb4f58b1952522525", "20794655980c91d8bbb4c1ea97618a4bf03f42581948b2ee4ee7ad67", }, /* SHA-256 */ { "ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad", "248d6a61d20638b8e5c026930c3e6039a33ce45964ff2167f6ecedd419db06c1", "cdc76e5c9914fb9281a1c7e284d73e67f1809a48a497200e046d39ccc7112cd0", }, /* SHA-384 */ { "cb00753f45a35e8bb5a03d699ac65007272c32ab0eded1631a8b605a43ff5bed" "8086072ba1e7cc2358baeca134c825a7", "09330c33f71147e83d192fc782cd1b4753111b173b3b05d22fa08086e3b0f712" "fcc7c71a557e2db966c3e9fa91746039", "9d0e1809716474cb086e834e310a4a1ced149e9c00f248527972cec5704c2a5b" "07b8b3dc38ecc4ebae97ddd87f3d8985", }, /* SHA-512 */ { "ddaf35a193617abacc417349ae20413112e6fa4e89a97ea20a9eeee64b55d39a" "2192992a274fc1a836ba3c23a3feebbd454d4423643ce80e2a9ac94fa54ca49f", "8e959b75dae313da8cf4f72814fc143f8f7779c6eb9f7fa17299aeadb6889018" "501d289e4900f7e4331b99dec4b5433ac7d329eeb6dd26545e96e55b874be909", "e718483d0ce769644e2e42c7bc15b4638e1f98b13b2044285632a803afa973eb" "de0ff244877ea60a4cb0432ce577c31beb009c5c2c49aa2e4eadb217ad8cc09b" } }; static const char message1[] = "abc"; static const char message2a[] = "abcdbcdecdefdefgefghfghighijhi" "jkijkljklmklmnlmnomnopnopq"; static const char message2b[] = "abcdefghbcdefghicdefghijdefghijkefghij" "klfghijklmghijklmnhijklmnoijklmnopjklm" "nopqklmnopqrlmnopqrsmnopqrstnopqrstu"; unsigned char *message3; unsigned int message3_len = 1000000; unsigned char digest[SHA512_DIGEST_SIZE]; message3 = malloc(message3_len); if (message3 == NULL) { fprintf(stderr, "Can't allocate memory\n"); return -1; } memset(message3, 'a', message3_len); printf("SHA-2 FIPS 180-2 Validation tests\n\n"); printf("SHA-224 Test vectors\n"); sha224((const unsigned char *) message1, strlen(message1), digest); test(vectors[0][0], digest, SHA224_DIGEST_SIZE); sha224((const unsigned char *) message2a, strlen(message2a), digest); test(vectors[0][1], digest, SHA224_DIGEST_SIZE); sha224(message3, message3_len, digest); test(vectors[0][2], digest, SHA224_DIGEST_SIZE); printf("\n"); printf("SHA-256 Test vectors\n"); sha256((const unsigned char *) message1, strlen(message1), digest); test(vectors[1][0], digest, SHA256_DIGEST_SIZE); sha256((const unsigned char *) message2a, strlen(message2a), digest); test(vectors[1][1], digest, SHA256_DIGEST_SIZE); sha256(message3, message3_len, digest); test(vectors[1][2], digest, SHA256_DIGEST_SIZE); printf("\n"); printf("SHA-384 Test vectors\n"); sha384((const unsigned char *) message1, strlen(message1), digest); test(vectors[2][0], digest, SHA384_DIGEST_SIZE); sha384((const unsigned char *)message2b, strlen(message2b), digest); test(vectors[2][1], digest, SHA384_DIGEST_SIZE); sha384(message3, message3_len, digest); test(vectors[2][2], digest, SHA384_DIGEST_SIZE); printf("\n"); printf("SHA-512 Test vectors\n"); sha512((const unsigned char *) message1, strlen(message1), digest); test(vectors[3][0], digest, SHA512_DIGEST_SIZE); sha512((const unsigned char *) message2b, strlen(message2b), digest); test(vectors[3][1], digest, SHA512_DIGEST_SIZE); sha512(message3, message3_len, digest); test(vectors[3][2], digest, SHA512_DIGEST_SIZE); printf("\n"); printf("All tests passed.\n"); return 0; } #endif /* TEST_VECTORS */ �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/vendor/sha2/sha2.h�������������������������������������������������������������������0000664�0000000�0000000�00000007335�14771603147�0016517�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * FIPS 180-2 SHA-224/256/384/512 implementation * Last update: 02/02/2007 * Issue date: 04/30/2005 * * Copyright (C) 2005, 2007 Olivier Gay <olivier.gay@a3.epfl.ch> * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. 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. * 3. Neither the name of the project nor the names of its contributors * may be used to endorse or promote products derived from this software * without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE PROJECT 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 PROJECT 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 SHA2_H #define SHA2_H #define SHA224_DIGEST_SIZE ( 224 / 8) #define SHA256_DIGEST_SIZE ( 256 / 8) #define SHA384_DIGEST_SIZE ( 384 / 8) #define SHA512_DIGEST_SIZE ( 512 / 8) #define SHA256_BLOCK_SIZE ( 512 / 8) #define SHA512_BLOCK_SIZE (1024 / 8) #define SHA384_BLOCK_SIZE SHA512_BLOCK_SIZE #define SHA224_BLOCK_SIZE SHA256_BLOCK_SIZE #ifndef SHA2_TYPES #define SHA2_TYPES typedef unsigned char uint8; typedef unsigned int uint32; typedef unsigned long long uint64; #endif #ifdef __cplusplus extern "C" { #endif typedef struct { unsigned int tot_len; unsigned int len; unsigned char block[2 * SHA256_BLOCK_SIZE]; uint32 h[8]; } sha256_ctx; typedef struct { unsigned int tot_len; unsigned int len; unsigned char block[2 * SHA512_BLOCK_SIZE]; uint64 h[8]; } sha512_ctx; typedef sha512_ctx sha384_ctx; typedef sha256_ctx sha224_ctx; void sha224_init(sha224_ctx *ctx); void sha224_update(sha224_ctx *ctx, const unsigned char *message, unsigned int len); void sha224_final(sha224_ctx *ctx, unsigned char *digest); void sha224(const unsigned char *message, unsigned int len, unsigned char *digest); void sha256_init(sha256_ctx * ctx); void sha256_update(sha256_ctx *ctx, const unsigned char *message, unsigned int len); void sha256_final(sha256_ctx *ctx, unsigned char *digest); void sha256(const unsigned char *message, unsigned int len, unsigned char *digest); void sha384_init(sha384_ctx *ctx); void sha384_update(sha384_ctx *ctx, const unsigned char *message, unsigned int len); void sha384_final(sha384_ctx *ctx, unsigned char *digest); void sha384(const unsigned char *message, unsigned int len, unsigned char *digest); void sha512_init(sha512_ctx *ctx); void sha512_update(sha512_ctx *ctx, const unsigned char *message, unsigned int len); void sha512_final(sha512_ctx *ctx, unsigned char *digest); void sha512(const unsigned char *message, unsigned int len, unsigned char *digest); #ifdef __cplusplus } #endif #endif /* !SHA2_H */ ���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/vendor/update������������������������������������������������������������������������0000775�0000000�0000000�00000007535�14771603147�0016066�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������#!/usr/bin/env perl # # InspIRCd -- Internet Relay Chat Daemon # # Copyright (C) 2020 Sadie Powell <sadie@witchery.services> # # This file is part of InspIRCd. InspIRCd is free software: you can # redistribute it and/or modify it under the terms of the GNU General Public # License as published by the Free Software Foundation, version 2. # # This program is distributed in the hope that it will be useful, but WITHOUT # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS # FOR A PARTICULAR PURPOSE. See the GNU General Public License for more # details. # # You should have received a copy of the GNU General Public License # along with this program. If not, see <http://www.gnu.org/licenses/>. # use v5.26.0; use strict; use warnings FATAL => qw(all); use File::Basename qw(basename dirname); use File::Copy qw(move); use File::Spec::Functions qw(abs2rel catdir catfile); use File::Temp qw(tempdir); use FindBin qw($RealDir); use POSIX qw(strftime); use TOML qw(from_toml); use lib dirname $RealDir; use make::common; use make::console; my $config = catfile $RealDir, 'update.toml'; open(my $fh, $config) or print_error "unable to read $config: $!"; my $contents = do { local $/; <$fh> }; close $fh; my ($data, $error) = from_toml $contents; print_error "unable to parse $config: $!" if $error; while (my ($name, $info) = each %{$data}) { say console_format "Updating <|GREEN $name|> ..."; my $unpackdir = File::Temp->newdir; my $vendordir = catdir $RealDir, $name; my $success = 0; if (defined $info->{git}) { my @extra_args; push @extra_args, '--branch', $info->{branch} if defined $info->{branch}; $success ||= execute 'git', 'clone', @extra_args, $info->{git}, $unpackdir; chomp(my $tag = `git -C $unpackdir describe --abbrev=0 --tags HEAD 2>/dev/null`) unless $success; $success ||= execute 'git', '-C', $unpackdir, 'checkout', $tag if $tag; chomp($info->{version} = `git -C $unpackdir describe --always --tags HEAD 2>/dev/null`); if (defined $info->{patches}) { my $patches = catfile($unpackdir, $info->{patches}); for my $patch (glob $patches) { $success |= execute 'git', '-C', $unpackdir, 'apply', $patch; } } } elsif (defined $info->{tarball}) { my $tarball = catfile $unpackdir, basename $info->{tarball}; $success ||= execute 'wget', '--output-document', $tarball, $info->{tarball}; $success ||= execute 'tar', 'fx', $tarball, '-C', $unpackdir, '--strip-components', 1; } else { print_error "unable to update $name; no git or tarball specified!"; } print_error "unable to update $name: download failed!" if $success; unlink $vendordir; my $glob = $info->{files} or print_error "unable to update $name: no file glob specified!"; for my $file (glob catfile $unpackdir, $glob) { my $pathname = abs2rel $file, $unpackdir; for (my $i = 0; $i < ($info->{depth} // 0); ++$i) { $pathname =~ s/[^\/]+\///; } my $filename = catfile $vendordir, $pathname; my $dirname = dirname $filename; create_directory $dirname, 0750; move $file, $filename; } } my $readme = catfile $RealDir, 'README.md'; open($fh, $readme) or print_error "unable to read $readme: $!"; $contents = do { local $/; <$fh> }; close $fh; open($fh, '>', $readme) or print_error "unable to write $readme: $!"; print $fh $contents =~ s/\n\#\#.*//rs; for my $name (sort keys %{$data}) { my $info = $data->{$name}; printf $fh "\n## %s\n\n", $name; printf $fh "**Author** &mdash; [%s](mailto:%s)\n\n", $info->{author}, $info->{email} if $info->{email}; printf $fh "**Author** &mdash; %s\n\n", $info->{author} unless $info->{email}; printf $fh "**License** &mdash; %s\n\n", $info->{license}; printf $fh "**Version** &mdash; %s\n\n", $info->{version}; my $website = $info->{website} // $info->{git}; printf $fh "**Website** &mdash; [%s](%s)\n", $website, $website; } close $fh; �������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/vendor/update.toml�������������������������������������������������������������������0000664�0000000�0000000�00000003134�14771603147�0017024�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������[bcrypt] author = "Solar Designer" email = "solar@openwall.com" files = "crypt_blowfish.[ch]" license = "Public Domain" tarball = "https://www.openwall.com/crypt/crypt_blowfish-1.3.tar.gz" version = "v1.3" website = "https://www.openwall.com/crypt/" [fmt] author = "Victor Zverovich and fmt contributors" depth = 2 files = "{include/fmt/*.h,LICENSE.rst,src/format.cc}" git = "https://github.com/fmtlib/fmt/" license = "MIT License" [http_parser] author = "Joyent, Inc. and other Node contributors" files = "{http_parser.[ch],LICENSE-MIT}" git = "https://git.in-ulm.de/cbiedl/http-parser" license = "MIT License" patches = "debian/patches/*.patch" [lyra] author = "Build Frameworks Group" depth = 3 files = "{data/single_include/lyra/lyra.hpp,LICENSE.txt}" git = "https://github.com/bfgroup/Lyra" branch = "release" license = "Boost Software License" [md5] author = "Solar Designer" depth = 1 email = "solar@openwall.com" files = "{LICENSE,md5/md5.[ch]}" license = "Cut-down BSD License" tarball = "https://www.openwall.com/blists/blists-2.0.tar.gz" version = "v2.0" website = "https://openwall.info/wiki/people/solar/software/public-domain-source-code/md5" [sha2] author = "Olivier Gay" email = "olivier.gay@a3.epfl.ch" files = "sha2.[ch]" license = "3-clause BSD License" tarball = "http://www.ouah.org/ogay/sha2/sha2.tar.gz" version = "2007-02-02" website = "http://www.ouah.org/ogay/sha2/" [utfcpp] author = "Nemanja Trifunovic" depth = 2 files = "{LICENSE,source/utf8/{core,unchecked}.h}" git = "https://github.com/nemtrif/utfcpp" license = "Boost Software License" ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/vendor/utfcpp/�����������������������������������������������������������������������0000775�0000000�0000000�00000000000�14771603147�0016145�5����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/vendor/utfcpp/LICENSE����������������������������������������������������������������0000664�0000000�0000000�00000002472�14771603147�0017157�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������Boost Software License - Version 1.0 - August 17th, 2003 Permission is hereby granted, free of charge, to any person or organization obtaining a copy of the software and accompanying documentation covered by this license (the "Software") to use, reproduce, display, distribute, execute, and transmit the Software, and to prepare derivative works of the Software, and to permit third-parties to whom the Software is furnished to do so, all subject to the following: The copyright notices in the Software and this entire statement, including the above license grant, this restriction and the following disclaimer, must be included in all copies of the Software, in whole or in part, and all derivative works of the Software, unless such copies or derivative works are solely in the form of machine-executable object code generated by a source language processor. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/vendor/utfcpp/core.h�����������������������������������������������������������������0000664�0000000�0000000�00000041356�14771603147�0017257�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������// Copyright 2006 Nemanja Trifunovic /* Permission is hereby granted, free of charge, to any person or organization obtaining a copy of the software and accompanying documentation covered by this license (the "Software") to use, reproduce, display, distribute, execute, and transmit the Software, and to prepare derivative works of the Software, and to permit third-parties to whom the Software is furnished to do so, all subject to the following: The copyright notices in the Software and this entire statement, including the above license grant, this restriction and the following disclaimer, must be included in all copies of the Software, in whole or in part, and all derivative works of the Software, unless such copies or derivative works are solely in the form of machine-executable object code generated by a source language processor. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ #ifndef UTF8_FOR_CPP_CORE_H_2675DCD0_9480_4c0c_B92A_CC14C027B731 #define UTF8_FOR_CPP_CORE_H_2675DCD0_9480_4c0c_B92A_CC14C027B731 #include <iterator> #include <cstring> #include <string> // Determine the C++ standard version. // If the user defines UTF_CPP_CPLUSPLUS, use that. // Otherwise, trust the unreliable predefined macro __cplusplus #if !defined UTF_CPP_CPLUSPLUS #define UTF_CPP_CPLUSPLUS __cplusplus #endif #if UTF_CPP_CPLUSPLUS >= 201103L // C++ 11 or later #define UTF_CPP_OVERRIDE override #define UTF_CPP_NOEXCEPT noexcept #else // C++ 98/03 #define UTF_CPP_OVERRIDE #define UTF_CPP_NOEXCEPT throw() #endif // C++ 11 or later namespace utf8 { // The typedefs for 8-bit, 16-bit and 32-bit code units #if UTF_CPP_CPLUSPLUS >= 201103L // C++ 11 or later #if UTF_CPP_CPLUSPLUS >= 202002L // C++ 20 or later typedef char8_t utfchar8_t; #else // C++ 11/14/17 typedef unsigned char utfchar8_t; #endif typedef char16_t utfchar16_t; typedef char32_t utfchar32_t; #else // C++ 98/03 typedef unsigned char utfchar8_t; typedef unsigned short utfchar16_t; typedef unsigned int utfchar32_t; #endif // C++ 11 or later // Helper code - not intended to be directly called by the library users. May be changed at any time namespace internal { // Unicode constants // Leading (high) surrogates: 0xd800 - 0xdbff // Trailing (low) surrogates: 0xdc00 - 0xdfff const utfchar16_t LEAD_SURROGATE_MIN = 0xd800u; const utfchar16_t LEAD_SURROGATE_MAX = 0xdbffu; const utfchar16_t TRAIL_SURROGATE_MIN = 0xdc00u; const utfchar16_t TRAIL_SURROGATE_MAX = 0xdfffu; const utfchar16_t LEAD_OFFSET = 0xd7c0u; // LEAD_SURROGATE_MIN - (0x10000 >> 10) const utfchar32_t SURROGATE_OFFSET = 0xfca02400u; // 0x10000u - (LEAD_SURROGATE_MIN << 10) - TRAIL_SURROGATE_MIN // Maximum valid value for a Unicode code point const utfchar32_t CODE_POINT_MAX = 0x0010ffffu; template<typename octet_type> inline utfchar8_t mask8(octet_type oc) { return static_cast<utfchar8_t>(0xff & oc); } template<typename u16_type> inline utfchar16_t mask16(u16_type oc) { return static_cast<utfchar16_t>(0xffff & oc); } template<typename octet_type> inline bool is_trail(octet_type oc) { return ((utf8::internal::mask8(oc) >> 6) == 0x2); } inline bool is_lead_surrogate(utfchar32_t cp) { return (cp >= LEAD_SURROGATE_MIN && cp <= LEAD_SURROGATE_MAX); } inline bool is_trail_surrogate(utfchar32_t cp) { return (cp >= TRAIL_SURROGATE_MIN && cp <= TRAIL_SURROGATE_MAX); } inline bool is_surrogate(utfchar32_t cp) { return (cp >= LEAD_SURROGATE_MIN && cp <= TRAIL_SURROGATE_MAX); } inline bool is_code_point_valid(utfchar32_t cp) { return (cp <= CODE_POINT_MAX && !utf8::internal::is_surrogate(cp)); } inline bool is_in_bmp(utfchar32_t cp) { return cp < utfchar32_t(0x10000); } template <typename octet_iterator> int sequence_length(octet_iterator lead_it) { const utfchar8_t lead = utf8::internal::mask8(*lead_it); if (lead < 0x80) return 1; else if ((lead >> 5) == 0x6) return 2; else if ((lead >> 4) == 0xe) return 3; else if ((lead >> 3) == 0x1e) return 4; else return 0; } inline bool is_overlong_sequence(utfchar32_t cp, int length) { if (cp < 0x80) { if (length != 1) return true; } else if (cp < 0x800) { if (length != 2) return true; } else if (cp < 0x10000) { if (length != 3) return true; } return false; } enum utf_error {UTF8_OK, NOT_ENOUGH_ROOM, INVALID_LEAD, INCOMPLETE_SEQUENCE, OVERLONG_SEQUENCE, INVALID_CODE_POINT}; /// Helper for get_sequence_x template <typename octet_iterator> utf_error increase_safely(octet_iterator& it, const octet_iterator end) { if (++it == end) return NOT_ENOUGH_ROOM; if (!utf8::internal::is_trail(*it)) return INCOMPLETE_SEQUENCE; return UTF8_OK; } #define UTF8_CPP_INCREASE_AND_RETURN_ON_ERROR(IT, END) {utf_error ret = increase_safely(IT, END); if (ret != UTF8_OK) return ret;} /// get_sequence_x functions decode utf-8 sequences of the length x template <typename octet_iterator> utf_error get_sequence_1(octet_iterator& it, octet_iterator end, utfchar32_t& code_point) { if (it == end) return NOT_ENOUGH_ROOM; code_point = utf8::internal::mask8(*it); return UTF8_OK; } template <typename octet_iterator> utf_error get_sequence_2(octet_iterator& it, octet_iterator end, utfchar32_t& code_point) { if (it == end) return NOT_ENOUGH_ROOM; code_point = utf8::internal::mask8(*it); UTF8_CPP_INCREASE_AND_RETURN_ON_ERROR(it, end) code_point = ((code_point << 6) & 0x7ff) + ((*it) & 0x3f); return UTF8_OK; } template <typename octet_iterator> utf_error get_sequence_3(octet_iterator& it, octet_iterator end, utfchar32_t& code_point) { if (it == end) return NOT_ENOUGH_ROOM; code_point = utf8::internal::mask8(*it); UTF8_CPP_INCREASE_AND_RETURN_ON_ERROR(it, end) code_point = ((code_point << 12) & 0xffff) + ((utf8::internal::mask8(*it) << 6) & 0xfff); UTF8_CPP_INCREASE_AND_RETURN_ON_ERROR(it, end) code_point = static_cast<utfchar32_t>(code_point + ((*it) & 0x3f)); return UTF8_OK; } template <typename octet_iterator> utf_error get_sequence_4(octet_iterator& it, octet_iterator end, utfchar32_t& code_point) { if (it == end) return NOT_ENOUGH_ROOM; code_point = utf8::internal::mask8(*it); UTF8_CPP_INCREASE_AND_RETURN_ON_ERROR(it, end) code_point = ((code_point << 18) & 0x1fffff) + ((utf8::internal::mask8(*it) << 12) & 0x3ffff); UTF8_CPP_INCREASE_AND_RETURN_ON_ERROR(it, end) code_point = static_cast<utfchar32_t>(code_point + ((utf8::internal::mask8(*it) << 6) & 0xfff)); UTF8_CPP_INCREASE_AND_RETURN_ON_ERROR(it, end) code_point = static_cast<utfchar32_t>(code_point + ((*it) & 0x3f)); return UTF8_OK; } #undef UTF8_CPP_INCREASE_AND_RETURN_ON_ERROR template <typename octet_iterator> utf_error validate_next(octet_iterator& it, octet_iterator end, utfchar32_t& code_point) { if (it == end) return NOT_ENOUGH_ROOM; // Save the original value of it so we can go back in case of failure // Of course, it does not make much sense with i.e. stream iterators octet_iterator original_it = it; utfchar32_t cp = 0; // Determine the sequence length based on the lead octet const int length = utf8::internal::sequence_length(it); // Get trail octets and calculate the code point utf_error err = UTF8_OK; switch (length) { case 0: return INVALID_LEAD; case 1: err = utf8::internal::get_sequence_1(it, end, cp); break; case 2: err = utf8::internal::get_sequence_2(it, end, cp); break; case 3: err = utf8::internal::get_sequence_3(it, end, cp); break; case 4: err = utf8::internal::get_sequence_4(it, end, cp); break; } if (err == UTF8_OK) { // Decoding succeeded. Now, security checks... if (utf8::internal::is_code_point_valid(cp)) { if (!utf8::internal::is_overlong_sequence(cp, length)){ // Passed! Return here. code_point = cp; ++it; return UTF8_OK; } else err = OVERLONG_SEQUENCE; } else err = INVALID_CODE_POINT; } // Failure branch - restore the original value of the iterator it = original_it; return err; } template <typename octet_iterator> inline utf_error validate_next(octet_iterator& it, octet_iterator end) { utfchar32_t ignored; return utf8::internal::validate_next(it, end, ignored); } template <typename word_iterator> utf_error validate_next16(word_iterator& it, word_iterator end, utfchar32_t& code_point) { if (it == end) return NOT_ENOUGH_ROOM; // Save the original value of it so we can go back in case of failure // Of course, it does not make much sense with i.e. stream iterators word_iterator original_it = it; utf_error err = UTF8_OK; const utfchar16_t first_word = *it++; if (!is_surrogate(first_word)) { code_point = first_word; return UTF8_OK; } else { if (it == end) err = NOT_ENOUGH_ROOM; else if (is_lead_surrogate(first_word)) { const utfchar16_t second_word = *it++; if (is_trail_surrogate(second_word)) { code_point = static_cast<utfchar32_t>(first_word << 10) + second_word + SURROGATE_OFFSET; return UTF8_OK; } else err = INCOMPLETE_SEQUENCE; } else { err = INVALID_LEAD; } } // error branch it = original_it; return err; } // Internal implementation of both checked and unchecked append() function // This function will be invoked by the overloads below, as they will know // the octet_type. template <typename octet_iterator, typename octet_type> octet_iterator append(utfchar32_t cp, octet_iterator result) { if (cp < 0x80) // one octet *(result++) = static_cast<octet_type>(cp); else if (cp < 0x800) { // two octets *(result++) = static_cast<octet_type>((cp >> 6) | 0xc0); *(result++) = static_cast<octet_type>((cp & 0x3f) | 0x80); } else if (cp < 0x10000) { // three octets *(result++) = static_cast<octet_type>((cp >> 12) | 0xe0); *(result++) = static_cast<octet_type>(((cp >> 6) & 0x3f) | 0x80); *(result++) = static_cast<octet_type>((cp & 0x3f) | 0x80); } else { // four octets *(result++) = static_cast<octet_type>((cp >> 18) | 0xf0); *(result++) = static_cast<octet_type>(((cp >> 12) & 0x3f)| 0x80); *(result++) = static_cast<octet_type>(((cp >> 6) & 0x3f) | 0x80); *(result++) = static_cast<octet_type>((cp & 0x3f) | 0x80); } return result; } // One of the following overloads will be invoked from the API calls // A simple (but dangerous) case: the caller appends byte(s) to a char array inline char* append(utfchar32_t cp, char* result) { return append<char*, char>(cp, result); } // Hopefully, most common case: the caller uses back_inserter // i.e. append(cp, std::back_inserter(str)); template<typename container_type> std::back_insert_iterator<container_type> append (utfchar32_t cp, std::back_insert_iterator<container_type> result) { return append<std::back_insert_iterator<container_type>, typename container_type::value_type>(cp, result); } // The caller uses some other kind of output operator - not covered above // Note that in this case we are not able to determine octet_type // so we assume it's utfchar8_t; that can cause a conversion warning if we are wrong. template <typename octet_iterator> octet_iterator append(utfchar32_t cp, octet_iterator result) { return append<octet_iterator, utfchar8_t>(cp, result); } // Internal implementation of both checked and unchecked append16() function // This function will be invoked by the overloads below, as they will know // the word_type. template <typename word_iterator, typename word_type> word_iterator append16(utfchar32_t cp, word_iterator result) { if (is_in_bmp(cp)) *(result++) = static_cast<word_type>(cp); else { // Code points from the supplementary planes are encoded via surrogate pairs *(result++) = static_cast<word_type>(LEAD_OFFSET + (cp >> 10)); *(result++) = static_cast<word_type>(TRAIL_SURROGATE_MIN + (cp & 0x3FF)); } return result; } // Hopefully, most common case: the caller uses back_inserter // i.e. append16(cp, std::back_inserter(str)); template<typename container_type> std::back_insert_iterator<container_type> append16 (utfchar32_t cp, std::back_insert_iterator<container_type> result) { return append16<std::back_insert_iterator<container_type>, typename container_type::value_type>(cp, result); } // The caller uses some other kind of output operator - not covered above // Note that in this case we are not able to determine word_type // so we assume it's utfchar16_t; that can cause a conversion warning if we are wrong. template <typename word_iterator> word_iterator append16(utfchar32_t cp, word_iterator result) { return append16<word_iterator, utfchar16_t>(cp, result); } } // namespace internal /// The library API - functions intended to be called by the users // Byte order mark const utfchar8_t bom[] = {0xef, 0xbb, 0xbf}; template <typename octet_iterator> octet_iterator find_invalid(octet_iterator start, octet_iterator end) { octet_iterator result = start; while (result != end) { utf8::internal::utf_error err_code = utf8::internal::validate_next(result, end); if (err_code != internal::UTF8_OK) return result; } return result; } inline const char* find_invalid(const char* str) { const char* end = str + std::strlen(str); return find_invalid(str, end); } inline std::size_t find_invalid(const std::string& s) { std::string::const_iterator invalid = find_invalid(s.begin(), s.end()); return (invalid == s.end()) ? std::string::npos : static_cast<std::size_t>(invalid - s.begin()); } template <typename octet_iterator> inline bool is_valid(octet_iterator start, octet_iterator end) { return (utf8::find_invalid(start, end) == end); } inline bool is_valid(const char* str) { return (*(utf8::find_invalid(str)) == '\0'); } inline bool is_valid(const std::string& s) { return is_valid(s.begin(), s.end()); } template <typename octet_iterator> inline bool starts_with_bom (octet_iterator it, octet_iterator end) { return ( ((it != end) && (utf8::internal::mask8(*it++)) == bom[0]) && ((it != end) && (utf8::internal::mask8(*it++)) == bom[1]) && ((it != end) && (utf8::internal::mask8(*it)) == bom[2]) ); } inline bool starts_with_bom(const std::string& s) { return starts_with_bom(s.begin(), s.end()); } } // namespace utf8 #endif // header guard ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/vendor/utfcpp/unchecked.h������������������������������������������������������������0000664�0000000�0000000�00000025465�14771603147�0020263�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������// Copyright 2006 Nemanja Trifunovic /* Permission is hereby granted, free of charge, to any person or organization obtaining a copy of the software and accompanying documentation covered by this license (the "Software") to use, reproduce, display, distribute, execute, and transmit the Software, and to prepare derivative works of the Software, and to permit third-parties to whom the Software is furnished to do so, all subject to the following: The copyright notices in the Software and this entire statement, including the above license grant, this restriction and the following disclaimer, must be included in all copies of the Software, in whole or in part, and all derivative works of the Software, unless such copies or derivative works are solely in the form of machine-executable object code generated by a source language processor. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ #ifndef UTF8_FOR_CPP_UNCHECKED_H_2675DCD0_9480_4c0c_B92A_CC14C027B731 #define UTF8_FOR_CPP_UNCHECKED_H_2675DCD0_9480_4c0c_B92A_CC14C027B731 #include "core.h" namespace utf8 { namespace unchecked { template <typename octet_iterator> octet_iterator append(utfchar32_t cp, octet_iterator result) { return internal::append(cp, result); } template <typename word_iterator> word_iterator append16(utfchar32_t cp, word_iterator result) { return internal::append16(cp, result); } template <typename octet_iterator, typename output_iterator> output_iterator replace_invalid(octet_iterator start, octet_iterator end, output_iterator out, utfchar32_t replacement) { while (start != end) { octet_iterator sequence_start = start; internal::utf_error err_code = utf8::internal::validate_next(start, end); switch (err_code) { case internal::UTF8_OK : for (octet_iterator it = sequence_start; it != start; ++it) *out++ = *it; break; case internal::NOT_ENOUGH_ROOM: out = utf8::unchecked::append(replacement, out); start = end; break; case internal::INVALID_LEAD: out = utf8::unchecked::append(replacement, out); ++start; break; case internal::INCOMPLETE_SEQUENCE: case internal::OVERLONG_SEQUENCE: case internal::INVALID_CODE_POINT: out = utf8::unchecked::append(replacement, out); ++start; // just one replacement mark for the sequence while (start != end && utf8::internal::is_trail(*start)) ++start; break; } } return out; } template <typename octet_iterator, typename output_iterator> inline output_iterator replace_invalid(octet_iterator start, octet_iterator end, output_iterator out) { static const utfchar32_t replacement_marker = utf8::internal::mask16(0xfffd); return utf8::unchecked::replace_invalid(start, end, out, replacement_marker); } inline std::string replace_invalid(const std::string& s, utfchar32_t replacement) { std::string result; replace_invalid(s.begin(), s.end(), std::back_inserter(result), replacement); return result; } inline std::string replace_invalid(const std::string& s) { std::string result; replace_invalid(s.begin(), s.end(), std::back_inserter(result)); return result; } template <typename octet_iterator> utfchar32_t next(octet_iterator& it) { utfchar32_t cp = utf8::internal::mask8(*it); switch (utf8::internal::sequence_length(it)) { case 1: break; case 2: it++; cp = ((cp << 6) & 0x7ff) + ((*it) & 0x3f); break; case 3: ++it; cp = ((cp << 12) & 0xffff) + ((utf8::internal::mask8(*it) << 6) & 0xfff); ++it; cp = static_cast<utfchar32_t>(cp + ((*it) & 0x3f)); break; case 4: ++it; cp = ((cp << 18) & 0x1fffff) + ((utf8::internal::mask8(*it) << 12) & 0x3ffff); ++it; cp = static_cast<utfchar32_t>(cp + ((utf8::internal::mask8(*it) << 6) & 0xfff)); ++it; cp = static_cast<utfchar32_t>(cp + ((*it) & 0x3f)); break; } ++it; return cp; } template <typename octet_iterator> utfchar32_t peek_next(octet_iterator it) { return utf8::unchecked::next(it); } template <typename word_iterator> utfchar32_t next16(word_iterator& it) { utfchar32_t cp = utf8::internal::mask16(*it++); if (utf8::internal::is_lead_surrogate(cp)) return (cp << 10) + *it++ + utf8::internal::SURROGATE_OFFSET; return cp; } template <typename octet_iterator> utfchar32_t prior(octet_iterator& it) { while (utf8::internal::is_trail(*(--it))) ; octet_iterator temp = it; return utf8::unchecked::next(temp); } template <typename octet_iterator, typename distance_type> void advance(octet_iterator& it, distance_type n) { const distance_type zero(0); if (n < zero) { // backward for (distance_type i = n; i < zero; ++i) utf8::unchecked::prior(it); } else { // forward for (distance_type i = zero; i < n; ++i) utf8::unchecked::next(it); } } template <typename octet_iterator> typename std::iterator_traits<octet_iterator>::difference_type distance(octet_iterator first, octet_iterator last) { typename std::iterator_traits<octet_iterator>::difference_type dist; for (dist = 0; first < last; ++dist) utf8::unchecked::next(first); return dist; } template <typename u16bit_iterator, typename octet_iterator> octet_iterator utf16to8(u16bit_iterator start, u16bit_iterator end, octet_iterator result) { while (start != end) { utfchar32_t cp = utf8::internal::mask16(*start++); // Take care of surrogate pairs first if (utf8::internal::is_lead_surrogate(cp)) { if (start == end) return result; utfchar32_t trail_surrogate = utf8::internal::mask16(*start++); cp = (cp << 10) + trail_surrogate + internal::SURROGATE_OFFSET; } result = utf8::unchecked::append(cp, result); } return result; } template <typename u16bit_iterator, typename octet_iterator> u16bit_iterator utf8to16(octet_iterator start, octet_iterator end, u16bit_iterator result) { while (start < end) { utfchar32_t cp = utf8::unchecked::next(start); if (cp > 0xffff) { //make a surrogate pair *result++ = static_cast<utfchar16_t>((cp >> 10) + internal::LEAD_OFFSET); *result++ = static_cast<utfchar16_t>((cp & 0x3ff) + internal::TRAIL_SURROGATE_MIN); } else *result++ = static_cast<utfchar16_t>(cp); } return result; } template <typename octet_iterator, typename u32bit_iterator> octet_iterator utf32to8(u32bit_iterator start, u32bit_iterator end, octet_iterator result) { while (start != end) result = utf8::unchecked::append(*(start++), result); return result; } template <typename octet_iterator, typename u32bit_iterator> u32bit_iterator utf8to32(octet_iterator start, octet_iterator end, u32bit_iterator result) { while (start < end) (*result++) = utf8::unchecked::next(start); return result; } // The iterator class template <typename octet_iterator> class iterator { octet_iterator it; public: typedef utfchar32_t value_type; typedef utfchar32_t* pointer; typedef utfchar32_t& reference; typedef std::ptrdiff_t difference_type; typedef std::bidirectional_iterator_tag iterator_category; iterator () {} explicit iterator (const octet_iterator& octet_it): it(octet_it) {} // the default "big three" are OK octet_iterator base () const { return it; } utfchar32_t operator * () const { octet_iterator temp = it; return utf8::unchecked::next(temp); } bool operator == (const iterator& rhs) const { return (it == rhs.it); } bool operator != (const iterator& rhs) const { return !(operator == (rhs)); } iterator& operator ++ () { ::std::advance(it, utf8::internal::sequence_length(it)); return *this; } iterator operator ++ (int) { iterator temp = *this; ::std::advance(it, utf8::internal::sequence_length(it)); return temp; } iterator& operator -- () { utf8::unchecked::prior(it); return *this; } iterator operator -- (int) { iterator temp = *this; utf8::unchecked::prior(it); return temp; } }; // class iterator } // namespace utf8::unchecked } // namespace utf8 #endif // header guard �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/win/���������������������������������������������������������������������������������0000775�0000000�0000000�00000000000�14771603147�0014144�5����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/win/.gitignore�����������������������������������������������������������������������0000664�0000000�0000000�00000000025�14771603147�0016131�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������config.h inspircd.rc �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/win/CMakeLists.txt�������������������������������������������������������������������0000664�0000000�0000000�00000012750�14771603147�0016711�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������# # InspIRCd -- Internet Relay Chat Daemon # # Copyright (C) 2019 Robby <robby@chatbelgie.be> # Copyright (C) 2018-2019, 2021-2024 Sadie Powell <sadie@witchery.services> # Copyright (C) 2013-2014 Attila Molnar <attilamolnar@hush.com> # Copyright (C) 2013-2014 Adam <Adam@anope.org> # # This file is part of InspIRCd. InspIRCd is free software: you can # redistribute it and/or modify it under the terms of the GNU General Public # License as published by the Free Software Foundation, version 2. # # This program is distributed in the hope that it will be useful, but WITHOUT # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS # FOR A PARTICULAR PURPOSE. See the GNU General Public License for more # details. # # You should have received a copy of the GNU General Public License # along with this program. If not, see <http://www.gnu.org/licenses/>. # cmake_minimum_required(VERSION 3.20 FATAL_ERROR) project("InspIRCd" CXX) if(NOT WIN32) message(FATAL_ERROR "CMake can only be used on Windows!") endif() set(CONFIG_DIR "conf" CACHE PATH "Configuration path") set(MODULE_DIR "modules" CACHE PATH "Module path") set(DATA_DIR "data" CACHE PATH "Data path") set(LOG_DIR "logs" CACHE PATH "Log path") # Find the root of the source directory cmake_path(GET CMAKE_CURRENT_SOURCE_DIR PARENT_PATH INSPIRCD_BASE) # Build with multiple processes set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /MP") # Use our own NSIS template set(CMAKE_MODULE_PATH "${INSPIRCD_BASE}/win") # Require C++17 set(CMAKE-CXX_EXTENSIONS OFF) set(CMAKE_CXX_STANDARD "17") set(CMAKE_CXX_STANDARD_REQUIRED ON) # Put modules in their own folder set_property(GLOBAL PROPERTY USE_FOLDERS ON) add_compile_definitions( "_WIN32_WINNT=0x0A00" # Set the minimum OS to Windows 10 "FD_SETSIZE=24000" # Increase the default socket limit to something reasonable "NOMINMAX" # Avoid the Windows API breaking std::{min,max} "NTDDI_VERSION=0x0A000005" # Set the minimum OS to Windows 10 1803 "Redstone 4" "WIN32_LEAN_AND_MEAN" # Trim down the size of the included headers. ) add_compile_options("/utf-8") include_directories("${INSPIRCD_BASE}/win" "${INSPIRCD_BASE}/include") include_directories(SYSTEM "${INSPIRCD_BASE}/vendor") # win32memory is statically linked into every target later add_library("win32memory" STATIC "${INSPIRCD_BASE}/win/win32memory.cpp") # Grab version info from version.sh file(STRINGS "${INSPIRCD_BASE}/src/version.sh" VERSIONSH) string(REGEX REPLACE ".*InspIRCd-([0-9]*).*" "\\1" VERSION_MAJOR "${VERSIONSH}") string(REGEX REPLACE ".*InspIRCd-[0-9]*\\.([0-9]*).*" "\\1" VERSION_MINOR "${VERSIONSH}") string(REGEX REPLACE ".*InspIRCd-[0-9]*\\.[0-9]*\\.([0-9]*).*" "\\1" VERSION_PATCH "${VERSIONSH}") string(REGEX REPLACE ".*InspIRCd-([^\"]+).*" "\\1" VERSION_FULL "${VERSIONSH}") # Preconfigure files that the InspIRCd build needs. configure_file("${INSPIRCD_BASE}/make/template/config.h" "${INSPIRCD_BASE}/include/config.h") configure_file("${INSPIRCD_BASE}/win/inspircd.rc.cmake" "${INSPIRCD_BASE}/win/inspircd.rc") file(GLOB INSPIRCD_HEADERS "${INSPIRCD_BASE}/include/*.h" "${INSPIRCD_BASE}/include/modules/*.h" "${INSPIRCD_BASE}/include/utility/*.h" ) list(SORT INSPIRCD_HEADERS) file(GLOB INSPIRCD_SOURCES "${INSPIRCD_BASE}/src/*.cpp" "${INSPIRCD_BASE}/src/socketengines/select.cpp" "${INSPIRCD_BASE}/win/win32wrapper.cpp" "${INSPIRCD_BASE}/win/win32service.cpp" ) list(SORT INSPIRCD_SOURCES) # The main server executable add_executable("inspircd" ${INSPIRCD_HEADERS} ${INSPIRCD_SOURCES} "${INSPIRCD_BASE}/win/inspircd.rc") add_dependencies("inspircd" "win32memory") target_compile_definitions("inspircd" PRIVATE "FMT_LIB_EXPORT" "INSPIRCD_CORE") set_target_properties("inspircd" PROPERTIES "ENABLE_EXPORTS" ON) target_link_libraries("inspircd" "win32memory") install(TARGETS "inspircd" RUNTIME DESTINATION ".") # Also build modules add_subdirectory("modules") # Package any DLLs from Conan file(GLOB EXTRA_DLLS "${CMAKE_CURRENT_SOURCE_DIR}/*.dll") install(FILES ${EXTRA_DLLS} DESTINATION ".") # Install example configs install(DIRECTORY "${INSPIRCD_BASE}/docs/conf/" DESTINATION "${CONFIG_DIR}/examples") install(DIRECTORY "${INSPIRCD_BASE}/docs/sql/" DESTINATION "${CONFIG_DIR}/sql") # Create an empty data and logs directory and install them file(MAKE_DIRECTORY ${DATA_DIR}) install(DIRECTORY ${DATA_DIR} DESTINATION .) file(MAKE_DIRECTORY ${LOG_DIR}) install(DIRECTORY ${LOG_DIR} DESTINATION .) if(EXISTS "${CMAKE_ROOT}/Modules/CPack.cmake") # Place runtime libraries next to the InspIRCd binary set(CMAKE_INSTALL_SYSTEM_RUNTIME_DESTINATION ".") include("InstallRequiredSystemLibraries") set(CPACK_PACKAGE_NAME "InspIRCd -- Internet Relay Chat Daemon") set(CPACK_PACKAGE_VENDOR "InspIRCd Team") set(CPACK_PACKAGE_VERSION_MAJOR ${VERSION_MAJOR}) set(CPACK_PACKAGE_VERSION_MINOR ${VERSION_MINOR}) set(CPACK_PACKAGE_VERSION_PATCH ${VERSION_PATCH}) set(CPACK_PACKAGE_FILE_NAME "InspIRCd-${VERSION_FULL}") set(CPACK_RESOURCE_FILE_LICENSE "${INSPIRCD_BASE}/docs/LICENSE.txt") set(CPACK_GENERATOR "NSIS") set(CPACK_PACKAGE_INSTALL_DIRECTORY "InspIRCd") # NSIS has a bug with full nix paths, so this must contain at least one backslash set(CPACK_PACKAGE_ICON "${INSPIRCD_BASE}/win\\\\inspircd.ico") set(CPACK_NSIS_MUI_ICON "${INSPIRCD_BASE}/win\\\\inspircd.ico") set(CPACK_NSIS_MUI_UNIICON "${INSPIRCD_BASE}/win\\\\inspircd.ico") set(CPACK_NSIS_INSTALLED_ICON_NAME "inspircd.exe") set(CPACK_NSIS_URL_INFO_ABOUT "https://www.inspircd.org") set(CPACK_NSIS_COMPRESSOR "/SOLID zlib") include("CPack") endif() ������������������������inspircd-4.7.0/win/NSIS.template.in�����������������������������������������������������������������0000664�0000000�0000000�00000072725�14771603147�0017077�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������; CPack install script designed for a nmake build ;-------------------------------- ; You must define these values !define VERSION "@CPACK_PACKAGE_VERSION@" !define PATCH "@CPACK_PACKAGE_VERSION_PATCH@" !define INST_DIR "@CPACK_TEMPORARY_DIRECTORY@" ;-------------------------------- ;Variables Var MUI_TEMP Var STARTMENU_FOLDER Var SV_ALLUSERS Var START_MENU Var DO_NOT_ADD_TO_PATH Var ADD_TO_PATH_ALL_USERS Var ADD_TO_PATH_CURRENT_USER Var INSTALL_DESKTOP Var IS_DEFAULT_INSTALLDIR ;-------------------------------- ;Include Modern UI !include "MUI.nsh" ;Default installation folder InstallDir "@CPACK_NSIS_INSTALL_ROOT@\@CPACK_PACKAGE_INSTALL_DIRECTORY@" ;-------------------------------- ;General ;Name and file Name "@CPACK_NSIS_PACKAGE_NAME@" OutFile "@CPACK_TOPLEVEL_DIRECTORY@/@CPACK_OUTPUT_FILE_NAME@" ;Set compression SetCompressor @CPACK_NSIS_COMPRESSOR@ ;Require administrator access RequestExecutionLevel admin @CPACK_NSIS_DEFINES@ @CPACK_NSIS_MANIFEST_DPI_AWARE_CODE@ @CPACK_NSIS_BRANDING_TEXT_CODE@ !include Sections.nsh ;--- Component support macros: --- ; The code for the add/remove functionality is from: ; https://nsis.sourceforge.io/Add/Remove_Functionality ; It has been modified slightly and extended to provide ; inter-component dependencies. Var AR_SecFlags Var AR_RegFlags @CPACK_NSIS_SECTION_SELECTED_VARS@ ; Loads the "selected" flag for the section named SecName into the ; variable VarName. !macro LoadSectionSelectedIntoVar SecName VarName SectionGetFlags ${${SecName}} $${VarName} IntOp $${VarName} $${VarName} & ${SF_SELECTED} ;Turn off all other bits !macroend ; Loads the value of a variable... can we get around this? !macro LoadVar VarName IntOp $R0 0 + $${VarName} !macroend ; Sets the value of a variable !macro StoreVar VarName IntValue IntOp $${VarName} 0 + ${IntValue} !macroend !macro InitSection SecName ; This macro reads component installed flag from the registry and ;changes checked state of the section on the components page. ;Input: section index constant name specified in Section command. ClearErrors ;Reading component status from registry ReadRegDWORD $AR_RegFlags HKLM "Software\Microsoft\Windows\CurrentVersion\Uninstall\@CPACK_PACKAGE_INSTALL_REGISTRY_KEY@\Components\${SecName}" "Installed" IfErrors "default_${SecName}" ;Status will stay default if registry value not found ;(component was never installed) IntOp $AR_RegFlags $AR_RegFlags & ${SF_SELECTED} ;Turn off all other bits SectionGetFlags ${${SecName}} $AR_SecFlags ;Reading default section flags IntOp $AR_SecFlags $AR_SecFlags & 0xFFFE ;Turn lowest (enabled) bit off IntOp $AR_SecFlags $AR_RegFlags | $AR_SecFlags ;Change lowest bit ; Note whether this component was installed before !insertmacro StoreVar ${SecName}_was_installed $AR_RegFlags IntOp $R0 $AR_RegFlags & $AR_RegFlags ;Writing modified flags SectionSetFlags ${${SecName}} $AR_SecFlags "default_${SecName}:" !insertmacro LoadSectionSelectedIntoVar ${SecName} ${SecName}_selected !macroend !macro FinishSection SecName ; This macro reads section flag set by user and removes the section ;if it is not selected. ;Then it writes component installed flag to registry ;Input: section index constant name specified in Section command. SectionGetFlags ${${SecName}} $AR_SecFlags ;Reading section flags ;Checking lowest bit: IntOp $AR_SecFlags $AR_SecFlags & ${SF_SELECTED} IntCmp $AR_SecFlags 1 "leave_${SecName}" ;Section is not selected: ;Calling Section uninstall macro and writing zero installed flag !insertmacro "Remove_${${SecName}}" WriteRegDWORD HKLM "Software\Microsoft\Windows\CurrentVersion\Uninstall\@CPACK_PACKAGE_INSTALL_REGISTRY_KEY@\Components\${SecName}" \ "Installed" 0 Goto "exit_${SecName}" "leave_${SecName}:" ;Section is selected: WriteRegDWORD HKLM "Software\Microsoft\Windows\CurrentVersion\Uninstall\@CPACK_PACKAGE_INSTALL_REGISTRY_KEY@\Components\${SecName}" \ "Installed" 1 "exit_${SecName}:" !macroend !macro RemoveSection_CPack SecName ; This macro is used to call section's Remove_... macro ;from the uninstaller. ;Input: section index constant name specified in Section command. !insertmacro "Remove_${${SecName}}" !macroend ; Determine whether the selection of SecName changed !macro MaybeSelectionChanged SecName !insertmacro LoadVar ${SecName}_selected SectionGetFlags ${${SecName}} $R1 IntOp $R1 $R1 & ${SF_SELECTED} ;Turn off all other bits ; See if the status has changed: IntCmp $R0 $R1 "${SecName}_unchanged" !insertmacro LoadSectionSelectedIntoVar ${SecName} ${SecName}_selected IntCmp $R1 ${SF_SELECTED} "${SecName}_was_selected" !insertmacro "Deselect_required_by_${SecName}" goto "${SecName}_unchanged" "${SecName}_was_selected:" !insertmacro "Select_${SecName}_depends" "${SecName}_unchanged:" !macroend ;--- End of Add/Remove macros --- ;-------------------------------- ;Interface Settings !define MUI_HEADERIMAGE !define MUI_ABORTWARNING ;---------------------------------------- ; based upon a script of "Written by KiCHiK 2003-01-18 05:57:02" ;---------------------------------------- !verbose 3 !include "WinMessages.NSH" !verbose 4 ;==================================================== ; get_NT_environment ; Returns: the selected environment ; Output : head of the stack ;==================================================== !macro select_NT_profile UN Function ${UN}select_NT_profile StrCmp $ADD_TO_PATH_ALL_USERS "1" 0 environment_single DetailPrint "Selected environment for all users" Push "all" Return environment_single: DetailPrint "Selected environment for current user only." Push "current" Return FunctionEnd !macroend !insertmacro select_NT_profile "" !insertmacro select_NT_profile "un." ;---------------------------------------------------- !define NT_current_env 'HKCU "Environment"' !define NT_all_env 'HKLM "SYSTEM\CurrentControlSet\Control\Session Manager\Environment"' !ifndef WriteEnvStr_RegKey !ifdef ALL_USERS !define WriteEnvStr_RegKey \ 'HKLM "SYSTEM\CurrentControlSet\Control\Session Manager\Environment"' !else !define WriteEnvStr_RegKey 'HKCU "Environment"' !endif !endif ; AddToPath - Adds the given dir to the search path. ; Input - head of the stack ; Note - Win9x systems requires reboot Function AddToPath Exch $0 Push $1 Push $2 Push $3 # don't add if the path doesn't exist IfFileExists "$0\*.*" "" AddToPath_done ReadEnvStr $1 PATH ; if the path is too long for a NSIS variable NSIS will return a 0 ; length string. If we find that, then warn and skip any path ; modification as it will trash the existing path. StrLen $2 $1 IntCmp $2 0 CheckPathLength_ShowPathWarning CheckPathLength_Done CheckPathLength_Done CheckPathLength_ShowPathWarning: Messagebox MB_OK|MB_ICONEXCLAMATION "Warning! PATH too long installer unable to modify PATH!" Goto AddToPath_done CheckPathLength_Done: Push "$1;" Push "$0;" Call StrStr Pop $2 StrCmp $2 "" "" AddToPath_done Push "$1;" Push "$0\;" Call StrStr Pop $2 StrCmp $2 "" "" AddToPath_done GetFullPathName /SHORT $3 $0 Push "$1;" Push "$3;" Call StrStr Pop $2 StrCmp $2 "" "" AddToPath_done Push "$1;" Push "$3\;" Call StrStr Pop $2 StrCmp $2 "" "" AddToPath_done Call IsNT Pop $1 StrCmp $1 1 AddToPath_NT ; Not on NT StrCpy $1 $WINDIR 2 FileOpen $1 "$1\autoexec.bat" a FileSeek $1 -1 END FileReadByte $1 $2 IntCmp $2 26 0 +2 +2 # DOS EOF FileSeek $1 -1 END # write over EOF FileWrite $1 "$\r$\nSET PATH=%PATH%;$3$\r$\n" FileClose $1 SetRebootFlag true Goto AddToPath_done AddToPath_NT: StrCmp $ADD_TO_PATH_ALL_USERS "1" ReadAllKey ReadRegStr $1 ${NT_current_env} "PATH" Goto DoTrim ReadAllKey: ReadRegStr $1 ${NT_all_env} "PATH" DoTrim: StrCmp $1 "" AddToPath_NTdoIt Push $1 Call Trim Pop $1 StrCpy $0 "$1;$0" AddToPath_NTdoIt: StrCmp $ADD_TO_PATH_ALL_USERS "1" WriteAllKey WriteRegExpandStr ${NT_current_env} "PATH" $0 Goto DoSend WriteAllKey: WriteRegExpandStr ${NT_all_env} "PATH" $0 DoSend: SendMessage ${HWND_BROADCAST} ${WM_WININICHANGE} 0 "STR:Environment" /TIMEOUT=5000 AddToPath_done: Pop $3 Pop $2 Pop $1 Pop $0 FunctionEnd ; RemoveFromPath - Remove a given dir from the path ; Input: head of the stack Function un.RemoveFromPath Exch $0 Push $1 Push $2 Push $3 Push $4 Push $5 Push $6 IntFmt $6 "%c" 26 # DOS EOF Call un.IsNT Pop $1 StrCmp $1 1 unRemoveFromPath_NT ; Not on NT StrCpy $1 $WINDIR 2 FileOpen $1 "$1\autoexec.bat" r GetTempFileName $4 FileOpen $2 $4 w GetFullPathName /SHORT $0 $0 StrCpy $0 "SET PATH=%PATH%;$0" Goto unRemoveFromPath_dosLoop unRemoveFromPath_dosLoop: FileRead $1 $3 StrCpy $5 $3 1 -1 # read last char StrCmp $5 $6 0 +2 # if DOS EOF StrCpy $3 $3 -1 # remove DOS EOF so we can compare StrCmp $3 "$0$\r$\n" unRemoveFromPath_dosLoopRemoveLine StrCmp $3 "$0$\n" unRemoveFromPath_dosLoopRemoveLine StrCmp $3 "$0" unRemoveFromPath_dosLoopRemoveLine StrCmp $3 "" unRemoveFromPath_dosLoopEnd FileWrite $2 $3 Goto unRemoveFromPath_dosLoop unRemoveFromPath_dosLoopRemoveLine: SetRebootFlag true Goto unRemoveFromPath_dosLoop unRemoveFromPath_dosLoopEnd: FileClose $2 FileClose $1 StrCpy $1 $WINDIR 2 Delete "$1\autoexec.bat" CopyFiles /SILENT $4 "$1\autoexec.bat" Delete $4 Goto unRemoveFromPath_done unRemoveFromPath_NT: StrCmp $ADD_TO_PATH_ALL_USERS "1" unReadAllKey ReadRegStr $1 ${NT_current_env} "PATH" Goto unDoTrim unReadAllKey: ReadRegStr $1 ${NT_all_env} "PATH" unDoTrim: StrCpy $5 $1 1 -1 # copy last char StrCmp $5 ";" +2 # if last char != ; StrCpy $1 "$1;" # append ; Push $1 Push "$0;" Call un.StrStr ; Find `$0;` in $1 Pop $2 ; pos of our dir StrCmp $2 "" unRemoveFromPath_done ; else, it is in path # $0 - path to add # $1 - path var StrLen $3 "$0;" StrLen $4 $2 StrCpy $5 $1 -$4 # $5 is now the part before the path to remove StrCpy $6 $2 "" $3 # $6 is now the part after the path to remove StrCpy $3 $5$6 StrCpy $5 $3 1 -1 # copy last char StrCmp $5 ";" 0 +2 # if last char == ; StrCpy $3 $3 -1 # remove last char StrCmp $ADD_TO_PATH_ALL_USERS "1" unWriteAllKey WriteRegExpandStr ${NT_current_env} "PATH" $3 Goto unDoSend unWriteAllKey: WriteRegExpandStr ${NT_all_env} "PATH" $3 unDoSend: SendMessage ${HWND_BROADCAST} ${WM_WININICHANGE} 0 "STR:Environment" /TIMEOUT=5000 unRemoveFromPath_done: Pop $6 Pop $5 Pop $4 Pop $3 Pop $2 Pop $1 Pop $0 FunctionEnd ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ; Uninstall stuff ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ########################################### # Utility Functions # ########################################### ;==================================================== ; IsNT - Returns 1 if the current system is NT, 0 ; otherwise. ; Output: head of the stack ;==================================================== ; IsNT ; no input ; output, top of the stack = 1 if NT or 0 if not ; ; Usage: ; Call IsNT ; Pop $R0 ; ($R0 at this point is 1 or 0) !macro IsNT un Function ${un}IsNT Push $0 ReadRegStr $0 HKLM "SOFTWARE\Microsoft\Windows NT\CurrentVersion" CurrentVersion StrCmp $0 "" 0 IsNT_yes ; we are not NT. Pop $0 Push 0 Return IsNT_yes: ; NT!!! Pop $0 Push 1 FunctionEnd !macroend !insertmacro IsNT "" !insertmacro IsNT "un." ; StrStr ; input, top of stack = string to search for ; top of stack-1 = string to search in ; output, top of stack (replaces with the portion of the string remaining) ; modifies no other variables. ; ; Usage: ; Push "this is a long ass string" ; Push "ass" ; Call StrStr ; Pop $R0 ; ($R0 at this point is "ass string") !macro StrStr un Function ${un}StrStr Exch $R1 ; st=haystack,old$R1, $R1=needle Exch ; st=old$R1,haystack Exch $R2 ; st=old$R1,old$R2, $R2=haystack Push $R3 Push $R4 Push $R5 StrLen $R3 $R1 StrCpy $R4 0 ; $R1=needle ; $R2=haystack ; $R3=len(needle) ; $R4=cnt ; $R5=tmp loop: StrCpy $R5 $R2 $R3 $R4 StrCmp $R5 $R1 done StrCmp $R5 "" done IntOp $R4 $R4 + 1 Goto loop done: StrCpy $R1 $R2 "" $R4 Pop $R5 Pop $R4 Pop $R3 Pop $R2 Exch $R1 FunctionEnd !macroend !insertmacro StrStr "" !insertmacro StrStr "un." Function Trim ; Added by Pelaca Exch $R1 Push $R2 Loop: StrCpy $R2 "$R1" 1 -1 StrCmp "$R2" " " RTrim StrCmp "$R2" "$\n" RTrim StrCmp "$R2" "$\r" RTrim StrCmp "$R2" ";" RTrim GoTo Done RTrim: StrCpy $R1 "$R1" -1 Goto Loop Done: Pop $R2 Exch $R1 FunctionEnd Function ConditionalAddToRegistry Pop $0 Pop $1 StrCmp "$0" "" ConditionalAddToRegistry_EmptyString WriteRegStr SHCTX "Software\Microsoft\Windows\CurrentVersion\Uninstall\@CPACK_PACKAGE_INSTALL_REGISTRY_KEY@" \ "$1" "$0" ;MessageBox MB_OK "Set Registry: '$1' to '$0'" DetailPrint "Set install registry entry: '$1' to '$0'" ConditionalAddToRegistry_EmptyString: FunctionEnd ;-------------------------------- !ifdef CPACK_USES_DOWNLOAD Function DownloadFile IfFileExists $INSTDIR\* +2 CreateDirectory $INSTDIR Pop $0 ; Skip if already downloaded IfFileExists $INSTDIR\$0 0 +2 Return StrCpy $1 "@CPACK_DOWNLOAD_SITE@" try_again: NSISdl::download "$1/$0" "$INSTDIR\$0" Pop $1 StrCmp $1 "success" success StrCmp $1 "Cancelled" cancel MessageBox MB_OK "Download failed: $1" cancel: Return success: FunctionEnd !endif ;-------------------------------- ; Define some macro setting for the gui @CPACK_NSIS_INSTALLER_MUI_ICON_CODE@ @CPACK_NSIS_INSTALLER_ICON_CODE@ @CPACK_NSIS_INSTALLER_MUI_WELCOMEFINISH_CODE@ @CPACK_NSIS_INSTALLER_MUI_UNWELCOMEFINISH_CODE@ @CPACK_NSIS_INSTALLER_MUI_FINISHPAGE_RUN_CODE@ ;-------------------------------- ;Pages @CPACK_NSIS_INSTALLER_WELCOME_TITLE_CODE@ @CPACK_NSIS_INSTALLER_WELCOME_TITLE_3LINES_CODE@ !insertmacro MUI_PAGE_WELCOME @CPACK_NSIS_LICENSE_PAGE@ Page custom InstallOptionsPage !insertmacro MUI_PAGE_DIRECTORY ;Start Menu Folder Page Configuration !define MUI_STARTMENUPAGE_REGISTRY_ROOT "SHCTX" !define MUI_STARTMENUPAGE_REGISTRY_KEY "Software\@CPACK_PACKAGE_VENDOR@\@CPACK_PACKAGE_INSTALL_REGISTRY_KEY@" !define MUI_STARTMENUPAGE_REGISTRY_VALUENAME "Start Menu Folder" !insertmacro MUI_PAGE_STARTMENU Application $STARTMENU_FOLDER @CPACK_NSIS_PAGE_COMPONENTS@ !insertmacro MUI_PAGE_INSTFILES @CPACK_NSIS_INSTALLER_FINISH_TITLE_CODE@ @CPACK_NSIS_INSTALLER_FINISH_TITLE_3LINES_CODE@ !insertmacro MUI_PAGE_FINISH !insertmacro MUI_UNPAGE_CONFIRM !insertmacro MUI_UNPAGE_INSTFILES ;-------------------------------- ;Languages !insertmacro MUI_LANGUAGE "English" ;first language is the default language !insertmacro MUI_LANGUAGE "Afrikaans" !insertmacro MUI_LANGUAGE "Albanian" !insertmacro MUI_LANGUAGE "Arabic" !insertmacro MUI_LANGUAGE "Asturian" !insertmacro MUI_LANGUAGE "Basque" !insertmacro MUI_LANGUAGE "Belarusian" !insertmacro MUI_LANGUAGE "Bosnian" !insertmacro MUI_LANGUAGE "Breton" !insertmacro MUI_LANGUAGE "Bulgarian" !insertmacro MUI_LANGUAGE "Catalan" !insertmacro MUI_LANGUAGE "Corsican" !insertmacro MUI_LANGUAGE "Croatian" !insertmacro MUI_LANGUAGE "Czech" !insertmacro MUI_LANGUAGE "Danish" !insertmacro MUI_LANGUAGE "Dutch" !insertmacro MUI_LANGUAGE "Esperanto" !insertmacro MUI_LANGUAGE "Estonian" !insertmacro MUI_LANGUAGE "Farsi" !insertmacro MUI_LANGUAGE "Finnish" !insertmacro MUI_LANGUAGE "French" !insertmacro MUI_LANGUAGE "Galician" !insertmacro MUI_LANGUAGE "German" !insertmacro MUI_LANGUAGE "Greek" !insertmacro MUI_LANGUAGE "Hebrew" !insertmacro MUI_LANGUAGE "Hungarian" !insertmacro MUI_LANGUAGE "Icelandic" !insertmacro MUI_LANGUAGE "Indonesian" !insertmacro MUI_LANGUAGE "Irish" !insertmacro MUI_LANGUAGE "Italian" !insertmacro MUI_LANGUAGE "Japanese" !insertmacro MUI_LANGUAGE "Korean" !insertmacro MUI_LANGUAGE "Kurdish" !insertmacro MUI_LANGUAGE "Latvian" !insertmacro MUI_LANGUAGE "Lithuanian" !insertmacro MUI_LANGUAGE "Luxembourgish" !insertmacro MUI_LANGUAGE "Macedonian" !insertmacro MUI_LANGUAGE "Malay" !insertmacro MUI_LANGUAGE "Mongolian" !insertmacro MUI_LANGUAGE "Norwegian" !insertmacro MUI_LANGUAGE "NorwegianNynorsk" !insertmacro MUI_LANGUAGE "Pashto" !insertmacro MUI_LANGUAGE "Polish" !insertmacro MUI_LANGUAGE "Portuguese" !insertmacro MUI_LANGUAGE "PortugueseBR" !insertmacro MUI_LANGUAGE "Romanian" !insertmacro MUI_LANGUAGE "Russian" !insertmacro MUI_LANGUAGE "ScotsGaelic" !insertmacro MUI_LANGUAGE "Serbian" !insertmacro MUI_LANGUAGE "SerbianLatin" !insertmacro MUI_LANGUAGE "SimpChinese" !insertmacro MUI_LANGUAGE "Slovak" !insertmacro MUI_LANGUAGE "Slovenian" !insertmacro MUI_LANGUAGE "Spanish" !insertmacro MUI_LANGUAGE "SpanishInternational" !insertmacro MUI_LANGUAGE "Swedish" !insertmacro MUI_LANGUAGE "Tatar" !insertmacro MUI_LANGUAGE "Thai" !insertmacro MUI_LANGUAGE "TradChinese" !insertmacro MUI_LANGUAGE "Turkish" !insertmacro MUI_LANGUAGE "Ukrainian" !insertmacro MUI_LANGUAGE "Uzbek" !insertmacro MUI_LANGUAGE "Vietnamese" !insertmacro MUI_LANGUAGE "Welsh" ;-------------------------------- ;Reserve Files ;These files should be inserted before other files in the data block ;Keep these lines before any File command ;Only for solid compression (by default, solid compression is enabled for BZIP2 and LZMA) ReserveFile "NSIS.InstallOptions.ini" !insertmacro MUI_RESERVEFILE_INSTALLOPTIONS ; for UserInfo::GetName and UserInfo::GetAccountType ReserveFile /plugin 'UserInfo.dll' ;-------------------------------- ; Installation types @CPACK_NSIS_INSTALLATION_TYPES@ ;-------------------------------- ; Component sections @CPACK_NSIS_COMPONENT_SECTIONS@ @CPACK_NSIS_INSTALLER_MUI_COMPONENTS_DESC@ ;-------------------------------- ;Installer Sections Section "-Core installation" ;Use the entire tree produced by the INSTALL target. Keep the ;list of directories here in sync with the RMDir commands below. SetOutPath "$INSTDIR" @CPACK_NSIS_EXTRA_PREINSTALL_COMMANDS@ @CPACK_NSIS_FULL_INSTALL@ ;Store installation folder WriteRegStr SHCTX "Software\@CPACK_PACKAGE_VENDOR@\@CPACK_PACKAGE_INSTALL_REGISTRY_KEY@" "" $INSTDIR ;Create uninstaller WriteUninstaller "$INSTDIR\@CPACK_NSIS_UNINSTALL_NAME@.exe" Push "DisplayName" Push "@CPACK_NSIS_DISPLAY_NAME@" Call ConditionalAddToRegistry Push "DisplayVersion" Push "@CPACK_PACKAGE_VERSION@" Call ConditionalAddToRegistry Push "Publisher" Push "@CPACK_PACKAGE_VENDOR@" Call ConditionalAddToRegistry Push "UninstallString" Push "$\"$INSTDIR\@CPACK_NSIS_UNINSTALL_NAME@.exe$\"" Call ConditionalAddToRegistry Push "NoRepair" Push "1" Call ConditionalAddToRegistry !ifdef CPACK_NSIS_ADD_REMOVE ;Create add/remove functionality Push "ModifyPath" Push "$INSTDIR\AddRemove.exe" Call ConditionalAddToRegistry !else Push "NoModify" Push "1" Call ConditionalAddToRegistry !endif ; Optional registration Push "DisplayIcon" Push "$INSTDIR\@CPACK_NSIS_INSTALLED_ICON_NAME@" Call ConditionalAddToRegistry Push "HelpLink" Push "@CPACK_NSIS_HELP_LINK@" Call ConditionalAddToRegistry Push "URLInfoAbout" Push "@CPACK_NSIS_URL_INFO_ABOUT@" Call ConditionalAddToRegistry Push "Contact" Push "@CPACK_NSIS_CONTACT@" Call ConditionalAddToRegistry !insertmacro MUI_INSTALLOPTIONS_READ $INSTALL_DESKTOP "NSIS.InstallOptions.ini" "Field 5" "State" !insertmacro MUI_STARTMENU_WRITE_BEGIN Application ;Create shortcuts CreateDirectory "$SMPROGRAMS\$STARTMENU_FOLDER" @CPACK_NSIS_CREATE_ICONS@ @CPACK_NSIS_CREATE_ICONS_EXTRA@ CreateShortCut "$SMPROGRAMS\$STARTMENU_FOLDER\Uninstall.lnk" "$INSTDIR\@CPACK_NSIS_UNINSTALL_NAME@.exe" ;Read a value from an InstallOptions INI file !insertmacro MUI_INSTALLOPTIONS_READ $DO_NOT_ADD_TO_PATH "NSIS.InstallOptions.ini" "Field 2" "State" !insertmacro MUI_INSTALLOPTIONS_READ $ADD_TO_PATH_ALL_USERS "NSIS.InstallOptions.ini" "Field 3" "State" !insertmacro MUI_INSTALLOPTIONS_READ $ADD_TO_PATH_CURRENT_USER "NSIS.InstallOptions.ini" "Field 4" "State" ; Write special uninstall registry entries Push "StartMenu" Push "$STARTMENU_FOLDER" Call ConditionalAddToRegistry Push "DoNotAddToPath" Push "$DO_NOT_ADD_TO_PATH" Call ConditionalAddToRegistry Push "AddToPathAllUsers" Push "$ADD_TO_PATH_ALL_USERS" Call ConditionalAddToRegistry Push "AddToPathCurrentUser" Push "$ADD_TO_PATH_CURRENT_USER" Call ConditionalAddToRegistry Push "InstallToDesktop" Push "$INSTALL_DESKTOP" Call ConditionalAddToRegistry !insertmacro MUI_STARTMENU_WRITE_END detailPrint "Installing InspIRCd service..." nsExec::Exec /TIMEOUT=30000 '"$INSTDIR\inspircd.exe" --installservice' @CPACK_NSIS_EXTRA_INSTALL_COMMANDS@ SectionEnd Section "-Add to path" Push $INSTDIR\bin StrCmp "@CPACK_NSIS_MODIFY_PATH@" "ON" 0 doNotAddToPath StrCmp $DO_NOT_ADD_TO_PATH "1" doNotAddToPath 0 Call AddToPath doNotAddToPath: SectionEnd ;-------------------------------- ; Create custom pages Function InstallOptionsPage !insertmacro MUI_HEADER_TEXT "Install Options" "Choose options for installing @CPACK_NSIS_PACKAGE_NAME@" !insertmacro MUI_INSTALLOPTIONS_DISPLAY "NSIS.InstallOptions.ini" FunctionEnd ;-------------------------------- ; determine admin versus local install Function un.onInit ClearErrors UserInfo::GetName IfErrors noLM Pop $0 UserInfo::GetAccountType Pop $1 StrCmp $1 "Admin" 0 +3 SetShellVarContext all ;MessageBox MB_OK 'User "$0" is in the Admin group' Goto done StrCmp $1 "Power" 0 +3 SetShellVarContext all ;MessageBox MB_OK 'User "$0" is in the Power Users group' Goto done noLM: ;Get installation folder from registry if available done: FunctionEnd ;--- Add/Remove callback functions: --- !macro SectionList MacroName ;This macro used to perform operation on multiple sections. ;List all of your components in following manner here. @CPACK_NSIS_COMPONENT_SECTION_LIST@ !macroend Section -FinishComponents ;Removes unselected components and writes component status to registry !insertmacro SectionList "FinishSection" !ifdef CPACK_NSIS_ADD_REMOVE ; Get the name of the installer executable System::Call 'kernel32::GetModuleFileNameA(i 0, t .R0, i 1024) i r1' StrCpy $R3 $R0 ; Strip off the last 13 characters, to see if we have AddRemove.exe StrLen $R1 $R0 IntOp $R1 $R0 - 13 StrCpy $R2 $R0 13 $R1 StrCmp $R2 "AddRemove.exe" addremove_installed ; We're not running AddRemove.exe, so install it CopyFiles $R3 $INSTDIR\AddRemove.exe addremove_installed: !endif SectionEnd ;--- End of Add/Remove callback functions --- ;-------------------------------- ; Component dependencies Function .onSelChange !insertmacro SectionList MaybeSelectionChanged FunctionEnd ;-------------------------------- ;Uninstaller Section Section "Uninstall" DetailPrint "Uninstalling InspIRCd service..." nsExec::Exec /TIMEOUT=30000 '"$INSTDIR\inspircd.exe" --removeservice' ReadRegStr $START_MENU SHCTX \ "Software\Microsoft\Windows\CurrentVersion\Uninstall\@CPACK_PACKAGE_INSTALL_REGISTRY_KEY@" "StartMenu" ;MessageBox MB_OK "Start menu is in: $START_MENU" ReadRegStr $DO_NOT_ADD_TO_PATH SHCTX \ "Software\Microsoft\Windows\CurrentVersion\Uninstall\@CPACK_PACKAGE_INSTALL_REGISTRY_KEY@" "DoNotAddToPath" ReadRegStr $ADD_TO_PATH_ALL_USERS SHCTX \ "Software\Microsoft\Windows\CurrentVersion\Uninstall\@CPACK_PACKAGE_INSTALL_REGISTRY_KEY@" "AddToPathAllUsers" ReadRegStr $ADD_TO_PATH_CURRENT_USER SHCTX \ "Software\Microsoft\Windows\CurrentVersion\Uninstall\@CPACK_PACKAGE_INSTALL_REGISTRY_KEY@" "AddToPathCurrentUser" ;MessageBox MB_OK "Add to path: $DO_NOT_ADD_TO_PATH all users: $ADD_TO_PATH_ALL_USERS" ReadRegStr $INSTALL_DESKTOP SHCTX \ "Software\Microsoft\Windows\CurrentVersion\Uninstall\@CPACK_PACKAGE_INSTALL_REGISTRY_KEY@" "InstallToDesktop" ;MessageBox MB_OK "Install to desktop: $INSTALL_DESKTOP " @CPACK_NSIS_EXTRA_UNINSTALL_COMMANDS@ ;Remove files we installed. ;Keep the list of directories here in sync with the File commands above. @CPACK_NSIS_DELETE_FILES@ @CPACK_NSIS_DELETE_DIRECTORIES@ !ifdef CPACK_NSIS_ADD_REMOVE ;Remove the add/remove program Delete "$INSTDIR\AddRemove.exe" !endif ;Remove the uninstaller itself. Delete "$INSTDIR\@CPACK_NSIS_UNINSTALL_NAME@.exe" DeleteRegKey SHCTX "Software\Microsoft\Windows\CurrentVersion\Uninstall\@CPACK_PACKAGE_INSTALL_REGISTRY_KEY@" ;Remove the installation directory if it is empty. RMDir "$INSTDIR" ; Remove the registry entries. DeleteRegKey SHCTX "Software\@CPACK_PACKAGE_VENDOR@\@CPACK_PACKAGE_INSTALL_REGISTRY_KEY@" ; Removes all optional components !insertmacro SectionList "RemoveSection_CPack" !insertmacro MUI_STARTMENU_GETFOLDER Application $MUI_TEMP Delete "$SMPROGRAMS\$MUI_TEMP\Uninstall.lnk" @CPACK_NSIS_DELETE_ICONS@ @CPACK_NSIS_DELETE_ICONS_EXTRA@ ;Delete empty start menu parent directories StrCpy $MUI_TEMP "$SMPROGRAMS\$MUI_TEMP" startMenuDeleteLoop: ClearErrors RMDir $MUI_TEMP GetFullPathName $MUI_TEMP "$MUI_TEMP\.." IfErrors startMenuDeleteLoopDone StrCmp "$MUI_TEMP" "$SMPROGRAMS" startMenuDeleteLoopDone startMenuDeleteLoop startMenuDeleteLoopDone: ; If the user changed the shortcut, then uninstall may not work. This should ; try to fix it. StrCpy $MUI_TEMP "$START_MENU" Delete "$SMPROGRAMS\$MUI_TEMP\Uninstall.lnk" @CPACK_NSIS_DELETE_ICONS_EXTRA@ ;Delete empty start menu parent directories StrCpy $MUI_TEMP "$SMPROGRAMS\$MUI_TEMP" secondStartMenuDeleteLoop: ClearErrors RMDir $MUI_TEMP GetFullPathName $MUI_TEMP "$MUI_TEMP\.." IfErrors secondStartMenuDeleteLoopDone StrCmp "$MUI_TEMP" "$SMPROGRAMS" secondStartMenuDeleteLoopDone secondStartMenuDeleteLoop secondStartMenuDeleteLoopDone: DeleteRegKey /ifempty SHCTX "Software\@CPACK_PACKAGE_VENDOR@\@CPACK_PACKAGE_INSTALL_REGISTRY_KEY@" Push $INSTDIR\bin StrCmp $DO_NOT_ADD_TO_PATH_ "1" doNotRemoveFromPath 0 Call un.RemoveFromPath doNotRemoveFromPath: SectionEnd ;-------------------------------- ; determine admin versus local install ; Is install for "AllUsers" or "JustMe"? ; Default to "JustMe" - set to "AllUsers" if admin or on Win9x ; This function is used for the very first "custom page" of the installer. ; This custom page does not show up visibly, but it executes prior to the ; first visible page and sets up $INSTDIR properly... ; Choose different default installation folder based on SV_ALLUSERS... ; "Program Files" for AllUsers, "My Documents" for JustMe... Function .onInit StrCmp "@CPACK_NSIS_ENABLE_UNINSTALL_BEFORE_INSTALL@" "ON" 0 inst ReadRegStr $0 HKLM "Software\Microsoft\Windows\CurrentVersion\Uninstall\@CPACK_PACKAGE_INSTALL_REGISTRY_KEY@" "UninstallString" StrCmp $0 "" inst MessageBox MB_YESNOCANCEL|MB_ICONEXCLAMATION \ "@CPACK_NSIS_PACKAGE_NAME@ is already installed. $\n$\nDo you want to uninstall the old version before installing the new one?" \ /SD IDYES IDYES uninst IDNO inst Abort ;Run the uninstaller uninst: ClearErrors # $0 should _always_ be quoted, however older versions of CMake did not # do this. We'll conditionally remove the begin/end quotes. # Remove first char if quote StrCpy $2 $0 1 0 # copy first char StrCmp $2 "$\"" 0 +2 # if char is quote StrCpy $0 $0 "" 1 # remove first char # Remove last char if quote StrCpy $2 $0 1 -1 # copy last char StrCmp $2 "$\"" 0 +2 # if char is quote StrCpy $0 $0 -1 # remove last char StrLen $2 "\@CPACK_NSIS_UNINSTALL_NAME@.exe" StrCpy $3 $0 -$2 # remove "\@CPACK_NSIS_UNINSTALL_NAME@.exe" from UninstallString to get path ExecWait '"$0" /S _?=$3' ;Do not copy the uninstaller to a temp file IfErrors uninst_failed inst uninst_failed: MessageBox MB_OK|MB_ICONSTOP "Uninstall failed." Abort inst: ; Reads components status for registry !insertmacro SectionList "InitSection" ; check to see if /D has been used to change ; the install directory by comparing it to the ; install directory that is expected to be the ; default StrCpy $IS_DEFAULT_INSTALLDIR 0 StrCmp "$INSTDIR" "@CPACK_NSIS_INSTALL_ROOT@\@CPACK_PACKAGE_INSTALL_DIRECTORY@" 0 +2 StrCpy $IS_DEFAULT_INSTALLDIR 1 StrCpy $SV_ALLUSERS "JustMe" ; if default install dir then change the default ; if it is installed for JustMe StrCmp "$IS_DEFAULT_INSTALLDIR" "1" 0 +2 StrCpy $INSTDIR "$DOCUMENTS\@CPACK_PACKAGE_INSTALL_DIRECTORY@" ClearErrors UserInfo::GetName IfErrors noLM Pop $0 UserInfo::GetAccountType Pop $1 StrCmp $1 "Admin" 0 +4 SetShellVarContext all ;MessageBox MB_OK 'User "$0" is in the Admin group' StrCpy $SV_ALLUSERS "AllUsers" Goto done StrCmp $1 "Power" 0 +3 SetShellVarContext all ;MessageBox MB_OK 'User "$0" is in the Power Users group' StrCpy $SV_ALLUSERS "AllUsers" Goto done noLM: StrCpy $SV_ALLUSERS "AllUsers" ;Get installation folder from registry if available done: StrCmp $SV_ALLUSERS "AllUsers" 0 +3 StrCmp "$IS_DEFAULT_INSTALLDIR" "1" 0 +2 StrCpy $INSTDIR "@CPACK_NSIS_INSTALL_ROOT@\@CPACK_PACKAGE_INSTALL_DIRECTORY@" StrCmp "@CPACK_NSIS_MODIFY_PATH@" "ON" 0 noOptionsPage !insertmacro MUI_INSTALLOPTIONS_EXTRACT "NSIS.InstallOptions.ini" noOptionsPage: FunctionEnd �������������������������������������������inspircd-4.7.0/win/build.ps1������������������������������������������������������������������������0000664�0000000�0000000�00000000270�14771603147�0015667�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������cd $PSScriptRoot/build conan install --build=missing .. cmake .. -A x64 -D CMAKE_BUILD_TYPE=Release msbuild PACKAGE.vcxproj /P:Configuration=Release /P:Platform=x64 /VERBOSITY:MINIMAL ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/win/build/���������������������������������������������������������������������������0000775�0000000�0000000�00000000000�14771603147�0015243�5����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/win/build/.gitignore�����������������������������������������������������������������0000664�0000000�0000000�00000000002�14771603147�0017223�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������* ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/win/conanfile.txt��������������������������������������������������������������������0000664�0000000�0000000�00000001237�14771603147�0016646�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������# Last updated: 2024-06-19 # # Modules we can't legally ship: geo_maxmind, ssl_openssl # Modules which don't apply to Windows: sslrehashsignal # Modules without packages: ssl_gnutls [requires] argon2/20190702 ## libmaxminddb/1.10.0 libmysqlclient/8.1.0 libpq/15.5 libpsl/0.21.1 ## openssl/3.3.2 pcre2/10.44 re2/20240702 sqlite3/3.47.0 yyjson/0.10.0 [options] argon2:shared=True libmaxminddb:shared=True libmysqlclient:shared=True libpq:shared=True libpsl:shared=True openssl:shared=True pcre2:shared=True re2:shared=True sqlite3:shared=True yyjson:shared=True [imports] ., *.dll -> extradll @ keep_path=False ., *.lib -> extralib @ keep_path=False [generators] cmake �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/win/inspircd.ico���������������������������������������������������������������������0000664�0000000�0000000�00000035356�14771603147�0016467�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�������������������������������������������������������������������������������������������������������������������������������������������������������������������������������� �h��6��� ���� �Ј��ž��00���� �Ј%��F��(������ ���� �����@������������������=3+<3*=3*Ћ=3*Ћ=3*Ћ=3*Ћ=3*Ћ=3*Ћ=3*Ћ=3*Ћ=3*Ћ=3*Ћ=3*Ћ=3*Ћ<3*=3+<3*=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ<3*=3*Ћ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3*Ћ=3*Ћ=3+џ=2)џ=3*џ=2*џ=2*џ=2)џ=3+џ=2(џ=2*џ=2*џ=2)џ=2*џ=3+џ=3+џ=3*Ћ=3*Ћ=2(џ:=›џ<6Lџ;:tџ;:tџ<8[џ;8bџ9@Кџ:=™џ;8_џ9?Дџ:>Јџ<5Cџ=3+џ=3*Ћ=3*Ћ=2'џ9AХџ<7Zџ9AХџ8Cрџ<5?џ9BЮџ<3/џ<6Pџ;:uџ;:|џ<6Mџ9@Нџ=2(џ=3*Ћ=3*Ћ=2*џ<6Qџ<7Yџ:>Єџ;;‚џ:<’џ9BЮџ<4:џ;8bџ;:vџ:;ƒџ;7Zџ9@Зџ=2(џ=3*Ћ=3*Ћ=2(џ:;џ<5Fџ:>Ѓџ:>Ÿџ<4Aџ<7Vџ8>Њџ:;‡џ;7Vџ:>Ђџ:=—џ<4<џ=3+џ=3*Ћ=3*Ћ;0(џ”ŠџSJCџxrџE<4џЃŸ›џ^UOџЎЊІџЇЂŸџNE>џ‹†€џ;1)џ=3+џ=3+џ=3*Ћ=3*Ћ9/'џЫШЦџaYSџІЁžџВЏЋџронџPG@џc[UџИЕВџzuџваЮџˆ‚}џSJCџ=3+џ=3*Ћ=3*Ћ<2*џf^XџaXRџпнлџЂžšџШХУџtmhџТПМџ€ytџKB;џЦФСџpicџСОМџ:0(џ=3*Ћ=3*Ћ:0(џ”‹џWNHџМИЕџ=3+џЌЈЄџWNGџНКИџНКЗџVMFџЦТРџОЛИџ|upџ<2*џ=3*Ћ=3*Ћ=3+џ:0(џ<2*џ:0(џ=3+џ:0(џ=3+џ:0'џ:0(џ<2*џ:/'џ:/'џ<2*џ=3+џ=3*Ћ=3*Ћ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3*Ћ<3*=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ<3*=3+<3*=3*Ћ=3*Ћ=3*Ћ=3*Ћ=3*Ћ=3*Ћ=3*Ћ=3*Ћ=3*Ћ=3*Ћ=3*Ћ=3*Ћ<3*=3+��џџ��џџ��џџ��џџ��џџ��џџ��џџ��џџ��џџ��џџ��џџ��џџ��џџ��џџ��џџ��џџ(��� ���@���� �����€������������������џџџџџџ=3+=3*U=3*U=3*U=3*U=3*U=3*U=3*U=3*U=3*U=3*U=3*U=3*U=3*U=3*U=3*U=3*U=3*U=3*U=3*U=3*U=3*U=3*U=3*U=3*U=3*U=3*U=3+џџџџџџџџџ=3+q=3+Ч=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+Ч=3+qџџџ=3+=3+Ч=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+Ч=3+=3*U=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3*U=3*U=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3*U=3*U=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3*U=3*U=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3*U=3*U=3+џ=3+џ=3+џ=2(џ=2'џ=3+џ=3)џ=2'џ=3*џ=3*џ=2(џ=2'џ=3*џ=3+џ=3+џ=2&џ=2$џ=2'џ=3*џ=3*џ=2(џ=2'џ=2'џ=2(џ=3*џ=3+џ=3+џ=3+џ=3+џ=3+џ=3*U=3*U=3+џ=3+џ=2'џ<8aџ;:zџ=3,џ<6Qџ;:wџ<47џ<3/џ;9jџ;:qџ<44џ=2)џ<5Cџ;;…џ:=šџ;:zџ<4=џ<3,џ;8dџ;;~џ;;џ;:wџ;7Yџ=2,џ=2*џ=3+џ=3+џ=3+џ=3*U=3*U=3+џ=3+џ=2#џ:>Њџ8Dцџ=3.џ;;†џ8Dмџ<6Hџ<7Uџ8Cсџ:>šџ<3,џ<6Rџ9BШџ8Eэџ8Cнџ8Eьџ9AСџ<4:џ9?Вџ8Dюџ8Dцџ8Dъџ8Dцџ;;‰џ<3/џ=3+џ=3+џ=3+џ=3*U=3*U=3+џ=3+џ=2"џ:>Ќџ8Dчџ=3.џ;;†џ8Dсџ<8`џ9AУџ8Cоџ=30џ=2%џ9AШџ8Cуџ<5Hџ=3)џ<8^џ;<џ<4;џ9?Гџ9AТџ<4;џ<5<џ:=•џ8D№џ;:rџ=2(џ=3+џ=3+џ=3*U=3*U=3+џ=3+џ=2$џ:=œџ8Dчџ=3.џ;;†џ8Eѓџ8Dтџ8Eєџ8Dъџ;:oџ=47џ8Dьџ:>Ёџ=2"џ=3*џ=2*џ=3*џ<3/џ9@Дџ9AРџ<43џ=2&џ<5>џ8D№џ:> џ=2$џ=3+џ=3+џ=3*U=3*U=3+џ=3+џ=3+џ<30џ;;џ=3/џ;;‡џ8Dтџ;9kџ<7Xџ9@Зџ8Cйџ<7Pџ8Dщџ:?Љџ=2"џ=2(џ=3+џ=3/џ<3/џ9@Дџ9AПџ<31џ=2%џ<5Cџ8Eёџ:>œџ=2$џ=3+џ=3+џ=3*U=3*U=3+џ=3+џ=2'џ;8_џ<47џ=2(џ;;‡џ8Dсџ;8bџ<6Lџ:?­џ8Cмџ<5Cџ:@Лџ8Dыџ<8eџ=48џ;:}џ:?Аџ<5Bџ9?Гџ9BШџ<7Tџ<7Wџ9?Љџ8Eъџ;9eџ=2)џ=3+џ=3+џ=3*U=3*U=3+џ=3+џ=2#џ:>Ѕџ9@Вџ=2(џ;:ƒџ8Eыџ8Dъџ8Dъџ8Dфџ;;„џ=2,џ<5Dџ9?Еџ8Eыџ8Dъџ8Dшџ:?Јџ<44џ9?­џ8Dшџ8Dыџ8Dшџ8Cиџ;:qџ=3+џ=3+џ=3+џ=3+џ=3*U=3*U=3+џ=3+џ=2)џ;5Jџ;7Zџ=3+џ<4Aџ;7\џ<7\џ<8\џ<6Qџ<2-џ<2)џ=3)џ<47џ:7aџ87sџ95Yџ<32џ<3+џ<6Mџ;6[џ;7\џ<7Wџ<5Dџ=2)џ=2*џ=3+џ=3+џ=3+џ=3*U=3*U=3+џ=3+џ;1)џ\SLџld^џ>4,џPF?џld^џH?7џ<2)џ<2*џha[џia[џ=3+џF<5џme^џ‚{sџ|unџ]UNџ;1)џD;3џnf`џRIAџ;1)џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3*U=3*U=3+џ=3+џ6,$џЉЅЁџсроџA70џxsџспоџe]Wџ9/'џd\VџцхуџждвџH?7џЌЈЄџщшчџтспџхфуџпнлџb[UџVNGџшшцџ†€zџ9/'џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3*U=3*U=3+џ=3+џ6+#џ­ЉЅџшцхџA80џzvџщччџe]WџYQJџгбЯџюэьџлкиџA80џ†€{џmf`џC92џcZTџкйзџАЌЉџ]UNџяюэџŠ…џE<4џG>6џ=3+џ<2*џ=3+џ=3+џ=3+џ=3*U=3*U=3+џ=3+џ6+#џЎЊІџщшчџA80џzvџшчцџbZTџГЏЌџъщшџкижџмкйџ?5-џ:0(џWNHџ‡€{џЗГАџэььџœ—“џZRKџяюэџкижџЬЪШџЧХУџ‹†џC92џ=3+џ=3+џ=3+џ=3*U=3*U=3+џ=3+џ<2*џULEџБ­ЉџB91џzvџщшчџЕВЏџяюэџ•ŒџЏЋЈџпнмџ?5-џ‹…€џюэьџфутџЬЩЧџ˜“Žџ@6/џXPIџяяюџЖВЏџŠ„џЌЈЅџюэьџ‡|џ9/'џ=3+џ=3+џ=3*U=3*U=3+џ=3+џ;1)џJA9џI?8џ<3+џ‚{wџё№яџьыъџРНЛџE;4џДА­џпнмџG=6џРНКџвЯЮџc[TџG=6џTLDџ<2*џYQJџяяюџ†€{џ1'џ[RKџ№яяџ ›—џ7,$џ=3+џ=3+џ=3*U=3*U=3+џ=3+џ6+#џЉЄЁџ“‰џ8.&џƒ|xџѕєєџронџQHAџ2( џЖВЏџспоџA7/џ˜’ŽџшшцџРМКџЦУСџэьыџme_џWOHџђёёџрпнџегвџусрџмкиџib\џ;1)џ=3+џ=3+џ=3*U=3*U=3+џ=3+џ9.&џ}vqџš•‘џ>4,џd[UџЄŸœџunhџ9/'џ8.&џzuџ™“џ=3+џF<4џ“‰џЛЗЕџЕВЏџŒ†‚џG=6џLC<џЃšџЁœ™џЂžšџ™”џld^џ?5-џ=3+џ=3+џ=3+џ=3*U=3*U=3+џ=3+џ=3+џ9/&џ7,$џ<2*џ:0(џ6,#џ:0'џ=3+џ=3+џ9.&џ7-%џ=3+џ=3+џ8.%џ6,#џ6+#џ9/&џ=3+џ<1)џ7,$џ7,$џ7,$џ7,$џ;1)џ=3+џ=3+џ=3+џ=3+џ=3*U=3*U=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3*U=3*U=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3*U=3*U=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3*U=3*U=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3*U=3+=3+Ч=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+Ч=3+џџџ=3+q=3+Ч=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+Ч=3+qџџџџџџџџџ=3+=3*U=3*U=3*U=3*U=3*U=3*U=3*U=3*U=3*U=3*U=3*U=3*U=3*U=3*U=3*U=3*U=3*U=3*U=3*U=3*U=3*U=3*U=3*U=3*U=3*U=3*U=3+џџџџџџ��������������������������������������������������������������������������������������������������������������������������������(���0���`���� �����€%������������������џџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џџџџџџџџџџџџџџџџџџџ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џџџџџџџџџџџџџ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џџџџџџџџџџ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џџџџџџџ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џџџџџџџ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џџџџџџџ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џџџџџџџ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џџџџџџџ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џџџџџџџ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џџџџџџџ=3+џ=3+џ=3+џ=3+џ=3+џ=3(џ=2%џ=2&џ=3+џ=3+џ=3'џ=2%џ=3(џ=3+џ=3+џ=3*џ=2%џ=2%џ=3'џ=3+џ=3+џ=3+џ=3+џ=2&џ=2!џ=2!џ=2#џ=3*џ=3+џ=3+џ=3*џ=2%џ=2%џ=2%џ=2%џ=2&џ=3(џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џџџџџџџ=3+џ=3+џ=3+џ=3+џ=3)џ=48џ=6Jџ=6Eџ=3,џ=3)џ=5@џ=6Kџ=5<џ=3)џ=3*џ=3+џ=6Fџ=6Kџ=6Cџ=3)џ=3+џ=3'џ=2#џ=6Dџ<9eџ<9jџ=7Tџ=3)џ=2%џ=3+џ=4/џ=6Gџ=6Hџ=6Hџ=6Hџ=6Dџ=45џ=2#џ=2%џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џџџџџџџ=3+џ=3+џ=3+џ=3+џ=2џ;;џ8Fљџ9Dжџ=45џ=2 џ:@Жџ7Gљџ;>™џ=2!џ=2џ<:nџ8Eђџ8Fђџ<:jџ=2#џ=2%џ=44џ;?Їџ8Eыџ8F§џ8Gџџ8Fіџ:AПџ=6Bџ=2џ<6Hџ8Eхџ8Eьџ8Eэџ8Eюџ8Eьџ9Dнџ:?Јџ=5@џ=2#џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џџџџџџџ=3+џ=3+џ=3+џ=3+џ=2џ;;‚џ8Fџџ9Dнџ=45џ=2 џ:@Мџ7Gџџ;>џ=2џ=4/џ9CЮџ7Fџџ:AЕџ=3%џ=3&џ=47џ:BЧџ8Gџџ8Fјџ9Cдџ9BЩџ8Eъџ8Gџџ9Eфџ=5Aџ=5Cџ8Eьџ8Eєџ8Dцџ8Dсџ8Dцџ8Fњџ8Fџџ9Dуџ<7Sџ=2"џ=3+џ=3+џ=3+џ=3+џ=3+џџџџџџџ=3+џ=3+џ=3+џ=3+џ=2џ;;џ8Fџџ9Dлџ=45џ=2 џ:@Кџ7Gџџ;>˜џ>0 џ;<‰џ7Gџџ9Cйџ=5:џ=2&џ=2 џ;>™џ8Fџџ8Eяџ<:tџ=3-џ=3(џ=7Nџ:Cаџ:AКџ=6Cџ=5Cџ8Eыџ8Fѕџ<9aџ=30џ=5;џ<9hџ9Dсџ8Fџџ9BЪџ=4.џ=3)џ=3+џ=3+џ=3+џ=3+џџџџџџџ=3+џ=3+џ=3+џ=3+џ=2џ;;†џ8Fџџ9Dлџ=45џ=2 џ:@Кџ8Fћџ9BЮџ;>œџ9Dтџ8Fњџ:AЙџ=4-џ=2#џ=42џ9Cжџ8Fџџ;>Ёџ=2џ=3(џ=3*џ=2$џ=46џ=3&џ=2 џ<6Iџ8Eыџ8Fѕџ<8Tџ=2џ=3&џ=1џ<:lџ8Eѕџ8Fљџ<9bџ=2"џ=3+џ=3+џ=3+џ=3+џџџџџџџ=3+џ=3+џ=3+џ=3+џ=2"џ<9cџ8Eѓџ9Dтџ=45џ=2 џ:@Кџ8Fїџ8Fјџ7Gџџ8Fћџ8Fјџ8Fјџ:BХџ=4.џ=6Eџ8Eьџ8Fљџ<8^џ=2!џ=3+џ=3+џ=3+џ=3(џ=3*џ=2%џ<6Hџ8Eыџ8Fѕџ<8Wџ=2#џ=3+џ=3&џ=5=џ8Dхџ8F§џ;;|џ=2 џ=3+џ=3+џ=3+џ=3+џџџџџџџ=3+џ=3+џ=3+џ=3+џ=3+џ=2!џ<8\џ:CЬџ=59џ=2 џ:@Кџ8G§џ:AКџ<9jџ<:mџ;>—џ8Eэџ8Fџџ<;џ=5:џ8Eъџ8Fњџ<9fџ=2 џ=3+џ=3+џ=3+џ=2$џ=3'џ=2%џ<6Hџ8Eыџ8Fѕџ<8Wџ=2#џ=3+џ=3%џ=5?џ8Dчџ8F§џ;;yџ=2 џ=3+џ=3+џ=3+џ=3+џџџџџџџ=3+џ=3+џ=3+џ=3+џ=3+џ=3-џ=2џ=5;џ=40џ=2#џ:@Кџ7Gџџ;=”џ=0 џ=1џ>1џ:AНџ7Gџџ:?Ћџ>3"џ:BЬџ7Fџџ:AЗџ=2 џ=2"џ=2%џ=2!џ=7Rџ=59џ=2!џ<6Hџ8Eыџ8Fѕџ<7Pџ=1џ=2 џ=1џ;<џ8Fјџ8Fєџ<8Uџ=2#џ=3+џ=3+џ=3+џ=3+џџџџџџџ=3+џ=3+џ=3+џ=3+џ=2"џ;;zџ<;}џ=1џ=3)џ=2$џ:@Кџ7G§џ:@Гџ<8Zџ<8^џ;;~џ9Dфџ8Gџџ;=Žџ>1џ<<џ8Gџџ8Eіџ;?Ѕџ=7Lџ=5?џ;;џ8Eюџ9Eхџ=7Sџ=5Aџ8Eыџ8Fєџ;<‚џ<8\џ<9dџ;=•џ8Eюџ8Gџџ:@Ўџ=3%џ=3+џ=3+џ=3+џ=3+џ=3+џџџџџџџ=3+џ=3+џ=3+џ=3+џ=2џ;<Šџ7Gџџ;<џ=3'џ=2#џ:@Рџ8Gџџ8Fњџ8Fџџ8Fўџ7Gџџ8Fџџ9Dнџ=5>џ=2%џ=3*џ;?Єџ8Fўџ7Gџџ8Eёџ8Eъџ8Fўџ8Gџџ:BСџ=43џ<6Fџ8Fђџ8Fљџ8F§џ8Fџџ8Gџџ7Gџџ8Fўџ:BТџ=5=џ=3%џ=3+џ=3+џ=3+џ=3+џ=3+џџџџџџџ=3+џ=3+џ=3+џ=3+џ=2"џ<:nџ:Cгџ:BЛџ=42џ=2#џ;>›џ:CЫџ:BФџ:BХџ:BХџ:BТџ:?Їџ=6Jџ=2$џ=3,џ=3'џ=3'џ;;{џ:BУџ9Dфџ8Eщџ9Cдџ;=‘џ=4.џ=2!џ<5Bџ:BРџ:BЦџ:BФџ:BХџ:AТџ:@Бџ;;zџ=3,џ=2%џ=3,џ=3+џ=3+џ=3+џ=3+џ=3+џџџџџџџ=3+џ=3+џ=3+џ=3+џ=3+џ<2)џ<1&џ<2'џ=3+џ=3+џ<2(џ<1&џ<2'џ>3(џ>3)џ=3&џ=2!џ<1$џ;1*џ<2)џ=3+џ=3*џ=2 џ<2&џ:17џ80:џ9/+џ;0џ=3(џ=3,џ=3+џ=3(џ<1&џ<2'џ=3(џ=3&џ=2"џ=2 џ=3)џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џџџџџџџ=3+џ=3+џ=3+џ=3+џ=3+џ>3+џ>4+џ>4+џ=3+џ=3+џ>4+џ>4+џ>4+џ=3*џ=3*џ=3*џ;1(џ;1)џ?5-џ>4,џ=3+џ<2*џ4)!џ9.%џI?4џTJ?џPG=џ@6.џ3)!џ;1)џ=3+џ=3*џ>4+џ>4+џ=3*џ=3*џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џџџџџџџ=3+џ=3+џ=3+џ=3+џ5*"џztnџждвџТПНџH?7џ3( џ–ŒџйзжџЋІЃџ:0(џ<2*џ:0(џB80џЙЕГџдбаџЖГАџ@6.џ<2*џ{toџСОМџомлџъщшџчхфџбЯЭџ”‹џ>5-џ4)!џd\VџваЮџЩЦФџULDџ8.&џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џџџџџџџ=3+џ=3+џ=3+џ=3+џ3( џ‹…€џџџўџцфуџJA;џ1&џЎЉІџџџџџШФТџ9/'џ<2*џ2( џš”џљљјџїїіџжегџ9/'џvojџќќќџўўўџяююџйижџтрпџїііџќћћџœ˜”џ-"џngaџљњљџюээџ[RKџ7-%џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џџџџџџџ=3+џ=3+џ=3+џ=3+џ3( џˆ‚}џјјїџронџJA:џ1&џЊЅЂџќќќџУПНџ9/'џ1'џuniџёёяџэьыџ№№яџбЯЭџ>4,џNE>џевбџЅ џ_WPџB81џD:3џЇЃŸџііѕџтсрџE;3џia[џѓѓђџшчцџSIBџ.$џ4*!џ5+"џ:0(џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џџџџџџџ=3+џ=3+џ=3+џ=3+џ3( џ‰ƒ~џјјїџронџJA:џ1&џЊЅЂџќќќџУПНџ3)!џOF?џнмкџѓђёџюэьџ№№яџбЯЭџB80џ9/&џJA:џ0%џ+ џ6,#џ>4-џЁœ˜џѕєєџъщчџNE>џg`Zџѓђёџщшчџ‡€|џogbџslgџia[џH>7џ7-$џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џџџџџџџ=3+џ=3+џ=3+џ=3+џ3( џ†€{џўџўџспоџJA:џ1&џЊЅЂџќќќџСНЛџ3)!џЙЖГџјїїџусрџПЛИџєєѓџбЯЭџB80џ:0(џ3( џYQJџ’ŒˆџСНЛџмкиџёё№џћћћџПЛЙџ2(џkd^џђё№џыъщџјјїџћћћџћћћџѓѓђџнлкџngaџ4*"џ=3+џ=3+џ=3+џ=3+џ=3+џџџџџџџ=3+џ=3+џ=3+џ=3+џ;1)џD:3џЈЃ џъщшџLC<џ1&џЊЅЂџќќќџМЙЖџŠ†џєѓђџјїіџˆƒџˆ‚}џћћћџбЯЭџA7/џ6,#џ“‰џэьыџњњљџ§§§џњњњџъщшџЕБЎџQHAџ0%џle_џђђёџъщшџТОМџЗГАџКЗДџутсџііѕџмкиџKB;џ:0'џ=3+џ=3+џ=3+џ=3+џџџџџџџ=3+џ=3+џ=3+џ=3+џ>4,џ5*"џ6,#џ†€{џKB;џ2'џЊЅЂџїіѕџомлџчцхџїїїџОЛЙџ1&џ‰…џћћћџбЯЭџ<2*џVMFџэьыџђђёџждвџЅЁџŒ…џYQJџ-"џ6,$џ6+#џle_џѓѓђџшчцџSJCџ/$џ.$џqicџюээџііѕџunhџ4)!џ=3+џ=3+џ=3+џ=3+џџџџџџџ=3+џ=3+џ=3+џ=3+џ:0'џ\SLџH?8џ0%џ=3+џ4*"џЊЅЂџѕєѓџэьыџђё№џнмкџSJCџ+ џ’ŒˆџћћћџбЯЭџ:/(џg_Yџђђёџѓђђџogbџ  џ'џ:0(џunhџF<4џ3( џle_џѓѓђџшчцџWNGџ3)!џ4)!џogaџэььџіѕѕџuniџ4)!џ=3+џ=3+џ=3+џ=3+џџџџџџџ=3+џ=3+џ=3+џ=3+џ3( џ’ŒˆџЩЦХџB91џ9/'џ4*"џЊЅЂџѕєѓџэьыџєѓѓџuniџ1'џ2' џ’ŒˆџћћћџбЯЭџ=3,џOE>џхфуџѕѕєџЩЦФџ‡ƒџš•‘џЮЫЩџў§ўџ“‰џ+!џle_џђђёџыъщџЫШЦџУРНџХТРџфтсџіѕєџмкйџJA:џ:0'џ=3+џ=3+џ=3+џ=3+џџџџџџџ=3+џ=3+џ=3+џ=3+џ3'џŒ†џџџџџЩЧХџA7/џ2'џЏЊЇџў§§џљљјџ ›˜џ5*"џ<2*џ2&џ–ŒџџџџџиждџB80џ4)!џysmџчцхџќќќџџџџџџџџџћњњџхфуџƒ|wџ.#џngaџњљљџѓђђџљљјџњњњџњњњџѕѕєџспоџngaџ5*"џ=3+џ=3+џ=3+џ=3+џ=3+џџџџџџџ=3+џ=3+џ=3+џ=3+џ:/'џVMGџ|upџyrlџC91џ9.&џaYSџ{toџumhџ@6.џ:0(џ=3+џ9/'џYQJџ}vqџogaџ?5-џ<2*џ6+#џTKDџŠ„€џЂ™џ˜”џ|vpџMD=џ6,$џ:0(џMD=џzrmџwpkџwpkџwpkџxqkџngaџMC<џ6,$џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џџџџџџџ=3+џ=3+џ=3+џ=3+џ>4,џ9/'џ3) џ5*"џ<2*џ>4,џ7-%џ3) џ4*!џ;1)џ=3+џ=3+џ>4,џ9.&џ3) џ5+#џ=3+џ=3+џ=3+џ8.%џ3( џ3) џ3( џ3)!џ9/&џ=3+џ=4,џ;0(џ4)!џ4)!џ4)!џ4)!џ4)!џ5*"џ9/'џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џџџџџџџ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џџџџџџџ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џџџџџџџ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џџџџџџџ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џџџџџџџ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џџџџџџџ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џџџџџџџ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џџџџџџџџџџ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џџџџџџџџџџџџџ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џџџџџџџџџџџџџџџџџџџ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џ=3+џџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџ������џџ������џџ������џџ������џџ������џџ������џџ������џџ������џџ������џџ������џџ������џџ������џџ������џџ������џџ������џџ������џџ������џџ������џџ������џџ������џџ������џџ������џџ������џџ������џџ������џџ������џџ������џџ������џџ������џџ������џџ������џџ������џџ������џџ������џџ������џџ������џџ������џџ������џџ������џџ������џџ������џџ������џџ������џџ������џџ������џџ������џџ������џџ������џџ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/win/inspircd.rc.cmake����������������������������������������������������������������0000664�0000000�0000000�00000002022�14771603147�0017360�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������101 ICON "inspircd.ico" 1 VERSIONINFO FILEVERSION @VERSION_MAJOR@,@VERSION_MINOR@,@VERSION_PATCH@ PRODUCTVERSION @VERSION_MAJOR@,@VERSION_MINOR@,@VERSION_PATCH@ FILEFLAGSMASK 0x3fL #ifdef _DEBUG FILEFLAGS 0x1L #else FILEFLAGS 0x0L #endif FILEOS 0x40004L FILETYPE 0x1L FILESUBTYPE 0x0L BEGIN BLOCK "StringFileInfo" BEGIN BLOCK "040904b0" BEGIN VALUE "Comments", "InspIRCd @VERSION_MAJOR@.@VERSION_MINOR@ IRC Daemon" VALUE "CompanyName", "InspIRCd Development Team" VALUE "FileDescription", "InspIRCd" VALUE "FileVersion", "@FULL_VERSION@" VALUE "InternalName", "InspIRCd" VALUE "LegalCopyright", "Copyright (C) InspIRCd Development Team" VALUE "OriginalFilename", "inspircd.exe" VALUE "ProductName", "InspIRCd - Internet Relay Chat Daemon" VALUE "ProductVersion", "@FULL_VERSION@" END END BLOCK "VarFileInfo" BEGIN VALUE "Translation", 0x809, 1200 END END ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/win/modules/�������������������������������������������������������������������������0000775�0000000�0000000�00000000000�14771603147�0015614�5����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/win/modules/CMakeLists.txt�����������������������������������������������������������0000664�0000000�0000000�00000006451�14771603147�0020362�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������# # InspIRCd -- Internet Relay Chat Daemon # # Copyright (C) 2021-2024 Sadie Powell <sadie@witchery.services> # Copyright (C) 2013-2014 Attila Molnar <attilamolnar@hush.com> # Copyright (C) 2013 Adam <Adam@anope.org> # # This file is part of InspIRCd. InspIRCd is free software: you can # redistribute it and/or modify it under the terms of the GNU General Public # License as published by the Free Software Foundation, version 2. # # This program is distributed in the hope that it will be useful, but WITHOUT # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS # FOR A PARTICULAR PURPOSE. See the GNU General Public License for more # details. # # You should have received a copy of the GNU General Public License # along with this program. If not, see <http://www.gnu.org/licenses/>. # # These modules can always be built on all platforms file(GLOB INSPIRCD_MODULES "${INSPIRCD_BASE}/src/coremods/core_*" "${INSPIRCD_BASE}/src/modules/m_*") # These modules have their dependencies provided by Windows list(APPEND INSPIRCD_MODULES "${INSPIRCD_BASE}/src/modules/extra/m_ldap.cpp") if(EXISTS "${CMAKE_BINARY_DIR}/conanbuildinfo.cmake") include("${CMAKE_BINARY_DIR}/conanbuildinfo.cmake") function(enable_extra NAME PACKAGE) if(DEFINED "CONAN_${PACKAGE}_ROOT") message("Enabling the ${NAME} module") list(APPEND INSPIRCD_MODULES "${INSPIRCD_BASE}/src/modules/extra/m_${NAME}.cpp") set(INSPIRCD_MODULES ${INSPIRCD_MODULES} PARENT_SCOPE) else() message("Unable to enable the ${NAME} module (missing library)") endif() endfunction() enable_extra("argon2" "ARGON2") enable_extra("geo_maxmind" "LIBMAXMINDDB") enable_extra("log_json" "YYJSON") enable_extra("mysql" "LIBMYSQLCLIENT") enable_extra("pgsql" "LIBPQ") enable_extra("regex_pcre2" "PCRE2") enable_extra("regex_posix" "PCRE2") enable_extra("regex_re2" "RE2") enable_extra("ssl_openssl" "OPENSSL") enable_extra("sqlite3" "SQLITE3") link_directories("${CMAKE_BINARY_DIR}/extradll" "${CMAKE_BINARY_DIR}/extralib") file(GLOB EXTRA_DLLS "${CMAKE_BINARY_DIR}/extradll/*.dll") install(FILES ${EXTRA_DLLS} DESTINATION .) conan_basic_setup(TARGETS) else() message("Unable to build extras: conanbuildinfo.cmake does not exist in the build directory!") endif() list(SORT INSPIRCD_MODULES) foreach(MODULE_NAME ${INSPIRCD_MODULES}) if(IS_DIRECTORY "${MODULE_NAME}") string(REGEX REPLACE "^.*[/\\](.*)$" "\\1" BASE_NAME ${MODULE_NAME}) else() string(REGEX REPLACE "^.*[/\\](.*).cpp$" "\\1" BASE_NAME ${MODULE_NAME}) endif() if(IS_DIRECTORY "${MODULE_NAME}") file(GLOB MODULES_SUBDIR_SRCS "${MODULE_NAME}/*.cpp") list(SORT MODULES_SUBDIR_SRCS) add_library(${BASE_NAME} MODULE ${MODULES_SUBDIR_SRCS}) else() add_library(${BASE_NAME} MODULE ${MODULE_NAME}) endif() # Link against the core and memory library add_dependencies(${BASE_NAME} "inspircd" "win32memory") target_link_libraries(${BASE_NAME} "inspircd" "win32memory") # Link against any dependencies if available if(CONAN_CXX_FLAGS) conan_target_link_libraries(${BASE_NAME}) endif() set_target_properties(${BASE_NAME} PROPERTIES PREFIX "" FOLDER "Modules" COMPILE_DEFINITIONS "FMT_SHARED;MODNAME=\"${BASE_NAME}\"" ) # Set the module to be installed to the module directory install(TARGETS ${BASE_NAME} LIBRARY DESTINATION ${MODULE_DIR}) endforeach() �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/win/win32memory.cpp������������������������������������������������������������������0000664�0000000�0000000�00000004067�14771603147�0017052�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2022, 2025 Sadie Powell <sadie@witchery.services> * Copyright (C) 2013 Adam <Adam@anope.org> * Copyright (C) 2012 Robby <robby@chatbelgie.be> * Copyright (C) 2009 John Brooks <john@jbrooks.io> * Copyright (C) 2007-2008 Craig Edwards <brain@inspircd.org> * Copyright (C) 2007 Robin Burchell <robin+git@viroteck.net> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include <new> #include <windows.h> /** On windows, all dll files and executables have their own private heap, * whereas on POSIX systems, shared objects loaded into an executable share * the executable's heap. This means that if we pass an arbitrary pointer to * a windows DLL which is not allocated in that dll, without some form of * marshalling, we get a page fault. To fix this, these overridden operators * new and delete use the windows HeapAlloc and HeapFree functions to claim * memory from the windows global heap. This makes windows 'act like' POSIX * when it comes to memory usage between dlls and exes. */ void* ::operator new(size_t count) { void* ptr = HeapAlloc(GetProcessHeap(), 0, count); if (!ptr) throw std::bad_alloc(); return ptr; } void ::operator delete(void* ptr) { if (ptr) HeapFree(GetProcessHeap(), 0, ptr); } void* operator new[](size_t count) { void* ptr = HeapAlloc(GetProcessHeap(), 0, count); if (!ptr) throw std::bad_alloc(); return ptr; } void operator delete[] (void* ptr) { if (ptr) HeapFree(GetProcessHeap(), 0, ptr); } �������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/win/win32service.cpp�����������������������������������������������������������������0000664�0000000�0000000�00000017542�14771603147�0017204�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2022-2024 Sadie Powell <sadie@witchery.services> * Copyright (C) 2021 Herman <GermanAizek@yandex.ru> * Copyright (C) 2013 ChrisTX <xpipe@hotmail.de> * Copyright (C) 2012 Robby <robby@chatbelgie.be> * Copyright (C) 2008 Craig Edwards <brain@inspircd.org> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include "inspircd.h" #include <windows.h> static SERVICE_STATUS_HANDLE g_ServiceStatusHandle; static SERVICE_STATUS g_ServiceStatus; static bool g_bRunningAsService; struct Service_Data { DWORD argc; LPSTR* argv; }; static Service_Data g_ServiceData; /** The main part of inspircd runs within this thread function. This allows the service part to run * separately on its own and to be able to kill the worker thread when its time to quit. */ DWORD WINAPI WorkerThread(LPVOID param) { smain(g_ServiceData.argc, g_ServiceData.argv); return 0; } /* This is called when all startup is done */ void SetServiceRunning() { if (!g_bRunningAsService) return; g_ServiceStatus.dwCurrentState = SERVICE_RUNNING; g_ServiceStatus.dwControlsAccepted = SERVICE_ACCEPT_STOP | SERVICE_ACCEPT_SHUTDOWN; if( !SetServiceStatus( g_ServiceStatusHandle, &g_ServiceStatus ) ) throw CWin32Exception(); } /* In windows we hook this to InspIRCd::Exit(EXIT_FAILURE) */ void SetServiceStopped(DWORD dwStatus) { if (!g_bRunningAsService) return; g_ServiceStatus.dwCurrentState = SERVICE_STOPPED; if(dwStatus != EXIT_SUCCESS) { g_ServiceStatus.dwServiceSpecificExitCode = dwStatus; g_ServiceStatus.dwWin32ExitCode = ERROR_SERVICE_SPECIFIC_ERROR; } else { g_ServiceStatus.dwWin32ExitCode = ERROR_SUCCESS; } SetServiceStatus( g_ServiceStatusHandle, &g_ServiceStatus ); } /** This callback is called by windows when the state of the service has been changed */ VOID ServiceCtrlHandler(DWORD controlCode) { switch(controlCode) { case SERVICE_CONTROL_SHUTDOWN: case SERVICE_CONTROL_STOP: g_ServiceStatus.dwCurrentState = SERVICE_STOPPED; SetServiceStatus( g_ServiceStatusHandle, &g_ServiceStatus ); break; } } /** This callback is called by windows when the service is started */ VOID ServiceMain(DWORD argc, LPCSTR* argv) { g_ServiceStatusHandle = RegisterServiceCtrlHandler(TEXT("InspIRCd"), (LPHANDLER_FUNCTION)ServiceCtrlHandler); if( !g_ServiceStatusHandle ) return; g_ServiceStatus.dwCheckPoint = 1; g_ServiceStatus.dwControlsAccepted = 0; g_ServiceStatus.dwServiceType = SERVICE_WIN32_OWN_PROCESS; g_ServiceStatus.dwWaitHint = 5000; g_ServiceStatus.dwWin32ExitCode = NO_ERROR; g_ServiceStatus.dwCurrentState = SERVICE_START_PENDING; if( !SetServiceStatus( g_ServiceStatusHandle, &g_ServiceStatus ) ) return; char szModuleName[MAX_PATH]; if(GetModuleFileNameA(nullptr, szModuleName, MAX_PATH)) { if(!argc) argc = 1; g_ServiceData.argc = argc; // Note: since this memory is going to stay allocated for the rest of the execution, // it doesn't make sense to free it, as it's going to be "freed" on process termination try { g_ServiceData.argv = new char*[argc]; uint32_t allocsize = strnlen_s(szModuleName, MAX_PATH) + 1; g_ServiceData.argv[0] = new char[allocsize]; strcpy_s(g_ServiceData.argv[0], allocsize, szModuleName); for(uint32_t i = 1; i < argc; i++) { allocsize = strnlen_s(argv[i], MAX_PATH) + 1; g_ServiceData.argv[i] = new char[allocsize]; strcpy_s(g_ServiceData.argv[i], allocsize, argv[i]); } *(strrchr(szModuleName, '\\') + 1) = '\0'; SetCurrentDirectoryA(szModuleName); HANDLE hThread = CreateThread(nullptr, 0, (LPTHREAD_START_ROUTINE)WorkerThread, nullptr, 0, nullptr); if (hThread != nullptr) { WaitForSingleObject(hThread, INFINITE); CloseHandle(hThread); } } catch(...) { g_ServiceStatus.dwCurrentState = SERVICE_STOPPED; g_ServiceStatus.dwWin32ExitCode = ERROR_OUTOFMEMORY; SetServiceStatus( g_ServiceStatusHandle, &g_ServiceStatus ); } } if(g_ServiceStatus.dwCurrentState == SERVICE_STOPPED) return; g_ServiceStatus.dwCurrentState = SERVICE_STOPPED; g_ServiceStatus.dwWin32ExitCode = GetLastError(); SetServiceStatus( g_ServiceStatusHandle, &g_ServiceStatus ); } /** Install the windows service. This requires administrator privileges. */ void InstallService() { SC_HANDLE InspServiceHandle = 0, SCMHandle = 0; try { TCHAR tszBinaryPath[MAX_PATH]; if(!GetModuleFileName(nullptr, tszBinaryPath, _countof(tszBinaryPath))) { throw CWin32Exception(); } SCMHandle = OpenSCManager(0, 0, SC_MANAGER_ALL_ACCESS); if (!SCMHandle) { throw CWin32Exception(); } InspServiceHandle = CreateService(SCMHandle, TEXT("InspIRCd"), TEXT("InspIRCd Daemon"), SERVICE_CHANGE_CONFIG, SERVICE_WIN32_OWN_PROCESS, SERVICE_AUTO_START, SERVICE_ERROR_NORMAL, tszBinaryPath, 0, 0, 0, TEXT("NT AUTHORITY\\NetworkService"), nullptr); if (!InspServiceHandle) { throw CWin32Exception(); } TCHAR tszDescription[] = TEXT("The InspIRCd service hosts IRC channels and conversations. If this service is stopped, the IRC server will be unavailable."); SERVICE_DESCRIPTION svDescription = { tszDescription }; if(!ChangeServiceConfig2(InspServiceHandle, SERVICE_CONFIG_DESCRIPTION, &svDescription)) { throw CWin32Exception(); } CloseServiceHandle(InspServiceHandle); CloseServiceHandle(SCMHandle); fmt::println("Service installed."); } catch(const CWin32Exception& e) { if(InspServiceHandle) CloseServiceHandle(InspServiceHandle); if(SCMHandle) CloseServiceHandle(SCMHandle); fmt::println("Service installation failed: {}", e.what()); } } /** Remove the windows service. This requires administrator privileges. */ void UninstallService() { SC_HANDLE InspServiceHandle = 0, SCMHandle = 0; try { SCMHandle = OpenSCManager(nullptr, SERVICES_ACTIVE_DATABASE, DELETE); if (!SCMHandle) throw CWin32Exception(); InspServiceHandle = OpenService(SCMHandle, TEXT("InspIRCd"), DELETE); if (!InspServiceHandle) throw CWin32Exception(); if (!DeleteService(InspServiceHandle) && GetLastError() != ERROR_SERVICE_MARKED_FOR_DELETE) { throw CWin32Exception(); } CloseServiceHandle(InspServiceHandle); CloseServiceHandle(SCMHandle); fmt::println("Service removed."); } catch(const CWin32Exception& e) { if(InspServiceHandle) CloseServiceHandle(InspServiceHandle); if(SCMHandle) CloseServiceHandle(SCMHandle); fmt::println("Service deletion failed: {}", e.what()); } } /* In windows, our main() flows through here, before calling the 'real' main, smain() in inspircd.cpp */ int main(int argc, char* argv[]) { /* Check for parameters */ if (argc > 1) { for (int i = 1; i < argc; i++) { if(!_stricmp(argv[i], "--installservice")) { InstallService(); return EXIT_SUCCESS; } if(!_stricmp(argv[i], "--uninstallservice") || !_stricmp(argv[i], "--removeservice")) { UninstallService(); return EXIT_SUCCESS; } } } SERVICE_TABLE_ENTRY serviceTable[] = { { (LPSTR)"InspIRCd", (LPSERVICE_MAIN_FUNCTION)ServiceMain }, { nullptr, nullptr } }; g_bRunningAsService = true; if( !StartServiceCtrlDispatcher(serviceTable) ) { // This error means that the program was not started as service. if( GetLastError() == ERROR_FAILED_SERVICE_CONTROLLER_CONNECT ) { g_bRunningAsService = false; return smain(argc, argv); } else { return EXIT_FAILURE; } } return EXIT_SUCCESS; } ��������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/win/win32service.h�������������������������������������������������������������������0000664�0000000�0000000�00000002430�14771603147�0016637�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2013, 2022 Sadie Powell <sadie@witchery.services> * Copyright (C) 2013 ChrisTX <xpipe@hotmail.de> * Copyright (C) 2012 Robby <robby@chatbelgie.be> * Copyright (C) 2008 Craig Edwards <brain@inspircd.org> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #pragma once #ifdef _WIN32 /* Redirect main() through a different method in win32service.cpp, to intercept service startup */ int smain(int argc, char** argv); /* Hook for win32service.cpp to exit properly with the service specific error code */ void SetServiceStopped(unsigned long dwStatus); /* Marks the service as running, not called until the config is parsed */ void SetServiceRunning(); #endif ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������inspircd-4.7.0/win/win32wrapper.cpp�����������������������������������������������������������������0000664�0000000�0000000�00000002707�14771603147�0017221�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2022 Sadie Powell <sadie@witchery.services> * Copyright (C) 2013 ChrisTX <xpipe@hotmail.de> * Copyright (C) 2012 Robby <robby@chatbelgie.be> * Copyright (C) 2007-2008 Craig Edwards <brain@inspircd.org> * Copyright (C) 2007 Dennis Friis <peavey@inspircd.org> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include "inspircd.h" CWin32Exception::CWin32Exception() { dwErrorCode = GetLastError(); szErrorString = GetErrorMessage(dwErrorCode); for (size_t pos = 0; ((pos = szErrorString.find_first_of("\r\n", pos)) != std::string::npos); ) szErrorString[pos] = ' '; } CWin32Exception::CWin32Exception(const CWin32Exception& other) : szErrorString(other.szErrorString) { } const char* CWin32Exception::what() const noexcept { return szErrorString.c_str(); } DWORD CWin32Exception::GetErrorCode() { return dwErrorCode; } ���������������������������������������������������������inspircd-4.7.0/win/win32wrapper.h�������������������������������������������������������������������0000664�0000000�0000000�00000010672�14771603147�0016666�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * InspIRCd -- Internet Relay Chat Daemon * * Copyright (C) 2020 Matt Schatz <genius3000@g3k.solutions> * Copyright (C) 2013, 2015, 2018, 2021-2023 Sadie Powell <sadie@witchery.services> * Copyright (C) 2013, 2015 Attila Molnar <attilamolnar@hush.com> * Copyright (C) 2012-2013 ChrisTX <xpipe@hotmail.de> * Copyright (C) 2012 Robby <robby@chatbelgie.be> * Copyright (C) 2011, 2014, 2019 Adam <Adam@anope.org> * Copyright (C) 2009 Uli Schlachter <psychon@znc.in> * Copyright (C) 2007-2008 Craig Edwards <brain@inspircd.org> * Copyright (C) 2007, 2009 Robin Burchell <robin+git@viroteck.net> * Copyright (C) 2007, 2009 Dennis Friis <peavey@inspircd.org> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #pragma once #include "win32service.h" /* Disable the deprecation warnings.. it spams :P */ #define _CRT_SECURE_NO_DEPRECATE #define _WINSOCK_DEPRECATED_NO_WARNINGS /* Normal windows (platform-specific) includes */ #include <winsock2.h> #pragma comment(lib, "Ws2_32.lib") #include <windows.h> #include <ws2tcpip.h> #include <io.h> /* strcasecmp is not defined on windows by default */ #define strcasecmp _stricmp #define strncasecmp _strnicmp typedef SSIZE_T ssize_t; // warning: 'identifier' : class 'type' needs to have dll-interface to be used by clients of class 'type2' // Normally, this is a huge problem, but due to our new/delete remap, we can ignore it. #pragma warning(disable:4251) // warning: DLL-interface classkey 'identifier' used as base for DLL-interface classkey 'identifier' #pragma warning(disable:4275) // warning: unreferenced formal parameter // Unimportant for now, but for the next version, we should take a look at these again. #pragma warning(disable:4100) // warning: 'class' : assignment operator could not be generated #pragma warning(disable:4512) // warning C4127: conditional expression is constant // This will be triggered like crazy because FOREACH_MOD and similar macros are wrapped in do { ... } while(0) constructs #pragma warning(disable:4127) // warning C4996: The POSIX name for this item is deprecated. #pragma warning(disable:4996) // warning C4244: conversion from 'x' to 'y', possible loss of data #pragma warning(disable:4244) // warning C4267: 'var' : conversion from 'size_t' to 'type', possible loss of data #pragma warning(disable:4267) // warning C4706: assignment within conditional expression #pragma warning(disable:4706) // warning C4800: 'type' : forcing value to bool 'true' or 'false' (performance warning) #pragma warning(disable:4800) /* Shared memory allocation functions */ void * ::operator new(size_t iSize); void ::operator delete(void * ptr); #include <exception> class CWin32Exception final : public std::exception { public: CWin32Exception(); CWin32Exception(const CWin32Exception& other); virtual const char* what() const noexcept; DWORD GetErrorCode(); private: std::string szErrorString; DWORD dwErrorCode; }; // POSIX iovec struct iovec final { void* iov_base; // Starting address size_t iov_len; // Number of bytes to transfer }; // Windows WSABUF with POSIX field names struct WindowsIOVec final { // POSIX iovec has iov_base then iov_len, WSABUF in Windows has the fields in reverse order u_long iov_len; // Number of bytes to transfer char FAR* iov_base; // Starting address }; inline ssize_t writev(int fd, const WindowsIOVec* iov, int count) { DWORD sent; int ret = WSASend(fd, reinterpret_cast<LPWSABUF>(const_cast<WindowsIOVec*>(iov)), count, &sent, 0, nullptr, nullptr); if (ret == 0) return sent; return -1; } inline std::string GetErrorMessage(DWORD dwErrorCode) { char szErrorString[1024]; if (FormatMessageA(FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS, nullptr, dwErrorCode, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), (LPSTR)szErrorString, _countof(szErrorString), nullptr) == 0) sprintf_s(szErrorString, _countof(szErrorString), "Error code: %u", dwErrorCode); return szErrorString; } ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������