X-Git-Url: https://git.netwichtig.de/gitweb/?a=blobdiff_plain;f=src%2Fmodules%2Fm_spanningtree%2Futils.h;h=345b62b099b3c9edb8872eff781d516ed95814cb;hb=67de413cad88194972d55a8ff88464370890c5a9;hp=48146e89e4977a95e8a37b6c8ea8192ff87d414f;hpb=bab14f0dd2345c9d7dcbc47c918563709e1ac094;p=user%2Fhenk%2Fcode%2Finspircd.git diff --git a/src/modules/m_spanningtree/utils.h b/src/modules/m_spanningtree/utils.h index 48146e89e..345b62b09 100644 --- a/src/modules/m_spanningtree/utils.h +++ b/src/modules/m_spanningtree/utils.h @@ -1 +1,187 @@ -/* +------------------------------------+ * | Inspire Internet Relay Chat Daemon | * +------------------------------------+ * * InspIRCd: (C) 2002-2007 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 __ST__UTIL__ #define __ST__UTIL__ #include "configreader.h" #include "users.h" #include "channels.h" #include "modules.h" #include "inspircd.h" /* Foward declarations */ class TreeServer; class TreeSocket; class Link; class ModuleSpanningTree; /* This hash_map holds the hash equivalent of the server * tree, used for rapid linear lookups. */ #ifdef WINDOWS typedef nspace::hash_map > > server_hash; #else typedef nspace::hash_map, irc::StrHashComp> server_hash; #endif typedef std::map TreeServerList; /** A group of modules that implement InspSocketHook * that we can use to hook our server to server connections. */ typedef std::map hookmodules; /** Contains helper functions and variables for this module, * and keeps them out of the global namespace */ class SpanningTreeUtilities { private: /** Creator server */ InspIRCd* ServerInstance; public: /** Creator module */ ModuleSpanningTree* Creator; /** Remote servers that are currently bursting */ server_hash RemoteServersBursting; /** Flatten links and /MAP for non-opers */ bool FlatLinks; /** Hide U-Lined servers in /MAP and /LINKS */ bool HideULines; /** Announce TS changes to channels on merge */ bool AnnounceTSChange; /** Synchronize timestamps between servers */ bool EnableTimeSync; /** Make snomasks +CQ quiet during bursts and splits */ bool quiet_bursts; /** Socket bindings for listening sockets */ std::vector Bindings; /* Number of seconds that a server can go without ping * before opers are warned of high latency. */ int PingWarnTime; /** This variable represents the root of the server tree */ TreeServer *TreeRoot; /** IPs allowed to link to us */ std::vector ValidIPs; /** Hash of currently connected servers by name */ server_hash serverlist; /** Hash of servers currently bursting but not initialized as connected */ std::map burstingserverlist; /** Holds the data from the tags in the conf */ std::vector LinkBlocks; /** Holds a bitmask of queued xline types waiting to be applied. * Will be a mask containing values APPLY_GLINES, APPLY_KLINES, * APPLY_QLINES and APPLY_ZLINES. */ int lines_to_apply; /** If this is true, this server is the master sync server for time * synching - e.g. it is the server with its clock correct. It will * send out the correct time at intervals. */ bool MasterTime; /** List of module pointers which can provide I/O abstraction */ hookmodules hooks; /** List of module names which can provide I/O abstraction */ std::vector hooknames; /** True (default) if we are to use challenge-response HMAC * to authenticate passwords. * * NOTE: This defaults to on, but should be turned off if * you are linking to an older version of inspircd. */ bool ChallengeResponse; /** Initialise utility class */ SpanningTreeUtilities(InspIRCd* Instance, ModuleSpanningTree* Creator); /** Destroy class and free listeners etc */ ~SpanningTreeUtilities(); /** Send a message from this server to one other local or remote */ bool DoOneToOne(const std::string &prefix, const std::string &command, std::deque ¶ms, std::string target); /** Send a message from this server to all but one other, local or remote */ bool DoOneToAllButSender(const std::string &prefix, const std::string &command, std::deque ¶ms, std::string omit); /** Send a message from this server to all but one other, local or remote */ bool DoOneToAllButSender(const char* prefix, const char* command, std::deque ¶ms, std::string omit); /** Send a message from this server to all others */ bool DoOneToMany(const std::string &prefix, const std::string &command, std::deque ¶ms); /** Send a message from this server to all others */ bool DoOneToMany(const char* prefix, const char* command, std::deque ¶ms); /** Send a message from this server to all others, without doing any processing on the command (e.g. send it as-is with colons and all) */ bool DoOneToAllButSenderRaw(const std::string &data, const std::string &omit, const std::string &prefix, const irc::string &command, std::deque ¶ms); /** Read the spanningtree module's tags from the config file */ void ReadConfiguration(bool rebind); /** Add a server to the server list for GetListOfServersForChannel */ void AddThisServer(TreeServer* server, TreeServerList &list); /** Compile a list of servers which contain members of channel c */ void GetListOfServersForChannel(chanrec* c, TreeServerList &list, char status, const CUList &exempt_list); /** Find a server by name */ TreeServer* FindServer(const std::string &ServerName); /** Find a remote bursting server by name */ TreeServer* FindRemoteBurstServer(TreeServer* Server); /** Set a remote server to bursting or not bursting */ void SetRemoteBursting(TreeServer* Server, bool bursting); /** Find a route to a server by name */ TreeServer* BestRouteTo(const std::string &ServerName); /** Find a server by glob mask */ TreeServer* FindServerMask(const std::string &ServerName); /** Returns true if this is a server name we recognise */ bool IsServer(const std::string &ServerName); /** Attempt to connect to the failover link of link x */ void DoFailOver(Link* x); /** Find a link tag from a server name */ Link* FindLink(const std::string& name); /** Refresh the IP cache used for allowing inbound connections */ void RefreshIPCache(); TreeSocket* FindBurstingServer(const std::string &ServerName); void AddBurstingServer(const std::string &ServerName, TreeSocket* s); void DelBurstingServer(TreeSocket* s); }; #endif \ No newline at end of file +/* + * InspIRCd -- Internet Relay Chat Daemon + * + * Copyright (C) 2009 Daniel De Graaf + * Copyright (C) 2008 Robin Burchell + * Copyright (C) 2007 Dennis Friis + * Copyright (C) 2007 Craig Edwards + * + * This file is part of InspIRCd. InspIRCd is free software: you can + * redistribute it and/or modify it under the terms of the GNU General Public + * License as published by the Free Software Foundation, version 2. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more + * details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ + + +#pragma once + +#include "inspircd.h" +#include "cachetimer.h" + +/* Foward declarations */ +class TreeServer; +class TreeSocket; +class Link; +class Autoconnect; +class ModuleSpanningTree; +class SpanningTreeUtilities; + +extern SpanningTreeUtilities* Utils; + +/* This hash_map holds the hash equivalent of the server + * tree, used for rapid linear lookups. + */ +typedef TR1NS::unordered_map server_hash; + +/** Contains helper functions and variables for this module, + * and keeps them out of the global namespace + */ +class SpanningTreeUtilities : public classbase +{ + /** Creates a line in the : [] format + */ + std::string ConstructLine(const std::string& prefix, const std::string& command, const parameterlist& params); + + CacheRefreshTimer RefreshTimer; + + public: + typedef std::set TreeSocketSet; + + /** Creator module + */ + ModuleSpanningTree* Creator; + + /** Flatten links and /MAP for non-opers + */ + bool FlatLinks; + /** Hide U-Lined servers in /MAP and /LINKS + */ + bool HideULines; + /** Announce TS changes to channels on merge + */ + bool AnnounceTSChange; + + /** Allow modules marked as VF_OPTCOMMON to be mismatched when linking + */ + bool AllowOptCommon; + + /** Make snomasks +CQ quiet during bursts and splits + */ + bool quiet_bursts; + + /* Number of seconds that a server can go without ping + * before opers are warned of high latency. + */ + int PingWarnTime; + /** This variable represents the root of the server tree + */ + TreeServer *TreeRoot; + /** IPs allowed to link to us + */ + std::vector ValidIPs; + /** Hash of currently connected servers by name + */ + server_hash serverlist; + /** Hash of currently known server ids + */ + server_hash sidlist; + /** List of all outgoing sockets and their timeouts + */ + std::map > timeoutlist; + /** Holds the data from the tags in the conf + */ + std::vector > LinkBlocks; + /** Holds the data from the tags in the conf + */ + std::vector > AutoconnectBlocks; + + /** True (default) if we are to use challenge-response HMAC + * to authenticate passwords. + * + * NOTE: This defaults to on, but should be turned off if + * you are linking to an older version of inspircd. + */ + bool ChallengeResponse; + + /** Ping frequency of server to server links + */ + int PingFreq; + + /** Initialise utility class + */ + SpanningTreeUtilities(ModuleSpanningTree* Creator); + + /** Prepare for class destruction + */ + CullResult cull(); + + /** Destroy class and free listeners etc + */ + ~SpanningTreeUtilities(); + + void RouteCommand(TreeServer* origin, CommandBase* cmd, const parameterlist& parameters, User* user); + + /** Send a message from this server to one other local or remote + */ + bool DoOneToOne(const std::string& prefix, const std::string& command, const parameterlist& params, const std::string& target); + + /** Send a message from this server to all but one other, local or remote + */ + void DoOneToAllButSender(const std::string& prefix, const std::string& command, const parameterlist& params, TreeServer* omit); + + /** Send a message from this server to all others + */ + void DoOneToMany(const std::string &prefix, const std::string &command, const parameterlist ¶ms); + + /** Read the spanningtree module's tags from the config file + */ + void ReadConfiguration(); + + /** Handle nick collision + */ + int DoCollision(User* u, TreeServer* server, time_t remotets, const std::string& remoteident, const std::string& remoteip, const std::string& remoteuid); + + /** Compile a list of servers which contain members of channel c + */ + void GetListOfServersForChannel(Channel* c, TreeSocketSet& list, char status, const CUList& exempt_list); + + /** Find a server by name + */ + TreeServer* FindServer(const std::string &ServerName); + + /** Find server by SID + */ + TreeServer* FindServerID(const std::string &id); + + /** Find a route to a server by name + */ + TreeServer* BestRouteTo(const std::string &ServerName); + + /** Find a server by glob mask + */ + TreeServer* FindServerMask(const std::string &ServerName); + + /** Find a link tag from a server name + */ + Link* FindLink(const std::string& name); + + /** Refresh the IP cache used for allowing inbound connections + */ + void RefreshIPCache(); + + /** Sends a PRIVMSG or a NOTICE to a channel obeying an exempt list and an optional prefix + */ + void SendChannelMessage(const std::string& prefix, Channel* target, const std::string& text, char status, const CUList& exempt_list, const char* message_type, TreeSocket* omit = NULL); +}; + +inline void SpanningTreeUtilities::DoOneToMany(const std::string& prefix, const std::string& command, const parameterlist& params) +{ + DoOneToAllButSender(prefix, command, params, NULL); +}