Move the OnCheckExemption hook out of the core.
--- /dev/null
+<!--
+---------------------------------------------------
+GENERAL SUPPORT INFORMATION
+---------------------------------------------------
+
+The GitHub issue tracker is for bug reports and feature requests.
+General support can be found at the following locations:
+
+IRC:
+irc.inspircd.org #inspircd
+
+Example configs:
+2.0 - https://github.com/inspircd/inspircd/tree/insp20/docs/conf
+3.0 (alpha) - https://github.com/inspircd/inspircd/tree/master/docs/conf
+
+Wiki:
+https://wiki.inspircd.org/
+-->
+
+**Description**
+
+<!--
+Briefly describe the problem you are having in a few paragraphs.
+-->
+
+**Steps to reproduce the issue:**
+1.
+2.
+3.
+
+**Describe the results you received:**
+
+
+**Describe the results you expected:**
+
+
+**Additional information you deem important (e.g. issue happens only occasionally):**
+
+**Output of `./bin/inspircd --version`:**
+
!.git*
/.configure
-/BSDmakefile
+/Makefile
/GNUmakefile
/build
/docs/doxygen
#
# InspIRCd -- Internet Relay Chat Daemon
#
+# Copyright (C) 2012-2017 Peter Powell <petpow@saberuk.com>
# Copyright (C) 2009-2010 Daniel De Graaf <danieldg@inspircd.org>
# Copyright (C) 2007, 2009 Dennis Friis <peavey@inspircd.org>
# Copyright (C) 2003, 2006-2008 Craig Edwards <craigedwards@brainbox.cc>
my %version = get_version $opt_distribution_label;
print_format "<|BOLD Configuring InspIRCd $version{FULL} on $^O.|>\n";
-our %config;
+my %config;
if ($interactive) {
- %config = read_configure_cache();
+ %config = read_config_file(CONFIGURE_CACHE_FILE);
run_test CONFIGURE_CACHE_FILE, %config;
if (!defined $config{VERSION}) {
$config{VERSION} = CONFIGURE_CACHE_VERSION;
$config{HAS_CLOCK_GETTIME} = run_test 'clock_gettime()', test_file($config{CXX}, 'clock_gettime.cpp', $^O eq 'darwin' ? undef : '-lrt');
$config{HAS_EVENTFD} = run_test 'eventfd()', test_file($config{CXX}, 'eventfd.cpp');
-if ($config{HAS_EPOLL} = run_test 'epoll', test_header($config{CXX}, 'sys/epoll.h')) {
- $config{SOCKETENGINE} //= 'epoll';
-}
-
-if ($config{HAS_KQUEUE} = run_test 'kqueue', test_file($config{CXX}, 'kqueue.cpp')) {
- $config{SOCKETENGINE} //= 'kqueue';
-}
-
-if ($config{HAS_PORTS} = run_test 'Solaris IOCP', test_header($config{CXX}, 'port.h')) {
- $config{SOCKETENGINE} //= 'ports';
-}
-
-if ($config{HAS_POLL} = run_test 'poll', test_header($config{CXX}, 'poll.h')) {
- $config{SOCKETENGINE} //= 'poll';
-}
-
-# Select is available on all platforms
-$config{HAS_SELECT} = 1;
-$config{SOCKETENGINE} //= 'select';
+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, 'ports' if run_test 'Solaris IOCP', test_header $config{CXX}, 'port.h';
+push @socketengines, 'poll' if run_test 'poll', test_header $config{CXX}, 'poll.h';
+push @socketengines, 'select';
if (defined $opt_socketengine) {
- my $cfgkey = 'HAS_' . uc $opt_socketengine;
- if ($config{$cfgkey} && -f "src/socketengines/socketengine_$opt_socketengine.cpp") {
- $config{SOCKETENGINE} = $opt_socketengine;
- } else {
- print "Unable to use a socket engine which is not supported on this platform ($opt_socketengine)!\n";
- print "Available socket engines are:";
- foreach (<src/socketengines/socketengine_*.cpp>) {
- s/src\/socketengines\/socketengine_(\w+)\.cpp/$1/;
- print " $1" if $config{'HAS_' . uc $1};
- }
- print "\n";
- exit 1;
+ unless (grep { $_ eq $opt_socketengine } @socketengines) {
+ my $reason = -f "src/socketengines/socketengine_$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_system) {
$config{BASE_DIR} = $opt_prefix // '/var/lib/inspircd';
# Clear the screen.
system 'tput', 'clear' if $interactive;
+# 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 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
+}
+
# Check that the user actually wants this version.
if ($version{LABEL} ne 'release') {
print_warning <<'EOW';
DOXYFILE_ENCODING = UTF-8
PROJECT_NAME = InspIRCd
-PROJECT_NUMBER = 2.0
+PROJECT_NUMBER = 3.0
PROJECT_BRIEF =
PROJECT_LOGO =
OUTPUT_DIRECTORY = docs/doxygen
# allowpattern="Guest* Bot*" #
# killreason="Access denied" #
# verbose="yes" #
-# host="$uid.$ou.inspircd.org"> #
+# host="$uid.$ou.inspircd.org" #
+# useusername="no"> #
# #
# <ldapwhitelist cidr="10.42.0.0/16"> #
# #
# regardless of if they have an account, for example guest and bot #
# users. #
# #
+# The useusername setting chooses whether the user's username or #
+# nickname is used when locating a user account, if a username isn't #
+# provided in PASS. #
+# #
# Killreason indicates the QUIT reason to give to users if they fail #
# to authenticate. #
# #
#<include file="permchannels.conf">
#
# You may also create channels on startup by using the <permchannels> block.
-# Don't forget to set them +P in the modes, or they won't stay permanent.
#<permchannels channel="#opers" modes="isP" topic="Opers only.">
#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#
#
#-#-#-#-#-#-#-#-#-# SECURELIST CONFIGURATION -#-#-#-#-#-#-#-#-#-#-#-#-#
# #
-# Securelist can be harmful to some IRC search engines such as #
-# netsplit.de and searchirc.com. To prevent securelist blocking these #
-# sites from listing, define exception tags as shown below: #
-#<securehost exception="*@*.searchirc.org">
+# 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">
-#<securehost exception="*@echo940.server4you.de">
#<securehost exception="*@*.ircdriven.com">
+#<securehost exception="*@*.irc-source.com">
# #
# Define the following variable to change how long a user must wait #
# before issuing a LIST. If not defined, defaults to 60 seconds. #
# SSL channel mode module: Adds support for SSL-only channels via
# channel mode +z and the 'z' extban which matches SSL client
# certificate fingerprints.
-# Does not do anything useful without a working SSL module (see below).
+# Does not do anything useful without a working SSL module and the
+# sslinfo module (see below).
#<module name="sslmodes">
#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#
<alias text="GLOBAL" replace="PRIVMSG $requirement :$2-" requires="Global" uline="yes" operonly="yes">
<alias text="GROUPSERV" replace="PRIVMSG $requirement :$2-" requires="GroupServ" uline="yes">
<alias text="HELPSERV" replace="PRIVMSG $requirement :$2-" requires="HelpServ" uline="yes">
-<alias text="INFOSERV" replace="PRIVMSG $requirement :$2-" requires="GroupServ" uline="yes">
+<alias text="INFOSERV" replace="PRIVMSG $requirement :$2-" requires="InfoServ" uline="yes">
<alias text="PROXYSCAN" replace="PRIVMSG $requirement :$2-" requires="Proxyscan" uline="yes" operonly="yes">
<alias text="RPGSERV" replace="PRIVMSG $requirement :$2-" requires="RPGServ" uline="yes">
* Actually no, it does nothing. Never mind.
* @throws Nothing!
*/
- virtual ~CoreException() throw() {};
+ virtual ~CoreException() throw() {}
/** Returns the reason for the exception.
* @return Human readable description of the error
*/
public:
ModeUserServerNoticeMask();
- ModeAction OnModeChange(User* source, User* dest, Channel* channel, std::string ¶meter, bool adding);
- void OnParameterMissing(User* user, User* dest, Channel* channel);
+ ModeAction OnModeChange(User* source, User* dest, Channel* channel, std::string ¶meter, bool adding) CXX11_OVERRIDE;
+ void OnParameterMissing(User* user, User* dest, Channel* channel) CXX11_OVERRIDE;
/** Create a displayable mode string of the snomasks set on a given user
* @param user The user whose notice masks to format
struct ParseStack
{
std::vector<std::string> reading;
- insp::flat_map<std::string, std::string> vars;
+ insp::flat_map<std::string, std::string, irc::insensitive_swo> vars;
ConfigDataHash& output;
ConfigFileCache& FilesOutput;
std::stringstream& errstr;
/** Structure representing a single \<tag> in config */
class CoreExport ConfigTag : public refcountbase
{
- std::vector<KeyVal> items;
+ ConfigItems items;
public:
const std::string tag;
const std::string src_name;
std::string getTagLocation();
- inline const std::vector<KeyVal>& getItems() const { return items; }
+ inline const ConfigItems& getItems() const { return items; }
- /** Create a new ConfigTag, giving access to the private KeyVal item list */
- static ConfigTag* create(const std::string& Tag, const std::string& file, int line, std::vector<KeyVal>*& Items);
+ /** Create a new ConfigTag, giving access to the private ConfigItems item list */
+ static ConfigTag* create(const std::string& Tag, const std::string& file, int line, ConfigItems*& Items);
private:
ConfigTag(const std::string& Tag, const std::string& file, int line);
};
inline const ExtensibleStore& GetExtList() const { return extensions; }
Extensible();
- virtual CullResult cull();
+ virtual CullResult cull() CXX11_OVERRIDE;
virtual ~Extensible();
void doUnhookExtensions(const std::vector<reference<ExtensionItem> >& toRemove);
*/
virtual void Close();
/** This ensures that close is called prior to destructor */
- virtual CullResult cull();
+ virtual CullResult cull() CXX11_OVERRIDE;
/** Get the IOHook of a module attached to this socket
* @param mod Module whose IOHook to return
/** When there is data waiting to be read on a socket, the OnDataReady()
* method is called.
*/
- virtual void OnDataReady() = 0;
+ virtual void OnDataReady() CXX11_OVERRIDE = 0;
/**
* When an outbound connection fails, and the attempt times out, you
*/
typedef std::vector<ListLimit> limitlist;
+ /** The default maximum list size. */
+ static const unsigned int DEFAULT_LIST_SIZE = 64;
+
/** 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
*/
unsigned int GetLimit(Channel* channel);
+ /** Gets the lower list limit for this listmode.
+ */
+ unsigned int 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
* @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);
- virtual CullResult cull();
+ virtual CullResult cull() CXX11_OVERRIDE;
virtual ~ModeHandler();
/** Register this object in the ModeParser
/** Clean up prior to destruction
* If you override, you must call this AFTER your module's cleanup
*/
- virtual CullResult cull();
+ virtual CullResult cull() CXX11_OVERRIDE;
/** Default destructor.
* destroys a module class
QUERY_CNAME = 5,
/* Reverse DNS lookup */
QUERY_PTR = 12,
+ /* TXT */
+ QUERY_TXT = 16,
/* IPv6 AAAA lookup */
QUERY_AAAA = 28
};
RPL_SERVERVERSION = 4, // 2812, not 1459
RPL_ISUPPORT = 5, // not RFC, extremely common though (defined as RPL_BOUNCE in 2812, widely ignored)
- RPL_MAP = 6, // unrealircd
- RPL_ENDMAP = 7, // unrealircd
RPL_SNOMASKIS = 8, // unrealircd
RPL_REDIR = 10,
+ RPL_MAP = 15, // ircu
+ RPL_ENDMAP = 17, // ircu
+ RPL_MAPUSERS = 18, // insp-specific
+
RPL_YOURUUID = 42, // taken from ircnet
RPL_UMODEIS = 221,
RPL_LOCALUSERS = 265,
RPL_GLOBALUSERS = 266,
- RPL_MAPUSERS = 270, // insp-specific
-
RPL_AWAY = 301,
RPL_USERHOST = 302,
RPL_ISON = 303,
*/
Statistics() : lastempty(0), TotalEvents(0), ReadEvents(0), WriteEvents(0), ErrorEvents(0) { }
- /** Increase the counters for bytes sent/received in this second.
- * @param len_in Bytes received, 0 if updating number of bytes written.
- * @param len_out Bytes sent, 0 if updating number of bytes read.
+ /** 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 Update(size_t len_in, size_t len_out);
+ void UpdateReadCounters(int 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(int len_out);
/** Get data transfer statistics.
* @param kbitspersec_in Filled with incoming traffic in this second in kbit/s.
*/
typedef std::vector<std::string> file_cache;
-/** A configuration key and value pair
+/** A mapping of configuration keys to their assigned values.
*/
-typedef std::pair<std::string, std::string> KeyVal;
+typedef insp::flat_map<std::string, std::string, irc::insensitive_swo> ConfigItems;
/** The entire configuration
*/
-typedef std::multimap<std::string, reference<ConfigTag> > ConfigDataHash;
+typedef std::multimap<std::string, reference<ConfigTag>, irc::insensitive_swo> ConfigDataHash;
/** Iterator of ConfigDataHash */
typedef ConfigDataHash::const_iterator ConfigIter;
/** Default destructor
*/
virtual ~User();
- virtual CullResult cull();
+ virtual CullResult cull() CXX11_OVERRIDE;
};
class CoreExport UserIOHandler : public StreamSocket
{
public:
LocalUser(int fd, irc::sockets::sockaddrs* client, irc::sockets::sockaddrs* server);
- CullResult cull();
+ CullResult cull() CXX11_OVERRIDE;
UserIOHandler eh;
*/
void SetClass(const std::string &explicit_name = "");
- bool SetClientIP(const char* sip, bool recheck_eline = true);
+ bool SetClientIP(const char* sip, bool recheck_eline = true) CXX11_OVERRIDE;
- void SetClientIP(const irc::sockets::sockaddrs& sa, bool recheck_eline = true);
+ void SetClientIP(const irc::sockets::sockaddrs& sa, bool recheck_eline = true) CXX11_OVERRIDE;
- void Write(const std::string& text);
- void Write(const char*, ...) CUSTOM_PRINTF(2, 3);
+ void Write(const std::string& text) CXX11_OVERRIDE;
+ void Write(const char*, ...) CXX11_OVERRIDE CUSTOM_PRINTF(2, 3);
/** 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 command A command (should be all CAPS)
* @return True if this user can execute the command
*/
- bool HasPermission(const std::string &command);
+ bool HasPermission(const std::string &command) CXX11_OVERRIDE;
/** 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
* @param noisy If set to true, the user is notified that they do not have the specified permission where applicable. If false, no notification is sent.
* @return True if this user has the permission in question.
*/
- bool HasPrivPermission(const std::string &privstr, bool noisy = false);
+ bool HasPrivPermission(const std::string &privstr, bool noisy = false) CXX11_OVERRIDE;
/** 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
* @param mh Mode to check
* @return True if the user can set or unset this mode.
*/
- bool HasModePermission(const ModeHandler* mh) const;
+ bool HasModePermission(const ModeHandler* mh) const CXX11_OVERRIDE;
/** Change nick to uuid, unset REG_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
nick = sname;
}
- virtual CullResult cull();
- virtual const std::string& GetFullHost();
- virtual const std::string& GetFullRealHost();
+ virtual CullResult cull() CXX11_OVERRIDE;
+ virtual const std::string& GetFullHost() CXX11_OVERRIDE;
+ virtual const std::string& GetFullRealHost() CXX11_OVERRIDE;
};
/* Faster than dynamic_cast */
obj/ld-extra.cmd: $core_src
\@\$(SOURCEPATH)/make/unit-cc.pl gen-ld \$\@ \$^ \$>
-bin/inspircd: obj/ld-extra.cmd $core_mk
+bin/inspircd: $core_mk obj/ld-extra.cmd
\@\$(SOURCEPATH)/make/unit-cc.pl static-ld \$\@ \$^ \$>
inspircd: bin/inspircd
#
# InspIRCd -- Internet Relay Chat Daemon
#
-# Copyright (C) 2013-201
4 Peter Powell <petpow@saberuk.com>
+# Copyright (C) 2013-201
7 Peter Powell <petpow@saberuk.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
use File::Path qw(mkpath);
use File::Spec::Functions qw(rel2abs);
+use make::console;
+
our @EXPORT = qw(create_directory
get_cpu_count
get_version
- module_installed);
+ read_config_file
+ write_config_file);
sub create_directory($$) {
my ($location, $permissions) = @_;
return %version;
}
-sub module_installed($) {
- my $module = shift;
- eval("use $module;");
- return !$@;
-}
-
sub get_cpu_count {
my $count = 1;
if ($^O =~ /bsd/) {
return $count;
}
+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 -- Internet Relay Chat Daemon
#
-# Copyright (C) 2012-201
4 Peter Powell <petpow@saberuk.com>
+# Copyright (C) 2012-201
7 Peter Powell <petpow@saberuk.com>
# Copyright (C) 2008 Robin Burchell <robin+git@viroteck.net>
# Copyright (C) 2007-2008 Craig Edwards <craigedwards@brainbox.cc>
# Copyright (C) 2008 Thomas Stagner <aquanight@inspircd.org>
run_test
test_file
test_header
- read_configure_cache
write_configure_cache
get_compiler_info
find_compiler
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_configure_cache();
+ my %config = read_config_file(CONFIGURE_CACHE_FILE);
my %compiler = get_compiler_info($config{CXX});
my %version = get_version $config{DISTRIBUTION};
parse_templates(\%config, \%compiler, \%version);
sub test_header($$;$) {
my ($compiler, $header, $args) = @_;
$args //= '';
- open(COMPILER, "| $compiler -E - $args ${\CONFIGURE_ERROR_PIPE}") or return 0;
- print COMPILER "#include <$header>";
- close(COMPILER);
+ open(my $fh, "| $compiler -E - $args ${\CONFIGURE_ERROR_PIPE}") or return 0;
+ print $fh "#include <$header>";
+ close $fh;
return !$?;
}
-sub read_configure_cache {
- my %config;
- open(CACHE, CONFIGURE_CACHE_FILE) or return %config;
- while (my $line = <CACHE>) {
- next if $line =~ /^\s*($|\#)/;
- my ($key, $value) = ($line =~ /^(\S+)(?:\s(.*))?$/);
- $config{$key} = $value;
- }
- close(CACHE);
- return %config;
-}
-
sub write_configure_cache(%) {
unless (-e CONFIGURE_DIRECTORY) {
print_format "Creating <|GREEN ${\CONFIGURE_DIRECTORY}|> ...\n";
print_format "Writing <|GREEN ${\CONFIGURE_CACHE_FILE}|> ...\n";
my %config = @_;
- open(CACHE, '>', CONFIGURE_CACHE_FILE) or print_error "unable to write ${\CONFIGURE_CACHE_FILE}: $!";
- while (my ($key, $value) = each %config) {
- $value //= '';
- say CACHE "$key $value";
- }
- close(CACHE);
+ write_config_file CONFIGURE_CACHE_FILE, %config;
}
sub get_compiler_info($) {
my $binary = shift;
- my $version = `$binary -v 2>&1`;
- if ($version =~ /Apple\sLLVM\sversion\s(\d+\.\d+)/i) {
- # Apple version their LLVM releases slightly differently to the mainline LLVM.
- # See https://trac.macports.org/wiki/XcodeVersionInfo for more information.
- return (NAME => 'AppleClang', VERSION => $1);
- } elsif ($version =~ /clang\sversion\s(\d+\.\d+)/i) {
- return (NAME => 'Clang', VERSION => $1);
- } elsif ($version =~ /gcc\sversion\s(\d+\.\d+)/i) {
- return (NAME => 'GCC', VERSION => $1);
- } elsif ($version =~ /(?:icc|icpc)\sversion\s(\d+\.\d+).\d+\s\(gcc\sversion\s(\d+\.\d+).\d+/i) {
- return (NAME => 'ICC', VERSION => $1);
+ my %info = (NAME => 'Unknown', VERSION => '0.0');
+ return %info if system "$binary -o __compiler_info make/test/compiler_info.cpp ${\CONFIGURE_ERROR_PIPE}";
+ open(my $fh, '-|', './__compiler_info 2>/dev/null');
+ while (my $line = <$fh>) {
+ $info{$1} = $2 if $line =~ /^([A-Z]+)\s(.+)$/;
}
- return (NAME => $binary, VERSION => '0.0');
+ close $fh;
+ unlink './__compiler_info';
+ return %info;
}
sub find_compiler {
# Iterate through files in make/template.
foreach (<make/template/*>) {
print_format "Parsing <|GREEN $_|> ...\n";
- open(TEMPLATE, $_) or print_error "unable to read $_: $!";
- my (@lines, $mode, @platforms, %targets);
+ open(my $fh, $_) or print_error "unable to read $_: $!";
+ my (@lines, $mode, @platforms, @targets);
# First pass: parse template variables and directives.
- while (my $line = <TEMPLATE>) {
+ while (my $line = <$fh>) {
chomp $line;
# Does this line match a variable?
} elsif ($1 eq 'platform') {
push @platforms, $2;
} elsif ($1 eq 'target') {
- if ($2 =~ /(\w+)\s(.+)/) {
- $targets{$1} = $2;
- } else {
- $targets{DEFAULT} = $2;
- }
+ push @targets, $2
} else {
print_warning "unknown template command '$1' in $_!";
push @lines, $line;
}
push @lines, $line;
}
- close(TEMPLATE);
+ 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 (scalar keys %targets) {
- $targets{DEFAULT} = catfile(CONFIGURE_DIRECTORY, basename $_);
+ unless (@targets) {
+ push @targets, catfile(CONFIGURE_DIRECTORY, basename $_);
}
- # Second pass: parse makefile junk and write files.
- while (my ($name, $target) = each %targets) {
-
- # TODO: when buildtool is done this mess can be removed completely.
- my @final_lines;
- foreach my $line (@lines) {
-
- # Are we parsing a makefile and does this line match a statement?
- if ($name =~ /(?:BSD|GNU)_MAKE/ && $line =~ /^\s*\@(\w+)(?:\s+(.+))?$/) {
- my @tokens = split /\s/, $2 if defined $2;
- if ($1 eq 'DO_EXPORT' && defined $2) {
- if ($name eq 'BSD_MAKE') {
- foreach my $variable (@tokens) {
- push @final_lines, "MAKEENV += $variable='\${$variable}'";
- }
- } elsif ($name eq 'GNU_MAKE') {
- push @final_lines, "export $2";
- }
- } elsif ($1 eq 'ELSE') {
- if ($name eq 'BSD_MAKE') {
- push @final_lines, ".else";
- } elsif ($name eq 'GNU_MAKE') {
- push @final_lines, "else";
- }
- } elsif ($1 eq 'ENDIF') {
- if ($name eq 'BSD_MAKE') {
- push @final_lines, ".endif";
- } elsif ($name eq 'GNU_MAKE') {
- push @final_lines, "endif";
- }
- } elsif ($1 eq 'ELSIFEQ' && defined $2) {
- if ($name eq 'BSD_MAKE') {
- push @final_lines, ".elif $tokens[0] == $tokens[1]";
- } elsif ($name eq 'GNU_MAKE') {
- push @final_lines, "else ifeq ($tokens[0], $tokens[1])";
- }
- } elsif ($1 eq 'IFDEF' && defined $2) {
- if ($name eq 'BSD_MAKE') {
- push @final_lines, ".if defined($2)";
- } elsif ($name eq 'GNU_MAKE') {
- push @final_lines, "ifdef $2";
- }
- } elsif ($1 eq 'IFEQ' && defined $2) {
- if ($name eq 'BSD_MAKE') {
- push @final_lines, ".if $tokens[0] == $tokens[1]";
- } elsif ($name eq 'GNU_MAKE') {
- push @final_lines, "ifeq ($tokens[0],$tokens[1])";
- }
- } elsif ($1 eq 'IFNEQ' && defined $2) {
- if ($name eq 'BSD_MAKE') {
- push @final_lines, ".if $tokens[0] != $tokens[1]";
- } elsif ($name eq 'GNU_MAKE') {
- push @final_lines, "ifneq ($tokens[0],$tokens[1])";
- }
- } elsif ($1 eq 'IFNDEF' && defined $2) {
- if ($name eq 'BSD_MAKE') {
- push @final_lines, ".if !defined($2)";
- } elsif ($name eq 'GNU_MAKE') {
- push @final_lines, "ifndef $2";
- }
- } elsif ($1 eq 'TARGET' && defined $2) {
- if ($tokens[0] eq $name) {
- push @final_lines, substr($2, length($tokens[0]) + 1);
- }
- } elsif ($1 !~ /[A-Z]/) {
- # HACK: silently ignore if lower case as these are probably make commands.
- push @final_lines, $line;
- } else {
- print_warning "unknown template command '$1' in $_!";
- push @final_lines, $line;
- }
- next;
- }
-
- push @final_lines, $line;
- }
+ # Write the templated files to disk.
+ for my $target (@targets) {
# Create the directory if it doesn't already exist.
my $directory = dirname $target;
# Write the template file.
print_format "Writing <|GREEN $target|> ...\n";
- open(TARGET, '>', $target) or print_error "unable to write $target: $!";
- foreach (@final_lines) {
- say TARGET $_;
+ open(my $fh, '>', $target) or print_error "unable to write $target: $!";
+ foreach (@lines) {
+ say $fh $_;
}
- close(TARGET);
+ close $fh;
# Set file permissions.
if (defined $mode) {
#
# InspIRCd -- Internet Relay Chat Daemon
#
-# Copyright (C) 2014 Peter Powell <petpow@saberuk.com>
+# Copyright (C) 2014
-2017 Peter Powell <petpow@saberuk.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
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);
-use Exporter qw(import);
-our @EXPORT = qw(print_format
+our @EXPORT = qw(command
+ execute_command
+ print_format
print_error
print_warning
prompt_bool
prompt_string);
my %FORMAT_CODES = (
- DEFAULT => "\e[0m",
- BOLD => "\e[1m",
+ DEFAULT => "\e[0m",
+ BOLD => "\e[1m",
+ UNDERLINE => "\e[4m",
RED => "\e[1;31m",
GREEN => "\e[1;32m",
BLUE => "\e[1;34m"
);
+my %commands;
+
+struct 'command' => {
+ 'callback' => '$',
+ 'description' => '$',
+};
+
sub __console_format($$) {
my ($name, $data) = @_;
return $data unless -t STDOUT;
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') {
+ print_format "<|GREEN Usage:|> $0 <<|UNDERLINE COMMAND|>> [<|UNDERLINE OPTIONS...|>]\n\n";
+ print_format "<|GREEN Commands:|>\n";
+ for my $key (sort keys %commands) {
+ next unless defined $commands{$key}->description;
+ my $name = sprintf "%-15s", $key;
+ my $description = $commands{$key}->description;
+ print_format " <|BOLD $name|> # $description\n";
+ }
+ 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;
sub get_directive($$;$)
{
my ($file, $property, $default) = @_;
- open(MODULE, $file) or return $default;
+ open(my $fh, $file) or return $default;
my $value = '';
- while (<MODULE>) {
+ while (<$fh>) {
if ($_ =~ /^\/\* \$(\S+): (.+) \*\/$/ || $_ =~ /^\/\/\/ \$(\S+): (.+)/) {
next unless $1 eq $property;
$value .= ' ' . execute_functions($file, $1, $2);
}
}
- close(MODULE);
+ close $fh;
# Strip all extraneous whitespace.
$value =~ s/^\s+|\s+$//g;
--- /dev/null
+%platform darwin
+%platform freebsd
+%platform netbsd
+%platform openbsd
+%target Makefile
+#
+# InspIRCd -- Internet Relay Chat Daemon
+#
+# Copyright (C) 2017 Peter Powell <petpow@saberuk.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/>.
+#
+
+# This file will be installed as `Makefile` on BSD derivatives. When a user runs
+# BSD Make it will be picked up as the default makefile even on systems like
+# OpenBSD which have removed BSDMakefile support. If they run GNU Make then it
+# will ignore this file and run GNUmakefile instead.
+
+all clean configureclean debug deinstall distclean help install:
+ @echo "InspIRCd no longer supports BSD Make. You should install GNU Make instead."
+ @echo "If this is problematic for you then please contact us via our IRC channel"
+ @echo "at irc.inspircd.org #InspIRCd."
+ @exit 1
-%target BSD_MAKE BSDmakefile
-%target GNU_MAKE GNUmakefile
+%target GNUmakefile
#
# InspIRCd -- Internet Relay Chat Daemon
#
# 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. This
-# needs to work in both GNU and BSD make; it is mangled for
-# them by configure.
+# Please do not edit unless you know what you're doing.
#
INSTMODE_BIN = 0750
INSTMODE_LIB = 0640
-@IFNEQ $(COMPILER) ICC
+ifneq ($(COMPILER), ICC)
CORECXXFLAGS += -Woverloaded-virtual -Wshadow
-@IFNEQ $(SYSTEM) openbsd
+ifneq ($(SYSTEM), openbsd)
CORECXXFLAGS += -pedantic -Wformat=2 -Wmissing-format-attribute
-@ENDIF
-@ENDIF
+endif
+endif
-@IFNEQ $(SYSTEM) darwin
+ifneq ($(SYSTEM), darwin)
LDLIBS += -pthread
-@ENDIF
+endif
-@IFEQ $(SYSTEM) linux
+ifeq ($(SYSTEM), linux)
LDLIBS += -ldl -lrt
-@ENDIF
-@IFEQ $(SYSTEM) gnukfreebsd
+endif
+ifeq ($(SYSTEM), gnukfreebsd)
LDLIBS += -ldl -lrt
-@ENDIF
-@IFEQ $(SYSTEM) gnu
+endif
+ifeq ($(SYSTEM), gnu)
LDLIBS += -ldl -lrt
-@ENDIF
-@IFEQ $(SYSTEM) solaris
+endif
+ifeq ($(SYSTEM), solaris)
LDLIBS += -lsocket -lnsl -lrt -lresolv
INSTALL = ginstall
-@ENDIF
-@IFEQ $(SYSTEM) darwin
+endif
+ifeq ($(SYSTEM), darwin)
LDLIBS += -ldl
CORELDFLAGS = -dynamic -bind_at_load -L. $(LDFLAGS)
PICLDFLAGS = -fPIC -shared -twolevel_namespace -undefined dynamic_lookup $(LDFLAGS)
-@ENDIF
+endif
-@IFNDEF INSPIRCD_DEBUG
+ifndef INSPIRCD_DEBUG
INSPIRCD_DEBUG=0
-@ENDIF
+endif
DBGOK=0
-@IFEQ $(INSPIRCD_DEBUG) 0
+ifeq ($(INSPIRCD_DEBUG), 0)
CORECXXFLAGS += -fno-rtti -O2
-@IFEQ $(COMPILER) GCC
+ifeq ($(COMPILER), GCC)
CORECXXFLAGS += -g1
-@ENDIF
+endif
HEADER = std-header
DBGOK=1
-@ENDIF
-@IFEQ $(INSPIRCD_DEBUG) 1
+endif
+ifeq ($(INSPIRCD_DEBUG), 1)
CORECXXFLAGS += -O0 -g3 -Werror -DINSPIRCD_ENABLE_RTTI
HEADER = debug-header
DBGOK=1
-@ENDIF
-@IFEQ $(INSPIRCD_DEBUG) 2
+endif
+ifeq ($(INSPIRCD_DEBUG), 2)
CORECXXFLAGS += -fno-rtti -O2 -g3
HEADER = debug-header
DBGOK=1
-@ENDIF
+endif
FOOTER = finishmessage
-@TARGET GNU_MAKE MAKEFLAGS += --no-print-directory
+MAKEFLAGS += --no-print-directory
-@TARGET GNU_MAKE SOURCEPATH = $(shell /bin/pwd)
-@TARGET BSD_MAKE SOURCEPATH != /bin/pwd
+SOURCEPATH = $(shell /bin/pwd)
-@IFNDEF INSPIRCD_VERBOSE
- @TARGET GNU_MAKE MAKEFLAGS += --silent
- @TARGET BSD_MAKE MAKE += -s
-@ENDIF
+ifndef INSPIRCD_VERBOSE
+ MAKEFLAGS += --silent
+endif
-@IFDEF INSPIRCD_STATIC
+ifdef INSPIRCD_STATIC
CORECXXFLAGS += -DINSPIRCD_STATIC
-@ENDIF
+endif
# Add the users CPPFLAGS/CXXFLAGS to the base ones to allow them to
# override things like -Wfatal-errors if they wish to.
CORECXXFLAGS += $(CPPFLAGS) $(CXXFLAGS)
-@DO_EXPORT CXX CORECXXFLAGS LDLIBS PICLDFLAGS INSPIRCD_VERBOSE SOCKETENGINE CORELDFLAGS
-@DO_EXPORT SOURCEPATH BUILDPATH INSPIRCD_STATIC
+export BUILDPATH
+export CORECXXFLAGS
+export CORELDFLAGS
+export CXX
+export INSPIRCD_STATIC
+export INSPIRCD_VERBOSE
+export LDLIBS
+export PICLDFLAGS
+export SOCKETENGINE
+export SOURCEPATH
# Default target
TARGET = all
-@IFDEF INSPIRCD_MODULE
+ifdef INSPIRCD_MODULE
HEADER = mod-header
FOOTER = mod-footer
- @TARGET BSD_MAKE TARGET = modules/${INSPIRCD_MODULE:S/.so$//}.so
- @TARGET GNU_MAKE TARGET = modules/$(INSPIRCD_MODULE:.so=).so
-@ENDIF
+ TARGET = modules/$(INSPIRCD_MODULE:.so=).so
+endif
-@IFDEF INSPIRCD_TARGET
+ifdef INSPIRCD_TARGET
HEADER =
FOOTER = target
TARGET = $(INSPIRCD_TARGET)
-@ENDIF
+endif
-@IFEQ $(DBGOK) 0
+ifeq ($(DBGOK), 0)
HEADER = unknown-debug-level
-@ENDIF
+endif
all: $(FOOTER)
@echo "*************************************"
mod-header:
-@IFDEF INSPIRCD_STATIC
+ifdef INSPIRCD_STATIC
@echo 'Cannot build single modules in pure-static build'
@exit 1
-@ENDIF
+endif
@echo 'Building single module:'
mod-footer: target
@-$(INSTALL) -d -m $(INSTMODE_DIR) $(MANPATH)
@-$(INSTALL) -d -m $(INSTMODE_DIR) $(MODPATH)
[ "$(BUILDPATH)/bin/" -ef $(BINPATH) ] || $(INSTALL) -m $(INSTMODE_BIN) "$(BUILDPATH)/bin/inspircd" $(BINPATH)
-@IFNDEF INSPIRCD_STATIC
+ifndef INSPIRCD_STATIC
[ "$(BUILDPATH)/modules/" -ef $(MODPATH) ] || $(INSTALL) -m $(INSTMODE_LIB) "$(BUILDPATH)/modules/"*.so $(MODPATH)
-@ENDIF
+endif
-$(INSTALL) -m $(INSTMODE_BIN) @CONFIGURE_DIRECTORY@/inspircd $(BASE) 2>/dev/null
-$(INSTALL) -m $(INSTMODE_LIB) .gdbargs $(BASE)/.gdbargs 2>/dev/null
-@IFEQ $(SYSTEM) darwin
+ifeq ($(SYSTEM), darwin)
-$(INSTALL) -m $(INSTMODE_BIN) @CONFIGURE_DIRECTORY@/org.inspircd.plist $(BASE) 2>/dev/null
-@ENDIF
-@IFEQ $(SYSTEM) linux
+endif
+ifeq ($(SYSTEM), linux)
-$(INSTALL) -m $(INSTMODE_LIB) @CONFIGURE_DIRECTORY@/inspircd.service $(BASE) 2>/dev/null
-@ENDIF
+endif
-$(INSTALL) -m $(INSTMODE_LIB) @CONFIGURE_DIRECTORY@/inspircd.1 $(MANPATH) 2>/dev/null
-$(INSTALL) -m $(INSTMODE_LIB) @CONFIGURE_DIRECTORY@/inspircd-genssl.1 $(MANPATH) 2>/dev/null
-$(INSTALL) -m $(INSTMODE_BIN) tools/genssl $(BINPATH)/inspircd-genssl 2>/dev/null
@echo 'Remember to create your config file:' $(CONPATH)/inspircd.conf
@echo 'Examples are available at:' $(CONPATH)/examples/
-GNUmakefile BSDmakefile: make/template/main.mk src/version.sh configure @CONFIGURE_CACHE_FILE@
+GNUmakefile: make/template/main.mk src/version.sh configure @CONFIGURE_CACHE_FILE@
./configure --update
-@TARGET BSD_MAKE .MAKEFILEDEPS: BSDmakefile
clean:
@echo Cleaning...
configureclean:
rm -f .gdbargs
- rm -f BSDmakefile
+ -rm -f Makefile
rm -f GNUmakefile
rm -f include/config.h
rm -rf @CONFIGURE_DIRECTORY@
/*
* InspIRCd -- Internet Relay Chat Daemon
*
+ * Copyright (C) 2013 Peter Powell <petpow@saberuk.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
/*
* InspIRCd -- Internet Relay Chat Daemon
*
+ * Copyright (C) 2016 Attila Molnar <attilamolnar@hush.com>
+ * Copyright (C) 2014-2015 Peter Powell <petpow@saberuk.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
--- /dev/null
+/*
+ * InspIRCd -- Internet Relay Chat Daemon
+ *
+ * Copyright (C) 2017 Peter Powell <petpow@saberuk.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 <iostream>
+
+#if defined __INTEL_COMPILER // Also defines __clang__ and __GNUC__
+# define INSPIRCD_COMPILER_NAME "Intel"
+# define INSPIRCD_COMPILER_VERSION (__INTEL_COMPILER / 100) << '.' << (__INTEL_COMPILER % 100)
+#elif defined __clang__ // Also defines __GNUC__
+# if defined __apple_build_version__
+# define INSPIRCD_COMPILER_NAME "AppleClang"
+# else
+# define INSPIRCD_COMPILER_NAME "Clang"
+# endif
+# define INSPIRCD_COMPILER_VERSION __clang_major__ << '.' << __clang_minor__
+#elif defined __GNUC__
+# define INSPIRCD_COMPILER_NAME "GCC"
+# define INSPIRCD_COMPILER_VERSION __GNUC__ << '.' << __GNUC_MINOR__
+#endif
+
+int main() {
+ std::cout << "NAME " << INSPIRCD_COMPILER_NAME << std::endl
+ << "VERSION " << INSPIRCD_COMPILER_VERSION << std::endl;
+ return 0;
+}
#
# InspIRCd -- Internet Relay Chat Daemon
#
+# Copyright (C) 2012-2017 Peter Powell <petpow@saberuk.com>
# Copyright (C) 2008-2009 Robin Burchell <robin+git@viroteck.net>
#
# This file is part of InspIRCd. InspIRCd is free software: you can
#
-use strict;
-use warnings FATAL => qw(all);
-
-use make::common;
-
BEGIN {
- unless (module_installed("LWP::Simple")) {
+ require 5.10.0;
+ unless (eval "use LWP::Simple; 1") {
die "Your system is missing the LWP::Simple Perl module!";
}
- unless (module_installed("Crypt::SSLeay") || module_installed("IO::Socket::SSL")) {
+ 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 File::Basename;
-use LWP::Simple;
+use feature ':5.10';
+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;
my %installed;
# $installed{name} = $version
}
# hash of installed module versions from our mini-database, key (m_foobar) to version (00abacca..).
-my %mod_versions;
+my %mod_versions = read_config_file '.modulemanager';
# useless helper stub
sub getmodversion {
return $mod_versions{$file};
}
-# read in installed versions
-if (-e '.modulemanager')
-{
- open SRC, '.modulemanager' or die ".modulemanager exists but i can't read it: $!";
- while (<SRC>)
- {
- s/\n//;
- (my $mod, my $ver) = split(/ /, $_);
- $mod_versions{$mod} = $ver;
- }
- close SRC;
-}
-
# read in external URL sources
open SRC, 'sources.list' or die "Could not open sources.list: $!";
while (<SRC>) {
}
}
-my $action = $#ARGV >= 0 ? lc shift @ARGV : 'help';
-
-if ($action eq 'install') {
- for my $mod (@ARGV) {
+command 'install', 'Install a third-party module', sub {
+ for my $mod (@_) {
my $vers = $mod =~ s/=([-0-9.]+)// ? $1 : undef;
$mod = lc $mod;
unless ($modules{$mod}) {
}
$todo{$mod} = $ver;
}
-} elsif ($action eq 'upgrade') {
+};
+
+command 'upgrade', 'Upgrade a third-party module', sub {
my @installed = sort keys %installed;
for my $mod (@installed) {
next unless $mod =~ /^m_/;
%todo = %saved;
}
}
-} elsif ($action eq 'list') {
+};
+
+command 'list', 'List available third-party modules', sub {
my @all = sort keys %modules;
for my $mod (@all) {
my @vers = sort { ver_cmp() } keys %{$modules{$mod}};
my $vers = join ' ', map { $_ eq $instver ? "\e[1m$_\e[m" : $_ } @vers;
print "$mod ($vers) - $desc\n";
}
-} else {
- print <<ENDUSAGE
-Use: $0 <action> <args>
-Action is one of the following
- install install new modules
- upgrade upgrade installed modules
- list lists available modules
-
-For installing a package, specify its name or name=version to force the
-installation of a specific version.
-ENDUSAGE
-;exit 1;
-}
+ exit 0;
+};
+
+execute_command @ARGV;
resolve_deps(0);
$| = 1; # immediate print of lines without \n
-print "Processing changes for $action...\n";
+print "Processing changes...\n";
for my $mod (keys %installed) {
next if $todo{$mod};
print "Uninstalling $mod $installed{$mod}\n";
}
# write database of installed versions
-open SRC, '>.modulemanager' or die "can't write installed versions to .modulemanager, won't be able to track upgrades properly: $!";
-foreach my $key (keys %mod_versions)
-{
- print SRC "$key $mod_versions{$key}\n";
-}
-close SRC;
+write_config_file '.modulemanager', %mod_versions;
print "Finished!\n";
unget(ch);
}
- bool kv(std::vector<KeyVal>* items, std::set<std::string>& seen)
+ bool kv(ConfigItems* items)
{
std::string key;
nextword(key);
value.push_back(ch);
}
- if (!seen.insert(key).second)
+ if (items->find(key) != items->end())
throw CoreException("Duplicate key '" + key + "' found");
- items->push_back(KeyVal(key, value));
+ (*items)[key] = value;
return true;
}
if (name.empty())
throw CoreException("Empty tag name");
- std::vector<KeyVal>* items;
- std::set<std::string> seen;
+ ConfigItems* items;
tag = ConfigTag::create(name, current.filename, current.line, items);
- while (kv(items, seen))
+ while (kv(items))
{
// Do nothing here (silences a GCC warning).
}
}
else if (name == "files")
{
- for(std::vector<KeyVal>::iterator i = items->begin(); i != items->end(); i++)
+ for(ConfigItems::iterator i = items->begin(); i != items->end(); i++)
{
stack.DoReadFile(i->first, i->second, flags, false);
}
}
else if (name == "execfiles")
{
- for(std::vector<KeyVal>::iterator i = items->begin(); i != items->end(); i++)
+ for(ConfigItems::iterator i = items->begin(); i != items->end(); i++)
{
stack.DoReadFile(i->first, i->second, flags, true);
}
bool ConfigTag::readString(const std::string& key, std::string& value, bool allow_lf)
{
- for(std::vector<KeyVal>::iterator j = items.begin(); j != items.end(); ++j)
+ for(ConfigItems::iterator j = items.begin(); j != items.end(); ++j)
{
if(j->first != key)
continue;
return src_name + ":" + ConvToStr(src_line);
}
-ConfigTag* ConfigTag::create(const std::string& Tag, const std::string& file, int line, std::vector<KeyVal>*& Items)
+ConfigTag* ConfigTag::create(const std::string& Tag, const std::string& file, int line, ConfigItems*& Items)
{
ConfigTag* rv = new ConfigTag(Tag, file, line);
Items = &rv->items;
static ConfigTag* CreateEmptyTag()
{
- std::vector<KeyVal>* items;
+ ConfigItems* items;
return ConfigTag::create("empty", "<auto>", 0, items);
}
if (blk_count == 0)
{
// No connect blocks found; make a trivial default block
- std::vector<KeyVal>* items;
+ ConfigItems* items;
ConfigTag* tag = ConfigTag::create("connect", "<auto>", 0, items);
- items->push_back(std::make_pair("allow", "*"));
+ (*items)["allow"] = "*";
config_data.insert(std::make_pair("connect", tag));
blk_count = 1;
}
#include "inspircd.h"
#include "core_channel.h"
#include "invite.h"
+#include "listmode.h"
class CoreModChannel : public Module, public CheckExemption::EventListener
{
exemptions.swap(exempts);
}
+ void On005Numeric(std::map<std::string, std::string>& tokens) CXX11_OVERRIDE
+ {
+ // Build a map of limits to their mode character.
+ insp::flat_map<int, std::string> limits;
+ const ModeParser::ListModeList& listmodes = ServerInstance->Modes->GetListModes();
+ for (ModeParser::ListModeList::const_iterator iter = listmodes.begin(); iter != listmodes.end(); ++iter)
+ {
+ const unsigned int limit = (*iter)->GetLowerLimit();
+ limits[limit].push_back((*iter)->GetModeChar());
+ }
+
+ // Generate the MAXLIST token from the limits map.
+ std::string& buffer = tokens["MAXLIST"];
+ for (insp::flat_map<int, std::string>::const_iterator iter = limits.begin(); iter != limits.end(); ++iter)
+ {
+ if (!buffer.empty())
+ buffer.push_back(',');
+
+ buffer.append(iter->second);
+ buffer.push_back(':');
+ buffer.append(ConvToStr(iter->first));
+ }
+ }
+
void OnPostJoin(Membership* memb) CXX11_OVERRIDE
{
Channel* const chan = memb->chan;
record.ttl = (input[pos] << 24) | (input[pos + 1] << 16) | (input[pos + 2] << 8) | input[pos + 3];
pos += 4;
- //record.rdlength = input[pos] << 8 | input[pos + 1];
+ uint16_t rdlength = input[pos] << 8 | input[pos + 1];
pos += 2;
switch (record.type)
break;
}
+ case QUERY_TXT:
+ {
+ if (pos + rdlength > input_size)
+ throw Exception("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("Invalid character in txt record");
+
+ break;
+ }
default:
break;
}
}
}
- void Process(DNS::Request* req)
+ void Process(DNS::Request* req) CXX11_OVERRIDE
{
if ((unloading) || (req->creator->dying))
throw Exception("Module is being unloaded");
ServerInstance->Timers.AddTimer(req);
}
- void RemoveRequest(DNS::Request* req)
+ void RemoveRequest(DNS::Request* req) CXX11_OVERRIDE
{
if (requests[req->id] == req)
requests[req->id] = NULL;
}
- std::string GetErrorStr(Error e)
+ std::string GetErrorStr(Error e) CXX11_OVERRIDE
{
switch (e)
{
delete request;
}
- bool Tick(time_t now)
+ bool Tick(time_t now) CXX11_OVERRIDE
{
ServerInstance->Logs->Log(MODNAME, LOG_DEBUG, "cache: purging DNS cache");
this->manager.Rehash(DNSServer, SourceIP, SourcePort);
}
- void OnUnloadModule(Module* mod)
+ void OnUnloadModule(Module* mod) CXX11_OVERRIDE
{
for (unsigned int i = 0; i <= MAX_REQUEST_ID; ++i)
{
}
}
- Version GetVersion()
+ Version GetVersion() CXX11_OVERRIDE
{
return Version("DNS support", VF_CORE|VF_VENDOR);
}
ph = &ptrHosts;
}
- void OnUserInit(LocalUser *user)
+ void OnUserInit(LocalUser *user) CXX11_OVERRIDE
{
if (!DNS || !user->MyClass->resolvehostnames)
{
}
}
- ModResult OnCheckReady(LocalUser* user)
+ ModResult OnCheckReady(LocalUser* user) CXX11_OVERRIDE
{
return this->dnsLookup.get(user) ? MOD_RES_DENY : MOD_RES_PASSTHRU;
}
- Version GetVersion()
+ Version GetVersion() CXX11_OVERRIDE
{
return Version("Provides support for DNS lookups on connecting clients", VF_CORE|VF_VENDOR);
}
{
}
- Version GetVersion()
+ Version GetVersion() CXX11_OVERRIDE
{
return Version("Provides the LOADMODULE and UNLOADMODULE commands", VF_VENDOR|VF_CORE);
}
{
}
- void OnPostConnect(User* user)
+ void OnPostConnect(User* user) CXX11_OVERRIDE
{
counters.UpdateMaxUsers();
if (user->IsModeSet(invisiblemode))
counters.invisible++;
}
- void OnUserQuit(User* user, const std::string& message, const std::string& oper_message)
+ void OnUserQuit(User* user, const std::string& message, const std::string& oper_message) CXX11_OVERRIDE
{
if (user->IsModeSet(invisiblemode))
counters.invisible--;
}
- Version GetVersion()
+ Version GetVersion() CXX11_OVERRIDE
{
return Version("LUSERS", VF_VENDOR | VF_CORE);
}
return CMD_FAILURE;
}
- User *u = ServerInstance->FindNick(parameters[0]);
- if (u)
+ User* target = ServerInstance->FindNick(parameters[0]);
+ if (!target)
+ {
+ user->WriteNumeric(Numerics::NoSuchNick(parameters[0]));
+ return CMD_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))
{
/*
- * 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
+ * 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 MOD_RESULT;
+ FIRST_MOD_RESULT(OnKill, MOD_RESULT, (user, target, parameters[1]));
+
+ if (MOD_RESULT == MOD_RES_DENY)
+ return CMD_FAILURE;
- if (IS_LOCAL(user))
+ killreason = "Killed (";
+ if (!ServerInstance->Config->HideKillsServer.empty())
{
- /*
- * 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 MOD_RESULT;
- FIRST_MOD_RESULT(OnKill, MOD_RESULT, (user, u, parameters[1]));
-
- if (MOD_RESULT == MOD_RES_DENY)
- return CMD_FAILURE;
-
- killreason = "Killed (";
- if (!ServerInstance->Config->HideKillsServer.empty())
- {
- // hidekills is on, use it
- killreason += ServerInstance->Config->HideKillsServer;
- }
- else
- {
- // hidekills is off, do nothing
- killreason += user->nick;
- }
-
- killreason += " (" + parameters[1] + "))";
+ // hidekills is on, use it
+ killreason += ServerInstance->Config->HideKillsServer;
}
else
{
- /* Leave it alone, remote server has already formatted it */
- killreason.assign(parameters[1], 0, ServerInstance->Config->Limits.MaxQuit);
+ // hidekills is off, do nothing
+ killreason += user->nick;
}
- /*
- * Now we need to decide whether or not to send a local or remote snotice. Currently this checking is a little flawed.
- * No time to fix it right now, so left a note. -- w00t
- */
- if (!IS_LOCAL(u))
- {
- // remote kill
- if ((!ServerInstance->Config->HideULineKills) || (!user->server->IsULine()))
- ServerInstance->SNO->WriteToSnoMask('K', "Remote kill by %s: %s (%s)", user->nick.c_str(), u->GetFullRealHost().c_str(), parameters[1].c_str());
- this->lastuuid = u->uuid;
- }
+ killreason += " (" + parameters[1] + "))";
+ }
+ else
+ {
+ /* Leave it alone, remote server has already formatted it */
+ killreason.assign(parameters[1], 0, ServerInstance->Config->Limits.MaxQuit);
+ }
+
+ if ((!ServerInstance->Config->HideULineKills) || (!user->server->IsULine()))
+ {
+ if (IS_LOCAL(user) && IS_LOCAL(target))
+ ServerInstance->SNO->WriteGlobalSno('k', "Local kill by %s: %s (%s)", user->nick.c_str(), target->GetFullRealHost().c_str(), parameters[1].c_str());
else
- {
- // local kill
- /*
- * XXX - this isn't entirely correct, servers A - B - C, oper on A, client on C. Oper kills client, A and B will get remote kill
- * snotices, C will get a local kill snotice. this isn't accurate, and needs fixing at some stage. -- w00t
- */
- if ((!ServerInstance->Config->HideULineKills) || (!user->server->IsULine()))
- {
- if (IS_LOCAL(user))
- ServerInstance->SNO->WriteGlobalSno('k',"Local Kill by %s: %s (%s)", user->nick.c_str(), u->GetFullRealHost().c_str(), parameters[1].c_str());
- else
- ServerInstance->SNO->WriteToSnoMask('k',"Local Kill by %s: %s (%s)", user->nick.c_str(), u->GetFullRealHost().c_str(), parameters[1].c_str());
- }
-
- ServerInstance->Logs->Log("KILL", LOG_DEFAULT, "LOCAL KILL: %s :%s!%s!%s (%s)", u->nick.c_str(), ServerInstance->Config->ServerName.c_str(), user->dhost.c_str(), user->nick.c_str(), parameters[1].c_str());
-
- u->Write(":%s KILL %s :%s!%s!%s (%s)", ServerInstance->Config->HideKillsServer.empty() ? user->GetFullHost().c_str() : ServerInstance->Config->HideKillsServer.c_str(),
- u->nick.c_str(),
- ServerInstance->Config->ServerName.c_str(),
- ServerInstance->Config->HideKillsServer.empty() ? user->dhost.c_str() : ServerInstance->Config->HideKillsServer.c_str(),
- ServerInstance->Config->HideKillsServer.empty() ? user->nick.c_str() : ServerInstance->Config->HideKillsServer.c_str(),
- parameters[1].c_str());
-
- this->lastuuid.clear();
- }
+ ServerInstance->SNO->WriteToSnoMask('K', "Remote kill by %s: %s (%s)", user->nick.c_str(), target->GetFullRealHost().c_str(), parameters[1].c_str());
+ }
- // send the quit out
- ServerInstance->Users->QuitUser(u, killreason);
+ if (IS_LOCAL(user) || IS_LOCAL(target))
+ ServerInstance->Logs->Log("KILL", LOG_DEFAULT, "%s KILL: %s :%s!%s!%s (%s)",
+ IS_LOCAL(user) && IS_LOCAL(target) ? "LOCAL" : "REMOTE",
+ target->nick.c_str(),
+ ServerInstance->Config->ServerName.c_str(), user->dhost.c_str(), user->nick.c_str(),
+ parameters[1].c_str());
+
+ if (IS_LOCAL(target))
+ {
+ target->Write(":%s KILL %s :%s",
+ ServerInstance->Config->HideKillsServer.empty() ? user->GetFullHost().c_str() : ServerInstance->Config->HideKillsServer.c_str(),
+ target->nick.c_str(),
+ parameters[1].c_str());
+
+ this->lastuuid.clear();
}
else
{
- user->WriteNumeric(Numerics::NoSuchNick(parameters[0]));
- return CMD_FAILURE;
+ this->lastuuid = target->uuid;
}
+ // send the quit out
+ ServerInstance->Users->QuitUser(target, killreason);
+
return CMD_SUCCESS;
}
{
}
- Version GetVersion()
+ Version GetVersion() CXX11_OVERRIDE
{
return Version("PRIVMSG, NOTICE", VF_CORE|VF_VENDOR);
}
{
}
- Version GetVersion()
+ Version GetVersion() CXX11_OVERRIDE
{
return Version("Provides the stub commands CONNECT, LINKS, SERVER and SQUIT", VF_VENDOR|VF_CORE);
}
bool opt_time;
ChanModeReference secretmode;
ChanModeReference privatemode;
+ UserModeReference hidechansmode;
UserModeReference invisiblemode;
- Membership* get_first_visible_channel(User* u)
+ Membership* get_first_visible_channel(User* source, User* u)
{
for (User::ChanList::iterator i = u->chans.begin(); i != u->chans.end(); ++i)
{
Membership* memb = *i;
- if (!memb->chan->IsModeSet(secretmode))
+
+ /* XXX move the +I check into m_hidechans */
+ bool has_modes = memb->chan->IsModeSet(secretmode) || memb->chan->IsModeSet(privatemode) || u->IsModeSet(hidechansmode);
+ if (source == u || !has_modes || memb->chan->HasUser(source))
return memb;
}
return NULL;
: Command(parent, "WHO", 1)
, secretmode(parent, "secret")
, privatemode(parent, "private")
+ , hidechansmode(parent, "hidechans")
, invisiblemode(parent, "invisible")
{
syntax = "<server>|<nickname>|<channel>|<realname>|<host>|0 [ohurmMiaplf]";
void CommandWho::SendWhoLine(User* user, const std::vector<std::string>& parms, Membership* memb, User* u, std::vector<Numeric::Numeric>& whoresults)
{
if (!memb)
- memb = get_first_visible_channel(u);
+ memb = get_first_visible_channel(user, u);
Numeric::Numeric wholine(RPL_WHOREPLY);
wholine.push(memb ? memb->chan->name : "*").push(u->ident);
{
}
- void OnGarbageCollect()
+ void OnGarbageCollect() CXX11_OVERRIDE
{
// Remove all entries older than MaxKeep
cmd.manager.Maintain();
}
- void OnUserQuit(User* user, const std::string& message, const std::string& oper_message)
+ void OnUserQuit(User* user, const std::string& message, const std::string& oper_message) CXX11_OVERRIDE
{
cmd.manager.Add(user);
}
cmd.manager.UpdateConfig(NewGroupSize, NewMaxGroups, NewMaxKeep);
}
- Version GetVersion()
+ Version GetVersion() CXX11_OVERRIDE
{
return Version("WHOWAS", VF_VENDOR);
}
// Add the default entry. This is inserted last so if the user specifies a
// wildcard record in the config it will take precedence over this entry.
- chanlimits.push_back(ListLimit("*", 64));
+ chanlimits.push_back(ListLimit("*", DEFAULT_LIST_SIZE));
// Most of the time our settings are unchanged, so we can avoid iterating the chanlist
if (oldlimits == chanlimits)
return it->limit;
}
}
- return 64;
+ return DEFAULT_LIST_SIZE;
}
unsigned int ListModeBase::GetLimitInternal(const std::string& channame, ChanData* cd)
return GetLimitInternal(channel->name, cd);
}
+unsigned int ListModeBase::GetLowerLimit()
+{
+ unsigned int limit = UINT_MAX;
+ for (limitlist::iterator iter = chanlimits.begin(); iter != chanlimits.end(); ++iter)
+ {
+ if (iter->limit < limit)
+ limit = iter->limit;
+ }
+ return limit == UINT_MAX ? DEFAULT_LIST_SIZE : limit;
+}
+
ModeAction ListModeBase::OnModeChange(User* source, User*, Channel* channel, std::string ¶meter, bool adding)
{
// Try and grab the list
stdalgo::delete_all(cmds);
}
- Version GetVersion()
+ Version GetVersion() CXX11_OVERRIDE
{
return Version("All commands", VF_VENDOR|VF_CORE);
}
}
}
- CullResult cull()
+ CullResult cull() CXX11_OVERRIDE
{
this->SQLProvider::cull();
ServerInstance->Modules->DelService(*this);
}
}
- void submit(SQLQuery *req, const std::string& q)
+ void submit(SQLQuery *req, const std::string& q) CXX11_OVERRIDE
{
if (qinprog.q.empty())
{
}
}
- void submit(SQLQuery *req, const std::string& q, const ParamL& p)
+ void submit(SQLQuery *req, const std::string& q, const ParamL& p) CXX11_OVERRIDE
{
std::string res;
unsigned int param = 0;
submit(req, res);
}
- void submit(SQLQuery *req, const std::string& q, const ParamM& p)
+ void submit(SQLQuery *req, const std::string& q, const ParamM& p) CXX11_OVERRIDE
{
std::string res;
for(std::string::size_type i = 0; i < q.length(); i++)
class ModuleAbbreviation : public Module
{
public:
- void Prioritize()
+ void Prioritize() CXX11_OVERRIDE
{
ServerInstance->Modules->SetPriority(this, I_OnPreCommand, PRIORITY_FIRST);
}
ServerInstance->Parser.CallHandler(command, pars, user);
}
- void Prioritize()
+ void Prioritize() CXX11_OVERRIDE
{
// Prioritise after spanningtree so that channel aliases show the alias before the effects.
Module* linkmod = ServerInstance->Modules->Find("m_spanningtree.so");
bcrypt.rounds = conf->getInt("rounds", 10, 1);
}
- Version GetVersion()
+ Version GetVersion() CXX11_OVERRIDE
{
return Version("Implements bcrypt hashing", VF_VENDOR);
}
realhost("cgiirc_realhost", ExtensionItem::EXT_USER, Creator)
, realip("cgiirc_realip", ExtensionItem::EXT_USER, Creator)
{
+ allow_empty_last_param = false;
works_before_reg = true;
this->syntax = "password client hostname ip";
}
if(user->registered == REG_ALL)
return CMD_FAILURE;
+ irc::sockets::sockaddrs ipaddr;
+ if (!irc::sockets::aptosa(parameters[3], 0, ipaddr))
+ {
+ IS_LOCAL(user)->CommandFloodPenalty += 5000;
+ ServerInstance->SNO->WriteGlobalSno('a', "Connecting user %s tried to use WEBIRC but gave an invalid IP address.", user->GetFullRealHost().c_str());
+ return CMD_FAILURE;
+ }
+
for(CGIHostlist::iterator iter = Hosts.begin(); iter != Hosts.end(); iter++)
{
if(InspIRCd::Match(user->host, iter->hostmask, ascii_case_insensitive_map) || InspIRCd::MatchCIDR(user->GetIPString(), iter->hostmask, ascii_case_insensitive_map))
}
}
+ IS_LOCAL(user)->CommandFloodPenalty += 5000;
ServerInstance->SNO->WriteGlobalSno('w', "Connecting user %s tried to use WEBIRC, but didn't match any configured webirc blocks.", user->GetFullRealHost().c_str());
return CMD_FAILURE;
}
{
}
- void init()
+ void init() CXX11_OVERRIDE
{
// Only attached while we are working; don't react to events otherwise
ServerInstance->Modules->DetachAll(this);
if (adding)
{
+ // assume this is more correct
+ if (user->registered != REG_ALL && user->host != user->dhost)
+ return MODEACTION_DENY;
+
std::string* cloak = ext.get(user);
if (!cloak)
std::string prefix;
std::string suffix;
std::string key;
- const char* xtab[4];
dynamic_reference<HashProvider> Hash;
ModuleCloaking() : cu(this), mode(MODE_OPAQUE), ck(this), Hash(this, "hash/md5")
return MOD_RES_PASSTHRU;
}
- void Prioritize()
+ void Prioritize() CXX11_OVERRIDE
{
/* Needs to be after m_banexception etc. */
ServerInstance->Modules->SetPriority(this, I_OnCheckBan, PRIORITY_LAST);
{
std::string chost;
+ irc::sockets::sockaddrs hostip;
+ bool host_is_ip = irc::sockets::aptosa(host, ip.port(), hostip) && hostip == ip;
+
switch (mode)
{
case MODE_HALF_CLOAK:
{
- if (ipstr != host)
+ if (!host_is_ip)
chost = prefix + SegmentCloak(host, 1, 6) + LastTwoDomainParts(host);
if (chost.empty() || chost.length() > 50)
chost = SegmentIP(ip, false);
defdelay = tag->getInt("delay", 0, 0, 60);
}
- void Prioritize()
+ void Prioritize() CXX11_OVERRIDE
{
ServerInstance->Modules->SetPriority(this, I_OnPostConnect, PRIORITY_LAST);
}
class ModuleModesOnConnect : public Module
{
public:
- void Prioritize()
+ void Prioritize() CXX11_OVERRIDE
{
// for things like +x on connect, important, otherwise we have to resort to config order (bleh) -- w00t
ServerInstance->Modules->SetPriority(this, I_OnUserConnect, PRIORITY_FIRST);
}
}
- void OnGarbageCollect()
+ void OnGarbageCollect() CXX11_OVERRIDE
{
ServerInstance->Logs->Log(MODNAME, LOG_DEBUG, "Clearing map.");
connects.clear();
if (!ans_record)
return;
+ // All replies should be in 127.0.0.0/8
+ if (ans_record->rdata.compare(0, 4, "127.") != 0)
+ {
+ ServerInstance->SNO->WriteGlobalSno('a', "DNSBL: %s returned address outside of acceptable subnet 127.0.0.0/8: %s", ConfEntry->domain.c_str(), ans_record->rdata.c_str());
+ ConfEntry->stats_misses++;
+ return;
+ }
+
int i = countExt.get(them);
if (i)
countExt.set(them, i - 1);
if (ServerInstance->XLines->AddLine(zl,NULL))
{
std::string timestr = InspIRCd::TimeString(zl->expiry);
- ServerInstance->SNO->WriteGlobalSno('x',"Z:line added due to DNSBL match on *@%s to expire on %s: %s",
+ ServerInstance->SNO->WriteGlobalSno('x',"Z:line added due to DNSBL match on %s to expire on %s: %s",
them->GetIPString().c_str(), timestr.c_str(), reason.c_str());
ServerInstance->XLines->ApplyLines();
}
ExemptTargetSet exemptednicks;
ModuleFilter();
- CullResult cull();
+ CullResult cull() CXX11_OVERRIDE;
ModResult OnUserPreMessage(User* user, void* dest, int target_type, std::string& text, char status, CUList& exempt_list, MessageType msgtype) CXX11_OVERRIDE;
FilterResult* FilterMatch(User* user, const std::string &text, int flags);
bool DeleteFilter(const std::string &freeform);
</cross-domain-policy>";
}
- CullResult cull()
+ CullResult cull() CXX11_OVERRIDE
{
for (insp::intrusive_list<FlashPDSocket>::const_iterator i = sockets.begin(); i != sockets.end(); ++i)
{
FOREACH_MOD(OnBuildNeighborList, (user, include_chans, exceptions));
+ // Users shouldn't see themselves quitting when host cycling
+ exceptions.erase(user);
for (std::map<User*,bool>::iterator i = exceptions.begin(); i != exceptions.end(); ++i)
{
LocalUser* u = IS_LOCAL(i->first);
WriteData("\r\n");
}
- void OnDataReady()
+ void OnDataReady() CXX11_OVERRIDE
{
if (InternalState == HTTP_SERVE_RECV_POSTDATA)
{
return MOD_RES_ALLOW;
}
- void OnUnloadModule(Module* mod)
+ void OnUnloadModule(Module* mod) CXX11_OVERRIDE
{
for (insp::intrusive_list<HttpServerSocket>::const_iterator i = sockets.begin(); i != sockets.end(); )
{
for (ConfigDataHash::iterator x = ServerInstance->Config->config_data.begin(); x != ServerInstance->Config->config_data.end(); ++x)
{
data << "<" << x->first << " ";
- ConfigTag* tag = x->second;
- for (std::vector<KeyVal>::const_iterator j = tag->getItems().begin(); j != tag->getItems().end(); j++)
+ const ConfigItems& items = x->second->getItems();
+ for (ConfigItems::const_iterator j = items.begin(); j != items.end(); j++)
{
data << Sanitize(j->first) << "="" << Sanitize(j->second) << "" ";
}
data << "<server>";
data << "<servername>" << b->servername << "</servername>";
data << "<parentname>" << b->parentname << "</parentname>";
- data << "<gecos>" << b->gecos << "</gecos>";
+ data << "<gecos>" << Sanitize(b->gecos) << "</gecos>";
data << "<usercount>" << b->usercount << "</usercount>";
// This is currently not implemented, so, commented out.
// data << "<opercount>" << b->opercount << "</opercount>";
last_excepts.clear();
}
- void Prioritize()
+ void Prioritize() CXX11_OVERRIDE
{
ServerInstance->Modules->SetPriority(this, I_OnUserJoin, PRIORITY_LAST);
}
return MOD_RES_DENY;
}
+ std::string what;
+ std::string::size_type pos = user->password.find(':');
+ if (pos != std::string::npos)
+ {
+ what = attribute + "=" + user->password.substr(0, pos);
+
+ // Trim the user: prefix, leaving just 'pass' for later password check
+ user->password = user->password.substr(pos + 1);
+ }
+ else
+ {
+ what = attribute + "=" + (useusername ? user->ident : user->nick);
+ }
+
try
{
- std::string what = attribute + "=" + (useusername ? user->ident : user->nick);
LDAP->BindAsManager(new AdminBindInterface(this, LDAP.GetProvider(), user->uuid, base, what));
}
catch (LDAPException &ex)
} while (--words);
}
- void MD5Init(MD5Context *ctx, unsigned int* ikey = NULL)
+ void MD5Init(MD5Context *ctx)
{
/* These are the defaults for md5 */
- if (!ikey)
- {
- ctx->buf[0] = 0x67452301;
- ctx->buf[1] = 0xefcdab89;
- ctx->buf[2] = 0x98badcfe;
- ctx->buf[3] = 0x10325476;
- }
- else
- {
- ctx->buf[0] = ikey[0];
- ctx->buf[1] = ikey[1];
- ctx->buf[2] = ikey[2];
- ctx->buf[3] = ikey[3];
- }
+ ctx->buf[0] = 0x67452301;
+ ctx->buf[1] = 0xefcdab89;
+ ctx->buf[2] = 0x98badcfe;
+ ctx->buf[3] = 0x10325476;
ctx->bytes[0] = 0;
ctx->bytes[1] = 0;
}
- void MyMD5(void *dest, void *orig, int len, unsigned int* ikey)
+ void MyMD5(void *dest, void *orig, int len)
{
MD5Context context;
- MD5Init(&context, ikey);
+ MD5Init(&context);
MD5Update(&context, (const unsigned char*)orig, len);
MD5Final((unsigned char*)dest, &context);
}
std::string GenerateRaw(const std::string& data)
{
char res[16];
- MyMD5(res, (void*)data.data(), data.length(), NULL);
+ MyMD5(res, (void*)data.data(), data.length());
return std::string(res, 16);
}
return MOD_RES_PASSTHRU;
}
- void Prioritize()
+ void Prioritize() CXX11_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);
return Version("Implements the ability to have server-side MLOCK enforcement.", VF_VENDOR);
}
- ModResult OnRawMode(User* source, Channel* channel, ModeHandler* mh, const std::string& parameter, bool adding)
+ ModResult OnRawMode(User* source, Channel* channel, ModeHandler* mh, const std::string& parameter, bool adding) CXX11_OVERRIDE
{
if (!channel)
return MOD_RES_PASSTHRU;
return Version("Provides the ability to manipulate modes via long names.",VF_VENDOR);
}
- void Prioritize()
+ void Prioritize() CXX11_OVERRIDE
{
ServerInstance->Modules->SetPriority(this, I_OnPreMode, PRIORITY_FIRST);
}
return MOD_RES_PASSTHRU;
}
- void Prioritize()
+ void Prioritize() CXX11_OVERRIDE
{
Module *nflood = ServerInstance->Modules->Find("m_nickflood.so");
ServerInstance->Modules->SetPriority(this, I_OnUserPreNick, PRIORITY_BEFORE, nflood);
return MOD_RES_DENY;
}
- void Prioritize()
+ void Prioritize() CXX11_OVERRIDE
{
ServerInstance->Modules->SetPriority(this, I_OnUserPreJoin, PRIORITY_FIRST);
}
return MOD_RES_PASSTHRU;
}
- void OnPostJoin(Membership* memb)
+ void OnPostJoin(Membership* memb) CXX11_OVERRIDE
{
if ((!IS_LOCAL(memb->user)) || (!memb->user->IsOper()) || (memb->user->IsModeSet(hideopermode)))
return;
return Version("Gives opers cmode +y which provides a staff prefix.", VF_VENDOR);
}
- void Prioritize()
+ void Prioritize() CXX11_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("m_opermodes.so");
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))
+ 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;
mode->OnModeChange(ServerInstance->FakeClient, ServerInstance->FakeClient, c, par, true);
}
}
+
+ // We always apply the permchannels mode to permanent channels.
+ par.clear();
+ p.OnModeChange(ServerInstance->FakeClient, ServerInstance->FakeClient, c, par, true);
}
}
}
dirty = false;
}
- void Prioritize()
+ void Prioritize() CXX11_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()
}
}
- void Prioritize()
+ void Prioritize() CXX11_OVERRIDE
{
Module* mod = ServerInstance->Modules->Find("m_cgiirc.so");
ServerInstance->Modules->SetPriority(this, I_OnUserRegister, PRIORITY_AFTER, mod);
return MOD_RES_PASSTHRU;
}
- void Prioritize()
+ void Prioritize() CXX11_OVERRIDE
{
Module *override = ServerInstance->Modules->Find("m_override.so");
ServerInstance->Modules->SetPriority(this, I_OnPreMode, PRIORITY_BEFORE, override);
SaslResult result;
bool state_announced;
+ /* taken from m_services_account */
+ static bool ReadCGIIRCExt(const char* extname, User* user, std::string& out)
+ {
+ ExtensionItem* wiext = ServerInstance->Extensions.GetItem(extname);
+ if (!wiext)
+ return false;
+
+ if (wiext->creator->ModuleSourceFile != "m_cgiirc.so")
+ return false;
+
+ StringExtItem* stringext = static_cast<StringExtItem*>(wiext);
+ std::string* addr = stringext->get(user);
+ if (!addr)
+ return false;
+
+ out = *addr;
+ return true;
+ }
+
+
+ void SendHostIP()
+ {
+ std::string host, ip;
+
+ if (!ReadCGIIRCExt("cgiirc_webirc_hostname", user, host))
+ {
+ host = user->host;
+ }
+ if (!ReadCGIIRCExt("cgiirc_webirc_ip", user, ip))
+ {
+ ip = user->GetIPString();
+ }
+ else
+ {
+ /* IP addresses starting with a : on irc are a Bad Thing (tm) */
+ if (ip.c_str()[0] == ':')
+ ip.insert(ip.begin(),1,'0');
+ }
+
+ parameterlist params;
+ params.push_back(sasl_target);
+ params.push_back("SASL");
+ params.push_back(user->uuid);
+ params.push_back("*");
+ params.push_back("H");
+ params.push_back(host);
+ params.push_back(ip);
+
+ SendSASL(params);
+ }
+
public:
SaslAuthenticator(User* user_, const std::string& method)
: user(user_), state(SASL_INIT), state_announced(false)
{
+ SendHostIP();
+
parameterlist params;
params.push_back(user->uuid);
params.push_back("*");
params.push_back(method);
LocalUser* localuser = IS_LOCAL(user);
- if (method == "EXTERNAL" && localuser)
+ if (localuser)
{
std::string fp = SSLClientCert::GetFingerprint(&localuser->eh);
: Command(Creator, "AUTHENTICATE", 1), authExt(ext), cap(Cap)
{
works_before_reg = true;
+ allow_empty_last_param = false;
}
CmdResult Handle (const std::vector<std::string>& parameters, User *user)
if (!cap.get(user))
return CMD_FAILURE;
+ if (parameters[0].find(' ') != std::string::npos || parameters[0][0] == ':')
+ return CMD_FAILURE;
+
SaslAuthenticator *sasl = authExt.get(user);
if (!sasl)
authExt.set(user, new SaslAuthenticator(user, parameters[0]));
servertracker.Reset();
}
- ModResult OnUserRegister(LocalUser *user) CXX11_OVERRIDE
+ void OnUserConnect(LocalUser *user) CXX11_OVERRIDE
{
SaslAuthenticator *sasl_ = authExt.get(user);
if (sasl_)
sasl_->Abort();
authExt.unset(user);
}
-
- return MOD_RES_PASSTHRU;
}
void OnDecodeMetaData(Extensible* target, const std::string& extname, const std::string& extdata) CXX11_OVERRIDE
big_endian = (htonl(1337) == 1337);
}
- Version GetVersion()
+ Version GetVersion() CXX11_OVERRIDE
{
return Version("Implements SHA-1 hashing", VF_VENDOR);
}
ServerInstance->XLines->UnregisterFactory(&f);
}
- void Prioritize()
+ void Prioritize() CXX11_OVERRIDE
{
Module* alias = ServerInstance->Modules->Find("m_alias.so");
ServerInstance->Modules->SetPriority(this, I_OnPreCommand, PRIORITY_BEFORE, alias);
void OnUnloadModule(Module* mod) CXX11_OVERRIDE;
ModResult OnAcceptConnection(int newsock, ListenSocket* from, irc::sockets::sockaddrs* client, irc::sockets::sockaddrs* server) CXX11_OVERRIDE;
void OnMode(User* source, User* u, Channel* c, const Modes::ChangeList& modes, ModeParser::ModeProcessFlag processflags, const std::string& output_mode) CXX11_OVERRIDE;
- CullResult cull();
+ CullResult cull() CXX11_OVERRIDE;
~ModuleSpanningTree();
Version GetVersion() CXX11_OVERRIDE;
- void Prioritize();
+ void Prioritize() CXX11_OVERRIDE;
};
void SendMetaData(Channel* chan, const std::string& key, const std::string& data) CXX11_OVERRIDE;
void SendMetaData(const std::string& key, const std::string& data) CXX11_OVERRIDE;
void SendSNONotice(char snomask, const std::string& text) CXX11_OVERRIDE;
- void SendMessage(Channel* target, char status, const std::string& text, MessageType msgtype);
- void SendMessage(User* target, const std::string& text, MessageType msgtype);
- void GetServerList(ServerList& sl);
+ void SendMessage(Channel* target, char status, const std::string& text, MessageType msgtype) CXX11_OVERRIDE;
+ void SendMessage(User* target, const std::string& text, MessageType msgtype) CXX11_OVERRIDE;
+ void GetServerList(ServerList& sl) CXX11_OVERRIDE;
};
void RegisterService() CXX11_OVERRIDE;
virtual CmdResult Handle(User* user, std::vector<std::string>& parameters) = 0;
- virtual RouteDescriptor GetRouting(User* user, const std::vector<std::string>& parameters);
+ virtual RouteDescriptor GetRouting(User* user, const std::vector<std::string>& parameters) CXX11_OVERRIDE;
/**
* Extract the TS from a string.
*/
void OnPong() { pingtimer.OnPong(); }
- CullResult cull();
+ CullResult cull() CXX11_OVERRIDE;
/** Destructor, deletes ServerUser unless IsRoot()
*/
*/
void CleanNegotiationInfo();
- CullResult cull();
+ CullResult cull() CXX11_OVERRIDE;
/** Destructor
*/
~TreeSocket();
* to server docs on the inspircd.org site, the other side
* will then send back its own server string.
*/
- void OnConnected();
+ void OnConnected() CXX11_OVERRIDE;
/** Handle socket error event
*/
/** This function is called when we receive data from a remote
* server.
*/
- void OnDataReady();
+ void OnDataReady() CXX11_OVERRIDE;
/** Send one or more complete lines down the socket
*/
/** Handle socket timeout from connect()
*/
- void OnTimeout();
+ void OnTimeout() CXX11_OVERRIDE;
/** Handle server quit on close
*/
- void Close();
+ void Close() CXX11_OVERRIDE;
/** Fixes messages coming from old servers so the new command handlers understand them
*/
/** Prepare for class destruction
*/
- CullResult cull();
+ CullResult cull() CXX11_OVERRIDE;
/** Destroy class and free listeners etc
*/
}
}
- void OnChannelDelete(Channel* chan)
+ void OnChannelDelete(Channel* chan) CXX11_OVERRIDE
{
// Remove all timed bans affecting the channel from internal bookkeeping
TimedBanList.erase(std::remove_if(TimedBanList.begin(), TimedBanList.end(), ChannelMatcher(chan)), TimedBanList.end());
tokens["CHANTYPES"] = "#";
tokens["ELIST"] = "MU";
tokens["KICKLEN"] = ConvToStr(ServerInstance->Config->Limits.MaxKick);
- tokens["MAXBANS"] = "64"; // TODO: make this a config setting.
tokens["MAXTARGETS"] = ConvToStr(ServerInstance->Config->MaxTargets);
tokens["MODES"] = ConvToStr(ServerInstance->Config->Limits.MaxModes);
tokens["NETWORK"] = ServerInstance->Config->Network;
int SocketEngine::RecvFrom(EventHandler* fd, void *buf, size_t len, int flags, sockaddr *from, socklen_t *fromlen)
{
int nbRecvd = recvfrom(fd->GetFd(), (char*)buf, len, flags, from, fromlen);
- if (nbRecvd > 0)
- stats.Update(nbRecvd, 0);
+ stats.UpdateReadCounters(nbRecvd);
return nbRecvd;
}
int SocketEngine::Send(EventHandler* fd, const void *buf, size_t len, int flags)
{
int nbSent = send(fd->GetFd(), (const char*)buf, len, flags);
- if (nbSent > 0)
- stats.Update(0, nbSent);
+ stats.UpdateWriteCounters(nbSent);
return nbSent;
}
int SocketEngine::Recv(EventHandler* fd, void *buf, size_t len, int flags)
{
int nbRecvd = recv(fd->GetFd(), (char*)buf, len, flags);
- if (nbRecvd > 0)
- stats.Update(nbRecvd, 0);
+ stats.UpdateReadCounters(nbRecvd);
return nbRecvd;
}
int SocketEngine::SendTo(EventHandler* fd, const void *buf, size_t len, int flags, const sockaddr *to, socklen_t tolen)
{
int nbSent = sendto(fd->GetFd(), (const char*)buf, len, flags, to, tolen);
- if (nbSent > 0)
- stats.Update(0, nbSent);
+ stats.UpdateWriteCounters(nbSent);
return nbSent;
}
int SocketEngine::WriteV(EventHandler* fd, const IOVector* iovec, int count)
{
int sent = writev(fd->GetFd(), iovec, count);
- if (sent > 0)
- stats.Update(0, sent);
+ stats.UpdateWriteCounters(sent);
return sent;
}
return shutdown(fd, how);
}
-void SocketEngine::Statistics::Update(size_t len_in, size_t len_out)
+void SocketEngine::Statistics::UpdateReadCounters(int len_in)
{
CheckFlush();
- indata += len_in;
- outdata += len_out;
+
+ ReadEvents++;
+ if (len_in > 0)
+ indata += len_in;
+ else if (len_in < 0)
+ ErrorEvents++;
+}
+
+void SocketEngine::Statistics::UpdateWriteCounters(int len_out)
+{
+ CheckFlush();
+
+ WriteEvents++;
+ if (len_out > 0)
+ outdata += len_out;
+ else if (len_out < 0)
+ ErrorEvents++;
}
void SocketEngine::Statistics::CheckFlush() const
#include "exitcodes.h"
#include <sys/epoll.h>
-#include <ulimit.h>
+#include <sys/resource.h>
#include <iostream>
/** A specialisation of the SocketEngine class, designed to use linux 2.6 epoll().
void SocketEngine::Init()
{
- // MAX_DESCRIPTORS is mainly used for display purposes, no problem if ulimit() fails and returns a negative number
- MAX_DESCRIPTORS = ulimit(4, 0);
+ // MAX_DESCRIPTORS is mainly used for display purposes, no problem if getrlimit() fails
+ struct rlimit limit;
+ if (!getrlimit(RLIMIT_NOFILE, &limit))
+ {
+ MAX_DESCRIPTORS = limit.rlim_cur;
+ }
// 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.
eh->SetEventMask(mask);
if (ev.events & EPOLLIN)
{
- stats.ReadEvents++;
eh->OnEventHandlerRead();
if (eh != GetRef(fd))
// whoa! we got deleted, better not give out the write event
}
if (ev.events & EPOLLOUT)
{
- stats.WriteEvents++;
eh->OnEventHandlerWrite();
}
}
}
if (filter == EVFILT_WRITE)
{
- stats.WriteEvents++;
/* 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.
}
else if (filter == EVFILT_READ)
{
- stats.ReadEvents++;
eh->SetEventMask(eh->GetEventMask() & ~FD_READ_WILL_BLOCK);
eh->OnEventHandlerRead();
}
port_associate(EngineHandle, PORT_SOURCE_FD, fd, mask_to_events(mask), eh);
if (portev_events & POLLRDNORM)
{
- stats.ReadEvents++;
eh->OnEventHandlerRead();
if (eh != GetRef(fd))
continue;
}
if (portev_events & POLLWRNORM)
{
- stats.WriteEvents++;
eh->OnEventHandlerWrite();
}
}
if (has_read)
{
- stats.ReadEvents++;
ev->SetEventMask(ev->GetEventMask() & ~FD_READ_WILL_BLOCK);
ev->OnEventHandlerRead();
if (ev != GetRef(i))
if (has_write)
{
- stats.WriteEvents++;
int newmask = (ev->GetEventMask() & ~(FD_WRITE_WILL_BLOCK | FD_WANT_SINGLE_WRITE));
SocketEngine::OnSetEvent(ev, ev->GetEventMask(), newmask);
ev->SetEventMask(newmask);
void User::InvalidateCache()
{
/* Invalidate cache */
+ cachedip.clear();
cached_fullhost.clear();
cached_hostip.clear();
cached_makehost.clear();
bool User::SetClientIP(const char* sip, bool recheck_eline)
{
- cachedip.clear();
- cached_hostip.clear();
+ this->InvalidateCache();
return irc::sockets::aptosa(sip, 0, client_sa);
}
close($tmp);
$status ||= system "$certtool --generate-privkey $sec_param --outfile key.pem";
$status ||= system "$certtool --generate-self-signed --load-privkey key.pem --outfile cert.pem --template $tmp";
+ $status ||= system "$certtool --generate-request --load-privkey key.pem --outfile csr.pem --template $tmp";
$status ||= system "$certtool --generate-dh-params $sec_param --outfile dhparams.pem";
$dercert = `$certtool --certificate-info --infile cert.pem --outder` unless $status;
} elsif ($tool eq 'openssl') {
$unit
$common_name
$email
+.
+$organization
__OPENSSL_END__
close($tmp);
$status ||= system "cat $tmp | openssl req -x509 -nodes -newkey rsa:2048 -keyout key.pem -out cert.pem -days $days 2>/dev/null";
+ $status ||= system "cat $tmp | openssl req -new -nodes -key key.pem -out csr.pem 2>/dev/null";
$status ||= system 'openssl dhparam -out dhparams.pem 2048';
$dercert = `openssl x509 -in cert.pem -outform DER` unless $status;
}
my $hash = Digest::SHA->new(256);
$hash->add($dercert);
say '';
- say 'Add this TLSA record to your domain for DANE support:';
+ say 'If you are using the self-signed certificate then add this TLSA record to your domain for DANE support:';
say "_6697._tcp." . $common_name . " TLSA 3 0 1 " . $hash->hexdigest;
}
install(DIRECTORY ${LOG_DIR} DESTINATION .)
if(EXISTS "${CMAKE_ROOT}/Modules/CPack.cmake")
+ set(CMAKE_INSTALL_SYSTEM_RUNTIME_DESTINATION ".") # place runtime libraries next to InspIRCd binary
include(InstallRequiredSystemLibraries)
set(CPACK_PACKAGE_NAME "InspIRCd IRC Daemon")
projects / user / henk / code / inspircd.git / commitdiff