Main Page | Namespace List | Class Hierarchy | Alphabetical List | Class List | Directories | File List | Namespace Members | Class Members | File Members

home » brain » inspircd-cvs » inspircd » include

inspircd.h

Go to the documentation of this file.

/*       +------------------------------------+
 *       | Inspire Internet Relay Chat Daemon |
 *       +------------------------------------+
 *
 *  InspIRCd: (C) 2002-2008 InspIRCd Development Team
 * See: http://www.inspircd.org/wiki/index.php/Credits
 *
 * This program is free but copyrighted software; see
 *          the file COPYING for details.
 *
 * ---------------------------------------------------
 */

#ifndef __INSPIRCD_H__
#define __INSPIRCD_H__

#ifndef WIN32
#define DllExport
#define CoreExport
#define printf_c printf
#else
#include "inspircd_win32wrapper.h"
#undef DELETE
#undef ERROR
#endif

#ifdef __GNUC__
#define CUSTOM_PRINTF(STRING, FIRST) __attribute__((format(printf, STRING, FIRST)))
#else
#define CUSTOM_PRINTF(STRING, FIRST)
#endif

// Required system headers.
#include <ctime>
#include <cstdarg>
#include <algorithm>
#include <cmath>
#include <cstring>
#include <climits>

#include <sstream>
#include <string>
#include <vector>
#include <deque>
#include <map>
#include <bitset>


typedef std::vector<std::pair<std::string, std::string> > FailedPortList;

typedef std::deque< std::string > file_cache;

typedef std::pair< std::string, std::string > KeyVal;

typedef std::vector< KeyVal > KeyValList;

typedef std::multimap< std::string, KeyValList > ConfigDataHash;

#include "inspircd_config.h"
#include "numerics.h"
#include "uid.h"
#include "users.h"
#include "channels.h"
#include "timer.h"
#include "hashcomp.h"
#include "typedefs.h"
#include "logger.h"
#include "usermanager.h"
#include "socket.h"
#include "ctables.h"
#include "command_parse.h"
#include "mode.h"
#include "socketengine.h"
#include "snomasks.h"
#include "cull_list.h"
#include "filelogger.h"
#include "caller.h"
#include "modules.h"
#include "configreader.h"
#include "inspstring.h"
#include "protocol.h"

#ifndef PATH_MAX
#warning Potentially broken system, PATH_MAX undefined
#define PATH_MAX 4096
#endif

#define MAXPARAMETERS 127

#define ERROR -1

#define ETIREDHAMSTERS EAGAIN

template<typename T> inline std::string ConvNumeric(const T &in)
{
        if (in == 0) return "0";
        char res[MAXBUF];
        char* out = res;
        T quotient = in;
        while (quotient) {
                *out = "0123456789"[ std::abs( (long)quotient % 10 ) ];
                ++out;
                quotient /= 10;
        }
        if (in < 0)
                *out++ = '-';
        *out = 0;
        std::reverse(res,out);
        return res;
}

inline std::string ConvToStr(const int in)
{
        return ConvNumeric(in);
}

inline std::string ConvToStr(const long in)
{
        return ConvNumeric(in);
}

inline std::string ConvToStr(const char* in)
{
        return in;
}

inline std::string ConvToStr(const bool in)
{
        return (in ? "1" : "0");
}

inline std::string ConvToStr(char in)
{
        return std::string(in,1);
}

template <class T> inline std::string ConvToStr(const T &in)
{
        std::stringstream tmp;
        if (!(tmp << in)) return std::string();
        return tmp.str();
}

template<typename T> inline long ConvToInt(const T &in)
{
        std::stringstream tmp;
        if (!(tmp << in)) return 0;
        return atoi(tmp.str().c_str());
}

template<typename T, typename V, typename R> inline char* itoa(const T &in, V *res, R base)
{
        if (base < 2 || base > 16) { *res = 0; return res; }
        char* out = res;
        int quotient = in;
        while (quotient) {
                *out = "0123456789abcdef"[ std::abs( quotient % base ) ];
                ++out;
                quotient /= base;
        }
        if ( in < 0 && base == 10) *out++ = '-';
        std::reverse( res, out );
        *out = 0;
        return res;
}

class serverstats : public classbase
{
  public:
        unsigned long statsAccept;
        unsigned long statsRefused;
        unsigned long statsUnknown;
        unsigned long statsCollisions;
        unsigned long statsDns;
        unsigned long statsDnsGood;
        unsigned long statsDnsBad;
        unsigned long statsConnects;
        double statsSent;
        double statsRecv;
        timeval LastCPU;
        timeval LastSampled;
        serverstats()
                : statsAccept(0), statsRefused(0), statsUnknown(0), statsCollisions(0), statsDns(0),
                statsDnsGood(0), statsDnsBad(0), statsConnects(0), statsSent(0.0), statsRecv(0.0)
        {
        }
};

class InspIRCd;

DEFINE_HANDLER1(ProcessUserHandler, void, User*);
DEFINE_HANDLER2(IsNickHandler, bool, const char*, size_t);
DEFINE_HANDLER1(IsIdentHandler, bool, const char*);
DEFINE_HANDLER1(FindDescriptorHandler, User*, int);
DEFINE_HANDLER1(FloodQuitUserHandler, void, User*);
DEFINE_HANDLER2(IsChannelHandler, bool, const char*, size_t);
DEFINE_HANDLER1(IsSIDHandler, bool, const std::string&);
DEFINE_HANDLER1(RehashHandler, void, const std::string&);

/* Forward declaration - required */
class XLineManager;
class BanCacheManager;

class CoreExport ConfigReaderThread : public Thread
{
        InspIRCd* ServerInstance;
        bool do_bail;
        std::string TheUserUID;
 public:
        ConfigReaderThread(InspIRCd* Instance, bool bail, const std::string &useruid) : Thread(), ServerInstance(Instance), do_bail(bail), TheUserUID(useruid)
        {
        }

        virtual ~ConfigReaderThread()
        {
        }

        void Run();
};

class CoreExport InspIRCd : public classbase
{
 private:
        char current_uid[UUID_LENGTH];

        void SetSignals();

        bool DaemonSeed();

        void DoSocketTimeouts(time_t TIME);

        void IncrementUID(int pos);

        void DoBackgroundUserStuff();

        bool AllModulesReportReady(User* user);

        char LogFileName[MAXBUF];

        time_t TIME;

        time_t OLDTIME;

        char ReadBuffer[65535];

        irc::sockets::insp_sockaddr client, server;

        socklen_t length;

#ifdef WIN32
        IPC* WindowsIPC;
#endif

 public:

        CullList GlobalCulls;

        /**** Functors ****/

        ProcessUserHandler HandleProcessUser;
        IsNickHandler HandleIsNick;
        IsIdentHandler HandleIsIdent;
        FindDescriptorHandler HandleFindDescriptor;
        FloodQuitUserHandler HandleFloodQuitUser;
        IsChannelHandler HandleIsChannel;
        IsSIDHandler HandleIsSID;
        RehashHandler HandleRehash;

        std::map<BufferedSocket*,BufferedSocket*> SocketCull;

        User *FakeClient;

        std::string GetUID();

        User *FindUUID(const std::string &);

        User *FindUUID(const char *);

        void BuildISupport();

        servernamelist servernames;

        time_t startup_time;

        char ConfigFileName[MAXBUF];

        ModeParser* Modes;

        CommandParser* Parser;

        SocketEngine* SE;

        ThreadEngine* Threads;

        MutexFactory* Mutexes;

        ConfigReaderThread* ConfigThread;

        LogManager *Logs;

        ModuleManager* Modules;

        BanCacheManager *BanCache;

        serverstats* stats;

        ServerConfig* Config;

        SnomaskManager* SNO;

        DNS* Res;

        TimerManager* Timers;

        XLineManager* XLines;

        UserManager *Users;

        chan_hash* chanlist;

        int s_signal;

        ProtocolInterface* PI;

        time_t Time();

        caller1<void, User*> ProcessUser;

        int BindPorts(bool bail, int &found_ports, FailedPortList &failed_ports);

        bool BindSocket(int sockfd, int port, const char* addr, bool dolisten = true);

        void AddServerName(const std::string &servername);

        const char* FindServerNamePtr(const std::string &servername);

        bool FindServerName(const std::string &servername);

        std::string GetServerDescription(const char* servername);

        User* FindNick(const std::string &nick);

        User* FindNick(const char* nick);

        User* FindNickOnly(const char* nick);

        User* FindNickOnly(const std::string &nick);

        Channel* FindChan(const std::string &chan);

        Channel* FindChan(const char* chan);

        void CheckDie();

        void CheckRoot();

        bool OpenLog(char** argv, int argc);

        caller2<bool, const char*, size_t> IsChannel;

        caller1<bool, const std::string&> IsSID;

        caller1<void, const std::string&> Rehash;

        void SignalHandler(int signal);

        static void SetSignal(int signal);

        void Exit(int status);

        static void QuickExit(int status);

        long ChannelCount();

        void SendError(const std::string &s);

        caller2<bool, const char*, size_t> IsNick;

        caller1<bool, const char*> IsIdent;

        caller1<User*, int> FindDescriptor;

        bool AddResolver(Resolver* r, bool cached);

        void AddCommand(Command *f);

        void SendMode(const std::vector<std::string>& parameters, User *user);

        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);

        CmdResult CallCommandHandler(const std::string &commandname, const std::vector<std::string>& parameters, User* user);

        bool IsValidModuleCommand(const std::string &commandname, int pcnt, User* user);

        bool IsValidMask(const std::string &mask);

        void RehashServer();

        Channel* GetChannelIndex(long index);

        void DumpText(User* User, const std::string &LinePrefix, std::stringstream &TextStream);

        bool NickMatchesEveryone(const std::string &nick, User* user);

        bool IPMatchesEveryone(const std::string &ip, User* user);

        bool HostMatchesEveryone(const std::string &mask, User* user);

        long Duration(const std::string &str);

        int PassCompare(Extensible* ex, const std::string &data, const std::string &input, const std::string &hashtype);

        bool ULine(const char* server);

        bool SilentULine(const char* server);

        std::string GetRevision();

        std::string GetVersionString();

        void WritePID(const std::string &filename);

        InspIRCd(int argc, char** argv);

        void SendWhoisLine(User* user, User* dest, int numeric, const std::string &text);

        void SendWhoisLine(User* user, User* dest, int numeric, const char* format, ...) CUSTOM_PRINTF(5, 6);

        caller1<void, User*> FloodQuitUser;

        void Restart(const std::string &reason);

        void Cleanup();

        void RehashUsersAndChans();

        void ResetMaxBans();

        std::string TimeString(time_t curtime);

        int Run();

        void BufferedSocketCull();

        void AddExtBanChar(char c);

        char* GetReadBuffer()
        {
                return this->ReadBuffer;
        }
};

ENTRYPOINT;

#endif