inspircd.h

/*
 * InspIRCd -- Internet Relay Chat Daemon
 *
 *   Copyright (C) 2019 Matt Schatz <[email protected]>
 *   Copyright (C) 2018 linuxdaemon <[email protected]>
 *   Copyright (C) 2013 Daniel Vassdal <[email protected]>
 *   Copyright (C) 2012-2016, 2018 Attila Molnar <[email protected]>
 *   Copyright (C) 2012-2014, 2017-2019 Sadie Powell <[email protected]ces>
 *   Copyright (C) 2012, 2019 Robby <[email protected]>
 *   Copyright (C) 2012 ChrisTX <[email protected]>
 *   Copyright (C) 2009-2010 Daniel De Graaf <[email protected]>
 *   Copyright (C) 2008 Thomas Stagner <[email protected]>
 *   Copyright (C) 2007-2009 Dennis Friis <[email protected]>
 *   Copyright (C) 2007-2008 Robin Burchell <[email protected]>
 *   Copyright (C) 2007 Oliver Lupton <[email protected]>
 *   Copyright (C) 2006-2008, 2010 Craig Edwards <[email protected]>
 *
 * This file is part of InspIRCd.  InspIRCd is free software: you can
 * redistribute it and/or modify it under the terms of the GNU General Public
 * License as published by the Free Software Foundation, version 2.
 *
 * This program is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
 * FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more
 * details.
 *
 * 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
 
// If the system has a pre-C11 stdint header this must be defined in
// order to use the numeric limit macros.
#define __STDC_LIMIT_MACROS
 
#include <cfloat>
#include <climits>
#include <cmath>
#include <csignal>
#include <cstdarg>
#include <cstdio>
#include <cstring>
#include <ctime>
#include <stdint.h>
 
#include <algorithm>
#include <bitset>
#include <deque>
#include <list>
#include <map>
#include <set>
#include <sstream>
#include <string>
#include <vector>
 
#include "intrusive_list.h"
#include "flat_map.h"
#include "compat.h"
#include "aligned_storage.h"
#include "typedefs.h"
#include "convto.h"
#include "stdalgo.h"
 
CoreExport extern InspIRCd* ServerInstance;
 
template <typename T>
struct fakederef
{
        T* operator->()
        {
                return static_cast<T*>(this);
        }
};
 
#include "config.h"
#include "dynref.h"
#include "consolecolors.h"
#include "cull_list.h"
#include "serialize.h"
#include "extensible.h"
#include "fileutils.h"
#include "ctables.h"
#include "numerics.h"
#include "numeric.h"
#include "uid.h"
#include "server.h"
#include "users.h"
#include "channels.h"
#include "timer.h"
#include "hashcomp.h"
#include "logger.h"
#include "usermanager.h"
#include "socket.h"
#include "command_parse.h"
#include "mode.h"
#include "socketengine.h"
#include "snomasks.h"
#include "filelogger.h"
#include "message.h"
#include "modules.h"
#include "clientprotocol.h"
#include "threadengine.h"
#include "configreader.h"
#include "inspstring.h"
#include "protocol.h"
#include "bancache.h"
#include "isupportmanager.h"
 
class serverstats
{
  public:
        unsigned long Accept;
        unsigned long Refused;
        unsigned long Unknown;
        unsigned long Collisions;
        unsigned long Dns;
        unsigned long DnsGood;
        unsigned long DnsBad;
        unsigned long Connects;
        unsigned long Sent;
        unsigned long Recv;
#ifdef _WIN32
 
        FILETIME LastCPU;
        LARGE_INTEGER LastSampled;
        LARGE_INTEGER QPFrequency;
#else
 
        timeval LastCPU;
        timespec LastSampled;
#endif
 
        serverstats()
                : Accept(0), Refused(0), Unknown(0), Collisions(0), Dns(0),
                DnsGood(0), DnsBad(0), Connects(0), Sent(0), Recv(0)
        {
        }
};
 
class CoreExport InspIRCd
{
 private:
        struct timespec TIME;
 
        char ReadBuffer[65535];
 
        ClientProtocol::RFCEvents rfcevents;
 
 public:
 
        UIDGenerator UIDGen;
 
        CullList GlobalCulls;
        ActionList AtomicActions;
 
        FakeUser* FakeClient;
 
        User* FindUUID(const std::string &uid);
 
        time_t startup_time;
 
        std::string ConfigFileName;
 
        ExtensionManager Extensions;
 
        ModeParser Modes;
 
        CommandParser Parser;
 
        ThreadEngine Threads;
 
        ConfigReaderThread* ConfigThread;
 
        LogManager Logs;
 
        ModuleManager Modules;
 
        BanCacheManager BanCache;
 
        serverstats stats;
 
        ServerConfig* Config;
 
        SnomaskManager SNO;
 
        TimerManager Timers;
 
        XLineManager* XLines;
 
        UserManager Users;
 
        chan_hash chanlist;
 
        std::vector<ListenSocket*> ports;
 
        static sig_atomic_t s_signal;
 
        ProtocolInterface* PI;
 
        ProtocolInterface DefaultProtocolInterface;
 
        ISupportManager ISupport;
 
        inline time_t Time() { return TIME.tv_sec; }
        inline long Time_ns() { return TIME.tv_nsec; }
        void UpdateTime();
 
        std::string GenRandomStr(unsigned int length, bool printable = true);
        unsigned long GenRandomInt(unsigned long max);
 
        TR1NS::function<void(char*, size_t)> GenRandom;
 
        static void DefaultGenRandom(char* output, size_t max);
 
        bool BindPort(ConfigTag* tag, const irc::sockets::sockaddrs& sa, std::vector<ListenSocket*>& old_ports);
 
        size_t BindPorts(FailedPortList &failed_ports);
 
        User* FindNick(const std::string &nick);
 
        User* FindNickOnly(const std::string &nick);
 
        Channel* FindChan(const std::string &chan);
 
        chan_hash& GetChans() { return chanlist; }
 
        TR1NS::function<bool(const std::string&)> IsChannel;
 
        static bool DefaultIsChannel(const std::string& channel);
 
        static bool IsHost(const std::string& host);
 
        static bool IsSID(const std::string& sid);
 
        void SignalHandler(int signal);
 
        static void SetSignal(int signal);
 
        void Exit(int status);
 
        static std::string Format(const char* formatString, ...) CUSTOM_PRINTF(1, 2);
        static std::string Format(va_list& vaList, const char* formatString) CUSTOM_PRINTF(2, 0);
 
        TR1NS::function<bool(const std::string&)> IsNick;
 
        static bool DefaultIsNick(const std::string& nick);
 
        TR1NS::function<bool(const std::string&)> IsIdent;
 
        static bool DefaultIsIdent(const std::string& ident);
 
        static bool Match(const std::string& str, const std::string& mask, unsigned const char* map = NULL);
        static bool Match(const char* str, const char* mask, unsigned const char* map = NULL);
 
        static bool MatchCIDR(const std::string& str, const std::string& mask, unsigned const char* map = NULL);
        static bool MatchCIDR(const char* str, const char* mask, unsigned const char* map = NULL);
 
        static bool MatchMask(const std::string& masks, const std::string& hostname, const std::string& ipaddr);
 
        static bool IsValidMask(const std::string& mask);
 
        static void StripColor(std::string &sentence);
 
        static void ProcessColors(file_cache& input);
 
        void Rehash(const std::string& uuid = "");
 
        static unsigned long Duration(const std::string& str);
 
        static bool Duration(const std::string& str, unsigned long& duration);
 
        static bool IsValidDuration(const std::string& str);
 
        static std::string DurationString(time_t duration);
 
        bool PassCompare(Extensible* ex, const std::string& data, const std::string& input, const std::string& hashtype);
 
        std::string GetVersionString(bool getFullVersion = false);
 
        void WritePID(const std::string& filename, bool exitonfail = true);
 
        InspIRCd(int argc, char** argv);
 
        void Cleanup();
 
        static std::string TimeString(time_t curtime, const char* format = NULL, bool utc = false);
 
        static bool TimingSafeCompare(const std::string& one, const std::string& two);
 
        void Run();
 
        char* GetReadBuffer()
        {
                return this->ReadBuffer;
        }
 
        ClientProtocol::RFCEvents& GetRFCEvents() { return rfcevents; }
};
 
ENTRYPOINT;
 
inline void stdalgo::culldeleter::operator()(classbase* item)
{
        if (item)
                ServerInstance->GlobalCulls.AddItem(item);
}
 
inline void Channel::Write(ClientProtocol::EventProvider& protoevprov, ClientProtocol::Message& msg, char status, const CUList& except_list)
{
        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);
}
 
#include "numericbuilder.h"
#include "clientprotocolmsg.h"
#include "clientprotocolevent.h"