X-Git-Url: https://git.netwichtig.de/gitweb/?a=blobdiff_plain;f=src%2Fmodules%2Fm_spanningtree%2Ftreesocket.h;h=6206448c159472014d20f920caedcacdcd288e33;hb=961109ae4fde97144fdedeef25607a5b8b3ec2c2;hp=6d79711cc3bbe394822027cf363b269eb7d597a3;hpb=1031f333332cf1b09db4fd632f141143ee637c34;p=user%2Fhenk%2Fcode%2Finspircd.git diff --git a/src/modules/m_spanningtree/treesocket.h b/src/modules/m_spanningtree/treesocket.h index 6d79711cc..6206448c1 100644 --- a/src/modules/m_spanningtree/treesocket.h +++ b/src/modules/m_spanningtree/treesocket.h @@ -73,7 +73,7 @@ struct CapabData std::string ourchallenge; /* Challenge sent for challenge/response */ std::string theirchallenge; /* Challenge recv for challenge/response */ int capab_phase; /* Have sent CAPAB already */ - bool auth_fingerprint; /* Did we auth using SSL fingerprint */ + bool auth_fingerprint; /* Did we auth using SSL certificate fingerprint */ bool auth_challenge; /* Did we auth using challenge/response */ // Data saved from incoming SERVER command, for later use when our credentials have been accepted by the other party @@ -89,19 +89,73 @@ struct CapabData */ class TreeSocket : public BufferedSocket { + struct BurstState; + std::string linkID; /* Description for this link */ ServerState LinkState; /* Link state */ CapabData* capab; /* Link setup data (held until burst is sent) */ TreeServer* MyRoot; /* The server we are talking to */ - time_t NextPing; /* Time when we are due to ping this server */ - bool LastPingWasGood; /* Responded to last ping we sent? */ - int proto_version; /* Remote protocol version */ - bool ConnectionFailureShown; /* Set to true if a connection failure message was shown */ + unsigned int proto_version; /* Remote protocol version */ + + /** True if we've sent our burst. + * This only changes the behavior of message translation for 1202 protocol servers and it can be + * removed once 1202 support is dropped. + */ + bool burstsent; /** Checks if the given servername and sid are both free */ bool CheckDuplicate(const std::string& servername, const std::string& sid); + /** Send all ListModeBase modes set on the channel + */ + void SendListModes(Channel* chan); + + /** Send all known information about a channel */ + void SyncChannel(Channel* chan, BurstState& bs); + + /** Send all users and their oper state, away state and metadata */ + void SendUsers(BurstState& bs); + + /** Send all additional info about the given server to this server */ + void SendServerInfo(TreeServer* from); + + /** Find the User source of a command given a prefix and a command string. + * This connection must be fully up when calling this function. + * @param prefix Prefix string to find the source User object for. Can be a sid, a uuid or a server name. + * @param command The command whose source to find. This is required because certain commands (like mode + * changes and kills) must be processed even if their claimed source doesn't exist. If the given command is + * such a command and the source does not exist, the function returns a valid FakeUser that can be used to + * to process the command with. + * @return The command source to use when processing the command or NULL if the source wasn't found. + * Note that the direction of the returned source is not verified. + */ + User* FindSource(const std::string& prefix, const std::string& command); + + /** Finish the authentication phase of this connection. + * Change the state of the connection to CONNECTED, create a TreeServer object for the server on the + * other end of the connection using the details provided in the parameters, and finally send a burst. + * @param remotename Name of the remote server + * @param remotesid SID of the remote server + * @param remotedesc Description of the remote server + * @param hidden True if the remote server is hidden according to the configuration + */ + void FinishAuth(const std::string& remotename, const std::string& remotesid, const std::string& remotedesc, bool hidden); + + /** Authenticate the remote server. + * Validate the parameters and find the link block that matches the remote server. In case of an error, + * an appropriate snotice is generated, an ERROR message is sent and the connection is closed. + * Failing to find a matching link block counts as an error. + * @param params Parameters they sent in the SERVER command + * @return Link block for the remote server, or NULL if an error occurred + */ + Link* AuthRemote(const CommandBase::Params& params); + + /** Write a line on this socket with a new line character appended, skipping all translation for old protocols + * @param line Line to write without a new line character at the end + */ + void WriteLineNoCompat(const std::string& line); + public: const time_t age; @@ -120,7 +174,7 @@ class TreeSocket : public BufferedSocket /** Get link state */ - ServerState GetLinkState(); + ServerState GetLinkState() const { return LinkState; } /** Get challenge set in our CAPAB for challenge/response */ @@ -146,7 +200,7 @@ class TreeSocket : public BufferedSocket */ void CleanNegotiationInfo(); - CullResult cull(); + CullResult cull() CXX11_OVERRIDE; /** Destructor */ ~TreeSocket(); @@ -162,7 +216,7 @@ class TreeSocket : public BufferedSocket * 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 */ @@ -184,6 +238,11 @@ class TreeSocket : public BufferedSocket */ std::string MyModules(int filter); + /** Returns mode list as a string, filtered by type. + * @param type The type of modes to return. + */ + std::string BuildModeList(ModeType type); + /** Send my capabilities to the remote side */ void SendCapabilities(int phase); @@ -192,21 +251,7 @@ class TreeSocket : public BufferedSocket void ListDifference(const std::string &one, const std::string &two, char sep, std::string& mleft, std::string& mright); - bool Capab(const parameterlist ¶ms); - - /** This function forces this server to quit, removing this server - * and any users on it (and servers and users below that, etc etc). - * It's very slow and pretty clunky, but luckily unless your network - * is having a REAL bad hair day, this function shouldnt be called - * too many times a month ;-) - */ - void SquitServer(std::string &from, TreeServer* Current, int& num_lost_servers, int& num_lost_users); - - /** This is a wrapper function for SquitServer above, which - * does some validation first and passes on the SQUIT to all - * other remaining servers. - */ - void Squit(TreeServer* Current, const std::string &reason); + bool Capab(const CommandBase::Params& params); /** Send one or more FJOINs for a channel of users. * If the length of a single line is more than 480-NICKMAX @@ -214,15 +259,12 @@ class TreeSocket : public BufferedSocket */ void SendFJoins(Channel* c); - /** Send G, Q, Z and E lines */ + /** Send G-, Q-, Z- and E-lines */ void SendXLines(); /** Send all known information about a channel */ void SyncChannel(Channel* chan); - /** send all users and their oper state/modes */ - void SendUsers(); - /** This function is called when we want to send a netburst to a local * server. There is a set order we must do this, because for example * users require their servers to exist, and channels require their @@ -233,45 +275,45 @@ class TreeSocket : public BufferedSocket /** 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 */ void WriteLine(const std::string& line); /** Handle ERROR command */ - void Error(parameterlist ¶ms); + void Error(CommandBase::Params& params); /** (local) -> SERVER */ - bool Outbound_Reply_Server(parameterlist ¶ms); + bool Outbound_Reply_Server(CommandBase::Params& params); /** (local) <- SERVER */ - bool Inbound_Server(parameterlist ¶ms); + bool Inbound_Server(CommandBase::Params& params); /** Handle IRC line split */ - void Split(const std::string &line, std::string& prefix, std::string& command, parameterlist ¶ms); + void Split(const std::string& line, std::string& tags, std::string& prefix, std::string& command, CommandBase::Params& params); /** Process complete line from buffer */ void ProcessLine(std::string &line); - void ProcessConnectedLine(std::string& prefix, std::string& command, parameterlist& params); + /** Process message tags received from a remote server. */ + void ProcessTag(User* source, const std::string& tag, ClientProtocol::TagMap& tags); + + /** Process a message for a fully connected server. */ + void ProcessConnectedLine(std::string& tags, std::string& prefix, std::string& command, CommandBase::Params& params); /** Handle socket timeout from connect() */ - void OnTimeout(); + void OnTimeout() CXX11_OVERRIDE; /** Handle server quit on close */ - void Close(); - - /** Returns true if this server was introduced to the rest of the network - */ - bool Introduced(); + void Close() CXX11_OVERRIDE; /** Fixes messages coming from old servers so the new command handlers understand them */ - bool PreProcessOldProtocolMessage(User*& who, std::string& cmd, std::vector& params); + bool PreProcessOldProtocolMessage(User*& who, std::string& cmd, CommandBase::Params& params); };