X-Git-Url: https://git.netwichtig.de/gitweb/?a=blobdiff_plain;f=src%2Fmodules%2Fm_spanningtree%2Futils.h;h=e83e1c8390a4ad0f1d08c417cb7f12435e9faa76;hb=dccf47d0a091be2395257d401f8ed55eaa258bc7;hp=291d7010ddb9a6e7ad628592733751e3485fabe8;hpb=a772b4dbf594bc0a851f5d3d6594111639453a4e;p=user%2Fhenk%2Fcode%2Finspircd.git diff --git a/src/modules/m_spanningtree/utils.h b/src/modules/m_spanningtree/utils.h index 291d7010d..e83e1c839 100644 --- a/src/modules/m_spanningtree/utils.h +++ b/src/modules/m_spanningtree/utils.h @@ -1,71 +1,86 @@ -/* +------------------------------------+ - * | Inspire Internet Relay Chat Daemon | - * +------------------------------------+ +/* + * InspIRCd -- Internet Relay Chat Daemon * - * InspIRCd: (C) 2002-2007 InspIRCd Development Team - * See: http://www.inspircd.org/wiki/index.php/Credits + * Copyright (C) 2009 Daniel De Graaf + * Copyright (C) 2008 Robin Burchell + * Copyright (C) 2007 Dennis Friis + * Copyright (C) 2007 Craig Edwards * - * This program is free but copyrighted software; see - * the file COPYING for details. + * This file is part of InspIRCd. InspIRCd is free software: you can + * redistribute it and/or modify it under the terms of the GNU General Public + * License as published by the Free Software Foundation, version 2. * - * --------------------------------------------------- + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more + * details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . */ -#ifndef __ST__UTIL__ -#define __ST__UTIL__ -#include "configreader.h" -#include "users.h" -#include "channels.h" -#include "modules.h" +#pragma once + #include "inspircd.h" +#include "cachetimer.h" -/* Foward declarations */ class TreeServer; class TreeSocket; class Link; +class Autoconnect; class ModuleSpanningTree; +class SpanningTreeUtilities; +class CmdBuilder; -/* This hash_map holds the hash equivalent of the server - * tree, used for rapid linear lookups. - */ -typedef nspace::hash_map, irc::StrHashComp> server_hash; - -typedef std::map TreeServerList; +extern SpanningTreeUtilities* Utils; -/** A group of modules that implement InspSocketHook - * that we can use to hook our server to server connections. +/** Associative container type, mapping server names/ids to TreeServers */ -typedef std::map hookmodules; +typedef TR1NS::unordered_map server_hash; /** Contains helper functions and variables for this module, * and keeps them out of the global namespace */ -class SpanningTreeUtilities +class SpanningTreeUtilities : public classbase { - private: - /** Creator server - */ - InspIRCd* ServerInstance; + CacheRefreshTimer RefreshTimer; + public: + typedef std::set TreeSocketSet; + typedef std::map > TimeoutList; + /** Creator module */ ModuleSpanningTree* Creator; + /** Flatten links and /MAP for non-opers */ bool FlatLinks; + + /** True if we're going to hide netsplits as *.net *.split for non-opers + */ + bool HideSplits; + /** Hide U-Lined servers in /MAP and /LINKS */ bool HideULines; /** Announce TS changes to channels on merge */ bool AnnounceTSChange; - /** Synchronize timestamps between servers + + /** Allow modules marked as VF_OPTCOMMON to be mismatched when linking + */ + bool AllowOptCommon; + + /** Make snomasks +CQ quiet during bursts and splits */ - bool EnableTimeSync; - /** Socket bindings for listening sockets + bool quiet_bursts; + + /* Number of seconds that a server can go without ping + * before opers are warned of high latency. */ - std::vector Bindings; + unsigned int PingWarnTime; /** This variable represents the root of the server tree */ TreeServer *TreeRoot; @@ -75,83 +90,92 @@ class SpanningTreeUtilities /** Hash of currently connected servers by name */ server_hash serverlist; + /** Hash of currently known server ids + */ + server_hash sidlist; + /** List of all outgoing sockets and their timeouts + */ + TimeoutList timeoutlist; /** Holds the data from the 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. + std::vector > LinkBlocks; + /** Holds the data from the tags in the conf */ - int lines_to_apply; + std::vector > AutoconnectBlocks; - /** 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. + /** Ping frequency of server to server links */ - bool MasterTime; + unsigned int PingFreq; - /** List of module pointers which can provide I/O abstraction + /** Initialise utility class */ - hookmodules hooks; + SpanningTreeUtilities(ModuleSpanningTree* Creator); - /** List of module names which can provide I/O abstraction + /** Prepare for class destruction */ - std::vector hooknames; + CullResult cull() CXX11_OVERRIDE; - /** Initialise utility class - */ - SpanningTreeUtilities(InspIRCd* Instance, ModuleSpanningTree* Creator); /** Destroy class and free listeners etc */ ~SpanningTreeUtilities(); + + void RouteCommand(TreeServer* origin, CommandBase* cmd, const CommandBase::Params& 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, 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); + void DoOneToOne(const CmdBuilder& params, Server* target); + /** 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); + void DoOneToAllButSender(const CmdBuilder& params, TreeServer* omit); + /** 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); + void DoOneToMany(const CmdBuilder& params); + /** Read the spanningtree module's tags from the config file */ - void ReadConfiguration(bool rebind); - /** Add a server to the server list for GetListOfServersForChannel + void ReadConfiguration(); + + /** Handle nick collision */ - void AddThisServer(TreeServer* server, TreeServerList &list); + bool DoCollision(User* u, TreeServer* server, time_t remotets, const std::string& remoteident, const std::string& remoteip, const std::string& remoteuid, const char* collidecmd); + /** 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 + void GetListOfServersForChannel(Channel* c, TreeSocketSet& list, char status, const CUList& exempt_list); + + /** Find a server by name or SID */ TreeServer* FindServer(const std::string &ServerName); - /** Find a route to a server by name + + /** Find server by SID + */ + TreeServer* FindServerID(const std::string &id); + + /** Find a server based on a target string. + * @param target Target string where a command should be routed to. May be a server name, a sid, a nickname or a uuid. */ - TreeServer* BestRouteTo(const std::string &ServerName); + TreeServer* FindRouteTarget(const std::string& target); + /** 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(); + + /** 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); }; -#endif +inline void SpanningTreeUtilities::DoOneToMany(const CmdBuilder& params) +{ + DoOneToAllButSender(params, NULL); +}