X-Git-Url: https://git.netwichtig.de/gitweb/?a=blobdiff_plain;f=include%2Fprotocol.h;h=f69acde0b2b0b6b675844c6cb0121f9485b56413;hb=2ba32afa9a9aca7c82966b66bda16c3c3dbfbba5;hp=6af0ed21c65891e814008bc8c2cbde178f136d36;hpb=1031f333332cf1b09db4fd632f141143ee637c34;p=user%2Fhenk%2Fcode%2Finspircd.git diff --git a/include/protocol.h b/include/protocol.h index 6af0ed21c..f69acde0b 100644 --- a/include/protocol.h +++ b/include/protocol.h @@ -1,8 +1,12 @@ /* * InspIRCd -- Internet Relay Chat Daemon * + * Copyright (C) 2018 Matt Schatz + * Copyright (C) 2013-2014 Attila Molnar + * Copyright (C) 2013, 2018-2019 Sadie Powell + * Copyright (C) 2012, 2019 Robby + * Copyright (C) 2008, 2010 Craig Edwards * Copyright (C) 2008 Robin Burchell - * Copyright (C) 2008 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 @@ -20,21 +24,29 @@ #pragma once -#include "hashcomp.h" - class User; -typedef std::vector parameterlist; +class ProtocolServer +{ + public: + /** Send metadata related to this server to the target server + * @param key The 'key' of the data + * @param data The string representation of the data + */ + virtual void SendMetaData(const std::string& key, const std::string& data) = 0; +}; -class ProtocolInterface +class CoreExport ProtocolInterface { public: + typedef ProtocolServer Server; + class ServerInfo { public: std::string servername; std::string parentname; - std::string gecos; + std::string description; unsigned int usercount; unsigned int opercount; unsigned int latencyms; @@ -44,52 +56,57 @@ class ProtocolInterface virtual ~ProtocolInterface() { } - /** Send an ENCAP message to one or more linked servers. + /** Send an ENCAP message to all servers matching a wildcard string. * See the protocol documentation for the purpose of ENCAP. - * @param encap This is a list of string parameters, the first of which must be a server ID or glob matching servernames. - * The second must be a subcommand. All subsequent parameters are dependant on the subcommand. + * @param targetmask The target server mask (can contain wildcards) + * @param cmd The ENCAP subcommand + * @param params List of string parameters which are dependent on the subcommand + * @param source The source of the message (prefix), must be a local user or NULL which means use local server + * @return Always true if the target mask contains wildcards; otherwise true if the server name was found, + * and the message was sent, false if it was not found. * ENCAP (should) be used instead of creating new protocol messages for easier third party application support. - * @return True if the message was sent out (target exists) */ - virtual bool SendEncapsulatedData(const parameterlist &encap) { return false; } + virtual bool SendEncapsulatedData(const std::string& targetmask, const std::string& cmd, const CommandBase::Params& params, User* source = NULL) { return false; } + + /** Send an ENCAP message to all servers. + * See the protocol documentation for the purpose of ENCAP. + * @param cmd The ENCAP subcommand + * @param params List of string parameters which are dependent on the subcommand + * @param source The source of the message (prefix), must be a local user or a user behind 'omit' + * or NULL which is equivalent to the local server + * @param omit If non-NULL the message won't be sent in the direction of this server, useful for forwarding messages + */ + virtual void BroadcastEncap(const std::string& cmd, const CommandBase::Params& params, User* source = NULL, User* omit = NULL) { } - /** Send metadata for an object to other linked servers. - * @param target The object to send metadata for. + /** Send metadata for a channel to other linked servers. + * @param chan The channel to send metadata for * @param key The 'key' of the data, e.g. "swhois" for swhois desc on a user * @param data The string representation of the data */ - virtual void SendMetaData(Extensible* target, const std::string &key, const std::string &data) { } + virtual void SendMetaData(Channel* chan, const std::string& key, const std::string& data) { } - /** Send a topic change for a channel - * @param channel The channel to change the topic for. - * @param topic The new topic to use for the channel. + /** Send metadata for a user to other linked servers. + * @param user The user to send metadata for + * @param key The 'key' of the data, e.g. "swhois" for swhois desc on a user + * @param data The string representation of the data */ - virtual void SendTopic(Channel* channel, std::string &topic) { } - - /** Send mode changes for an object. - * @param source The source of the mode change - * @param usertarget The target user, NULL if the target is a channel - * @param chantarget The target channel, NULL if the target is a user - * @param modedata The mode changes to send. - * @param translate A list of translation types + virtual void SendMetaData(User* user, const std::string& key, const std::string& data) { } + + /** Send metadata related to the server to other linked servers. + * @param key The 'key' of the data + * @param data The string representation of the data */ - virtual void SendMode(User* source, User* usertarget, Channel* chantarget, const parameterlist& modedata, const std::vector& translate) { } + virtual void SendMetaData(const std::string& key, const std::string& data) { } /** Send a notice to users with a given snomask. * @param snomask The snomask required for the message to be sent. * @param text The message to send. */ - virtual void SendSNONotice(const std::string &snomask, const std::string &text) { } - - /** Send raw data to a remote client. - * @param target The user to push data to. - * @param rawline The raw IRC protocol line to deliver (":me NOTICE you :foo", whatever). - */ - virtual void PushToClient(User* target, const std::string &rawline) { } + virtual void SendSNONotice(char snomask, const std::string& text) { } /** Send a message to a channel. * @param target The channel to message. - * @param status The status character (e.g. %) required to recieve. + * @param status The status character (e.g. %) required to receive. * @param text The message to send. * @param type The message type (MSG_PRIVMSG or MSG_NOTICE) */ @@ -104,10 +121,10 @@ class ProtocolInterface /** Send a notice to a channel. * @param target The channel to message. - * @param status The status character (e.g. %) required to recieve. + * @param status The status character (e.g. %) required to receive. * @param text The message to send. */ - void SendChannelNotice(Channel* target, char status, const std::string &text) + DEPRECATED_METHOD(void SendChannelNotice(Channel* target, char status, const std::string& text)) { SendMessage(target, status, text, MSG_NOTICE); } @@ -116,7 +133,7 @@ class ProtocolInterface * @param target The user to message. * @param text The message to send. */ - void SendUserNotice(User* target, const std::string &text) + DEPRECATED_METHOD(void SendUserNotice(User* target, const std::string& text)) { SendMessage(target, text, MSG_NOTICE); }